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
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]) | |
|---|---|
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
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
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
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
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
Positive Results
stressFxPos(Case,Element,station) → List of Number ([Axial Stress,Shear Stress in Y, Stress,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, Stress,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, Stress,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, Stress,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, Stress,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, Stress,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, Stress,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, Stress,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, Stress,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, Stress,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, Stress,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, Stress,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 |
0 Comments