def get_disp(GRS):
ops.timeSeries('Linear', 1)
ops.pattern('Plain', 1, 1)
for i in range(GRS.nbnBns):
if GRS.LoadType == 0 \
or (GRS.GeomType in {0, 1, 2} and GRS.LoadType == 1 and GRS.nsAll.x[GRS.nbn[i]] <= 0) \
or (GRS.GeomType in {0, 1, 2} and GRS.LoadType == 2 and GRS.nsAll.y[GRS.nbn[i]] <= 0) \
or (GRS.GeomType in {4} and GRS.LoadType == 1 and GRS.nsAll.x[GRS.nbn[i]] <= GRS.span / 2) \
or (GRS.GeomType in {4} and GRS.LoadType == 2 and GRS.nsAll.y[GRS.nbn[i]] <= GRS.span / 2):
ops.load(int(100 + GRS.nbn[i]), 0., 0., -1., 0., 0., 0.)
ops.algorithm("Linear")
ops.integrator("LoadControl", 1)
ops.analysis('Static')
ops.analyze(1)
NDisp = np.zeros([GRS.nbNsAll, 3])
for j in range(GRS.nbNsAll):
NDisp[j, 0] = ops.nodeDisp(int(j + 100), 1)
NDisp[j, 1] = ops.nodeDisp(int(j + 100), 2)
NDisp[j, 2] = ops.nodeDisp(int(j + 100), 3)
return NDisp
def RunIterations2(GRS, Fz, printOn):
ops.timeSeries('Linear', 1)
ops.pattern('Plain', 1, 1)
for i in range(GRS.nbnBns):
ops.load(int(100 + GRS.nbn[i]), 0., 0., Fz * un.kN, 0., 0., 0.)
GRS.GetTopNode()
# ops.load(int(100+GRS.maxNsID), 0., 0., Fz * kN, 0., 0., 0.) # mid-point
# create SOE
ops.system('UmfPack')
# create DOF number
ops.numberer('RCM')
# create constraint handler
ops.constraints('Transformation')
# create integrator
ops.integrator("LoadControl", 1.0 / GRS.Steps)
# create algorithm
ops.algorithm("Newton")
# create test
ops.test('EnergyIncr', 1.e-10, 100)
ops.analysis('Static')
NDisp = np.zeros([GRS.Steps + 1, GRS.nbNsAll, 3])
# EDisp = np.zeros([GRS.Steps + 1, GRS.nbElAll, 6])
EForce = np.zeros([GRS.Steps + 1, GRS.nbElAll, 12])
reI = 0
reI = 0
lefutott = 1
for i in range(1, GRS.Steps + 1):
hiba = ops.analyze(1)
if hiba == 0:
if i == 1:
if printOn: print('analysis step 1 completed successfully')
for j in range(GRS.nbNsAll):
NDisp[i, j, 0] = -ops.nodeDisp(int(j + 100),
1) / un.mm # mm displacement
NDisp[i, j, 1] = -ops.nodeDisp(int(j + 100),
2) / un.mm # mm displacement
NDisp[i, j, 2] = -ops.nodeDisp(int(j + 100),
3) / un.mm # mm displacement
for j in range(GRS.nbElAll):
EForce[i, j] = ops.eleResponse(int(j + 1000), 'localForce')
# EDisp[i, j] = ops.eleResponse(int(j + 1000), 'basicDeformation')
else:
lefutott = 0
reI = i
if reI == 1:
if printOn: print('analysis failed to converge in step ', i)
break
return lefutott, NDisp, EForce, reI
def test_recorder_time_step_can_handle_fp_precision():
import tempfile
opy.model('basic', '-ndm', 2, '-ndf', 3)
opy.node(1, 0.0, 0.0)
opy.node(2, 0.0, 5.0)
opy.fix(2, 0, 1, 0)
opy.fix(1, 1, 1, 1)
opy.equalDOF(2, 1, 2)
opy.mass(2, 1.0, 0.0, 0.0)
opy.geomTransf('Linear', 1, '-jntOffset')
opy.element('elasticBeamColumn', 1, 1, 2, 1.0, 1e+06, 0.00164493, 1)
opy.timeSeries('Path', 1, '-dt', 0.1, '-values', 0.0, -0.001, 0.001,
-0.015, 0.033, 0.105, 0.18)
opy.pattern('UniformExcitation', 1, 1, '-accel', 1)
opy.rayleigh(0.0, 0.0159155, 0.0, 0.0)
opy.wipeAnalysis()
opy.algorithm('Newton')
opy.system('SparseSYM')
opy.numberer('RCM')
opy.constraints('Transformation')
opy.integrator('Newmark', 0.5, 0.25)
opy.analysis('Transient')
opy.test('EnergyIncr', 1e-07, 10, 0, 2)
node_rec_ffp = tempfile.NamedTemporaryFile(delete=False).name
ele_rec_ffp = tempfile.NamedTemporaryFile(delete=False).name
rdt = 0.01
adt = 0.001
opy.recorder('Node', '-file', node_rec_ffp, '-precision', 16, '-dT', rdt,
'-rTolDt', 0.00001, '-time', '-node', 1, '-dof', 1, 'accel')
opy.recorder('Element', '-file', ele_rec_ffp, '-precision', 16, '-dT', rdt,
'-rTolDt', 0.00001, '-time', '-ele', 1, 'force')
opy.record()
for i in range(1100):
opy.analyze(1, adt)
opy.getTime()
opy.wipe()
a = open(node_rec_ffp).read().splitlines()
for i in range(len(a) - 1):
dt = float(a[i + 1].split()[0]) - float(a[i].split()[0])
assert abs(dt - 0.01) < adt * 0.1, (i, dt)
a = open(ele_rec_ffp).read().splitlines()
for i in range(len(a) - 1):
dt = float(a[i + 1].split()[0]) - float(a[i].split()[0])
assert abs(dt - 0.01) < adt * 0.1, (i, dt)
def get_normal_force(GRS):
ops.timeSeries('Linear', 1)
ops.pattern('Plain', 1, 1)
for i in range(GRS.nbnBns):
if GRS.LoadType == 0 \
or (GRS.GeomType in {0, 1, 2} and GRS.LoadType == 1 and GRS.nsAll.x[GRS.nbn[i]] <= 0) \
or (GRS.GeomType in {0, 1, 2} and GRS.LoadType == 2 and GRS.nsAll.y[GRS.nbn[i]] <= 0) \
or (GRS.GeomType in {4} and GRS.LoadType == 1 and GRS.nsAll.x[GRS.nbn[i]] <= GRS.span / 2) \
or (GRS.GeomType in {4} and GRS.LoadType == 2 and GRS.nsAll.y[GRS.nbn[i]] <= GRS.span / 2):
ops.load(int(100 + GRS.nbn[i]), 0., 0., -1., 0., 0., 0.)
ops.algorithm("Linear")
ops.integrator("LoadControl", 1)
ops.analysis('Static')
ops.analyze(1)
EForce = np.zeros([GRS.nbElAll])
for j in range(GRS.nbElAll):
EForce[j] = ops.eleResponse(int(j + 1000), 'localForce')[0]
return EForce
ops.numberer("RCM")
# create the constraint handler
ops.constraints("Plain")
# create the convergence test
ops.test("EnergyIncr", 1.0E-12, 10)
# create the solution algorithm, a Newton-Raphson algorithm
ops.algorithm("Newton")
# create the load control with variable load steps
ops.integrator("LoadControl", 1.0, 1, 1.0, 10.0)
# create the analysis object
ops.analysis("Static")
# Perform the analysis
ops.analyze(10)
# --------------------------
# End of static analysis
# --------------------------
# ----------------------------
# Start of recorder generation
# ----------------------------
ops.recorder("Node", "-file", "Node.out", "-time", "-node", l1, "-dof", 2,
"disp")
#ops.recorder("plot", "Node.out", "CenterNodeDisp", 625, 10, 625, 450, "-columns", 1, 2)
ops.numberer("Plain")
# create the constraint handler
ops.constraints("Transformation")
# create the convergence test
ops.test("EnergyIncr", 1.0E-8, 20)
# create the solution algorithm, a Newton-Raphson algorithm
ops.algorithm("Newton")
# create the integration scheme, the Newmark with gamma=0.5 and beta=0.25
ops.integrator("Newmark", 0.5, 0.25)
# create the analysis object
ops.analysis("Transient")
# --------------------------
# End of analysis generation
# --------------------------
# ----------------------------
# Start of recorder generation
# ----------------------------
# Record DOF 1 and 2 displacements at nodes 9, 14, and 19
ops.recorder("Node", "-file", "Node51.out", "-time", "-node", 9, 14, 19, "-dof", 1, 2, "disp")
#ops.recorder("plot", "Node51.out", "Node9_14_19_Xdisp", 10, 340, 300, 300, "-columns", 1, 2, "-columns", 1, 4, "-columns", 1, 6, "-dT", 1.0)
# --------------------------
#-----------------------------------------------------------------------------------------
# 9. GRAVITY ANALYSIS
#-----------------------------------------------------------------------------------------
# update materials to ensure elastic behavior
op.updateMaterialStage('-material', 1, '-stage', 0)
op.updateMaterialStage('-material', 2, '-stage', 0)
op.updateMaterialStage('-material', 3, '-stage', 0)
op.constraints('Penalty', 1.0E14, 1.0E14)
op.test('NormDispIncr', 1e-4, 35, 1)
op.algorithm('KrylovNewton')
op.numberer('RCM')
op.system('ProfileSPD')
op.integrator('Newmark', gamma, beta)
op.analysis('Transient')
startT = tt.time()
op.analyze(10, 5.0E2)
print('Finished with elastic gravity analysis...')
# update material to consider elastoplastic behavior
op.updateMaterialStage('-material', 1, '-stage', 1)
op.updateMaterialStage('-material', 2, '-stage', 1)
op.updateMaterialStage('-material', 3, '-stage', 1)
# plastic gravity loading
op.analyze(40, 5.0e2)
print('Finished with plastic gravity analysis...')
# Solution algorithm
ops.algorithm("Newton")
# DOF numberer
ops.numberer("RCM")
# Cosntraint handler
ops.constraints("Plain")
# System of equations solver
ops.system("SparseGeneral", "-piv")
#ops.system("ProfileSPD")
# Analysis for gravity load
ops.analysis("Static")
# Perform the gravity load analysis
ops.analyze(5)
# --------------------------
# End of static analysis
# --------------------------
# ----------------------------
# Start of recorder generation
# ----------------------------
ops.recorder("Node", "-file", "Node.out", "-time", "-node", mid, "-dof", 2, "disp")
#ops.recorder("plot", "Node.out", "CenterNodeDisp", 625, 10, 625, 450, "-columns", 1, 2)
def get_inelastic_response(mass,
k_spring,
f_yield,
motion,
dt,
xi=0.05,
r_post=0.0):
"""
Run seismic analysis of a nonlinear SDOF
:param mass: SDOF mass
:param k_spring: spring stiffness
:param f_yield: yield strength
:param motion: list, acceleration values
:param dt: float, time step of acceleration values
:param xi: damping ratio
:param r_post: post-yield stiffness
:return:
"""
op.wipe()
op.model('basic', '-ndm', 2, '-ndf', 3) # 2 dimensions, 3 dof per node
# Establish nodes
bot_node = 1
top_node = 2
op.node(bot_node, 0., 0.)
op.node(top_node, 0., 0.)
# Fix bottom node
op.fix(top_node, opc.FREE, opc.FIXED, opc.FIXED)
op.fix(bot_node, opc.FIXED, opc.FIXED, opc.FIXED)
# Set out-of-plane DOFs to be slaved
op.equalDOF(1, 2, *[2, 3])
# nodal mass (weight / g):
op.mass(top_node, mass, 0., 0.)
# Define material
bilinear_mat_tag = 1
mat_type = "Steel01"
mat_props = [f_yield, k_spring, r_post]
op.uniaxialMaterial(mat_type, bilinear_mat_tag, *mat_props)
# Assign zero length element
beam_tag = 1
op.element('zeroLength', beam_tag, bot_node, top_node, "-mat",
bilinear_mat_tag, "-dir", 1, '-doRayleigh', 1)
# Define the dynamic analysis
load_tag_dynamic = 1
pattern_tag_dynamic = 1
values = list(-1 * motion) # should be negative
op.timeSeries('Path', load_tag_dynamic, '-dt', dt, '-values', *values)
op.pattern('UniformExcitation', pattern_tag_dynamic, opc.X, '-accel',
load_tag_dynamic)
# set damping based on first eigen mode
angular_freq = op.eigen('-fullGenLapack', 1)**0.5
alpha_m = 0.0
beta_k = 2 * xi / angular_freq
beta_k_comm = 0.0
beta_k_init = 0.0
op.rayleigh(alpha_m, beta_k, beta_k_init, beta_k_comm)
# Run the dynamic analysis
op.wipeAnalysis()
op.algorithm('Newton')
op.system('SparseGeneral')
op.numberer('RCM')
op.constraints('Transformation')
op.integrator('Newmark', 0.5, 0.25)
op.analysis('Transient')
tol = 1.0e-10
iterations = 10
op.test('EnergyIncr', tol, iterations, 0, 2)
analysis_time = (len(values) - 1) * dt
analysis_dt = 0.001
outputs = {
"time": [],
"rel_disp": [],
"rel_accel": [],
"rel_vel": [],
"force": []
}
while op.getTime() < analysis_time:
curr_time = op.getTime()
op.analyze(1, analysis_dt)
outputs["time"].append(curr_time)
outputs["rel_disp"].append(op.nodeDisp(top_node, 1))
outputs["rel_vel"].append(op.nodeVel(top_node, 1))
outputs["rel_accel"].append(op.nodeAccel(top_node, 1))
op.reactions()
outputs["force"].append(
-op.nodeReaction(bot_node, 1)) # Negative since diff node
op.wipe()
for item in outputs:
outputs[item] = np.array(outputs[item])
return outputs
import sys
TEST_DIR = os.path.dirname(os.path.abspath(__file__)) + "/"
INTERPRETER_PATH = TEST_DIR + "../SRC/interpreter/"
sys.path.append(INTERPRETER_PATH)
import opensees as opy
opy.wipe()
opy.model('basic', '-ndm', 2, '-ndf', 2)
opy.node(1, 0.0, 0.0)
opy.node(2, 1.0, 0.0)
opy.node(3, 1.0, 1.0)
opy.node(4, 0.0, 1.0)
for i in range(4):
opy.fix(1 + 1 * i, 1, 1)
opy.nDMaterial('stressDensity', 1, 1.8, 0.7, 250.0, 0.6, 0.2, 0.592, 0.021, 291.0, 55.0, 98.0, 13.0, 4.0, 0.22, 0.0, 0.0055, 0.607, 98.1)
opy.nDMaterial('InitStressNDMaterial', 2, 1, -100.0, 2)
opy.element('SSPquad', 1, 1, 2, 3, 4, 2, 'PlaneStrain', 1.0, 0.0, 0.0)
opy.constraints('Penalty', 1e+15, 1e+15)
opy.algorithm('Linear', False, False, False)
opy.numberer('RCM')
opy.system('FullGeneral')
opy.integrator('LoadControl', 0.1, 1)
opy.analysis('Static')
opy.timeSeries('Path', 1, '-values', 0, 0, 0, 0.1, '-time', 0.0, 1.0, 2.0, 1002.0, '-factor', 1.0)
opy.pattern('Plain', 1, 1)
opy.sp(3, 1, 1)
opy.sp(4, 1, 1)
opy.analyze(1)
opy.setParameter('-val', 1, '-ele', 1, 'materialState')
opy.analyze(1)
ops.fix(1, 1, 1)
ops.fix(6, 1, 1)
ops.fix(11, 1, 1)
ops.fix(16, 1, 1)
ops.fix(21, 1, 1)
ops.equalDOF(2, 22, 1, 2)
ops.equalDOF(3, 23, 1, 2)
ops.equalDOF(4, 24, 1, 2)
ops.equalDOF(5, 25, 1, 2)
ops.timeSeries('Linear', 1)
ops.pattern('Plain', 1, 1)
ops.load(15, 0., -1.)
ops.analysis('Static')
ops.analyze(1)
# - plot model
opsv.plot_model()
plt.axis('equal')
# - plot deformation
plt.figure()
opsv.plot_defo()
plt.axis('equal')
# get values at OpenSees nodes
sig_out = opsv.sig_out_per_node()
print(f'sig_out:\n{sig_out}')
def RunIterations(GRS, Fz, printOn):
ops.timeSeries('Linear', 1)
ops.pattern('Plain', 1, 1)
loadA = np.linspace(0, -Fz, GRS.Steps + 1) # kN
for i in range(GRS.nbnBns):
if GRS.LoadType == 0 \
or (GRS.GeomType in {0, 1, 2} and GRS.LoadType == 1 and GRS.nsAll.x[GRS.nbn[i]] <= 0) \
or (GRS.GeomType in {0, 1, 2} and GRS.LoadType == 2 and GRS.nsAll.y[GRS.nbn[i]] <= 0) \
or (GRS.GeomType in {4} and GRS.LoadType == 1 and GRS.nsAll.x[GRS.nbn[i]] <= GRS.span / 2) \
or (GRS.GeomType in {4} and GRS.LoadType == 2 and GRS.nsAll.y[GRS.nbn[i]] <= GRS.span / 2):
ops.load(int(100 + GRS.nbn[i]), 0., 0., Fz * un.kN, 0., 0., 0.)
GRS.GetTopNode()
# ops.load(int(100+GRS.maxNsID), 0., 0., Fz * kN, 0., 0., 0.) # mid-point
# create SOE
ops.system('UmfPack')
# create DOF number
ops.numberer('RCM')
# create constraint handler
ops.constraints('Transformation')
# create test
ops.test('EnergyIncr', 1.e-12, 10)
# create algorithm
ops.algorithm("Newton")
NDisp = np.zeros([GRS.Steps + 1, GRS.nbNsAll, 3])
# EDisp = np.zeros([GRS.Steps + 1, GRS.nbElAll, 6])
EForce = np.zeros([GRS.Steps + 1, GRS.nbElAll, 12])
reI=0
reI = 0
lefutott = 1
i=0
load = 0
stepSize = 1.0 / GRS.Steps
ops.integrator("LoadControl", stepSize)
ops.analysis('Static')
while ((-stepSize*Fz > GRS.MinStepSize) and (i<GRS.Steps)):
hiba = ops.analyze(1)
if hiba == 0:
load += -stepSize * Fz
i += 1
loadA[i] = load
if i == 1:
if printOn: print('analysis step 1 completed successfully')
for j in range(GRS.nbNsAll):
NDisp[i, j, 0] = - ops.nodeDisp(int(j + 100), 1) / un.mm # mm displacement
NDisp[i, j, 1] = - ops.nodeDisp(int(j + 100), 2) / un.mm # mm displacement
NDisp[i, j, 2] = - ops.nodeDisp(int(j + 100), 3) / un.mm # mm displacement
for j in range(GRS.nbElAll):
EForce[i, j] = ops.eleResponse(int(j+1000), 'localForce')
# EDisp[i, j] = ops.eleResponse(int(j + 1000), 'basicDeformation')
else:
stepSize = stepSize/2
if printOn: print('analysis failed to converge in step ', i)
ops.integrator("LoadControl", stepSize)
lefutott = 0
reI = i
if i == GRS.Steps:
if reI == 1:
if printOn: print('analysis failed to converge')
return lefutott, NDisp, EForce, loadA, reI
def test_recorder_time_step_is_stable():
opy.model('basic', '-ndm', 2, '-ndf', 2)
opy.loadConst('-time', 1e+13)
opy.node(1, 0.0, 0.0)
opy.node(2, 0.5, 0.0)
opy.node(3, 0.0, -0.5)
opy.node(4, 0.5, -0.5)
opy.equalDOF(3, 4, 1, 2)
opy.node(5, 0.0, -1.0)
opy.node(6, 0.5, -1.0)
opy.equalDOF(5, 6, 1, 2)
opy.node(7, 0.0, -1.5)
opy.node(8, 0.5, -1.5)
opy.equalDOF(7, 8, 1, 2)
opy.node(9, 0.0, -2.0)
opy.node(10, 0.5, -2.0)
opy.equalDOF(9, 10, 1, 2)
opy.node(11, 0.0, -2.5)
opy.node(12, 0.5, -2.5)
opy.equalDOF(11, 12, 1, 2)
opy.node(13, 0.0, -3.0)
opy.node(14, 0.5, -3.0)
opy.equalDOF(13, 14, 1, 2)
opy.fix(13, 0, 1)
opy.fix(14, 0, 1)
opy.node(15, 0.0, -3.0)
opy.node(16, 0.0, -3.0)
opy.fix(15, 1, 1)
opy.fix(16, 0, 1)
opy.equalDOF(13, 14, 1)
opy.equalDOF(13, 16, 1)
opy.nDMaterial('ElasticIsotropic', 1, 212500.0, 0.0, 1.7)
opy.element('SSPquad', 1, 3, 4, 2, 1, 1, 'PlaneStrain', 1.0, 0.0, 16.677)
opy.element('SSPquad', 2, 5, 6, 4, 3, 1, 'PlaneStrain', 1.0, 0.0, 16.677)
opy.element('SSPquad', 3, 7, 8, 6, 5, 1, 'PlaneStrain', 1.0, 0.0, 16.677)
opy.element('SSPquad', 4, 9, 10, 8, 7, 1, 'PlaneStrain', 1.0, 0.0, 16.677)
opy.element('SSPquad', 5, 11, 12, 10, 9, 1, 'PlaneStrain', 1.0, 0.0,
16.677)
opy.element('SSPquad', 6, 13, 14, 12, 11, 1, 'PlaneStrain', 1.0, 0.0,
16.677)
opy.uniaxialMaterial('Viscous', 2, 212.5, 1.0)
opy.element('zeroLength', 7, 15, 16, '-mat', 2, '-dir', 1)
opy.constraints('Transformation')
opy.test('NormDispIncr', 0.0001, 30, 0, 2)
opy.algorithm('Newton', False, False, False)
opy.numberer('RCM')
opy.system('ProfileSPD')
opy.integrator('Newmark', 0.5, 0.25)
opy.analysis('Transient')
opy.analyze(40, 1.0)
opy.analyze(50, 0.5)
opy.setTime(1.0e3)
opy.wipeAnalysis()
opy.recorder('Node', '-file', 'time_0_01.txt', '-precision', 16, '-dT',
0.01, '-rTolDt', 0.00001, '-time', '-node', 1, '-dof', 1,
'accel')
opy.recorder('Element', '-file', 'etime_0_01.txt', '-precision', 16, '-dT',
0.01, '-rTolDt', 0.00001, '-time', '-ele', 1, 2, 'stress')
opy.recorder('EnvelopeNode', '-file', 'entime_0_01.txt', '-precision', 16,
'-dT', 0.01, '-time', '-node', 1, '-dof', 1, 'accel')
# opy.recorder('Drift', '-file', 'dtime_0_01.txt', '-precision', 16, '-dT', 0.01, '-time',
# '-iNode', 1, '-jNode', 2, '-dof', 1, '-perpDirn', 2)
opy.timeSeries('Path', 1, '-dt', 0.01, '-values', -0.0, -0.0, -0.0, -0.0,
-0.0, -0.0, -0.0, -0.0, -7.51325e-05)
opy.pattern('Plain', 1, 1)
opy.load(13, 1.0, 0.0)
opy.algorithm('Newton', False, False, False)
opy.system('SparseGeneral')
opy.numberer('RCM')
opy.constraints('Transformation')
opy.integrator('Newmark', 0.5, 0.25)
opy.rayleigh(0.17952, 0.000909457, 0.0, 0.0)
opy.analysis('Transient')
opy.test('EnergyIncr', 1e-07, 10, 0, 2)
opy.record()
opy.analyze(1, 0.001)
for i in range(1100):
print(i)
opy.analyze(1, 0.001)
cur_time = opy.getTime()
opy.wipe()
a = open('time_0_01.txt').read().splitlines()
for i in range(len(a) - 1):
dt = float(a[i + 1].split()[0]) - float(a[i].split()[0])
assert abs(dt - 0.01) < 0.0001, (i, dt)
ops.numberer("Plain")
# create the constraint handler
ops.constraints("Transformation")
# create the convergence test
ops.test("EnergyIncr", 1.0E-8, 20)
# create the solution algorithm, a Newton-Raphson algorithm
ops.algorithm("Newton")
# create the integration scheme, the Newmark with gamma=0.5 and beta=0.25
ops.integrator("Newmark", 0.5, 0.25)
# create the analysis object
ops.analysis("Transient")
# --------------------------
# End of analysis generation
# --------------------------
# ----------------------------
# Start of recorder generation
# ----------------------------
# Record DOF 1 and 2 displacements at nodes 9, 14, and 19
ops.recorder("Node", "-file", "Node51.out", "-time", "-node", 9, 14, 19,
"-dof", 1, 2, "disp")
#ops.recorder("plot", "Node51.out", "Node9_14_19_Xdisp", 10, 340, 300, 300, "-columns", 1, 2, "-columns", 1, 4, "-columns", 1, 6, "-dT", 1.0)
# --------------------------
# Start of analysis generation
# ------------------------------
# create SOE
op.system('UmfPack')
# create DOF number
op.numberer('RCM')
# create constraint handler
op.constraints('Transformation')
# create integrator
op.integrator('LoadControl', timeStep, NumSteps)
# create algorithm
op.algorithm('Newton')
# create test
op.test('NormUnbalance', 1, 1000, 1)
# create analysis object
op.analysis('Static')
# perform the analysis
op.analyze(NumSteps)
op.loadConst('-time', 1.00)
op.wipeAnalysis()
#----------------------------------------------------------------------------------
###################################################################################
# Stage 2 : Perform Dynamic analysis with excess pore pressure generation in soil
###################################################################################
Total_Time = 30
#total time of simulation
dt = 0.01
#time step increment
numIncr = int(Total_Time / dt) - 1
# create the constraint handler, a Plain handler is used as h**o constraints
ops.constraints("Plain")
# 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)
# create the analysis object
ops.analysis("Static")
# ------------------------------
# End of analysis generation
# ------------------------------
# ------------------------------
# Finally perform the analysis
# ------------------------------
# perform the gravity load analysis, requires 10 steps to reach the load level
ops.analyze(10)
# Print out the state of nodes 3 and 4
ops.printModel("node", 3, 4)
op.pattern('Plain', 10, 1)
op.load(nodeTag, *loadValues)
print("Finished creating loading object...")
#----------------------------------------------------------
# create the analysis
#----------------------------------------------------------
op.integrator('LoadControl', 0.05)
op.numberer('RCM')
op.system('SparseGeneral')
op.constraints('Transformation')
op.test('NormDispIncr', 1e-5, 20, 1)
op.algorithm('Newton')
op.analysis('Static')
print("Starting Load Application...")
op.analyze(201)
print("Load Application finished...")
#print("Loading Analysis execution time: [expr $endT-$startT] seconds.")
#op.wipe
op.reactions()
Nodereactions = dict()
Nodedisplacements = dict()
for i in range(201,nodeTag+1):
Nodereactions[i] = op.nodeReaction(i)
Nodedisplacements[i] = op.nodeDisp(i)
# create the constraint handler, a Plain handler is used as h**o constraints
ops.constraints("Plain")
# 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)
# create the analysis object
ops.analysis("Static")
# ------------------------------
# End of analysis generation
# ------------------------------
# ------------------------------
# Finally perform the analysis
# ------------------------------
# perform the gravity load analysis, requires 10 steps to reach the load level
ops.analyze(10)
# Print out the state of nodes 3 and 4
ops.printModel("node", 3, 4)
ops.fix(1, 1)
ops.element('Truss', 1, 1, 2, 10.0, 1)
ops.timeSeries('Linear', 1)
ops.pattern('Plain', 1, 1)
ops.load(2, 100.0)
ops.constraints('Transformation')
ops.numberer('ParallelPlain')
ops.test('NormDispIncr', 1e-6, 6, 2)
ops.system('ProfileSPD')
ops.integrator('Newmark', 0.5, 0.25)
# ops.analysis('Transient')
ops.algorithm('Linear')
ops.analysis('VariableTransient')
ops.analyze(5, 0.0001, 0.00001, 0.001, 10)
time = ops.getTime()
print(f'time: ', ops.getTime())
approx_vtime = 0.0001 + 0.001 # One step at target, then one step at maximum
assert 0.99 < time / approx_vtime < 1.01, (time, approx_vtime)
ops.setTime(0.0)
# Can still run a non-variable analysis - since analyze function has multiple dispatch.
ops.analyze(5, 0.0001)
time = ops.getTime()
print(f'time: ', ops.getTime())
approx_vtime = 0.0001 * 5 # variable transient is not active so time should be dt * 5
# If variable transient is not active then time would be 0.0005
assert 0.99 < time / approx_vtime < 1.01, (time, approx_vtime)
