Analysis Result Extraction Functions
- Harika Inanc (Unlicensed)
All results available through the OpenBrIM app are also accessible in ParamML documents through result extraction functions. That means results can be used just like any other parameter in your ParamML document. Keep in mind that if there are not analysis results available (results have been reset or analysis have not yet been run), these parameters will evaluate to zero.
Negative/Positive Effects
Certain analysis cases provide results separately for negative and positive displacements/forces. For example, influence based live load analysis cases provide results that maximizes negative moment and/or positive moment on a beam. Or an enveloped case that is setup to pick the maximum separately for negative and positive force effects.
If such analysis case is provided to the aforementioned functions, the returned result may be for negative or positive depending on which one is larger in magnitude. Internally, OpenBrIM fetches the results for both positive and negative and then picks the absolute maximum.
Composite Forces
Instead of getting forces on a particular finite element, in certain cases, you may be interested in getting sum of forces of multiple elements. OpenBrIM calls these composite forces. Given a set of finite elements, composite force procedure computes a geometric centroid formed by the elements and then transform the forces in the elements to this centroid, sum and report as composite force.
One common use case for composite forces is to get composite forces acting on a girder where the girder and the deck is modeled using separate finite elements. In such case, rather than the forces in the individual finite elements, you would be interested in composite forces formed by the elements of the girder and the contributing deck over the girder.
Extracting Displacement
FEA simulations calculate these displacement values for each element in the structure based on the applied loads and boundary conditions.
disp(Case,Element) → List of Number ([Tx,Ty,Tz,Rx,Ry,Rz]) | |
|---|---|
dispTx(Case,Element) = disp(Case,Element)[0] → Number (Tx) | |
dispTy(Case,Element) = disp(Case,Element)[1] → Number (Ty) | |
dispTz(Case,Element) = disp(Case,Element)[2] → Number (Tz) | |
dispRx(Case,Element) = disp(Case,Element)[3] → Number (Rx) | |
dispRy(Case,Element) = disp(Case,Element)[4] → Number (Ry) | |
dispRz(Case,Element) = disp(Case,Element)[5] → Number (Rz) | |
Case : Object | Element : Object |
T=”AnalysisCase“ T=”Combination” | T=”Node” |
disp(Case,Node Coordinate) → List of Number ([Tx,Ty,Tz,Rx,Ry,Rz]) | |
dispTx(Case,Node Coordinate) = disp(Case,Node Coordinate)[0] → Number (Tx) | |
dispTy(Case,Node Coordinate) = disp(Case,Node Coordinate)[1] → Number (Ty) | |
dispTz(Case,Node Coordinate) = disp(Case,Node Coordinate)[2] → Number (Tz) | |
dispRx(Case,Node Coordinate) = disp(Case,Node Coordinate)[3] → Number (Rx) | |
dispRy(Case,Node Coordinate) = disp(Case,Node Coordinate)[4] → Number (Ry) | |
dispRz(Case,Node Coordinate) = disp(Case,Node Coordinate)[5] → Number (Rz) | |
Case : Object | Node Coordinate : List of Number |
T=”AnalysisCase“ T=”Combination” | [X coordinate, Y coordinate, Z coordinate] → If you don't have direct access to the node object, you can pass in a coordinate as a list of 3 numbers (this only applies to nodes, will not work for finite element). OpenBrIM will find the node that is closest to the specified coordinate and return the results. |
Extracting Positive/Negative Critical Displacement
Envelope results help identify the worst-case scenarios in terms of stresses, strains, displacements, or other relevant parameters. By considering extreme values across different load cases or conditions, engineers can ensure that their designs are robust and capable of withstanding the most demanding situations.
The following functions are designed to extract the displacements where the force action that is indicated in the function name is maximized.
dispPos(Case,Element) → List of Number ([Tx,Ty,Tz,Rx,Ry,Rz]) | |
|---|---|
dispTxPos(Case,Element) = dispPos(Case,Element)[0] → Number (Tx) | |
dispTyPos(Case,Element) = dispPos(Case,Element)[1] → Number (Ty) | |
dispTzPos(Case,Element) = dispPos(Case,Element)[2] → Number (Tz) | |
dispRxPos(Case,Element) = dispPos(Case,Element)[3] → Number (Rx) | |
dispRyPos(Case,Element) = dispPos(Case,Element)[4] → Number (Ry) | |
dispRzPos(Case,Element) = dispPos(Case,Element)[5] → Number (Rz) | |
Case : Object | Element : Object |
T=”AnalysisCase“ T=”Combination” | T=”Node” |
dispPos(Case,Node Coordinate) → List of Number ([Tx,Ty,Tz,Rx,Ry,Rz]) | |
dispTxPos(Case,Node Coordinate) = dispPos(Case,Node Coordinate)[0] → Number (Tx) | |
dispTyPos(Case,Node Coordinate) = dispPos(Case,Node Coordinate)[1] → Number (Ty) | |
dispTzPos(Case,Node Coordinate) = dispPos(Case,Node Coordinate)[2] → Number (Tz) | |
dispRxPos(Case,Node Coordinate) = dispPos(Case,Node Coordinate)[3] → Number (Rx) | |
dispRyPos(Case,Node Coordinate) = dispPos(Case,Node Coordinate)[4] → Number (Ry) | |
dispRzPos(Case,Node Coordinate) = dispPos(Case,Node Coordinate)[5] → Number (Rz) | |
Case : Object | Node Coordinate : List of Number |
T=”AnalysisCase“ T=”Combination” | [X coordinate, Y coordinate, Z coordinate] → If you don't have direct access to the node object, you can pass in a coordinate as a list of 3 numbers (this only applies to nodes, will not work for finite element). OpenBrIM will find the node that is closest to the specified coordinate and return the results. |
dispNeg(Case,Element) → List of Number ([Tx,Ty,Tz,Rx,Ry,Rz]) | |
|---|---|
dispTxNeg(Case,Element) = dispNeg(Case,Element)[0] → Number (Tx) | |
dispTyNeg(Case,Element) = dispNeg(Case,Element)[1] → Number (Ty) | |
dispTzNeg(Case,Element) = dispNeg(Case,Element)[2] → Number (Tz) | |
dispRxNeg(Case,Element) = dispNeg(Case,Element)[3] → Number (Rx) | |
dispRyNeg(Case,Element) = dispNeg(Case,Element)[4] → Number (Ry) | |
dispRzNeg(Case,Element) = dispNeg(Case,Element)[5] → Number (Rz) | |
Case : Object | Element : Object |
T=”AnalysisCase“ T=”Combination” | T=”Node” |
dispNeg(Case,Node Coordinate) → List of Number ([Tx,Ty,Tz,Rx,Ry,Rz]) | |
dispTxNeg(Case,Node Coordinate) = dispNeg(Case,Node Coordinate)[0] → Number (Tx) | |
dispTyNeg(Case,Node Coordinate) = dispNeg(Case,Node Coordinate)[1] → Number (Ty) | |
dispTzNeg(Case,Node Coordinate) = dispNeg(Case,Node Coordinate)[2] → Number (Tz) | |
dispRxNeg(Case,Node Coordinate) = dispNeg(Case,Node Coordinate)[3] → Number (Rx) | |
dispRyNeg(Case,Node Coordinate) = dispNeg(Case,Node Coordinate)[4] → Number (Ry) | |
dispRzNeg(Case,Node Coordinate) = dispNeg(Case,Node Coordinate)[5] → Number (Rz) | |
Case : Object | Node Coordinate : List of Number |
T=”AnalysisCase“ T=”Combination” | [X coordinate, Y coordinate, Z coordinate] → If you don't have direct access to the node object, you can pass in a coordinate as a list of 3 numbers (this only applies to nodes, will not work for finite element). OpenBrIM will find the node that is closest to the specified coordinate and return the results. |
Extracting Concurrent Displacement
Positive Results
dispTxPosConc(Case,Element) → List of Number ([Tx*,Ty,Tz,Rx,Ry,Rz]) critical Tx result and its concurrent results | |
dispTyPosConc(Case,Element) → List of Number ([Tx,Ty*,Tz,Rx,Ry,Rz]) critical Ty result and its concurrent results | |
dispTzPosConc(Case,Element) → List of Number ([Tx,Ty,Tz*,Rx,Ry,Rz]) critical Tz result and its concurrent results | |
dispRxPosConc(Case,Element) → List of Number ([Tx,Ty,Tz,Rx*,Ry,Rz]) critical Rx result and its concurrent results | |
dispRyPosConc(Case,Element) → List of Number ([Tx,Ty,Tz,Rx,Ry*,Rz]) critical Ry result and its concurrent results | |
dispRzPosConc(Case,Element) → List of Number ([Tx,Ty,Tz,Rx,Ry,Rz*]) critical Rz result and its concurrent results | |
Case : Object | Element : Object |
T=”AnalysisCase“ T=”Combination” | T=”Node” |
dispTxPosConc(Case,Node Coordinate) → List of Number ([Tx*,Ty,Tz,Rx,Ry,Rz]) critical Tx result and its concurrent results | |
dispTyPosConc(Case,Node Coordinate) → List of Number ([Tx,Ty*,Tz,Rx,Ry,Rz]) critical Ty result and its concurrent results | |
dispTzPosConc(Case,Node Coordinate) → List of Number ([Tx,Ty,Tz*,Rx,Ry,Rz]) critical Tz result and its concurrent results | |
dispRxPosConc(Case,Node Coordinate) → List of Number ([Tx,Ty,Tz,Rx*,Ry,Rz]) critical Rx result and its concurrent results | |
dispRyPosConc(Case,Node Coordinate) → List of Number ([Tx,Ty,Tz,Rx,Ry*,Rz]) critical Ry result and its concurrent results | |
dispRzPosConc(Case,Node Coordinate) → List of Number ([Tx,Ty,Tz,Rx,Ry,Rz*]) critical Rz result and its concurrent results | |
Case : Object | Node Coordinate : List of Number |
T=”AnalysisCase“ T=”Combination” | [X coordinate, Y coordinate, Z coordinate] → If you don't have direct access to the node object, you can pass in a coordinate as a list of 3 numbers (this only applies to nodes, will not work for finite element). OpenBrIM will find the node that is closest to the specified coordinate and return the results. |
Negative Results
dispTxNegConc(Case,Element) → List of Number ([Tx*,Ty,Tz,Rx,Ry,Rz]) critical Tx result and its concurrent results | |
dispTyNegConc(Case,Element) → List of Number ([Tx,Ty*,Tz,Rx,Ry,Rz]) critical Ty result and its concurrent results | |
dispTzNegConc(Case,Element) → List of Number ([Tx,Ty,Tz*,Rx,Ry,Rz]) critical Tz result and its concurrent results | |
dispRxNegConc(Case,Element) → List of Number ([Tx,Ty,Tz,Rx*,Ry,Rz]) critical Rx result and its concurrent results | |
dispRyNegConc(Case,Element) → List of Number ([Tx,Ty,Tz,Rx,Ry*,Rz]) critical Ry result and its concurrent results | |
dispRzNegConc(Case,Element) → List of Number ([Tx,Ty,Tz,Rx,Ry,Rz*]) critical Rz result and its concurrent results | |
Case : Object | Element : Object |
T=”AnalysisCase“ T=”Combination” | T=”Node” |
dispTxNegConc(Case,Node Coordinate) → List of Number ([Tx*,Ty,Tz,Rx,Ry,Rz]) critical Tx result and its concurrent results | |
dispTyNegConc(Case,Node Coordinate) → List of Number ([Tx,Ty*,Tz,Rx,Ry,Rz]) critical Ty result and its concurrent results | |
dispTzNegConc(Case,Node Coordinate) → List of Number ([Tx,Ty,Tz*,Rx,Ry,Rz]) critical Tz result and its concurrent results | |
dispRxNegConc(Case,Node Coordinate) → List of Number ([Tx,Ty,Tz,Rx*,Ry,Rz]) critical Rx result and its concurrent results | |
dispRyNegConc(Case,Node Coordinate) → List of Number ([Tx,Ty,Tz,Rx,Ry*,Rz]) critical Ry result and its concurrent results | |
dispRzNegConc(Case,Node Coordinate) → List of Number ([Tx,Ty,Tz,Rx,Ry,Rz*]) critical Rz result and its concurrent results | |
Case : Object | Node Coordinate : List of Number |
T=”AnalysisCase“ T=”Combination” | [X coordinate, Y coordinate, Z coordinate] → If you don't have direct access to the node object, you can pass in a coordinate as a list of 3 numbers (this only applies to nodes, will not work for finite element). OpenBrIM will find the node that is closest to the specified coordinate and return the results. |
Extracting Force
The following functions are designed to extract the analysis results of limit states - unfactored load cases - combinations and/or envelopes. These analysis results can be derived from a single finite element (FE), such as a node, line, or surface. Additionally, analysis results can be derived from a combination of elements which defines a composite section.
force(Case,Element,Station) → List of Number ([Fx,Fy,Fz,Mx,My,Mz]) | ||
|---|---|---|
forceFx(Case,Element,Station) = force(Case,Element,Station)[0] → Number (Fx) | ||
forceFy(Case,Element,Station) = force(Case,Element,Station)[1] → Number (Fy) | ||
forceFz(Case,Element,Station) = force(Case,Element,Station)[2] → Number (Fz) | ||
forceMx(Case,Element,Station) = force(Case,Element,Station)[3] → Number (Mx) | ||
forceMy(Case,Element,Station) = force(Case,Element,Station)[4] → Number (My) | ||
forceMy(Case,Element,Station) = force(Case,Element,Station)[5] → Number (Mz) | ||
Case : Object | Element : Object | Station : Number |
T=”AnalysisCase“ T=”Combination” | T=”Node” T=”FELine” T=”FESurface” T=”FEComposite” | Node → Leave empty FELine → 0 for start edge, 1 for end edge FESurface → 0,1,2,4 for edge nodes FEComposite → The distance from the start point of FEComposite path |
force(Case,Node Coordinate) → List of Number ([Fx,Fy,Fz,Mx,My,Mz]) | ||
forceFx(Case,Node Coordinate) = force(Case,Node Coordinate)[0] → Number (Fx) | ||
forceFy(Case,Node Coordinate) = force(Case,Node Coordinate)[1] → Number (Fy) | ||
forceFz(Case,Node Coordinate) = force(Case,Node Coordinate)[2] → Number (Fz) | ||
forceMx(Case,Node Coordinate) = force(Case,Node Coordinate)[3] → Number (Mx) | ||
forceMy(Case,Node Coordinate) = force(Case,Node Coordinate)[4] → Number (My) | ||
forceMy(Case,Node Coordinate) = force(Case,Node Coordinate)[5] → Number (Mz) | ||
Case : Object | Node Coordinate : List of Number | |
T=”AnalysisCase“ T=”Combination” | [X coordinate, Y coordinate, Z coordinate] → If you don't have direct access to the node object, you can pass in a coordinate as a list of 3 numbers (this only applies to nodes, will not work for finite element). OpenBrIM will find the node that is closest to the specified coordinate and return the results. | |
Extracting Positive/Negative Critical Force
Envelope results are crucial in finite element analysis (FEA) as they identify worst-case scenarios for parameters like stresses and displacements. To obtain these results, the following functions can be utilized. The term "Pos" signifies that the function provides the maximum critical force on the element at the specified station under the given loading scenario in the particular case. Similarly, "Neg" indicates that the function returns to the minimum critical analysis result of the given loading case on the specified element at the specified station.
forcePos(Case,Element,Station) → List of Number ([Fx,Fy,Fz,Mx,My,Mz]) | ||
|---|---|---|
forceFxPos(Case,Element,Station) = forcePos(Case,Element,Station)[0] → Number (Fx) | ||
forceFyPos(Case,Element,Station) = forcePos(Case,Element,Station)[1] → Number (Fy) | ||
forceFzPos(Case,Element,Station) = forcePos(Case,Element,Station)[2] → Number (Fz) | ||
forceMxPos(Case,Element,Station) = forcePos(Case,Element,Station)[3] → Number (Mx) | ||
forceMyPos(Case,Element,Station) = forcePos(Case,Element,Station)[4] → Number (My) | ||
forceMyPos(Case,Element,Station) = forcePos(Case,Element,Station)[5] → Number (Mz) | ||
Case : Object | Element : Object | Station : Number |
T=”AnalysisCase“ T=”Combination” | T=”Node” T=”FELine” T=”FESurface” T=”FEComposite” | Node → Leave empty FELine → 0 for start edge, 1 for end edge FESurface → 0,1,2,4 for edge nodes FEComposite → The distance from the start point of FEComposite path |
forcePos(Case,Node Coordinate) → List of Number ([Fx,Fy,Fz,Mx,My,Mz]) | ||
forceFxPos(Case,Node Coordinate) = forcePos(Case,Node Coordinate)[0] → Number (Fx) | ||
forceFyPos(Case,Node Coordinate) = forcePos(Case,Node Coordinate)[1] → Number (Fy) | ||
forceFzPos(Case,Node Coordinate) = forcePos(Case,Node Coordinate)[2] → Number (Fz) | ||
forceMxPos(Case,Node Coordinate) = forcePos(Case,Node Coordinate)[3] → Number (Mx) | ||
forceMyPos(Case,Node Coordinate) = forcePos(Case,Node Coordinate)[4] → Number (My) | ||
forceMyPos(Case,Node Coordinate) = forcePos(Case,Node Coordinate)[5] → Number (Mz) | ||
Case : Object | Node Coordinate : List of Number | |
T=”AnalysisCase“ T=”Combination” | [X coordinate, Y coordinate, Z coordinate] → If you don't have direct access to the node object, you can pass in a coordinate as a list of 3 numbers (this only applies to nodes, will not work for finite element). OpenBrIM will find the node that is closest to the specified coordinate and return the results. | |
forceNeg(Case,Element,Station) → List of Number ([Fx,Fy,Fz,Mx,My,Mz]) | ||
|---|---|---|
forceFxNeg(Case,Element,Station) = forceNeg(Case,Element,Station)[0] → Number (Fx) | ||
forceFyNeg(Case,Element,Station) = forceNeg(Case,Element,Station)[1] → Number (Fy) | ||
forceFzNeg(Case,Element,Station) = forceNeg(Case,Element,Station)[2] → Number (Fz) | ||
forceMxNeg(Case,Element,Station) = forceNeg(Case,Element,Station)[3] → Number (Mx) | ||
forceMyNeg(Case,Element,Station) = forceNeg(Case,Element,Station)[4] → Number (My) | ||
forceMyNeg(Case,Element,Station) = forceNeg(Case,Element,Station)[5] → Number (Mz) | ||
Case : Object | Element : Object | Station : Number |
T=”AnalysisCase“ T=”Combination” | T=”Node” T=”FELine” T=”FESurface” T=”FEComposite” | Node → Leave empty FELine → 0 for start edge, 1 for end edge FESurface → 0,1,2,4 for edge nodes FEComposite → The distance from the start point of FEComposite path |
forceNeg(Case,Node Coordinate) → List of Number ([Fx,Fy,Fz,Mx,My,Mz]) | ||
forceFxNeg(Case,Node Coordinate) = forceNeg(Case,Node Coordinate)[0] → Number (Fx) | ||
forceFyNeg(Case,Node Coordinate) = forceNeg(Case,Node Coordinate)[1] → Number (Fy) | ||
forceFzNeg(Case,Node Coordinate) = forceNeg(Case,Node Coordinate)[2] → Number (Fz) | ||
forceMxNeg(Case,Node Coordinate) = forceNeg(Case,Node Coordinate)[3] → Number (Mx) | ||
forceMyNeg(Case,Node Coordinate) = forceNeg(Case,Node Coordinate)[4] → Number (My) | ||
forceMyNeg(Case,Node Coordinate) = forceNeg(Case,Node Coordinate)[5] → Number (Mz) | ||
Case : Object | Node Coordinate : List of Number | |
T=”AnalysisCase“ T=”Combination” | [X coordinate, Y coordinate, Z coordinate] → If you don't have direct access to the node object, you can pass in a coordinate as a list of 3 numbers (this only applies to nodes, will not work for finite element). OpenBrIM will find the node that is closest to the specified coordinate and return the results. | |
Extracting Concurrent Force
“Concurrent force” refers to a set of analysis results (in all DOFs) formed by obtaining the most critical outcome in a specific degree of freedom under a loading scenario. The following functions can be used to extract the maximum and minimum critical concurrent results for elements.
Positive Results
forceFxPosConc(Case,Element,Station) → List of Number ([Fx*,Fy,Fz,Mx,My,Mz]) critical Fx result and its concurrent results | ||
forceFyPosConc(Case,Element,Station) → List of Number ([Fx,Fy*,Fz,Mx,My,Mz]) critical Fy result and its concurrent results | ||
forceFzPosConc(Case,Element,Station) → List of Number ([Fx,Fy,Fz*,Mx,My,Mz]) critical Fz result and its concurrent results | ||
forceMxPosConc(Case,Element,Station) → List of Number ([Fx,Fy,Fz,Mx*,My,Mz]) critical Mx result and its concurrent results | ||
forceMyPosConc(Case,Element,Station) → List of Number ([Fx,Fy,Fz,Mx,My*,Mz]) critical My result and its concurrent results | ||
forceMzPosConc(Case,Element,Station) → List of Number ([Fx,Fy,Fz,Mx,My,Mz*]) critical Mz result and its concurrent results | ||
Case : Object | Element : Object | Station : Number |
T=”AnalysisCase“ T=”Combination” | T=”Node” T=”FELine” T=”FESurface” T=”FEComposite” | Node → Leave empty FELine → 0 for start edge, 1 for end edge FESurface → 0,1,2,4 for edge nodes FEComposite → The distance from the start point of FEComposite path |
forceFxPosConc(Case,Node Coordinate) → List of Number ([Fx*,Fy,Fz,Mx,My,Mz]) critical Fx result and its concurrent results | ||
forceFyPosConc(Case,Node Coordinate) → List of Number ([Fx,Fy*,Fz,Mx,My,Mz]) critical Fy result and its concurrent results | ||
forceFzPosConc(Case,Node Coordinate) → List of Number ([Fx,Fy,Fz*,Mx,My,Mz]) critical Fz result and its concurrent results | ||
forceMxPosConc(Case,Node Coordinate) → List of Number ([Fx,Fy,Fz,Mx*,My,Mz]) critical Mx result and its concurrent results | ||
forceMyPosConc(Case,Node Coordinate) → List of Number ([Fx,Fy,Fz,Mx,My*,Mz]) critical My result and its concurrent results | ||
forceMzPosConc(Case,Node Coordinate) → List of Number ([Fx,Fy,Fz,Mx,My,Mz*]) critical Mz result and its concurrent results | ||
Case : Object | Node Coordinate : List of Number | |
T=”AnalysisCase“ T=”Combination” | [X coordinate, Y coordinate, Z coordinate] → If you don't have direct access to the node object, you can pass in a coordinate as a list of 3 numbers (this only applies to nodes, will not work for finite element). OpenBrIM will find the node that is closest to the specified coordinate and return the results. | |
Negative Results
forceFxNegConc(Case,Element,Station) → List of Number ([Fx*,Fy,Fz,Mx,My,Mz]) critical Fx result and its concurrent results | ||
forceFyNegConc(Case,Element,Station) → List of Number ([Fx,Fy*,Fz,Mx,My,Mz]) critical Fy result and its concurrent results | ||
forceFzNegConc(Case,Element,Station) → List of Number ([Fx,Fy,Fz*,Mx,My,Mz]) critical Fz result and its concurrent results | ||
forceMxNegConc(Case,Element,Station) → List of Number ([Fx,Fy,Fz,Mx*,My,Mz]) critical Mx result and its concurrent results | ||
forceMyNegConc(Case,Element,Station) → List of Number ([Fx,Fy,Fz,Mx,My*,Mz]) critical My result and its concurrent results | ||
forceMzNegConc(Case,Element,Station) → List of Number ([Fx,Fy,Fz,Mx,My,Mz*]) critical Mz result and its concurrent results | ||
Case : Object | Element : Object | Station : Number |
T=”AnalysisCase“ T=”Combination” | T=”Node” T=”FELine” T=”FESurface” T=”FEComposite” | Node → Leave empty FELine → 0 for start edge, 1 for end edge FESurface → 0,1,2,4 for edge nodes FEComposite → The distance from the start point of FEComposite path |
forceFxNegConc(Case,Node Coordinate) → List of Number ([Fx*,Fy,Fz,Mx,My,Mz]) critical Fx result and its concurrent results | ||
forceFyNegConc(Case,Node Coordinate) → List of Number ([Fx,Fy*,Fz,Mx,My,Mz]) critical Fy result and its concurrent results | ||
forceFzNegConc(Case,Node Coordinate) → List of Number ([Fx,Fy,Fz*,Mx,My,Mz]) critical Fz result and its concurrent results | ||
forceMxNegConc(Case,Node Coordinate) → List of Number ([Fx,Fy,Fz,Mx*,My,Mz]) critical Mx result and its concurrent results | ||
forceMyNegConc(Case,Node Coordinate) → List of Number ([Fx,Fy,Fz,Mx,My*,Mz]) critical My result and its concurrent results | ||
forceMzNegConc(Case,Node Coordinate) → List of Number ([Fx,Fy,Fz,Mx,My,Mz*]) critical Mz result and its concurrent results | ||
Case : Object | Node Coordinate : List of Number | |
T=”AnalysisCase“ T=”Combination” | [X coordinate, Y coordinate, Z coordinate] → If you don't have direct access to the node object, you can pass in a coordinate as a list of 3 numbers (this only applies to nodes, will not work for finite element). OpenBrIM will find the node that is closest to the specified coordinate and return the results. | |
Extracting Stress
In finite element analysis (FEA), stress refers to the distribution of internal forces within a structure or a material due to external loads and constraints. Stress is a measure of how the material within a structure responds to applied forces or loads. It's typically represented as a tensor quantity with components that describe the forces acting along different directions within an infinitesimally small volume of the material. The most common types of stress considered in FEA include:
Normal Stress: This is the stress acting perpendicular to a plane. It's divided into two categories:
Tensile Stress: When the material is being pulled apart in opposite directions, causing elongation along the axis of the applied load.
Compressive Stress: When the material is being pushed together in opposite directions, causing contraction along the axis of the applied load.
Shear Stress: This is the stress that acts parallel to a plane, causing one part of the material to slide against an adjacent part. Shear stress is further divided into:
Shear in X-Y Plane: Stress acting in the XY plane and causing deformation along the Z-axis.
Shear in Y-Z Plane: Stress acting in the YZ plane and causing deformation along the X-axis.
Shear in Z-X Plane: Stress acting in the ZX plane and causing deformation along the Y-axis.
In FEA, stress analysis involves calculating these stresses at various points within each finite element. OpenBrIM calculates the stressess at extreme points for non-composite (4 points) and composite sections (8 points) with the following functions that are tabulated.
stress(Case,Element,station) → List of Number ([Axial Stress,Shear Stress in Y, Shear Stress in Z,|max stress|,stress at pt1,stress at pt2,stress at pt3,stress at pt4,stress at pt5,stress at pt6,stress at pt7,stress at pt8]) | ||
|---|---|---|
stressPos(Case,Element,station) → List of Number ([Axial Stress,Shear Stress in Y, Shear Stress in Z,|max stress|,stress at pt1,stress at pt2,stress at pt3,stress at pt4,stress at pt5,stress at pt6,stress at pt7,stress at pt8]) | ||
stressNeg(Case,Element,station) → List of Number ([Axial Stress,Shear Stress in Y, Shear Stress in Z,|max stress|,stress at pt1,stress at pt2,stress at pt3,stress at pt4,stress at pt5,stress at pt6,stress at pt7,stress at pt8]) | ||
Case : Object | Element : Object | Station : Number |
T=”AnalysisCase“ T=”Combination” | T=”FEComposite” | FEComposite → The distance from the start point of FEComposite path |
In the context of finite element analysis (FEA), an "envelope" usually refers to the concept of extracting the most critical or extreme values of a certain parameter or result from a set of simulation results. For example, in stress analysis, an "envelope analysis" or "stress envelope" might refer to identifying the maximum or minimum stress values within a structure across different load cases. This can help engineers determine the worst-case scenario for stress distribution, which is crucial for designing components that can withstand a range of operating conditions.
The following functions are designed to extract the stresses where the force action that is indicated in the function name is maximized.
Positive Results
stressFxPos(Case,Element,station) → List of Number ([Axial Stress,Shear Stress in Y,Shear Stress in Z,|max stress|,stress at pt1,stress at pt2,stress at pt3,stress at pt4,stress at pt5,stress at pt6,stress at pt7,stress at pt8]) | ||
|---|---|---|
stressFyPos(Case,Element,station) → List of Number ([Axial Stress,Shear Stress in Y, Shear Stress in Z,|max stress|,stress at pt1,stress at pt2,stress at pt3,stress at pt4,stress at pt5,stress at pt6,stress at pt7,stress at pt8]) | ||
stressFzPos(Case,Element,station) → List of Number ([Axial Stress,Shear Stress in Y,Shear Stress in Z,|max stress|,stress at pt1,stress at pt2,stress at pt3,stress at pt4,stress at pt5,stress at pt6,stress at pt7,stress at pt8]) | ||
stressMxPos(Case,Element,station) → List of Number ([Axial Stress,Shear Stress in Y,Shear Stress in Z,|max stress|,stress at pt1,stress at pt2,stress at pt3,stress at pt4,stress at pt5,stress at pt6,stress at pt7,stress at pt8]) | ||
stressMyPos(Case,Element,station) → List of Number ([Axial Stress,Shear Stress in Y,Shear Stress in Z,|max stress|,stress at pt1,stress at pt2,stress at pt3,stress at pt4,stress at pt5,stress at pt6,stress at pt7,stress at pt8]) | ||
stressMzPos(Case,Element,station) → List of Number ([Axial Stress,Shear Stress in Y,Shear Stress in Z,|max stress|,stress at pt1,stress at pt2,stress at pt3,stress at pt4,stress at pt5,stress at pt6,stress at pt7,stress at pt8]) | ||
Case : Object | Element : Object | Station : Number |
T=”AnalysisCase“ T=”Combination” | T=”FEComposite” | FEComposite → The distance from the start point of FEComposite path |
Negative Results
stressFxNeg(Case,Element,station) → List of Number ([Axial Stress,Shear Stress in Y,Shear Stress in Z,|max stress|,stress at pt1,stress at pt2,stress at pt3,stress at pt4,stress at pt5,stress at pt6,stress at pt7,stress at pt8]) | ||
|---|---|---|
stressFyNeg(Case,Element,station) → List of Number ([Axial Stress,Shear Stress in Y,Shear Stress in Z,|max stress|,stress at pt1,stress at pt2,stress at pt3,stress at pt4,stress at pt5,stress at pt6,stress at pt7,stress at pt8]) | ||
stressFzNeg(Case,Element,station) → List of Number ([Axial Stress,Shear Stress in Y,Shear Stress in Z,|max stress|,stress at pt1,stress at pt2,stress at pt3,stress at pt4,stress at pt5,stress at pt6,stress at pt7,stress at pt8]) | ||
stressMxNeg(Case,Element,station) → List of Number ([Axial Stress,Shear Stress in Y,Shear Stress in Z,|max stress|,stress at pt1,stress at pt2,stress at pt3,stress at pt4,stress at pt5,stress at pt6,stress at pt7,stress at pt8]) | ||
stressMyNeg(Case,Element,station) → List of Number ([Axial Stress,Shear Stress in Y,Shear Stress in Z,|max stress|,stress at pt1,stress at pt2,stress at pt3,stress at pt4,stress at pt5,stress at pt6,stress at pt7,stress at pt8]) | ||
stressMzNeg(Case,Element,station) → List of Number ([Axial Stress,Shear Stress in Y,Shear Stress in Z,|max stress|,stress at pt1,stress at pt2,stress at pt3,stress at pt4,stress at pt5,stress at pt6,stress at pt7,stress at pt8]) | ||
Case : Object | Element : Object | Station : Number |
T=”AnalysisCase“ T=”Combination” | T=”FEComposite” | FEComposite → The distance from the start point of FEComposite path |