OpenSeesPy

https://github.com/zhuminjie/openseespydoc
Admin
OpenSeesPy is a Python 3 interpreter of OpenSees that provides Python commands and examples for...
Tokens:289,075
Snippets:1,356
Trust Score:8.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### Install OpenSeesPy using pip

Source: https://github.com/zhuminjie/openseespydoc/blob/master/src/pypilinux.md

Installs the OpenSeesPy library using pip. It provides commands for both a system-wide installation and a user-specific installation.

```bash
python3 -m pip install openseespy
```

```bash
python3 -m pip install --user openseespy
```

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

### Parallel Truss Analysis Setup with OpenSeesPy

Source: https://github.com/zhuminjie/openseespydoc/blob/master/src/paralleltruss.md

This Python script sets up a parallel truss analysis using OpenSeesPy. It initializes the model, defines nodes, elements, materials, and loads, distributing them across processors. It requires the openseespy library and an MPI environment.

```python
import openseespy.opensees as ops

pid = ops.getPID()
np = ops.getNP()
ops.start()
if np != 2:
    exit()

ops.model('basic', '-ndm', 2, '-ndf', 2)
ops.uniaxialMaterial('Elastic', 1, 3000.0)

if pid == 0:
    ops.node(1, 0.0, 0.0)
    ops.node(4, 72.0, 96.0)

    ops.fix(1, 1, 1)

    ops.element('Truss', 1, 1, 4, 10.0, 1)
    ops.timeSeries('Linear', 1)
    ops.pattern('Plain', 1, 1)
    ops.load(4, 100.0, -50.0)

else:
    ops.node(2, 144.0, 0.0)
    ops.node(3, 168.0, 0.0)
    ops.node(4, 72.0, 96.0)

    ops.fix(2, 1, 1)
    ops.fix(3, 1, 1)

    ops.element('Truss', 2, 2, 4, 5.0, 1)
    ops.element('Truss', 3, 3, 4, 5.0, 1)

ops.constraints('Transformation')
ops.numberer('ParallelPlain')
ops.system('Mumps')
ops.test('NormDispIncr', 1e-6, 6, 2)
ops.algorithm('Newton')
ops.integrator('LoadControl', 0.1)
ops.analysis('Static')

ops.analyze(10)

print('Node 4: ', [ops.nodeCoord(4), ops.nodeDisp(4)])

ops.loadConst('-time', 0.0)

if pid == 0:
    ops.pattern('Plain', 2, 1)
    ops.load(4, 1.0, 0.0)

ops.domainChange()
ops.integrator('ParallelDisplacementControl', 4, 1, 0.1)
ops.analyze(10)

print('Node 4: ', [ops.nodeCoord(4), ops.nodeDisp(4)])
ops.stop()
```

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

### Run Parallel Truss Example with MPI

Source: https://github.com/zhuminjie/openseespydoc/blob/master/src/paralleltruss.md

This command executes the parallel truss Python script using two processors via MPI. Ensure OpenSeesPy and MPI are installed and configured correctly. The output will show node information and analysis progress.

```bash
mpiexec -np 2 python paralleltruss.py
```

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

### Install OpenSeesPy using pip

Source: https://github.com/zhuminjie/openseespydoc/blob/master/src/pypimac.md

This command installs the openseespy package for the current user. Ensure Python 3.8 is installed and accessible in your PATH.

```shell
python3.8 -m pip install openseespy
python3.8 -m pip install --user openseespy
```

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

### Install UMFPACK via Homebrew

Source: https://github.com/zhuminjie/openseespydoc/blob/master/src/compileqt.md

Installs the UMFPACK library, which provides routines for solving unsymmetric sparse linear systems, using Homebrew on macOS. UMFPACK is part of the suite-sparse library and automatically installs Metis as a dependency.

```bash
brew tap homebrew/science
brew install suite-sparse
```

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

### Install Python 3 on Ubuntu/Debian

Source: https://github.com/zhuminjie/openseespydoc/blob/master/src/pypilinux.md

Installs Python 3 and pip using the apt package manager on Ubuntu/Debian-based Linux distributions. This is a prerequisite for installing OpenSeesPy.

