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