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
#-----------------------------------------------------------------------------------------
# 12. DYNAMIC ANALYSIS
#-----------------------------------------------------------------------------------------
op.model('basic', '-ndm', 2, '-ndf', 3)
# define constant scaling factor for applied velocity
cFactor = colArea * dashpotCoeff
# define velocity time history file
velocityFile = 'velocityHistory'
data_gm = np.loadtxt('velocityHistory.txt')
#motionSteps=len(data_gm)
#print('Number of point for GM:',motionSteps)
# timeseries object for force history
op.timeSeries('Path', 2, '-dt', motionDT, '-filePath', velocityFile + '.txt',
'-factor', cFactor)
op.pattern('Plain', 10, 2)
op.load(1, 1.0, 0.0, 0.0)
print("Dynamic loading created...")
op.constraints('Penalty', 1.0E16, 1.0E16)
op.test('NormDispIncr', 1e-3, 35, 1)
op.algorithm('KrylovNewton')
op.numberer('RCM')
op.system('ProfileSPD')
op.integrator('Newmark', gamma, beta)
op.rayleigh(a0, a1, 0.0, 0.0)
op.analysis('Transient')
# perform analysis with timestep reduction loop
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
ops.beamIntegration("Lobatto", gbiTag, gsecTag, N)
cbiTag = 2
ops.beamIntegration("Lobatto", cbiTag, csecTag, N)
leftColTag = 1
ops.element("forceBeamColumn", leftColTag, 1, 2, transfTag, cbiTag)
girderTag = 2
ops.element("forceBeamColumn", girderTag, 2, 3, transfTag, gbiTag)
rightColTag = 3
ops.element("forceBeamColumn", rightColTag, 3, 4, transfTag, cbiTag)
P = 25.0
w = 1.0e-1
tsTag = 1
ops.timeSeries("Constant", tsTag)
patternTag = 1
ops.pattern("Plain", patternTag, tsTag)
ops.load(2, P, 0, 0)
ops.eleLoad("-ele", girderTag, "-type", "beamUniform", -w)
ops.analysis("Static")
ops.randomVariable(62, 'lognormal', '-mean', E, '-stdv', 0.1 * E)
ops.randomVariable(32, 'normal', '-mean', P, '-stdv', 0.2 * P)
ops.randomVariable(89, 'normal', '-mean', 0, '-stdv', 1)
ops.randomVariable(41, 'normal', '-mean', -w, '-stdv', abs(0.2 * w))
ops.parameter(12, 'randomVariable', 62, "element", leftColTag, "E")
ops.fix(1, 1, 1)
ops.fix(2, 0, 1)
E = 30000.0
A = 25.0
fy = 50.0
ops.uniaxialMaterial("Hardening", 1, E, fy, 0, 100.0)
ops.element("truss", 1, 1, 2, A, 1)
P = 25.0
tsTag = 1
ops.timeSeries("Linear", tsTag)
patternTag = 1
ops.pattern("Plain", patternTag, tsTag)
ops.load(2, P, 0)
ops.analysis("Static")
ops.randomVariable(62, 'lognormal', '-mean', E, '-stdv', 0.1 * E)
ops.randomVariable(25, 'lognormal', '-mean', A, '-stdv', 0.1 * A)
ops.randomVariable(33, 'lognormal', '-mean', fy, '-stdv', 0.1 * fy)
ops.parameter(12, 'randomVariable', 62, "element", 1, "E")
ops.parameter(13, 'randomVariable', 25, "element", 1, "A")
ops.parameter(14, 'randomVariable', 33, "element", 1, "fy")
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.element('quad', 14, 17, 22, 23, 18, 1, 'PlaneStress', 1)
ops.element('quad', 15, 18, 23, 24, 19, 1, 'PlaneStress', 1)
ops.element('quad', 16, 19, 24, 25, 20, 1, 'PlaneStress', 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')
0.233, 0.143, 0.219, 0.255, 0.240, 0.173, 0.168, 0.231, 0.239, 0.195,
0.104, 0.196, 0.229, 0.208, 0.130, 0.148, 0.209, 0.212, 0.159, 0.082,
0.177, 0.206, 0.177, 0.087, 0.132, 0.189, 0.186, 0.124, 0.069, 0.161,
0.185, 0.149, 0.047, 0.120, 0.172, 0.163, 0.090, 0.061, 0.148, 0.166,
0.122, 0.008, 0.111, 0.158, 0.141, 0.059, 0.057, 0.138, 0.149, 0.097,
0.000, 0.105, 0.146, 0.122, 0.029, 0.055, 0.130, 0.135, 0.073, 0.000,
0.101, 0.136, 0.104, 0.004, 0.057, 0.125, 0.122, 0.052, 0.003, 0.101,
0.128, 0.089, 0.000, 0.062, 0.122, 0.112, 0.033, 0.005, 0.102, 0.123,
0.075, 0.000, 0.068, 0.121, 0.104, 0.016, 0.018, 0.106, 0.119, 0.064
])
MNS_TZ = MeanStress
MNS_QZ = 0.8 * MeanStress + 0.2
MNS_Time = 1.0 + np.linspace(0, 30.0, len(MNS_TZ))
seriesTag = 1
op.timeSeries('Path', seriesTag, '-time', *MNS_Time, '-values', *MNS_QZ,
'-factor', 1.0)
seriesTag = 2
op.timeSeries('Path', seriesTag, '-time', *MNS_Time, '-values', *MNS_TZ,
'-factor', 1.0)
# q-z liq
matTag = 1
qzType = 1
#qzType = 1 Backbone of q-z curve approximates Reese and O'Neill's (1987) relation for drilled shafts in clay. qzType = 2 Backbone of q-z curve approximates Vijayvergiya's (1977) relation for piles in sand.
qult = 1000.0
#Ultimate capacity of the q-z material. (kN)
qzz50 = 0.02
#Displacement at which 50% of qult is mobilized in monotonic loading. (m)
suction = 0.0
#Uplift resistance is equal to suction*qult. Default = 0.0.
c = 0.0
coordTransf = 'Linear'
ops.geomTransf(coordTransf, gTTagz, 0., -1., 0.)
ops.geomTransf(coordTransf, gTTagx, 0., -1., 0.)
ops.geomTransf(coordTransf, gTTagy, 1., 0., 0.)
ops.element('elasticBeamColumn', 1, 1, 2, A, E, G, J, Iy, Iz, gTTagz)
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
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)
# Mass lumped at master nodes
m = (4.0 * p) / g
# Rotary inertia of floor about master node
i = m * (bx * bx + by * by) / 12.0
# Set mass at the master nodes
# tag MX MY MZ RX RY RZ
ops.mass(9, m, m, 0.0, 0.0, 0.0, i)
ops.mass(14, m, m, 0.0, 0.0, 0.0, i)
ops.mass(19, m, m, 0.0, 0.0, 0.0, i)
# Define gravity loads
# create a Constant TimeSeries
ops.timeSeries("Constant", 1)
# create a Plain load pattern
ops.pattern("Plain", 1, 1, "-fact", 1.0)
for i in [5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 17, 18]:
ops.load(i, 0.0, 0.0, -p, 0.0, 0.0, 0.0)
# set rayleigh damping factors
ops.rayleigh(0.0, 0.0, 0.0, 0.0018)
# Define earthquake excitation
# ----------------------------
dt = 0.02
# Set up the acceleration records for Tabas fault normal and fault parallel
ops.timeSeries("Path", 2, "-filePath", "tabasFN.txt", "-dt", dt, "-factor", g)
ops.timeSeries("Path", 3, "-filePath", "tabasFP.txt", "-dt", dt, "-factor", g)
# Mass lumped at master nodes
m = (4.0*p)/g
# Rotary inertia of floor about master node
i = m*(bx*bx + by*by)/12.0
# Set mass at the master nodes
# tag MX MY MZ RX RY RZ
ops.mass( 9, m, m, 0.0, 0.0, 0.0, i)
ops.mass(14, m, m, 0.0, 0.0, 0.0, i)
ops.mass(19, m, m, 0.0, 0.0, 0.0, i)
# Define gravity loads
# create a Constant TimeSeries
ops.timeSeries("Constant", 1)
# create a Plain load pattern
ops.pattern("Plain", 1, 1, "-fact", 1.0)
for i in [5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 17, 18]:
ops.load(i, 0.0, 0.0, -p, 0.0, 0.0, 0.0)
# set rayleigh damping factors
ops.rayleigh(0.0, 0.0, 0.0, 0.0018)
# Define earthquake excitation
# ----------------------------
dt = 0.02
# Set up the acceleration records for Tabas fault normal and fault parallel
ops.timeSeries("Path", 2, "-filePath", "tabasFN.txt", "-dt", dt, "-factor", g)
ops.timeSeries("Path", 3, "-filePath", "tabasFP.txt", "-dt", dt, "-factor", g)
0.301, 0.354, 0.371, 0.356, 0.304, 0.311, 0.349, 0.348, 0.311, 0.256,
0.317, 0.335, 0.313, 0.249, 0.276, 0.314, 0.310, 0.264, 0.221, 0.285,
0.300, 0.273, 0.196, 0.245, 0.283, 0.274, 0.218, 0.192, 0.257, 0.269,
0.233, 0.143, 0.219, 0.255, 0.240, 0.173, 0.168, 0.231, 0.239, 0.195,
0.104, 0.196, 0.229, 0.208, 0.130, 0.148, 0.209, 0.212, 0.159, 0.082,
0.177, 0.206, 0.177, 0.087, 0.132, 0.189, 0.186, 0.124, 0.069, 0.161,
0.185, 0.149, 0.047, 0.120, 0.172, 0.163, 0.090, 0.061, 0.148, 0.166,
0.122, 0.008, 0.111, 0.158, 0.141, 0.059, 0.057, 0.138, 0.149, 0.097,
0.000, 0.105, 0.146, 0.122, 0.029, 0.055, 0.130, 0.135, 0.073, 0.000,
0.101, 0.136, 0.104, 0.004, 0.057, 0.125, 0.122, 0.052, 0.003, 0.101,
0.128, 0.089, 0.000, 0.062, 0.122, 0.112, 0.033, 0.005, 0.102, 0.123,
0.075, 0.000, 0.068, 0.121, 0.104, 0.016, 0.018, 0.106, 0.119, 0.064
])
MNS_Time = np.linspace(0, 30.0, len(MeanStress))
seriesTag = 1
op.timeSeries('Path', seriesTag, '-time', *MNS_Time, '-values', *MeanStress,
'-factor', 1.0)
# p-y liq
matTag = 1
soilType = 2
#soilType = 1 Backbone of p-y curve approximates Matlock (1970) soft clay relation. soilType = 2 Backbone of p-y curve approximates API (1993) sand relation.
pult = 1.0
#Ultimate capacity of the p-y material.
y50 = 0.0001
#Displacement at which 50% of pult is mobilized in monotonic loading.
Cd = 0.3
#Variable that sets the drag resistance within a fully-mobilized gap as Cd*pult.
c = 0.0
#The viscous damping term (dashpot) on the far-field (elastic) component of the displacement rate (velocity).
pRes = 0.1
#sets the minimum (or residual) peak resistance that the material retains as the adjacent solid soil elements liquefy
# ------------------
# Geometric transformation for beams
# tag
ops.geomTransf("Linear", 2)
# Create the beam element
# tag ndI ndJ A E Iz transfTag
ops.element("elasticBeamColumn", 3, 3, 4, 360.0, 4030.0, 8640.0, 2)
# Define gravity loads
# --------------------
# Set a parameter for the axial load
P = 180.0; # 10% of axial capacity of columns
# create a Linear TimeSeries (load factor varies linearly with time) - command: timeSeries Linear $tag
ops.timeSeries("Linear", 1)
# create a Plain load pattern - command: pattern Plain $tag $timeSeriesTag { $loads }
ops.pattern("Plain", 1, 1, "-fact", 1.0)
# create the nodal load - command: load nodeID xForce yForce zMoment
ops.load(3, 0.0, -P, 0.0)
ops.load(4, 0.0, -P, 0.0)
# ------------------------------
# End of model generation
# ------------------------------
# ------------------------------
# Start of analysis generation
# Geometry of column elements
# tag
ops.geomTransf("Linear", 2)
# Create the beam element
# tag ndI ndJ A E Iz transfTag
ops.element("elasticBeamColumn", 3, 3, 4, 360.0, 4030.0, 8640.0, 2)
# Define gravity loads
# --------------------
# Set a parameter for the axial load
P = 180.0
# 10% of axial capacity of columns
# create a Linear TimeSeries (load factor varies linearly with time) - command: timeSeries Linear $tag
ops.timeSeries("Linear", 1)
# create a Plain load pattern - command: pattern Plain $tag $timeSeriesTag { $loads }
ops.pattern("Plain", 1, 1, "-fact", 1.0)
# create the nodal load - command: load nodeID xForce yForce zMoment
ops.load(3, 0.0, -P, 0.0)
ops.load(4, 0.0, -P, 0.0)
# print model
#ops.printModel()
ops.printModel("-JSON", "-file", "Example3.1.json")
# ------------------------------
# End of model generation
# ------------------------------
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
# -----------------------------
# Geometry of column elements
# tag
ops.geomTransf("Linear", 2)
# Create the beam element
# tag ndI ndJ A E Iz transfTag
ops.element("elasticBeamColumn", 3, 3, 4, 360.0, 4030.0, 8640.0, 2)
# Define gravity loads
# --------------------
# Set a parameter for the axial load
P = 180.0; # 10% of axial capacity of columns
# create a Linear TimeSeries (load factor varies linearly with time) - command: timeSeries Linear $tag
ops.timeSeries("Linear", 1)
# create a Plain load pattern - command: pattern Plain $tag $timeSeriesTag { $loads }
ops.pattern("Plain", 1, 1, "-fact", 1.0)
# create the nodal load - command: load nodeID xForce yForce zMoment
ops.load(3, 0.0, -P, 0.0)
ops.load(4, 0.0, -P, 0.0)
# print model
#ops.printModel()
ops.printModel("-JSON", "-file", "Example3.1.json")
# ------------------------------
# End of model generation
# ------------------------------
print("Finished creating all recorders...")
#----------------------------------------------------------
# create the loading
#----------------------------------------------------------
op.setTime(10.0)
# apply point load at the uppermost pile node in the x-direction
values = [0.0, 0.0, 1.0, 1.0]
time = [0.0, 10.0, 20.0, 10000.0]
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')
