N2PSandwich User Manual#

Overview#

The N2PSandwichFailure module is developed to evaluate the failure of sandwich structures by calculating stresses or displacements derived from linear Finite Element Analysis (FEA) results. Each analysis is conducted with a specific core type, either Honeycomb or Continuous. If the structure contains elements with different core types, separate analyses must be performed for each.

The module also computes the Reserve Factor (RF), which measures the structural safety margin by assessing the excess strength available beyond the required capacity to support the applied load. The RF is calculated for each N2PElement within the provided list (ElementList) (refer to the Mandatory Inputs section for more details). If results are provided for nodes instead of elements, the list of nodes is derived from all nodes contained within the elements specified in the ElementList.

Sandwich panels can fail in several modes, with each failure mode imposing a limit on their load-bearing capacity. The most critical failure mode depends on the panel’s geometry and the type of load applied. Structural failure may occur due to the strength limitations of the face sheet, core, or adhesive, or it may result from local instabilities like face sheet wrinkling or dimpling. Additionally, overall instability, such as shear crimping, can also lead to failure [Ref-2].

Failure modes covered by this module are the following:

Core shear (CoreShear) failure happens when the core material fractures due to shear stress. Since the core bears nearly all the transverse load while experiencing minimal in-plane load, it is primarily subjected to shear forces. In honeycomb cores, failure can also occur through cell wall buckling, which may not be immediately visible once the load is removed.

Core crushing (CoreCrushing) occurs when the face sheets are pushed toward each other due to bending or through-thickness loads. This type of failure happens when the core lacks adequate compressive strength to withstand the applied forces.

Face sheet wrinkling (Wrinkling) is a local instability that occurs when the face sheet buckles, often alongside core crushing, core tearing, or debonding between the face sheet and core. This failure is more common in structures with thin face sheets and low-density cores. Depending on the loading conditions, material properties, and thickness of the core and face sheets, one or both face sheets may experience wrinkling. Wrinkling may be symmetric and antisymmetric.

Face sheet dimpling, or intracell buckling (Dimpling), is a local instability in which the face sheet buckles inward or outward within the boundaries of a single cell. This failure is more likely to occur when the face sheets are thin and the cell size is large.

Shear crimping (Crimping) is an instability that arises when the buckle wavelength is comparable to the cell size. It is characterized by local core shear failure and the lateral displacement of the face sheets. Although it appears to be a local instability due to the short wavelengths, it is actually a form of general instability. This failure mode is more likely to occur when the core has a low shear modulus.

Facesheet failure (FacesheetFailure) occurs when the face sheets fail by yielding or fracture. The criterion for failure is that the face sheet material exceeds its allowable stress. In case of isotropic facesheet, failure will occur when load exceeds the allowable strength in any direction. When face sheets are composed of composite laminates, several modes of failure are possible due to the complexity of the composite structure. In this module are covered the failures by the following criteria: ‘Tsai-Wu’, ‘Tsai-Hill’ and ‘MaxStress’. (NOTE: For a more detailed analysis regarding failure of composite laminates, N2PFailureComposite module should be used)

General buckling (Buckling) of a sandwich panel is similar to the traditional buckling of plates or columns. In this type of failure, the facesheets and core remain unaffected.

Flatwise tension (and compression) (FlatwiseTension): At the edges of most sandwich panels, one of the face sheets—typically the bag-side sheet in composite construction—transitions upward over the core, forming a ramp. At the beginning and end of this ramp, where the face sheet changes direction, interlaminar stresses (either flatwise tension or compression) develop at the bondline between the face sheet and the core. Flatwise tension stress may result in tensile core failure or debonding between the face sheet and the core, while flatwise compression stress can lead to core crushing.

Panel stiffness criteria (PanelStiffness) is characterized by the maximum allowable structural elastic deformation due to external thermo-mechanical loads.

\[ RF = \frac{Allowable \hspace{0.1cm}deflection}{Maximum \hspace{0.1cm}deflection\hspace{0.1cm} (u_{x}^{i};u_{y}^{i};u_{z}^{i};u_{R}^{i})} \]

Supported Failure Modes and Theories#

For each failure mode, there are different criteria according to different theories which are depicted in the following table (further information in Background Theory),

