# Honeycomb structures in crushing

Honeycomb structures are extremely light and rigid, ideal for structures where keeping the mass low is of highest priority. However how much load can an aluminium panel withstand in crushing?

## Goal

Determine ultimate and mean crushing forces for an aluminium honeycomb panel seen in Figure 1.

Honeycomb dimensions:

- Dominating dimension of a single cell:
`d = 0.0096`

[m] - Distance between two edges of honeycomb core hexagon:
`S = 0.166`

[m] - Yield stress of honeycomb core material:
`sigma = 8.96e7`

[Pa] - Angle of honeycomb core hexagon:
`alfa = (2 * Pi / 3)`

[rad] - Wall thickness of honeycomb core cell:
`t_c = 7.6e-5`

[m] - Number of cells:
`n = 17`

- Elastic modulus of the core material:
`E = 7.03e10`

[Pa] - Poissons's ratio of core material:
`v = 0.33`

## Calculations

Two methods were used to determine the forces at question. First an analytical approach, second a simulation using the finite element method via LS-DYNA. All the code may be found in this github repo along with additional materials.

### Analytical method

The analytical solution was taken from a paper titled Crushing analysis of metal honeycombs by Tomasz Wierzbicki, and implemented into code.

```
def virtual_length(d, alfa):
L = 2 * d * (1 + math.cos(alfa / 2))
return L
def virtual_width(d, alfa, t_c):
W = 2 * (t_c + d *math.sin(alfa / 2))
return W
def virtual_area(L, W):
A = L * W
return A
```

### Formulas for mean and ultimate crushing forces

```
def mean_crushing(A, sigma, t_c, S):
P_mean = 16.54 * A * sigma * (t_c / S) ** (5/3)
return P_mean
def ultimate_crushing(sigma, t_c, d, v, E):
part_1 = (t_c / d) ** 2
part_2 = 3 * (1 - v ** 2)
part_3 = math.pi ** 2 * E * sigma ** 2
combine = ((part_3 / part_2) * part_1) ** (1/3)
P_ultimate = 8 * d * t_c * combine
return P_ultimate
```

### Calculating forces

```
d = 0.0096
S = 0.0166
sigma = 8.96e7
alfa = (2 * math.pi / 3)
t_c = 7.6e-5
n = 17
E = 7.03e10
v = 0.33
L = virtual_length(d, alfa)
W = virtual_width(d, alfa, t_c)
A = virtual_area(L, W)
P_m = mean_crushing(A, sigma, t_c, S)
P_u = ultimate_crushing(sigma, t_c, d, v, E)
print("Mean crushing force for 1 cell = {:.2f}N, and for {} cells = {:.2f}N".
format(P_m, n, (P_m * n)))
print("Ultimate crushing force for 1 cell = {:.2f}N, and for {} cells = {:.2f}N".
format(P_u, n, (P_u * n)))
```

Using the formulas from this paper we got the following answers:

```
Mean crushing force for 1 cell = 90.41N, and for 17 cells = 1536.90N
Ultimate crushing force for 1 cell = 296.13N, and for 17 cells = 5034.15N
```

### Finite element method

The structures model was created in HyperMesh.

It consist of 10200 square shell elements (Figure 2.). A rigid impactor crushes the honeycomb with energy of 50J. Contact established via `AUTOMATIC_GENERAL`

, output via `NOTOUT`

and `NOTFOR`

. Animation from the FEA simulation.

### Results

We plot out the displacement AKA shortening of the honeycomb and the corresponding force.

In Figure 3. We can basically see that the analytical results are similar with the numerical solution. We can also plot the force vs strain relation.

The structure reaches maximum load at the strain of 0.0025 and then collapses (Figure 4.).

## Paper model

As a proof of concept, a paper model of a honeycomb panel with 20 cells was built.

The model was tested under extensive load, carrying it without failure (Figure 5.).

## Summary

The results obtained from the FEA model are consistent with the analytical solution. For more informations head to this github repo.