Skip to content

OpenSeesMatlabCmds

All OpenSees commands use the same input format as OpenSees and OpenSeesPy. For example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
opsMat = OpenSeesMatlab();  % Get Instance
ops = opsmat.opensees;  % Get the OpenSees command interface

ops.wipe();
ops.model('basic', '-ndm', 2, '-ndf', 3);
...
ops.node(1, 0.0, 0.0);
ops.node(2, 5.0, 0.0);
ops.fix(1, 1, 1, 1);
ops.element(...);

For details, please refer to their official documentation, You can call it in the same way.

OpenSeesPy

OpenSees

OpenSees Command Manual

📌 A few notes:

  • ✨ Both char and string inputs are supported. However, using char is recommended.

  • ✨ Most commands accept scalar arguments only and do not support passing a numeric array directly. Please pass scalar arguments one by one.

    To unpack a cell array, use {:} expansion:

    1
    ops.node(1, coords{:});         % coords is a cell array

    To unpack a numeric array, convert to cell first:

    1
2
    coords = num2cell(coords);
ops.node(1, coords{:});

    The following commands are exceptions and do support numeric array and cell array inputs, which are flattened automatically (Since OpenSeesMatlab v3.8.0.1):

    node, element, eleLoad, geomTransf, uniaxialMaterial, nDMaterial, equalDOF, equationConstraint, rigidDiaphragm, rigidLink, fix, fixX, fixY, fixZ, section, fiber, layer, patch, load, mass, rayleigh, ShallowFoundationGen, block2D, block3D, setNodeDisp, setNodeVel, setNodeAccel, frictionModel, region, setElementRayleighDampingFactors, setElementRayleighFactors, recorder , and timeSeries (Path type only: numeric array accepted for -values and -time )

  • ✨ Commands with return values will return MATLAB data. If a command has no return value, an empty array [] will be returned.

  • ✨ The additional post-processing provided by OpenSeesMatlab may be slow or buggy. If you think so, you can use only the OpenSees command interface and use recorder or other output commands to post-process the analysis results.

ops.OpenSeesMatlabCmds ¤

Bases: ops.OpenSeesMatlabBase

OpenSees command interface used by OpenSeesMatlab.

OpenSeesMatlabCmds exposes MATLAB methods that forward OpenSees commands to the configured OpenSees MATLAB MEX module. Most command wrappers are inherited from OpenSeesMatlabBase and follow the same argument order as OpenSees/OpenSeesPy where possible.

Users normally access this class through the opensees property of an OpenSeesMatlab object:

1
2
  opsmat = OpenSeesMatlab();
  ops = opsmat.opensees;
References

OpenSeesPy documentation: https://openseespydoc.readthedocs.io/en/latest/index.html

OpenSees documentation: https://opensees.github.io/OpenSeesDocumentation/

