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)
# print model
#ops.printModel()
ops.printModel("-JSON", "-file", "Example1.1.json")
# ------------------------------
# End of model generation
# ------------------------------
# ------------------------------
# Start of analysis generation
# ------------------------------
# create the system of equation, a SPD using a band storage scheme
ops.system("BandSPD")
# create the DOF numberer, the reverse Cuthill-McKee algorithm
ops.numberer("RCM")
# create the constraint handler, a Plain handler is used as h**o constraints
ops.constraints("Plain")
# create the solution algorithm, a Linear algorithm is created
ops.algorithm("Linear")
# create the integration scheme, the LoadControl scheme using steps of 1.0
ops.integrator("LoadControl", 1.0)
# create the analysis object
ops.analysis("Static")
# print model
#ops.printModel()
ops.printModel("-JSON", "-file", "Example5.1.json")
# -----------------------
# End of model generation
# -----------------------
# ----------------------------
# Start of analysis generation
# ----------------------------
# create the system of equation
ops.system("UmfPack")
# create the DOF numberer
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)
gamma = 0.5
beta = 0.25
#-----------------------------------------------------------------------------------------
# 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)
# Convergence test
# tolerance maxIter displayCode
ops.test("EnergyIncr", 1.0E-10, 20, 0)
# 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
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.load(4, 0.0, -P, 0.0)
# print model
#ops.printModel()
ops.printModel("-JSON", "-file", "Example3.1.json")
# ------------------------------
# End of model generation
# ------------------------------
# ------------------------------
# Start of analysis generation
# ------------------------------
# create the system of equation
ops.system("BandGeneral")
# create the DOF numberer, the reverse Cuthill-McKee algorithm
ops.numberer("RCM")
# 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
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.element('elasticBeamColumn', 2, 2, 3, A, E, G, J, Iy, Iz, gTTagx)
ops.element('elasticBeamColumn', 3, 3, 4, A, E, G, J, Iy, Iz, gTTagy)
Ew = {}
Px = -4.e1
Py = -2.5e1
Pz = -3.e1
ops.timeSeries('Constant', 1)
ops.pattern('Plain', 1, 1)
ops.load(4, Px, Py, Pz, 0., 0., 0.)
ops.constraints('Transformation')
ops.numberer('RCM')
ops.system('BandGeneral')
ops.test('NormDispIncr', 1.0e-6, 6, 2)
ops.algorithm('Linear')
ops.integrator('LoadControl', 1)
ops.analysis('Static')
ops.analyze(1)
opsv.plot_model()
sfac = 2.0e0
# fig_wi_he = 22., 14.
fig_wi_he = 30., 20.
# - 1
nep = 9
ops.element("Truss", 1, 1, 4, 10.0, 1)
ops.element("Truss", 2, 2, 4, 5.0, 1)
ops.element("Truss", 3, 3, 4, 5.0, 1)
# create TimeSeries
ops.timeSeries("Linear", 1)
# create a plain load pattern
ops.pattern("Plain", 1, 1, "-fact", 1.0)
ops.load(4, 100, -50)
# print model
#ops.Print()
# create SOE
ops.system("BandSPD")
# create DOF number
ops.numberer("RCM")
# create constraint handler
ops.constraints("Plain")
# create algorithm
ops.algorithm("Linear")
# create integrator
ops.integrator("LoadControl", 1.0)
# create analysis object
ops.analysis("Static")
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)
# Convergence test
# tolerance maxIter displayCode
ops.test("EnergyIncr", 1.0E-10, 20, 0)
# 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.pattern("UniformExcitation", 3, 2, "-accel", 3)
# print model
#ops.printModel()
ops.printModel("-JSON", "-file", "Example5.1.json")
# -----------------------
# End of model generation
# -----------------------
# ----------------------------
# Start of analysis generation
# ----------------------------
# create the system of equation
ops.system("UmfPack")
# create the DOF numberer
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)
ops.load(l2, 0.0, -1.0)
# print model
#ops.printModel()
ops.printModel("-JSON", "-file", "Example6.1.json")
# -----------------------
# End of model generation
# -----------------------
# --------------------------------------------------------------------
# Start of static analysis (creation of the analysis & analysis itself)
# --------------------------------------------------------------------
# create the system of equation
ops.system("ProfileSPD")
# create the DOF numberer
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)
seriesTag = seriesTag + 1
op.timeSeries("Linear", seriesTag)
# create a plain load pattern
patternTag = 1
op.pattern("Plain", patternTag, seriesTag)
# add load at the pile head load
loadValues = [0, P, 0.0]
op.load(3, *loadValues)
# ------------------------------
# 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)
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")
# print model
#ops.printModel()
ops.printModel("-JSON", "-file", "Example3.1.json")
# ------------------------------
# End of model generation
# ------------------------------
# ------------------------------
# Start of analysis generation
# ------------------------------
# create the system of equation
ops.system("BandGeneral")
# create the DOF numberer, the reverse Cuthill-McKee algorithm
ops.numberer("RCM")
# 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
nodeTag = 200+nNodePile
loadValues = [3500.0, 0.0, 0.0, 0.0, 0.0, 0.0]
op.timeSeries('Path', 1, '-values', *values, '-time', *time, '-factor', 1.0)
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()