```bash
sudo apt install python3 python3-pip
```

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

### Install OpenSeesPy via Command Line (pip)

Source: https://github.com/zhuminjie/openseespydoc/blob/master/src/pypiwin.md

This snippet demonstrates how to install and upgrade the OpenSeesPy library using the pip package manager within an Anaconda Prompt on Windows. It includes commands for both regular and user-specific installations, as well as for upgrading the package.

```default
python -m pip install openseespy

python -m pip install --user openseespy
```

```default
python -m pip install --upgrade openseespy

python -m pip install --user --upgrade openseespy
```

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

### OpenSeesPy Setup and Node/Mass Definition for Column Analysis

Source: https://github.com/zhuminjie/openseespydoc/blob/master/src/nonlinearcanti2.md

Initializes the OpenSeesPy model, defines basic parameters like number of dimensions and degrees of freedom, sets up column geometry (length, depth, width), weight, and calculates mass based on gravity. It then defines the nodes for the column base and top, applies boundary conditions (fixed base), and assigns mass to the top node. Material and section tags are also initialized.

```python
# SET UP ----------------------------------------------------------------------------
import openseespy.opensees as op
#import the os module
import os
import math
op.wipe()
#########################################################################################################################################################################
#to create a directory at specified path with name "Data"
os.chdir('C:\\Opensees Python\\OpenseesPy examples')

#this will create the directory with name 'Data' and will update it when we rerun the analysis, otherwise we have to keep deleting the old 'Data' Folder
dir = "C:\\Opensees Python\\OpenseesPy examples\\Data-2c"
if not os.path.exists(dir):
    os.makedirs(dir)
#this will create just 'Data' folder    
#os.mkdir("Data")    
#detect the current working directory
#path1 = os.getcwd()
#print(path1)
#########################################################################################################################################################################

#########################################################################################################################################################################
op.model('basic', '-ndm', 2, '-ndf', 3) 
LCol = 432.0 # column length
Weight = 2000.0 # superstructure weight

# define section geometry
HCol = 60.0 # Column Depth
BCol = 60.0 # Column Width

PCol =Weight  # nodal dead-load weight per column
g = 386.4
Mass =  PCol/g

ACol = HCol*BCol*1000  # cross-sectional area, make stiff
IzCol = (BCol*math.pow(HCol,3))/12 # Column moment of inertia

op.node(1, 0.0, 0.0)
op.node(2, 0.0, LCol)

op.fix(1, 1, 1, 1)

op.mass(2, Mass, 1e-9, 0.0)

ColSecTag = 1			# assign a tag number to the column section
coverCol = 5.0   # Column cover to reinforcing steel NA. 
numBarsCol = 16  # number of longitudinal-reinforcement bars in column. (symmetric top & bot)
barAreaCol = 2.25  # area of longitudinal-reinforcement bars

# MATERIAL parameters
IDconcU = 1 			# material ID tag -- unconfined cover concrete (here used for complete section)
IDreinf = 2 			# material ID tag -- reinforcement

# nominal concrete compressive strength
fc = -4.0 				# CONCRETE Compressive Strength (+Tension, -Compression)
ec = 57*math.sqrt(-fc*1000) # Concrete Elastic Modulus (the term in sqr root needs to be in psi

```

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

### Install SUPERLU via Homebrew

Source: https://github.com/zhuminjie/openseespydoc/blob/master/src/compileqt.md

Installs the SUPERLU library for solving large, sparse, nonsymmetric systems of linear equations using Homebrew on macOS. It is typically installed with OpenMP enabled for parallel analysis and requires GCC and OpenBLAS as dependencies.

```bash
brew install superlu
```

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

### Install OpenMPI via Homebrew

Source: https://github.com/zhuminjie/openseespydoc/blob/master/src/compileqt.md

Installs the OpenMPI high-performance message passing library using Homebrew on macOS. OpenMPI requires GCC and libevent as dependencies, which are installed automatically.

```bash
brew install open-mpi
```

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

### Import Libraries for Spaced Nonlinear SDOF Example

Source: https://github.com/zhuminjie/openseespydoc/blob/master/src/exampleNamedSpacedNonlinearSDOF.md

