opstool

https://github.com/yexiang92/opstool
Admin
opstool is a Python package for pre-processing, post-processing, and visualization of structural...
Tokens:275,895
Snippets:1,650
Trust Score:6.8
License:GPL-3.0
Update:6 months ago
Show doc for...
Tokens:
Raw
### Loading Examples and Defining Loads

Source: https://github.com/yexiang92/opstool/blob/master/docs/_sphinx_gallery_examples/vis-guide/pyvista/ex-08-brick-resp-pyvista.ipynb

Load a predefined example and set up gravity loads.

```python
opst.load_ops_examples("Dam-Brick")

ops.timeSeries("Linear", 1)
ops.pattern("Plain", 1, 1)
_ = opst.pre.gen_grav_load(direction="Z", factor=-9.81)
```

--------------------------------

### Loading model examples

Source: https://github.com/yexiang92/opstool/blob/master/docs/src/post/brick_resp.ipynb

Load a predefined model example from the opstool library.

```python
opst.load_ops_examples("Pier-Brick")
# or your model code here
```

--------------------------------

### Load Model Example

Source: https://github.com/yexiang92/opstool/blob/master/docs/_sphinx_gallery_examples/vis-guide/pyvista/ex-01-model-pyvista.ipynb

Load a built-in example model or prepare the environment for custom model scripts.

```python
opst.load_ops_examples("CableStayedBridge")
# or your model code here
```

--------------------------------

### Load Opstool Examples

Source: https://github.com/yexiang92/opstool/blob/master/docs/_sphinx_gallery_examples/vis-guide/plotly/ex-01-model-plotly.ipynb

Load a built-in example model from opstool. This is useful for testing visualization functions.

```python
import opstool as opst
import opstool.vis.plotly as opsvis

opst.load_ops_examples("ArchBridge2")
```

--------------------------------

### Analysis Setup

Source: https://github.com/yexiang92/opstool/blob/master/docs/_sphinx_gallery_examples/examples/postprocessing/ex-cantilever-roll-up.ipynb

Configures the analysis settings, including constraints, numbering scheme, system solver, test criteria, algorithm, integrator, and analysis type. 'Static' analysis is chosen for this example.

```python
duration = 1.0
nsteps = 40
dt = duration / nsteps
dt_record = 0.2
ops.constraints("Transformation")
ops.numberer("RCM")
ops.system("UmfPack")
ops.test("NormDispIncr", 1.0e-5, 100, 0)
ops.algorithm("Newton")
ops.integrator("LoadControl", dt)
ops.analysis("Static")
```

--------------------------------

### Initialize Gmsh Script

Source: https://github.com/yexiang92/opstool/blob/master/docs/_sphinx_gallery_examples/examples/postprocessing/ex-forma11c.ipynb

Setup the Gmsh environment and import necessary modules.

```python
import json
import math

import gmsh
```

```python
gmsh.initialize()

gmsh.model.add("forma11c_gmsh")
```

--------------------------------

### Install and activate Poetry environment

Source: https://github.com/yexiang92/opstool/blob/master/CONTRIBUTING.md

Install project dependencies and activate the virtual environment using Poetry. This ensures a consistent development environment.

```bash
cd opstool
poetry install
poetry shell
```

--------------------------------

### Setup OpenSeesPy Model and Material

Source: https://github.com/yexiang92/opstool/blob/master/docs/_sphinx_gallery_examples/examples/preprocessing/ex-read-gmsh-2.ipynb

Initializes the OpenSeesPy environment and defines an elastic isotropic material.

```python
ops.wipe()
# Initialize a basic 3D model with 3 degrees of freedom per node
ops.model("basic", "-ndm", 3, "-ndf", 3)

# Define an elastic isotropic material
# Material ID: 1
# Elastic modulus: 3e7
# Poisson's ratio: 0.2
# Density: 2.55
matTag = 1
ops.nDMaterial("ElasticIsotropic", matTag, 3e7, 0.2, 2.55)
```

--------------------------------

### Install opstool Package

Source: https://github.com/yexiang92/opstool/blob/master/README.md

Install the opstool package using pip. Ensure you have Python installed.

```bash
pip install --upgrade opstool
```

--------------------------------

### Load Example Model in Opstool

Source: https://github.com/yexiang92/opstool/blob/master/docs/_sphinx_gallery_examples/vis-guide/plotly/ex-01-model-plotly.rst

This snippet shows how to load an example model, 'ArchBridge2', using opstool. This is a prerequisite for visualizing the model. Replace this with your own model loading code.

```Python
import opstool as opst
import opstool.vis.plotly as opsvis

opst.load_ops_examples("ArchBridge2")
# or your model code here
```

--------------------------------

### Initialize Opstool Model for Visualization

Source: https://github.com/yexiang92/opstool/blob/master/docs/_sphinx_gallery_examples/quick-start/ex-quick-plot-model.ipynb

Load a built-in example model or define a custom model to prepare for visualization.

