...
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 Force
...
dispPos(Case,Element) → List of Number ([Tx,Ty,Tz,Rx,Ry,Rz])
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 Force 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. |
...
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
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. | |
...
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. | |
...