Imports essential Python libraries for the OpenSeesPy SDOF example. Requires numpy for numerical operations, matplotlib for plotting, eqsig for earthquake signal processing, and openseespy for structural analysis.

```python
import requests
import eqsig
import matplotlib.pyplot as plt
import numpy as np
from os.path import exists

import openseespy.opensees as op
```

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

### Install SUPERLUMT via Homebrew

Source: https://github.com/zhuminjie/openseespydoc/blob/master/src/compileqt.md

Installs the SUPERLUMT library, a shared-memory parallel version of SUPERLU that provides Pthreads and OpenMP interfaces, using Homebrew on macOS. It requires OpenBLAS as a dependency.

```bash
brew install superlu_mt
```

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

### OpenSeesPy Parallel Communication Example

Source: https://github.com/zhuminjie/openseespydoc/blob/master/src/hello2.md

This Python script utilizes OpenSeesPy's MPI wrapper to perform parallel operations. It demonstrates sending data from worker processes to the master (pid 0), receiving ordered data, and broadcasting messages. Key functions include ops.getPID(), ops.getNP(), ops.send(), ops.recv(), ops.barrier(), and ops.Bcast().

```python
import openseespy.opensees as ops

pid = ops.getPID()
np = ops.getNP()

# datatype = 'float'
# datatype = 'int'
datatype = 'str'

if pid == 0:
    print('Random: ')

    for i in range(1, np):
        data = ops.recv('-pid', 'ANY')
        print(data)
else:
    if datatype == 'str':
        ops.send('-pid', 0, 'Hello from {}'.format(pid))
    elif datatype == 'float':
        ops.send('-pid', 0, float(pid))
    elif datatype == 'int':
        ops.send('-pid', 0, int(pid))

ops.barrier()

if pid == 0:
    print('\nOrdered: ')

    for i in range(1, np):
        data = ops.recv('-pid', i)
        print(data)
else:
    if datatype == 'str':
        ops.send('-pid', 0, 'Hello from {}'.format(pid))
    elif datatype == 'float':
        ops.send('-pid', 0, float(pid))
    elif datatype == 'int':
        ops.send('-pid', 0, int(pid))

ops.barrier()
if pid == 0:
    print('\nBroadcasting: ')
    if datatype == 'str':
        ops.Bcast('Hello from {}'.format(pid))
    elif datatype == 'float':
        ops.Bcast(float(pid))
    elif datatype == 'int':
        ops.Bcast(int(pid))
else:
    data = ops.Bcast()
    print(data)

```

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

### Run OpenSeesPy Parallel Script

Source: https://github.com/zhuminjie/openseespydoc/blob/master/src/hello2.md

This command executes the 'hello2.py' script using 4 processors via mpiexec. It demonstrates how to launch parallel OpenSeesPy simulations and is a fundamental step for distributed analysis.

```bash
mpiexec -np 4 python hello2.py
```

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

### Run OpenSeesPy Hello World with MPI

Source: https://github.com/zhuminjie/openseespydoc/blob/master/src/hello.md

This snippet shows how to execute the OpenSeesPy 'Hello World' script using MPI with 4 processors. It requires the 'hello.py' script to be present and assumes an MPI environment is configured.

```bash
mpiexec -np 4 python hello.py
```

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

### Install Python 3 on CentOS/Redhat

Source: https://github.com/zhuminjie/openseespydoc/blob/master/src/pypilinux.md

Installs Python 3 and pip using the yum package manager on CentOS/Redhat-based Linux distributions. This is a prerequisite for installing OpenSeesPy.

```bash
sudo yum install python3 python3-pip
```

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

### Setup OpenSeesPy Model and Directory

Source: https://github.com/zhuminjie/openseespydoc/blob/master/src/portal2deq.md

Initializes OpenSeesPy, sets up the model dimensions, creates a directory for output files if it doesn't exist, and defines nodes with fixed or free boundary conditions. It also assigns mass to specific nodes.