FailureTheory	FailureMode	Output Request (NASTRAN)
Airbus	Wrinkling	FORCES
Airbus	Dimpling	FORCES
Airbus	Crimping	FORCES
Airbus	CoreCrushing	FORCES
Airbus	CoreShear	FORCES
Airbus	FacesheetFailure	FORCES
Airbus	Buckling	EIGENVECTORS (SOL 105)
Airbus	PanelStiffness	DISPLACEMENTS
HyperSizer	Wrinkling	FORCES
HyperSizer	Dimpling	FORCES
HyperSizer	Crimping	FORCES
HyperSizer	CoreCrushing	FORCES
HyperSizer	CoreShear	FORCES
CMH-17	Wrinkling	FORCES
CMH-17	Dimpling	FORCES
CMH-17	Crimping	FORCES
CMH-17	CoreCrushing	FORCES
CMH-17	CoreShear	FORCES
CMH-17	FacesheetFailure	FORCES
CMH-17	FlatwiseTension	FORCES
NASA	Wrinkling	FORCES
HSB	Wrinkling	FORCES

Example Usage#

1. Importing the module#

import NaxToPy as n2p
from NaxToPy.Modules.N2PSandwich.N2PSandwich import N2PSandwichFailure

2. Load the model#

model = n2p.load_model(r"file path")

3. Define Elements and Load Cases#

element_list = [3026292,3026293,3026294] # List of element
n2pelem = model.get_elements(element_list)

load_case_id = [68195, 68196] # List of ID of Load Cases
n2plc = model.get_load_case(load_case_id)

4. Create and Configure N2PSandwich#

sandwich = N2PSandwichFailure()
sandwich.Model = model
sandwich.FailureMode = 'Wrinkling'
sandwich.FailureTheory = 'HyperSizer'
sandwich.LoadCases = n2ploadcases
sandwich.ElementList = n2pelems
sandwich.CoreType = 'Honeycomb'
sandwich.Parameters['K1'] = 0.8

5. Run Calculations#

sandwich.HDF5.FilePath = r"file output"
sandwich.calculate()

Setup#

Prerequisites#

Python Environment: Ensure you have a compatible Python environment with the following libraries:
- NaxToPy modules
NaxToPy Framework: The module integrates with the NaxToPy library, which must be installed and configured in your environment.

Module Inputs#

The N2PSandwichFailure class provides methods and attributes for defining the model, associating materials, and calculating RF.

Mandatory Inputs#

Property	Type	Description
.Model	`N2PModelContent`	FEM model
.ElementList	`list[N2PElement]`	List of elements
.LoadCases	`list[N2PLoadCase]`	List of load cases
.FailureMode	`str`	Failure mode (must be one of the allowed)
.FailureTheory	`str`	Failure theory (must be one of the allowed for the selected failure mode)
.CoreType	`str`	Core type (`Honeycomb`/`Continuous`)

FEM Requirements#

For this module to function properly, the FEM model must include force fluxes linear and non linear static results in the output requests. This module is available for Nastran.

Supported Type Files#

Solver	File Extension
Nastran	.op2
	.xdb
	.h5

Conditional Inputs#