```python
import opstool as opst
import opstool.vis.plotly as opsvis

opst.load_ops_examples("ArchBridge2")  # Built-in example model in opstool
# or your model code here
```

```python
import opstool as opst
import opstool.vis.pyvista as opsvis

opst.load_ops_examples("Frame3D")
# or your model code here
```

--------------------------------

### Load OpenSeesPy Examples and Generate Gravity Load

Source: https://github.com/yexiang92/opstool/blob/master/docs/_sphinx_gallery_examples/vis-guide/pyvista/ex-06-shell-resp-pyvista.ipynb

Loads a predefined OpenSeesPy example model ('Shell3D') and generates gravity loads in the Z direction. Ensure OpenSeesPy and opstool are installed.

```python
import openseespy.opensees as ops

import opstool as opst
import opstool.vis.pyvista as opsvis

opst.load_ops_examples("Shell3D")

ops.timeSeries("Linear", 1)
ops.pattern("Plain", 1, 1)
_ = opst.pre.gen_grav_load(direction="Z", factor=-9810)
```

--------------------------------

### Load Example Model

Source: https://github.com/yexiang92/opstool/blob/master/docs/_sphinx_gallery_examples/vis-guide/pyvista/ex-02-eigen-pyvista.ipynb

Loads a built-in example model for demonstration purposes. This is useful for testing and understanding the library's capabilities.

```python
import opstool as opst
import opstool.vis.pyvista as opsvis

# Here, we use a built-in example from ``opstool``, which is an example of a suspension bridge model primarily composed of frame elements and shell elements.
```

```python
opst.load_ops_examples("SuspensionBridge")
# or your model code here
opst.vis.pyvista.plot_model().show()
```

--------------------------------

### load_ops_examples Function

Source: https://github.com/yexiang92/opstool/blob/master/docs/src/api/_autosummary/opstool.load_ops_examples.rst

This function is used to load operational examples.

```APIDOC
## load_ops_examples

### Description
Loads operational examples.

### Module
opstool

### Function Signature
`load_ops_examples()`

### Parameters
This function does not accept any parameters.

### Returns
This function does not explicitly return a value, but it loads operational examples.
```

--------------------------------

### Install pre-commit hooks

Source: https://github.com/yexiang92/opstool/blob/master/CONTRIBUTING.md

Install pre-commit to automatically run linters and formatters before each commit, ensuring code quality.

```bash
poetry run pre-commit install
```

--------------------------------

### Load Example Model

Source: https://github.com/yexiang92/opstool/blob/master/docs/_sphinx_gallery_examples/vis-guide/plotly/ex-03-nodal-resp-plotly.ipynb

Loads a built-in deck arch bridge model from the Opstool library.

```python
opst.load_ops_examples("ArchBridge2")
# or your model code here
```

--------------------------------

### Load Model and Apply Loads

Source: https://github.com/yexiang92/opstool/blob/master/docs/_sphinx_gallery_examples/vis-guide/plotly/ex-04-frame-resp-plotly.ipynb

Load a predefined example model and apply uniform beam loads to specific elements.

```python
opst.load_ops_examples("Frame3D2")
ops.timeSeries("Linear", 1)
ops.pattern("Plain", 1, 1)
for etag in [5, 6, 7, 8, 15, 16, 17, 18, 19, 20, 21]:
    ops.eleLoad("-ele", etag, "-type", "-beamUniform", 0.0, -10)  # wy=0.0, wz=-10.0
```

--------------------------------

### Initialize OpenSeesPy and Opstool

Source: https://github.com/yexiang92/opstool/blob/master/docs/_sphinx_gallery_examples/examples/postprocessing/ex-forma11c.ipynb

Import necessary libraries for the analysis.

```python
import openseespy.opensees as ops

import opstool as opst
```

--------------------------------

### Visualize Arch Bridge Model

Source: https://github.com/yexiang92/opstool/blob/master/docs/src/post/eigen.ipynb

Loads and visualizes the built-in ArchBridge example model. Ensure matplotlib and pyvista are installed and configured for notebook use.

```python
import matplotlib.pyplot as plt

import opstool as opst
```

```python
opst.load_ops_examples("ArchBridge")

# plot
opst.vis.pyvista.set_plot_props(notebook=True)
fig = opst.vis.pyvista.plot_model()
fig.show(jupyter_backend="static")
```

--------------------------------

### Configure Transient Analysis

Source: https://github.com/yexiang92/opstool/blob/master/docs/src/post/plane_up_resp.ipynb

Initializes the analysis environment and sets up the transient solver parameters.

```python
ops.wipeAnalysis()
ops.setTime(0.0)
ops.timeSeries("Trig", 1, 0.0, 10.0, 1.0, "-factor", 2)
ops.pattern("UniformExcitation", 1, 1, "-accel", 1)
```

```python
ops.constraints("Penalty", 1e18, 1e18)
ops.test("NormDispIncr", 0.0001, 25, 0)
ops.numberer("RCM")
ops.algorithm("KrylovNewton")
ops.system("ProfileSPD")
ops.integrator("Newmark", 0.6, 0.30250000000000005)
ops.rayleigh(0.0, 0.0, 0.002, 0.0)
ops.analysis("Transient")
```