```python
import openseespy.opensees as op
import os
op.wipe()
op.model('basic', '-ndm', 2, '-ndf', 3)

dir = "Data-1b"
if not os.path.exists(dir):
    os.makedirs(dir)

h = 432.0
w  =  504.0

op.node(1, 0.0, 0.0)
op.node(2, h, 0.0)
op.node(3, 0.0, w)
op.node(4, h, w)

op.fix(1, 1,1,1)
op.fix(2, 1,1,1)
op.fix(3, 0,0,0)
op.fix(4, 0,0,0)

op.mass(3, 5.18, 0.0, 0.0)
op.mass(4, 5.18, 0.0, 0.0)
```

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

### Perform Static Analysis with Nonlinear Solvers

Source: https://context7.com/zhuminjie/openseespydoc/llms.txt

This Python snippet outlines the setup for static analysis in OpenSeesPy. It includes configuring the system of equations solver, constraint handler, DOF numberer, convergence test, solution algorithm, and integrator. The 'analyze' command then performs the static analysis.

```python
import openseespy.opensees as ops

# Model setup (abbreviated)
ops.wipe()
ops.model('basic', '-ndm', 2, '-ndf', 3)
# ... create nodes, materials, elements, loads ...

# Define system of equations solver
ops.system('BandGeneral')  # or 'BandSPD', 'ProfileSPD', 'SparseGeneral'

# Define constraint handler
ops.constraints('Transformation')  # or 'Plain', 'Penalty', 'Lagrange'

# Define DOF numberer
ops.numberer('RCM')  # Reverse Cuthill-McKee algorithm

# Define convergence test
ops.test('NormDispIncr', 1.0e-12, 10, 3)  # tolerance, maxIter, printFlag

# Define solution algorithm
ops.algorithm('Newton')  # or 'Linear', 'ModifiedNewton', 'NewtonLineSearch'

# Define integrator
ops.integrator('LoadControl', 0.1)  # load step

# Create analysis object
ops.analysis('Static')

# Perform analysis
ops.analyze(10)  # 10 load steps

# Extract results
u = ops.nodeDisp(2, 1)  # x-displacement at node 2
forces = ops.eleResponse(1, 'forces')
```

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

### Set Up Model Nodes and Boundary Conditions (OpenSeespy)

Source: https://github.com/zhuminjie/openseespydoc/blob/master/src/columneq.md

Initializes the OpenSeespy model by defining nodes, their coordinates, and fixing degrees of freedom for boundary conditions. Node 1 is fixed, while Node 2 is placed at a height LCol.

```python
import openseespy.opensees as op

op.node(1, 0.0, 0.0)
op.node(2, 0.0, LCol)

op.fix(1, 1, 1, 1)
```

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

### Install boost using MacPorts

Source: https://github.com/zhuminjie/openseespydoc/blob/master/src/compilemac.md

Installs the boost libraries using MacPorts. Boost is a collection of C++ libraries that OpenSees depends on.

```bash
sudo port install boost
```

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

### Install gcc8 using MacPorts

Source: https://github.com/zhuminjie/openseespydoc/blob/master/src/compilemac.md

Installs the gcc8 compiler using the MacPorts package manager. This compiler is a dependency for compiling OpenSees.

```bash
sudo port install gcc8
```

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

### OpenSeesPy Hello World Script

Source: https://github.com/zhuminjie/openseespydoc/blob/master/src/hello.md

This Python script uses the OpenSeesPy library to print a 'Hello World' message along with its process ID (PID) and the total number of processes (NP). It's designed for parallel execution via MPI.

```python
import openseespy.opensees as ops

pid = ops.getPID()
np = ops.getNP()

print('Hello World Process:', pid)
if pid == 0:
    print('Total number of processes:', np)

```

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

### Configure and Perform Pushover Analysis

Source: https://github.com/zhuminjie/openseespydoc/blob/master/src/ThreeStorySteel.md

Sets up and executes a static pushover analysis. This involves defining a pushover load pattern, controlling displacement at a specific node and DOF, and setting up analysis parameters. It also defines recorders to save nodal reactions and displacements, and element stresses.

