NaxToPy.Modules.Fasteners.Joints package

Submodules

NaxToPy.Modules.Fasteners.Joints.N2PAttachment module

class NaxToPy.Modules.Fasteners.Joints.N2PAttachment.N2PAttachment(id)

Bases: object

Class that represents an attachment, which is a series of N2PJoints that join the same N2PPlates.

id

int

attached_plates_ids

list[int] -> list of the attached N2PPlates’ ID.

attached_plates

list[N2PPlate] -> list of the attached N2PPlates.

joints

list[N2PJoint] -> list of the attached N2PJoints.

pitch

float -> minimum distance from an N2PJoint to its neighbours.

property AttachedPlates: list[N2PPlate]

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

property AttachedPlatesIDs: list[int]

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

property ID: int

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

property Joints: 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.

get_pitch()

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

Calling example:

>>> from NaxToPy.Modules.Fasteners.Joints.N2PAttachment import N2PAttachment
>>> jointPitch = myAttachment.get_pitch()

NaxToPy.Modules.Fasteners.Joints.N2PBolt module

class NaxToPy.Modules.Fasteners.Joints.N2PBolt.N2PBolt(info, input_data_father)

Bases: object

Class that represents a single bolt.

id

int -> bolt’s internal identificator.

one_dim_elems_id_list

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. It could contain nulls/

nones, like when dealing with .op2 files.

type

str -> type of bolt.

joint

N2PJoint -> N2PJoint associated to the N2PBolt.

elements

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

element_local_system_force

dict[int, dict[int, list[float]]] -> dictionary in the form {Load Case ID: Bolt

Element ID

[FX, FY, FZ]} of the joint in the local coordinate system.

axial_force

dict[int, dict[int, float]] -> dictionary in the form {Load Case ID: Bolt Element ID: F} of the

joint's axial force.

shear_force

dict[int, dict[int, float]] -> dictionary in the form {Load Case ID: Bolt Element ID: F} of the

joint's shear force.

max_axial_force

dict[int, dict[int, float]] -> dictionary in the form {Load Case ID: F} of the joint’s maximum

axial force.

load_angle

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, 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 ElementLocalSystemForce: dict[int, list[float]]

Property that returns the element_local_system_force attribute, that is, the bolt’s 1D forces in the local reference frame.

property Elements: list[N2PElement]

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

property ElementsID: list[int]

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

property ElementsInternalID: list[int]

