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 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 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 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.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)
# 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("Gravity load analysis completed\n")
# Set the gravity loads to be constant & reset the time in the domain
ops.loadConst("-time", 0.0)
# ----------------------------------------------------
# End of Model Generation & Initial Gravity Analysis
# ----------------------------------------------------
# ----------------------------------------------------
# Start of additional modelling for lateral loads
# ----------------------------------------------------
# Define lateral loads
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(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}')
# !!! select from sig_out: e.g. vmises
# 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
#number of analysis steps to perform
# create a Recorder object for the nodal displacements at node 4
ops.recorder("Node", "-file", "example.out", "-time", "-node", 4, "-dof", 1, 2, "disp")
# create a recorder for element forces, one in global and the other local system
ops.recorder("Element", "-file", "eleGlobal.out", "-time", "-ele", 1, 2, 3, "forces")
ops.recorder("Element", "-file", "eleLocal.out", "-time", "-ele", 1, 2, 3, "basicForces")
# ------------------------------
# End of recorder generation
# ------------------------------
# ------------------------------
# Finally perform the analysis
# ------------------------------
# perform the analysis
ops.analyze(1)
# ------------------------------
# Print Stuff to Screen
# ------------------------------
# print the current state at node 4 and at all elements
#print("node 4 displacement: ", ops.nodeDisp(4))
ops.printModel("node", 4)
ops.printModel("ele")
ops.wipe()
# ----------------------------
# 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)
# --------------------------
# End of recorder generation
# --------------------------
# --------------------
# Perform the analysis
# --------------------
# record once at time 0
ops.record()
# Analysis duration of 20 seconds
# numSteps dt
ok = ops.analyze(2000, 0.01)
if (ok != 0):
print("analysis FAILED")
else:
print("analysis SUCCESSFUL")
ops.wipe()
# 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)
# create the display
#ops.recorder("display", "shellDynamics", 10, 10, 600, 600, "-wipe")
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
# ----------------------------
# 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)
# --------------------------
# End of recorder generation
# --------------------------
# --------------------
# Perform the analysis
# --------------------
# record once at time 0
ops.record()
# Analysis duration of 20 seconds
# numSteps dt
ok = ops.analyze(2000, 0.01)
if (ok != 0):
print("analysis FAILED")
else:
print("analysis SUCCESSFUL")
ops.wipe()
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)
# 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)
# create the display
#ops.recorder("display", "shellDynamics", 10, 10, 600, 600, "-wipe")
ops.algorithm("Newton")
# DOF numberer
ops.numberer("RCM")
# Cosntraint handler
ops.constraints("Plain")
# System of equations solver
ops.system("ProfileSPD")
# Analysis for gravity load
ops.analysis("Static")
# Perform the analysis
ops.analyze(5)
# --------------------------
# End of static analysis
# --------------------------
# ----------------------------
# Start of recorder generation
# ----------------------------
ops.recorder("Node", "-file", "Node.out", "-time", "-node", nn, "-dof", 1, "disp")
ops.recorder("Element", "-file", "Elem.out", "-time", "-eleRange", 1, 10, "material", "1", "strains")
#ops.recorder("plot", "Node.out", "CenterNodeDisp", 625, 10, 625, 450, "-columns", 1, 2)
# create the display
ops.analysis("Static")
# ------------------------------------------------
# End of analysis generation for gravity analysis
# ------------------------------------------------
# ------------------------------
# Perform gravity load analysis
# ------------------------------
# initialize the model, done to set initial tangent
ops.initialize()
# perform the gravity load analysis, requires 10 steps to reach the load level
ops.analyze(10)
print("Gravity load analysis completed\n")
# set gravity loads to be const and set pseudo time to be 0.0
# for start of lateral load analysis
ops.loadConst("-time", 0.0)
# ------------------------------
# Add lateral loads
# ------------------------------
# Reference lateral load for pushover analysis
H = 10.0
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("Gravity load analysis completed\n")
# Set the gravity loads to be constant & reset the time in the domain
ops.loadConst("-time", 0.0)
# ----------------------------------------------------
# End of Model Generation & Initial Gravity Analysis
# ----------------------------------------------------
# ----------------------------------------------------
# Start of additional modelling for dynamic loads
# ----------------------------------------------------
#-----------------------------------------------------------------------------------------
# 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...')
#-----------------------------------------------------------------------------------------
# 10. UPDATE ELEMENT PERMEABILITY VALUES FOR POST-GRAVITY ANALYSIS
#-----------------------------------------------------------------------------------------
# create the analysis object
ops.analysis("Static")
# ------------------------------------------------
# End of analysis generation for gravity analysis
# ------------------------------------------------
# ------------------------------
# Perform gravity load analysis
# ------------------------------
# initialize the model, done to set initial tangent
ops.initialize()
# perform the gravity load analysis, requires 10 steps to reach the load level
ops.analyze(10)
print("Gravity load analysis completed\n")
# set gravity loads to be const and set pseudo time to be 0.0
# for start of lateral load analysis
ops.loadConst("-time", 0.0)
# ------------------------------
# Add lateral loads
# ------------------------------
# Reference lateral load for pushover analysis
H = 10.0
# Set lateral load pattern with a Linear TimeSeries
op.algorithm('Newton')
# create test
tol = 1.0E-8
Iter = 25
pFlag = 0
op.test('NormDispIncr', tol, Iter, pFlag)
# create analysis object
op.analysis('VariableTransient')
# perform the analysis
dtMin = dt / 100
#Minimum time steps. (required for VariableTransient analysis)
dtMax = dt / 10
#Maximum time steps (required for VariableTransient analysis)
Jd = 1000
#Number of iterations user would like performed at each step. The variable transient analysis will change current time step if last analysis step took more or less iterations than this to converge (required for VariableTransient analysis)
op.analyze(numIncr, dt, dtMin, dtMax, Jd)
op.wipe()
#################################################################
# Plot the results
#################################################################
Node_Disp = np.loadtxt('Node_Disp_Liq.txt', delimiter=' ')
TZ1 = np.loadtxt('TZ1_Liq.txt', delimiter=' ')
Time = Node_Disp[:, 0]
Figure = plt.figure(figsize=(10, 8))
Ru_Axis = Figure.add_subplot(311)
U_Axis = Figure.add_subplot(312)
TZ_Axis = Figure.add_subplot(313)
Ru_Axis.plot(MNS_Time, 1 - MeanStress, '-k', linewidth=2)
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
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)
# create the display
#ops.recorder("display", g3, 10, 10, 800, 200, "-wipe")
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("Gravity load analysis completed\n")
# Set the gravity loads to be constant & reset the time in the domain
ops.loadConst("-time", 0.0)
# ----------------------------------------------------
# End of Model Generation & Initial Gravity Analysis
# ----------------------------------------------------
# ----------------------------------------------------
# Start of additional modelling for lateral loads
# ----------------------------------------------------
# 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)
# Print out the state of element 1
ops.printModel("ele", 1)
ops.wipe()
ops.fix(2, 1, 1)
ops.fix(3, 1, 1)
ops.mass(4, 100.0, 100.0)
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.test('NormDispIncr', 1e-6, 6, 2)
ops.algorithm('Linear')
etype = 'central_difference'
etype = 'explicit_difference' # Comment out this line to run with central difference
if etype == 'central_difference':
ops.system('Mumps')
ops.integrator('CentralDifference')
else:
# ops.system('Mumps')
ops.system(
'MPIDiagonal') # Can use Mumps here but not sure if it scales as well
ops.integrator('ExplicitDifference')
ops.analysis('Transient')
for i in range(30):
print(f'######################################## run {i} ##')
ops.analyze(1, 0.000001)
print('PPP')
ops.analyze(20, 0.00001)
print(pid, ' Node 4: ', [ops.nodeCoord(4), ops.nodeDisp(4)])
print(pid, " COMPLETED")
# 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)
# Print out the state of element 1
ops.printModel("ele", 1)
ops.wipe()
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)
print('Node Reactions are: ', Nodereactions)
print('Node Displacements are: ', Nodedisplacements)