Property/Method	Type	Description
.CellSize	`float`	Diameter (in mm) of a circle that can be inscribed in a cell of a honeycomb core (requested for `Dimpling` failure mode)
.LaminateCriteria	`str`	Composite laminate failure criteria. Criteria allowed: `TsaiWu`,`TsaiHill`,`MaxStress` (requested for `FacesheetFailure` failure mode)
.RampRadius	`float`	Ramp radius (requested for `FlatwiseTension` failure mode)
.BagAngle	`float`	Local angle between bag side and tool side (in degrees) (requested for `FlatwiseTension` failure mode)
.AllowableDisplacement	`float`	Maximum allowable structural elastic deformation (requested for `PanelStiffness` failure mode)
.Materials[(Material ID,Increment ID)].YoungZ	`float`	Elastic modulus in Z direction for orthotropic materials (requested for `Wrinkling` failure mode)
.Materials[(Material ID,Increment ID)].ShearXZ	`float`	Shear modulus in XZ direction for orthotropic materials (requested for `Wrinkling` and `Crimping` failure modes)
.Materials[(Material ID,Increment ID)].ShearYZ	`float`	Shear modulus in YZ direction for orthotropic materials (requested for `Wrinkling` and `Crimping` failure modes)
.Materials[(Material ID,Increment ID)].Young	`float`	Elastic modulus in Z direction for isotropic materials (requested for `Wrinkling` failure mode)
.Materials[(Material ID,Increment ID)].Shear	`float`	Shear modulus in XZ direction for isotropic materials (requested for `Wrinkling` and `Crimping` failure modes)
.Materials[(Material ID,Increment ID)].Allowables.ShearXZ	`float`	Allowable in XZ-Shear for orthotropic materials (requested for `CoreShear` failure mode)
.Materials[(Material ID,Increment ID)].Allowables.ShearYZ	`float`	Allowable in YZ-Shear for orthotropic materials (requested for `CoreShear` failure mode)
.Materials[(Material ID,Increment ID)].Allowables.ZCompressive	`float`	Allowable for Compression in out-of-plane direction for orthotropic materials (requested for `CoreCrushing` failure mode)
.Materials[(Material ID,Increment ID)].Allowables.XCompressive	`float`	Allowable for Compression in longitudinal direction for orthotropic materials (requested for `FacesheetFailure` failure mode)
.Materials[(Material ID,Increment ID)].Allowables.YCompressive	`float`	Allowable for Compression in transversal direction for orthotropic materials (requested for `FacesheetFailure` failure mode)
.Materials[(Material ID,Increment ID)].Allowables.XTensile	`float`	Allowable for Tension in longitudinal direction for orthotropic materials (requested for `FacesheetFailure` failure mode)
.Materials[(Material ID,Increment ID)].Allowables.YTensile	`float`	Allowable for Tension in transversal direction for orthotropic materials (requested for `FacesheetFailure` failure mode)
.Materials[(Material ID,Increment ID)].Allowables.Yield_compression	`float`	Allowable in tension for isotropic materials (requested for `CoreCrushing` and `FacesheetFailure` failure modes)
.Materials[(Material ID,Increment ID)].Allowables.Yield_shear	`float`	Allowable for Compression for isotropic materials (requested for `CoreShear` and `FacesheetFailure` failure modes)
.Materials[(Material ID,Increment ID)].Allowables.Yield_stress	`float`	Allowable for Tension for isotropic materials (requested for `FacesheetFailure` failure mode)

Optional Inputs#

Property/Method	Type	Description
.HDF5.FilePath	`str`	Path to specify the location of the created HDF5 file. If no path is provided, the file is created in memory
.HDF5.export_to_HDF5	`method`	Convert an HDF5 file that has been created in memory to an HDF5 file on disk
.Parameters	`dict`	Set optional constants for the different failure theory: • Keys for wrinkling NASA: `K1`, `K2` • Keys for wrinkling HyperSizer: `K1`, `K2`, `K3` • Keys for wrinkling CMH-17: `C1`, `C2`, `C3`, `C4`

To export the data into a HDF5 file set the path in the property HDF5:

sandwich.HDF5.FilePath = "output.h5"

Warning

For FEM models with many load cases and elements to analyze, the option to export results to HDF5 must be enabled; otherwise, an exception will be raised due to memory overflow.

Output Description#

The output derived from N2PSandwichFailure is a reserve factor comparing the actual load with the limit load

Material Associaton#

Materials are automatically associated with elements.

Warning

Ensure that Z elastic modulus, and allowables for compression and tension are defined for all materials for which strength failure modes are to be calculated.

Common Errors#

C800: Assigned model input must be a N2PModelContent instance
C801: Assigned elements must be a list of N2PElement instances
C802: Assigned elements must be a list of N2PLoadCase instances
C950: Young modulus in Z direction is not defined for a material
C951: Failure mode is not defined or is not one of the allowed
C952: Failure theory is not defined or is not one of the allowed
C953: Core type must be Isotropic or Honeycomb
C954: Failure mode selected is not supported for the failure theory selected
C955: Cell size is compulsory for calculating dimpling failure mode
C956: ZCompressive allowable is not defined
C957: ShearXZ allowable is not defined
C958: ShearYZ allowable is not defined
C959: Cell size must be assigned to a Honeycomb core
C960: Core must be alligned with x-axis of material system
C961: Ratio core-to-face thickness must be greater than 5.77 (thin face assumption) (see Background Theory))
C962: Core type for dimpling failure mode must be honeycomb
C963: Composite laminate failure criteria is not defined or is not one of the allowed
C964: Global buckling analysis cannot be performed since the cell size is not coarse enough to supress local buckling modes
C965: Load cases must request static results
C966: Forces must be requested for the selected failure mode
C967: Buckling results must be requested for the selected failure mode
C968: Ramp radius must be positive
C969: Local angle between bag side and tool side must be between 0 and 360
C970: Ramp radius must be defined for flatwise tension failure mode
C971: Local angle between bag side and tool sede must be defined for flatwise for flatwise tension failure mode
C972: Weak core assumption is not satisfied (see Background Theory))
C973: Allowable displacement must be positive
C974: Allowable displacement must be defined for panel stiffness criteria