Methods:

  • wipe –

    Wipe the OpenSees model.

  • model –

    Set the default model dimensions and number of dofs.

  • node –

    Create an OpenSees node.

  • element –

    Define an OpenSees element.

  • fix –

    Create a homogeneous single-point (SP) constriant.

  • fixX –

    Fix a node along the X direction.

  • fixY –

    Fix a node along the Y direction.

  • fixZ –

    Fix a node along the Z direction.

  • equalDOF –

    Create a multi-point constraint between nodes.

  • equalDOF_Mixed –

    Define a mixed equalDOF constraint between two nodes.

  • rigidLink –

    Defines a rigid link between two nodes using the specified link type.

  • rigidDiaphragm –

    Define a rigid diaphragm constraint between a reference node and a set of constraint nodes.

  • timeSeries –

    This command is used to construct a TimeSeries object which represents the relationship between the time in the domain, t, and the load factor applied to the loads, 𝜆, in the load pattern with which the TimeSeries object is associated, i.e. 𝜆 =𝐹(𝑡).

  • pattern –

    Define an OpenSees load pattern. Each LoadPattern in OpenSees has a TimeSeries associated with it. In addition it may contain ElementLoads, NodalLoads and SinglePointConstraints. Some of these SinglePoint constraints may be associated with GroundMotions.

  • load –

    This command is used to construct a NodalLoad object and add it to the enclosing LoadPattern.

  • eleLoad –

    The eleLoad command is used to construct an ElementalLoad object and add it to the enclosing LoadPattern.

  • loadConst –

    Apply a load that does not change with time.

  • sp –

    Apply a single-point load to a node.

  • groundMotion –

    This command is used to construct a GroundMotion object.

  • imposedMotion –

    This command is used to impose a ground motion on a node.

  • mass –

    This command is used to set the mass at a node, replacing any previously defined mass at the node.

  • region –

    The region command is used to label a group of nodes and elements. This command is also used to assign rayleigh damping parameters to the nodes and elements in this region. The region is specified by either elements or nodes, not both. If elements are defined, the region includes these elements and the all connected nodes, unless the -eleOnly option is used in which case only elements are included. If nodes are specified, the region includes these nodes and all elements of which all nodes are prescribed to be in the region, unless the -nodeOnly option is used in which case only the nodes are included.

  • rayleigh –

    This command is used to assign damping to all previously-defined elements and nodes. When using rayleigh damping in OpenSees, the damping matrix for an element or node, D is specified as a combination of stiffness and mass-proportional damping matrices:

  • modalDamping –

    The following is used to assign the modal damping model to the model. eigen command needs to be called first.

  • damping –

    The following is used to assign the damping model to a specific element. The user should append the parameters of '-damp', dampingTag to the end of the element definition.

  • block2D –

    Create mesh of quadrilateral elements.

  • block3D –

    Create mesh of cubic elements.

  • beamIntegration –

    Define a beam integration rule. A wide range of numerical integration options are available in OpenSees to represent distributed plasticity or non-prismatic section details in Beam-Column Elements, i.e., across the entire element domain [0, L].

  • uniaxialMaterial –

    This command is used to construct a UniaxialMaterial object which represents uniaxial stress-strain (or force-deformation) relationships.

  • nDMaterial –

    This command is used to construct an NDMaterial object which represents the stress-strain relationship at the gauss-point of a continuum element.

  • section –

    This command is used to construct a Section object which represents the section geometry of a beam element.

  • fiber –

    This command allows the user to construct a single fiber and add it to the enclosing FiberSection or NDFiberSection.

  • patch –

    The patch command is used to generate a number of fibers over a cross-sectional area. Currently there are three types of cross-section that fibers can be generated: quadrilateral, rectangular and circular.

  • layer –

    The layer command is used to generate a number of fibers along a line or a circular arc.

  • frictionModel –

    The frictionModel command is used to construct a friction model object, which specifies the behavior of the coefficient of friction in terms of the absolute sliding velocity and the pressure on the contact area. The command has at least one argument, the friction model type.

  • geomTransf –

    The geometric-transformation command is used to construct a coordinate-transformation (CrdTransf) object, which transforms beam element stiffness and resisting force from the basic system to the global-coordinate system. The command has at least one argument, the transformation type.

  • remove –

    This command is used to remove an object from the model.

  • setCreep –

    Set the creep parameter for the model.

  • constraints –

    This command is used to construct the ConstraintHandler object. The ConstraintHandler object determines how the constraint equations are enforced in the analysis. Constraint equations enforce a specified value for a DOF, or a relationship between DOFs.

  • numberer –

    This command is used to construct the DOF_Numberer object. The DOF_Numberer object determines the mapping between equation numbers and degrees-of-freedom – how degrees-of-freedom are numbered.

  • system –

    This command is used to construct the LinearSOE and LinearSolver objects to store and solve the system of equations in the analysis.

  • test –

    This command is used to construct the LinearSOE and LinearSolver objects to store and solve the test of equations in the analysis.

  • algorithm –

    Set the algorithm for the analysis.

  • integrator –

    This command is used to construct the Integrator object. The Integrator object determines the meaning of the terms in the system of equation object Ax=B.

  • analysis –

    Set the analysis type.

  • analyze –

    Run the analysis.

  • eigen –

    Run an eigenvalue analysis.

  • modalProperties –

    This command is used to compute the modal properties of a model after an eigen command.

  • responseSpectrumAnalysis –

    This command is used to perform a response spectrum analysis on a model.

  • wipeAnalysis –

    This command is used to destroy all components of the Analysis object, i.e. any objects created with system, numberer, constraints, integrator, algorithm, and analysis commands.

  • record –

    This command is used to cause all the recorders to do a record on the current state of the model.

  • recorder –

    This command is used to generate a recorder object which is to monitor what is happening during the analysis and generate output for the user.

  • nodeDisp –

    Get nodal displacement.

  • nodeVel –

    Get nodal velocity.

  • nodeAccel –

    Get nodal acceleration.

  • nodeCoord –

    Get nodal coordinate.

  • nodeBounds –

    Get the boundary of all nodes. Return a list of boundary values.

  • nodeEigenvector –

    Returns the eigenvector at a specified node.

  • nodeDOFs –

    Returns the DOF numbering of a node.

  • nodeMass –

    Returns the mass at a specified node.

  • nodePressure –

    Returns the pressure at a specified node.

  • nodeReaction –

    Returns the reaction at a specified node. Must call reactions() command before this command.

  • reactions –

    Calculate the reactions. Call this command before the nodeReaction() command.

  • nodeResponse –

    Returns the responses at a specified node. To get reactions (id=6), must call the reactions command before this command.

  • nodeUnbalance –

    Returns the unbalance at a specified node.

  • basicDeformation –

    Returns the deformation of the basic system for a beam-column element.

  • basicForce –

    Returns the force of the basic system for a beam-column element.

  • basicStiffness –

    Returns the stiffness of the basic system for a beam-column element. A vector of values in row order will be returned.

  • eleDynamicalForce –

    Returns the elemental dynamic force.

  • eleForce –

    Returns the elemental resisting force.

  • eleNodes –

    Returns the nodes of the element.

  • eleResponse –

    This command is used to obtain the same element quantities as those obtained from the element recorder at a particular time step.

  • getEleTags –

    Get all elements in the domain or in a mesh.

  • getNodeTags –

    Get all nodes in the domain or in a mesh.

  • getLoadFactor –

    Get the load factor for a given pattern tag.

  • getTime –

    Get the current time in the domin.

  • setTime –

    This command is used to set the pseudo-time of the analysis.

  • sectionForce –

    Returns the section force for a beam-column element. The dof of the section depends on the section type. Please check with the section manual.

  • sectionDeformation –

    Returns the section deformation for a beam-column element. The dof of the section depends on the section type. Please check with the section manual.

  • sectionStiffness –

    Returns the section stiffness matrix for a beam-column element. A list of values in the row order will be returned.

  • sectionFlexibility –

    Returns the section flexibility matrix for a beam-column element. A list of values in the row order will be returned.

  • sectionLocation –

    Returns the section location for a beam-column element.

  • sectionWeight –

    Returns the weights of integration points of a section for a beam-column element.

  • systemSize –

    Return the system size.

  • numIter –

    Return the number of iterations.

  • testIter –

    Returns the number of iterations the convergence test took in the last analysis step

  • testNorm –

    Returns the norms from the convergence test for the last analysis step.

  • testUniaxialMaterial –

    Set the uniaxial material tag and test it.

  • setStrain –

    Set the strain and test the uniaxial material specified by testUniaxialMaterial.

  • getStrain –

    Returns the strain of the uniaxial material specified by testUniaxialMaterial.

  • getStress –

    Returns the stress of the uniaxial material specified by testUniaxialMaterial.

  • getTangent –

    Returns the tangent modulus of the uniaxial material specified by testUniaxialMaterial.

  • getDampTangent –

    Returns the damping tangent modulus of the uniaxial material specified by testUniaxialMaterial.

  • reset –

    Reset the model.

wipe ¤

()

Wipe the OpenSees model.

model ¤

(modelType, varargin)

Set the default model dimensions and number of dofs.

Syntax 
1
2
3
model()
model('basic', '-ndm', 2)
model('basic', '-ndm', 2, '-ndf', 3)

Input arguments:

  • modelType (char | string) –

    Model type (default: 'basic')

  • ndm (int) –

    Number of spatial dimensions. Style ('-ndm', ndm) is needed.

  • ndf (int) –

    Number of degrees of freedom (default sets it to ndm*(ndm+1)/2). Style ('-ndf', ndf) is needed.

node ¤

(nodeTag, varargin)

Create an OpenSees node.

Syntax 
1
2
3
4
5
ops.node(nodeTag, x, y)
ops.node(nodeTag, x, y, z)
ops.node(nodeTag, x, y, z, '-ndf', ndf)
ops.node(nodeTag, x, y, z, '-mass', m1, m2, m3)
ops.node(nodeTag, [x, y, z], '-mass', [m1, m2, m3])

Input arguments:

  • nodeTag –

    Node tag.

  • crds –

    Nodal coordinates, multiple scalars or a double vector is supported.

  • ndf –

    Number of degrees of freedom. Style ('-ndf', ndf) is needed.

  • mass –

    Nodal mass vector. Style ('-mass', m1, m2, m3, ...) is needed.

  • vel –

    Initial velocity vector. Style ('-vel', v1, v2, v3, ...) is needed.

  • disp –

    Initial displacement vector. Style ('-disp', d1, d2, d3, ...) is needed.

  • dispLoc –

    Displacement location. Style ('-dispLoc', loc1, loc2, loc3, ...) is needed.

  • temp –

    Initial temperature. Style ('-temp', temp) is needed.