--------------------------------

### Set Up Analysis Algorithm for Pushover

Source: https://github.com/yexiang92/opstool/blob/master/docs/_sphinx_gallery_examples/examples/postprocessing/ex-sensitivity2.ipynb

Configures the analysis algorithm, including system solver, constraints, numbering scheme, convergence test, and integration scheme for static analysis with displacement control.

```python
ops.wipeAnalysis()
ops.system("BandGeneral")
ops.constraints("Transformation")
ops.numberer("RCM")
ops.test("NormDispIncr", 1.0e-8, 10)
ops.algorithm("Newton")
# Change the integration scheme to be displacement control
#                                     node      dof  init Jd min max
ops.integrator("DisplacementControl", ctrlNode, dof, Dincr)
ops.analysis("Static")
ops.sensitivityAlgorithm("-computeAtEachStep")  # automatically compute sensitivity at the end of each step
```

--------------------------------

### Load Example Model

Source: https://github.com/yexiang92/opstool/blob/master/docs/_sphinx_gallery_examples/vis-guide/plotly/ex-02-eigen-plotly.ipynb

Load a built-in example model, such as the 'ArchBridge', to perform eigenvalue analysis. Alternatively, load your own model code.

```python
opst.load_ops_examples("ArchBridge")
# or your model code here
```

--------------------------------

### Model Setup: Nodes and Elements

Source: https://github.com/yexiang92/opstool/blob/master/docs/_sphinx_gallery_examples/examples/postprocessing/ex-cantilever-roll-up.ipynb

Initializes the OpenSeesPy model, defines material and section properties, and creates a mesh of ASDShellQ4 elements with a corotational formulation. Nodes are created in a grid, and elements connect these nodes.

```python
ops.wipe()
ops.model("basic", "-ndm", 3, "-ndf", 6)
E = 1e4
h = 1.0
ops.section("ElasticMembranePlateSection", 1, E, 0.0, h)

# mesh
Lx = 20.0
Ly = 1.0
Nx = 20
Ny = 1
dLx = Lx / Nx
dLy = Ly / Ny
for j in range(Ny + 1):
    offset = j * (Nx + 1)
    jY = j * dLy
    for i in range(Nx + 1):
        iX = i * dLx
        ops.node(offset + i + 1, iX, jY, 0.0)
ele_id = 1
for j in range(Ny):
    for i in range(Nx):
        qids = (j * (Nx + 1) + i + 1, j * (Nx + 1) + i + 2, (j + 1) * (Nx + 1) + i + 2, (j + 1) * (Nx + 1) + i + 1)
        ops.element("ASDShellQ4", ele_id, *qids, 1, "-corotational")
        ele_id += 1

# fix
for j in range(Ny + 1):
    ops.fix(j * (Nx + 1) + 1, 1, 1, 1, 1, 1, 1)

# load
Nrolls = 2
M = Nrolls * 2.0 * np.pi * E * h**3 / 12 / Lx
dM = M / Ny / 2
ops.timeSeries("Linear", 1)
ops.pattern("Plain", 1, 1)
for j in range(Ny):
    i = Nx - 1
    n1 = j * (Nx + 1) + i + 2
    n2 = (j + 1) * (Nx + 1) + i + 2
    ops.load(n1, 0, 0, 0, 0, -dM, 0)
    ops.load(n2, 0, 0, 0, 0, -dM, 0)
```

--------------------------------

### Initialize UnitSystem and Access Units

Source: https://github.com/yexiang92/opstool/blob/master/docs/src/pre/unit_system.ipynb

Demonstrates how to define base units and access converted values for various physical quantities.

```python
import numpy as np
import openseespy.opensees as ops

import opstool as opst

length_unit = "m"  # base unit
force_unit = "kN"  # base unit

UNIT = opst.pre.UnitSystem(length=length_unit, force=force_unit)

print("Length:", UNIT.mm, UNIT.mm2, UNIT.cm, UNIT.m, UNIT.inch, UNIT.ft)
print("Force", UNIT.N, UNIT.kN, UNIT.lbf, UNIT.kip)
print("Stress", UNIT.MPa, UNIT.kPa, UNIT.Pa, UNIT.psi, UNIT.ksi)
print("Mass", UNIT.g, UNIT.kg, UNIT.ton, UNIT.slug)
# print(UNIT)
```

--------------------------------

### Configure Analysis Settings

Source: https://github.com/yexiang92/opstool/blob/master/docs/_sphinx_gallery_examples/examples/postprocessing/ex-PressureDependMultiYield-6.ipynb

Sets up sinusoidal base excitation, uniform excitation pattern, Rayleigh damping, Newmark integration, constraints, and analysis algorithm. This is typically done at the beginning of an analysis setup.