Common Warnings#

W950: Load state in some elements is different from uniaxial compression, but criteria selected applies for uniaxial compression. Check validity of the calculation.
W951: Tension load state used for a compression criteria in some elements. (RF set to 999999)

Methodology#

Background Theory#

The methodology is based on the structural calculations outlined in the different bibliographic references. (see References section)

Consider the following limitations applied to the sandwich analysis method [Ref 4]:

Linear-elastic material behavior assumed.
Geometrical and material non-linearities implying large deformations and rotations are not considered in the present method.
The sandwich configuration shall be consistent with the ‘thin-face’ and the ‘weak-core’ approximation (see equations below), so that it can be assumed that the skin laminates withstand the in-plane loads while the core reacts the transverse shear loads.

\[ Thin \hspace{0.1cm}face \hspace{0.5cm} \frac{h}{t_{f}} \ge 5.77 \]

\[ Weak \hspace{0.1cm}core \hspace{0.5cm} \frac{6E_{f}t_{f}h^{2}}{E_{c}t_{c}^{3}} > 100 \]

Influence of manufacturing defects and fatigue loading is not considered.

Implementation#

The main function of this module is the extraction of results using the get_result_by_LCs_Incr method from N2PModelContent. Results are processed with ndarray. The main calculation process is divided into batches and load cases. If a file path is provided, memory will be released as it iterates through the load cases.

Advanced Features#

No advanced features of the module.

Extra Examples#

If an analysis of different failure modes or different criteria is required, the way to proceed is to make a series of loops that iterate over the different failure modes and theories, obtaining an .h5 file for each iteration.

import NaxToPy as n2p
from NaxToPy.Modules.N2PSandwich.N2PSandwich import N2PSandwichFailure

# Define file paths for the model and results
model_path_ = r"file_model_path.bdf"
results_path = r"file_results_path.op2"

# Define the load case list
lc_list = [1]

# Get elements from the model filtered by a specific property ID
n2pelems = model.get_elements_filtered(properties=28500001)

# Retrieve load cases from the model
n2ploadcases = model.get_load_case(lc_list)

# Define failure modes and failure criteria in lists 
failure_mode_list = ['Wrinkling','Crimping']
failure_criteria_list = ['Airbus','HyperSizer']

# Iterate through each failure mode and failure criteria combination
for failure_mode in failure_mode_list:
    for failure_criteria in failure_criteria_list:
        # Define the output file name
        output_file_h5 = rf"ResultsFolder\Sandwich_{failure_mode}_{failure_criteria}_Loop.h5"

        # Initialize the N2PSandwichFailure object
        sandwich = N2PSandwichFailure()
        sandwich.Model = model  # Assign the model
        sandwich.FailureMode = failure_mode  # Set the failure mode
        sandwich.FailureTheory = failure_criteria  # Set the failure theory
        sandwich.LoadCases = n2ploadcases  # Assign the load cases
        sandwich.ElementList = n2pelems  # Assign the element list
        sandwich.CoreType = 'Continuous'  # Define the core type

        # Set the output file path for the results
        sandwich.HDF5.FilePath = output_file_h5

        # Define material properties
        mat_ID = 28500000
        part_mat = '0'

        # Assign material properties for the specific material ID and part
        sandwich.Materials[(28500000,part_mat)].YoungZ = 5000  # Young's modulus in Z direction
        sandwich.Materials[(28500000,part_mat)].Allowables.ShearXZ = 160  # Shear allowable in XZ plane
        sandwich.Materials[(28500000,part_mat)].Allowables.ShearYZ = 160  # Shear allowable in YZ plane
        sandwich.Materials[(28500000,part_mat)].Allowables.ZCompressive = 160  # Compressive allowable in Z direction

        # Perform the failure calculation
        sandwich.calculate()

References#

[Ref-1]: NASA CR-1999-208994. Facesheet Wrinkling in Sandwich Structures
[Ref-2]: CMH-17. Composite Material Handbook. Volume 6: Structural Sandwich Composites
[Ref-3]: Bruhn. Chapter 12: Sandwich Construction and Design.
[Ref-4]: Airbus Technical Report 0813804. Method for the analysis of composite sandwich.
[Ref-5]: HyperSizer Methods and Equations.
[Ref-6]: HSB 55111-01. Flat sandwich panels under in-plane compression and shear.

This guide serves as a comprehensive reference for using the N2PSandwich Module in structural analysis tasks. For further information, refer to the source code comments and examples provided.