```python
if(AnalysisType=="Pushover"):
	
	print("<<<< Running Pushover Analysis >>>>")

	# Create load pattern for pushover analysis
	# create a plain load pattern
	pattern("Plain", 2, 1)

	load(11, 1.61, 0.0, 0.0)
	load(21, 3.22, 0.0, 0.0)
	load(31, 4.83, 0.0, 0.0)
	
	ControlNode=31
	ControlDOF=1
	MaxDisp=0.15*H_story
	DispIncr=0.1
	NstepsPush=int(MaxDisp/DispIncr)
	
system("ProfileSPD")
	numberer("Plain")
	constraints("Plain")
	integrator("DisplacementControl", ControlNode, ControlDOF, DispIncr)
	algorithm("Newton")
	test('NormUnbalance',1e-8, 10)
	analysis("Static")
	
	PushDataDir = r'PushoverOut'
	if not os.path.exists(PushDataDir):
		os.makedirs(PushDataDir)
	recorder('Node', '-file', "PushoverOut/Node2React.out", '-closeOnWrite', '-node', 2, '-dof',1, 'reaction')
	recorder('Node', '-file', "PushoverOut/Node31Disp.out", '-closeOnWrite', '-node', 31, '-dof',1, 'disp')
	recorder('Element', '-file', "PushoverOut/BeamStress.out", '-closeOnWrite', '-ele', 102, 'section', '4', 'fiber','1', 'stressStrain')

	# analyze(NstepsPush)

	# Perform pushover analysis
	dataPush = np.zeros((NstepsPush+1,5))
	for j in range(NstepsPush):
		analyze(1)
		dataPush[j+1,0] = nodeDisp(31,1)
		reactions()
		dataPush[j+1,1] = nodeReaction(1, 1) + nodeReaction(2, 1) + nodeReaction(3, 1)
		
	plt.plot(dataPush[:,0], -dataPush[:,1])
	plt.xlim(0, MaxDisp)
	plt.xticks(np.linspace(0,MaxDisp,5,endpoint=True))
	plt.yticks(np.linspace(0, -int(dataPush[NstepsPush,1]),10,endpoint=True))
	plt.grid(linestyle='dotted') 
	plt.xlabel('Top Displacement (inch)')
	plt.ylabel('Base Shear (kip)')
	plt.show()
	
	
	print("Pushover analysis complete")
```

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

### Install Python 3.8 using MacPorts

Source: https://github.com/zhuminjie/openseespydoc/blob/master/src/compilemac.md

Installs Python 3.8 and its development files using MacPorts. This is required for OpenSees to interface with Python.

```bash
sudo port install python38 python38-devel
```

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

### Configure and Perform Static Gravity Analysis

Source: https://github.com/zhuminjie/openseespydoc/blob/master/src/ThreeStorySteel.md

Sets up and executes a static analysis for gravity loads. This includes defining analysis parameters like number of steps, system solver, numberer, constraints, integrator, algorithm, and test criteria. It then iterates through analysis steps, recording displacements and load factors.

```tcl
NstepsGrav = 10

system("BandGEN")
numberer("Plain")
constraints("Plain")
integrator("LoadControl", 1.0/NstepsGrav)
algorithm("Newton")
test('NormUnbalance',1e-8, 10)
analysis("Static")

# perform the analysis
data = np.zeros((NstepsGrav+1,2))
for j in range(NstepsGrav):
    analyze(1)
    data[j+1,0] = nodeDisp(31,2)
    data[j+1,1] = getLoadFactor(1)*5

loadConst('-time', 0.0)
	 
print("Gravity analysis complete")

wipeAnalysis()
```

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

### Upgrade OpenSeesPy using pip

Source: https://github.com/zhuminjie/openseespydoc/blob/master/src/pypimac.md

These commands upgrade an existing openseespy installation to the latest version. It's recommended to use the --user flag for broader compatibility.

```shell
python3.8 -m pip install --upgrade openseespy
python3.8 -m pip install --user --upgrade openseespy
```

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

### Adding OpenSeesPy to Python Path

Source: https://github.com/zhuminjie/openseespydoc/blob/master/src/windows.rst

This code snippet demonstrates how to add the directory containing the 'opensees.pyd' library file to the Python system path. This is necessary for Python to locate and import the OpenSeesPy module. Ensure the provided path is replaced with the actual location of your OpenSeesPy installation.