element ¤

(eleType, eleTag, varargin)

Define an OpenSees element. Every element has its own type, tag, nodes, and arguments.

See also in element commands

Example 
1
2
3
4
5
6
7
eleType = 'truss';
eleTag = 1;
eleNodes = [iNode, jNode];
eleArgs = {A, matTag};
element(eleType, eleTag, eleNodes, eleArgs{:});
% Or
element(eleType, eleTag, iNode, jNode, A, matTag);

Input arguments:

  • eleType –

    Element type.

  • eleTag –

    Element tag.

  • eleNodes –

    Element nodes.

  • eleArgs –

    Element arguments.

fix ¤

(nodeTag, constrValues)

Create a homogeneous single-point (SP) constriant.

Syntax 
1
2
fix(nodeTag, 1, 1, 1)
fix(nodeTag, [1, 1, 1])

Input arguments:

  • nodeTag –

    Tag of node to be constrained.

  • constrValues –

    Constraint values to be applied.

    • 0: free
    • 1: fixed

fixX ¤

(x, varargin)

Fix a node along the X direction.

Input arguments:

  • x –

    X coordinate of node to be constrained.

  • constrValues –

    Constraint values to be applied.

    • 0: free
    • 1: fixed
  • tol –

    Tolerance for constraint satisfaction. Style ("-tol", tol) is needed.

fixY ¤

(y, varargin)

Fix a node along the Y direction.

Input arguments:

  • y –

    Y coordinate of node to be constrained.

  • constrValues –

    Constraint values to be applied.

    • 0: free
    • 1: fixed
  • tol –

    Tolerance for constraint satisfaction. Style ("-tol", tol) is needed.

fixZ ¤

(z, varargin)

Fix a node along the Z direction.

Input arguments:

  • z –

    Z coordinate of node to be constrained.

  • constrValues –

    Constraint values to be applied.

    • 0: free
    • 1: fixed
  • tol –

    Tolerance for constraint satisfaction. Style ("-tol", tol) is needed.

equalDOF ¤

(rNodeTag, cNodeTag, dofs)

Create a multi-point constraint between nodes.

Example 
1
2
equalDOF(1, 2, [1 2 3 4 5 6]);
equalDOF(1, 3, 1, 2, 3);

Input arguments:

  • rNodeTag –

    Integer tag identifying the retained, or primary node.

  • cNodeTag –

    Integer tag identifying the constrained, or secondary node.

  • dofs –

    Nodal degrees-of-freedom that are constrained at the cNode to be the same as those at the rNode. Valid range is from 1 through ndf, the number of nodal degrees-of-freedom.

equalDOF_Mixed ¤

(rNodeTag, cNodeTag, numDOF, dofPairs)

Define a mixed equalDOF constraint between two nodes.

Examples:

1
2
equalDOF_Mixed(rNodeTag, cNodeTag, numDOF, [rdof1, cdof1, rdof2, cdof2, ...])
equalDOF_Mixed(rNodeTag, cNodeTag, numDOF, rdof1, cdof1, rdof2, cdof2, ...)

Input arguments:

  • rNodeTag (int) –

    Integer tag identifying the reference, or primary node.

  • cNodeTag (int) –

    Integer tag identifying the constrained, or secondary node.

  • numDOF (int) –

    Number of degrees-of-freedom to be constrained.

  • dofPairs (varargin(int)) –

    Nodal degrees-of-freedom that are constrained at the cNode to be the same as those at the rNode. Valid range is from 1 through ndf, the number of nodal degrees-of-freedom. rcdofs = [rdof1, cdof1, rdof2, cdof2, ...]

(linkType, rNodeTag, cNodeTag)

Defines a rigid link between two nodes using the specified link type.

Syntax: 
1
rigidLink(linkType, rNodeTag, cNodeTag)

Input arguments:

  • linkType –

    String-based argument for rigid-link type:

    • 'bar': only the translational degree-of-freedom will be constrained to be exactly the same as those at the master node
    • 'beam': both the translational and rotational degrees of freedom are constrained.
  • rNodeTag –

    Integer tag identifying the retained (primary) node.

  • cNodeTag –

    Integer tag identifying the constrained (secondary) node.

rigidDiaphragm ¤

(perpDirn, rNodeTag, cNodeTags)

Define a rigid diaphragm constraint between a reference node and a set of constraint nodes.

Example: 
1
rigidDiaphragm(1, 2, 3, 4, 5)

Input arguments:

  • perpDirn –

    The direction perpendicular to the rigid plane (i.e. direction 3 corresponds to the 1-2 plane).

  • rNodeTag –

    Integer tag identifying the retained (primary) node.

  • cNodeTags –

    The integar tags identifying the constrained (secondary) nodes.

timeSeries ¤

(tsType, tsTag, tsArgs)

This command is used to construct a TimeSeries object which represents the relationship between the time in the domain, t, and the load factor applied to the loads, 𝜆, in the load pattern with which the TimeSeries object is associated, i.e. 𝜆 =𝐹(𝑡).

See Also

timeSeries commands

Input arguments:

  • tsType (str) –

    Type of time series to construct.

  • tsTag (int) –

    Tag identifying the time series.

  • tsArgs (varargin) –

    Additional arguments for the time series.

pattern ¤

(patternType, patternTag, patternArgs)

Define an OpenSees load pattern. Each LoadPattern in OpenSees has a TimeSeries associated with it. In addition it may contain ElementLoads, NodalLoads and SinglePointConstraints. Some of these SinglePoint constraints may be associated with GroundMotions.

