def PDelta_analysis(Nnodes, P, steps, tol, max_iter):
tsTag = 1
ops.timeSeries('Linear', tsTag)
pattTag = 1
ops.pattern('Plain', pattTag, tsTag)
ops.load(Nnodes, *P)
##########################################################################
ops.constraints('Plain')
ops.numberer('RCM')
ops.system('BandGeneral')
ops.test('NormUnbalance', tol, max_iter)
ops.algorithm('Newton')
temp = 1 / steps
ops.integrator('LoadControl', temp)
ops.analysis('Static')
ops.analyze(steps)
##########################################################################
opsplt.plot_model('nodes')
##########################################################################
ops.wipe()
def analysis(P, du, steps, tol, max_iter):
tsTag = 1
ops.timeSeries('Linear', tsTag)
pattTag = 1
ops.pattern('Plain', pattTag, tsTag)
ops.load(2, *P)
##########################################################################
ops.constraints('Plain')
ops.numberer('RCM')
ops.system('BandGeneral')
ops.test('NormUnbalance', tol, max_iter)
ops.algorithm('Newton')
ops.integrator('DisplacementControl', 2, 2, du, max_iter)
ops.analysis('Static')
ops.analyze(steps)
##########################################################################
opsplt.plot_model()
##########################################################################
ops.wipe()
def main():
log_init(flag="Author: Mengsen Wang\n", filename='test.log')
ops_model()
ops_node()
ops_material()
ops_element()
ops.printModel()
opsplt.plot_model('elements')
def test_plot_fn(monkeypatch):
# repress the show plot attribute
monkeypatch.setattr(plt, 'show', lambda: None)
Model_2D()
opp.plot_model()
plt.close()
assert True
def test_plot_model_3D_Active(monkeypatch):
# repress the show plot attribute
monkeypatch.setattr(plt, 'show', lambda: None)
RunAnalysis()
opp.plot_model('nodes', 'elements')
plt.close()
assert True == True
def main():
log_init(flag="Author: Mengsen Wang\n", filename='test.log')
logger.info("dispBeamColumn + shell")
ops_model()
ops_node()
ops_material()
ops_element()
# ops.printModel()
opsplt.plot_model('element')
def test_plot_model_3D_ODB(monkeypatch):
# repress the show plot attribute
monkeypatch.setattr(plt, 'show', lambda: None)
RunAnalysis()
ops.wipe()
Model = 'test'
opp.plot_model('nodes', 'elements', Model=Model)
plt.close()
assert True == True
def test_plot_modeshape_3D_Active(monkeypatch):
# repress the show plot attribute
monkeypatch.setattr(plt, 'show', lambda: None)
RunAnalysis()
opp.plot_modeshape(1, 200)
plt.close()
opp.plot_modeshape(2, 200)
plt.close()
assert True == True
def Model_Build(x, y, A, E):
'''
Description
-----------
This function is used to determine the basic parameters of the structural
problem at hand.
Parameters
----------
x : LIST OF FLOATS
The list of the coordinates of the nodes along the x-axis.
y : LIST OF FLOATS
The list of the coordinates of the nodes along the y-axis.
A : LIST OF FLOATS
The list with the materials used for the different elements.
E : FLOAT
The modulus of elesticity of the elements.
Returns
-------
None.
'''
# Delete existing model.
ops.wipe()
# Define the model.
ops.model('basic', '-ndm', 2, '-ndf', 3)
# Define materials.
ops.uniaxialMaterial('Elastic', 1, E)
# Define the nodes.
m = len(x)
[ops.node(i + 1, *[x[i], y[i]]) for i in range(m)]
# Fix the nodes.
fixxity = [[0, 0, 1], [0, 1, 1], [1, 0, 1], [1, 1, 1]]
[
ops.fix(i +
1, *fixxity[3]) if i + 1 != 4 else ops.fix(i + 1, *fixxity[0])
for i in range(m)
]
# Define elements.
conn = [[1, 4], [2, 4], [3, 4]]
[
ops.element('Truss', i + 1, *conn[i], A[1], 1)
if i != 0 else ops.element('Truss', i + 1, *conn[i], A[0], 1)
for i in range(len(conn))
]
# Plot model.
opsplt.plot_model()
def test_plot_modeshape_2D(monkeypatch):
# repress the show plot attribute
monkeypatch.setattr(plt, 'show', lambda: None)
Model = 'test'
LoadCase = 'Pushover'
RunAnalysis()
ops.wipe()
opp.plot_modeshape(1, 200, Model = Model)
plt.close()
opp.plot_modeshape(2, 200, Model = Model)
plt.close()
assert True == True
def test_animation_2D(monkeypatch):
# repress the show plot attribute
monkeypatch.setattr(plt, 'show', lambda: None)
Model = 'test'
LoadCase = 'Pushover'
dt = 0.2
RunAnalysis()
ops.wipe()
ani = opp.animate_deformedshape(Model, LoadCase, dt, scale=10)
plt.close()
def test_plot_fiberResponse2D_section_2(monkeypatch):
# repress the show plot attribute
monkeypatch.setattr(plt, 'show', lambda: None)
main.RunAnalysis()
op.wipe()
Model = 'test'
LoadCase = 'Pushover'
element2 = 2
section2 = 3
opp.plot_fiberResponse2D(Model,
LoadCase,
element2,
section2,
InputType='stress',
tstep=1)
plt.close()
assert True == True
def test_animate_deformedshape_3D(monkeypatch):
# repress the show plot attribute
monkeypatch.setattr(plt, 'show', lambda: None)
RunAnalysis()
ops.wipe()
dt = 0.2
Model = 'test'
LoadCase = 'Transient'
ani = opp.animate_deformedshape(Model, LoadCase, dt, scale=30)
plt.close()
assert True == True
def test_readODB():
[nodes, elements, NodeDisp, Reaction,
EleForce] = opp.readODB('TestModel', 'TestLoadCase')
# [nodes, elements, NodeDisp] = opp.readODB('TestModel', 'TestLoadCase')
# We don't check everything, we just do a few manual tests.
check1 = np.all(nodes == np.ones([10, 3]) * 0)
check2 = np.all(elements[4] == np.array([1., 1., 1.]))
check3 = np.all(EleForce == np.ones([10, 3]) * 6)
# check4 = len(EleStress[:,0]) == 10
check = np.all([check1, check2, check3])
# check = np.all([check1,check2])
assert check == True
# return check
# test_readODB()
def test_animate_fiberResponse2D_Section1(monkeypatch):
# repress the show plot attribute
monkeypatch.setattr(plt, 'show', lambda: None)
main.RunAnalysis()
op.wipe()
Model = 'test'
LoadCase = 'Pushover'
element1 = 1
section1 = 1
ani1 = opp.animate_fiberResponse2D(Model,
LoadCase,
element1,
section1,
InputType='stress',
rFactor=4)
plt.close()
assert True == True
def test_plot_deformedshape_2D(monkeypatch):
# repress the show plot attribute
monkeypatch.setattr(plt, 'show', lambda: None)
Model = 'test'
LoadCase = 'Pushover'
RunAnalysis()
ops.wipe()
opp.plot_deformedshape(Model, LoadCase)
plt.close()
opp.plot_deformedshape(Model, LoadCase, tstep = 12, scale = 10, overlap = 'yes')
plt.close()
opp.plot_deformedshape(Model, LoadCase, tstep = 3.1231, overlap = 'yes')
plt.close()
assert True == True
def RunAnalysis():
op.wipe()
# Build Model
mf.getSections()
mf.buildModel()
# Prepare Outputs
Model = 'test'
LoadCase = 'Pushover'
element1 = 1
section1 = 1
element2 = 2
section2 = 3
opp.createODB(Model, LoadCase)
opp.saveFiberData2D(Model, LoadCase, element1, section1)
opp.saveFiberData2D(Model, LoadCase, element2, section2)
# Run Analysis
af.PushoverLcD(0.001)
op.wipe()
# Load control with Disp
# =============================================================================
op.wipe()
# Build Model
mf.getSections()
mf.buildModel()
# Show Model
# opp.plot_model('node', 'elements')
# Create Database
Model = 'Cantilever'
LoadCase = 'PushoverLcD'
opp.createODB(Model, LoadCase)
eleNumber = 1
sectionNumber = 1
opp.saveFiberData2D(Model, LoadCase, eleNumber, sectionNumber)
# Run Analysis
af.PushoverLcD(0.05)
out = op.eleResponse(1, 'section', '1', 'fiberData')
op.wipe()
opp.plot_fiberResponse2D(Model, LoadCase, eleNumber, sectionNumber)
opp.plot_fiberResponse2D(Model,
LoadCase,
import openseespy.postprocessing.Get_Rendering as opsplt
opsplt.plot_model("node", Model="CantiBeam")
opsplt.plot_deformedshape(Model="CantiBeam",LoadCase="Push", overlap="no", tstep=2.0, scale=1.0)
opsplt.plot_deformedshape(Model="CantiBeam",LoadCase="Push", overlap="no", scale=1.0)
ani=opsplt.animate_deformedshape(Model="CantiBeam",LoadCase="Push",dt=0.01, scale=1, timeScale=10, Movie = "CantiBeam")
def test_plot_deformedshape_3D(monkeypatch):
# repress the show plot attribute
monkeypatch.setattr(plt, 'show', lambda: None)
RunAnalysis()
ops.wipe()
Model = 'test'
LoadCase = 'Transient'
LoadCase2 = 'Transient_5s'
# Deformed shape time steps, one that uses an exact step and one that doesn't
opp.plot_deformedshape(Model, LoadCase, tstep=3.1231, overlap='yes')
plt.close()
opp.plot_deformedshape(Model, LoadCase, tstep=3., overlap='yes')
plt.close()
opp.plot_deformedshape(Model, LoadCase, tstep=3.)
plt.close()
opp.plot_deformedshape(Model, LoadCase2, tstep=3.1231, overlap='yes')
plt.close()
opp.plot_deformedshape(Model, LoadCase2, tstep=3., overlap='yes')
plt.close()
opp.plot_deformedshape(Model, LoadCase2, tstep=3.)
plt.close()
assert True == True
ops.analysis('Static')
ok = ops.analyze(100)
logger.info("gravity analyze result is %s", ok == 0)
def ops_cyclic():
ops.remove('recorders')
ops.wipeAnalysis()
ops.loadConst('-time', 0.0)
# set hysteresis
ops.recorder('Node', '-file', 'output\\cyclic_657.out',
'-time', '-node', 81, '-dof', 1, 'disp')
ops.pattern('Plain', 2, 1)
ops.load(81, 1, 0, 0, 0, 0, 0)
CyclicDisplace(1e-3, 80, 1e-3, 81, 1, 1, 1e6)
if __name__ == '__main__':
ops_init()
ops_node()
ops_material()
ops_section()
ops_element()
ops_gravity()
ops_cyclic()
ops.printModel()
opsplt.plot_model('element')
ops.stop()
pass
def RunAnalysis():
AnalysisType = 'Pushover'
# Pushover Gravity
## ------------------------------
## Start of model generation
## -----------------------------
# remove existing model
ops.wipe()
# set modelbuilder
ops.model('basic', '-ndm', 2, '-ndf', 3)
import math
############################################
### Units and Constants ###################
############################################
inch = 1
kip = 1
sec = 1
# Dependent units
sq_in = inch * inch
ksi = kip / sq_in
ft = 12 * inch
# Constants
g = 386.2 * inch / (sec * sec)
pi = math.acos(-1)
#######################################
##### Dimensions
#######################################
# Dimensions Input
H_story = 10.0 * ft
W_bayX = 16.0 * ft
W_bayY_ab = 5.0 * ft + 10.0 * inch
W_bayY_bc = 8.0 * ft + 4.0 * inch
W_bayY_cd = 5.0 * ft + 10.0 * inch
# Calculated dimensions
W_structure = W_bayY_ab + W_bayY_bc + W_bayY_cd
################
### Material
################
# Steel02 Material
matTag = 1
matConnAx = 2
matConnRot = 3
Fy = 60.0 * ksi
# Yield stress
Es = 29000.0 * ksi
# Modulus of Elasticity of Steel
v = 0.2
# Poisson's ratio
Gs = Es / (1 + v)
# Shear modulus
b = 0.10
# Strain hardening ratio
params = [18.0, 0.925, 0.15] # R0,cR1,cR2
R0 = 18.0
cR1 = 0.925
cR2 = 0.15
a1 = 0.05
a2 = 1.00
a3 = 0.05
a4 = 1.0
sigInit = 0.0
alpha = 0.05
ops.uniaxialMaterial('Steel02', matTag, Fy, Es, b, R0, cR1, cR2, a1, a2,
a3, a4, sigInit)
# ##################
# ## Sections
# ##################
colSecTag1 = 1
colSecTag2 = 2
beamSecTag1 = 3
beamSecTag2 = 4
beamSecTag3 = 5
# COMMAND: section('WFSection2d', secTag, matTag, d, tw, bf, tf, Nfw, Nff)
ops.section('WFSection2d', colSecTag1, matTag, 10.5 * inch, 0.26 * inch,
5.77 * inch, 0.44 * inch, 15, 16) # outer Column
ops.section('WFSection2d', colSecTag2, matTag, 10.5 * inch, 0.26 * inch,
5.77 * inch, 0.44 * inch, 15, 16) # Inner Column
ops.section('WFSection2d', beamSecTag1, matTag, 8.3 * inch, 0.44 * inch,
8.11 * inch, 0.685 * inch, 15, 15) # outer Beam
ops.section('WFSection2d', beamSecTag2, matTag, 8.2 * inch, 0.40 * inch,
8.01 * inch, 0.650 * inch, 15, 15) # Inner Beam
ops.section('WFSection2d', beamSecTag3, matTag, 8.0 * inch, 0.40 * inch,
7.89 * inch, 0.600 * inch, 15, 15) # Inner Beam
# Beam size - W10x26
Abeam = 7.61 * inch * inch
IbeamY = 144. * (inch**4)
# Inertia along horizontal axis
IbeamZ = 14.1 * (inch**4)
# inertia along vertical axis
# BRB input data
Acore = 2.25 * inch
Aend = 10.0 * inch
LR_BRB = 0.55
# ###########################
# ##### Nodes
# ###########################
# Create All main nodes
ops.node(1, 0.0, 0.0)
ops.node(2, W_bayX, 0.0)
ops.node(3, 2 * W_bayX, 0.0)
ops.node(11, 0.0, H_story)
ops.node(12, W_bayX, H_story)
ops.node(13, 2 * W_bayX, H_story)
ops.node(21, 0.0, 2 * H_story)
ops.node(22, W_bayX, 2 * H_story)
ops.node(23, 2 * W_bayX, 2 * H_story)
ops.node(31, 0.0, 3 * H_story)
ops.node(32, W_bayX, 3 * H_story)
ops.node(33, 2 * W_bayX, 3 * H_story)
# Beam Connection nodes
ops.node(1101, 0.0, H_story)
ops.node(1201, W_bayX, H_story)
ops.node(1202, W_bayX, H_story)
ops.node(1301, 2 * W_bayX, H_story)
ops.node(2101, 0.0, 2 * H_story)
ops.node(2201, W_bayX, 2 * H_story)
ops.node(2202, W_bayX, 2 * H_story)
ops.node(2301, 2 * W_bayX, 2 * H_story)
ops.node(3101, 0.0, 3 * H_story)
ops.node(3201, W_bayX, 3 * H_story)
ops.node(3202, W_bayX, 3 * H_story)
ops.node(3301, 2 * W_bayX, 3 * H_story)
# ###############
# Constraints
# ###############
ops.fix(1, 1, 1, 1)
ops.fix(2, 1, 1, 1)
ops.fix(3, 1, 1, 1)
# #######################
# ### Elements
# #######################
# ### Assign beam-integration tags
ColIntTag1 = 1
ColIntTag2 = 2
BeamIntTag1 = 3
BeamIntTag2 = 4
BeamIntTag3 = 5
ops.beamIntegration('Lobatto', ColIntTag1, colSecTag1, 4)
ops.beamIntegration('Lobatto', ColIntTag2, colSecTag2, 4)
ops.beamIntegration('Lobatto', BeamIntTag1, beamSecTag1, 4)
ops.beamIntegration('Lobatto', BeamIntTag2, beamSecTag2, 4)
ops.beamIntegration('Lobatto', BeamIntTag3, beamSecTag3, 4)
# Assign geometric transformation
ColTransfTag = 1
BeamTranfTag = 2
ops.geomTransf('PDelta', ColTransfTag)
ops.geomTransf('Linear', BeamTranfTag)
# Assign Elements ##############
# ## Add non-linear column elements
ops.element('forceBeamColumn', 1, 1, 11, ColTransfTag, ColIntTag1, '-mass',
0.0)
ops.element('forceBeamColumn', 2, 2, 12, ColTransfTag, ColIntTag2, '-mass',
0.0)
ops.element('forceBeamColumn', 3, 3, 13, ColTransfTag, ColIntTag1, '-mass',
0.0)
ops.element('forceBeamColumn', 11, 11, 21, ColTransfTag, ColIntTag1,
'-mass', 0.0)
ops.element('forceBeamColumn', 12, 12, 22, ColTransfTag, ColIntTag2,
'-mass', 0.0)
ops.element('forceBeamColumn', 13, 13, 23, ColTransfTag, ColIntTag1,
'-mass', 0.0)
ops.element('forceBeamColumn', 21, 21, 31, ColTransfTag, ColIntTag1,
'-mass', 0.0)
ops.element('forceBeamColumn', 22, 22, 32, ColTransfTag, ColIntTag2,
'-mass', 0.0)
ops.element('forceBeamColumn', 23, 23, 33, ColTransfTag, ColIntTag1,
'-mass', 0.0)
# ### Add linear main beam elements, along x-axis
#element('elasticBeamColumn', 101, 1101, 1201, Abeam, Es, Gs, Jbeam, IbeamY, IbeamZ, beamTransfTag, '-mass', 0.0)
ops.element('forceBeamColumn', 101, 1101, 1201, BeamTranfTag, BeamIntTag1,
'-mass', 0.0)
ops.element('forceBeamColumn', 102, 1202, 1301, BeamTranfTag, BeamIntTag1,
'-mass', 0.0)
ops.element('forceBeamColumn', 201, 2101, 2201, BeamTranfTag, BeamIntTag2,
'-mass', 0.0)
ops.element('forceBeamColumn', 202, 2202, 2301, BeamTranfTag, BeamIntTag2,
'-mass', 0.0)
ops.element('forceBeamColumn', 301, 3101, 3201, BeamTranfTag, BeamIntTag3,
'-mass', 0.0)
ops.element('forceBeamColumn', 302, 3202, 3301, BeamTranfTag, BeamIntTag3,
'-mass', 0.0)
# Assign constraints between beam end nodes and column nodes (RIgid beam column connections)
ops.equalDOF(11, 1101, 1, 2, 3)
ops.equalDOF(12, 1201, 1, 2, 3)
ops.equalDOF(12, 1202, 1, 2, 3)
ops.equalDOF(13, 1301, 1, 2, 3)
ops.equalDOF(21, 2101, 1, 2, 3)
ops.equalDOF(22, 2201, 1, 2, 3)
ops.equalDOF(22, 2202, 1, 2, 3)
ops.equalDOF(23, 2301, 1, 2, 3)
ops.equalDOF(31, 3101, 1, 2, 3)
ops.equalDOF(32, 3201, 1, 2, 3)
ops.equalDOF(32, 3202, 1, 2, 3)
ops.equalDOF(33, 3301, 1, 2, 3)
AllNodes = ops.getNodeTags()
massX = 0.49
for nodes in AllNodes:
ops.mass(nodes, massX, massX, 0.00001)
################
## Gravity Load
################
# create TimeSeries
ops.timeSeries("Linear", 1)
# create a plain load pattern
ops.pattern("Plain", 1, 1)
# Create the nodal load
ops.load(11, 0.0, -5.0 * kip, 0.0)
ops.load(12, 0.0, -6.0 * kip, 0.0)
ops.load(13, 0.0, -5.0 * kip, 0.0)
ops.load(21, 0., -5. * kip, 0.0)
ops.load(22, 0., -6. * kip, 0.0)
ops.load(23, 0., -5. * kip, 0.0)
ops.load(31, 0., -5. * kip, 0.0)
ops.load(32, 0., -6. * kip, 0.0)
ops.load(33, 0., -5. * kip, 0.0)
###############################
### PUSHOVER ANALYSIS
###############################
if (AnalysisType == "Pushover"):
print("<<<< Running Pushover Analysis >>>>")
# Create load pattern for pushover analysis
# create a plain load pattern
ops.pattern("Plain", 2, 1)
ops.load(11, 1.61, 0.0, 0.0)
ops.load(21, 3.22, 0.0, 0.0)
ops.load(31, 4.83, 0.0, 0.0)
ControlNode = 31
ControlDOF = 1
MaxDisp = 0.15 * H_story
DispIncr = 0.1
NstepsPush = int(MaxDisp / DispIncr)
Model = 'test'
LoadCase = 'Pushover'
dt = 0.2
opp.createODB(Model, LoadCase, Nmodes=3)
ops.system("ProfileSPD")
ops.numberer("Plain")
ops.constraints("Plain")
ops.integrator("DisplacementControl", ControlNode, ControlDOF,
DispIncr)
ops.algorithm("Newton")
ops.test('NormUnbalance', 1e-8, 10)
ops.analysis("Static")
# analyze(NstepsPush)
ops.analyze(100)
print("Pushover analysis complete")
MaxDisp = 0.15 * H_story
DispIncr = 0.1
NstepsPush = int(MaxDisp / DispIncr)
Model = '2D_Steel'
LoadCase = 'Pushover'
dt = 0.2
createODB(Model, LoadCase, Nmodes=3)
system("ProfileSPD")
numberer("Plain")
constraints("Plain")
integrator("DisplacementControl", ControlNode, ControlDOF, DispIncr)
algorithm("Newton")
test('NormUnbalance', 1e-8, 10)
analysis("Static")
# analyze(NstepsPush)
analyze(170)
wipe()
print("Pushover analysis complete")
# =============================================================================
# Plot outputs
# =============================================================================
opp.plot_model('nodes', 'elements', Model=Model)
opp.plot_modeshape(2, 200, Model=Model)
opp.plot_deformedshape(Model, LoadCase, tstep=12, scale=10, overlap='yes')
opp.plot_deformedshape(Model, LoadCase, tstep=3.1231, overlap='yes')
ani = opp.animate_deformedshape(Model, LoadCase, dt, Scale=10)
# =============================================================================
op.wipe()
# Build Model
mf.getSections()
mf.buildModel()
# Prepare Outputs
Model = 'Cantilever'
LoadCase = 'Pushover'
element1 = 1
section1 = 1
element2 = 2
section2 = 3
opp.createODB(Model, LoadCase)
opp.saveFiberData2D(Model, LoadCase, element1, section1)
opp.saveFiberData2D(Model, LoadCase, element2, section2)
# # Run Analysis
af.PushoverLcD(0.05)
op.wipe()
# =============================================================================
# Animation outputs
# =============================================================================
opp.plot_fiberResponse2D(Model,
LoadCase,
element2,
#transfTag = 10 # actual.
integrationTag = 1 # testing.
#integrationTag = 10 # actual.
# element('forceBeamColumn', eleTag, *eleNodes, transfTag, integrationTag, '-iter', maxIter=10, tol=1e-12)
#ops.element('forceBeamColumn', i, *[i, i + 1], transfTag, integrationTag, '-iter', 30, 1e-12)
[
ops.element('forceBeamColumn', i, *[i, i + 1], transfTag,
integrationTag, '-iter', 30, 1e-12) for i in range(1, N)
]
print('Model built.')
##############################################################################
##### Main Analysis #####
##############################################################################
# Initialization:
ops.wipe()
# Modelbuild:
ops.model('Basic', '-ndm', 2, '-ndf', 3)
get_Sections(fc, Es, fy, sec_dims, D, rebar_coords_YZ)
get_Model(coords)
opsplt.plot_model()
# Analysis:
# Close:
ops.wipe()
iNode = ops.nodeCoord(nodeTag1)
jNode = ops.nodeCoord(nodeTag2)
ops.element('elasticBeamColumn', eleTag, nodeTag1, nodeTag2, 50.,
E, 1000., 1000., 2150., 2150., 2, '-mass', M, massType)
eleTag += 1
nodeTag1 += 1
nodeTag1 += 1
# calculate eigenvalues & print results
numEigen = 7
eigenValues = ops.eigen(numEigen)
PI = 2 * asin(1.0)
###################################
#### Display the active model with node tags only
opsplt.plot_model("nodes")
#### Display specific mode shape with scale factor of 300 using the active model
opsplt.plot_modeshape(5, 300)
###################################
# To save the analysis output for deformed shape, use createODB command before running the analysis
# The following command saves the model data, and output for gravity analysis and the first 3 modes
# in a folder "3DFrame_ODB"
opsplt.createODB("3DFrame", "Gravity", Nmodes=3)
# Define Static Analysis
ops.timeSeries('Linear', 1)
ops.pattern('Plain', 1, 1)
ops.load(72, 1, 0, 0, 0, 0, 0)
def RunAnalysis():
# ----------------------------
# Start of model generation
# ----------------------------
# remove existing model
ops.wipe()
ops.model("BasicBuilder", "-ndm", 3, "-ndf", 6)
# set default units
ops.defaultUnits("-force", "kip", "-length", "in", "-time", "sec", "-temp",
"F")
# Define the section
# ------------------
# secTag E nu h rho
ops.section("ElasticMembranePlateSection", 1, 3.0E3, 0.25, 1.175, 1.27)
# Define geometry
# ---------------
# these should both be even
nx = 10
ny = 2
# loaded nodes
mid = int(((nx + 1) * (ny + 1) + 1) / 2)
side1 = int((nx + 2) / 2)
side2 = int((nx + 1) * (ny + 1) - side1 + 1)
# generate the nodes and elements
# numX numY startNode startEle eleType eleArgs? coords?
ops.block2D(nx, ny, 1, 1, "ShellMITC4", 1, 1, -20.0, 0.0, 0.0, 2, -20.0,
0.0, 40.0, 3, 20.0, 0.0, 40.0, 4, 20.0, 0.0, 0.0, 5, -10.0,
10.0, 20.0, 7, 10.0, 10.0, 20.0, 9, 0.0, 10.0, 20.0)
# define the boundary conditions
ops.fixZ(0.0, 1, 1, 1, 0, 1, 1)
ops.fixZ(40.0, 1, 1, 1, 0, 1, 1)
ops.mass(20, 10.0, 10.0, 10.0, 0.0, 0.0, 0.0)
# create a Linear time series
ops.timeSeries("Linear", 1)
# add some loads
ops.pattern("Plain", 1, 1, "-fact", 1.0)
ops.load(mid, 0.0, -0.50, 0.0, 0.0, 0.0, 0.0)
ops.load(side1, 0.0, -0.25, 0.0, 0.0, 0.0, 0.0)
ops.load(side2, 0.0, -0.25, 0.0, 0.0, 0.0, 0.0)
# ------------------------
# Start of static analysis
# ------------------------
# Load control with variable load steps
# init Jd min max
ops.integrator("LoadControl", 1.0, 1, 1.0, 10.0)
ops.test("EnergyIncr", 1.0E-10, 20, 0)
ops.algorithm("Newton")
ops.numberer("RCM")
ops.constraints("Plain")
ops.system("SparseGeneral", "-piv")
ops.analysis("Static")
ops.analyze(5)
# ---------------------------------------
# Create and Perform the dynamic analysis
# ---------------------------------------
# Remove the static analysis & reset the time to 0.0
ops.wipeAnalysis()
ops.setTime(0.0)
# Now remove the loads and let the beam vibrate
ops.remove("loadPattern", 1)
Model = 'test'
LoadCase = 'Transient'
LoadCase2 = 'Transient_5s'
opp.createODB(Model, LoadCase, Nmodes=3, recorders=[])
opp.createODB(Model, LoadCase2, Nmodes=3, deltaT=5., recorders=[])
# Create the transient analysis
ops.test("EnergyIncr", 1.0E-10, 20, 0)
ops.algorithm("Newton")
ops.numberer("RCM")
ops.constraints("Plain")
ops.system("SparseGeneral", "-piv")
ops.integrator("Newmark", 0.50, 0.25)
ops.analysis("Transient")
# Perform the transient analysis (20 sec)
ops.analyze(100, 0.2)
# ---------------------------------------
# Create and Perform the dynamic analysis
# ---------------------------------------
# Remove the static analysis & reset the time to 0.0
ops.wipeAnalysis()
ops.setTime(0.0)
# Now remove the loads and let the beam vibrate
ops.remove("loadPattern", 1)
Model = '3D_Shell'
LoadCase = 'Transient'
LoadCase2 = 'Transient_5s'
opp.createODB(Model, LoadCase, Nmodes=3, recorders=[])
opp.createODB(Model, LoadCase2, Nmodes=3, deltaT=5., recorders=[])
# Create the transient analysis
ops.test("EnergyIncr", 1.0E-10, 20, 0)
ops.algorithm("Newton")
ops.numberer("RCM")
ops.constraints("Plain")
ops.system("SparseGeneral", "-piv")
ops.integrator("Newmark", 0.50, 0.25)
ops.analysis("Transient")
# Perform the transient analysis (20 sec)
ops.analyze(100, 0.2)
####### Model Visualization
ops.analyze(5)
# ---------------------------------------
# Create and Perform the dynamic analysis
# ---------------------------------------
# Remove the static analysis & reset the time to 0.0
ops.wipeAnalysis()
ops.setTime(0.0)
# Now remove the loads and let the beam vibrate
ops.remove("loadPattern", 1)
ModelName = '3D_Shell'
LoadCaseName = 'Transient'
opp.createODB(ModelName, LoadCaseName, Nmodes=3)
LoadCaseName2 = 'Transient_2ms'
opp.createODB(ModelName, LoadCaseName2, deltaT=1 / 24, Nmodes=3)
# Create the transient analysis
ops.test("EnergyIncr", 1.0E-10, 20, 0)
ops.algorithm("Newton")
ops.numberer("RCM")
ops.constraints("Plain")
ops.system("SparseGeneral", "-piv")
ops.integrator("Newmark", 0.50, 0.25)
ops.analysis("Transient")
# Perform the transient analysis (20 sec)
ops.analyze(1000, 0.002)
def plot_opensees_mode_shapes():
opp.plot_model()
for i in range(1, numEigen + 1):
opp.plot_modeshape(i, 50)
return