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')