See also 
1
[pattern commands](https://openseespydoc.readthedocs.io/en/latest/src/pattern.html)

Input arguments:

  • patternType (str) –

    Type of pattern to construct. Options are 'Plain', 'UniformExcitation', or 'MultipleSupport'.

  • patternTag (int) –

    Tag identifying the pattern.

  • patternArgs (varargin) –

    Additional arguments for the pattern.

load ¤

(nodeTag, varargin)

This command is used to construct a NodalLoad object and add it to the enclosing LoadPattern.

Syntax 
1
2
load(nodeTag, -1, -1, -1);
load(nodeTag, -1, -1, -1, '-pattern', patternTag);
Note

The load values are reference loads values. It is the time series that provides the load factor. The load factor times the reference values is the load that is actually applied to the node.

Input arguments:

  • nodeTag –

    The tag of the node to which the load is applied.

  • loadValues –

    The load values to apply to the node.

  • varargin (cell) –

    Additional arguments to pass to OpenSees.

    • if '-const' is specified, the load is applied as a constant load.
    • if {'-pattern', patternTag} is specified, the load is applied to this pattern.

eleLoad ¤

(varargin)

The eleLoad command is used to construct an ElementalLoad object and add it to the enclosing LoadPattern.

Input arguments:

  • eleTags –

    Tag of the element to which the load is applied. Pairs style ('-ele', eleTag1, eleTag2, ...) is necessary.

  • eleRange –

    Range of element tags to which the load is applied. Pairs style ('-range', eleTag1, eleTag2) is necessary.

  • loadType –

    Type of load to apply. Pairs style ('-type', loadType) is necessary.

    • beamUniform: Uniform beam load. Pairs style ('-type', '-beamUniform', Wy, <Wz>, Wx=0.0) is necessary. Wy is the load along the local y-axis, Wz is the load along the local z-axis (required only for 3D), and Wx is the load along the local x-axis.
    • beamPoint: Point load at a specific fiber location. Pairs style ('-type', '-beamPoint', Py, <Pz>, xL, Px=0.0) is necessary. Py is the load along the local y-axis, Pz is the load along the local z-axis (required only for 3D), xL is the fiber location along the local x-axis (0-1), and Px is the load along the local x-axis.
    • surfaceLoad: Surface load. Pairs style ('-type', '-surfaceLoad') is necessary. You need define the SurfaceLoad or TriSurfaceLoad element in advance, and pass the element tag to this command. See also How to Apply Surface Loads
    • selfWeight: Self-weight load implemented for all continuum elements. Pairs style ('-type', '-selfWeight', xf, yf, <zf>) is necessary, xf, yf, zf are the body force components. See also Do It Your Self-Weight and Element Self-Weight. The element implementations of the addLoad() method handle the self-weight calculations–no script pre-processing necessary.
    • beamThermal: Thermal load. Pairs style ('-type', '-beamThermal', T1, y1, T2, y2, ..., T9, y9) is necessary. Each point (T1, y1) define a temperature and location. This command may accept 2,5 or 9 temperature points.
    • shellThermal: Thermal load for shell elements. Pairs style ('-type', '-shellThermal', T1, y1, T2, y2,) is necessary. Each point (T1, y1) define a temperature and location. This command only accept 2 temperature points in the current version.
Note
  1. The load values are reference load values, it is the time series that provides the load factor. The load factor times the reference values is the load that is actually applied to the element.
  2. At the moment, eleLoads do not work with 3D beam-column elements if Corotational geometric transformation is used.

loadConst ¤

(varargin)

Apply a load that does not change with time.

Input arguments:

  • varargin (varargin{any}) –

    Optional parameters for loadConst command. If '-time', value is provided, the time reset to value.

sp ¤

(nodeTag, dof, dofValue, varargin)

Apply a single-point load to a node.

Note

The dofValue is a reference value, it is the time series that provides the load factor. The load factor times the reference value is the constraint that is actually applied to the node.

Input arguments:

  • nodeTag (int) –

    The tag of the node to which the load is applied.

  • dof (int) –

    The degree of freedom to which the load is applied (1 through ndf).

  • dofValue (numeric) –

    The reference value of the load.

  • varargin (cell) –

    Additional arguments to pass to OpenSees.

    • if '-const' is specified, the load is applied as a constant load.
    • if '-subtractInit' is specified, allow user to ignore init disp values at the node.
    • if {'-pattern', patternTag} is specified, the load is applied to this pattern.

groundMotion ¤

(gmTag, gmType, varargin)

This command is used to construct a GroundMotion object.

Syntax 
1
2
groundMotion(gmTag, 'Plain', '-accel', accelSeriesTag, '-int', 'Trapezoidal', '-fact', factor)
groundMotion(gmTag, 'Interpolated', gmTag1, gmTag2, ..., '-fact', factor1, factor2, ...)

Input arguments:

  • gmTag (int) –

    Tag identifying the ground motion.

  • gmType (str) –

    Type of ground motion. Must be one of {'Plain', 'Interpolated'}.

    • 'Plain' : This command is used to construct a plain GroundMotion object. Each GroundMotion object is associated with a number of TimeSeries objects, which define the acceleration, velocity and displacement records for that ground motion.
    • 'Interpolated' : Constructs an interpolated GroundMotion object with acceleration, velocity and displacement records defined by the provided TimeSeries objects.

imposedMotion ¤

(nodeTag, dof, gmTag)

This command is used to impose a ground motion on a node.

Syntax 
1
ops.imposedMotion(nodeTag, dof, gmTag)

Input arguments:

  • nodeTag (int) –

    The tag of the node to which the ground motion is imposed.

  • dof (int) –

    The degree of freedom of the node to which the ground motion is imposed. Valid range is from 1 through ndf at node.

  • gmTag (int) –

    The tag of the ground motion to impose.

mass ¤

(nodeTag, massValues)

This command is used to set the mass at a node, replacing any previously defined mass at the node.

Syntax

mass(obj, nodeTag, massValues)

Input arguments:

  • nodeTag (int) –

    The tag of the node to which the mass is applied.

  • massValues (double) –

    The mass values to apply to the node.

region ¤

(regTag, varargin)

The region command is used to label a group of nodes and elements. This command is also used to assign rayleigh damping parameters to the nodes and elements in this region. The region is specified by either elements or nodes, not both. If elements are defined, the region includes these elements and the all connected nodes, unless the -eleOnly option is used in which case only elements are included. If nodes are specified, the region includes these nodes and all elements of which all nodes are prescribed to be in the region, unless the -nodeOnly option is used in which case only the nodes are included.

See also region command

Input arguments:

  • regTag –

    Unique integer tag for the region.

  • eles –

    Tags of selected elements in domain to be included in region (optional). Style '-ele', ele1, ele2, ... or '-eleOnly', ele1, ele2, ... is necessary.

  • nodes –

    Tags of selected nodes in domain to be included in region (optional). Style '-node', node1, node2, ... or '-nodeOnly', node1, node2, ... is necessary.

  • eleRange –

    Range of element tags to include in region (optional). Style '-eleRange', startEle, endEle or '-eleOnlyRange', startEle, endEle is necessary.

  • nodeRange –

    Range of node tags to include in region (optional). Style '-nodeRange', startNode, endNode or '-nodeOnlyRange', startNode, endNode is necessary.

  • Rayleigh –

    Rayleigh damping factors (optional). Style '-rayleigh', alphaM, betaK, betaKinit, betaKcomm is necessary.

Note

The user cannot prescribe the region by BOTH elements and nodes.

rayleigh ¤

(alphaM, betaK, betaKinit, betaKcomm)

This command is used to assign damping to all previously-defined elements and nodes. When using rayleigh damping in OpenSees, the damping matrix for an element or node, D is specified as a combination of stiffness and mass-proportional damping matrices:

\[ 𝐷=\alpha_𝑀∗𝑀+\beta_𝐾∗𝐾_{curr}+\beta_{K_{init}}*K_{init}+\beta_{K_{commit}}*K_{commit} \]
See also

Input arguments:

  • alphaM ((1,1) {mustBeNumeric}) –

    Mass proportional damping factor for the mass matrix.

  • betaK ((1,1) {mustBeNumeric}) –

    Stiffness proportional damping factor for the current stiffness matrix.

  • betaKinit ((1,1) {mustBeNumeric}) –

    Stiffness proportional damping factor for the initial stiffness matrix.

  • betaKcomm ((1,1) {mustBeNumeric}) –

    Stiffness proportional damping factor for the committed stiffness matrix.

modalDamping ¤

(factors)

The following is used to assign the modal damping model to the model. eigen command needs to be called first.

See also

Input arguments:

  • factors (varargin{mustBeNumeric}) –

    Modal damping factors, its number must equals 1 or the length of eigen modes.

Warning

Modal damping implementation is as in Perform3D. The tangent matrix is not modified for damping terms as this would result in a full matrix. Instead just the right hand side of the equation, i.e. the resisting force vector is modified. As a consequence, iteration is required at each step to obtain a converged solution, i.e. no Linear solution algorithm or explicit time stepping algorithms will work correctly with modal damping!

damping ¤

(dampingType, dampingTag, dampingArgs)

The following is used to assign the damping model to a specific element. The user should append the parameters of '-damp', dampingTag to the end of the element definition.

See also

Input arguments:

  • dampingType –

    The type of damping model to use. Must be one of 'Uniform', 'SecStif', 'URD', or 'URDbeta'.

  • dampingTag –

    The tag of the damping model to use.

  • dampingArgs –

    Additional arguments to pass to the damping model.

block2D ¤

(numX, numY, startNode, startEle, eleType, varargin)

Create mesh of quadrilateral elements.

Input arguments:

  • numX (int) –

    Number of elements in the x-direction

  • numY (int) –

    Number of elements in the y-direction

  • startNode (int) –

    Starting node tag

  • startEle (int) –

    Starting element tag

  • eleType (str) –

    Element type ('quad', 'shell', 'bbarQuad', 'enhancedQuad', or 'SSPquad')

  • eleArgs –

    Additional element properties

  • crds –

    coordinates of the block elements with the format:

block3D ¤

(numX, numY, numZ, startNode, startEle, eleType, varargin)

Create mesh of cubic elements.

Input arguments:

  • numX (int) –

    Number of elements in the x-direction.

  • numY (int) –

    Number of elements in the y-direction.

  • numZ (int) –

    Number of elements in the z-direction.

  • startNode (int) –

    Starting node tag.

  • startEle (int) –

    Starting element tag.

  • eleType (str) –

    Element type ('stdBrick', 'bbarBrick', 'SSPbrick')

  • eleArgs –

    Additional element properties

  • crds –

    coordinates of the block elements with the format:

beamIntegration ¤

(integType, tag, varargin)

Define a beam integration rule. A wide range of numerical integration options are available in OpenSees to represent distributed plasticity or non-prismatic section details in Beam-Column Elements, i.e., across the entire element domain [0, L].

See also

Input arguments:

  • integType (str) –

    The integration type.

  • tag (int) –

    The integration rule tag.

  • varargin (cell) –

    Additional integration rule parameters. Every integration type requires specific parameters.

uniaxialMaterial ¤

(matType, matTag, matArgs)

This command is used to construct a UniaxialMaterial object which represents uniaxial stress-strain (or force-deformation) relationships.

See also

Input arguments:

  • matType (str) –

    The material type.

  • tag (int) –

    The material tag.

  • matArgs (cell) –

    Additional material parameters. Every material type requires specific parameters.

nDMaterial ¤

(matType, matTag, matArgs)

This command is used to construct an NDMaterial object which represents the stress-strain relationship at the gauss-point of a continuum element.

See also

Input arguments:

  • matType (str) –

    The material type.

  • matTag (int) –

    The material tag.

  • matArgs (cell) –

    Additional material parameters. Every material type requires specific parameters.

section ¤

(secType, secTag, secArgs)

This command is used to construct a Section object which represents the section geometry of a beam element.

See also in section commands (Python) and section commands (Tcl)

Input arguments:

  • secType (str) –

    The section type.

  • secTag (int) –

    The section tag.

  • secArgs (cell) –

    Additional section parameters. Every section type requires specific parameters.

fiber ¤

(yloc, zloc, A, matTag)

This command allows the user to construct a single fiber and add it to the enclosing FiberSection or NDFiberSection.

Input arguments:

  • yloc (double) –

    Fiber y-location.

  • zloc (double) –

    Fiber z-location.

  • A (double) –

    Fiber area.

  • matTag (int) –

    Material tag associated with this fiber (UniaxialMaterial tag for a FiberSection and NDMaterial tag for use in an NDFiberSection).

Output arguments:

  • varargout –

    Outputs returned by the underlying OpenSees MEX command, if any.

patch ¤

(patchType, matTag, varargin)

The patch command is used to generate a number of fibers over a cross-sectional area. Currently there are three types of cross-section that fibers can be generated: quadrilateral, rectangular and circular.

See Also

Input arguments:

  • patchType (str) –

    The type of patch to generate. Must be one of 'rect', 'quad', or 'circ'.

  • matTag (int) –

    The tag of the material to use for the patch.

  • varargin (varargin) –

    Additional arguments to pass to the patch command. Every patchType requires different arguments.

layer ¤

(layerType, matTag, varargin)

The layer command is used to generate a number of fibers along a line or a circular arc.

See Also

Input arguments:

  • layerType (str) –

    The type of layer to generate. Must be one of 'straight', 'circ', or 'rect'.

  • matTag (int) –

    The tag of the material to use for the layer.

  • varargin (varargin) –

    Additional arguments to pass to the layer command. Every layerType requires different arguments.

frictionModel ¤

(frnType, frnTag, frnArgs)

The frictionModel command is used to construct a friction model object, which specifies the behavior of the coefficient of friction in terms of the absolute sliding velocity and the pressure on the contact area. The command has at least one argument, the friction model type.

See also

Input arguments:

  • frnType (str) –

    The friction type. Must be one of the following: 'Coulomb', 'VelDependent', 'VelPressureDep', 'VelDepMultiLinear', 'VelNormalFrcDep'.

  • frnTag (int) –

    The friction tag.

  • frnArgs (varargin) –

    Additional arguments for the friction model. Every frnType requires different arguments.

geomTransf ¤

(transfType, transfTag, transfArgs)

The geometric-transformation command is used to construct a coordinate-transformation (CrdTransf) object, which transforms beam element stiffness and resisting force from the basic system to the global-coordinate system. The command has at least one argument, the transformation type.

See also

Input arguments:

  • transfType (str) –

    The transformation type.

  • transfTag (int) –

    The transformation tag.

  • transfArgs (varargin) –

    Additional arguments for the transformation.

remove ¤

(objectType, args)

This command is used to remove an object from the model.

Input arguments:

  • objectType –

    The type of object to remove. Must be one of the following: node, element, pattern, parameter, recorders, recorder, timeSeries, SPconstraint, MPconstraint.

  • args –

    Additional arguments for the object to remove.

    • node: removes a node from the model, remove('node', nodeTag).
    • element: removes an element from the model, remove('element', eleTag).
    • pattern: removes a load pattern from the model, remove('pattern', patternTag).
    • parameter: removes a parameter from the model, remove('parameter', paramTag).
    • recorders: removes all recorders from the model, remove('recorders').
    • recorder: removes a specific recorder from the model, remove('recorder', recorderTag).
    • timeSeries: removes a time series from the model, remove('timeSeries', timeSeriesTag).
    • SPconstraint: removes a single-point constraint from the model, remove('SPconstraint', spTag) or remove('SPconstraint', nodeTag, dofTag, <patternTag?>).
    • MPconstraint: removes a multi-point constraint from the model, remove('MPconstraint', cNodeTag) or remove('MPconstraint', '-tag', mpTag).

setCreep ¤

(value)

Set the creep parameter for the model.

Input arguments:

  • value (double) –

    The creep parameter value to set.

constraints ¤

(constraintType, constraintArgs)

This command is used to construct the ConstraintHandler object. The ConstraintHandler object determines how the constraint equations are enforced in the analysis. Constraint equations enforce a specified value for a DOF, or a relationship between DOFs.

See also

Input arguments:

  • constraintType (str) –

    The type of constraint handler to construct. Must be one of {'Plain', 'Penalty', 'Lagrange', 'Transformation', 'Auto'}.

  • constraintArgs (varargin) –

    Additional arguments for the constraint handler.

numberer ¤

(numbererType, numbererArgs)

This command is used to construct the DOF_Numberer object. The DOF_Numberer object determines the mapping between equation numbers and degrees-of-freedom – how degrees-of-freedom are numbered.

See also

Input arguments:

  • numbererType (str) –

    The type of numberer to construct. Must be one of {'Plain', 'RCM', 'AMD', 'ParallelPlain', 'ParallelRCM'}.

  • numbererArgs (varargin) –

    Additional arguments for the numberer.

system ¤

(systemType, systemArgs)

This command is used to construct the LinearSOE and LinearSolver objects to store and solve the system of equations in the analysis.

See also

Input arguments:

  • systemType (str) –

    The system type. One of {'BandGen', 'BandSPD', 'Diagonal', 'ProfileSPD', 'SuperLU', 'UmfPack', 'FullGeneral', 'SparseSYM'}

  • systemArgs (varargin) –

    Additional arguments for the system.

test ¤

(testType, testArgs)

This command is used to construct the LinearSOE and LinearSolver objects to store and solve the test of equations in the analysis.

See also

Input arguments:

  • testType (str) –

    The test type.

  • testArgs (varargin) –

    Additional arguments for the test.

algorithm ¤

(algoType, algoArgs)

Set the algorithm for the analysis.

See also

Input arguments:

  • algoType (char | string) –

    Algorithm type.

  • algoArgs (varargin) –

    Additional arguments for the algorithm.

integrator ¤

(intType, intArgs)

This command is used to construct the Integrator object. The Integrator object determines the meaning of the terms in the system of equation object Ax=B. The Integrator object is used for the following:

  • determine the predictive step for time t+dt
  • specify the tangent matrix and residual vector at any iteration
  • determine the corrective step based on the displacement increment dU
See also

Input arguments:

  • intType (char | string) –

    Integrator type.

  • intArgs (varargin) –

    Additional arguments passed directly to OpenSees.

analysis ¤

(analysisType, analysisArgs)

Set the analysis type.

See also

Input arguments:

  • analysisType (char | string) –

    Analysis type. One of:

    • 'Static'
    • 'Transient'
    • 'PFEM'
    • 'VariableTransient'

    analysisArgs : varargin Optional arguments, e.g. '-noWarnings'.

analyze ¤

(numIncr=1, analyzeArgs)

Run the analysis.

See also
Syntax 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
% Static analysis:
ops.analyze(numIncr)
ops.analyze(numIncr, '-noFlush')

% Transient analysis:
ops.analyze(numIncr, dt)
ops.analyze(numIncr, dt, '-noFlush')

% Variable transient analysis:
ops.analyze(numIncr, dt, dtMin, dtMax, Jd)
ops.analyze(numIncr, dt, dtMin, dtMax, Jd, '-noFlush')

% PFEM analysis:
ops.analyze()
ops.analyze('-noFlush')

Input arguments:

  • numIncr (int) –

    Number of increments (static/transient).

  • dt (double) –

    Time step (transient).

  • dtMin (double) –

    Minimum time step (variable transient).

  • dtMax (double) –

    Maximum time step (variable transient).

  • Jd (int) –

    Number of iterations per step (variable transient).

eigen ¤

(varargin)

Run an eigenvalue analysis.

Syntax

eigen(10) eigen('-genBandArpack', 10)

See also

Input arguments:

  • solver (char | string) –

    Solver type (default: '-genBandArpack'). One of: '-genBandArpack', '-fullGenLapack', '-symmBandLapack', '-symmGenLapack', '-standard', '-findLargest'.

  • numModes (int) –

    Number of eigenvalues to compute.

modalProperties ¤

(varargin)

This command is used to compute the modal properties of a model after an eigen command.

responseSpectrumAnalysis ¤

(varargin)

This command is used to perform a response spectrum analysis on a model.

See also

wipeAnalysis ¤

()

This command is used to destroy all components of the Analysis object, i.e. any objects created with system, numberer, constraints, integrator, algorithm, and analysis commands.

record ¤

()

This command is used to cause all the recorders to do a record on the current state of the model.

Note

A record is issued after every successfull static or transient analysis step. Sometimes the user may need the record to be issued on more occasions than this, for example if the user is just looking to record the eigenvectors after an eigen command or for example the user wishes to include the state of the model at time 0.0 before any analysis has been completed.

recorder ¤

(recorderType, recorderArgs)

This command is used to generate a recorder object which is to monitor what is happening during the analysis and generate output for the user.

See also:
Parameters:

recorderType: str Type of recorder to create. recorderArgs: varargin Arguments for the recorder.

Return:

ok: int - >0 an integer tag that can be used as a handle on the recorder for the remove recorder commmand. - -1 recorder command failed if integer -1 returned.

nodeDisp ¤

(nodeTag, dof=-1)

Get nodal displacement.

See also
Syntax 
1
2
disp = ops.nodeDisp(nodeTag)        % all DOFs -> double vector
disp = ops.nodeDisp(nodeTag, dof)   % single DOF -> double scalar

Input arguments:

  • nodeTag (int) –

    Node tag.

  • dof (int(optional)) –

    Degree of freedom (1-based). If omitted, returns all DOFs.

Output arguments:

  • result ( double scalar | double vector | [] ) –

    Nodal displacement(s). If dof is omitted, returns all DOFs.

nodeVel ¤

(nodeTag, dof=-1)

Get nodal velocity.

Syntax 
1
2
vel = ops.nodeVel(nodeTag)        % all DOFs -> double vector
vel = ops.nodeVel(nodeTag, dof)   % single DOF -> double scalar

Input arguments:

  • nodeTag (int) –

    Node tag.

  • dof (int(optional)) –

    Degree of freedom (1-based). If omitted, returns all DOFs.

Output arguments:

  • result ( double scalar | double vector | [] ) –

    Nodal velocity(s). If dof is omitted, returns all DOFs.

nodeAccel ¤

(nodeTag, dof=-1)

Get nodal acceleration.

See also
Syntax 
1
2
accel = ops.nodeAccel(nodeTag)        % all DOFs -> double vector
accel = ops.nodeAccel(nodeTag, dof)   % single DOF -> double scalar

Input arguments:

  • nodeTag (int) –

    Node tag.

  • dof (int(optional)) –

    Degree of freedom (1-based). If omitted, returns all DOFs.

Output arguments:

  • result ( double scalar | double vector | [] ) –

    Nodal acceleration(s). If dof is omitted, returns all DOFs.

nodeCoord ¤

(nodeTag, dim=-1)

Get nodal coordinate.

Syntax 
1
2
coord = ops.nodeCoord(nodeTag)        % all dimensions -> double vector
coord = ops.nodeCoord(nodeTag, dim)   % single dimension -> double scalar

Input arguments:

  • nodeTag (int) –

    Node tag.

  • dim (int(optional)) –

    Dimension (1-based). If omitted, returns all dimensions.

Output arguments:

  • result ( double scalar | double vector | [] ) –

    Nodal coordinate(s). If dim is omitted, returns all dimensions.

nodeBounds ¤

()

Get the boundary of all nodes. Return a list of boundary values.

Output arguments:

  • result ( struct ) –

    Struct containing min/max values for each dimension. [xmin, ymin, zmin, xmax, ymax, zmax]

nodeEigenvector ¤

(nodeTag, modeTag, dof=-1)

Returns the eigenvector at a specified node.

Input arguments:

  • nodeTag (numeric) –

    The tag of the node.

  • modeTag (numeric) –

    The mode number of eigenvector to be returned.

  • dof (numeric) –

    The degree of freedom (1 through ndf). If -1, returns the eigenvector for all DOFs.

Output arguments:

  • result ( double scalar | double vector | [] ) –

    Nodal eigenvector value(s). If dof is omitted, returns all DOFs.

nodeDOFs ¤

(nodeTag)

Returns the DOF numbering of a node.

Input arguments:

  • nodeTag (numeric) –

    The tag of the node.

Output arguments:

  • result ( double vector ) –

    The DOF numbering of the node.

nodeMass ¤

(nodeTag, dof=-1)

Returns the mass at a specified node.

Input arguments:

  • nodeTag (numeric) –

    The tag of the node.

  • dof (numeric) –

    The degree of freedom (1 through ndf). If -1, returns the mass values for all DOFs.

Output arguments:

  • result ( double scalar | double vector | [] ) –

    Mass value(s). If dof is omitted, returns all DOFs.

nodePressure ¤

(nodeTag)

Returns the pressure at a specified node.

Input arguments:

  • nodeTag (numeric) –

    The tag of the node.

Output arguments:

  • result ( double scalar | [] ) –

    Pressure value.

nodeReaction ¤

(nodeTag, dof=-1)

Returns the reaction at a specified node. Must call reactions() command before this command.

Input arguments:

  • nodeTag (numeric) –

    The tag of the node.

  • dof (numeric) –

    The degree of freedom (1 through ndf). If -1, returns the reaction values for all DOFs.

Output arguments:

  • result ( double scalar | double vector | [] ) –

    Reaction value(s). If dof is omitted, returns all DOFs.

reactions ¤

(dynamic="")

Calculate the reactions. Call this command before the nodeReaction() command.

Input arguments:

  • dynamic (string scalar) –
    • if dynamic is empty, calculates static reactions.
    • if '-dynamic' is specified, calculates dynamic reactions.
    • if '-rayleigh' is specified, calculates dynamic reactions with Rayleigh damping.

nodeResponse ¤

(nodeTag, dof, responseID)

Returns the responses at a specified node. To get reactions (id=6), must call the reactions command before this command.

Input arguments:

  • nodeTag (numeric scalar) –

    The tag of the node.

  • dof (numeric scalar) –

    The degree of freedom (1-based index).

  • responseID (numeric scalar) –

    The response ID (1-based index).

    • Disp = 1
    • Vel = 2
    • Accel = 3
    • IncrDisp = 4
    • IncrDeltaDisp = 5
    • Reaction = 6
    • Unbalance = 7
    • RayleighForces = 8

Output arguments:

  • result ( numeric scalar ) –

    The response value.

nodeUnbalance ¤

(nodeTag, dof=-1)

Returns the unbalance at a specified node.

Input arguments:

  • nodeTag (numeric scalar) –

    The tag of the node.

  • dof (numeric scalar) –

    The specific dof at the node (1 through ndf), if no dof is provided, a vector of values for all dofs is returned.

Output arguments:

  • result ( numeric scalar or vector ) –

    The unbalance value(s).

basicDeformation ¤

(eleTag)

Returns the deformation of the basic system for a beam-column element.

Input arguments:

  • eleTag (numeric scalar) –

    The tag of the element.

Output arguments:

  • result ( numeric vector ) –

    The basic deformation values.

basicForce ¤

(eleTag)

Returns the force of the basic system for a beam-column element.

Input arguments:

  • eleTag (numeric scalar) –

    The tag of the element.

Output arguments:

  • result ( numeric vector ) –

    The basic force values.

basicStiffness ¤

(eleTag)

Returns the stiffness of the basic system for a beam-column element. A vector of values in row order will be returned.

Input arguments:

  • eleTag (numeric scalar) –

    The tag of the element.

Output arguments:

  • result ( numeric vector ) –

    The basic stiffness values.

eleDynamicalForce ¤

(eleTag, dof=-1)

Returns the elemental dynamic force.

Input arguments:

  • eleTag (numeric scalar) –

    The tag of the element.

  • dof (numeric scalar) –

    The degree of freedom, 1-based index.

Output arguments:

  • result ( numeric scalar | numeric vector ) –

    The dynamical force value.

eleForce ¤

(eleTag, dof=-1)

Returns the elemental resisting force.

Input arguments:

  • eleTag (numeric scalar) –

    The tag of the element.

  • dof (numeric scalar) –

    The degree of freedom, 1-based index.

Output arguments:

  • result ( numeric scalar | numeric vector ) –

    The force value.

eleNodes ¤

(eleTag)

Returns the nodes of the element.

Input arguments:

  • eleTag (numeric scalar) –

    The tag of the element.

Output arguments:

  • result ( numeric vector ) –

    The node tags.

eleResponse ¤

(eleTag, args)

This command is used to obtain the same element quantities as those obtained from the element recorder at a particular time step.

Input arguments:

  • eleTag (numeric scalar) –

    The tag of the element.

  • args –

    Same arguments as those specified in element recorder. These arguments are specific to the type of element being used.

Output arguments:

  • result ( string ) –

    The element type.

getEleTags ¤

(varargin)

Get all elements in the domain or in a mesh.

Syntax 
1
2
result = getEleTags()
result = getEleTags('-mesh', mtag)

Output arguments:

  • result ( numeric vector ) –

    The tags of all elements in the domain or mesh.

getNodeTags ¤

(varargin)

Get all nodes in the domain or in a mesh.

Syntax 
1
2
result = getNodeTags()
result = getNodeTags('-mesh', mtag)

Output arguments:

  • result ( numeric vector ) –

    The tags of all nodes in the domain or mesh.

getLoadFactor ¤

(patternTag)

Get the load factor for a given pattern tag.

Input arguments:

  • patternTag (numeric scalar) –

    The tag of the pattern.

Output arguments:

  • result ( numeric scalar ) –

    The load factor.

getTime ¤

()

Get the current time in the domin.

Output arguments:

  • result ( numeric scalar ) –

    The current time.

setTime ¤

(pseudoTime)

This command is used to set the pseudo-time of the analysis.

sectionForce ¤

(eleTag, secNum, dof=-1)

Returns the section force for a beam-column element. The dof of the section depends on the section type. Please check with the section manual.

Input arguments:

  • eleTag (numeric scalar) –

    The tag of the element.

  • secNum (numeric scalar) –

    The section number, 1-based.

  • dof (numeric scalar) –

    The degree of freedom, 1-based.

Output arguments:

  • result ( numeric scalar | numeric vector ) –

    The section force, if dof is not specified, scalar; otherwise, numeric vector.

sectionDeformation ¤

(eleTag, secNum, dof=-1)

Returns the section deformation for a beam-column element. The dof of the section depends on the section type. Please check with the section manual.

Input arguments:

  • eleTag (numeric scalar) –

    The tag of the element.

  • secNum (numeric scalar) –

    The section number, 1-based.

  • dof (numeric scalar) –

    The degree of freedom, 1-based.

Output arguments:

  • result ( numeric scalar | numeric vector ) –

    The section deformation, if dof is not specified, scalar; otherwise, numeric vector.

sectionStiffness ¤

(eleTag, secNum)

Returns the section stiffness matrix for a beam-column element. A list of values in the row order will be returned.

Input arguments:

  • eleTag (numeric scalar) –

    The tag of the element.

  • secNum (numeric scalar) –

    The section number, 1-based.

Output arguments:

  • result ( numeric vector ) –

    The section stiffness matrix, flattened in row order.

sectionFlexibility ¤

(eleTag, secNum)

Returns the section flexibility matrix for a beam-column element. A list of values in the row order will be returned.

Input arguments:

  • eleTag (numeric scalar) –

    The tag of the element.

  • secNum (numeric scalar) –

    The section number, 1-based.

Output arguments:

  • result ( numeric vector ) –

    The section flexibility matrix, flattened in row order.

sectionLocation ¤

(eleTag, secNum=-1)

Returns the section location for a beam-column element.

Input arguments:

  • eleTag (numeric scalar) –

    The tag of the element.

  • secNum (numeric scalar) –

    The section number, 1-based. If not provided, returns the location of all sections.

Output arguments:

  • result ( numeric vector | numeric scalar ) –

    The section location, flattened in row order. If secNum is not provided, returns the location of all sections.

sectionWeight ¤

(eleTag, secNum=-1)

Returns the weights of integration points of a section for a beam-column element.

Input arguments:

  • eleTag (numeric scalar) –

    The tag of the element.

  • secNum (numeric scalar) –

    The section number, 1-based. If not provided, returns the weight of all sections.

Output arguments:

  • result ( numeric scalar | numeric vector ) –

    The section weight. If secNum is not provided, returns the weight of all sections.

systemSize ¤

()

Return the system size.

numIter ¤

()

Return the number of iterations.

testIter ¤

()

Returns the number of iterations the convergence test took in the last analysis step

testNorm ¤

()

Returns the norms from the convergence test for the last analysis step.

Note

The size of norms will be equal to the max number of iterations specified. The first testIter of these will be non-zero, the remaining ones will be zero.

testUniaxialMaterial ¤

(matTag)

Set the uniaxial material tag and test it.

setStrain ¤

(eps)

Set the strain and test the uniaxial material specified by testUniaxialMaterial.

getStrain ¤

()

Returns the strain of the uniaxial material specified by testUniaxialMaterial.

getStress ¤

()

Returns the stress of the uniaxial material specified by testUniaxialMaterial.

getTangent ¤

()

Returns the tangent modulus of the uniaxial material specified by testUniaxialMaterial.

getDampTangent ¤

()

Returns the damping tangent modulus of the uniaxial material specified by testUniaxialMaterial.

reset ¤

()

Reset the model.