```python
import sys
sys.path.append('C:/path/to/OpenSeesPy')
```

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

### Pushover Analysis Setup and Execution in OpenSeesPy

Source: https://github.com/zhuminjie/openseespydoc/blob/master/src/RCshearwall.md

This snippet configures and runs a static pushover analysis. It defines analysis parameters, applies a unit load, sets up the solver, and records nodal displacements and reactions. Dependencies include the 'os' and 'numpy' libraries.

```python
if(AnalysisType=="Pushover"):
	
	print("<<<< Running Pushover Analysis >>>>")

	# create a plain load pattern for pushover analysis
	pattern("Plain", 2, 1)
	
	ControlNode=53
	ControlDOF=1
	MaxDisp= 0.020
	DispIncr=0.00001
	NstepsPush=int(MaxDisp/DispIncr)
	
	load(ControlNode, 1.00, 0.0, 0.0, 0.0, 0.0, 0.0)  # Apply a unit reference load in DOF=1
	
system("BandGeneral")
	numberer("RCM")
	constraints('Penalty',1e20,1e20)
	integrator("DisplacementControl", ControlNode, ControlDOF, DispIncr)
	algorithm('KrylovNewton')
	test('NormDispIncr',1e-05, 1000, 2)
	analysis("Static")
	
	# Create a folder to put the output
	PushDataDir = r'PushoverOut'
	if not os.path.exists(PushDataDir):
		os.makedirs(PushDataDir)
	recorder('Node', '-file', "PushoverOut/React.out", '-closeOnWrite', '-node', 1, 2, 3, 4, 5, '-dof',1, 'reaction')
	recorder('Node', '-file', "PushoverOut/Disp.out", '-closeOnWrite', '-node', ControlNode, '-dof',1, 'disp')

	# Perform pushover analysis
	dataPush = np.zeros((NstepsPush+1,5))
	for j in range(NstepsPush):
		analyze(1)
		dataPush[j+1,0] = nodeDisp(ControlNode,1)*1000		# Convert to mm
		dataPush[j+1,1] = -getLoadFactor(2)*0.001		# Convert to kN
	
	print("Pushover analysis complete")
```

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

### Add OpenSeesPy to Python Path (sys.path)

Source: https://github.com/zhuminjie/openseespydoc/blob/master/src/linux.rst

This snippet demonstrates how to programmatically add the directory containing the OpenSeesPy library to Python's system path. This is useful for ensuring that Python can import the 'opensees' module. No external dependencies are required beyond a standard Python installation.

```python
import sys
sys.path.append('/path/to/OpenSeesPy')
```

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

### Project Configuration

Source: https://github.com/zhuminjie/openseespydoc/blob/master/src/partmesh.md

This section details the configuration parameters for a project, specifically focusing on initial velocities and pressure.

```APIDOC
## Project Configuration Parameters

### Description
This endpoint or configuration section allows for setting initial conditions for a project, including a list of initial velocities and an initial pressure value.

### Method
N/A (Configuration Parameters)

### Endpoint
N/A (Configuration Parameters)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **vel0** (list[float]) - Optional - A list of initial velocities.
- **p0** (float) - Optional - The initial pressure value.
```

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

### Upgrade OpenSeesPy using pip

Source: https://github.com/zhuminjie/openseespydoc/blob/master/src/pypilinux.md

Upgrades the OpenSeesPy library to the latest version using pip. It includes options for both system-wide and user-specific upgrades.

```bash
python3 -m pip install --upgrade openseespy
```

```bash
python3 -m pip install --user --upgrade openseespy
```

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

### Get Node Mass (Python)

Source: https://github.com/zhuminjie/openseespydoc/blob/master/src/nodeMass.md

Retrieves the mass at a specified node using the nodeMass command in Openseespy. It can return mass for all degrees of freedom or a specific one. This function is part of the Openseespy library.

```python
import openseespy.opensees as ops

# Example usage:
# Define a node
ops.node(1, 0.0, 0.0)

# Set nodal mass (example)
ops.mass(1, 1000.0, 1000.0, 1000.0)

# Get mass at node 1 for all dofs
all_mass = ops.nodeMass(1)
print(f"Mass at node 1 (all dofs): {all_mass}")

# Get mass at node 1 for the first dof
first_dof_mass = ops.nodeMass(1, 1)
print(f"Mass at node 1 (dof 1): {first_dof_mass}")
```

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