```python
ops.timeSeries("Sine", 1, 0.0, 10.0, 1.0, "-factor", accMul)
ops.pattern("UniformExcitation", 1, 1, "-accel", 1)

ops.rayleigh(massProportionalDamping, 0.0, InitStiffnessProportionalDamping, 0.0)

beta = (gamma + 0.5) ** 2 / 4.0
ops.integrator("Newmark", gamma, beta)

ops.constraints("Penalty", 1e18, 1e18)
ops.test("NormDispIncr", 1e-10, 25, 0)
ops.algorithm("ModifiedNewton")
ops.system("ProfileSPD")
ops.numberer("Plain")
ops.analysis("VariableTransient")
```

--------------------------------

### Get Node Coordinates

Source: https://github.com/yexiang92/opstool/blob/master/docs/src/api/_autosummary/opstool.pre.get_node_coord.rst

Retrieves the coordinates of a node.

```APIDOC
## get_node_coord

### Description
Retrieves the coordinates of a node.

### Method
GET

### Endpoint
/opstool/pre/get_node_coord

### Parameters
#### Query Parameters
- **node_id** (string) - Required - The unique identifier of the node.

### Response
#### Success Response (200)
- **x_coordinate** (float) - The x-coordinate of the node.
- **y_coordinate** (float) - The y-coordinate of the node.

#### Response Example
{
  "x_coordinate": 10.5,
  "y_coordinate": 20.2
}
```

--------------------------------

### Initialize FEM Model and Visualization

Source: https://github.com/yexiang92/opstool/blob/master/docs/_sphinx_gallery_examples/examples/postprocessing/ex-excavation.ipynb

Load the model and configure visualization properties.

```python
from utils.excavation import FEMmodel

import opstool as opst
import opstool.vis.pyvista as opsvis

FEMmodel()
```

```python
opsvis.set_plot_props(point_size=1, font_size=9)
opsvis.plot_model(show_node_numbering=True, show_ele_numbering=True).show()
```

--------------------------------

### Get Element Responses

Source: https://github.com/yexiang92/opstool/blob/master/docs/src/api/_autosummary/opstool.post.get_element_responses.rst

Retrieves responses for elements.

```APIDOC
## GET /elements/responses

### Description
Retrieves responses associated with elements.

### Method
GET

### Endpoint
/elements/responses

### Parameters
#### Query Parameters
- **element_id** (string) - Required - The ID of the element to retrieve responses for.

### Response
#### Success Response (200)
- **responses** (list) - A list of responses for the specified element.

#### Response Example
```json
{
  "responses": [
    {
      "response_id": "resp_123",
      "content": "This is a response."
    }
  ]
}
```
```

--------------------------------

### Initialize Opstool Environment

Source: https://github.com/yexiang92/opstool/blob/master/docs/_sphinx_gallery_examples/vis-guide/plotly/ex-03-nodal-resp-plotly.ipynb

Imports the required OpenSeesPy and Opstool modules for structural modeling and visualization.

```python
import openseespy.opensees as ops

import opstool as opst
import opstool.vis.plotly as opsvis
```

--------------------------------

### Initialize opstool and load model

Source: https://github.com/yexiang92/opstool/blob/master/docs/quick-start/vis-megatall.ipynb

Imports the necessary libraries and initializes the FEM model.

```python
import time

import opstool as opst
```

```python
from data.MegatallBuilding import FEMmodel

FEMmodel()
```

--------------------------------

### Get Element Responses Info

Source: https://github.com/yexiang92/opstool/blob/master/docs/src/api/_autosummary/opstool.post.get_element_responses_info.rst

Retrieves information about element responses.

```APIDOC
## GET /elements/responses/info

### Description
Retrieves detailed information regarding element responses. This endpoint is useful for understanding the status and details of responses associated with specific elements.

### Method
GET

### Endpoint
/elements/responses/info

### Parameters
#### Query Parameters
- **element_id** (string) - Required - The unique identifier for the element whose responses are to be retrieved.

### Response
#### Success Response (200)
- **responses** (array) - A list of response objects, each containing details about a specific response.
  - **response_id** (string) - The unique identifier for the response.
  - **timestamp** (string) - The time at which the response was recorded.
  - **status** (string) - The status of the response (e.g., 'success', 'failed').
  - **details** (object) - Additional details about the response.

#### Response Example
```json
{
  "responses": [
    {
      "response_id": "resp_12345",
      "timestamp": "2023-10-27T10:00:00Z",
      "status": "success",
      "details": {
        "code": 200,
        "message": "Response processed successfully."
      }
    }
  ]
}
```
```

--------------------------------

### Initialize OpenSees and Opstool Environment

Source: https://github.com/yexiang92/opstool/blob/master/docs/src/post/truss_resp.ipynb

Imports necessary libraries for plotting and OpenSees modeling.

```python
import matplotlib.pyplot as plt
import openseespy.opensees as ops

import opstool as opst

%matplotlib inline
```

--------------------------------

### Get Frame Section Properties

Source: https://github.com/yexiang92/opstool/blob/master/docs/src/pre/sec_mesh.ipynb

Calculates and displays the geometric properties of the section.

