NaxToPy.Modules.static.fasteners.joints package

Submodules

NaxToPy.Modules.static.fasteners.joints.N2PAttachment module

Class that represents a single attachment, which is a series of N2PJoints that join the same region of the model.

class NaxToPy.Modules.static.fasteners.joints.N2PAttachment.N2PAttachment(id)

Bases: object

Class that represents a single attachment, which is a series of N2PJoints that join the same region of the model.

Properties:

ID: int AttachedPlatesIDList: list[int] -> list of the attached N2PPlates’ element’s solver ID. AttachedPlateList: list[N2PPlate] -> list of the attached N2PPlates. JointsList: list[N2PJoint] -> list of the attached N2PJoints. Pitch: float -> minimum distance from an N2PJoint to its neighbours.

get_pitch()

Method used to obtain the attachment’s pitch, that is, the minimum distance from an N2PJoint to its neighbours.

Calling example:

>>> jointPitch = myAttachment.get_pitch()

property AttachedPlateList: list[N2PPlate]

Property that returns the attached_plates_list attribute, that is, the list of all attached N2PPlates.

property AttachedPlatesIDList: list[int]

Property that returns the attached_plates_id_list attribute, that is, the list of the solver IDs of all elements in the attached plates.

property ID: int

Property that returns the id attribute, that is, the N2PAttachment’s ID.

property JointsList: list[N2PJoint]

Property that returns the joints attribute, that is, the list of all N2PJoints.

property Pitch: float

Property that returns the pitch attribute, that is, the attachment’s pitch.

NaxToPy.Modules.static.fasteners.joints.N2PBolt module

Class that represents a single bolt, which is the union of one or several fasteners in the model.

class NaxToPy.Modules.static.fasteners.joints.N2PBolt.N2PBolt(info, input_data_father)

Bases: object

Class that represents a single bolt, which is the union of one or several fasteners in the model.

Properties:

ID: int -> bolt’s internal identificator. OneDimElemsIDList: list[int] -> list of the internal IDs of N2PElements that make up the bolt. Cards: list[N2PCard] -> list of the cards of the N2PElements that make up the bolt. Type: str -> type of bolt. Joint: N2PJoint -> N2PJoint associated to the N2PBolt. ElementList: list[N2PElement] -> list of all N2PElements associated to the N2PBolt. ElementIDList: list[int] -> list of the solver IDs of all elements associated to the bolt. ElementInternalIDList: list[int] -> list of the internal IDs of all elements associated to the bolt. NodeList: list[N2PNode] -> list[tuple[N2PNode]] -> list of all N2PNodes associated to the bolt. PartID: str -> part ID of the bolt (precisely, of the first element that makes up the bolt). AxialForce: dict[int, dict[int, float]] -> dictionary in the form {Load Case ID: Bolt Element ID: F} of the joint’s axial force. ShearForce: dict[int, dict[int, float]] -> dictionary in the form {Load Case ID: Bolt Element ID: F} of the joint’s shear force. MaxAxialForce: dict[int, dict[int, float]] -> dictionary in the form {Load Case ID: F} of the joint’s maximum axial force. LoadAngle: dict[int, dict[int, float]] -> dictionary in the form {Load Case ID: Bolt Element ID: Angle} of the joint’s load angle in degrees.

property AxialForce: dict[int, dict[int, float]]

Property that returns the axial_force attribute, that is, the bolt’s shear force.

property Cards: list[N2PCard]

Property that returns the cards attribute, that is, the list of N2PCards associated to the N2PElements that make up the bolt.

property ElementIDList: list[int]

Property that returns the list of the solver IDs of all N2PElements that compose the bolt.

property ElementInternalIDList: list[int]

Property that returns the list of the internal IDs of all N2PElements that compose the bolt.

property ElementList: list[N2PElement]

Property that returns the element_list attribute, that is, the list of all N2PElements that compose the bolt.

property ID: int

Property that returns the id attribute, that is, the bolt’s internal identificator.

property Joint: N2PJoint

Property that returns the joint attribute, that is, the N2PJoint associated to the bolt.

property LoadAngle: dict[int, dict[int, float]]

Property that returns the load_angle attribute, that is, the bolt’s load angle in degrees.

property MaxAxialForce: dict[int, float]

Property that returns the max_axial_force attribute, that is, the maximum axial force sustained by the bolt.

property NodeList: list[tuple[N2PNode]]

Property that returns the list of all N2PNodes that compose the bolt.

property OneDimElemsIDList: list[int]

