def run_pm4sand_et(sl,
csr,
esig_v0=101.0e3,
static_bias=0.0,
n_lim=100,
k0=0.5,
strain_limit=0.03,
strain_inc=5.0e-6,
etype='implicit'):
nu_init = k0 / (1 + k0)
damp = 0.02
omega0 = 0.2
omega1 = 20.0
a1 = 2. * damp / (omega0 + omega1)
a0 = a1 * omega0 * omega1
# Initialise OpenSees instance
osi = o3.OpenSeesInstance(ndm=2, ndf=3, state=3)
# Establish nodes
h_ele = 1.
bl_node = o3.node.Node(osi, 0, 0)
br_node = o3.node.Node(osi, h_ele, 0)
tr_node = o3.node.Node(osi, h_ele, h_ele)
tl_node = o3.node.Node(osi, 0, h_ele)
all_nodes = [bl_node, br_node, tr_node, tl_node]
# Fix bottom node
o3.Fix3DOF(osi, bl_node, o3.cc.FIXED, o3.cc.FIXED, o3.cc.FIXED)
o3.Fix3DOF(osi, br_node, o3.cc.FIXED, o3.cc.FIXED, o3.cc.FIXED)
o3.Fix3DOF(osi, tr_node, o3.cc.FREE, o3.cc.FREE, o3.cc.FIXED)
o3.Fix3DOF(osi, tl_node, o3.cc.FREE, o3.cc.FREE, o3.cc.FIXED)
# Set out-of-plane DOFs to be slaved
o3.EqualDOF(osi, tr_node, tl_node, [o3.cc.X, o3.cc.Y])
# Define material
pm4sand = o3.nd_material.PM4Sand(osi,
sl.relative_density,
sl.g0_mod,
sl.h_po,
sl.unit_sat_mass,
101.3,
nu=nu_init)
# Note water bulk modulus is irrelevant since constant volume test - so as soil skeleton contracts
# the bulk modulus of the soil skeleton controls the change in effective stress
water_bulk_mod = 2.2e6
ele = o3.element.SSPquadUP(osi,
all_nodes,
pm4sand,
1.0,
water_bulk_mod,
1.,
sl.permeability,
sl.permeability,
sl.e_curr,
alpha=1.0e-5,
b1=0.0,
b2=0.0)
o3.constraints.Transformation(osi)
o3.test_check.NormDispIncr(osi, tol=1.0e-6, max_iter=35, p_flag=0)
o3.numberer.RCM(osi)
omegas = np.array(o3.get_eigen(osi, n=1))**0.5
periods = 2 * np.pi / omegas
periods = [0.001]
if etype == 'implicit':
o3.algorithm.Newton(osi)
o3.system.FullGeneral(osi)
o3.integrator.Newmark(osi, gamma=5. / 6, beta=4. / 9)
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.5)
explicit_dt = periods[0] / np.pi / 8
elif etype == 'central_difference':
o3.integrator.CentralDifference(osi)
explicit_dt = periods[0] / np.pi / 16 # 0.5 is a factor of safety
elif etype == 'hht_explicit':
o3.integrator.HHTExplicit(osi, alpha=0.5)
explicit_dt = periods[0] / np.pi / 8
elif etype == 'explicit_difference':
o3.integrator.ExplicitDifference(osi)
explicit_dt = periods[0] / np.pi / 4
else:
raise ValueError(etype)
print('explicit_dt: ', explicit_dt)
dt = explicit_dt
o3.analysis.Transient(osi)
freqs = [0.5, 10]
xi = 0.1
use_modal_damping = 0
if use_modal_damping:
omega_1 = 2 * np.pi * freqs[0]
omega_2 = 2 * np.pi * freqs[1]
a0 = 2 * xi * omega_1 * omega_2 / (omega_1 + omega_2)
a1 = 2 * xi / (omega_1 + omega_2)
o3.rayleigh.Rayleigh(osi, a0, 0, a1, 0)
else:
o3.ModalDamping(osi, [xi])
o3.update_material_stage(osi, pm4sand, stage=0)
# print('here1: ', o3.get_ele_response(osi, ele, 'stress'), esig_v0, csr)
all_stresses_cache = o3.recorder.ElementToArrayCache(osi,
ele,
arg_vals=['stress'])
all_strains_cache = o3.recorder.ElementToArrayCache(osi,
ele,
arg_vals=['strain'])
nodes_cache = o3.recorder.NodesToArrayCache(osi,
all_nodes,
dofs=[1, 2, 3],
res_type='disp')
o3.recorder.NodesToFile(osi,
'node_disp.txt',
all_nodes,
dofs=[1, 2, 3],
res_type='disp')
# Add static vertical pressure and stress bias
ttime = 30
time_series = o3.time_series.Path(osi,
time=[0, ttime, 1e10],
values=[0, 1, 1])
o3.pattern.Plain(osi, time_series)
o3.Load(osi, tl_node, [0, -esig_v0 / 2, 0])
o3.Load(osi, tr_node, [0, -esig_v0 / 2, 0])
o3.analyze(osi, num_inc=int(ttime / dt) + 10, dt=dt)
ts2 = o3.time_series.Path(osi,
time=[ttime, 80000, 1e10],
values=[1., 1., 1.],
factor=1)
o3.pattern.Plain(osi, ts2, fact=1.)
y_vert = o3.get_node_disp(osi, tr_node, o3.cc.Y)
o3.SP(osi, tl_node, dof=o3.cc.Y, dof_values=[y_vert])
o3.SP(osi, tr_node, dof=o3.cc.Y, dof_values=[y_vert])
# Close the drainage valves
for node in all_nodes:
o3.remove_sp(osi, node, dof=3)
o3.analyze(osi, int(5 / dt), dt=dt)
print('here3: ', o3.get_ele_response(osi, ele, 'stress'), esig_v0, csr)
o3.update_material_stage(osi, pm4sand, stage=1)
o3.set_parameter(osi, value=0, eles=[ele], args=['FirstCall', pm4sand.tag])
o3.analyze(osi, int(5 / dt), dt=dt)
o3.set_parameter(osi,
value=sl.poissons_ratio,
eles=[ele],
args=['poissonRatio', pm4sand.tag])
o3.extensions.to_py_file(osi)
n_cyc = 0.0
target_strain = 1.1 * strain_limit
target_disp = target_strain * h_ele
limit_reached = 0
export = 1
while n_cyc < n_lim:
print('n_cyc: ', n_cyc)
h_disp = o3.get_node_disp(osi, tr_node, o3.cc.X)
curr_time = o3.get_time(osi)
steps = target_strain / strain_inc
ts0 = o3.time_series.Path(osi,
time=[curr_time, curr_time + steps, 1e10],
values=[h_disp, target_disp, target_disp],
factor=1)
pat0 = o3.pattern.Plain(osi, ts0)
o3.SP(osi, tr_node, dof=o3.cc.X, dof_values=[1.0])
curr_stress = o3.get_ele_response(osi, ele, 'stress')[2]
if math.isnan(curr_stress):
raise ValueError
if export:
o3.extensions.to_py_file(osi)
export = 0
while curr_stress < (csr - static_bias) * esig_v0:
o3.analyze(osi, int(0.1 / dt), dt=dt)
curr_stress = o3.get_ele_response(osi, ele, 'stress')[2]
h_disp = o3.get_node_disp(osi, tr_node, o3.cc.X)
print(h_disp, target_disp)
if h_disp >= target_disp:
print('STRAIN LIMIT REACHED - on load')
limit_reached = 1
break
if limit_reached:
break
n_cyc += 0.25
print('load reversal, n_cyc: ', n_cyc)
curr_time = o3.get_time(osi)
o3.remove_load_pattern(osi, pat0)
o3.remove(osi, ts0)
o3.remove_sp(osi, tr_node, dof=o3.cc.X)
# Reverse cycle
steps = (h_disp + target_disp) / (strain_inc * h_ele)
ts0 = o3.time_series.Path(osi,
time=[curr_time, curr_time + steps, 1e10],
values=[h_disp, -target_disp, -target_disp],
factor=1)
pat0 = o3.pattern.Plain(osi, ts0)
o3.SP(osi, tr_node, dof=o3.cc.X, dof_values=[1.0])
i = 0
while curr_stress > -(csr + static_bias) * esig_v0:
o3.analyze(osi, int(0.1 / dt), dt=dt)
curr_stress = o3.get_ele_response(osi, ele, 'stress')[2]
h_disp = o3.get_node_disp(osi, tr_node, o3.cc.X)
if -h_disp >= target_disp:
print('STRAIN LIMIT REACHED - on reverse')
limit_reached = 1
break
i += 1
if i > steps:
break
if limit_reached:
break
n_cyc += 0.5
print('reload, n_cyc: ', n_cyc)
curr_time = o3.get_time(osi)
o3.remove_load_pattern(osi, pat0)
o3.remove(osi, ts0)
o3.remove_sp(osi, tr_node, dof=o3.cc.X)
# reload cycle
steps = (-h_disp + target_disp) / (strain_inc * h_ele)
ts0 = o3.time_series.Path(osi,
time=[curr_time, curr_time + steps, 1e10],
values=[h_disp, target_disp, target_disp],
factor=1)
pat0 = o3.pattern.Plain(osi, ts0)
o3.SP(osi, tr_node, dof=o3.cc.X, dof_values=[1.0])
while curr_stress < static_bias * esig_v0:
o3.analyze(osi, int(0.1 / dt), dt=dt)
curr_stress = o3.get_ele_response(osi, ele, 'stress')[2]
h_disp = o3.get_node_disp(osi, tr_node, o3.cc.X)
if h_disp >= target_disp:
print('STRAIN LIMIT REACHED - on reload')
limit_reached = 1
break
if limit_reached:
break
o3.remove_load_pattern(osi, pat0)
o3.remove(osi, ts0)
o3.remove_sp(osi, tr_node, dof=o3.cc.X)
n_cyc += 0.25
o3.wipe(osi)
all_stresses = all_stresses_cache.collect()
all_strains = all_strains_cache.collect()
disps = nodes_cache.collect()
stress = all_stresses[:, 2]
strain = all_strains[:, 2]
ppt = all_stresses[:, 1]
return stress, strain, ppt, disps
pass
def site_response(sp,
asig,
freqs=(0.5, 10),
xi=0.03,
analysis_dt=0.001,
dy=0.5,
analysis_time=None,
outs=None,
rec_dt=None,
use_explicit=0):
"""
Run seismic analysis of a soil profile that has a compliant base
Parameters
----------
sp: sfsimodels.SoilProfile object
A soil profile
asig: eqsig.AccSignal object
An acceleration signal
Returns
-------
"""
if analysis_time is None:
analysis_time = asig.time[-1]
if outs is None:
outs = {
'ACCX': [0]
} # Export the horizontal acceleration at the surface
if rec_dt is None:
rec_dt = analysis_dt
osi = o3.OpenSeesInstance(ndm=2, ndf=2, state=3)
assert isinstance(sp, sm.SoilProfile)
sp.gen_split(props=['shear_vel', 'unit_mass'], target=dy)
thicknesses = sp.split["thickness"]
n_node_rows = len(thicknesses) + 1
node_depths = np.cumsum(sp.split["thickness"])
node_depths = np.insert(node_depths, 0, 0)
ele_depths = (node_depths[1:] + node_depths[:-1]) / 2
unit_masses = sp.split["unit_mass"] / 1e3
grav = 9.81
omega_1 = 2 * np.pi * freqs[0]
omega_2 = 2 * np.pi * freqs[1]
a0 = 2 * xi * omega_1 * omega_2 / (omega_1 + omega_2)
a1 = 2 * xi / (omega_1 + omega_2)
k0 = 0.5
pois = k0 / (1 + k0)
newmark_gamma = 0.5
newmark_beta = 0.25
ele_width = min(thicknesses)
# Define nodes and set boundary conditions for simple shear deformation
# Start at top and build down?
sn = [[o3.node.Node(osi, 0, 0), o3.node.Node(osi, ele_width, 0)]]
for i in range(1, n_node_rows):
# Establish left and right nodes
sn.append([
o3.node.Node(osi, 0, -node_depths[i]),
o3.node.Node(osi, ele_width, -node_depths[i])
])
# set x and y dofs equal for left and right nodes
o3.EqualDOF(osi, sn[i][0], sn[i][1], [o3.cc.X, o3.cc.Y])
# Fix base nodes
o3.Fix2DOF(osi, sn[-1][0], o3.cc.FREE, o3.cc.FIXED)
o3.Fix2DOF(osi, sn[-1][1], o3.cc.FREE, o3.cc.FIXED)
# Define dashpot nodes
dashpot_node_l = o3.node.Node(osi, 0, -node_depths[-1])
dashpot_node_2 = o3.node.Node(osi, 0, -node_depths[-1])
o3.Fix2DOF(osi, dashpot_node_l, o3.cc.FIXED, o3.cc.FIXED)
o3.Fix2DOF(osi, dashpot_node_2, o3.cc.FREE, o3.cc.FIXED)
# define equal DOF for dashpot and soil base nodes
o3.EqualDOF(osi, sn[-1][0], sn[-1][1], [o3.cc.X])
o3.EqualDOF(osi, sn[-1][0], dashpot_node_2, [o3.cc.X])
# define materials
ele_thick = 1.0 # m
soil_mats = []
prev_args = []
prev_kwargs = {}
prev_sl_type = None
eles = []
for i in range(len(thicknesses)):
y_depth = ele_depths[i]
sl_id = sp.get_layer_index_by_depth(y_depth)
sl = sp.layer(sl_id)
app2mod = {}
if y_depth > sp.gwl:
umass = sl.unit_sat_mass / 1e3
else:
umass = sl.unit_dry_mass / 1e3
# Define material
sl_class = o3.nd_material.ElasticIsotropic
sl.e_mod = 2 * sl.g_mod * (1 + sl.poissons_ratio) / 1e3
app2mod['rho'] = 'unit_moist_mass'
overrides = {'nu': sl.poissons_ratio, 'unit_moist_mass': umass}
args, kwargs = o3.extensions.get_o3_kwargs_from_obj(
sl, sl_class, custom=app2mod, overrides=overrides)
changed = 0
if sl.type != prev_sl_type or len(args) != len(prev_args) or len(
kwargs) != len(prev_kwargs):
changed = 1
else:
for j, arg in enumerate(args):
if not np.isclose(arg, prev_args[j]):
changed = 1
for pm in kwargs:
if pm not in prev_kwargs or not np.isclose(
kwargs[pm], prev_kwargs[pm]):
changed = 1
if changed:
mat = sl_class(osi, *args, **kwargs)
prev_sl_type = sl.type
prev_args = copy.deepcopy(args)
prev_kwargs = copy.deepcopy(kwargs)
soil_mats.append(mat)
# def element
nodes = [sn[i + 1][0], sn[i + 1][1], sn[i][1],
sn[i][0]] # anti-clockwise
eles.append(
o3.element.SSPquad(osi, nodes, mat, o3.cc.PLANE_STRAIN, ele_thick,
0.0, -grav))
# eles.append(o3.element.Quad(osi, nodes, mat=mat, otype=o3.cc.PLANE_STRAIN, thick=ele_thick, pressure=0.0, rho=unit_masses[i], b2=grav))
# define material and element for viscous dampers
base_sl = sp.layer(sp.n_layers)
c_base = ele_width * base_sl.unit_dry_mass / 1e3 * sp.get_shear_vel_at_depth(
sp.height)
dashpot_mat = o3.uniaxial_material.Viscous(osi, c_base, alpha=1.)
o3.element.ZeroLength(osi, [dashpot_node_l, dashpot_node_2],
mats=[dashpot_mat],
dirs=[o3.cc.DOF2D_X])
# Static analysis
o3.constraints.Transformation(osi)
o3.test_check.NormDispIncr(osi, tol=1.0e-4, max_iter=30, p_flag=0)
o3.algorithm.Newton(osi)
o3.numberer.RCM(osi)
o3.system.ProfileSPD(osi)
o3.integrator.Newmark(osi, newmark_gamma, newmark_beta)
o3.analysis.Transient(osi)
o3.analyze(osi, 40, 1.)
for i in range(len(soil_mats)):
if isinstance(soil_mats[i], o3.nd_material.PM4Sand) or isinstance(
soil_mats[i], o3.nd_material.PressureIndependMultiYield):
o3.update_material_stage(osi, soil_mats[i], 1)
o3.analyze(osi, 50, 0.5)
# reset time and analysis
o3.set_time(osi, 0.0)
o3.wipe_analysis(osi)
ods = {}
for otype in outs:
if otype == 'ACCX':
ods['ACCX'] = []
if isinstance(outs['ACCX'], str) and outs['ACCX'] == 'all':
ods['ACCX'] = o3.recorder.NodesToArrayCache(osi,
nodes=sn[:][0],
dofs=[o3.cc.X],
res_type='accel',
dt=rec_dt)
else:
for i in range(len(outs['ACCX'])):
ind = np.argmin(abs(node_depths - outs['ACCX'][i]))
ods['ACCX'].append(
o3.recorder.NodeToArrayCache(osi,
node=sn[ind][0],
dofs=[o3.cc.X],
res_type='accel',
dt=rec_dt))
if otype == 'TAU':
ods['TAU'] = []
if isinstance(outs['TAU'], str) and outs['TAU'] == 'all':
ods['TAU'] = o3.recorder.ElementsToArrayCache(
osi, eles=eles, arg_vals=['stress'], dt=rec_dt)
else:
for i in range(len(outs['TAU'])):
ind = np.argmin(abs(ele_depths - outs['TAU'][i]))
ods['TAU'].append(
o3.recorder.ElementToArrayCache(osi,
ele=eles[ind],
arg_vals=['stress'],
dt=rec_dt))
if otype == 'STRS':
ods['STRS'] = []
if isinstance(outs['STRS'], str) and outs['STRS'] == 'all':
ods['STRS'] = o3.recorder.ElementsToArrayCache(
osi, eles=eles, arg_vals=['strain'], dt=rec_dt)
else:
for i in range(len(outs['STRS'])):
ind = np.argmin(abs(ele_depths - outs['STRS'][i]))
ods['STRS'].append(
o3.recorder.ElementToArrayCache(osi,
ele=eles[ind],
arg_vals=['strain'],
dt=rec_dt))
# Define the dynamic analysis
ts_obj = o3.time_series.Path(osi,
dt=asig.dt,
values=asig.velocity * 1,
factor=c_base)
o3.pattern.Plain(osi, ts_obj)
o3.Load(osi, sn[-1][0], [1., 0.])
# Run the dynamic analysis
if use_explicit:
o3.system.FullGeneral(osi)
# o3.algorithm.Newton(osi)
o3.algorithm.Linear(osi)
# o3.integrator.ExplicitDifference(osi)
# o3.integrator.CentralDifference(osi)
o3.integrator.NewmarkExplicit(osi, newmark_gamma) # also works
else:
o3.system.SparseGeneral(osi)
o3.algorithm.Newton(osi)
o3.integrator.Newmark(osi, newmark_gamma, newmark_beta)
o3.numberer.RCM(osi)
o3.constraints.Transformation(osi)
n = 2
modal_damp = 0
omegas = np.array(o3.get_eigen(osi, n=n))**0.5
response_periods = 2 * np.pi / omegas
print('response_periods: ', response_periods)
if not modal_damp:
o3.rayleigh.Rayleigh(osi, a0, a1, 0, 0)
else:
o3.ModalDamping(osi, [xi, xi])
o3.analysis.Transient(osi)
o3.test_check.NormDispIncr(osi, tol=1.0e-6, max_iter=10)
while o3.get_time(osi) < analysis_time:
print(o3.get_time(osi))
if o3.analyze(osi, 1, analysis_dt):
print('failed')
break
o3.wipe(osi)
out_dict = {}
for otype in ods:
if isinstance(ods[otype], list):
out_dict[otype] = []
for i in range(len(ods[otype])):
out_dict[otype].append(ods[otype][i].collect())
out_dict[otype] = np.array(out_dict[otype])
else:
out_dict[otype] = ods[otype].collect().T
out_dict['time'] = np.arange(0, analysis_time, rec_dt)
return out_dict
def site_response(sp,
asig,
freqs=(0.5, 10),
xi=0.03,
analysis_dt=0.001,
dy=0.5,
analysis_time=None,
outs=None,
rec_dt=None):
"""
Run seismic analysis of a soil profile - example based on:
http://opensees.berkeley.edu/wiki/index.php/Site_Response_Analysis_of_a_Layered_Soil_Column_(Total_Stress_Analysis)
Parameters
----------
sp: sfsimodels.SoilProfile object
A soil profile
asig: eqsig.AccSignal object
An acceleration signal
Returns
-------
"""
if analysis_time is None:
analysis_time = asig.time[-1]
if outs is None:
outs = {
'ACCX': [0]
} # Export the horizontal acceleration at the surface
if rec_dt is None:
rec_dt = analysis_dt
osi = o3.OpenSeesInstance(ndm=2, ndf=2, state=3)
assert isinstance(sp, sm.SoilProfile)
sp.gen_split(props=['shear_vel', 'unit_mass'], target=dy)
thicknesses = sp.split["thickness"]
n_node_rows = len(thicknesses) + 1
node_depths = np.cumsum(sp.split["thickness"])
node_depths = np.insert(node_depths, 0, 0)
ele_depths = (node_depths[1:] + node_depths[:-1]) / 2
unit_masses = sp.split["unit_mass"] / 1e3
grav = 9.81
omega_1 = 2 * np.pi * freqs[0]
omega_2 = 2 * np.pi * freqs[1]
a0 = 2 * xi * omega_1 * omega_2 / (omega_1 + omega_2)
a1 = 2 * xi / (omega_1 + omega_2)
k0 = 0.5
pois = k0 / (1 + k0)
newmark_gamma = 0.5
newmark_beta = 0.25
ele_width = min(thicknesses)
total_soil_nodes = len(thicknesses) * 2 + 2
# Define nodes and set boundary conditions for simple shear deformation
# Start at top and build down?
sn = [[o3.node.Node(osi, 0, 0), o3.node.Node(osi, ele_width, 0)]]
for i in range(1, n_node_rows):
# Establish left and right nodes
sn.append([
o3.node.Node(osi, 0, -node_depths[i]),
o3.node.Node(osi, ele_width, -node_depths[i])
])
# set x and y dofs equal for left and right nodes
o3.EqualDOF(osi, sn[i][0], sn[i][1], [o3.cc.X, o3.cc.Y])
sn = np.array(sn)
# Fix base nodes
o3.Fix2DOF(osi, sn[-1][0], o3.cc.FREE, o3.cc.FIXED)
o3.Fix2DOF(osi, sn[-1][1], o3.cc.FREE, o3.cc.FIXED)
# Define dashpot nodes
dashpot_node_l = o3.node.Node(osi, 0, -node_depths[-1])
dashpot_node_2 = o3.node.Node(osi, 0, -node_depths[-1])
o3.Fix2DOF(osi, dashpot_node_l, o3.cc.FIXED, o3.cc.FIXED)
o3.Fix2DOF(osi, dashpot_node_2, o3.cc.FREE, o3.cc.FIXED)
# define equal DOF for dashpot and soil base nodes
o3.EqualDOF(osi, sn[-1][0], sn[-1][1], [o3.cc.X])
o3.EqualDOF(osi, sn[-1][0], dashpot_node_2, [o3.cc.X])
# define materials
ele_thick = 1.0 # m
soil_mats = []
strains = np.logspace(-6, -0.5, 16)
ref_strain = 0.005
rats = 1. / (1 + (strains / ref_strain)**0.91)
prev_args = []
prev_kwargs = {}
prev_sl_type = None
eles = []
tau_inds = []
total_stress_inds = 0
strs_inds = []
total_strain_inds = 0
for i in range(len(thicknesses)):
y_depth = ele_depths[i]
sl_id = sp.get_layer_index_by_depth(y_depth)
sl = sp.layer(sl_id)
app2mod = {}
if y_depth > sp.gwl:
umass = sl.unit_sat_mass / 1e3
else:
umass = sl.unit_dry_mass / 1e3
# Define material
if sl.type == 'pm4sand':
sl_class = o3.nd_material.PM4Sand
overrides = {'nu': pois, 'p_atm': 101, 'unit_moist_mass': umass}
app2mod = sl.app2mod
elif sl.type == 'sdmodel':
sl_class = o3.nd_material.StressDensity
overrides = {'nu': pois, 'p_atm': 101, 'unit_moist_mass': umass}
app2mod = sl.app2mod
elif sl.type == 'pimy':
sl_class = o3.nd_material.PressureIndependMultiYield
overrides = {
'nu': pois,
'p_atm': 101,
'rho': umass,
'nd': 2.0,
'g_mod_ref': sl.g_mod / 1e3,
'bulk_mod_ref': sl.bulk_mod / 1e3,
'cohesion': sl.cohesion / 1e3,
'd': 0.0,
# 'no_yield_surf': 20
}
tau_inds.append(total_stress_inds + 3) # 4th
total_stress_inds += 5
strs_inds.append(total_strain_inds + 2) # 3rd
total_strain_inds += 3
else:
sl_class = o3.nd_material.ElasticIsotropic
sl.e_mod = 2 * sl.g_mod * (1 - sl.poissons_ratio) / 1e3
app2mod['rho'] = 'unit_moist_mass'
overrides = {'nu': sl.poissons_ratio, 'unit_moist_mass': umass}
# opw.extensions.to_py_file(osi)
args, kwargs = o3.extensions.get_o3_kwargs_from_obj(
sl, sl_class, custom=app2mod, overrides=overrides)
changed = 0
if sl.type != prev_sl_type or len(args) != len(prev_args) or len(
kwargs) != len(prev_kwargs):
changed = 1
else:
for j, arg in enumerate(args):
if not np.isclose(arg, prev_args[j]):
changed = 1
for pm in kwargs:
if pm not in prev_kwargs or not np.isclose(
kwargs[pm], prev_kwargs[pm]):
changed = 1
if changed:
mat = sl_class(osi, *args, **kwargs)
prev_sl_type = sl.type
prev_args = copy.deepcopy(args)
prev_kwargs = copy.deepcopy(kwargs)
soil_mats.append(mat)
# def element
nodes = [sn[i + 1][0], sn[i + 1][1], sn[i][1],
sn[i][0]] # anti-clockwise
# ele = o3.element.Quad(osi, nodes, ele_thick, o3.cc.PLANE_STRAIN, mat, b2=grav * unit_masses[i])
ele = o3.element.SSPquad(osi,
nodes,
mat,
'PlaneStrain',
ele_thick,
0.0,
b2=grav * unit_masses[i])
eles.append(ele)
# define material and element for viscous dampers
base_sl = sp.layer(sp.n_layers)
c_base = ele_width * base_sl.unit_dry_mass / 1e3 * sp.get_shear_vel_at_depth(
sp.height)
dashpot_mat = o3.uniaxial_material.Viscous(osi, c_base, alpha=1.)
o3.element.ZeroLength(osi, [dashpot_node_l, dashpot_node_2],
mats=[dashpot_mat],
dirs=[o3.cc.DOF2D_X])
# Static analysis
o3.constraints.Transformation(osi)
o3.test_check.NormDispIncr(osi, tol=1.0e-4, max_iter=30, p_flag=0)
o3.algorithm.Newton(osi)
o3.numberer.RCM(osi)
o3.system.ProfileSPD(osi)
o3.integrator.Newmark(osi, newmark_gamma, newmark_beta)
o3.analysis.Transient(osi)
o3.analyze(osi, 40, 1.)
for i in range(len(soil_mats)):
if isinstance(soil_mats[i], o3.nd_material.PM4Sand) or isinstance(
soil_mats[i], o3.nd_material.PressureIndependMultiYield):
o3.update_material_stage(osi, soil_mats[i], 1)
o3.analyze(osi, 50, 0.5)
# reset time and analysis
o3.set_time(osi, 0.0)
o3.wipe_analysis(osi)
# o3.recorder.NodeToFile(osi, 'sample_out.txt', node=nd["R0L"], dofs=[o3.cc.X], res_type='accel')
na = o3.recorder.NodeToArrayCache(osi,
node=sn[0][0],
dofs=[o3.cc.X],
res_type='accel')
otypes = ['ACCX', 'TAU', 'STRS']
ods = {}
for otype in outs:
if otype == 'ACCX':
ods['ACCX'] = []
if isinstance(outs['ACCX'], str) and outs['ACCX'] == 'all':
ods['ACCX'] = o3.recorder.NodesToArrayCache(osi,
nodes=sn[:, 0],
dofs=[o3.cc.X],
res_type='accel',
dt=rec_dt)
else:
for i in range(len(outs['ACCX'])):
ind = np.argmin(abs(node_depths - outs['ACCX'][i]))
ods['ACCX'].append(
o3.recorder.NodeToArrayCache(osi,
node=sn[ind][0],
dofs=[o3.cc.X],
res_type='accel',
dt=rec_dt))
if otype == 'TAU':
ods['TAU'] = []
if isinstance(outs['TAU'], str) and outs['TAU'] == 'all':
ods['TAU'] = o3.recorder.ElementsToArrayCache(
osi, eles=eles, arg_vals=['stress'], dt=rec_dt)
else:
for i in range(len(outs['TAU'])):
ind = np.argmin(abs(ele_depths - outs['TAU'][i]))
ods['TAU'].append(
o3.recorder.ElementToArrayCache(osi,
ele=eles[ind],
arg_vals=['stress'],
dt=rec_dt))
if otype == 'STRS':
ods['STRS'] = []
if isinstance(outs['STRS'], str) and outs['STRS'] == 'all':
ods['STRS'] = o3.recorder.ElementsToArrayCache(
osi, eles=eles, arg_vals=['strain'], dt=rec_dt)
else:
for i in range(len(outs['STRS'])):
ind = np.argmin(abs(ele_depths - outs['STRS'][i]))
ods['STRS'].append(
o3.recorder.ElementToArrayCache(osi,
ele=eles[ind],
arg_vals=['strain'],
dt=rec_dt))
# Define the dynamic analysis
ts_obj = o3.time_series.Path(osi,
dt=asig.dt,
values=asig.velocity * -1,
factor=c_base)
o3.pattern.Plain(osi, ts_obj)
o3.Load(osi, sn[-1][0], [1., 0.])
# Run the dynamic analysis
o3.algorithm.Newton(osi)
o3.system.SparseGeneral(osi)
o3.numberer.RCM(osi)
o3.constraints.Transformation(osi)
o3.integrator.Newmark(osi, newmark_gamma, newmark_beta)
o3.rayleigh.Rayleigh(osi, a0, a1, 0, 0)
o3.analysis.Transient(osi)
o3.test_check.EnergyIncr(osi, tol=1.0e-7, max_iter=10)
o3.extensions.to_py_file(osi)
while opy.getTime() < analysis_time:
print(opy.getTime())
if o3.analyze(osi, 1, analysis_dt):
print('failed')
break
opy.wipe()
out_dict = {}
for otype in ods:
if isinstance(ods[otype], list):
out_dict[otype] = []
for i in range(len(ods[otype])):
a = ods[otype][i].collect()
out_dict[otype].append(
a[3::4]) # TODO: not working for generic case
out_dict[otype] = np.array(out_dict[otype])
else:
if otype == 'TAU':
a = ods[otype].collect()
out_dict[otype] = a[:, tau_inds].T * 1e3
elif otype == 'STRS':
a = ods[otype].collect()
out_dict[otype] = a[:, strs_inds].T
else:
out_dict[otype] = ods[otype].collect().T
out_dict['time'] = np.arange(0, len(out_dict[otype][0])) * rec_dt
return out_dict
def update_to_nonlinear(self):
from o3seespy import update_material_stage
update_material_stage(self.osi, self, 1)
def run_ts_custom_strain(mat, esig_v0, strains, osi=None, nu_dyn=None, target_d_inc=0.00001, k0=None, etype='newmark_explicit',
handle='silent', verbose=0, opyfile=None, dss=False, plain_strain=True, min_n=10, nl=True):
# if dss:
# raise ValueError('dss option is not working')
damp = 0.05
omega0 = 0.2
omega1 = 20.0
a1 = 2. * damp / (omega0 + omega1)
a0 = a1 * omega0 * omega1
if osi is None:
osi = o3.OpenSeesInstance(ndm=2, ndf=2)
mat.build(osi)
# Establish nodes
h_ele = 1.
nodes = [
o3.node.Node(osi, 0.0, 0.0),
o3.node.Node(osi, h_ele, 0.0),
o3.node.Node(osi, h_ele, h_ele),
o3.node.Node(osi, 0.0, h_ele)
]
# Fix bottom node
o3.Fix2DOF(osi, nodes[0], o3.cc.FIXED, o3.cc.FIXED)
if k0 is None:
o3.Fix2DOF(osi, nodes[1], o3.cc.FIXED, o3.cc.FIXED)
# Set out-of-plane DOFs to be slaved
o3.EqualDOF(osi, nodes[2], nodes[3], [o3.cc.X, o3.cc.Y])
else: # control k0 with node forces
o3.Fix2DOF(osi, nodes[1], o3.cc.FIXED, o3.cc.FREE)
if plain_strain:
oop = 'PlaneStrain'
else:
oop = 'PlaneStress'
ele = o3.element.SSPquad(osi, nodes, mat, oop, 1, 0.0, 0.0)
angular_freqs = np.array(o3.get_eigen(osi, solver='fullGenLapack', n=2)) ** 0.5
print('angular_freqs: ', angular_freqs)
periods = 2 * np.pi / angular_freqs
xi = 0.03
o3.ModalDamping(osi, [xi, xi])
print('periods: ', periods)
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.FullGeneral(osi)
o3.integrator.Newmark(osi, gamma=0.5, beta=0.25)
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.5)
explicit_dt = periods[0] / np.pi / 8
elif etype == 'central_difference':
o3.integrator.CentralDifference(osi)
explicit_dt = periods[0] / np.pi / 16 # 0.5 is a factor of safety
elif etype == 'hht_explicit':
o3.integrator.HHTExplicit(osi, alpha=0.5)
explicit_dt = periods[0] / np.pi / 8
elif etype == 'explicit_difference':
o3.integrator.ExplicitDifference(osi)
explicit_dt = periods[0] / np.pi / 4
else:
raise ValueError(etype)
print('explicit_dt: ', explicit_dt)
dt = explicit_dt
o3.analysis.Transient(osi)
o3.update_material_stage(osi, mat, stage=0)
# dt = 0.00001
tload = 60
n_steps = tload / dt
# Add static vertical pressure and stress bias
time_series = o3.time_series.Path(osi, time=[0, tload, 1e10], values=[0, 1, 1])
o3.pattern.Plain(osi, time_series)
# ts0 = o3.time_series.Linear(osi, factor=1)
# o3.pattern.Plain(osi, ts0)
if k0:
o3.Load(osi, nodes[2], [-esig_v0 / 2, -esig_v0 / 2])
o3.Load(osi, nodes[3], [esig_v0 / 2, -esig_v0 / 2])
o3.Load(osi, nodes[1], [-esig_v0 / 2, 0])
# node 0 is fixed
else:
o3.Load(osi, nodes[2], [0, -esig_v0 / 2])
o3.Load(osi, nodes[3], [0, -esig_v0 / 2])
print('Apply init stress to elastic element')
o3.analyze(osi, num_inc=n_steps, dt=dt)
stresses = o3.get_ele_response(osi, ele, 'stress')
print('init_stress0: ', stresses)
o3.load_constant(osi, tload)
if hasattr(mat, 'update_to_nonlinear') and nl:
print('set to nonlinear')
mat.update_to_nonlinear()
o3.analyze(osi, 10000, dt=dt)
# if not nl:
# mat.update_to_linear()
if nu_dyn is not None:
mat.set_nu(nu_dyn, eles=[ele])
o3.analyze(osi, 10000, dt=dt)
# o3.extensions.to_py_file(osi)
stresses = o3.get_ele_response(osi, ele, 'stress')
print('init_stress1: ', stresses)
# Prepare for reading results
exit_code = None
stresses = o3.get_ele_response(osi, ele, 'stress')
if dss:
o3.gen_reactions(osi)
force0 = o3.get_node_reaction(osi, nodes[2], o3.cc.DOF2D_X)
force1 = o3.get_node_reaction(osi, nodes[3], o3.cc.DOF2D_X)
# force2 = o3.get_node_reaction(osi, nodes[0], o3.cc.DOF2D_X)
stress = [force1 + force0]
strain = [o3.get_node_disp(osi, nodes[2], dof=o3.cc.DOF2D_X)]
sxy_ind = None
gxy_ind = None
# iforce0 = o3.get_node_reaction(osi, nodes[0], o3.cc.DOF2D_X)
# iforce1 = o3.get_node_reaction(osi, nodes[1], o3.cc.DOF2D_X)
# iforce2 = o3.get_node_reaction(osi, nodes[2], o3.cc.DOF2D_X)
# iforce3 = o3.get_node_reaction(osi, nodes[3], o3.cc.DOF2D_X)
# print(iforce0, iforce1, iforce2, iforce3, stresses[2])
else:
ro = o3.recorder.load_recorder_options()
import pandas as pd
df = pd.read_csv(ro)
mat_type = ele.mat.type
dfe = df[(df['mat'] == mat_type) & (df['form'] == oop)]
df_sxy = dfe[dfe['recorder'] == 'stress']
outs = df_sxy['outs'].iloc[0].split('-')
sxy_ind = outs.index('sxy')
df_gxy = dfe[dfe['recorder'] == 'strain']
outs = df_gxy['outs'].iloc[0].split('-')
gxy_ind = outs.index('gxy')
stress = [stresses[sxy_ind]]
cur_strains = o3.get_ele_response(osi, ele, 'strain')
strain = [cur_strains[gxy_ind]]
time_series = o3.time_series.Path(osi, time=[0, tload, 1e10], values=[0, 1, 1])
o3.pattern.Plain(osi, time_series)
disps = list(np.array(strains) * 1)
d_per_dt = 0.01
diff_disps = np.diff(disps, prepend=0)
time_incs = np.abs(diff_disps) / d_per_dt
approx_n_steps = time_incs / dt
time_incs = np.where(approx_n_steps < 800, 800 * dt, time_incs)
approx_n_steps = time_incs / dt
assert min(approx_n_steps) >= 8, approx_n_steps
curr_time = o3.get_time(osi)
times = list(np.cumsum(time_incs) + curr_time)
disps.append(disps[-1])
times.append(1e10)
disps = list(disps)
n_steps_p2 = int((times[-2] - curr_time) / dt) + 10
print('n_steps: ', n_steps_p2)
times.insert(0, curr_time)
disps.insert(0, 0.0)
init_disp = o3.get_node_disp(osi, nodes[2], dof=o3.cc.X)
disps = list(np.array(disps) + init_disp)
ts0 = o3.time_series.Path(osi, time=times, values=disps, factor=1)
pat0 = o3.pattern.Plain(osi, ts0)
o3.SP(osi, nodes[2], dof=o3.cc.X, dof_values=[1])
o3.SP(osi, nodes[3], dof=o3.cc.X, dof_values=[1])
print('init_disp: ', init_disp)
print('path -times: ', times)
print('path -values: ', disps)
v_eff = [stresses[1]]
h_eff = [stresses[0]]
time = [o3.get_time(osi)]
for i in range(int(n_steps_p2 / 200)):
print(i / (n_steps_p2 / 200))
fail = o3.analyze(osi, 200, dt=dt)
o3.gen_reactions(osi)
stresses = o3.get_ele_response(osi, ele, 'stress')
v_eff.append(stresses[1])
h_eff.append(stresses[0])
if dss:
o3.gen_reactions(osi)
force0 = o3.get_node_reaction(osi, nodes[2], o3.cc.DOF2D_X)
force1 = o3.get_node_reaction(osi, nodes[3], o3.cc.DOF2D_X)
stress.append(force1 + force0)
strain.append(o3.get_node_disp(osi, nodes[2], dof=o3.cc.DOF2D_X))
else:
stress.append(stresses[sxy_ind])
cur_strains = o3.get_ele_response(osi, ele, 'strain')
strain.append(cur_strains[gxy_ind])
time.append(o3.get_time(osi))
if fail:
break
return np.array(stress), np.array(strain)-init_disp, np.array(v_eff), np.array(h_eff), np.array(time), exit_code
def run_2d_strain_driver_iso(osi, base_mat, esig_v0, disps, target_d_inc=0.00001, max_steps=10000, handle='silent', da_strain_max=0.05, max_cycles=200, srate=0.0001, esig_v_min=1.0, k0_init=1, verbose=0,
cyc_lim_fail=True):
if not np.isclose(k0_init, 1., rtol=0.05):
raise ValueError(f'Only supports k0=1, current k0={k0_init:.3f}')
max_steps_per_half_cycle = 50000
nodes = [
o3.node.Node(osi, 0.0, 0.0),
o3.node.Node(osi, 1.0, 0.0),
o3.node.Node(osi, 1.0, 1.0),
o3.node.Node(osi, 0.0, 1.0)
]
for node in nodes:
o3.Fix2DOF(osi, node, 1, 1)
mat = o3.nd_material.InitStressNDMaterial(osi, other=base_mat, init_stress=-esig_v0, n_dim=2)
ele = o3.element.SSPquad(osi, nodes, mat, 'PlaneStrain', 1, 0.0, 0.0)
# create analysis
o3.constraints.Penalty(osi, 1.0e15, 1.0e15)
o3.algorithm.Linear(osi)
o3.numberer.RCM(osi)
o3.system.FullGeneral(osi)
o3.analysis.Static(osi)
d_init = 0.0
d_max = 0.1 # element height is 1m
max_time = (d_max - d_init) / srate
ts0 = o3.time_series.Linear(osi, factor=1)
o3.pattern.Plain(osi, ts0)
o3.Load(osi, nodes[2], [1.0, 0.0])
o3.Load(osi, nodes[3], [1.0, 0.0])
o3.analyze(osi, 1)
o3.set_parameter(osi, value=1, eles=[ele], args=['materialState'])
o3.update_material_stage(osi, base_mat, 1)
o3.analyze(osi, 1)
exit_code = None
# loop through the total number of cycles
react = 0
strain = [0]
stresses = o3.get_ele_response(osi, ele, 'stress')
stress = [stresses[2]]
v_eff = [stresses[1]]
h_eff = [stresses[0]]
d_incs = np.diff(disps, prepend=0)
# orys = np.where(diffs >= 0, 1, -1)
for i in range(len(disps)):
d_inc_i = d_incs[i]
if target_d_inc < abs(d_inc_i):
n = int(abs(d_inc_i / target_d_inc))
d_step = d_inc_i / n
else:
n = 1
d_step = d_inc_i
for j in range(n):
o3.integrator.DisplacementControl(osi, nodes[2], o3.cc.DOF2D_X, -d_step)
o3.Load(osi, nodes[2], [1.0, 0.0])
o3.Load(osi, nodes[3], [1.0, 0.0])
o3.analyze(osi, 1)
o3.gen_reactions(osi)
# react = o3.get_ele_response(osi, ele, 'force')[0]
stresses = o3.get_ele_response(osi, ele, 'stress')
v_eff.append(stresses[1])
h_eff.append(stresses[0])
force0 = o3.get_node_reaction(osi, nodes[0], o3.cc.DOF2D_X)
force1 = o3.get_node_reaction(osi, nodes[1], o3.cc.DOF2D_X)
stress.append(-force0 - force1)
# stress.append(stresses[2])
end_strain = -o3.get_node_disp(osi, nodes[2], dof=o3.cc.DOF2D_X)
strain.append(end_strain)
return -np.array(stress), np.array(strain), np.array(v_eff), np.array(h_eff), exit_code
def run_2d_stress_driver(osi, base_mat, esig_v0, forces, d_step=0.001, max_steps=10000, handle='silent', da_strain_max=0.05, max_cycles=200, srate=0.0001, esig_v_min=1.0, k0_init=1, verbose=0,
cyc_lim_fail=True):
if k0_init != 1:
raise ValueError('Only supports k0=1')
max_steps_per_half_cycle = 50000
nodes = [
o3.node.Node(osi, 0.0, 0.0),
o3.node.Node(osi, 1.0, 0.0),
o3.node.Node(osi, 1.0, 1.0),
o3.node.Node(osi, 0.0, 1.0)
]
for node in nodes:
o3.Fix2DOF(osi, node, 1, 1)
mat = o3.nd_material.InitStressNDMaterial(osi, other=base_mat, init_stress=-esig_v0, n_dim=2)
ele = o3.element.SSPquad(osi, nodes, mat, 'PlaneStrain', 1, 0.0, 0.0)
# create analysis
o3.constraints.Penalty(osi, 1.0e15, 1.0e15)
o3.algorithm.Linear(osi)
o3.numberer.RCM(osi)
o3.system.FullGeneral(osi)
o3.analysis.Static(osi)
d_init = 0.0
d_max = 0.1 # element height is 1m
max_time = (d_max - d_init) / srate
ts0 = o3.time_series.Linear(osi, factor=1)
o3.pattern.Plain(osi, ts0)
o3.Load(osi, nodes[2], [1.0, 0.0])
o3.Load(osi, nodes[3], [1.0, 0.0])
o3.analyze(osi, 1)
o3.set_parameter(osi, value=1, eles=[ele], args=['materialState'])
o3.update_material_stage(osi, base_mat, 1)
o3.analyze(osi, 1)
exit_code = None
print('hhh')
# loop through the total number of cycles
react = 0
strain = [0]
stresses = o3.get_ele_response(osi, ele, 'stress')
stress = [stresses[2]]
v_eff = [stresses[1]]
h_eff = [stresses[0]]
diffs = np.diff(forces, prepend=0)
orys = np.where(diffs >= 0, 1, -1)
for i in range(len(forces)):
print('i: ', i, d_step)
ory = orys[i]
o3.integrator.DisplacementControl(osi, nodes[2], o3.cc.DOF2D_X, -d_step * ory)
o3.Load(osi, nodes[2], [ory * 1.0, 0.0])
o3.Load(osi, nodes[3], [ory * 1.0, 0.0])
for j in range(max_steps):
if react * ory < forces[i] * ory:
o3.analyze(osi, 1)
else:
print('reached!')
break
o3.gen_reactions(osi)
# react = o3.get_ele_response(osi, ele, 'force')[0]
stresses = o3.get_ele_response(osi, ele, 'stress')
# print(stresses)
tau = stresses[2]
print(tau, forces[i], ory)
react = -tau
v_eff.append(stresses[1])
h_eff.append(stresses[0])
stress.append(tau)
end_strain = -o3.get_node_disp(osi, nodes[2], dof=o3.cc.DOF2D_X)
strain.append(end_strain)
if j == max_steps - 1:
if handle == 'silent':
break
if handle == 'warn':
print(f'Target force not reached: force={react:.4g}, target: {forces[i]:.4g}')
else:
raise ValueError()
return np.array(stress), np.array(strain), np.array(v_eff), np.array(h_eff), exit_code
def run_2d_strain_driver(osi, mat, esig_v0, disps, target_d_inc=0.00001, handle='silent', verbose=0):
k0 = 1.0
pois = k0 / (1 + k0)
damp = 0.05
omega0 = 0.2
omega1 = 20.0
a1 = 2. * damp / (omega0 + omega1)
a0 = a1 * omega0 * omega1
# Establish nodes
h_ele = 1.
nodes = [
o3.node.Node(osi, 0.0, 0.0),
o3.node.Node(osi, h_ele, 0.0),
o3.node.Node(osi, h_ele, h_ele),
o3.node.Node(osi, 0.0, h_ele)
]
# Fix bottom node
o3.Fix2DOF(osi, nodes[0], o3.cc.FIXED, o3.cc.FIXED)
o3.Fix2DOF(osi, nodes[1], o3.cc.FIXED, o3.cc.FIXED)
o3.Fix2DOF(osi, nodes[2], o3.cc.FREE, o3.cc.FREE)
o3.Fix2DOF(osi, nodes[3], o3.cc.FREE, o3.cc.FREE)
# Set out-of-plane DOFs to be slaved
o3.EqualDOF(osi, nodes[2], nodes[3], [o3.cc.X, o3.cc.Y])
ele = o3.element.SSPquad(osi, nodes, mat, 'PlaneStrain', 1, 0.0, 0.0)
o3.constraints.Transformation(osi)
o3.test_check.NormDispIncr(osi, tol=1.0e-3, max_iter=35, p_flag=0)
o3.algorithm.Newton(osi)
o3.numberer.RCM(osi)
o3.system.FullGeneral(osi)
o3.integrator.DisplacementControl(osi, nodes[2], o3.cc.DOF2D_Y, 0.005)
# o3.rayleigh.Rayleigh(osi, a0, a1, 0.0, 0.0)
o3.analysis.Static(osi)
o3.update_material_stage(osi, mat, stage=0)
# Add static vertical pressure and stress bias
# time_series = o3.time_series.Path(osi, time=[0, 100, 1e10], values=[0, 1, 1])
# o3.pattern.Plain(osi, time_series)
ts0 = o3.time_series.Linear(osi, factor=1)
o3.pattern.Plain(osi, ts0)
o3.Load(osi, nodes[2], [0, -esig_v0 / 2])
o3.Load(osi, nodes[3], [0, -esig_v0 / 2])
o3.analyze(osi, num_inc=100)
stresses = o3.get_ele_response(osi, ele, 'stress')
print('init_stress0: ', stresses)
# ts2 = o3.time_series.Path(osi, time=[110, 80000, 1e10], values=[1., 1., 1.], factor=1)
# o3.pattern.Plain(osi, ts2, fact=1.)
# y_vert = o3.get_node_disp(osi, nodes[2], o3.cc.Y)
# o3.SP(osi, nodes[3], dof=o3.cc.Y, dof_values=[y_vert])
# o3.SP(osi, nodes[2], dof=o3.cc.Y, dof_values=[y_vert])
#
# o3.analyze(osi, 25, dt=1)
o3.wipe_analysis(osi)
o3.constraints.Transformation(osi)
o3.test_check.NormDispIncr(osi, tol=1.0e-6, max_iter=35, p_flag=0)
o3.algorithm.Newton(osi)
o3.numberer.RCM(osi)
o3.system.FullGeneral(osi)
o3.analysis.Static(osi)
o3.update_material_stage(osi, mat, stage=1)
o3.analyze(osi, 25, dt=1)
# o3.set_parameter(osi, value=sl.poissons_ratio, eles=[ele], args=['poissonRatio', 1])
# o3.extensions.to_py_file(osi)
stresses = o3.get_ele_response(osi, ele, 'stress')
print('init_stress1: ', stresses)
exit_code = None
strain = [0]
stresses = o3.get_ele_response(osi, ele, 'stress')
force0 = o3.get_node_reaction(osi, nodes[0], o3.cc.DOF2D_X)
force1 = o3.get_node_reaction(osi, nodes[1], o3.cc.DOF2D_X)
stress = [-force0 - force1]
v_eff = [stresses[1]]
h_eff = [stresses[0]]
d_incs = np.diff(disps, prepend=0)
for i in range(len(disps)):
d_inc_i = d_incs[i]
if target_d_inc < abs(d_inc_i):
n = int(abs(d_inc_i / target_d_inc))
d_step = d_inc_i / n
else:
n = 1
d_step = d_inc_i
for j in range(n):
o3.integrator.DisplacementControl(osi, nodes[2], o3.cc.DOF2D_X, -d_step)
o3.Load(osi, nodes[2], [1.0, 0.0])
o3.Load(osi, nodes[3], [1.0, 0.0])
o3.analyze(osi, 1)
o3.gen_reactions(osi)
stresses = o3.get_ele_response(osi, ele, 'stress')
print(stresses)
v_eff.append(stresses[1])
h_eff.append(stresses[0])
force0 = o3.get_node_reaction(osi, nodes[0], o3.cc.DOF2D_X)
force1 = o3.get_node_reaction(osi, nodes[1], o3.cc.DOF2D_X)
stress.append(-force0 - force1)
end_strain = o3.get_node_disp(osi, nodes[2], dof=o3.cc.DOF2D_X)
strain.append(end_strain)
return -np.array(stress), -np.array(strain), np.array(v_eff), np.array(h_eff), exit_code