```python
_ = SEC_MESH.get_frame_props(display_results=True)
```

--------------------------------

### Get Nodal Responses Info

Source: https://github.com/yexiang92/opstool/blob/master/docs/src/api/_autosummary/opstool.post.get_nodal_responses_info.rst

Retrieves information related to nodal responses.

```APIDOC
## GET /yexiang92/opstool/get_nodal_responses_info

### Description
Retrieves information related to nodal responses from the Opstool.

### Method
GET

### Endpoint
/yexiang92/opstool/get_nodal_responses_info

### Parameters
This endpoint does not have any documented parameters.

### Request Example
No request body is expected for this GET request.

### Response
#### Success Response (200)
- **nodal_responses_info** (object) - Contains detailed information about nodal responses.

#### Response Example
```json
{
  "nodal_responses_info": {
    "node_id_1": {
      "response_type_a": "value1",
      "response_type_b": "value2"
    },
    "node_id_2": {
      "response_type_a": "value3",
      "response_type_c": "value4"
    }
  }
}
```
```

--------------------------------

### Get element responses

Source: https://github.com/yexiang92/opstool/blob/master/docs/_sphinx_gallery_examples/examples/postprocessing/ex-fsi-gu.ipynb

Retrieve element responses for specific element types.

```python
opst.post.get_element_responses(odb_tag="FSI", ele_type="Brick")
```

```python
opst.post.get_element_responses(odb_tag="FSI", ele_type="Plane")
```

--------------------------------

### Configuring Static Analysis

Source: https://github.com/yexiang92/opstool/blob/master/docs/_sphinx_gallery_examples/vis-guide/plotly/ex-05-truss-resp-plotly.ipynb

Set up the analysis parameters including system, numberer, and integrator.

```python
Nsteps = 10
ops.system("ProfileSPD")
# create DOF number
ops.numberer("Plain")
# create constraint handler
ops.constraints("Plain")
# create integrator
ops.integrator("LoadControl", 1.0 / Nsteps)
# create algorithm
ops.algorithm("Newton")
# create test
ops.test("NormUnbalance", 1e-8, 10)
# create analysis object
ops.analysis("Static")
```

--------------------------------

### Create and Analyze with Static Analysis

Source: https://github.com/yexiang92/opstool/blob/master/docs/src/post/frame_resp.ipynb

This snippet demonstrates how to initialize a static analysis, create an ODB object, perform analysis steps, fetch response data for each step, and save the results.

```APIDOC
## POST /api/analysis/static

### Description
Initializes and performs a static analysis.

### Method
POST

### Endpoint
/api/analysis/static

### Parameters
#### Request Body
- **analysis_type** (string) - Required - The type of analysis to perform (e.g., "Static").

### Request Example
```json
{
  "analysis_type": "Static"
}
```

## POST /api/odb/create

### Description
Creates an ODB (Output Database) object to store response data.

### Method
POST

### Endpoint
/api/odb/create

### Parameters
#### Request Body
- **odb_tag** (integer) - Required - A unique tag for the ODB object.
- **elastic_frame_sec_points** (integer) - Required - Number of elastic frame section points.

### Request Example
```json
{
  "odb_tag": 1,
  "elastic_frame_sec_points": 9
}
```

## POST /api/analyze

### Description
Performs an analysis step.

### Method
POST

### Endpoint
/api/analyze

### Parameters
#### Request Body
- **odb_tag** (integer) - Required - The tag of the ODB object to associate with the analysis.

### Request Example
```json
{
  "odb_tag": 1
}
```

## POST /api/odb/fetch_response_step

### Description
Fetches the response data for the current analysis step and associates it with the ODB object.

### Method
POST

### Endpoint
/api/odb/fetch_response_step

### Parameters
#### Request Body
- **odb_tag** (integer) - Required - The tag of the ODB object.

### Request Example
```json
{
  "odb_tag": 1
}
```

## POST /api/odb/save_response

### Description
Saves the accumulated response data to the results directory.

### Method
POST

### Endpoint
/api/odb/save_response

### Parameters
#### Request Body
- **odb_tag** (integer) - Required - The tag of the ODB object.

### Request Example
```json
{
  "odb_tag": 1
}
```
```

--------------------------------

### Create Gravity Loads

Source: https://github.com/yexiang92/opstool/blob/master/docs/_sphinx_gallery_examples/vis-guide/plotly/ex-08-brick-resp-plotly.ipynb

Load an example model and define a gravity load pattern.

```python
opst.load_ops_examples("Dam-Brick")  # or your own model

# Create a gravity load pattern
ops.timeSeries("Linear", 1)
ops.pattern("Plain", 1, 1)
node_loads = opst.pre.create_gravity_load(direction="Z", factor=-9.81)
```

--------------------------------

### Configure analysis parameters

Source: https://github.com/yexiang92/opstool/blob/master/docs/_sphinx_gallery_examples/examples/postprocessing/ex-fsi-gu.ipynb

Set up the transient analysis parameters.

