def ops_cyclic(): ops.remove('recorders') ops.wipeAnalysis() ops.loadConst('-time', 0.0) # set hysteresis ops.recorder('Node', '-file', f'output\\cyclic_81_disp_{argv[0]}.out', '-time', '-node', 81, '-dof', 1, 'disp') ops.recorder('Node', '-file', f'output\\cyclic_81_rea_{argv[0]}.out', '-time', '-nodeRange', 1, 8, '-dof', 1, 'reaction') # ops.timeSeries("Path", 2, '-dt', 0.1, '-filePath', 'disp.txt') ops.timeSeries('Linear', 2) ops.pattern('Plain', 2, 2) # ops.sp(81, 1, 1) ops.load(81, 1, 0, 0, 0, 0, 0) # ops.constraints('Penalty', 1e20, 1e20) # ops.numberer('RCM') # ops.system('BandGeneral') # ops.test('NormDispIncr', 1e-4, 1e6, 2) # ops.algorithm('KrylovNewton') # ops.integrator('LoadControl', 0.1) # ops.analysis('Static') # # ops.analyze(12961) # with open('disp.txt', 'r') as f: # i = 1 # lines = f.readlines() # count = len(lines) # for line in lines: # logger.info( # 'position = {} line = {} and {:3%}'.format(line[:-1], i, i/count)) # ops.analyze(1) # i = i + 1 CyclicDisplace(1e-3, 80, 1e-3, 81, 1, 1e-6, 1e6)
def run(arg_1, arg_2, arg_3, arg_4): ops.reset() ops.wipe() ops.model('basic', '-ndm', 3, '-ndf', 6) ops.node(1, 0.0, 0.0, 0.0) ops.node(2, 0.0, 3.2, 0.0) ops.fix(1, 1, 1, 1, 1, 1, 1) ops.uniaxialMaterial('Concrete01', 1, -80.0e6, -0.002, 0.0, -0.005) ops.section('Fiber', 1, '-GJ', 1) ops.patch('rect', 1, 10, 10, -0.8, -0.1, 0.8, 0.1) ops.geomTransf('Linear', 1, 0, 0, 1) ops.beamIntegration('Legendre', 1, 1, 10) ops.element('dispBeamColumn', 1, 1, 2, 1, 1) ops.timeSeries('Linear', 1) ops.pattern('Plain', 1, 1) ops.load(2, 0, -24586.24, 0, 0, 0, 0) ops.constraints('Plain') ops.numberer('RCM') ops.system('UmfPack') ops.test('NormDispIncr', 1.0e-6, 2000) ops.algorithm('Newton') ops.integrator('LoadControl', 0.01) ops.analysis('Static') ops.analyze(100) ops.wipeAnalysis() ops.loadConst('-time', 0.0) ops.recorder('Node', '-file', 'disp.out', ' -time', '-node', 2, '-dof', 1, 'disp') ops.recorder('Node', '-file', 'react.out', '-time ', '-node', 2, '-dof', 1, 'reaction') ops.timeSeries('Linear', 2) ops.pattern('Plain', 2, 2) ops.load(2, 11500, 0, 0, 0, 0, 0) ops.constraints('Plain') ops.numberer('RCM') ops.system('UmfPack') ops.test('NormDispIncr', 1.0, 2000) ops.algorithm('Newton') ops.integrator('LoadControl', 0.01) ops.analysis('Static') # ops.analyze(100) step = 100 data = np.zeros((step, 2)) for i in range(step): ops.analyze(1) data[i, 0] = ops.nodeDisp(2, 1) data[i, 1] = ops.getLoadFactor(2) * 11500 return data
def ops_cyclic(): ops.remove('recorders') ops.wipeAnalysis() ops.loadConst('-time', 0.0) # set hysteresis ops.recorder('Node', '-file', 'output\\cyclic_657.out', '-time', '-node', 651, '-dof', 1, 'disp') ops.pattern('Plain', 2, 1) ops.load(651, 1, 0, 0, 0, 0, 0) CyclicDisplace(1e-3, 80, 1e-3, 651, 1, 1, 1e6)
def perform_modal_analysis_and_comparison(etabs_periods): eigenValues = modal_response(len(etabs_periods)) periods = 2 * math.pi / np.sqrt(eigenValues) # compare modal analysis results print('\nETABS Periods: ') print(etabs_periods) print('\nOpenSees Periods: ') print([round(n, 3) for n in list(periods)]) print('\nAgreement: (ETABS Periods/OpenSees Periods)') print(etabs_periods / periods) op.wipeAnalysis() return
def run_gravity_analysis(steps=10): """ Run gravity analysis (in 10 steps) """ ops.wipeAnalysis() ops.system("BandGeneral") ops.numberer("RCM") ops.constraints("Transformation") ops.test("NormDispIncr", 1.0E-12, 10, 3) ops.algorithm("Newton") # KrylovNewton ops.integrator("LoadControl", 1 / steps) ops.analysis("Static") ops.analyze(steps) title("Gravity Analysis Completed!") # Set the gravity loads to be constant & reset the time in the domain ops.loadConst("-time", 0.0) ops.wipeAnalysis()
def run_sensitivity_analysis(ctrlNode, dof, baseNode, SensParam, steps=500, IOflag=False): """ Run load-control sensitivity analysis """ ops.wipeAnalysis() start_time = time.time() title("Running Load-Control Sensitivity Analysis ...") ops.system("BandGeneral") ops.numberer("RCM") ops.constraints("Transformation") ops.test("NormDispIncr", 1.0E-12, 10, 3) ops.algorithm("Newton") # KrylovNewton ops.integrator("LoadControl", 1 / steps) ops.analysis("Static") ops.sensitivityAlgorithm( "-computeAtEachStep" ) # automatically compute sensitivity at the end of each step outputs = { "time": np.array([]), "disp": np.array([]), "force": np.array([]), } for sens in SensParam: outputs[f"sensDisp_{sens}"] = np.array([]), for i in range(steps): ops.reactions() if IOflag: print( f"Single Cycle Response: Step #{i}, Node #{ctrlNode}: {ops.nodeDisp(ctrlNode, dof):.3f} {LunitTXT} / {-ops.nodeReaction(baseNode, dof):.2f} {FunitTXT}." ) ops.analyze(1) tCurrent = ops.getTime() outputs["time"] = np.append(outputs["time"], tCurrent) outputs["disp"] = np.append(outputs["disp"], ops.nodeDisp(ctrlNode, dof)) outputs["force"] = np.append(outputs["force"], -ops.nodeReaction(baseNode, dof)) for sens in SensParam: # sensDisp(patternTag, paramTag) outputs[f"sensDisp_{sens}"] = np.append( outputs[f"sensDisp_{sens}"], ops.sensNodeDisp(ctrlNode, dof, sens)) title("Sensitvity Analysis Completed!") print( f"Analysis elapsed time is {(time.time() - start_time):.3f} seconds.\n" ) return outputs
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: """ opy.wipe() opy.model('basic', '-ndm', 2, '-ndf', 3) # 2 dimensions, 3 dof per node # Establish nodes bot_node = 1 top_node = 2 opy.node(bot_node, 0., 0.) opy.node(top_node, 0., 0.) # Fix bottom node opy.fix(top_node, opc.FREE, opc.FIXED, opc.FIXED) opy.fix(bot_node, opc.FIXED, opc.FIXED, opc.FIXED) # Set out-of-plane DOFs to be slaved opy.equalDOF(1, 2, *[2, 3]) # nodal mass (weight / g): opy.mass(top_node, mass, 0., 0.) # Define material bilinear_mat_tag = 1 mat_type = "Steel01" mat_props = [f_yield, k_spring, r_post] opy.uniaxialMaterial(mat_type, bilinear_mat_tag, *mat_props) # Assign zero length element beam_tag = 1 opy.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 opy.timeSeries('Path', load_tag_dynamic, '-dt', dt, '-values', *values) opy.pattern('UniformExcitation', pattern_tag_dynamic, opc.X, '-accel', load_tag_dynamic) # set damping based on first eigen mode angular_freq2 = opy.eigen('-fullGenLapack', 1) if hasattr(angular_freq2, '__len__'): angular_freq2 = angular_freq2[0] angular_freq = angular_freq2**0.5 alpha_m = 0.0 beta_k = 2 * xi / angular_freq beta_k_comm = 0.0 beta_k_init = 0.0 opy.rayleigh(alpha_m, beta_k, beta_k_init, beta_k_comm) # Run the dynamic analysis opy.wipeAnalysis() opy.algorithm('Newton') opy.system('SparseGeneral') opy.numberer('RCM') opy.constraints('Transformation') opy.integrator('Newmark', 0.5, 0.25) opy.analysis('Transient') tol = 1.0e-10 iterations = 10 opy.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 opy.getTime() < analysis_time: curr_time = opy.getTime() opy.analyze(1, analysis_dt) outputs["time"].append(curr_time) outputs["rel_disp"].append(opy.nodeDisp(top_node, 1)) outputs["rel_vel"].append(opy.nodeVel(top_node, 1)) outputs["rel_accel"].append(opy.nodeAccel(top_node, 1)) opy.reactions() outputs["force"].append( -opy.nodeReaction(bot_node, 1)) # Negative since diff node opy.wipe() for item in outputs: outputs[item] = np.array(outputs[item]) return outputs
def run_analysis(GM_dt, GM_npts, TS_List, EDP_specs, model_params): """ Run dynamic analysis for a time history and return a dictionary of envelope EDPs. Assumes that length is measured in inches and acceleration in in/s2 Parameters ---------- GM_dt: float Time step of time series GM_npts: float Number of points in time series TS_List: float 1x2 list where first component is a list of accelerations in the X direction, the second component is a list of accelerations in the Y direction. EDP_specs: dict """ stories = model_params["NumberOfStories"] node_tags = list(range(stories + 1)) height = ops.nodeCoord(node_tags[-1], 3) - ops.nodeCoord(node_tags[0], 3) # define parameters for dynamic analysis dt = GM_dt # time increment for analysis GMX = TS_List[0] # list of GM accelerations in X direction GMY = TS_List[1] # list of GM accelerations in Y direction driftLimit = 0.20 # interstory drift limit indicating collapse tol = 1.e-08 # tolerance criteria to check for convergence maxiter = 30 # max number of iterations to check subSteps = 2 # number of subdivisions in cases of ill convergence # pad shorter record with zeros (free vibration) such that two horizontal records are the same length nsteps = max(len(GMX), len(GMY)) for GM in [GMX, GMY]: if len(GM) < nsteps: diff = nsteps - len(GM) GM.extend(np.zeros(diff)) # initialize dictionary of envelope EDPs envelopeDict = {} for edp in EDP_specs: envelopeDict[edp] = {} for loc in EDP_specs[edp]: envelopeDict[edp][loc] = np.zeros(len( EDP_specs[edp][loc])).tolist() #print(envelopeDict) # initialize dictionary of time history EDPs time_analysis = np.zeros(nsteps * 5) acc_history = {} for floor in range(stories + 1): acc_history.update( {floor: { 1: time_analysis.copy(), 2: time_analysis.copy() }}) ops.wipeAnalysis() ops.constraints( 'Transformation' ) # handles boundary conditions based on transformation equation method ops.numberer('RCM') # renumber dof's to minimize band-width (optimization) ops.system('UmfPack' ) # constructs sparse system of equations using UmfPack solver ops.test( 'NormDispIncr', tol, maxiter ) # tests for convergence using norm of left-hand side of matrix equation ops.algorithm( 'NewtonLineSearch' ) # use Newton's solution algorithm: updates tangent stiffness at every iteration ops.integrator( 'Newmark', 0.5, 0.25) # Newmark average acceleration method for numerical integration ops.analysis('Transient') # define type of analysis: time-dependent # initialize variables maxDiv = 1024 minDiv = subSteps step = 0 ok = 0 breaker = 0 count = 0 while step < nsteps and ok == 0 and breaker == 0: step = step + 1 # take 1 step ok = 2 div = minDiv length = maxDiv while div <= maxDiv and length > 0 and breaker == 0: stepSize = dt / div # perform analysis for one increment; will return 0 if no convergence issues ok = ops.analyze(1, stepSize) if ok == 0: count = count + 1 length = length - maxDiv / div floor = 1 while floor <= stories: # check if drift limits are satisfied # check X direction drifts (direction 1) drift_x = abs( ops.nodeDisp(node_tags[1], 1) - ops.nodeDisp(node_tags[0], 1)) / height if drift_x >= driftLimit: breaker = 1 # check Y direction drifts (direction 2) drift_y = abs( ops.nodeDisp(node_tags[1], 2) - ops.nodeDisp(node_tags[0], 2)) / height if drift_y >= driftLimit: breaker = 1 # save parameter values in recording dictionaries at every step time_analysis[count] = time_analysis[count - 1] + stepSize envelopeDict['PID'][floor][0] = max( drift_x, envelopeDict['PID'][floor][0]) envelopeDict['PID'][floor][1] = max( drift_y, envelopeDict['PID'][floor][1]) floor = floor + 1 for floor in range(stories + 1): for dof in [1, 2]: acc_history[floor][dof][count] = ops.nodeAccel( node_tags[floor], dof) else: div = div * 2 print("Number of increments increased to ", str(div)) # end analysis once drift limit has been reached if breaker == 1: ok = 1 print("Collapse drift has been reached") print("Number of analysis steps completed: {}".format(count)) # remove extra zeros from the end of the time history time_analysis = time_analysis[1:count + 1] # generate time array from recording time_record = np.linspace(0, nsteps * dt, num=nsteps, endpoint=False) # remove extra zeros from accel time history, add GM to obtain absolute a # acceleration, and record envelope value GMX_interp = np.interp(time_analysis, time_record, GMX) GMY_interp = np.interp(time_analysis, time_record, GMY) for floor in range(0, stories + 1): # X direction envelopeDict['PFA'][floor][0] = max( abs(np.asarray(acc_history[floor][1][1:count + 1]) + GMX_interp)) # Y direction envelopeDict['PFA'][floor][1] = max( abs(np.asarray(acc_history[floor][2][1:count + 1]) + GMY_interp)) return envelopeDict
def RunAnalysis(): # ---------------------------- # Start of model generation # ---------------------------- # remove existing model ops.wipe() ops.model("BasicBuilder", "-ndm", 3, "-ndf", 6) # set default units ops.defaultUnits("-force", "kip", "-length", "in", "-time", "sec", "-temp", "F") # Define the section # ------------------ # secTag E nu h rho ops.section("ElasticMembranePlateSection", 1, 3.0E3, 0.25, 1.175, 1.27) # Define geometry # --------------- # these should both be even nx = 10 ny = 2 # loaded nodes mid = int(((nx + 1) * (ny + 1) + 1) / 2) side1 = int((nx + 2) / 2) side2 = int((nx + 1) * (ny + 1) - side1 + 1) # generate the nodes and elements # numX numY startNode startEle eleType eleArgs? coords? ops.block2D(nx, ny, 1, 1, "ShellMITC4", 1, 1, -20.0, 0.0, 0.0, 2, -20.0, 0.0, 40.0, 3, 20.0, 0.0, 40.0, 4, 20.0, 0.0, 0.0, 5, -10.0, 10.0, 20.0, 7, 10.0, 10.0, 20.0, 9, 0.0, 10.0, 20.0) # define the boundary conditions ops.fixZ(0.0, 1, 1, 1, 0, 1, 1) ops.fixZ(40.0, 1, 1, 1, 0, 1, 1) ops.mass(20, 10.0, 10.0, 10.0, 0.0, 0.0, 0.0) # create a Linear time series ops.timeSeries("Linear", 1) # add some loads ops.pattern("Plain", 1, 1, "-fact", 1.0) ops.load(mid, 0.0, -0.50, 0.0, 0.0, 0.0, 0.0) ops.load(side1, 0.0, -0.25, 0.0, 0.0, 0.0, 0.0) ops.load(side2, 0.0, -0.25, 0.0, 0.0, 0.0, 0.0) # ------------------------ # Start of static analysis # ------------------------ # Load control with variable load steps # init Jd min max ops.integrator("LoadControl", 1.0, 1, 1.0, 10.0) ops.test("EnergyIncr", 1.0E-10, 20, 0) ops.algorithm("Newton") ops.numberer("RCM") ops.constraints("Plain") ops.system("SparseGeneral", "-piv") ops.analysis("Static") ops.analyze(5) # --------------------------------------- # Create and Perform the dynamic analysis # --------------------------------------- # Remove the static analysis & reset the time to 0.0 ops.wipeAnalysis() ops.setTime(0.0) # Now remove the loads and let the beam vibrate ops.remove("loadPattern", 1) Model = 'test' LoadCase = 'Transient' LoadCase2 = 'Transient_5s' opp.createODB(Model, LoadCase, Nmodes=3, recorders=[]) opp.createODB(Model, LoadCase2, Nmodes=3, deltaT=5., recorders=[]) # Create the transient analysis ops.test("EnergyIncr", 1.0E-10, 20, 0) ops.algorithm("Newton") ops.numberer("RCM") ops.constraints("Plain") ops.system("SparseGeneral", "-piv") ops.integrator("Newmark", 0.50, 0.25) ops.analysis("Transient") # Perform the transient analysis (20 sec) ops.analyze(100, 0.2)
def ModalAnalysis3D(numEigen): """ |-----------------------------------------------------------------------| | | | Modal Analysis of 3D systems | | | | Author: Volkan Ozsarac | | Affiliation: University School for Advanced Studies IUSS Pavia | | Earthquake Engineering PhD Candidate | | | |-----------------------------------------------------------------------| """ import numpy as np import openseespy.opensees as op import time import sys print('Extracting the mass matrix, ignore the following warnings...\n') op.wipeAnalysis() op.system('FullGeneral') op.analysis('Transient') # Extract the Mass Matrix op.integrator('GimmeMCK',1.0,0.0,0.0) op.analyze(1,0.0) time.sleep(0.5) # Number of equations in the model N = op.systemSize() # Has to be done after analyze Mmatrix = op.printA('-ret') # Or use op.printA('-file','M.out') Mmatrix = np.array(Mmatrix) # Convert the list to an array Mmatrix.shape = (N,N) # Make the array an NxN matrix print('\nExtracted the mass matrix, ignore the previous warnings...') # Rerrange the mass matrix in accordance with nodelist order from getNodeTags() DOFs = [] # These are the idx of all the DOFs used in the extract mass matrix, order is rearranged used = {} # Save here the nodes and their associated dofs used in global mass matrix lx = np.zeros([N,1]) # influence vector (x) ly = np.zeros([N,1]) # influence vector (y) lz = np.zeros([N,1]) # influence vector (z) lrx = np.zeros([N,1]) # influence vector (rx) lry = np.zeros([N,1]) # influence vector (ry) lrz = np.zeros([N,1]) # influence vector (rz) idx = 0 # index NDF = 6 # NDF is number of DOFs/node for node in op.getNodeTags(): used[node] = [] for j in range(NDF): temp = op.nodeDOFs(node)[j] if temp not in DOFs and temp >=0: DOFs.append(op.nodeDOFs(node)[j]) used[node].append(j+1) if j == 0: lx[idx,0] = 1 if j == 1: ly[idx,0] = 1 if j == 2: lz[idx,0] = 1 if j == 3: lrx[idx,0] = 1 if j == 4: lry[idx,0] = 1 if j == 5: lrz[idx,0] = 1 idx += 1 Mmatrix = Mmatrix[DOFs,:][:,DOFs] op.wipeAnalysis() listSolvers = ['-genBandArpack','-fullGenLapack','-symmBandLapack'] ok = 1 for s in listSolvers: print("Using %s as solver..." % s[1:]) try: eigenValues = op.eigen(s,numEigen) catchOK = 0 ok = 0 except: catchOK = 1 if catchOK==0: for i in range(numEigen): if eigenValues[i] < 0: ok = 1 if ok==0: print('Eigenvalue analysis is completed.') break if ok!=0: print("Error on Modal Analysis...") sys.exit() else: Lamda = np.asarray(eigenValues) Omega = Lamda**0.5 T = 2*np.pi/Omega f = 1/T print('Modal properties for the first %d modes:' % numEigen) Mx = []; My = []; Mz = []; Mrx = []; Mry = []; Mrz = [] dofs = ['x','y','z','rx','ry','rz'] print('Mode| T [sec] | f [Hz] | \u03C9 [rad/sec] | Mx [%] | My [%] | Mz [%] | \u2211Mx [%] | \u2211My [%] | \u2211Mz [%]') for mode in range(1,numEigen+1): # Although Mrx, Mry and Mrz are calculated, I am not printing these idx = 0 phi = np.zeros([N,1]) for node in used: for dof in used[node]: phi[idx,0]=op.nodeEigenvector(node,mode,dof) idx += 1 for dof in dofs: l = eval('l'+dof) Mtot = l.T@Mmatrix@l # Total mass in specified global dof Mn = phi.T@Mmatrix@phi # Modal mass in specified global dof Ln = phi.T@Mmatrix@l # Effective modal mass in specified global dof Mnstar = Ln**2/Mn/Mtot*100 # Normalised effective modal mass participating [%], in specified global dof eval('M'+dof).append(Mnstar[0,0]) # Save the modal mass for the specified dof print('%3s |%7s |%6s |%9s |%6s |%6s |%6s |%7s |%7s |%7s' \ % ("{:.0f}".format(mode), "{:.3f}".format(T[mode-1]), "{:.3f}".format(f[mode-1]), "{:.2f}".format(Omega[mode-1]), \ "{:.2f}".format(Mx[mode-1]), "{:.2f}".format(My[mode-1]), "{:.2f}".format(Mz[mode-1]), \ "{:.2f}".format(sum(Mx)), "{:.2f}".format(sum(My)), "{:.2f}".format(sum(Mz)))) Mtot = lx.T@Mmatrix@lx; Mtot = Mtot[0,0]
def __init__(self): # AIが取れるアクションの設定 self.action = np.array([ 0, 0.02, 0.03, 0.05, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1 ]) self.naction = len(self.action) self.beta = 1 / 4 # 1質点系モデル self.T0 = 4 self.h = self.action[0] self.hs = [self.h] self.m = 100 self.k = 4 * np.pi**2 * self.m / self.T0**2 # 入力地震動 self.dt = 0.02 to_meter = 0.01 # cmをmに変換する値 self.wave_url = 'https://github.com/kakemotokeita/dqn-seismic-control/blob/master/wave/sample.csv' with urllib.request.urlopen(self.wave_url) as wave_file: self.wave_data = np.loadtxt( wave_file, usecols=(0, ), delimiter=',', skiprows=3) * to_meter # OpenSees設定 op.wipe() op.model('basic', '-ndm', 2, '-ndf', 3) # 2 dimensions, 3 dof per node # 節点 self.bot_node = 1 self.top_node = 2 op.node(self.bot_node, 0., 0.) op.node(self.top_node, 0., 0.) # 境界条件 op.fix(self.top_node, FREE, FIXED, FIXED) op.fix(self.bot_node, FIXED, FIXED, FIXED) op.equalDOF(1, 2, *[Y, ROTZ]) # 質量 op.mass(self.top_node, self.m, 0., 0.) # 弾性剛性 elastic_mat_tag = 1 Fy = 1e10 E0 = self.k b = 1.0 op.uniaxialMaterial('Steel01', elastic_mat_tag, Fy, E0, b) # Assign zero length element beam_tag = 1 op.element('zeroLength', beam_tag, self.bot_node, self.top_node, "-mat", elastic_mat_tag, "-dir", 1, '-doRayleigh', 1) # Define the dynamic analysis load_tag_dynamic = 1 pattern_tag_dynamic = 1 self.values = list(-1 * self.wave_data) # should be negative op.timeSeries('Path', load_tag_dynamic, '-dt', self.dt, '-values', *self.values) op.pattern('UniformExcitation', pattern_tag_dynamic, X, '-accel', load_tag_dynamic) # 減衰の設定 self.w0 = op.eigen('-fullGenLapack', 1)[0]**0.5 self.alpha_m = 0.0 self.beta_k = 2 * self.h / self.w0 self.beta_k_init = 0.0 self.beta_k_comm = 0.0 op.rayleigh(self.alpha_m, self.beta_k, self.beta_k_init, self.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) self.i_pre = 0 self.i = 0 self.i_next = 0 self.time = 0 self.analysis_time = (len(self.values) - 1) * self.dt self.dis = 0 self.vel = 0 self.acc = 0 self.a_acc = 0 self.force = 0 self.resp = { "time": [], "dis": [], "acc": [], "a_acc": [], "vel": [], "force": [], } self.done = False
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: """ osi = o3.OpenSeesInstance(ndm=2) # Establish nodes bot_node = o3.node.Node(osi, 0, 0) top_node = o3.node.Node(osi, 0, 0) # Fix bottom node opy.fix(top_node.tag, o3.cc.FREE, o3.cc.FIXED, o3.cc.FIXED) opy.fix(bot_node.tag, o3.cc.FIXED, o3.cc.FIXED, o3.cc.FIXED) # Set out-of-plane DOFs to be slaved opy.equalDOF(top_node.tag, bot_node.tag, *[o3.cc.Y, o3.cc.ROTZ]) # nodal mass (weight / g): opy.mass(top_node.tag, mass, 0., 0.) # Define material bilinear_mat = o3.uniaxial_material.Steel01(osi, fy=f_yield, e0=k_spring, b=r_post) # Assign zero length element, # Note: pass actual node and material objects into element o3.element.ZeroLength(osi, [bot_node, top_node], mats=[bilinear_mat], dirs=[o3.cc.DOF2D_X], r_flag=1) # Define the dynamic analysis load_tag_dynamic = 1 pattern_tag_dynamic = 1 values = list(-1 * motion) # should be negative opy.timeSeries('Path', load_tag_dynamic, '-dt', dt, '-values', *values) opy.pattern('UniformExcitation', pattern_tag_dynamic, o3.cc.X, '-accel', load_tag_dynamic) # set damping based on first eigen mode angular_freq2 = opy.eigen('-fullGenLapack', 1) if hasattr(angular_freq2, '__len__'): angular_freq2 = angular_freq2[0] angular_freq = angular_freq2**0.5 beta_k = 2 * xi / angular_freq o3.rayleigh.Rayleigh(osi, alpha_m=0.0, beta_k=beta_k, beta_k_init=0.0, beta_k_comm=0.0) # Run the dynamic analysis opy.wipeAnalysis() newmark_gamma = 0.5 newmark_beta = 0.25 o3.algorithm.Newton(osi) o3.constraints.Transformation(osi) o3.algorithm.Newton(osi) o3.numberer.RCM(osi) o3.system.SparseGeneral(osi) o3.integrator.Newmark(osi, newmark_gamma, newmark_beta) o3.analysis.Transient(osi) o3.test_check.EnergyIncr(osi, tol=1.0e-10, max_iter=10) analysis_time = (len(values) - 1) * dt analysis_dt = 0.001 outputs = { "time": [], "rel_disp": [], "rel_accel": [], "rel_vel": [], "force": [] } while opy.getTime() < analysis_time: curr_time = opy.getTime() opy.analyze(1, analysis_dt) outputs["time"].append(curr_time) outputs["rel_disp"].append(opy.nodeDisp(top_node.tag, o3.cc.X)) outputs["rel_vel"].append(opy.nodeVel(top_node.tag, o3.cc.X)) outputs["rel_accel"].append(opy.nodeAccel(top_node.tag, o3.cc.X)) opy.reactions() outputs["force"].append(-opy.nodeReaction( bot_node.tag, o3.cc.X)) # Negative since diff node opy.wipe() for item in outputs: outputs[item] = np.array(outputs[item]) return outputs
def createOutputDatabase(self, Nmodes=0, deltaT=0.0, recorders=[]): """ This function creates a directory to save all the output data. Command: createODB("ModelName",<"LoadCase Name">, <Nmodes=Nmodes(int)>, <recorders=*recorder(list)>) ModelName : (string) Name of the model. The main output folder will be named "ModelName_ODB" in the current directory. LoadCase Name: (string), Optional. Name of the load case forder to be created inside the ModelName_ODB folder. If not provided, no load case data will be read. Nmodes : (int) Optional key argument to save modeshape data. Default is 0, no modeshape data is saved. deltaT : (float) Optional time interval for recording. will record when next step is deltaT greater than last recorder step. (default: records at every time step) recorders : (string) A list of additional quantities a users would like to record in the output database. The arguments for these additional inputs match the standard OpenSees arguments to avoid any confusion. 'localForce','basicDeformation', 'plasticDeformation','stresses','strains' The recorders for node displacement and reactions are saved by default to help plot the deformed shape. Example: createODB(TwoSpanBridge, Pushover, Nmodes=3, recorders=['stresses', 'strains']) Future: The integrationPoints output works only for nonlinear beam column elements. If a model has a combination of elastic and nonlienar elements, we need to create a method distinguish. """ ODBdir = self.ODBdir # ODB Dir name if not os.path.exists(ODBdir): os.makedirs(ODBdir) nodeList = op.getNodeTags() eleList = op.getEleTags() dofList = [int(ii + 1) for ii in range(len(op.nodeCoord(nodeList[0])))] # Save node and element data in the main Output folder self.saveNodesandElements() ######################### ## Create mode shape dir ######################### if Nmodes > 0: ModeShapeDir = os.path.join(ODBdir, "ModeShapes") if not os.path.exists(ModeShapeDir): os.makedirs(ModeShapeDir) ## Run eigen analysis internally and get information to print Tarray = np.zeros([1, Nmodes]) # To save all the periods of vibration op.wipeAnalysis() eigenVal = op.eigen(Nmodes + 1) for mm in range(1, Nmodes + 1): Tarray[0, mm - 1] = 4 * asin(1.0) / (eigenVal[mm - 1])**0.5 modeTFile = os.path.join(ModeShapeDir, "ModalPeriods.out") np.savetxt(modeTFile, Tarray, delimiter=self.delim, fmt=self.fmt) ### Save mode shape data for ii in range(1, Nmodes + 1): self.saveModeShapeData(ii) op.wipeAnalysis() LoadCaseDir = self.LoadCaseDir if not os.path.exists(LoadCaseDir): os.makedirs(LoadCaseDir) NodeDispFile = os.path.join(LoadCaseDir, "NodeDisp_All.out") EleForceFile = os.path.join(LoadCaseDir, "EleForce_All.out") ReactionFile = os.path.join(LoadCaseDir, "Reaction_All.out") EleStressFile = os.path.join(LoadCaseDir, "EleStress_All.out") EleStrainFile = os.path.join(LoadCaseDir, "EleStrain_All.out") EleBasicDefFile = os.path.join(LoadCaseDir, "EleBasicDef_All.out") ElePlasticDefFile = os.path.join(LoadCaseDir, "ElePlasticDef_All.out") # EleIntPointsFile = os.path.join(LoadCaseDir,"EleIntPoints_All.out") # Save recorders in the ODB folder op.recorder('Node', '-file', NodeDispFile, '-time', '-dT', deltaT, '-node', *nodeList, '-dof', *dofList, 'disp') op.recorder('Node', '-file', ReactionFile, '-time', '-dT', deltaT, '-node', *nodeList, '-dof', *dofList, 'reaction') if 'localForce' in recorders: op.recorder('Element', '-file', EleForceFile, '-time', '-dT', deltaT, '-ele', *eleList, '-dof', *dofList, 'localForce') if 'basicDeformation' in recorders: op.recorder('Element', '-file', EleBasicDefFile, '-time', '-dT', deltaT, '-ele', *eleList, '-dof', *dofList, 'basicDeformation') if 'plasticDeformation' in recorders: op.recorder('Element', '-file', ElePlasticDefFile, '-time', '-dT', deltaT, '-ele', *eleList, '-dof', *dofList, 'plasticDeformation') if 'stresses' in recorders: op.recorder('Element', '-file', EleStressFile, '-time', '-dT', deltaT, '-ele', *eleList, 'stresses') if 'strains' in recorders: op.recorder('Element', '-file', EleStrainFile, '-time', '-dT', deltaT, '-ele', *eleList, 'strains')
def test_DynAnal_BeamWithQuadElements(): ops.wipe() # clear opensees model # create data directory # file mkdir Data #----------------------------- # Define the model # ---------------------------- # Create ModelBuilder with 2 dimensions and 2 DOF/node ops.model('BasicBuilder', '-ndm', 2, '-ndf', 2) # create the material ops.nDMaterial('ElasticIsotropic', 1, 1000.0, 0.25, 3.0) # set type of quadrilateral element (uncomment one of the three options) Quad = 'quad' #set Quad bbarQuad #set Quad enhancedQuad # set up the arguments for the three considered elements if Quad == "enhancedQuad": eleArgs = "PlaneStress2D 1" if Quad == "quad": eleArgs = "1 PlaneStress2D 1" if Quad == "bbarQuad": eleArgs = "1" # set up the number of elements in x (nx) and y (ny) direction nx = 16 # NOTE: nx MUST BE EVEN FOR THIS EXAMPLE ny = 4 # define numbering of node at the left support (bn), and the two nodes at load application (l1, l2) bn = nx + 1 l1 = int(nx / 2 + 1) l2 = int(l1 + ny * (nx + 1)) # create the nodes and elements using the block2D command ops.block2D(nx, ny, 1, 1, Quad, 1., 'PlaneStress2D', 1, 1, 0., 0., 2, 40., 0., 3, 40., 10., 4, 0., 10.) # define boundary conditions ops.fix(1, 1, 1) ops.fix(bn, 0, 1) # define the recorder #--------------------- # recorder Node -file Data/Node.out -time -node l1 -dof 2 disp # define load pattern #--------------------- ops.timeSeries('Linear', 1) ops.pattern('Plain', 1, 1) ops.load(l1, 0.0, -1.0) ops.load(l2, 0.0, -1.0) # -------------------------------------------------------------------- # Start of static analysis (creation of the analysis & analysis itself) # -------------------------------------------------------------------- # Load control with variable load steps # init Jd min max ops.integrator('LoadControl', 1.0, 1, 1.0, 10.0) # Convergence test # tolerance maxIter displayCode ops.test('EnergyIncr', 1.0e-12, 10, 0) # Solution algorithm ops.algorithm('Newton') # DOF numberer ops.numberer('RCM') # Cosntraint handler ops.constraints('Plain') # System of equations solver ops.system('ProfileSPD') # Type of analysis analysis ops.analysis('Static') # Perform the analysis ops.analyze(10) # -------------------------- # End of static analysis # -------------------------- # ------------------------------------- # create display for transient analysis #-------------------------------------- # windowTitle xLoc yLoc xPixels yPixels # recorder display "Simply Supported Beam" 10 10 800 200 -wipe # prp 20 5.0 1.0 # projection reference point (prp) defines the center of projection (viewer eye) # vup 0 1 0 # view-up vector (vup) # vpn 0 0 1 # view-plane normal (vpn) # viewWindow -30 30 -10 10 # coordiantes of the window relative to prp # display 10 0 5 # the 1st arg. is the tag for display mode # the 2nd arg. is magnification factor for nodes, the 3rd arg. is magnif. factor of deformed shape # --------------------------------------- # Create and Perform the dynamic analysis # --------------------------------------- #define damping evals = ops.eigen(1) ops.rayleigh(0., 0., 0., 2 * 0.02 / sqrt(evals[0])) # Remove the static analysis & reset the time to 0.0 ops.wipeAnalysis() ops.setTime(0.0) # Now remove the loads and let the beam vibrate ops.remove('loadPattern', 1) uy1 = ops.nodeDisp(9, 2) print("uy(9) = ", uy1) # Create the transient analysis ops.test('EnergyIncr', 1.0e-12, 10, 0) ops.algorithm('Newton') ops.numberer('RCM') ops.constraints('Plain') ops.integrator('Newmark', 0.5, 0.25) ops.system('BandGeneral') ops.analysis('Transient') # Perform the transient analysis (50 sec) ops.analyze(1500, 0.5) uy2 = ops.nodeDisp(9, 2) print("uy(9) = ", uy2) assert abs(uy1 + 0.39426414168933876514) < 1e-12 and abs( uy2 + 0.00736847273806807632) < 1e-12 print("========================================")
# Permform the conversion from SMD record to OpenSees record dt, nPts = ReadRecord.ReadRecord(record + '.at2', record + '.dat') # Set time series to be passed to uniform excitation ops.timeSeries('Path', 7, '-filePath', record + '.dat', '-dt', dt, '-factor', g) # Create UniformExcitation load pattern # tag dir ops.pattern('UniformExcitation', 7, 1, '-accel', 7) # set the rayleigh damping factors for nodes & elements ops.rayleigh(0.4274, 0.005827, 0.0, 0.0) # Delete the old analysis and all it's component objects ops.wipeAnalysis() # Create the system of equation, a banded general storage scheme ops.system('BandGeneral') # Create the constraint handler, a plain handler as homogeneous boundary ops.constraints('Transformation') # 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-4, 100) # Create the solution algorithm, a Newton-Raphson algorithm ops.algorithm('Newton') # Create the DOF numberer, the reverse Cuthill-McKee algorithm
#import os import math op.wipe() from InelasticFiberSection import * Dmax = 0.05 * LCol Dincr = 0.001 * LCol Hload = Weight maxNumIter = 6 tol = 1e-8 op.timeSeries('Linear', 2) op.pattern('Plain', 200, 2) op.load(2, Hload, 0.0, 0.0) op.wipeAnalysis() op.constraints('Plain') op.numberer('Plain') op.system('BandGeneral') op.test('EnergyIncr', Tol, maxNumIter) op.algorithm('Newton') op.integrator('DisplacementControl', IDctrlNode, IDctrlDOF, Dincr) op.analysis('Static') Nsteps = int(Dmax / Dincr) ok = op.analyze(Nsteps) print(ok) # for gravity analysis, load control is fine, 0.1 is the load factor increment (http://opensees.berkeley.edu/wiki/index.php/Load_Control)
def run_sensitivity_pushover_analysis(ctrlNode, baseNodes, dof, Dincr, max_disp, SensParam, IOflag=False): """ Run pushover analysis with sensitivity """ ops.wipeAnalysis() start_time = time.time() ops.loadConst("-time", 0.0) title("Running Displacement-Control Pushover Sensitivity Analysis ...") testType = "NormDispIncr" # EnergyIncr tolInit = 1.0E-8 iterInit = 10 # Set the initial Max Number of Iterations algorithmType = "Newton" # Set the algorithm type ops.system("BandGeneral") ops.constraints("Transformation") ops.numberer("RCM") ops.test(testType, tolInit, iterInit) ops.algorithm(algorithmType) # Change the integration scheme to be displacement control # node dof init Jd min max ops.integrator("DisplacementControl", ctrlNode, dof, Dincr) ops.analysis("Static") ops.sensitivityAlgorithm( "-computeAtEachStep" ) # automatically compute sensitivity at the end of each step if IOflag: print( f"Single Pushover: Push node {ctrlNode} to {max_disp} {LunitTXT}.\n" ) # Set some parameters tCurrent = ops.getTime() currentStep = 1 outputs = { "time": np.array([]), "disp": np.array([]), "force": np.array([]), } for sens in SensParam: outputs[f"sensLambda_{sens}"] = np.array([]), nodeList = [] for node in baseNodes: nodeList.append(f"- ops.nodeReaction({node}, dof) ") nodeList = "".join(nodeList) currentDisp = ops.nodeDisp(ctrlNode, dof) ok = 0 while ok == 0 and currentDisp < max_disp: ops.reactions() ok = ops.analyze(1) tCurrent = ops.getTime() currentDisp = ops.nodeDisp(ctrlNode, dof) if IOflag: print( f"Current displacement ==> {ops.nodeDisp(ctrlNode, dof):.3f} {LunitTXT}" ) # if the analysis fails try initial tangent iteration if ok != 0: print("\n==> Trying relaxed convergence...") ops.test(testType, tolInit / 0.01, iterInit * 50) ok = ops.analyze(1) if ok == 0: print("==> that worked ... back to default analysis...\n") ops.test(testType, tolInit, iterInit) if ok != 0: print("\n==> Trying Newton with initial then current...") ops.test(testType, tolInit / 0.01, iterInit * 50) ops.algorithm("Newton", "-initialThenCurrent") ok = ops.analyze(1) if ok == 0: print("==> that worked ... back to default analysis...\n") ops.algorithm(algorithmType) ops.test(testType, tolInit, iterInit) if ok != 0: print("\n==> Trying ModifiedNewton with initial...") ops.test(testType, tolInit / 0.01, iterInit * 50) ops.algorithm("ModifiedNewton", "-initial") ok = ops.analyze(1) if ok == 0: print("==> that worked ... back to default analysis...\n") ops.algorithm(algorithmType) ops.test(testType, tolInit, iterInit) currentStep += 1 tCurrent = ops.getTime() outputs["time"] = np.append(outputs["time"], tCurrent) outputs["disp"] = np.append(outputs["disp"], ops.nodeDisp(ctrlNode, dof)) outputs["force"] = np.append(outputs["force"], eval(nodeList)) for sens in SensParam: # sensLambda(patternTag, paramTag) outputs[f"sensLambda_{sens}"] = np.append( outputs[f"sensLambda_{sens}"], ops.sensLambda(1, sens)) # Print a message to indicate if analysis completed succesfully or not if ok == 0: title("Pushover Analysis Completed Successfully!") else: title("Pushover Analysis Completed Failed!") print( f"Analysis elapsed time is {(time.time() - start_time):.3f} seconds.\n" ) return outputs
def analisis_opensees(path, permutaciones): #helper, #win ops.wipe() # bucle para generar los x análisis for i in range(len(permutaciones)): perfil = str(permutaciones[i][0]) nf = permutaciones[i][2] amort = permutaciones[i][3] den = permutaciones[i][4] vel = permutaciones[i][5] capas = len(permutaciones[i][6]) nstep = permutaciones[i][30] dt = float(permutaciones[i][31]) # creación de elementos sElemX = permutaciones[i][1] # elementos en X sElemZ = permutaciones[i][46] # espesor en Z # ============================================================================= # ######## geometría de la columna ###### # ============================================================================= # límite entre capas limite_capa = [] anterior = 0 for j in range(capas): espesor = permutaciones[i][8][j] limite_capa.append(espesor + anterior) anterior = limite_capa[j] print('Límite de capa: ' + str(limite_capa[j])) # creación de elementos y nodos en x nElemX = 1 # elementos en x nNodeX = 2 * nElemX + 1 # nodos en x # creación de elementos y nodos para z nElemZ = 1 # creación de elementos y nodos en Y y totales nElemY = [] # elementos en y sElemY = [] # dimension en y nElemT = 0 for j in range(capas): espesor = permutaciones[i][8][j] nElemY.append(2 * espesor) nElemT += nElemY[j] print('Elementos en capa ' + str(j + 1) + ': ' + str(nElemY[j])) sElemY.append(permutaciones[i][8][j] / nElemY[j]) print('Tamaño de los elementos en capa ' + str(j + 1) + ': ' + str(sElemY[j]) + '\n') # number of nodes in vertical direction in each layer nNodeY = [] # dimension en y nNodeT = 0 s = 0 for j in range(capas - 1): nNodeY.append(4 * nElemY[j]) nNodeT += nNodeY[j] s += 1 print('Nodos en capa ' + str(j + 1) + ': ' + str(nNodeY[j])) nNodeY.append(4 * (nElemY[-1] + 1)) nNodeT += nNodeY[-1] print('Nodos en capa ' + str(s + 1) + ': ' + str(nNodeY[s])) print('Nodos totales: ' + str(nNodeT)) #win.ui.progressBar.setValue(15) # ============================================================================= # ######### Crear nodos del suelo ########## # ============================================================================= # creación de nodos de presión de poros ops.model('basic', '-ndm', 3, '-ndf', 4) with open(path + '/Post-proceso/' + perfil + '/ppNodesInfo.dat', 'w') as f: count = 0.0 yCoord = 0.0 nodos = [] dryNode = [] altura_nf = 10 - nf for k in range(capas): for j in range(0, int(nNodeY[k]), 4): ops.node(j + count + 1, 0.0, yCoord, 0.0) ops.node(j + count + 2, 0.0, yCoord, sElemZ) ops.node(j + count + 3, sElemX, yCoord, sElemZ) ops.node(j + count + 4, sElemX, yCoord, 0.0) f.write( str(int(j + count + 1)) + '\t' + str(0.0) + '\t' + str(yCoord) + '\t' + str(0.0) + '\n') f.write( str(int(j + count + 2)) + '\t' + str(0.0) + '\t' + str(yCoord) + '\t' + str(sElemZ) + '\n') f.write( str(int(j + count + 3)) + '\t' + str(sElemX) + '\t' + str(yCoord) + '\t' + str(sElemZ) + '\n') f.write( str(int(j + count + 4)) + '\t' + str(sElemX) + '\t' + str(yCoord) + '\t' + str(0.0) + '\n') nodos.append(str(j + count + 1)) nodos.append(str(j + count + 2)) nodos.append(str(j + count + 3)) nodos.append(str(j + count + 4)) #designate node sobre la superficie de agua if yCoord >= altura_nf: dryNode.append(j + count + 1) dryNode.append(j + count + 2) dryNode.append(j + count + 3) dryNode.append(j + count + 4) yCoord = (yCoord + sElemY[k]) count = (count + nNodeY[k]) print("Finished creating all soil nodes...") # ============================================================================= # ####### Condiciones de contorno en la base de la columna ######### # ============================================================================= ops.fix(1, *[0, 1, 1, 0]) ops.fix(2, *[0, 1, 1, 0]) ops.fix(3, *[0, 1, 1, 0]) ops.fix(4, *[0, 1, 1, 0]) ops.equalDOF(1, 2, 1) ops.equalDOF(1, 3, 1) ops.equalDOF(1, 4, 1) print('Fin de creación de nodos de la base de la columna\n\n') # ============================================================================= # ####### Condiciones de contorno en los nudos restantes ######### # ============================================================================= count = 0 for k in range(5, int(nNodeT + 1), 4): ops.equalDOF(k, k + 1, *[1, 2, 3]) ops.equalDOF(k, k + 2, *[1, 2, 3]) ops.equalDOF(k, k + 3, *[1, 2, 3]) print('Fin de creación equalDOF para nodos de presión de poros\n\n') for j in range(len(dryNode)): ops.fix(dryNode[j], *[0, 0, 0, 1]) print("Finished creating all soil boundary conditions...") # ============================================================================= # ####### crear elemento y material de suelo ######### # ============================================================================= cargas = [] for j in range(capas): pendiente = permutaciones[i][9][j] slope = math.atan(pendiente / 100) tipo_suelo = permutaciones[i][6][j] rho = permutaciones[i][10][j] Gr = permutaciones[i][12][j] Br = permutaciones[i][13][j] fric = permutaciones[i][15][j] refpress = permutaciones[i][18][j] gmax = permutaciones[i][19][j] presscoef = permutaciones[i][20][j] surf = permutaciones[i][21][j] ev = permutaciones[i][22][j] cc1 = permutaciones[i][23][j] cc3 = permutaciones[i][24][j] cd1 = permutaciones[i][25][j] cd3 = permutaciones[i][26][j] ptang = permutaciones[i][27][j] coh = permutaciones[i][28][j] if tipo_suelo == 'No cohesivo': if float(surf) > 0: ops.nDMaterial('PressureDependMultiYield02', j + 1, 3.0, rho, Gr, Br, fric, gmax, refpress, presscoef, ptang, cc1, cc3, cd1, cd3, float(surf), 5.0, 3.0, *[1.0, 0.0], ev, *[0.9, 0.02, 0.7, 101.0]) else: ops.nDMaterial('PressureDependMultiYield02', j + 1, 3.0, rho, Gr, Br, fric, gmax, refpress, presscoef, ptang, cc1, cc3, cd1, cd3, float(surf), *permutaciones[i][29][j], 5.0, 3.0, *[1.0, 0.0], ev, *[0.9, 0.02, 0.7, 101.0]) cargas.append( [0.0, -9.81 * math.cos(slope), -9.81 * math.sin(slope)]) print('Fin de la creación de material de suelo\n\n') #----------------------------------------------------------------------------------------- # 5. CREATE SOIL ELEMENTS #----------------------------------------------------------------------------------------- count = 0 alpha = 1.5e-6 with open(path + '/Post-proceso/' + perfil + '/ppElemInfo.dat', 'w') as f: # crear elemento de suelo for k in range(capas): for j in range(int(nElemY[k])): nI = 4 * (j + count + 1) - 3 nJ = nI + 1 nK = nI + 2 nL = nI + 3 nM = nI + 4 nN = nI + 5 nO = nI + 6 nP = nI + 7 f.write( str(j + count + 1) + '\t' + str(nI) + '\t' + str(nJ) + '\t' + str(nK) + '\t' + str(nL) + '\t' + str(nM) + '\t' + str(nN) + '\t' + str(nO) + '\t' + str(nP) + '\n') Bc = permutaciones[i][14][k] ev = permutaciones[i][22][k] ops.element('SSPbrickUP', (j + count + 1), *[nI, nJ, nK, nL, nM, nN, nO, nP], (k + 1), float(Bc), 1.0, 1.0, 1.0, 1.0, float(ev), alpha, cargas[k][0], cargas[k][1], cargas[k][2]) count = (count + int(nElemY[k])) print('Fin de la creación del elemento del suelo\n\n') #win.ui.progressBar.setValue(25) # ============================================================================= # ######### Amortiguamiento de Lysmer ########## # ============================================================================= ops.model('basic', '-ndm', 3, '-ndf', 3) # definir nodos y coordenadas del amortiguamiento dashF = nNodeT + 1 dashX = nNodeT + 2 dashZ = nNodeT + 3 ops.node(dashF, 0.0, 0.0, 0.0) ops.node(dashX, 0.0, 0.0, 0.0) ops.node(dashZ, 0.0, 0.0, 0.0) # definir restricciones para los nodos de amortiguamiento ops.fix(dashF, 1, 1, 1) ops.fix(dashX, 0, 1, 1) ops.fix(dashZ, 1, 1, 0) # definir equalDOF para el amortiguamiento en la base del suelo ops.equalDOF(1, dashX, 1) ops.equalDOF(1, dashZ, 3) print( 'Fin de la creación de condiciones de contorno de los nodos de amortiguamiento\n\n' ) # definir el material de amortiguamiento colArea = sElemX * sElemZ dashpotCoeff = vel * den * colArea ops.uniaxialMaterial('Viscous', capas + 1, dashpotCoeff, 1.0) # definir el elemento ops.element('zeroLength', nElemT + 1, *[dashF, dashX], '-mat', capas + 1, '-dir', *[1]) ops.element('zeroLength', nElemT + 2, *[dashF, dashZ], '-mat', capas + 1, '-dir', *[3]) print('Fin de la creación del elemento de amortiguamiento\n\n') #----------------------------------------------------------------------------------------- # 9. DEFINE ANALYSIS PARAMETERS #----------------------------------------------------------------------------------------- # amortiguamiento de Rayleigh # frecuencia menor omega1 = 2 * math.pi * 0.2 # frecuencia mayor omega2 = 2 * math.pi * 20 a0 = 2.0 * (amort / 100) * omega1 * omega2 / (omega1 + omega2) a1 = 2.0 * (amort / 100) / (omega1 + omega2) print('Coeficientes de amortiguamiento' + '\n' + 'a0: ' + format(a0, '.6f') + '\n' + 'a1: ' + format(a1, '.6f') + '\n\n') #win.ui.progressBar.setValue(35) # ============================================================================= # ######## Determinación de análisis estático ######### # ============================================================================= #---DETERMINE STABLE ANALYSIS TIME STEP USING CFL CONDITION # se determina a partir de un análisis transitorio de largo tiempo duration = nstep * dt # tamaño mínimo del elemento y velocidad máxima minSize = sElemY[0] vsMax = permutaciones[i][11][0] for j in range(1, capas): if sElemY[j] < minSize: minSize = sElemY[j] if permutaciones[i][11][j] > vsMax: vsMax = permutaciones[i][11][j] # trial analysis time step kTrial = minSize / (vsMax**0.5) # tiempo de análisis y pasos de tiempo if dt <= kTrial: nStep = nstep dT = dt else: nStep = int(math.floor(duration / kTrial) + 1) dT = duration / nStep print('Número de pasos en el análisis: ' + str(nStep) + '\n') print('Incremento de tiempo: ' + str(dT) + '\n\n') #---------------------------------------------------------------------------------------- # 7. GRAVITY ANALYSIS #----------------------------------------------------------------------------------------- ops.model('basic', '-ndm', 3, '-ndf', 4) ops.updateMaterialStage('-material', int(k + 1), '-stage', 0) # algoritmo de análisis estático ops.constraints(permutaciones[i][32][0], float(permutaciones[i][32][1]), float(permutaciones[i][32][2])) ops.test(permutaciones[i][34][0], float(permutaciones[i][34][1]), int(permutaciones[i][34][2]), int(permutaciones[i][34][3])) ops.algorithm(permutaciones[i][38][0]) ops.numberer(permutaciones[i][33][0]) ops.system(permutaciones[i][36][0]) ops.integrator(permutaciones[i][35][0], float(permutaciones[i][35][1]), float(permutaciones[i][35][2])) ops.analysis(permutaciones[i][37][0]) print('Inicio de análisis estático elástico\n\n') ops.start() ops.analyze(20, 5.0e2) print('Fin de análisis estático elástico\n\n') #win.ui.progressBar.setValue(40) # update materials to consider plastic behavior # ============================================================================= ops.updateMaterialStage('-material', int(k + 1), '-stage', 1) # ============================================================================= # plastic gravity loading print('Inicio de análisis estático plástico\n\n') ok = ops.analyze(40, 5.0e-2) if ok != 0: error = 'Error de convergencia en análisis estático de modelo' + str( perfil) + '\n\n' print(error) break print('Fin de análisis estático plástico\n\n') #----------------------------------------------------------------------------------------- # 11. UPDATE ELEMENT PERMEABILITY VALUES FOR POST-GRAVITY ANALYSIS #----------------------------------------------------------------------------------------- ini = 1 aum = 0 sum = 0 for j in range(capas): #Layer 3 ops.setParameter( '-val', permutaciones[i][16][j], ['-eleRange', int(ini + aum), int(nElemY[j] + sum)], 'xPerm') ops.setParameter( '-val', permutaciones[i][17][j], ['-eleRange', int(ini + aum), int(nElemY[j] + sum)], 'yPerm') ops.setParameter( '-val', permutaciones[i][16][j], ['-eleRange', int(ini + aum), int(nElemY[j] + sum)], 'zPerm') ini = nElemY[j] + sum sum += nElemY[j] aum = 1 print("Finished updating permeabilities for dynamic analysis...") # ============================================================================= # ########### Grabadores dinámicos ########## # ============================================================================= ops.setTime(0.0) ops.wipeAnalysis() ops.remove('recorders') # tiempo de la grabadora recDT = 10 * dt path_acel = path + '/Post-proceso/' + perfil + '/dinamico/aceleraciones/' ops.recorder('Node', '-file', path_acel + 'accelerationx.out', '-time', '-dT', recDT, '-node', *nodos, '-dof', 1, 'accel') print('Fin de creación de grabadores\n\n') #win.ui.progressBar.setValue(50) # ============================================================================= # ######### Determinación de análisis dinámico ########## # ============================================================================= # objeto de serie temporal para el historial de fuerza path_vel = path + '/Pre-proceso/' + perfil + '/TREASISL2.txt' ops.timeSeries('Path', 1, '-dt', dt, '-filePath', path_vel, '-factor', dashpotCoeff) ops.pattern('Plain', 10, 1) ops.load(1, *[1.0, 0.0, 0.0, 0.0]) #CAMBIO REALIZADO OJO print('Fin de creación de carga dinámica\n\n') # algoritmo de análisis dinámico ops.constraints(permutaciones[i][39][0], float(permutaciones[i][39][1]), float(permutaciones[i][39][2])) ops.test(permutaciones[i][41][0], float(permutaciones[i][41][1]), int(permutaciones[i][41][2]), int(permutaciones[i][41][3])) ops.algorithm(permutaciones[i][45][0]) ops.numberer(permutaciones[i][40][0]) ops.system(permutaciones[i][43][0]) ops.integrator(permutaciones[i][42][0], float(permutaciones[i][42][1]), float(permutaciones[i][42][2])) ops.analysis(permutaciones[i][44][0]) # ============================================================================= # ops.rayleigh(a0, a1, 0.0, 0.0) # ============================================================================= print('Inicio de análisis dinámico\n\n') #win.ui.progressBar.setValue(85) ok = ops.analyze(nStep, dT) if ok != 0: error = 'Error de convergencia en análisis dinámico de modelo' + str( permutaciones[i][0]) + '\n\n' print(error) curTime = ops.getTime() mTime = curTime print('cursTime:' + str(curTime)) curStep = (curTime / dT) print('cursStep:' + str(curStep)) rStep = (nStep - curStep) * 2.0 remStep = int(nStep - curStep) * 2.0 print('remSTep:' + str(curStep)) dT = (dT / 2) print('dT:' + str(dT)) ops.analyze(remStep, dT) if ok != 0: error = 'Error de convergencia en análisis dinámico de modelo' + str( permutaciones[i][0]) + '\n\n' print(error) curTime = ops.getTime() print('cursTime:' + str(curTime)) curStep = (curTime - mTime) / dT print('cursStep:' + str(curStep)) remStep = int(rStep - curStep) * 2 print('remSTep:' + str(curStep)) dT = (dT / 2) print('dT:' + str(dT)) ops.analyze(remStep, dT) print('Fin de análisis dinámico\n\n') ops.wipe()
def run_dynamic_analysis_w_rayleigh_damping(dict_of_hinges, dict_of_disp_nodes, dict_of_rxn_nodes, zeta, initialOrTangent='initial', parent_dir=os.getcwd()): # remove any existing analysis data op.wipeAnalysis() # define a time series to add the ground motion op.timeSeries('Path', 2, '-dt', 0.01, '-filePath', 'BM68elc.acc', '-factor', 3.0 * g) op.pattern('UniformExcitation', 2, 1, '-accel', 2) # uncomment/comment the code below to run bideirectional/unidirectional ground motion analysis # op.timeSeries('Path', 3, '-dt', 0.01, '-filePath', 'BM68elc.acc', '-factor', 1.0*g) # op.pattern('UniformExcitation', 3, 2, '-accel', 3) op.constraints('Transformation') op.numberer('RCM') op.system('UmfPack') # op.test('NormDispIncr', 1e-2, 100000, 0, 0) op.test('EnergyIncr', 1e-4, 1e4, 0, 2) # available set of algorithms if the default fails backup_algos = { 'Modified Newton w/ Initial Stiffness': ['ModifiedNewton', '-initial'], 'Newton with Line Search': [ 'NewtonLineSearch', 'tol', 1e-3, 'maxIter', 1e5, 'maxEta', 10, 'minEta', 1e-2 ], } # define the default algorithm to be used for this analysis op.algorithm('KrylovNewton', 'maxDim', 3) # define the integrator to be used for this analysis from the set of available integrators in opensees alpha = 0.67 op.integrator( 'HHT', alpha) # can be either of: ('HHT', alpha), ('Newmark', 0.5, 0.25) # define the type of analysis to be performed op.analysis('Transient') # obtain the modal analysis eigenValues = modal_response(numEigen) # get periods from the modal analsis periods = 2 * math.pi / np.sqrt(eigenValues) w1 = (eigenValues[0]**0.5) w2 = (eigenValues[0]**0.5) / 0.384 a0 = zeta * 2 * w1 * w2 / (w1 + w2) a1 = zeta * 2 / (w1 + w2) print('\nRayleigh Damping Coefficients:') print(f'\talpha: {a0}') print(f'\tbeta : {a1}\n') if initialOrTangent == 'tangent': op.rayleigh(a0, a1, 0, 0) else: op.rayleigh(a0, 0, a1, 0) # setup to record analysis data setup_recorders(dict_of_disp_nodes, dict_of_rxn_nodes, dict_of_hinges, initialOrTangent, parent_dir) total_run_time = 50 # seconds time_step = 0.01 # seconds total_num_of_steps = total_run_time / time_step # default initialization of constants to be used in the execution loop failed = 0 time = 0 algo = 'Krylov-Newton' pbar = tqdm(total=total_num_of_steps) # execution loop # this execution loop tries to use krylov-Newton until it works, when this fails it iterate through set of # algorithms until it finds a solution, if it is not able to find a solution with any algorithm, the loop ends. # Whereas if it is able to find a solution with any of the algorithms, it switches back to krylov-Newton while time <= total_run_time and failed == 0: failed = op.analyze(1, time_step) if failed: print(f'\n{algo} failed. Trying other algorithms...') for alg, algo_args in backup_algos.items(): print(f'\nTrying {alg}...') op.algorithm(*algo_args) failed = op.analyze(1, time_step) if failed: continue else: algo = 'Krylov-Newton' print(f'\n{alg} worked.\n\nMoving back to {algo}') op.algorithm('KrylovNewton', 'maxDim', 3) break print(''.center(100, '-')) pbar.update(1) time = op.getTime() op.wipe() # move output files to results directory list_of_out_files = [ fname for fname in os.listdir() if fname.endswith('.out') ] for fname in list_of_out_files: shutil.move(os.path.join(os.getcwd(), fname), os.path.join(parent_dir, fname)) return periods, eigenValues
def get_inelastic_response(fb, asig, extra_time=0.0, xi=0.05, analysis_dt=0.001): """ Run seismic analysis of a nonlinear FrameBuilding :param fb: FrameBuilding object :param asig: AccSignal object :param extra_time: float, additional analysis time after end of ground motion :param xi: damping ratio :param analysis_dt: time step to perform the analysis :return: """ op.wipe() op.model('basic', '-ndm', 2, '-ndf', 3) # 2 dimensions, 3 dof per node q_floor = 10000. # kPa trib_width = fb.floor_length trib_mass_per_length = q_floor * trib_width / 9.8 # Establish nodes and set mass based on trib area # Nodes named as: C<column-number>-S<storey-number>, first column starts at C1-S0 = ground level left nd = OrderedDict() col_xs = np.cumsum(fb.bay_lengths) col_xs = np.insert(col_xs, 0, 0) n_cols = len(col_xs) sto_ys = fb.heights sto_ys = np.insert(sto_ys, 0, 0) for cc in range(1, n_cols + 1): for ss in range(fb.n_storeys + 1): n_i = cc * 100 + ss nd["C%i-S%i" % (cc, ss)] = n_i op.node(n_i, col_xs[cc - 1], sto_ys[ss]) if ss != 0: if cc == 1: node_mass = trib_mass_per_length * fb.bay_lengths[0] / 2 elif cc == n_cols: node_mass = trib_mass_per_length * fb.bay_lengths[-1] / 2 else: node_mass = trib_mass_per_length * (fb.bay_lengths[cc - 2] + fb.bay_lengths[cc - 1] / 2) op.mass(n_i, node_mass) # Set all nodes on a storey to have the same displacement for ss in range(0, fb.n_storeys + 1): for cc in range(1, n_cols + 1): op.equalDOF(nd["C%i-S%i" % (1, ss)], nd["C%i-S%i" % (cc, ss)], opc.X) # Fix all base nodes for cc in range(1, n_cols + 1): op.fix(nd["C%i-S%i" % (cc, 0)], opc.FIXED, opc.FIXED, opc.FIXED) # Coordinate transformation geo_tag = 1 trans_args = [] op.geomTransf("Linear", geo_tag, *[]) l_hinge = fb.bay_lengths[0] * 0.1 # Define material e_conc = 30.0e6 i_beams = 0.4 * fb.beam_widths * fb.beam_depths ** 3 / 12 i_columns = 0.5 * fb.column_widths * fb.column_depths ** 3 / 12 a_beams = fb.beam_widths * fb.beam_depths a_columns = fb.column_widths * fb.column_depths ei_beams = e_conc * i_beams ei_columns = e_conc * i_columns eps_yield = 300.0e6 / 200e9 phi_y_col = calc_yield_curvature(fb.column_depths, eps_yield) phi_y_beam = calc_yield_curvature(fb.beam_depths, eps_yield) # Define beams and columns md = OrderedDict() # material dict sd = OrderedDict() # section dict ed = OrderedDict() # element dict # Columns named as: C<column-number>-S<storey-number>, first column starts at C1-S0 = ground floor left # Beams named as: B<bay-number>-S<storey-number>, first beam starts at B1-S1 = first storey left (foundation at S0) for ss in range(fb.n_storeys): # set columns for cc in range(1, fb.n_cols + 1): ele_i = cc * 100 + ss md["C%i-S%i" % (cc, ss)] = ele_i sd["C%i-S%i" % (cc, ss)] = ele_i ed["C%i-S%i" % (cc, ss)] = ele_i mat_props = elastic_bilin(ei_columns[ss][cc - 1], 0.05 * ei_columns[ss][cc - 1], phi_y_col[ss][cc - 1]) #print(opc.ELASTIC_BILIN, ele_i, *mat_props) op.uniaxialMaterial(opc.ELASTIC_BILIN, ele_i, *mat_props) # op.uniaxialMaterial("Elastic", ele_i, ei_columns[ss][cc - 1]) node_numbers = [nd["C%i-S%i" % (cc, ss)], nd["C%i-S%i" % (cc, ss + 1)]] op.element(opc.ELASTIC_BEAM_COLUMN, ele_i, *node_numbers, a_columns[ss - 1][cc - 1], e_conc, i_columns[ss - 1][cc - 1], geo_tag ) # Set beams for bb in range(1, fb.n_bays + 1): ele_i = bb * 10000 + ss md["B%i-S%i" % (bb, ss)] = ele_i sd["B%i-S%i" % (bb, ss)] = ele_i ed["B%i-S%i" % (bb, ss)] = ele_i mat_props = elastic_bilin(ei_beams[ss][bb - 1], 0.05 * ei_beams[ss][bb - 1], phi_y_beam[ss][bb - 1]) op.uniaxialMaterial(opc.ELASTIC_BILIN, ele_i, *mat_props) # op.uniaxialMaterial("Elastic", ele_i, ei_beams[ss][bb - 1]) node_numbers = [nd["C%i-S%i" % (bb, ss + 1)], nd["C%i-S%i" % (bb + 1, ss + 1)]] print((opc.BEAM_WITH_HINGES, ele_i, *node_numbers, sd["B%i-S%i" % (bb, ss)], l_hinge, sd["B%i-S%i" % (bb, ss)], l_hinge, sd["B%i-S%i" % (bb, ss)], geo_tag )) # Old definition # op.element(opc.BEAM_WITH_HINGES, ele_i, # *[nd["C%i-S%i" % (bb, ss - 1)], nd["C%i-S%i" % (bb + 1, ss)]], # sd["B%i-S%i" % (bb, ss)], l_hinge, # sd["B%i-S%i" % (bb, ss)], l_hinge, # e_conc, # a_beams[ss - 1][bb - 1], # i_beams[ss - 1][bb - 1], geo_tag # ) # New definition # op.element(opc.BEAM_WITH_HINGES, ele_i, # *node_numbers, # sd["B%i-S%i" % (bb, ss)], l_hinge, # sd["B%i-S%i" % (bb, ss)], l_hinge, # sd["B%i-S%i" % (bb, ss)], geo_tag # TODO: make this elastic # # ) # Elastic definition op.element(opc.ELASTIC_BEAM_COLUMN, ele_i, *node_numbers, a_beams[ss - 1][bb - 1], e_conc, i_beams[ss - 1][bb - 1], geo_tag ) # Define the dynamic analysis load_tag_dynamic = 1 pattern_tag_dynamic = 1 values = list(-1 * asig.values) # should be negative op.timeSeries('Path', load_tag_dynamic, '-dt', asig.dt, '-values', *values) op.pattern('UniformExcitation', pattern_tag_dynamic, opc.X, '-accel', load_tag_dynamic) # set damping based on first eigen mode angular_freq2 = op.eigen('-fullGenLapack', 1) if hasattr(angular_freq2, '__len__'): angular_freq2 = angular_freq2[0] angular_freq = angular_freq2 ** 0.5 if isinstance(angular_freq, complex): raise ValueError("Angular frequency is complex, issue with stiffness or mass") alpha_m = 0.0 beta_k = 2 * xi / angular_freq beta_k_comm = 0.0 beta_k_init = 0.0 period = angular_freq / 2 / np.pi print("period: ", period) 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') #op.test("NormDispIncr", 1.0e-1, 2, 0) tol = 1.0e-10 iter = 10 op.test('EnergyIncr', tol, iter, 0, 2) # TODO: make this test work analysis_time = (len(values) - 1) * asig.dt + extra_time outputs = { "time": [], "rel_disp": [], "rel_accel": [], "rel_vel": [], "force": [] } print("Analysis starting") 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(nd["C%i-S%i" % (1, fb.n_storeys)], opc.X)) outputs["rel_vel"].append(op.nodeVel(nd["C%i-S%i" % (1, fb.n_storeys)], opc.X)) outputs["rel_accel"].append(op.nodeAccel(nd["C%i-S%i" % (1, fb.n_storeys)], opc.X)) op.reactions() react = 0 for cc in range(1, fb.n_cols): react += -op.nodeReaction(nd["C%i-S%i" % (cc, 0)], opc.X) outputs["force"].append(react) # Should be negative since diff node op.wipe() for item in outputs: outputs[item] = np.array(outputs[item]) return outputs
def test_Ex1aCanti2DEQmodif(): # SET UP ---------------------------------------------------------------------------- ops.wipe() # clear opensees model ops.model('basic', '-ndm', 2, '-ndf', 3) # 2 dimensions, 3 dof per node # file mkdir data # create data directory # define GEOMETRY ------------------------------------------------------------- # nodal coordinates: ops.node(1, 0., 0.) # node#, X Y ops.node(2, 0., 432.) # Single point constraints -- Boundary Conditions ops.fix(1, 1, 1, 1) # node DX DY RZ # nodal masses: ops.mass(2, 5.18, 0., 0.) # node#, Mx My Mz, Mass=Weight/g. # Define ELEMENTS ------------------------------------------------------------- # define geometric transformation: performs a linear geometric transformation of beam stiffness and resisting force from the basic system to the global-coordinate system ops.geomTransf('Linear', 1) # associate a tag to transformation # connectivity: ops.element('elasticBeamColumn', 1, 1, 2, 3600.0, 3225.0, 1080000.0, 1) # define GRAVITY ------------------------------------------------------------- ops.timeSeries('Linear', 1) ops.pattern( 'Plain', 1, 1, ) ops.load(2, 0., -2000., 0.) # node#, FX FY MZ -- superstructure-weight ops.constraints('Plain') # how it handles boundary conditions ops.numberer( 'Plain' ) # renumber dof's to minimize band-width (optimization), if you want to ops.system( 'BandGeneral' ) # how to store and solve the system of equations in the analysis ops.algorithm('Linear') # use Linear algorithm for linear analysis ops.integrator( 'LoadControl', 0.1 ) # determine the next time step for an analysis, # apply gravity in 10 steps ops.analysis('Static') # define type of analysis static or transient ops.analyze(10) # perform gravity analysis ops.loadConst('-time', 0.0) # hold gravity constant and restart time # DYNAMIC ground-motion analysis ------------------------------------------------------------- # create load pattern G = 386.0 ops.timeSeries( 'Path', 2, '-dt', 0.005, '-filePath', 'A10000.dat', '-factor', G ) # define acceleration vector from file (dt=0.005 is associated with the input file gm) ops.pattern( 'UniformExcitation', 2, 1, '-accel', 2) # define where and how (pattern tag, dof) acceleration is applied # set damping based on first eigen mode evals = ops.eigen('-fullGenLapack', 1) freq = evals[0]**0.5 dampRatio = 0.02 ops.rayleigh(0., 0., 0., 2 * dampRatio / freq) # display displacement shape of the column # recorder display "Displaced shape" 10 10 500 500 -wipe # prp 200. 50. 1 # vup 0 1 0 # vpn 0 0 1 # display 1 5 40 # create the analysis ops.wipeAnalysis() # clear previously-define analysis parameters ops.constraints('Plain') # how it handles boundary conditions ops.numberer( 'Plain' ) # renumber dof's to minimize band-width (optimization), if you want to ops.system( 'BandGeneral' ) # how to store and solve the system of equations in the analysis ops.algorithm('Linear') # use Linear algorithm for linear analysis ops.integrator('Newmark', 0.5, 0.25) # determine the next time step for an analysis ops.analysis('Transient') # define type of analysis: time-dependent ops.analyze(3995, 0.01) # apply 3995 0.01-sec time steps in analysis u2 = ops.nodeDisp(2, 2) print("u2 = ", u2) assert abs(u2 + 0.07441860465116277579) < 1e-12 ops.wipe() print("=========================================")