Property that returns the one_dim_elems_id_list attribute, that is, the list of the internal IDs of all N2PElements that make up the N2PBolt.

property PartID: str

Property that returns the part ID of the bolt.

property ShearForce: dict[int, dict[int, float]]

Property that returns the shear_force attribute, that is, the bolt’s shear force.

property Type: str

Property that returns the type attribute, that is, what type of elements make up the bolt.

NaxToPy.Modules.static.fasteners.joints.N2PFastenerSystem module

class NaxToPy.Modules.static.fasteners.joints.N2PFastenerSystem.N2PFastenerSystem

Bases: object

Class that represents a specific fastener designation whose values need to be defined in order to obtain RF values for one or more failure modes

Designation

fastener system name (str)

Fastener_pin_single_SH_allow

fastener pin single shear strength allowable [Force] (float)

Fastener_collar_single_SH_allow

fastener collar single shear strength allowable [Force] (float)

Fastener_pin_tensile_allow

fastener pin tensile strength allowable [Force] (float)

Fastener_collar_tensile_allow

fastener collar tensile strength allowable [Force] (float)

D_head

head diameter (float)

D_tail

tail diameter (float)

D_nom

nominal diameter (float)

Configuration

BOLT or RIVET or SOLID (str) (Default: BOLT)

FastenerType

LOCK or BLIND (str) (Default: LOCK)

FastenerInstallation

PERMANENT or REMOVABLE or QUICK RELEASE (str) (Default: PERMANENT)

FastenerHead

PAN or CSK (str) (Default: PAN)

FloatingNut

True or False (bool) (Default: False)

AluminumNut

True or False (bool) (Default: False)

property AluminumNut: bool

Property that returns if the nut is made out of aluminum (True) or not (False).

property Configuration: str

BOLT).

Type:

Property that returns the fastener configuration (RIVET/BOLT/SOLID) (Default

property D_head: float

Property that returns the head diameter of the fastener.

property D_nom: float

Property that returns the nominal diameter of the fastener.

property D_tail: float

Property that returns the tail diameter of the fastener.

property Designation: str

Property that returns the designation of the fastener.

property FastenerHead: float

PAN).

Type:

Property that returns the fastener head geometry (PAN/CSK) (Default

property FastenerInstallation: str

PERMANENT).

Type:

Property that returns the fastener installation (PERMANENT/REMOVABLE/QUICK RELEASE) (Default

property FastenerType: str

LOCK).

Type:

Property that returns the fastener configuration (LOCK/BLIND) (Default

property Fastener_collar_single_SH_allow: float

Property that returns the fastener collar single shear strength allowable.

property Fastener_collar_tensile_allow: float

Property that returns the of the fastener collar tensile strength allowable.

property Fastener_pin_single_SH_allow: float

Property that returns the fastener pin single shear strength allowable.

property Fastener_pin_tensile_allow: float

Property that returns the of the fastener pin tensile strength allowable.

property FloatingNut: bool

Property that returns if the fastener has a floating nut (True) or not (False).

NaxToPy.Modules.static.fasteners.joints.N2PJoint module

Class that represents a single joint, that is, a N2PBolt and a series of N2PPlate objects.

class NaxToPy.Modules.static.fasteners.joints.N2PJoint.N2PJoint(info, input_data_father)

Bases: object

Class that represents a single joint, that is, a N2PBolt and a series of N2PPlate objects.

Properties:

Diameter: float -> joint’s diameter. Bolt: N2PBolt -> associated N2PBolt. ID: int -> joint’s internal identificator. TypeFastener: str -> type of joint. PlateList: list[N2PPlate] -> list of unique N2PPlates associated to the N2PJoint. SwitchPlates: bool -> boolean that shows if the joint’s plates have to be switched. PartID: str -> joint’s part ID. BoltElementList: list[N2PElement] -> list of N2PElements that make up the bolt. BoltElementIDList: list[int] -> list of the IDs of the elements that make up the bolt. BoltElementInternalIDList: list[int] -> list of the internal IDs of the elements that make up the bolt. BoltNodeList: list[N2PNode] -> list of N2PNodes that make up the bolt. PlateElementList: list[list[N2PElement]] -> list of N2PElements that make up the plates. PlateElementIDList: list[list[int]] -> list of the IDs of the elements that make up the plates. PlateElementInternalIDList: list[list[int]] -> list of the internal IDs of the elements that make up the plates. PlateNodeList: list[list[tuple[N2PNode]]] -> list of N2PNodes that make up the plates. PlatePartID: list[str] -> list of the part IDs of the plates. Attachment: N2PAttachment -> joint’s attachment. Pitch: float -> joint’s pitch. FastenerSystem: N2PFastenerSystem -> joint’s Fastener System associated JointAnalysisParameters: N2PJointAnalysisParameters -> joint’s Analysis Parameter associated

get_forces(results: ndarray, loadCaseList: list[N2PLoadCase], compressionEqualsZero: bool = True, pullThroughAsIs: bool = True, shearAsIs: bool = True, typeAnalysis: Literal['PAG', 'ALTAIR'] = 'PAG')

Method that takes an N2PJoint and obtains its 1D forces, as well as the 1D forces associated to each of its N2PPlates. Forces will be obtained as N2PPlate or N2PBolt attributes as dictionaries in the form:

{Load Case ID: [FX, FY, FZ]} or {Load Case ID: F or Load Angle}

depending on what is obtained.

Parameters:

• results – np.ndarray -> results array.

• loadCaseList – list[N2PLoadCase] -> load cases to be studied.

• compressionEqualsZero – bool -> boolean that shows whether or not the pullthrough force is set to zero when

• compressed. (the fastener is)

• pullThroughAsIs – bool -> boolean that shows if the pullthrough is to be set to the value found in the

• not. (files or)

• shearAsIs – bool -> boolean that shows if the shear force is to be set to the value found in the results

• not.

• typeAnalysis – Literal[“PAG”, “ALTAIR”] -> type of analysis that will be done. The difference is whether or

• 0 (not plates pierced by two fasteners have a pullthrough force of)

The following attributes are obtained:

• shear_force: dictionary in the form {Load Case ID: Bolt Element ID: F} which represents the 1D force in

the bolt’s element reference frame. It is a N2PBolt attribute. - axial_force: dictionary in the form {Load Case ID: Bolt Element ID: F} which represents the axial force (pulltrhrough force) in the 1st plate’s material reference frame. It will be positive if the fastener is extended or 0 if it is compressed. It is a N2PBolt attribute. - translational_fastener_forces: dictionary in the form {Load Case ID: [[FX, FY, FZ], [FX, FY, FZ]]} which represents the 1D forces that each the N2PElements associated to the N2PBolt associated to the N2PPlate experience. It is represented in a local reference frame, in which the x-axis is the same as the N2PPlate’s material reference frame’s x-axis, the z-axis is coincident with the axial direction of the bolt and the y-axis is obtained via the cross product. If there is only one fastener attached to the plate, the second list will be filled with zeros. It is a N2PPlate attribute. - bearing_force: dictionary in the form {Load Case ID: [FX, FY, FZ]} which represents the 1D force experienced by the bolt, as calculated by Altair. It takes into account if there are two CFASTs attached to the plate and, if so, sums up their contributions. It is represented in the local reference frame and it is a N2PPlate attribute. - max_axial_force: dictionary in the form {Load Case ID: Bolt Element ID: F} which represents the maximum axial force (bolt tension) of the whole bolt. It is a N2PBolt attribute. - load_angle: dictionary in the form {Load Case ID: Bolt Element ID: Angle} which represents the joint’s load angle in degrees. It is a N2PBolt attribute.

The following steps are followed:

1. Forces are adequately rotated into the plate’s material reference frame.

2. The shear and axial forces are calculated with their formulas, as well as the load angle.

3. If there are two CFASTs attached to a plate, the shear and axial force may be updated.

4. The final force that the plate experiences (called here bearing_force) is obtained by adding the contributions of both CFAST, if they exist, or taking into account if the existing CFAST is the A or B one.

Calling example:

>>> myForces = myJoint.get_forces(loads.Results, loads.LoadCases, False, False, False, "ALTAIR")

get_intersection(model: N2PModelContent = None, domain: set[N2PElement] = None, getDistanceBool: bool = False, errorCounter: int = 0, maxErrorCounter: int = 50)

Method that calculates the intersection point of a N2PPlate, its normal, its A and B CFASTs, their direction and factor and, optionally, the distance from each N2PJoint to the closest free edge.

Parameters:

• model – N2PModelContent

• domain – set[N2PElement] -> domain of elements to be searched

• getDistanceBool – bool -> boolean that shows if the actual distance will be calculated or not

The following steps are followed:

1. The intersection points between every N2PPlate and its N2PJoint is obtained, as well as its normal direction. 2. The A and B bolts are assigned for each plate, as well as the CFAST factor and the bolt direction using the position of the nodes, their normal direction and the content of their cards. 3. All the elements that are attached to the element where the intersection point is are retrieved using the function “get_elements_attached”. Right after this, “get_free_edges” obtains a list of segments from the attached elements which define the free edges of the selection. 4. Finally, the distance between the intersection point to each segments is obtained and compared to the rest in order to get the minimum one, which is of course the desired value.

Calling example:

>>> myJoint.get_intersection(model1, domain, True)

property Attachment: N2PAttachment

Property that returns the attachment attribute, that is, the joint’s N2PAttachment.

property Bolt: N2PBolt

Property that returns the bolt attribute, that is, the N2PBolt associated to the N2PJoint.

property BoltElementIDList: list[int]

Property that returns the list of the IDs of the N2PElements that make up the joint’s bolt.

property BoltElementInternalIDList: list[int]

Property that returns the list of the internal IDs of the N2PElements that make up the joint’s bolt.

property BoltElementList: list[N2PElement]

Property that returns the list of N2PElements that make up the joint’s bolt.

property BoltNodeList: list[N2PNode]

Property that returns the list of N2PNodes that make up the joint’s bolt.

property Diameter: float

Property that returns the diameter attribute, that is, the joint’s diameter.

property FastenerSystem: N2PFastenerSystem

Property that returns the N2PFastenerSystem of the joint.

property ID: int

Property that returns the joint’s internal identificator.

property JointAnalysisParameters: N2PJointAnalysisParameters

Property that returns the N2PJointAnalysisParameters of the joint.

property PartID: int

Property that returns the part ID of the elements that make up the bolt.

property Pitch: float

Property that returns the pitch attribute, that is, the joint’s pitch.

property PlateElementIDList: list[list[int]]

Property that returns the list of the IDs of the N2PElements that make up the joint’s plates.

property PlateElementInternalIDList: list[list[int]]

Property that returns the internal ID of the N2PElements that make up the joint’s plates.

property PlateElementList: list[list[N2PElement]]

Property that returns the list of N2PElements that make up the joint’s plates.

property PlateList: list[N2PPlate]

Property that returns the plate_list attribute, that is, the list of N2PPlates associated to the N2PJoint.

property PlateNodeList: list[list[tuple[N2PNode]]]

Property that returns the list of N2PNodes that make up the joint’s plates.

property PlatePartID: list[str]

Property that returns the part ID of each element that makes up the plates.

property SwitchPlates: bool

Property that returns the switch_plates attribute, that is, whether the joint’s plates have to be switched or not.

property TypeFastener: str

Property that returns the type of joint that is being used.

NaxToPy.Modules.static.fasteners.joints.N2PJointAnalysisParameters module

class NaxToPy.Modules.static.fasteners.joints.N2PJointAnalysisParameters.N2PJointAnalysisParameters(n2p_joint: N2PJoint)

Bases: object

class that represents a specific INPUT parameters to obtain the joint RF values (for compositemetal plates and bolt)

Attributes

ShearType: str -> defines the support condition for each N2PJoint depending on the surrounding structure and the joint configuration. (str = [DLS, SLS-S, SLS-U]) (Default SLS-U) CenvMet: float -> enviromental KDF for met parts. For all failure modes in the same way. (Default 1.00) CenvComp: float -> enviromental KDF for comp parts. For all failure modes in the same way. (Default 1.00) UserKDFComp: float -> user Defined Knock-Down Factor which applies to all comp failure modes at RF level. Intended to account for Fitting Factor, Buttjoint, Safety Factor. (Default 1.00) UserKDFMet: float -> user defined Knock-Down Factor which applies to all met failure modes at RF level. Intended to account for Fitting Factor, Buttjoint, Safety Factor. (Default 1.00) UserKDFBoltShear: float -> user defined Knock-Down factor for bolt shear failure mode at RF level. Intended to account for several bolt factors. (Default 1.00) UserKDFBoltTension: float -> user defined Knock-Down factor for bolt tension failure mode at RF level. Intended to account for several bolt factors. (Default 1.00) M: float -> slope of the composite bearing-bypass interaction curve [-] (float = [3, 4]) (Default 4.0) TShim: float -> total shim thickness applied to the joint. Includes solid and liquid shim. (Default 0.0) TShimL: float -> liquid shim thickness applied to the joint. Includes solid and liquid shim. (Default 0.0) CPrying: float -> aplied to the tension loads of the failure modes of the external plates. (Default 1.0) PT_Alpha_Met: float -> coefficient alpha of the pull-througth allowable curve for metallic plates, applicable to head side (and tail side, optionally) PT_Gamma_Met: float -> coefficient gamma of the pull-througth allowable curve for metallic plates, applicable to head side (and tail side, optionally) EdgeDistance: list[float] -> list which contains the edge distance of each plate of the joint. EffectiveWidth: list[float] -> plate effective width. NetRatio: list[float] -> plate net ratio. NetSectionArea: list[float] -> net section area for the net section metallic failure mode. Coef_A_CombinedMet: list[float] -> coefficient a for combined interaction allowable curve for metallic plates. Coef_B_CombinedMet: list[float] -> coefficient b for combined interaction allowable curve for metallic plates. Coef_Alpha_CombinedComp: list[float] -> coefficient alpha for combined interaction allowable curve for composite plates. Coef_Beta_CombinedComp: list[float] -> coefficient beta for combined interaction allowable curve for composite plates. Coef_SRF_NetSection_Met: list[float] -> stress reduction factor for net section failure of metallic plates.

property CPrying: float

Property that returns the prying factor of the joint.

property CenvComp: float

Property that returns the joint enviromental KDF for the composite parts.

property CenvMet: float

Property that returns the joint enviromental KDF for the metallic parts.

property Coef_A_CombinedMet: list

Property that returns a list of each plate coefficient “a” for combined interaction allowable curve for metallic plates.

property Coef_Alpha_CombinedComp: list

Property that returns a list of each plate coefficient “alpha” for combined interaction allowable curve for composite plates.

property Coef_B_CombinedMet: list

Property that returns a list of each plate coefficient “b” for combined interaction allowable curve for metallic plates.

property Coef_Beta_CombinedComp: list

Property that returns a list of each plate coefficient “beta” for combined interaction allowable curve for composite plates.

property Coef_SRF_NetSection_Met: list

Property that returns a list of each plate coefficient srf for net section failure mode of metallic plates.

property EdgeDistance: list

Property that returns a list of each plate edge distance.

property EffectiveWidth: list

Property that returns a list of each palte effective width (W).

property M: float

Property that returns the slope of the composite bearing-bypass interaction curve.

property NetRatio: list

Property that returns a list of each plate net ratio (D/W).

property NetSectionArea: list

Property that returns a list of each plate net section area (W-D)*t.

property PT_Alpha_Met: float

Property that returns the coefficient alpha of the pull-througth allowable curve for metallic plates.

property PT_Gamma_Met: float

Property that returns a list of each plate coefficient gamma of the pull-througth allowable curve for metallic plates.

property ShearType: str

Property that returns the shear_type parameter of the joint.

property TShim: float

Property that returns the total shim thickness (solid + liquid) of the joint.

property TShimL: float

Property that returns the liquid shim thickness of the joint.

property UserKDFBoltShear: float

Property that returns the joint user defined KDF for the bolt shear.

property UserKDFBoltTension: float

Property that returns the joint user defined KDF for the bolt tension.

property UserKDFComp: float

Property that returns the joint user defined KDF for the composite parts.

property UserKDFMet: float

Property that returns the joint user defined KDF for the metallic parts.

NaxToPy.Modules.static.fasteners.joints.N2PPlate module

Class that represents a single plate.

class NaxToPy.Modules.static.fasteners.joints.N2PPlate.N2PPlate(info, input_data_father)

Bases: object

Class that represents a single plate.

ID

int -> plate’s internal identificator.

GlobalID

list[int] -> global identificator of the plate.

SolverID

list[int] -> list of the solver IDs of the N2PElements that make up the N2PPlate.

PlateCentralCellSolverID

int -> solver ID of one N2PElement that could represent the entire N2PPlate.

cards

list[N2PCard] -> list of the N2PCards associated to the plate’s elements.

Joint

N2PJoint -> N2PJoint associated to the N2PPlate. Several N2PPlates will be associated to the same

N2PJoint.

Bolt

N2PBolt -> N2PBolt associated to the plate.

ElementList

list[N2PElement] -> list of N2PElements associated to the N2PPlate.

ElementIDList

list[int] -> list of the IDs of the elements associated to the plate.

ElementInternalIDList

list[int] -> list of the internal IDs of the elements associated to the plate.

NodeList

list[tuple[N2PNode]] -> list of N2PNodes associated to the N2PPlate.

PartID

part ID of the associated elements.

CentralElement

N2PElement -> N2PElement that could represent the entire N2PPlate.

BoltElementList

dict[str, N2PElement] -> dictionary in the form {CFAST A: N2PElement 1, CFAST B: N2PElement 2},

corresponding to the A and B CFASTs associated to the plate. If one of the CFAST is not present, 0 is displayed.

BoltDirection

dict[str, str] -> dictionary in the form {CFAST A: Arrow, CFAST B: Arrow}, corresponding to the

direction

Type:

-> or <-

CFASTFactor

dict[str, int] -> dictionary in the form {CFAST A: Factor, CFAST B: Factor}, corresponding to the

multiplication factor

Type:

1 or -1

AttachmentID

int -> ID that the plate receives when it goes through get_attachments

Intersection

list[float] -> intersection point between the N2PPlate and its N2PBolt.

DistanceVector

np.ndarray -> distance (as a vector) from the N2PPlate’s edge to its N2PBolt.

Distance

float -> distance from the N2PPlate’s edge to its N2PBolt.

Normal

list[float] -> perpendicular direction to the N2PPlate.

switched_bolt_elements

bool = False -> internal flag showing if the CFASTs have been switched, which must be

considered to calculate the 1D forces.

BearingForce

dict[int, list[float]] -> dictionary in the form {Load Case ID: [FX, FY, FZ]} corresponding to

the X and Y bearing force, and the pullthrough force.

TranslationalFastenerForces

dict[int, list[list[float]]] -> dictionary in the form

{Load Case ID

[[FX, FY, FZ], [FX, FY, FZ]]} corresponding to the 1D forces that each the N2PElements

associated to the N2PBolt associated to the N2PPlate experience.

NxBypass

dict[int, float] -> dictionary in the form {Load Case ID: Nx} corresponding to the bypass force in

the x axis.

NxTotal

dict[int, float] -> dictionary in the form {Load Case ID: Nx} corresponding to the total force in the

x axis.

NyBypass

dict[int, float] -> dictionary in the form {Load Case ID: Ny} corresponding to the bypass force in

the y axis.

NyTotal

dict[int, float] -> dictionary in the form {Load Case ID: Ny} corresponding to the total force in the

y axis.

NxyBypass

dict[int, float] -> dictionary in the form {Load Case ID: Nxy} corresponding to the bypass force in

the xy axis.

NxyTotal

dict[int, float] -> dictionary in the form {Load Case ID: Nxy} corresponding to the total force in

the xy axis.

MxTotal

dict[int, float] -> dictionary in the form {Load Case ID: Mx} corresponding to the total moment in

the x axis.

MyTotal

dict[int, float] -> dictionary in the form {Load Case ID: My} corresponding to the total moment in

the y axis.

MxyTotal

dict[int, float] -> dictionary in the form {Load Case ID: Mxy} corresponding to the total moment in

the xy axis.

BypassMax

dict[int, float] -> dictionary in the form {Load Case: N} corresponding to the maximum bypass force.

BypassMin

dict[int, float] -> dictionary in the form {Load Case: N} corresponding to the minimum bypass force.

BypassSides

dict[int, list[list[float]]] -> dictionary in the form {Load Case: [[NxNorth, NxSouth, NxWest, NxEast], [NyNorth, …], [NxyNorth, …], [MxNorth, …], [MyNorth, …], [MxyNorth, …]]}

BoxDimension

float -> dimension of the box used in the bypass calculations.

BoxSystem

list[float] -> reference frame used to define the bypass box.

BoxPoints

dict[int, np.ndarray] -> dictionary in the form {1: coords, 2: coords, …, 8: coords} including

each point's coordinates that was used for the bypass calculations.

BoxElements

dict[int, N2PElement] -> dictionary in the form {1: N2PElement 1, 2: N2PElement 2, …,

8

N2PElement 8} including the element in which each point is located.

BoxFluxes

dict[dict[int, list[float]]] -> dictionary in the form

{Load Case ID

{1: [FXX, FYY, FXY, MXX, MYY, MXY], 2: [], …, 8: []}} including fluxes associated to each

box point.

get_bypass_box(model: N2PModelContent, materialFactor=4.0, areaFactor=2.5, maxIterations=200, projTol=0.01, errorCounter=0, maxErrorCounter=10)

Method used to obtain a plate’s bypass box.

Procedure and methodology:

• The procedure is based on the crown method, so the fluxes will be calculated using a square-shaped box

around the joint in the plate’s plane. - Firstly, the box where the calculations are to be made is obtained. Its dimension is

a = 0.4 * areaFactor * materialFactor * Diameter

Assuming that the default parameters are used, this dimension is

a = 4 * Diameter

which is the box dimension used by PAG. - Knowing its dimension, the box should be defined with a specific orientation and order. The orientation is defined by the box reference frame, which coincides with the material system of the element where the joint is pierced. This may cause a small variation because the z-axis is defined as the joint’s axial direction, and sometimes the material system’s z-axis does not coincide with it. - Then, the box system’s origin would be placed in the center of the box and the first point would be located in (-a, a) and the other points would be placed in the clockwise direction. - Adjacent elements will be evaluated until the distance from the joint to them is greater to the box’s semidiagonal. After this, no more points will be found further away, so the search stops here. If there are still points to be assigned, it is concluded that they lie outside of the edge of the plate and therefore they will be projected. - If all points lie within the free edges, the process is simple. The adjacent elements to the pierced one are evaluated in case that any point lies inside of it, which is done taking into consideration the so-called box tolerance, stopping the iterations when the element that is being analysed is far from the box location. - However, there are two cases where the box point location is not as simple. Firstly, if there are points outside the free edges, they are orthogonally projected onto the mesh. In the FastPPH tool used by Altair, this projection does not always follow the same procedure but, to simplify, in this tool an orthogonal projection is always used. - The second critical case occurs when a box crosses a T-edge or gets out of a surface that does not finish in a free edge. If the box crosses a T-edge, it is considered that all points are located within the free edges and should not be projected. If the box gets out of the borders of a surface, and these borders are not free edges, they are treated as so, and the same procedure is followed as when they were outside of free edges (they are orthogonally projected).

Parameters:

• model – N2PModelContent

• materialFactor – float = 4.0

• areaFactor – float = 2.5

• maxIterations – int = 200

• projTol – float = 0.01

Calling example:

>>> myPlate.get_bypass_box(model, domain)

get_bypass_loads(model: N2PModelContent, results: ndarray, loadCaseList: list[N2PLoadCase], cornerData: bool = False, typeAnalysis: Literal['PAG', 'ALTAIR'] = 'PAG', projTol: float = 0.01, errorCounter=0, maxErrorCounter=10)

Method used to obtain the bypass loads of a joint’s plates. Maintaining the defauld parameters is highly recommended, although the user is free to change some of them.

Parameters:

• model – N2PModelContent

• results – np.ndarray -> results obtained from loads.Results or loads.ResultsCorner.

• loadCaseList – list[N2PLoadCase] -> list of N2PLoadCases to analyse.

• cornerData – bool = False -> boolean that shows if there is data in the corners or not.

• typeAnalysis – Literal[“PAG”, “ALTAIR”] = “PAG” -> type of analysis to be done. The only difference is in the

• fluxes. (calculation of the momentum)

• projTol – float = 0.01 -> tolerance used in the interpolation.

Calling example:

>>> myPlate.get_bypass_loads(loads.Model, domain, loads.Results, loads.LoadCases, False, "ALTAIR", 0.05)

Procedure and methodology:

• After the bypass box has been created, the fluxes in each of the points of the boxes must be obtained, in

order to calculate the final values for bypass and total loads. There are two options to be analyzed:

1. cornerData = True

If the user asks for results in the corner when running the model and obtaining the corresponding results, these results will be given by node and not by element, giving several values for a node, related to the element where it is. This can be achieved by selecting the CORNER or BILIN describer in the FORCE card. Results will be more accurate if corner data is used, as there are more values to be used.

Taking each of the box’s points, the same procedure is carried out. Firstly, the results for all nodes that form the element where the box point is are retrieved. They are represented in their element reference frame, so they are transformed into the same reference frame. Once 3 or 4 values for the nodes are obtained (depending on wether the element is a TRIA or QUAD), a bilinear interpolation to the box point from the node locations is used.

2. cornerData = False

The results in the result files are retrieved in the centroid of each element, leading to results that will be less precise, since results in the corners must be approximated instead of actually calculated. This approximation is made by averaging the adjacent elements. Besides this, the same procedure is used as in the previous case.

• Finally, all results are transformed into the material reference frame corresponding to the element where

the joint is pierced.

property AttachmentID: int

Property that returns the attachment_id attribute, that is, the plate’s internal ID when it goes through the get_attachments() function.

property BearingForce: dict[int, ndarray]

Property that returns the bearing_force attribute, that is, the 1D force that the plate experiences.

property Bolt: N2PBolt

Property that returns the bolt attribute, that is, the N2PBolt associated to the plate.

property BoltDirection: dict[str, str]

Property that returns the bolt_direction attribute, that is, the dictionary of the orientation of the CFASTs that are joined to the plate.

property BoltElementList: dict[str, N2PElement]

Property that returns the bolt_element_list attribute, that is, the dictionary of the CFAST that are joined to the plate.

property BoxDimension: float

Property that returns the box_dimension attribute, that is, the length of the side of the box that is used in the bypass loads calculation.

property BoxElements: dict[int, N2PElement]

Property that returns the box_elements attribute, that is, the N2PElement associated to each point that makes up the box used in the bypass loads calculations.

property BoxFluxes: dict[int, dict[int, list[float]]]

Property that returns the box_fluxes attribute, that is, the fluxes (in every direction) that every point that makes up the box used in the bypass loads calculation experience.

property BoxPoints: dict[int, ndarray]

Property that returns the box_points attribute, that is, the coordinates of each point that makes up the box used in the bypass loads calculation.

property BoxSystem: list[float]

Property that returns the the reference frame of the box used in the bypass loads calculation, which is the plate’s element material reference frame.

property BypassMax: dict[int, float]

Property that returns the bypass_max attribute, that is, the maximum bypass load that the plate experiences.

property BypassMin: dict[int, float]

Property that returns the bypass_min attribute, that is, the minimum bypass load that the plate experiences.

property BypassSides: dict[int, list[float]]

Property that retuns the bypass_sides attribute, that is, the bypass loads in the north, south, east and west sides of the box.

property CFASTFactor: dict[str, int]

Property that returns the cfast_factor attribute, that is, the dictionary of the factor (0, +1 or -1) which should be included in the exported results of the PAG forces.

property Cards: list[N2PCard]

Property that returns the cards attribute, that is, the list of the N2PCards associated with the N2PPlate’s N2PElements.

property CentralElement: N2PElement

Property that returns the central_element attribute, that is, the representative N2PElement of the plate.

property Distance: float

Property that returns the distance attribute, that is, the distance between the bolt and the plate’s edge.

property DistanceVector: ndarray

Property that returns the distance_vector attribute, that is, the distance between the bolt and the plate’s edge as a vector.

property ElementIDList: list[int]

Property that returns the list of the IDs of the N2PElements that make up a plate.

property ElementInternalIDList: list[int]

Property that returns the unique internal ID of the N2PElements that make up the plate.

property ElementList: list[N2PElement]

Property that returns the element_list attribute, that is, the list of N2PElements that make up the plate.

property GlobalID: list[int]

Property that returns the global_id attribute, that is, the global identificator.

property ID: int

Property that returns the id attribute, that is, the internal identificator.

property Intersection: list[float]

Property that returns the intersection attribute, that is, the point where the bolt pierces the plate.

property Joint: N2PJoint

Property that returns the joint attribute, that is, the N2PJoint associated to the plate.

property MxTotal: dict[int, float]

Property that returns the mx_total attribute, that is, the total moment that the plate experiences in the x-axis.

property MxyTotal: dict[int, float]

Property that returns the mxy_total attribute, that is, the total moment that the plate experiences in the xy-axis.

property MyTotal: dict[int, float]

Property that returns the my_total attribute, that is, the total moment that the plate experiences in the y-axis.

property NodeList: list[tuple[N2PNode]]

Property that returns the list of N2PNodes that make up the plate.

property Normal: list[float]

Property that returns the normal attribute, that is, the direction perpendicular to the plate’s plane.

property NxBypass: dict[int, float]

Property that returns the nx_bypass attribute, that is, the bypass load that the plate experiences in the x-axis.

property NxTotal: dict[int, float]

Property that returns the nx_total attribute, that is, the total load that the plate experiences in the x-axis.

property NxyBypass: dict[int, float]

Property that returns the nxy_bypass attribute, that is, the bypass load that the plate experiences in the xy-axis.

property NxyTotal: dict[int, float]

Property that returns the nxy_total attribute, that is, the total load that the plate experiences in the xy-axis.

property NyBypass: dict[int, float]

Property that returns the ny_bypass attribute, that is, the bypass load that the plate experiences in the y-axis.

property NyTotal: dict[int, float]

Property that returns the ny_total attribute, that is, the total load that the plate experiences in the y-axis.

property PartID: list[str]

Property that returns the part ID of eache element that makes up the plate.

property PlateCentralCellSolverID: int

Property that returns the plate_central_cell_solver_id attribute, that is, the solver ID of one representative N2PElement that makes up the plate.

property SolverID: list[int]

Property that returns the solver_id attribute, that is, the solver IDs of the N2PElements that make up the plate.

property TranslationalFastenerForces: dict[int, list[ndarray]]

Property that returns the translational_fastener_forces attribute, that is, the 1D force that each fastener experiences.

Module contents