```python
ops.wipeAnalysis()
ops.constraints("Transformation")
ops.system("BandGeneral")
ops.numberer("Plain")
ops.test("NormDispIncr", 1e-05, 20, 0)
ops.algorithm("Newton")
ops.integrator("Newmark", 0.5, 0.25)
ops.analysis("Transient")
```

--------------------------------

### Console Output Log

Source: https://github.com/yexiang92/opstool/blob/master/docs/_sphinx_gallery_examples/examples/postprocessing/ex-ssi-Gu.rst

Example of the console output generated when loading response data.

```none
OPSTOOL™ ::  Loading responses data from G:\opstool\docs\.opstool.output\RespStepData-1.odb ...
```

--------------------------------

### Configure and Run Static Analysis

Source: https://github.com/yexiang92/opstool/blob/master/docs/src/post/truss_resp.ipynb

Sets up and runs a static analysis. This includes defining the solver, numberer, test, algorithm, integrator, and analysis type.

```python
ops.system("BandGeneral")
ops.constraints("Transformation")
ops.numberer("RCM")
ops.test("NormDispIncr", 1.0e-12, 10, 3)
ops.algorithm("Newton")
ops.integrator("LoadControl", 1.0 / Nsteps)
ops.analysis("Static")
```

--------------------------------

### Get Linear Buckling Data

Source: https://github.com/yexiang92/opstool/blob/master/docs/src/api/_autosummary/opstool.post.get_linear_buckling_data.rst

Retrieves linear buckling data from the analysis results.

```APIDOC
## GET /yexiang92/opstool/post/get_linear_buckling_data

### Description
Retrieves linear buckling data. This function is part of the post-processing capabilities of the opstool library.

### Method
GET

### Endpoint
/yexiang92/opstool/post/get_linear_buckling_data

### Parameters
This function does not appear to have any explicitly defined parameters in the provided documentation.

### Request Example
This endpoint does not require a request body.

### Response
#### Success Response (200)
- **data** (any) - The linear buckling data. The specific structure of this data is not detailed in the provided documentation.

#### Response Example
{
  "data": "[Linear buckling data structure]"
}
```

--------------------------------

### Get Eigen Data

Source: https://github.com/yexiang92/opstool/blob/master/docs/src/api/_autosummary/opstool.post.get_eigen_data.rst

Retrieves eigenvalue data. This function is part of the post module.

```APIDOC
## GET /yexiang92/opstool/get_eigen_data

### Description
Retrieves eigenvalue data from the opstool.post module.

### Method
GET

### Endpoint
/yexiang92/opstool/get_eigen_data

### Parameters
This endpoint does not have any documented path, query, or request body parameters.

### Response
#### Success Response (200)
Details about the success response are not explicitly provided in the source text.

#### Response Example
No example response is provided in the source text.
```

--------------------------------

### Set up 3D Model for Surface Load Equivalence

Source: https://github.com/yexiang92/opstool/blob/master/docs/src/pre/loads.ipynb

Initializes a 3D model with 6 degrees of freedom per node and defines nodes and boundary conditions. This setup is for demonstrating surface load equivalence to nodal loads.

```python
import opstool as opst
import openseespy.opensees as ops
```

```python
ops.wipe()
# set up a 3D-6DOFs model
ops.model("Basic", "-ndm", 3, "-ndf", 6)
ops.node(1, 0.0, 0.0, 0.0)
ops.node(2, 1.0, 0.0, 0.0)
ops.node(3, 1.0, 1.0, 0.0)
ops.node(4, 0.0, 1.0, 0.0)

ops.node(5, 2.0, 0.0, 0.0)
ops.node(6, 2.0, 1.0, 0.0)

ops.fix(1, *([1] * 6))
ops.fix(4, *([1] * 6))

# create a fiber shell section with 4 layers of material 1

```

--------------------------------

### Initialize OpenSeesPy Model

Source: https://github.com/yexiang92/opstool/blob/master/docs/src/api/pre.section.rst

Sets up the basic OpenSeesPy environment and defines a uniaxial material.

```python
import numpy as np
import openseespy.opensees as ops
import opstool as opst

ops.wipe()
ops.model("basic", "-ndm", 3, "-ndf", 6)
ops.uniaxialMaterial("Elastic", 1, 1000)
```

--------------------------------

### Inspect Data Array Structure

Source: https://github.com/yexiang92/opstool/blob/master/docs/_sphinx_gallery_examples/examples/postprocessing/ex-excavation.rst

Example of the internal array structure for element response data.

```text
           [ 0.00000000e+00, -3.60340287e-04,  0.00000000e+00,
             0.00000000e+00,  0.00000000e+00,  0.00000000e+00],
           [ 4.99718124e-04,  0.00000000e+00,  0.00000000e+00,
             0.00000000e+00,  0.00000000e+00,  0.00000000e+00],
           ...,
           [ 2.49371585e-02,  4.52551951e-08,  0.00000000e+00,
             0.00000000e+00,  0.00000000e+00, -2.51339329e-03],
           [ 0.00000000e+00,  1.36165805e-02,  0.00000000e+00,
             0.00000000e+00,  0.00000000e+00,  0.00000000e+00],
           [ 0.00000000e+00,  1.54468101e-02,  0.00000000e+00,
             0.00000000e+00,  0.00000000e+00,  0.00000000e+00]],
          shape=(385, 6), dtype=float32)
```