### Setup Rayleigh Damping (Opensees)

Source: https://github.com/zhuminjie/openseespydoc/blob/master/src/nonlinearcanti2.md

Configures Rayleigh damping for the analysis. It calculates the modal frequency and damping ratio based on the first mode and defines the mass-proportional and stiffness-proportional damping coefficients. The 'rayleigh' command is then used to apply these parameters.

```tcl
#applying Dynamic Ground motion analysis
GMdirection = 1
GMfile = 'BM68elc.acc'
GMfact = 1.0

Lambda = op.eigen('-fullGenLapack', 1)
import math
Omega = math.pow(Lambda, 0.5)
betaKcomm = 2 * (0.02/Omega)

xDamp = 0.02
alphaM = 0.0
betaKcurr = 0.0
betaKinit = 0.0

op.rayleigh(alphaM,betaKcurr, betaKinit, betaKcomm)
```

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

### Create AccSignal and Show Comparison - Openseespy

Source: https://github.com/zhuminjie/openseespydoc/blob/master/src/exampleNamedSpacedNonlinearSDOF.md

Initializes an AccSignal object with ground motion data and its time step, then calls a function to display a single comparison plot. This demonstrates the use of openseespy's signal processing and plotting capabilities.

```python
eq_motion_dt = 0.01

    acc_signal = eqsig.AccSignal(eq_motion, eq_motion_dt)

    ### Running Analysis #############
    show_single_comparison(acc_signal)
```

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

### Start Jupyter Notebook in WSL

Source: https://github.com/zhuminjie/openseespydoc/blob/master/src/wsl.md

Launches the Jupyter Notebook server from the WSL terminal. The provided URL should be copied to a web browser to access the interface.

```bash
~$ /home/username/anaconda3/bin/jupyter-notebook
```

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

### Set PYTHONPATH Environment Variable

Source: https://github.com/zhuminjie/openseespydoc/blob/master/src/linux.rst

This code snippet shows how to set the PYTHONPATH environment variable in a bash shell to include the OpenSeesPy library directory. This method configures the Python interpreter to find the 'opensees' module without needing to modify Python scripts directly. This is a common practice for managing Python package locations.

```bash
export PYTHONPATH="$PYTHONPATH:$HOME/OpenSeesPy"
```

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

### Set Up Transient Analysis (OpenSeespy)

Source: https://github.com/zhuminjie/openseespydoc/blob/master/src/columneq.md

Configures and performs a transient dynamic analysis using the Newmark integration scheme. This includes setting up the analysis algorithm, integrator, and specifying the time step and total analysis duration.

```python
op.wipeAnalysis()
op.constraints('Transformation')
op.numberer('Plain')
op.system('BandGeneral')
op.test('EnergyIncr', Tol, 1000)
op.algorithm('ModifiedNewton')

NewmarkGamma = 0.5
NewmarkBeta = 0.25
op.integrator('Newmark', NewmarkGamma, NewmarkBeta)
op.analysis('Transient')

DtAnalysis = 0.01
TmaxAnalysis = 10.0

Nsteps =  int(TmaxAnalysis/ DtAnalysis)

ok = op.analyze(Nsteps, DtAnalysis)
tCurrent = op.getTime()
```

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

### Analysis Setup (Transient) in OpenSeesPy

Source: https://github.com/zhuminjie/openseespydoc/blob/master/src/pm4sand_cyc_cal.md

Configures the analysis settings for a transient analysis, including constraints, testing criteria, algorithm, numbering scheme, system solver, integration method (Newmark), Rayleigh damping, and the analysis type.

```python
op.constraints('Transformation')
op.test('NormDispIncr', 1.0e-5, 35, 1)
op.algorithm('Newton')
op.numberer('RCM')
op.system('FullGeneral')
op.integrator('Newmark', 5.0/6.0, 4.0/9.0)
op.rayleigh(a1, a0, 0.0, 0.0) #modification
op.analysis('Transient')
```
Tokens:
Raw