Property that returns the list of the internal IDs 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, 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 Nodes: list[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, 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.Fasteners.Joints.N2PJoint module

class NaxToPy.Modules.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.

diameter

float = None -> joint’s diameter.

bolt

N2PBolt -> N2PBolt associated.

plates

list[N2PPlate] -> list of unique N2PPlates associated to the N2PJoint.

attachment

N2PAttachment -> joint’s attachment.

pitch

float -> joint’s pitch.

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 BoltElements: list[N2PElement]

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

property BoltElementsID: list[int]

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

property BoltElementsInternalID: list[int]

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

property BoltNodes: 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 ID: int

Property that returns the joint’s internal identificator.

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 PlateElements: list[N2PElement]

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

property PlateElementsID: list[int]

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

property PlateElementsInternalID: list[int]

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

property PlateNodes: list[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 Plates: list[N2PPlate]

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

property TypeFastener: str

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

export_forces(model: N2PModelContent, pathFile: str, analysisName: str, results: dict, typeExport: Literal['NAXTOPY', 'ALTAIR'] = 'NAXTOPY')

Method used to export the obtained forces and bypass loads to a CSV file in the path described by the user.

Parameters:

• model – N2PModelContent

• pathFile – str -> path file.

• analysisName – str -> file’s name.

• results – dict -> results dictionary.

• typeExport – Literal[“NAXTOPY”, “ALTAIR”] = “NAXTOPY” -> export style. By default, results are exported in

• style. (the NAXTOPY)

The CSV file has the following information, in this order, for the NAXTOPY style:

Bolt ID Plate Global ID Plate Local ID Plate Part ID Plate Element ID -> solver ID of the central N2PElement associated to the N2PPlate. Plate Element Property ID -> ID of the N2PProperty associated to the previous N2PElement. Bolt Element 1 ID -> ID of the 1st N2PElement associated to the N2PBolt. Bolt Element 2 ID -> ID of the 2nd N2PElement associated to the N2PBolt (if there is no 2nd element, ‘0’ is displayed instead). Load Case ID Analysis Name -> as defined by the user. Box Dimension Box System Intersection -> intersection point between the plate and its bolt FX Altair; FY Altair; FZ Altair FX Connector 1; FY Connector 1; FZ Connector 1; FX Connector 2; FY Connector 2; FZ Connector 2 FZ max p1; p2; …; p8 -> nth box point Fxx p1; Fxx p2; …; Fxx p8 -> FXX flux associated to the nth box point. Fyy p1; … -> FYY flux associated to the nth box point. Fxy p1; … -> FXY flux associated to the nth box point. Mxx p1; … -> MXX flux associated to the nth box point. Myy p1; … -> MYY flux associated to the nth box point. Mxy p1; … -> MXY flux associated to the nth box point. Nx bypass; Nx total; Ny bypass; Ny total; Nxy bypass; Nxy total; Mx total; My total; Mxy total

It has the following information, in this order, for the ALTAIR style:

DDP -> joint ID. elementid -> ID of the central N2PElement associated to the N2PPlate. Component Name elem 1 id -> ID of the first connector. elem 1 node id -> ID of the first node of the first connector. elem 2 id -> ID of the second connector. elem 2 node id -> ID of the first node of the second connector. box dimension loadcase -> loadcase ID. file name -> analysis name. LoadCase Name Time Step Name -> ‘N/A’ pierced location -> intersection point. FX, FY, FZ MaxFz p1; p2; …; p8 -> nth box point Fxx p1; Fxx p2; …; Fxx p8 -> FXX flux associated to the nth box point. Fyy p1; … -> FYY flux associated to the nth box point. Fxy p1; … -> FXY flux associated to the nth box point. Mxx p1; … -> MXX flux associated to the nth box point. Myy p1; … -> MYY flux associated to the nth box point. Mxy p1; … -> MXY flux associated to the nth box point. Nx bypass; Nx total; Ny bypass; Ny total; Nxy bypass; Nxy total; Mx total; My total; Mxy total

There is one row for each loadcase and each distinct N2PPlate, so there are a total of

Numer of Loadcases * Number of different N2PPlates

total rows, without taking into consideration the header.

Calling example:

>>> myJoint.export_forces(pathFile, "test", fasteners.Results, "ALTAIR")

get_bypass_loads(model: N2PModelContent, results: dict, cornerData: bool = False, materialFactorMetal: float = 4.0, materialFactorComposite: float = 4.5, areaFactor: float = 2.5, maxIterations: int = 200, boxTol: float = 0.001, projTol: float = 0)

Method that takes an N2PJoint, as well as some other inputs obtained throughout the code, and obtains the bypass loads of each of its associated N2PPlates. It is highly recommended to use the default inputs, but the user could manually alter any of them.

Parameters:

• model – N2PModelContent

• results – dict -> result dictionary.

• cornerData – bool = False -> boolean which shows whether the corner data is to be used or not.

• materialFactorMetal – float = 4.0 -> material factor corresponding to metallic materials.

• materialFactorComposite – float = 4.5 -> material factor corresponding to composite materials.

• areaFactor – float = 2.5

• maxIterations – int = 200: maximum number of iterations.

• boxTol – float = 1e-3 -> tolerance used to determine whether a point is inside the box or not.

• projTol – float = 0 -> tolerance used in the projections.

Calling example:

>>> bypassLoads = myJoint.get_bypass_loads(model1, fasteners.Results)

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

• 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. - This does not always coincide with what Altair displays, but the final results should be the same. - 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). - Now, the fluxes in each of the points of the boxes, for each load case, 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.

There are several checks during the program that help the user understand if there are any problems in the analysis. In any case, an error appears. The checks are the following:

1. There are less than two plates connected to the joint.

2. A plate does not have the necessary information (intersection, normal, distance and elements).

3. The joint has no diameter or it is negative.

4. The maximum number of iterations is reached.

5. There are no candidate elements to search. This should not actually occur, though, because of a previous check. 6. There are not enough adjacent elements in the model. 7. Certain arrays do not have, for whatever reason, six elements. 8. The final rotation matrix is not well defined.

get_distance(model: N2PModelContent)

Method that calculates the distance from each N2PJoint to the edge of its corresponding N2PPlates.

Parameters:

model – N2PModelContent

The following steps are followed:

1. The intersection points between every N2PPlate and its N2PJoint is obtained.

2. 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. 3. 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_distance(model1)

get_forces(results: dict)

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

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

depending on what is obtained.

Parameters:

results – dict -> results dictionary.

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 in the 1st plate’s material reference frame. It will be positive if the fastener is extender or 0 if it is compressed. It is a N2PBolt attribute. - element_local_system_force: dictionary in the form {Load Case ID: Bolt Element ID: [FX, FY, FZ]} which represents the 1D force in the 1st plate’s material reference frame. It is a N2PBolt attribute. - plates_force: 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. - altair_force: dictionary in the form {Load Case ID: [FX, FY, FZ]} which represents the 1D force experienced by the joint, as calculated by Altair. It takes into account if there are two joints 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 of the whole joint. 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. All reference frames are obtained: the 1st plate’s material reference frame, the bolt’s N2PElement reference frame and the local reference frame. 2. All forces are calculated according to their definition. If necessary, they are rotated so that they are expressed in the correct reference frame. 3. If there are two joints attached to the same plate, their contributions are added.

It must be added that, in the original code, there was a distinction between top and bottom plates and, as such, the force that the top and bottom plates experienced was also calculated. As in the modern code this distinction no longer exists, this cannot be calculated.

Calling example:

>>> myForces = myJoint.get_forces(fasteners.Results)

NaxToPy.Modules.Fasteners.Joints.N2PPlate module

class NaxToPy.Modules.Fasteners.Joints.N2PPlate.N2PPlate(info, input_data_father)

Bases: object

Class that represents a single plate.

id

int -> internal ID.

global_id

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

solver_id

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

plate_central_cell_solver_id

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

cards

list[N2PCard] -> list of the N2PCards of the N2PElements that make up the N2PPlate. It could contain

nulls/nones, like when dealing with .op2 files.

joint

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

N2PJoint.

elements

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

attachment_id

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

intersection

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

distance

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

normal

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

altair_force

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

Altair's 1D force.

plates_force

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.

nx_bypass

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

the x axis.

nx_total

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

x axis.

ny_bypass

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

the y axis.

ny_total

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

y axis.

nxy_bypass

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

the xy axis.

nxy_total

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

the xy axis.

mx_total

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

the x axis.

my_total

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

the y axis.

mxy_total

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

the xy axis.

bypass_max

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

bypass_min

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

box_dimension

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

box_system

list[float] -> box coordinate system used in the bypass calculations.

box_points

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

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

box_fluxes

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.

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

Property that returns the altair_force attribute, that is, the 1D force that the plate experiences as calculated by Altair.

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 Bolt: N2PBolt

Property that returns the bolt attribute, that is, the N2PBolt associated 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 BoxFluxes: dict[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, array]

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 box_system attribute, that is, the reference frame of the box used in the bypass loads calculation.

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 Cards: list[N2PCard]

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

property Distance: list[float]

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

property Elements: list[N2PElement]

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

property ElementsID: list[int]

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

property ElementsInternalID: list[int]

Property that returns the unique internal ID of the 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 Nodes: list[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 PlatesForce: dict[int, list[list[float]]]

Property that returns the plates_force attribute, that is, the 1D force that each N2PPlate’s N2PElement experiences.

property SolverID: list[int]

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

Module contents