```text
array([  1,   2,   3, ..., 435, 436, 445], shape=(385,))
```

```text
array(['UX', 'UY', 'UZ', 'RX', 'RY', 'RZ'], dtype='<U2')
```

```text
array(33., dtype=float32)
```

--------------------------------

### Initialize Environment and Materials

Source: https://github.com/yexiang92/opstool/blob/master/docs/_sphinx_gallery_examples/examples/sec-mesh/ex-rc-section.rst

Sets up the OpenSees model and defines concrete and steel material properties.

```Python
import matplotlib.pyplot as plt
import openseespy.opensees as ops

import opstool as opst
```

```Python
ops.wipe()
ops.model("basic", "-ndm", 3, "-ndf", 6)
coverID, coreID, rebarID = 1, 2, 3
ops.uniaxialMaterial("Concrete01", coverID, -30, -0.002, -15, -0.005)
ops.uniaxialMaterial("Concrete01", coreID, -40, -0.006, -30, -0.015)
ops.uniaxialMaterial("Steel01", rebarID, 200, 2.0e5, 0.02)
```

--------------------------------

### Configure OpenSees Analysis System

Source: https://github.com/yexiang92/opstool/blob/master/docs/src/post/nodal_resp.ipynb

Sets up the analysis system in OpenSeesPy, including the system solver, constraint handler, DOF numberer, convergence test, solution algorithm, and integrator. This is a standard setup for static analysis.

```python
ops.system("BandGeneral")
# Create the constraint handler, the transformation method
ops.constraints("Transformation")
# Create the DOF numberer, the reverse Cuthill-McKee algorithm
ops.numberer("RCM")
# Create the convergence test, the norm of the residual with a tolerance of
# 1e-12 and a max number of iterations of 10
ops.test("NormDispIncr", 1.0e-12, 10, 3)
# Create the solution algorithm, a Newton-Raphson algorithm
ops.algorithm("Newton")
# Create the integration scheme, the LoadControl scheme using steps of 0.1
ops.integrator("LoadControl", 0.1)
```

--------------------------------

### Get Model Data

Source: https://github.com/yexiang92/opstool/blob/master/docs/src/api/_autosummary/opstool.post.get_model_data.rst

Retrieves data related to models. This function is part of the post module.

```APIDOC
## GET /api/models/data

### Description
Retrieves data associated with models. This endpoint is part of the post module.

### Method
GET

### Endpoint
/api/models/data

### Parameters
#### Query Parameters
- **model_id** (string) - Required - The identifier for the model whose data is to be retrieved.

### Response
#### Success Response (200)
- **data** (object) - A JSON object containing the requested model data.

#### Response Example
```json
{
  "data": {
    "model_name": "example_model",
    "version": "1.0",
    "parameters": {
      "param1": 10,
      "param2": "value"
    }
  }
}
```
```

--------------------------------

### Configure Static Analysis

Source: https://github.com/yexiang92/opstool/blob/master/docs/_sphinx_gallery_examples/vis-guide/plotly/ex-04-frame-resp-plotly.ipynb

Set up the OpenSees analysis parameters for a static load control simulation.

```python
ops.constraints("Transformation")
ops.numberer("RCM")
ops.system("BandGeneral")
ops.test("NormDispIncr", 1.0e-8, 6, 2)
ops.algorithm("Linear")
ops.integrator("LoadControl", 0.1)
ops.analysis("Static")
```

--------------------------------

### Configure Analysis and ODB

Source: https://github.com/yexiang92/opstool/blob/master/docs/src/post/fiber_sec_resp.ipynb

Sets up the analysis parameters and initializes an ODB object to record fiber section responses.

```python
maxU = 15.0  # Max displacement
currentDisp = 0.0
ok = 0

ops.test("NormDispIncr", 1.0e-6, 1000)
ops.algorithm("KrylovNewton")
```

```python
ODB = opst.post.CreateODB(odb_tag=1, save_fiber_sec_resp=True, fiber_ele_tags=[1, 2])
while ok == 0 and currentDisp < maxU:
    ok = ops.analyze(1)

    # if the analysis fails try initial tangent iteration
    if ok != 0:
        print("KrylovNewton failed")
        break

    ODB.fetch_response_step()

    currentDisp = ops.nodeDisp(3, 1)

ODB.save_response()
```

--------------------------------

### Create Geometry Points and Lines

Source: https://github.com/yexiang92/opstool/blob/master/docs/_sphinx_gallery_examples/examples/preprocessing/ex-read-gmsh-4.ipynb

Defines points and lines for the start section of the arch structure.

