def get_inelastic_response(fb, asig, extra_time=0.0, xi=0.05, analysis_dt=0.001):
"""
Run seismic analysis of a nonlinear FrameBuilding
Parameters
----------
fb: sfsimodels.Frame2DBuilding object
asig: eqsig.AccSignal object
extra_time
xi
analysis_dt
Returns
-------
"""
osi = o3.OpenSeesInstance(ndm=2)
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):
nd[f"C{cc}-S{ss}"] = o3.node.Node(osi, 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)
o3.set_node_mass(osi, nd[f"C{cc}-S{ss}"], node_mass, 0., 0.)
# 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):
o3.set_equal_dof(osi, nd[f"C1-S{ss}"], nd[f"C{cc}-S{ss}"], o3.cc.X)
# Fix all base nodes
for cc in range(1, n_cols + 1):
o3.Fix3DOF(osi, nd[f"C{cc}-S0"], o3.cc.FIXED, o3.cc.FIXED, o3.cc.FIXED)
# Coordinate transformation
transf = o3.geom_transf.Linear2D(osi, [])
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) * 10 # TODO: re-evaluate
# Define beams and columns
# 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)
md = OrderedDict() # material dict
sd = OrderedDict() # section dict
ed = OrderedDict() # element dict
for ss in range(fb.n_storeys):
# set columns
for cc in range(1, fb.n_cols + 1):
lp_i = 0.4
lp_j = 0.4 # plastic hinge length
ele_str = f"C{cc}-S{ss}S{ss+1}"
top_sect = o3.section.Elastic2D(osi, e_conc, a_columns[ss][cc - 1], i_columns[ss][cc - 1])
bot_sect = o3.section.Elastic2D(osi, e_conc, a_columns[ss][cc - 1], i_columns[ss][cc - 1])
centre_sect = o3.section.Elastic2D(osi, e_conc, a_columns[ss][cc - 1], i_columns[ss][cc - 1])
sd[ele_str + "T"] = top_sect
sd[ele_str + "B"] = bot_sect
sd[ele_str + "C"] = centre_sect
integ = o3.beam_integration.HingeMidpoint(osi, bot_sect, lp_i, top_sect, lp_j, centre_sect)
bot_node = nd[f"C{cc}-S{ss}"]
top_node = nd[f"C{cc}-S{ss+1}"]
ed[ele_str] = o3.element.ForceBeamColumn(osi, [bot_node, top_node], transf, integ)
# Set beams
for bb in range(1, fb.n_bays + 1):
lp_i = 0.5
lp_j = 0.5
ele_str = f"C{bb-1}C{bb}-S{ss}"
mat = o3.uniaxial_material.ElasticBilin(osi, ei_beams[ss][bb - 1], 0.05 * ei_beams[ss][bb - 1], phi_y_beam[ss][bb - 1])
md[ele_str] = mat
left_sect = o3.section.Uniaxial(osi, mat, quantity=o3.cc.M_Z)
right_sect = o3.section.Uniaxial(osi, mat, quantity=o3.cc.M_Z)
centre_sect = o3.section.Elastic2D(osi, e_conc, a_beams[ss][bb - 1], i_beams[ss][bb - 1])
integ = o3.beam_integration.HingeMidpoint(osi, left_sect, lp_i, right_sect, lp_j, centre_sect)
left_node = nd[f"C{bb}-S{ss+1}"]
right_node = nd[f"C{bb+1}-S{ss+1}"]
ed[ele_str] = o3.element.ForceBeamColumn(osi, [left_node, right_node], transf, integ)
# Define the dynamic analysis
a_series = o3.time_series.Path(osi, dt=asig.dt, values=-1 * asig.values) # should be negative
o3.pattern.UniformExcitation(osi, dir=o3.cc.X, accel_series=a_series)
# set damping based on first eigen mode
angular_freq_sqrd = o3.get_eigen(osi, solver='fullGenLapack', n=1)
if hasattr(angular_freq_sqrd, '__len__'):
angular_freq = angular_freq_sqrd[0] ** 0.5
else:
angular_freq = angular_freq_sqrd ** 0.5
if isinstance(angular_freq, complex):
raise ValueError("Angular frequency is complex, issue with stiffness or mass")
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
o3.wipe_analysis(osi)
o3.algorithm.Newton(osi)
o3.system.SparseGeneral(osi)
o3.numberer.RCM(osi)
o3.constraints.Transformation(osi)
o3.integrator.Newmark(osi, 0.5, 0.25)
o3.analysis.Transient(osi)
tol = 1.0e-4
iter = 4
o3.test_check.EnergyIncr(osi, tol, iter, 0, 2)
analysis_time = (len(asig.values) - 1) * asig.dt + extra_time
outputs = {
"time": [],
"rel_disp": [],
"rel_accel": [],
"rel_vel": [],
"force": [],
"ele_mom": [],
"ele_curve": [],
}
print("Analysis starting")
while o3.get_time(osi) < analysis_time:
curr_time = opy.getTime()
o3.analyze(osi, 1, analysis_dt)
outputs["time"].append(curr_time)
outputs["rel_disp"].append(o3.get_node_disp(osi, nd["C%i-S%i" % (1, fb.n_storeys)], o3.cc.X))
outputs["rel_vel"].append(o3.get_node_vel(osi, nd["C%i-S%i" % (1, fb.n_storeys)], o3.cc.X))
outputs["rel_accel"].append(o3.get_node_accel(osi, nd["C%i-S%i" % (1, fb.n_storeys)], o3.cc.X))
# outputs['ele_mom'].append(opy.eleResponse('-ele', [ed['B%i-S%i' % (1, 0)], 'basicForce']))
o3.gen_reactions(osi)
react = 0
for cc in range(1, fb.n_cols):
react += -o3.get_node_reaction(osi, nd["C%i-S%i" % (cc, 0)], o3.cc.X)
outputs["force"].append(react) # Should be negative since diff node
o3.wipe(osi)
for item in outputs:
outputs[item] = np.array(outputs[item])
return outputs
def run_analysis(asig, period, xi, f_yield, etype):
# Load a ground motion
# Define inelastic SDOF
mass = 1.0
r_post = 0.0
# Initialise OpenSees instance
osi = o3.OpenSeesInstance(ndm=2, state=0)
# Establish nodes
bot_node = o3.node.Node(osi, 0, 0)
top_node = o3.node.Node(osi, 0, 0)
# Fix bottom node
o3.Fix3DOF(osi, top_node, o3.cc.FREE, o3.cc.FIXED, o3.cc.FIXED)
o3.Fix3DOF(osi, bot_node, o3.cc.FIXED, o3.cc.FIXED, o3.cc.FIXED)
# Set out-of-plane DOFs to be slaved
o3.EqualDOF(osi, top_node, bot_node, [o3.cc.Y, o3.cc.ROTZ])
# nodal mass (weight / g):
o3.Mass(osi, top_node, mass, 0., 0.)
# Define material
k_spring = 4 * np.pi**2 * mass / period**2
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
# Define the dynamic analysis
acc_series = o3.time_series.Path(osi, dt=asig.dt, values=-1 *
asig.values) # should be negative
o3.pattern.UniformExcitation(osi, dir=o3.cc.X, accel_series=acc_series)
# set damping based on first eigen mode
angular_freqs = np.array(o3.get_eigen(osi, solver='fullGenLapack',
n=1))**0.5
beta_k = 2 * xi / angular_freqs[0]
print('angular_freqs: ', angular_freqs)
periods = 2 * np.pi / angular_freqs
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
o3.wipe_analysis(osi)
# Run the dynamic analysis
o3.constraints.Transformation(osi)
o3.test_check.NormDispIncr(osi, tol=1.0e-6, max_iter=35, p_flag=0)
o3.numberer.RCM(osi)
if etype == 'implicit':
o3.algorithm.Newton(osi)
o3.system.SparseGeneral(osi)
o3.integrator.Newmark(osi, gamma=0.5, beta=0.25)
analysis_dt = 0.01
else:
o3.algorithm.Linear(osi, factor_once=True)
o3.system.FullGeneral(osi)
if etype == 'newmark_explicit':
o3.integrator.NewmarkExplicit(osi, gamma=0.6)
explicit_dt = periods[0] / np.pi / 32
elif etype == 'central_difference':
o3.integrator.CentralDifference(osi)
o3.opy.integrator('HHTExplicit')
explicit_dt = periods[0] / np.pi / 16 # 0.5 is a factor of safety
elif etype == 'explicit_difference':
o3.integrator.ExplicitDifference(osi)
explicit_dt = periods[0] / np.pi / 32
else:
raise ValueError(etype)
print('explicit_dt: ', explicit_dt)
analysis_dt = explicit_dt
o3.analysis.Transient(osi)
analysis_time = asig.time[-1]
outputs = {
"time": [],
"rel_disp": [],
"rel_accel": [],
"rel_vel": [],
"force": []
}
while o3.get_time(osi) < analysis_time:
o3.analyze(osi, 1, analysis_dt)
curr_time = o3.get_time(osi)
outputs["time"].append(curr_time)
outputs["rel_disp"].append(o3.get_node_disp(osi, top_node, o3.cc.X))
outputs["rel_vel"].append(o3.get_node_vel(osi, top_node, o3.cc.X))
outputs["rel_accel"].append(o3.get_node_accel(osi, top_node, o3.cc.X))
o3.gen_reactions(osi)
outputs["force"].append(-o3.get_node_reaction(
osi, bot_node, o3.cc.X)) # Negative since diff node
o3.wipe(osi)
for item in outputs:
outputs[item] = np.array(outputs[item])
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
Parameters
----------
mass: float
SDOF mass
k_spring: float
Spring stiffness
f_yield: float
Yield strength
motion: array_like,
Acceleration values
dt: float, time step of acceleration values
xi: damping ratio
r_post: post-yield stiffness
Returns
-------
outputs: dict
Dictionary containing time series from analysis
"""
osi = o3.OpenSeesInstance(ndm=2, state=0)
# Establish nodes
bot_node = o3.node.Node(osi, 0, 0)
top_node = o3.node.Node(osi, 0, 0)
# Fix bottom node
o3.Fix3DOF(osi, top_node, o3.cc.FREE, o3.cc.FIXED, o3.cc.FIXED)
o3.Fix3DOF(osi, bot_node, o3.cc.FIXED, o3.cc.FIXED, o3.cc.FIXED)
# Set out-of-plane DOFs to be slaved
o3.EqualDOF(osi, top_node, bot_node, [o3.cc.Y, o3.cc.ROTZ])
# nodal mass (weight / g):
o3.Mass(osi, top_node, 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
acc_series = o3.time_series.Path(osi, dt=dt,
values=-motion) # should be negative
o3.pattern.UniformExcitation(osi, dir=o3.cc.X, accel_series=acc_series)
# set damping based on first eigen mode
angular_freq_sqrd = o3.get_eigen(osi, solver='fullGenLapack', n=1)
if hasattr(angular_freq_sqrd, '__len__'):
angular_freq = angular_freq_sqrd[0]**0.5
else:
angular_freq = angular_freq_sqrd**0.5
response_period = 2 * np.pi / angular_freq
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
o3.wipe_analysis(osi)
o3.algorithm.Newton(osi)
o3.system.SparseGeneral(osi)
o3.numberer.RCM(osi)
o3.constraints.Transformation(osi)
o3.integrator.Newmark(osi, 0.5, 0.25)
o3.analysis.Transient(osi)
o3.test_check.EnergyIncr(osi, tol=1.0e-10, max_iter=10)
analysis_time = (len(motion) - 1) * dt
analysis_dt = 0.001
outputs = {
"time": [],
"rel_disp": [],
"rel_accel": [],
"rel_vel": [],
"force": []
}
while o3.get_time(osi) < analysis_time:
o3.analyze(osi, 1, analysis_dt)
curr_time = o3.get_time(osi)
outputs["time"].append(curr_time)
outputs["rel_disp"].append(o3.get_node_disp(osi, top_node, o3.cc.X))
outputs["rel_vel"].append(o3.get_node_vel(osi, top_node, o3.cc.X))
outputs["rel_accel"].append(o3.get_node_accel(osi, top_node, o3.cc.X))
o3.gen_reactions(osi)
outputs["force"].append(-o3.get_node_reaction(
osi, bot_node, o3.cc.X)) # Negative since diff node
o3.wipe(osi)
for item in outputs:
outputs[item] = np.array(outputs[item])
return outputs
def run(show=0):
# Load a ground motion
record_filename = 'test_motion_dt0p01.txt'
asig = eqsig.load_asig(ap.MODULE_DATA_PATH + 'gms/' + record_filename,
m=0.5)
# Define inelastic SDOF
period = 1.0
xi = 0.05
mass = 1.0
f_yield = 1.5 # Reduce this to make it nonlinear
r_post = 0.0
# Initialise OpenSees instance
osi = o3.OpenSeesInstance(ndm=2, state=0)
# Establish nodes
bot_node = o3.node.Node(osi, 0, 0)
top_node = o3.node.Node(osi, 0, 0)
# Fix bottom node
o3.Fix3DOF(osi, top_node, o3.cc.FREE, o3.cc.FIXED, o3.cc.FIXED)
o3.Fix3DOF(osi, bot_node, o3.cc.FIXED, o3.cc.FIXED, o3.cc.FIXED)
# Set out-of-plane DOFs to be slaved
o3.EqualDOF(osi, top_node, bot_node, [o3.cc.Y, o3.cc.ROTZ])
# nodal mass (weight / g):
o3.Mass(osi, top_node, mass, 0., 0.)
# Define material
k_spring = 4 * np.pi**2 * mass / period**2
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
# Define the dynamic analysis
acc_series = o3.time_series.Path(osi, dt=asig.dt, values=-1 *
asig.values) # should be negative
o3.pattern.UniformExcitation(osi, dir=o3.cc.X, accel_series=acc_series)
# set damping based on first eigen mode
angular_freq = o3.get_eigen(osi, solver='fullGenLapack', n=1)[0]**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
o3.wipe_analysis(osi)
# Run the dynamic analysis
o3.algorithm.Newton(osi)
o3.system.SparseGeneral(osi)
o3.numberer.RCM(osi)
o3.constraints.Transformation(osi)
o3.integrator.Newmark(osi, gamma=0.5, beta=0.25)
o3.analysis.Transient(osi)
o3.test_check.EnergyIncr(osi, tol=1.0e-10, max_iter=10)
analysis_time = asig.time[-1]
analysis_dt = 0.001
outputs = {
"time": [],
"rel_disp": [],
"rel_accel": [],
"rel_vel": [],
"force": []
}
while o3.get_time(osi) < analysis_time:
o3.analyze(osi, 1, analysis_dt)
curr_time = o3.get_time(osi)
outputs["time"].append(curr_time)
outputs["rel_disp"].append(o3.get_node_disp(osi, top_node, o3.cc.X))
outputs["rel_vel"].append(o3.get_node_vel(osi, top_node, o3.cc.X))
outputs["rel_accel"].append(o3.get_node_accel(osi, top_node, o3.cc.X))
o3.gen_reactions(osi)
outputs["force"].append(-o3.get_node_reaction(
osi, bot_node, o3.cc.X)) # Negative since diff node
o3.wipe(osi)
for item in outputs:
outputs[item] = np.array(outputs[item])
if show:
import matplotlib.pyplot as plt
plt.plot(outputs['time'], outputs['rel_disp'], label='o3seespy')
periods = np.array([period])
# Compare closed form elastic solution
from eqsig import sdof
resp_u, resp_v, resp_a = sdof.response_series(motion=asig.values,
dt=asig.dt,
periods=periods,
xi=xi)
plt.plot(asig.time, resp_u[0], ls='--', label='Elastic')
plt.legend()
plt.show()
def get_elastic_response(mass, k_spring, 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 motion: array_like,
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, state=3)
height = 5.
# Establish nodes
bot_node = o3.node.Node(osi, 0, 0)
top_node = o3.node.Node(osi, 0, height)
# Fix bottom node
o3.Fix3DOF(osi, top_node, o3.cc.FREE, o3.cc.FIXED, o3.cc.FREE)
o3.Fix3DOF(osi, bot_node, o3.cc.FIXED, o3.cc.FIXED, o3.cc.FIXED)
# Set out-of-plane DOFs to be slaved
o3.EqualDOF(osi, top_node, bot_node, [o3.cc.Y])
# nodal mass (weight / g):
o3.Mass(osi, top_node, mass, 0., 0.)
# Define material
transf = o3.geom_transf.Linear2D(osi, [])
area = 1.0
e_mod = 1.0e6
iz = k_spring * height ** 3 / (3 * e_mod)
ele_nodes = [bot_node, top_node]
ele = o3.element.ElasticBeamColumn2D(osi, ele_nodes, area=area, e_mod=e_mod, iz=iz, transf=transf)
# Define the dynamic analysis
acc_series = o3.time_series.Path(osi, dt=dt, values=-motion) # should be negative
o3.pattern.UniformExcitation(osi, dir=o3.cc.X, accel_series=acc_series)
# set damping based on first eigen mode
angular_freq = o3.get_eigen(osi, solver='fullGenLapack', n=1)[0] ** 0.5
response_period = 2 * np.pi / angular_freq
print('response_period: ', response_period)
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
o3.wipe_analysis(osi)
o3.algorithm.Newton(osi)
o3.system.SparseGeneral(osi)
o3.numberer.RCM(osi)
o3.constraints.Transformation(osi)
o3.integrator.Newmark(osi, 0.5, 0.25)
o3.analysis.Transient(osi)
o3.extensions.to_py_file(osi, 'simple.py')
o3.test_check.EnergyIncr(osi, tol=1.0e-10, max_iter=10)
analysis_time = (len(motion) - 1) * dt
analysis_dt = 0.001
outputs = {
"time": [],
"rel_disp": [],
"rel_accel": [],
"rel_vel": [],
"force": []
}
while o3.get_time(osi) < analysis_time:
o3.analyze(osi, 1, analysis_dt)
curr_time = o3.get_time(osi)
outputs["time"].append(curr_time)
outputs["rel_disp"].append(o3.get_node_disp(osi, top_node, o3.cc.X))
outputs["rel_vel"].append(o3.get_node_vel(osi, top_node, o3.cc.X))
outputs["rel_accel"].append(o3.get_node_accel(osi, top_node, o3.cc.X))
o3.gen_reactions(osi)
outputs["force"].append(o3.get_ele_response(osi, ele, 'force'))
o3.wipe(osi)
for item in outputs:
outputs[item] = np.array(outputs[item])
return outputs
def gen_response(period, xi, asig, etype, fos_for_dt=None):
# Define inelastic SDOF
mass = 1.0
f_yield = 1.5 # Reduce this to make it nonlinear
r_post = 0.0
# Initialise OpenSees instance
osi = o3.OpenSeesInstance(ndm=2, state=0)
# Establish nodes
bot_node = o3.node.Node(osi, 0, 0)
top_node = o3.node.Node(osi, 0, 0)
# Fix bottom node
o3.Fix3DOF(osi, top_node, o3.cc.FREE, o3.cc.FIXED, o3.cc.FIXED)
o3.Fix3DOF(osi, bot_node, o3.cc.FIXED, o3.cc.FIXED, o3.cc.FIXED)
# Set out-of-plane DOFs to be slaved
o3.EqualDOF(osi, top_node, bot_node, [o3.cc.Y, o3.cc.ROTZ])
# nodal mass (weight / g):
o3.Mass(osi, top_node, mass, 0., 0.)
# Define material
k_spring = 4 * np.pi**2 * mass / period**2
# bilinear_mat = o3.uniaxial_material.Steel01(osi, fy=f_yield, e0=k_spring, b=r_post)
mat = o3.uniaxial_material.Elastic(osi, e_mod=k_spring)
# Assign zero length element, # Note: pass actual node and material objects into element
o3.element.ZeroLength(osi, [bot_node, top_node],
mats=[mat],
dirs=[o3.cc.DOF2D_X],
r_flag=1)
# Define the dynamic analysis
# Define the dynamic analysis
acc_series = o3.time_series.Path(osi, dt=asig.dt, values=-1 *
asig.values) # should be negative
o3.pattern.UniformExcitation(osi, dir=o3.cc.X, accel_series=acc_series)
# set damping based on first eigen mode
angular_freq = o3.get_eigen(osi, solver='fullGenLapack', n=1)[0]**0.5
period = 2 * np.pi / angular_freq
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)
o3.set_time(osi, 0.0)
# Run the dynamic analysis
o3.wipe_analysis(osi)
# Run the dynamic analysis
o3.numberer.RCM(osi)
o3.system.FullGeneral(osi)
if etype == 'central_difference':
o3.algorithm.Linear(osi, factor_once=True)
o3.integrator.CentralDifference(osi)
explicit_dt = 2 / angular_freq / fos_for_dt
analysis_dt = explicit_dt
elif etype == 'implicit':
o3.algorithm.Newton(osi)
o3.integrator.Newmark(osi, gamma=0.5, beta=0.25)
analysis_dt = 0.001
else:
raise ValueError()
o3.constraints.Transformation(osi)
o3.analysis.Transient(osi)
o3.test_check.EnergyIncr(osi, tol=1.0e-10, max_iter=10)
analysis_time = asig.time[-1]
outputs = {
"time": [],
"rel_disp": [],
"rel_accel": [],
"rel_vel": [],
"force": []
}
rec_dt = 0.002
n_incs = int(analysis_dt / rec_dt)
n_incs = 1
while o3.get_time(osi) < analysis_time:
o3.analyze(osi, n_incs, analysis_dt)
curr_time = o3.get_time(osi)
outputs["time"].append(curr_time)
outputs["rel_disp"].append(o3.get_node_disp(osi, top_node, o3.cc.X))
outputs["rel_vel"].append(o3.get_node_vel(osi, top_node, o3.cc.X))
outputs["rel_accel"].append(o3.get_node_accel(osi, top_node, o3.cc.X))
o3.gen_reactions(osi)
outputs["force"].append(-o3.get_node_reaction(
osi, bot_node, o3.cc.X)) # Negative since diff node
o3.wipe(osi)
for item in outputs:
outputs[item] = np.array(outputs[item])
return outputs