```python
lcar = 0.1  # characteristic mesh size density (will not be used)
bottom_points = [
    geom.addPoint(0, -wb / 2, -h / 2, lcar),
    geom.addPoint(0, 0, -h / 2, lcar),
    geom.addPoint(0, wb / 2, -h / 2, lcar),
]
top_points = [
    geom.addPoint(0, -wt / 2, h / 2, lcar),
    geom.addPoint(0, 0, h / 2, lcar),
    geom.addPoint(0, wt / 2, h / 2, lcar),
]
bottom_flange = [
    geom.addLine(bottom_points[0], bottom_points[1]),
    geom.addLine(bottom_points[1], bottom_points[2]),
]
web = [geom.addLine(bottom_points[1], top_points[1])]
top_flange = [
    geom.addLine(top_points[0], top_points[1]),
    geom.addLine(top_points[1], top_points[2]),
]
start_section = bottom_flange + web + top_flange
```

--------------------------------

### Define Model and Gravity Loads

Source: https://github.com/yexiang92/opstool/blob/master/docs/_sphinx_gallery_examples/vis-guide/plotly/ex-06-shell-resp-plotly.ipynb

Loads an example model and applies gravity loads in the Z direction.

```python
opst.load_ops_examples("Shell3D")

ops.timeSeries("Linear", 1)
ops.pattern("Plain", 1, 1)
_ = opst.pre.gen_grav_load(direction="Z", factor=-9810)
```

--------------------------------

### Get Element Response Information

Source: https://github.com/yexiang92/opstool/blob/master/docs/src/post/plane_up_resp.ipynb

Retrieves metadata about available response types for a given element type.

```python
info = opst.post.get_element_responses_info(ele_type="Plane")
```

--------------------------------

### Get Nodal Responses

Source: https://github.com/yexiang92/opstool/blob/master/docs/src/api/_autosummary/opstool.post.get_nodal_responses.rst

Retrieves nodal responses from the Opstool system. This function is part of the post module.

```APIDOC
## GET /yexiang92/opstool/get_nodal_responses

### Description
Retrieves nodal responses.

### Method
GET

### Endpoint
/yexiang92/opstool/get_nodal_responses

### Parameters
None specified.

### Request Example
None specified.

### Response
#### Success Response (200)
- **response_data** (object) - The retrieved nodal response data.

#### Response Example
```json
{
  "response_data": {
    "node_id_1": {
      "stress": [0.1, 0.2, 0.3],
      "strain": [0.01, 0.02, 0.03]
    },
    "node_id_2": {
      "stress": [0.4, 0.5, 0.6],
      "strain": [0.04, 0.05, 0.06]
    }
  }
}
```
```

--------------------------------

### Initialize Analysis and Save Response Data

Source: https://github.com/yexiang92/opstool/blob/master/docs/src/post/nodal_resp.ipynb

Sets up the analysis environment and saves response data to an ODB file.

```python
ops.analysis("Static")
```

```python
ODB = opst.post.CreateODB(odb_tag=1)
for _ in range(10):
    ops.analyze(1)
    ODB.fetch_response_step()
ODB.save_response()
```

--------------------------------

### Import opstool library

Source: https://github.com/yexiang92/opstool/blob/master/docs/_sphinx_gallery_examples/examples/sec-mesh/ex-cfst.ipynb

Initializes the opstool package for section modeling.

```python
import opstool as opst
```

--------------------------------

### Import Libraries for OpenSeesPy and Visualization

Source: https://github.com/yexiang92/opstool/blob/master/docs/_sphinx_gallery_examples/vis-guide/plotly/ex-07-plane-resp-plotly.ipynb

Imports necessary libraries for OpenSeesPy and its visualization tools. Ensure these libraries are installed.

```python
import openseespy.opensees as ops

import opstool
import opstool.vis.plotly as opsvis
```

--------------------------------

### Transient Analysis Warning Output

Source: https://github.com/yexiang92/opstool/blob/master/docs/_sphinx_gallery_examples/examples/postprocessing/ex-MRF-2Story-Concentrated-PanelZone.rst

Example of the warning message generated when an analysis is initialized without an explicit algorithm.

```none
WARNING analysis Transient - no Algorithm yet specified, 
 NewtonRaphson default will be used
```

--------------------------------

### Initialize OpenSeesPy Model

Source: https://github.com/yexiang92/opstool/blob/master/docs/_sphinx_gallery_examples/examples/preprocessing/ex-read-gmsh-3.ipynb

Sets up the basic OpenSeesPy environment for a 3D model.

```python
import openseespy.opensees as ops

import opstool as opst

ops.wipe()
ops.model("basic", "-ndm", 3, "-ndf", 6)
```

--------------------------------

### Initialize Gmsh Model

Source: https://github.com/yexiang92/opstool/blob/master/docs/_sphinx_gallery_examples/examples/preprocessing/ex-read-gmsh-4.ipynb

Sets up the Gmsh environment and adds a new model.

```python
gmsh.initialize()
gmsh.model.add(filename)
geom = gmsh.model.geo
```
Tokens:
Raw