class FabricLayer(ReinfLayer):
"""Reinforcement with a grid structure
"""
name = 'Fabric layer'
width = Float(100, CS=True)
spacing = Float(14, CS=True)
A_roving = Float(1, CS=True)
A = tr.Property(Float, depends_on='+CS')
"""cross section area of reinforcement layers"""
@tr.cached_property
def _get_A(self):
return int(self.width / self.spacing) * self.A_roving
P = tr.Property(Float, depends_on='+CS')
"""cross section area of reinforcement layers"""
@tr.cached_property
def _get_P(self):
raise NotImplementedError
def _matmod_default(self):
return 'carbon'
ipw_view = View(
Item('matmod', latex=r'\mathrm{behavior}'),
Item('z', latex='z \mathrm{[mm]}'),
Item('width', latex='\mathrm{fabric~width} \mathrm{[mm]}'),
Item('spacing', latex='\mathrm{rov~spacing} \mathrm{[mm]}'),
Item('A_roving', latex='A_r \mathrm{[mm^2]}'),
Item('A', latex=r'A [mm^2]', readonly=True),
)
class TFBilinear(TimeFunction):
loading_ratio = Float(0.5, TIME=True)
time_ratio = Float(0.5, TIME=True)
ipw_view = View(
Item('t_max'),
Item('loading_ratio', editor=FloatRangeEditor(low=0, high=1)),
Item('time_ratio', editor=FloatRangeEditor(low=0, high=1)),
Item('range_factor'))
range_factor = Float(1)
def _generate_time_function(self):
# Define the monotonic range beyond the unit range
# allow for interactive extensions. The fact
d_history = np.array([
0, 1 * self.loading_ratio * self.range_factor,
1 * self.range_factor
])
t_arr = np.array([
0, self.t_max * self.time_ratio * self.range_factor,
self.t_max * self.range_factor
])
return interp1d(t_arr,
d_history,
bounds_error=False,
fill_value=self.t_max)
class MonotonicLoadingScenario(LoadingScenario):
n_incr = Int(10, BC=True)
maximum_loading = Float(1.0, BC=True,
enter_set=True, auto_set=False,
symbol='\phi_{\max}',
desc='load factor at maximum load level',
unit='-')
ipw_view = bu.View(
bu.Item("n_incr"),
bu.Item('maximum_loading'),
)
xy_arrays = Property(depends_on="state_changed")
@cached_property
def _get_xy_arrays(self):
t_arr = np.linspace(0, self.t_max, self.n_incr)
d_arr = np.linspace(0, self.maximum_loading, self.n_incr)
return t_arr, d_arr
def write_figure(self, f, rdir, rel_study_path):
print('FNAME', self.node_name)
fname = 'fig_' + self.node_name.replace(' ', '_') + '.pdf'
print('FNAME', fname)
self._update_xy_arrays()
f.write(r'''
\multicolumn{3}{r}{\includegraphics[width=5cm]{%s}}\\
''' % join(rel_study_path, fname))
self.savefig(join(rdir, fname))
class BarLayer(ReinfLayer):
""""Layer consisting of discrete bar reinforcement"""
name = 'Bar layer'
ds = Float(16, CS=True)
count = Int(1, CS=True)
A = tr.Property(Float, depends_on='+CS')
"""cross section area of reinforcement layers"""
@tr.cached_property
def _get_A(self):
return self.count * np.pi * (self.ds / 2.)**2
P = tr.Property(Float, depends_on='+CS')
"""permeter of reinforcement layers"""
@tr.cached_property
def _get_P(self):
return self.count * np.pi * (self.ds)
def _matmod_default(self):
return 'steel'
ipw_view = View(
Item('matmod', latex=r'\mathrm{behavior}'),
Item('z', latex=r'z \mathrm{[mm]}'),
Item('ds', latex=r'ds \mathrm{[mm]}'),
Item('count', latex='count'),
Item('A', latex=r'A [mm^2]'),
)
class CrossSectionShapeBase(InteractiveModel):
""""This class describes the geometry of the cross section."""
name = 'Cross Section Shape'
H = Float(400, GEO=True)
ipw_view = View(Item('H', minmax=(10, 3000), latex='H [mm]'))
class TimeFunction(Model):
name = 'time function'
t_max = Float(1.0, TIME=True)
t_shift = Float(0.0, TIME=True)
def __call__(self, arg):
return self.time_function(arg)
time_function = tr.Property(depends_on='state_changed')
@tr.cached_property
def _get_time_function(self):
return self._generate_time_function()
def update_plot(self, axes):
t_range = np.linspace(0, self.t_max, 500)
f_range = self.time_function(t_range)
axes.plot(t_range, f_range)
axes.set_xlabel(r'$t$ [-]')
axes.set_ylabel(r'$\theta$ [-]')
class TFMonotonic(TimeFunction):
ipw_view = View(Item('t_max'), Item('range_factor'))
range_factor = Float(10000)
def _generate_time_function(self):
# Define the monotonic range beyond the unit range
# allow for interactive extensions. The fact
d_history = np.array([0, 1 * self.range_factor])
t_arr = np.array([0, self.t_max * self.range_factor])
return interp1d(t_arr, d_history)
class ReinfLayer(InteractiveModel):
# TODO: changes in the ipw interactive window doesn't reflect on mkappa
# (maybe because these are lists and changing the elements doesn't notify)
name = 'Reinf layer'
cs_layout = tr.WeakRef
z = Float(50, CS=True)
"""z positions of reinforcement layers"""
P = Float(100, CS=True)
"""Perimeter"""
A = Float(100, CS=True)
"""Cross sectional area"""
matmod = EitherType(
options=[('steel', SteelReinfMatMod), ('carbon', CarbonReinfMatMod)])
ipw_view = View(
Item('matmod',
latex=r'\mathrm{behavior}',
editor=EitherTypeEditor(show_properties=False)),
Item('z', latex='z \mathrm{[mm]}'),
Item('A', latex='A \mathrm{[mm^2]}'),
)
tree = ['matmod']
def get_N(self, eps):
return self.A * self.matmod_.get_sig(eps)
def update_plot(self, ax):
eps_range = self.matmod_.get_eps_plot_range()
N_range = self.get_N(eps_range)
ax.plot(eps_range, N_range, color='red')
ax.fill_between(eps_range, N_range, 0, color='red', alpha=0.1)
ax.set_xlabel(r'$\varepsilon$ [-]')
ax.set_ylabel(r'$F$ [N]')
class MATS3DIfcElastic(MATSEval):
node_name = "Elastic interface"
E_n = Float(1e+6, tooltip='Normal stiffness of the interface [MPa]',
MAT=True, unit='MPa/m', symbol='E_\mathrm{n}',
desc='Normal stiffness of the interface',
auto_set=False, enter_set=True)
E_s = Float(1.0, tooltip='Shear stiffness of the interface [MPa]',
MAT=True, unit='MPa/m', symbol='E_\mathrm{s}',
desc='Shear-modulus of the interface',
auto_set=True, enter_set=True)
state_var_shapes = {}
D_rs = Property(depends_on='E_n,E_s')
@cached_property
def _get_D_rs(self):
return np.array([[self.E_n, 0, 0],
[0, self.E_s, 0],
[0, 0, self.E_s]], dtype=np.float_)
def get_corr_pred(self, u_r, tn1):
tau = np.einsum(
'rs,...s->...r',
self.D_rs, u_r)
grid_shape = tuple([1 for _ in range(len(u_r.shape[:-1]))])
D = self.D_rs.reshape(grid_shape + self.D_rs.shape)
return tau, D
ipw_view = View(
Item('E_s'),
Item('E_n')
)
class TFCyclicSin(TimeFunction):
number_of_cycles = Int(10, TIME=True)
phase_shift = Float(0, TIME=True)
ipw_view = View(Item('number_of_cycles'), Item('phase_shift'),
Item('t_max'))
def _generate_time_function(self):
t = sp.symbols(r't')
p = self.phase_shift
tf = sp.sin(2 * self.number_of_cycles * sp.pi * t / self.t_max)
if p > 0:
T = self.t_max / self.number_of_cycles
pT = p * T
tf = sp.Piecewise((0, t < pT), (tf.subs(t, t - pT), True))
return sp.lambdify(t, tf, 'numpy')
class LoadingScenario(MFnLineArray, BMCSLeafNode, RInputRecord):
"""Loading scenario.
"""
def reset(self):
return
node_name = Str('loading scenario')
t_max = Float(1.)
xdata = Property
def _get_xdata(self):
return self.xy_arrays[0]
ydata = Property
def _get_ydata(self):
return self.xy_arrays[1]
def update_plot(self, axes):
axes.plot(self.xdata, self.ydata)
axes.fill_between(self.xdata, self.ydata, 0, alpha=0.1)
class Rectangle(CrossSectionShapeBase):
B = Float(200, GEO=True)
ipw_view = View(
*CrossSectionShapeBase.ipw_view.
content, # this will add View Items of the base class CrossSectionShapeBase
Item('B', minmax=(10, 500), latex='B \mathrm{[mm]}'))
def get_cs_area(self):
return self.B * self.H
def get_cs_i(self):
return self.B * self.H**3 / 12
def get_b(self, z_positions_array):
return np.full_like(z_positions_array, self.B)
def update_plot(self, ax):
ax.fill(
[-self.B / 2, self.B / 2, self.B / 2, -self.B / 2, -self.B / 2],
[0, 0, self.H, self.H, 0],
color='gray',
alpha=0.2)
ax.plot(
[-self.B / 2, self.B / 2, self.B / 2, -self.B / 2, -self.B / 2],
[0, 0, self.H, self.H, 0],
color='black')
ax.autoscale_view()
ax.set_aspect('equal')
ax.annotate('Area = {} $mm^2$'.format(int(Rectangle.get_cs_area(self)),
0),
xy=(-self.H / 2 * 0.8, self.H / 2),
color='blue')
ax.annotate('I = {} $mm^4$'.format(int(Rectangle.get_cs_i(self)), 0),
xy=(-self.H / 2 * 0.8, self.H / 2 * 0.8),
color='blue')
class TFCyclicNonsymmetricConstant(TimeFunction):
number_of_cycles = Int(10, TIME=True)
unloading_ratio = Float(0.5, TIME=True)
shift_cycles = Int(0, TIME=True)
ipw_view = View(
Item('number_of_cycles'), Item('shift_cycles'),
Item('unloading_ratio', editor=FloatRangeEditor(low=0, high=1)),
Item('t_max'))
def _generate_time_function(self):
d_1 = np.zeros(1)
d_2 = np.zeros(((self.number_of_cycles + self.shift_cycles) * 2, ))
d_2.reshape(-1, 2)[self.shift_cycles:, 0] = 1
d_2.reshape(-1, 2)[self.shift_cycles:, 1] = self.unloading_ratio
d_history = d_2.flatten()
d_arr = np.hstack((d_1, d_history))
t_arr = np.linspace(0, self.t_max, len(d_arr))
return interp1d(t_arr,
d_arr,
bounds_error=False,
fill_value=self.t_max)
class Circle(CrossSectionShapeBase):
# TODO->Rostia: provide input field instead minmax range
# H from the base class is used as the D, for the diameter of the circular section
H = Float(250, GEO=True)
ipw_view = View(Item('H', minmax=(10, 3000), latex='D [mm]'), )
def get_cs_area(self):
return np.pi * self.H * self.H
def get_cs_i(self):
return np.pi * self.H**4 / 4
def get_b(self, z_positions_array):
return np.full_like(z_positions_array, self.H)
# TODO->Saeed: complete this
def update_plot(self, ax):
# TODO->Saeed: fix this
circle = MPL_Circle((0, self.H / 2),
self.H / 2,
facecolor=(.5, .5, .5, 0.2),
edgecolor=(0, 0, 0, 1))
ax.add_patch(circle)
ax.autoscale_view()
ax.set_aspect('equal')
ax.annotate('Area = {} $mm^2$'.format(int(self.get_cs_area()), 0),
xy=(-self.H / 2 * 0.8, self.H / 2),
color='blue')
ax.annotate('I = {} $mm^4$'.format(int(self.get_cs_i()), 0),
xy=(-self.H / 2 * 0.8, self.H / 2 * 0.8),
color='blue')
class VDNTIM(MATS3DEval):
"""
Vectorized uncoupled normal tngential interface model
"""
# -------------------------------------------------------------------------
# Elasticity
# -------------------------------------------------------------------------
name = 'equiv damage NTIM'
E_N = Float(10000, MAT=True)
E_T = Float(1000, MAT=True)
epsilon_0 = Float(59.0e-6, MAT=True,
label="a",
desc="Lateral pressure coefficient",
enter_set=True,
auto_set=False)
epsilon_f = Float(250.0e-6, MAT=True,
label="a",
desc="Lateral pressure coefficient",
enter_set=True,
auto_set=False)
c_T = Float(0.01, MAT=True,
label="a",
desc="Lateral pressure coefficient",
enter_set=True,
auto_set=False)
ipw_view = View(
Item('E_T', readonly=True),
Item('E_N', readonly=True),
Item('epsilon_0'),
Item('epsilon_f'),
Item('c_T'),
Item('eps_max'),
Item('n_eps')
)
n_D = 3
state_var_shapes = dict(
kappa=(),
omega_N=(),
omega_T=()
)
def get_e_equiv(self, eps_N, eps_T):
r"""
Returns a list of the microplane equivalent strains
based on the list of microplane strain vectors
"""
# positive part of the normal strain magnitude for each microplane
e_N_pos = (np.abs(eps_N) + eps_N) / 2.0
# tangent strain ratio
c_T = self.c_T
# equivalent strain for each microplane
eps_equiv = np.sqrt(e_N_pos * e_N_pos + c_T * eps_T)
return eps_equiv
def get_normal_law(self, eps_N, eps_T_a, kappa, omega_N, omega_T):
E_N = self.E_N
E_T = self.E_T
eps_T = np.sqrt(np.einsum('...a,...a->...', eps_T_a, eps_T_a))
eps_equiv = self.get_e_equiv(eps_N, eps_T)
kappa[...] = np.max(np.array([kappa, eps_equiv]), axis=0)
epsilon_0 = self.epsilon_0
epsilon_f = self.epsilon_f
I = np.where(kappa >= epsilon_0)
omega_N[I] = (
1.0 - (epsilon_0 / kappa[I] *
np.exp(-1.0 * (kappa[I] - epsilon_0) / (epsilon_f - epsilon_0))
)
)
sig_N = (1 - omega_N) * E_N * eps_N
sig_T_a = (1 - omega_N[..., np.newaxis]) * E_T * eps_T_a
sig_a = np.concatenate([sig_N[...,np.newaxis], sig_T_a], axis=-1)
return sig_a
def get_corr_pred(self, eps_a, t_n1, **Eps):
eps_a_ = np.einsum('...a->a...',eps_a)
eps_N = eps_a_[0,...]
eps_T_a = np.einsum('a...->...a', eps_a_[1:,...])
sig_a = self.get_normal_law(eps_N, eps_T_a, **Eps)
D_ = np.zeros(eps_a.shape + (eps_a.shape[-1],))
D_[..., 0, 0] = self.E_N# * (1 - omega_N)
D_[..., 1, 1] = self.E_T# * (1 - omega_T)
D_[..., 2, 2] = self.E_T# * (1 - omega_T)
D_[..., 3, 3] = self.E_T# * (1 - omega_T)
return sig_a, D_
def get_eps_NT_p(self, **Eps):
"""Plastic strain tensor
"""
return None
def plot_idx(self, ax_sig, ax_d_sig, idx=0):
eps_max = self.eps_max
n_eps = self.n_eps
eps1_range = np.linspace(1e-9,eps_max,n_eps)
Eps = { var : np.zeros( (1,) + shape )
for var, shape in self.state_var_shapes.items()
}
eps_range = np.zeros((n_eps, 4))
eps_range[:,idx] = eps1_range
# monotonic load in the normal direction
sig1_range, d_sig11_range = [], []
for eps_a in eps_range:
sig_a, D_range = self.get_corr_pred(eps_a[np.newaxis, ...], 1, **Eps)
sig1_range.append(sig_a[0, idx])
d_sig11_range.append(D_range[0, idx, idx])
sig1_range = np.array(sig1_range, dtype=np.float_)
eps1_range = eps1_range[:len(sig1_range)]
ax_sig.plot(eps1_range, sig1_range,color='blue')
d_sig11_range = np.array(d_sig11_range, dtype=np.float_)
ax_d_sig.plot(eps1_range, d_sig11_range, linestyle='dashed', color='gray')
ax_sig.set_xlabel(r'$\varepsilon_{11}$ [-]')
ax_sig.set_ylabel(r'$\sigma_{11}$ [MPa]')
ax_d_sig.set_ylabel(r'$\mathrm{d} \sigma_{11} / \mathrm{d} \varepsilon_{11}$ [MPa]')
ax_d_sig.plot(eps1_range[:-1],
(sig1_range[:-1]-sig1_range[1:])/(eps1_range[:-1]-eps1_range[1:]),
color='orange', linestyle='dashed')
def subplots(self, fig):
ax_sig_N, ax_sig_T = fig.subplots(1,2)
ax_d_sig_N = ax_sig_N.twinx()
ax_d_sig_T = ax_sig_T.twinx()
return ax_sig_N, ax_d_sig_N, ax_sig_T, ax_d_sig_T
def update_plot(self, axes):
ax_sig_N, ax_d_sig_N, ax_sig_T, ax_d_sig_T = axes
self.plot_idx(ax_sig_N, ax_d_sig_N, 0)
self.plot_idx(ax_sig_T, ax_d_sig_T, 1)
class MKappa(InteractiveModel, InjectSymbExpr):
"""Class returning the moment curvature relationship."""
name = 'Moment-Curvature'
symb_class = MKappaSymbolic
cs_design = Instance(CrossSectionDesign, ())
tree = ['cs_design']
# Use PrototypedFrom only when the prototyped object is a class
# (The prototyped attribute behaves similarly
# to a delegated attribute, until it is explicitly
# changed; from that point forward, the prototyped attribute
# changes independently from its prototype.)
# (it's kind of like tr.DelegatesTo('cs_design.cross_section_shape'))
cross_section_shape = tr.DelegatesTo('cs_design')
cross_section_shape_ = tr.DelegatesTo('cs_design')
cross_section_layout = tr.DelegatesTo('cs_design')
matrix_ = tr.DelegatesTo('cs_design')
# Geometry
H = tr.DelegatesTo('cross_section_shape_')
DEPSTR = 'state_changed'
n_m = Int(
100,
DSC=True,
desc=
'Number of discretization points along the height of the cross-section'
)
# @todo: fix the dependency - `H` should be replaced by _GEO
z_m = tr.Property(depends_on=DEPSTR)
@tr.cached_property
def _get_z_m(self):
return np.linspace(0, self.H, self.n_m)
low_kappa = Float(0.0, BC=True, GEO=True)
high_kappa = Float(0.00002, BC=True, GEO=True)
n_kappa = Int(100, BC=True)
step_kappa = tr.Property(Float, depends_on='low_kappa, high_kappa')
@tr.cached_property
def _get_step_kappa(self):
return float((self.high_kappa - self.low_kappa) / self.n_kappa)
kappa_slider = Float(0.0000001)
ipw_view = View(
Item(
'low_kappa',
latex=r'\text{Low}~\kappa'), #, editor=FloatEditor(step=0.00001)),
Item('high_kappa', latex=r'\text{High}~\kappa'
), # , editor=FloatEditor(step=0.00001)),
Item('n_kappa', latex='n_{\kappa}'),
Item('plot_strain'),
Item('solve_for_eps_bot_pointwise'),
Item('n_m', latex='n_m'),
Item('kappa_slider', latex='\kappa', readonly=True),
# editor=FloatRangeEditor(low_name='low_kappa',
# high_name='high_kappa',
# n_steps_name='n_kappa')
# ),
time_editor=HistoryEditor(
var='kappa_slider',
min_var='low_kappa',
max_var='high_kappa',
),
)
idx = tr.Property(depends_on='kappa_slider')
apply_material_safety_factors = tr.Bool(False)
@tr.cached_property
def _get_idx(self):
ks = self.kappa_slider
idx = np.argmax(ks <= self.kappa_t)
return idx
kappa_t = tr.Property(tr.Array(np.float_), depends_on=DEPSTR)
'''Curvature values for which the bending moment must be found
'''
@tr.cached_property
def _get_kappa_t(self):
return np.linspace(self.low_kappa, self.high_kappa, self.n_kappa)
z_j = tr.Property
def _get_z_j(self):
return self.cross_section_layout.z_j
A_j = tr.Property
def _get_A_j(self):
return self.cross_section_layout.A_j
# Normal force in steel (tension and compression)
def get_N_s_tj(self, kappa_t, eps_bot_t):
# get the strain at the height of the reinforcement
eps_z_tj = self.symb.get_eps_z(kappa_t[:, np.newaxis],
eps_bot_t[:, np.newaxis],
self.z_j[np.newaxis, :])
# Get the crack bridging force in each reinforcement layer
# given the corresponding crack-bridge law.
N_s_tj = self.cross_section_layout.get_N_tj(eps_z_tj)
return N_s_tj
# TODO - [RC] avoid repeated evaluations of stress profile in
# N and M calculations for the same inputs as it
# is the case now.
def get_sig_c_z(self, kappa_t, eps_bot_t, z_tm):
"""Get the stress profile over the height"""
eps_z = self.symb.get_eps_z(kappa_t[:, np.newaxis],
eps_bot_t[:, np.newaxis], z_tm)
sig_c_z = self.matrix_.get_sig(eps_z)
return sig_c_z
# Normal force in concrete (tension and compression)
def get_N_c_t(self, kappa_t, eps_bot_t):
z_tm = self.z_m[np.newaxis, :]
b_z_m = self.cross_section_shape_.get_b(z_tm)
N_z_tm2 = b_z_m * self.get_sig_c_z(kappa_t, eps_bot_t, z_tm)
return np.trapz(N_z_tm2, x=z_tm, axis=-1)
def get_N_t(self, kappa_t, eps_bot_t):
N_s_t = np.sum(self.get_N_s_tj(kappa_t, eps_bot_t), axis=-1)
N_c_t = self.get_N_c_t(kappa_t, eps_bot_t)
return N_c_t + N_s_t
# SOLVER: Get eps_bot to render zero force
# num_of_trials = tr.Int(30)
eps_bot_t = tr.Property(depends_on=DEPSTR)
r'''Resolve the tensile strain to get zero normal force for the prescribed curvature'''
# @tr.cached_property
# def _get_eps_bot_t(self):
# initial_step = (self.high_kappa - self.low_kappa) / self.num_of_trials
# for i in range(self.num_of_trials):
# print('Solution started...')
# res = root(lambda eps_bot_t: self.get_N_t(self.kappa_t, eps_bot_t),
# 0.0000001 + np.zeros_like(self.kappa_t), tol=1e-6)
# if res.success:
# print('success high_kappa: ', self.high_kappa)
# if i == 0:
# print('Note: high_kappa success from 1st try! selecting a higher value for high_kappa may produce '
# 'a more reliable result!')
# return res.x
# else:
# print('failed high_kappa: ', self.high_kappa)
# self.high_kappa -= initial_step
# self.kappa_t = np.linspace(self.low_kappa, self.high_kappa, self.n_kappa)
#
# print('No solution', res.message)
# return res.x
# @tr.cached_property
# def _get_eps_bot_t(self):
# res = root(lambda eps_bot_t: self.get_N_t(self.kappa_t, eps_bot_t),
# 0.0000001 + np.zeros_like(self.kappa_t), tol=1e-6)
# if not res.success:
# raise SolutionNotFoundError('No solution', res.message)
# return res.x
solve_for_eps_bot_pointwise = Bool(True, BC=True, GEO=True)
@tr.cached_property
def _get_eps_bot_t(self):
if self.solve_for_eps_bot_pointwise:
""" INFO: Instability in eps_bot solutions was caused by unsuitable init_guess value causing a convergence
to non-desired solutions. Solving the whole kappa_t array improved the init_guess after each
calculated value, however, instability still there. The best results were obtained by taking the last
solution as the init_guess for the next solution like in the following.. """
# One by one solution for kappa values
eps_bot_sol_for_pos_kappa = self._get_eps_bot_piecewise_sol(
kappa_pos=True)
eps_bot_sol_for_neg_kappa = self._get_eps_bot_piecewise_sol(
kappa_pos=False)
res = np.concatenate(
[eps_bot_sol_for_neg_kappa, eps_bot_sol_for_pos_kappa])
return res
else:
# Array solution for the whole kappa_t
res = root(lambda eps_bot_t: self.get_N_t(self.kappa_t, eps_bot_t),
0.0000001 + np.zeros_like(self.kappa_t),
tol=1e-6)
if not res.success:
print('No solution', res.message)
return res.x
def _get_eps_bot_piecewise_sol(self, kappa_pos=True):
if kappa_pos:
kappas = self.kappa_t[np.where(self.kappa_t >= 0)]
else:
kappas = self.kappa_t[np.where(self.kappa_t < 0)]
res = []
if kappa_pos:
init_guess = 0.00001
kappa_loop_list = kappas
else:
init_guess = -0.00001
kappa_loop_list = reversed(kappas)
for kappa in kappa_loop_list:
sol = root(
lambda eps_bot: self.get_N_t(np.array([kappa]), eps_bot),
np.array([init_guess]),
tol=1e-6).x[0]
# This condition is to avoid having init_guess~0 which causes non-convergence
if abs(sol) > 1e-5:
init_guess = sol
res.append(sol)
if kappa_pos:
return res
else:
return list(reversed(res))
# POSTPROCESSING
kappa_cr = tr.Property(depends_on=DEPSTR)
'''Curvature at which a critical strain is attained at the eps_bot'''
@tr.cached_property
def _get_kappa_cr(self):
res = root(lambda kappa: self.get_N_t(kappa, self.eps_cr),
0.0000001 + np.zeros_like(self.eps_cr),
tol=1e-10)
if not res.success:
print('No kappa_cr solution (for plot_norm() function)',
res.message)
return res.x
M_s_t = tr.Property(depends_on=DEPSTR)
'''Bending moment (steel)
'''
@tr.cached_property
def _get_M_s_t(self):
if len(self.z_j) == 0:
return np.zeros_like(self.kappa_t)
eps_z_tj = self.symb.get_eps_z(self.kappa_t[:, np.newaxis],
self.eps_bot_t[:, np.newaxis],
self.z_j[np.newaxis, :])
# Get the crack bridging force in each reinforcement layer
# given the corresponding crack-bridge law.
N_tj = self.cross_section_layout.get_N_tj(eps_z_tj)
return -np.einsum('tj,j->t', N_tj, self.z_j)
M_c_t = tr.Property(depends_on=DEPSTR)
'''Bending moment (concrete)
'''
@tr.cached_property
def _get_M_c_t(self):
z_tm = self.z_m[np.newaxis, :]
b_z_m = self.cross_section_shape_.get_b(z_tm)
N_z_tm2 = b_z_m * self.get_sig_c_z(self.kappa_t, self.eps_bot_t, z_tm)
return -np.trapz(N_z_tm2 * z_tm, x=z_tm, axis=-1)
M_t = tr.Property(depends_on=DEPSTR)
'''Bending moment
'''
@tr.cached_property
def _get_M_t(self):
# print('M - k recalculated')
eta_factor = 1.
return eta_factor * (self.M_c_t + self.M_s_t)
# @tr.cached_property
# def _get_M_t(self):
# initial_step = (self.high_kappa - self.low_kappa) / self.num_of_trials
# for i in range(self.num_of_trials):
# try:
# M_t = self.M_c_t + self.M_s_t
# except SolutionNotFoundError:
# print('failed high_kappa: ', self.high_kappa)
# self.high_kappa -= initial_step
# else:
# # This will run when no exception has been received
# print('success high_kappa: ', self.high_kappa)
# if i == 0:
# print('Note: high_kappa success from 1st try! selecting a higher value for high_kappa may produce '
# 'a more reliable result!')
# return M_t
# print('No solution has been found!')
# return M_t
N_s_tj = tr.Property(depends_on=DEPSTR)
'''Normal forces (steel)
'''
@tr.cached_property
def _get_N_s_tj(self):
return self.get_N_s_tj(self.kappa_t, self.eps_bot_t)
eps_tm = tr.Property(depends_on=DEPSTR)
'''strain profiles
'''
@tr.cached_property
def _get_eps_tm(self):
return self.symb.get_eps_z(self.kappa_t[:, np.newaxis],
self.eps_bot_t[:, np.newaxis],
self.z_m[np.newaxis, :])
sig_tm = tr.Property(depends_on=DEPSTR)
'''strain profiles
'''
@tr.cached_property
def _get_sig_tm(self):
return self.get_sig_c_z(self.kappa_t, self.eps_bot_t,
self.z_m[np.newaxis, :])
M_norm = tr.Property(depends_on=DEPSTR)
'''
'''
@tr.cached_property
def _get_M_norm(self):
# Section modulus @TODO optimize W for var b
W = (self.b * self.H**2) / 6
sig_cr = self.E_ct * self.eps_cr
return W * sig_cr
kappa_norm = tr.Property()
def _get_kappa_norm(self):
return self.kappa_cr
inv_M_kappa = tr.Property(depends_on=DEPSTR)
'''Return the inverted data points
'''
@tr.cached_property
def _get_inv_M_kappa(self):
try:
"""cut off the descending tails"""
M_t = self.M_t
I_max = np.argmax(M_t)
I_min = np.argmin(M_t)
M_I = np.copy(M_t[I_min:I_max + 1])
kappa_I = np.copy(self.kappa_t[I_min:I_max + 1])
# find the index corresponding to zero kappa
idx = np.argmax(0 <= kappa_I)
# and modify the values such that the
# Values of moment are non-descending
M_plus = M_I[idx:]
M_diff = M_plus[:, np.newaxis] - M_plus[np.newaxis, :]
n_ij = len(M_plus)
ij = np.mgrid[0:n_ij:1, 0:n_ij:1]
M_diff[np.where(ij[1] >= ij[0])] = 0
i_x = np.argmin(M_diff, axis=1)
M_I[idx:] = M_plus[i_x]
return M_I, kappa_I
except ValueError:
print(
'M inverse has not succeeded, the M-Kappa solution may have failed due to '
'a wrong kappa range or not suitable material law!')
return np.array([0]), np.array([0])
def get_kappa_M(self, M):
M_I, kappa_I = self.inv_M_kappa
return np.interp(M, M_I, kappa_I)
def plot_norm(self, ax1, ax2):
idx = self.idx
ax1.plot(self.kappa_t / self.kappa_norm, self.M_t / self.M_norm)
ax1.plot(self.kappa_t[idx] / self.kappa_norm,
self.M_t[idx] / self.M_norm,
marker='o')
ax2.barh(self.z_j,
self.N_s_tj[idx, :],
height=2,
color='red',
align='center')
# ax2.fill_between(eps_z_arr[idx,:], z_arr, 0, alpha=0.1);
ax3 = ax2.twiny()
# ax3.plot(self.eps_tm[idx, :], self.z_m, color='k', linewidth=0.8)
ax3.plot(self.sig_tm[idx, :], self.z_m)
ax3.axvline(0, linewidth=0.8, color='k')
ax3.fill_betweenx(self.z_m, self.sig_tm[idx, :], 0, alpha=0.1)
mpl_align_xaxis(ax2, ax3)
M_scale = Float(1e+6)
plot_strain = Bool(False)
def plot(self, ax1, ax2, ax3):
self.plot_mk_and_stress_profile(ax1, ax2)
if self.plot_strain:
self.plot_strain_profile(ax3)
else:
self.plot_mk_inv(ax3)
@staticmethod
def subplots(fig):
ax1, ax2, ax3 = fig.subplots(1, 3)
return ax1, ax2, ax3
def update_plot(self, axes):
self.plot(*axes)
def plot_mk_inv(self, ax3):
try:
M, kappa = self.inv_M_kappa
ax3.plot(M / self.M_scale, kappa)
except ValueError:
print(
'M inverse has not succeeded, the M-Kappa solution may have failed due to a wrong kappa range!'
)
ax3.set_xlabel('Moment [kNm]')
ax3.set_ylabel('Curvature[mm$^{-1}$]')
def plot_mk_and_stress_profile(self, ax1, ax2):
self.plot_mk(ax1)
idx = self.idx
ax1.plot(self.kappa_t[idx],
self.M_t[idx] / self.M_scale,
color='orange',
marker='o')
if len(self.z_j):
ax2.barh(self.z_j,
self.N_s_tj[idx, :] / self.A_j,
height=4,
color='red',
align='center')
ax2.set_ylabel('z [mm]')
ax2.set_xlabel('$\sigma_r$ [MPa]')
ax22 = ax2.twiny()
ax22.set_xlabel('$\sigma_c$ [MPa]')
ax22.plot(self.sig_tm[idx, :], self.z_m)
ax22.axvline(0, linewidth=0.8, color='k')
ax22.fill_betweenx(self.z_m, self.sig_tm[idx, :], 0, alpha=0.1)
mpl_align_xaxis(ax2, ax22)
def plot_mk(self, ax1):
ax1.plot(self.kappa_t, self.M_t / self.M_scale, label='M-K')
ax1.set_ylabel('Moment [kNm]')
ax1.set_xlabel('Curvature [mm$^{-1}$]')
ax1.legend()
def plot_strain_profile(self, ax):
ax.set_ylabel('z [mm]')
ax.set_xlabel(r'$\varepsilon$ [-]')
ax.plot(self.eps_tm[self.idx, :], self.z_m)
ax.axvline(0, linewidth=0.8, color='k')
ax.fill_betweenx(self.z_m, self.eps_tm[self.idx, :], 0, alpha=0.1)
def get_mk(self):
return self.M_t / self.M_scale, self.kappa_t
class IShape(CrossSectionShapeBase):
H = Float(900, GEO=True)
B_w = Float(50, GEO=True)
B_f_bot = Float(200, GEO=True)
B_f_top = Float(200, GEO=True)
H_f_bot = Float(145, GEO=True)
H_f_top = Float(145, GEO=True)
ipw_view = View(
*CrossSectionShapeBase.ipw_view.content,
Item('B_w', minmax=(10, 3000), latex=r'B_w \mathrm{[mm]}'),
Item('B_f_bot', minmax=(10, 3000), latex=r'B_{f_{bot}} \mathrm{[mm]}'),
Item('B_f_top', minmax=(10, 3000), latex=r'B_{f_{top}} \mathrm{[mm]}'),
Item('H_f_bot', minmax=(10, 3000), latex=r'H_{f_{bot}} \mathrm{[mm]}'),
Item('H_f_top', minmax=(10, 3000), latex=r'H_{f_{top}} \mathrm{[mm]}'),
)
def get_cs_area(self):
return self.B_f_bot * self.H_f_bot + self.B_f_top * self.H_f_top + self.B_w * (
self.H - self.H_f_top - self.H_f_bot)
def get_cs_i(self):
pass
get_b = tr.Property(tr.Callable, depends_on='+input')
@tr.cached_property
def _get_get_b(self):
z_ = sp.Symbol('z')
b_p = sp.Piecewise((self.B_f_bot, z_ < self.H_f_bot),
(self.B_w, z_ < self.H - self.H_f_top),
(self.B_f_top, True))
return sp.lambdify(z_, b_p, 'numpy')
def update_plot(self, ax):
# Start drawing from bottom center of the cross section
cs_points = np.array([[self.B_f_bot / 2, 0],
[self.B_f_bot / 2, self.H_f_bot],
[self.B_w / 2, self.H_f_bot],
[self.B_w / 2, self.H - self.H_f_top],
[self.B_f_top / 2, self.H - self.H_f_top],
[self.B_f_top / 2, self.H],
[-self.B_f_top / 2, self.H],
[-self.B_f_top / 2, self.H - self.H_f_top],
[-self.B_w / 2, self.H - self.H_f_top],
[-self.B_w / 2, self.H_f_bot],
[-self.B_f_bot / 2, self.H_f_bot],
[-self.B_f_bot / 2, 0]])
cs = Polygon(cs_points)
patch_collection = PatchCollection([cs],
facecolor=(.5, .5, .5, 0.2),
edgecolors=(0, 0, 0, 1))
ax.add_collection(patch_collection)
# ax.scatter(0, TShape.get_cs_i(self)[0], color='white', s=self.B_w, marker="+")
ax.autoscale_view()
ax.set_aspect('equal')
ax.annotate('Area = {} $mm^2$'.format(int(IShape.get_cs_area(self)),
0),
xy=(0, self.H / 2),
color='blue')
class TShape(CrossSectionShapeBase):
B_f = Float(400, GEO=True)
B_w = Float(100, GEO=True)
H_w = Float(300, GEO=True)
ipw_view = View(
*CrossSectionShapeBase.ipw_view.content,
Item('B_f', minmax=(10, 3000), latex=r'B_f \mathrm{[mm]}'),
Item('B_w', minmax=(10, 3000), latex=r'B_w \mathrm{[mm]}'),
Item('H_w', minmax=(10, 3000), latex=r'H_w \mathrm{[mm]}'),
)
def get_cs_area(self):
return self.B_w * self.H_w + self.B_f * (self.H - self.H_w)
def get_cs_i(self):
A_f = self.B_f * (self.H - self.H_w)
Y_f = (self.H - self.H_w) / 2 + self.H_w
I_f = self.B_f * (self.H - self.H_w)**3 / 12
A_w = self.B_w * self.H_w
Y_w = self.H_w / 2
I_w = self.B_w * self.H_w**3 / 12
Y_c = (Y_f * A_f + Y_w * A_w) / (A_f + A_w)
I_c = I_f + A_f * (Y_c - Y_f)**2 + I_w + A_w * (Y_c - Y_w)**2
return Y_c, I_c
get_b = tr.Property(tr.Callable, depends_on='+input')
@tr.cached_property
def _get_get_b(self):
z_ = sp.Symbol('z')
b_p = sp.Piecewise((self.B_w, z_ < self.H_w), (self.B_f, True))
return sp.lambdify(z_, b_p, 'numpy')
def update_plot(self, ax):
# Start drawing from bottom center of the cross section
cs_points = np.array([[self.B_w / 2, 0], [self.B_w / 2, self.H_w],
[self.B_f / 2, self.H_w], [self.B_f / 2, self.H],
[-self.B_f / 2, self.H],
[-self.B_f / 2, self.H_w],
[-self.B_w / 2, self.H_w], [-self.B_w / 2, 0]])
cs = Polygon(cs_points)
patch_collection = PatchCollection([cs],
facecolor=(.5, .5, .5, 0.2),
edgecolors=(0, 0, 0, 1))
ax.add_collection(patch_collection)
ax.scatter(0,
TShape.get_cs_i(self)[0],
color='white',
s=self.B_w,
marker="+")
ax.autoscale_view()
ax.set_aspect('equal')
ax.annotate('Area = {} $mm^2$'.format(int(TShape.get_cs_area(self)),
0),
xy=(-self.H / 2 * 0.8, (self.H / 2 + self.H_w / 2)),
color='blue')
ax.annotate('I = {} $mm^4$'.format(int(TShape.get_cs_i(self)[1]), 0),
xy=(-self.H / 2 * 0.8, (self.H / 2 + self.H_w / 2) * 0.9),
color='blue')
ax.annotate('$Y_c$',
xy=(0, TShape.get_cs_i(self)[0] * 0.85),
color='purple')
class MATS2DScalarDamage(MATS2DEval):
r'''Isotropic damage model.
'''
name = 'isotropic damage model'
node_name = 'isotropic damage model'
tree = ['omega_fn','strain_norm']
omega_fn = EitherType(
options=[('exp-slope', ExpSlopeDamageFn),
('linear', LinearDamageFn),
('abaqus', AbaqusDamageFn),
('fracture-energy', GfDamageFn),
('weibull-CDF', WeibullDamageFn),
],
MAT=True,
on_option_change='link_omega_to_mats'
)
D_alg = Float(0)
r'''Selector of the stiffness calculation.
'''
eps_max = Float(0.03, ALG=True)
# upon change of the type attribute set the link to the material model
def link_omega_to_mats(self):
self.omega_fn_.trait_set(mats=self,
E_name='E',
x_max_name='eps_max')
#=========================================================================
# Material model
#=========================================================================
strain_norm = EitherType(
options=[('Rankine', SN2DRankine),
('Masars', SN2DMasars),
('Energy', SN2DEnergy)],
on_option_change='link_strain_norm_to_mats'
)
def link_strain_norm_to_mats(self):
self.strain_norm_.trait_set(mats=self)
state_var_shapes = {'kappa': (),
'omega': ()}
r'''
Shapes of the state variables
to be stored in the global array at the level
of the domain.
'''
def get_corr_pred(self, eps_ab_n1, tn1, kappa, omega):
r'''
Corrector predictor computation.
@param eps_app_eng input variable - engineering strain
'''
eps_eq = self.strain_norm_.get_eps_eq(eps_ab_n1, kappa)
I = self.omega_fn_.get_f_trial(eps_eq, kappa)
eps_eq_I = eps_eq[I]
kappa[I] = eps_eq_I
omega[I] = self._omega(eps_eq_I)
phi = (1.0 - omega)
D_abcd = np.einsum(
'...,abcd->...abcd',
phi, self.D_abcd
)
sig_ab = np.einsum(
'...abcd,...cd->...ab',
D_abcd, eps_ab_n1
)
if self.D_alg > 0:
domega_ds_I = self._omega_derivative(eps_eq_I)
deps_eq_I = self.strain_norm_.get_deps_eq(eps_ab_n1[I])
D_red_I = np.einsum('...,...ef,cdef,...ef->...cdef', domega_ds_I,
deps_eq_I, self.D_abcd, eps_ab_n1[I]) * self.D_alg
D_abcd[I] -= D_red_I
return sig_ab, D_abcd
def _omega(self, kappa):
return self.omega_fn_(kappa)
def _omega_derivative(self, kappa):
return self.omega_fn_.diff(kappa)
ipw_view = View(
Item('E'),
Item('nu'),
Item('strain_norm'),
Item('omega_fn'),
Item('stress_state'),
Item('D_alg', latex=r'\theta_\mathrm{alg. stiff.}',
editor=FloatRangeEditor(low=0,high=1)),
Item('eps_max'),
Item('G_f', latex=r'G_\mathrm{f}^{\mathrm{estimate}}', readonly=True),
)
G_f = tr.Property(Float, depends_on='state_changed')
@tr.cached_property
def _get_G_f(self):
eps_max = self.eps_max
n_eps = 1000
eps11_range = np.linspace(1e-9,eps_max,n_eps)
eps_range = np.zeros((len(eps11_range), 2, 2))
eps_range[:,1,1] = eps11_range
state_vars = { var : np.zeros( (len(eps11_range),) + shape )
for var, shape in self.state_var_shapes.items()
}
sig_range, D = self.get_corr_pred(eps_range, 1, **state_vars)
sig11_range = sig_range[:,1,1]
return np.trapz(sig11_range, eps11_range)
def subplots(self, fig):
ax_sig = fig.subplots(1,1)
ax_d_sig = ax_sig.twinx()
return ax_sig, ax_d_sig
def update_plot(self, axes):
ax_sig, ax_d_sig = axes
eps_max = self.eps_max
n_eps = 100
eps11_range = np.linspace(1e-9,eps_max,n_eps)
eps_range = np.zeros((n_eps, 2, 2))
eps_range[:,0,0] = eps11_range
state_vars = { var : np.zeros( (n_eps,) + shape )
for var, shape in self.state_var_shapes.items()
}
sig_range, D_range = self.get_corr_pred(eps_range, 1, **state_vars)
sig11_range = sig_range[:,0,0]
ax_sig.plot(eps11_range, sig11_range,color='blue')
d_sig1111_range = D_range[...,0,0,0,0]
ax_d_sig.plot(eps11_range, d_sig1111_range,
linestyle='dashed', color='gray')
ax_sig.set_xlabel(r'$\varepsilon_{11}$ [-]')
ax_sig.set_ylabel(r'$\sigma_{11}$ [MPa]')
ax_d_sig.set_ylabel(r'$\mathrm{d} \sigma_{11} / \mathrm{d} \varepsilon_{11}$ [MPa]')
ax_d_sig.plot(eps11_range[:-1],
(sig11_range[:-1]-sig11_range[1:])/(eps11_range[:-1]-eps11_range[1:]),
color='orange', linestyle='dashed')
def get_omega(self, eps_ab, tn1, **Eps):
return Eps['omega']
var_dict = tr.Property(tr.Dict(tr.Str, tr.Callable))
'''Dictionary of response variables
'''
@tr.cached_property
def _get_var_dict(self):
var_dict = dict(omega=self.get_omega)
var_dict.update(super()._get_var_dict())
return var_dict
class VUNTIM(MATS3DEval):
"""
Vectorized uncoupled normal tngential interface model
"""
# -------------------------------------------------------------------------
# Elasticity
# -------------------------------------------------------------------------
E_N = Float(10000, MAT=True)
E_T = Float(1000, MAT=True)
gamma_T = Float(100000., MAT=True)
K_T = Float(10000., MAT=True)
S_T = Float(0.005, MAT=True)
r_T = Float(9., MAT=True)
e_T = Float(12., MAT=True)
c_T = Float(4.6, MAT=True)
tau_pi_bar = Float(1.7, MAT=True)
a = Float(0.003, MAT=True)
# ------------------------------------------------------------------------------
# Normal_Tension constitutive law parameters (without cumulative normal strain)
# ------------------------------------------------------------------------------
Ad = Float(100.0, MAT=True)
eps_0 = Float(0.00008, MAT=True)
# -----------------------------------------------
# Normal_Compression constitutive law parameters
# -----------------------------------------------
K_N = Float(10000., MAT=True)
gamma_N = Float(5000., MAT=True)
sig_0 = Float(30., MAT=True)
ipw_view = View(
Item('E_N'),
Item('E_T'),
Item('Ad'),
Item('eps_0'),
Item('K_N'),
Item('gamma_N'),
Item('sig_0'),
Item('gamma_T', latex=r'\gamma_\mathrm{T}', minmax=(10, 100000)),
Item('K_T', latex=r'K_\mathrm{T}', minmax=(10, 10000)),
Item('S_T', latex=r'S_\mathrm{T}', minmax=(0.001, 0.01)),
Item('r_T', latex=r'r_\mathrm{T}', minmax=(1, 3)),
Item('e_T', latex=r'e_\mathrm{T}', minmax=(1, 40)),
Item('c_T', latex=r'c_\mathrm{T}', minmax=(1, 10)),
Item('tau_pi_bar', latex=r'\bar{\sigma}^\pi_{T}', minmax=(1, 10)),
Item('a', latex=r'a_\mathrm{T}', minmax=(0.001, 3)),
)
n_D = 3
state_var_shapes = dict(
omega_N=(), # damage N
z_N=(),
alpha_N=(),
r_N=(),
eps_N_p=(),
sig_N=(),
omega_T=(),
z_T=(),
alpha_T_a=(n_D, ),
eps_T_p_a=(n_D, ),
sig_T_a=(n_D, ),
)
# --------------------------------------------------------------
# microplane constitutive law (normal behavior CP + TD)
# --------------------------------------------------------------
def get_normal_law(self, eps_N, **Eps):
omega_N, z_N, alpha_N, r_N, eps_N_p = [
Eps[key]
for key in ['omega_N', 'z_N', 'alpha_N', 'r_N', 'eps_N_p']
]
E_N = self.E_N
# When deciding if a microplane is in tensile or compression, we define a strain boundary such that that
# sigN <= 0 if eps_N < 0, avoiding entering in the quadrant of compressive strains and traction
sig_trial = E_N * (eps_N - eps_N_p)
pos1 = [(eps_N < -1e-6) & (sig_trial > 1e-6)
] # looking for microplanes violating strain boundary
sig_trial[pos1[0]] = 0
pos = sig_trial > 1e-6 # microplanes under traction
pos2 = sig_trial < -1e-6 # microplanes under compression
H = 1.0 * pos
H2 = 1.0 * pos2
# thermo forces
sig_N_tilde = E_N * (eps_N - eps_N_p)
sig_N_tilde[pos1[0]] = 0 # imposing strain boundary
Z = self.K_N * z_N
X = self.gamma_N * alpha_N * H2
h = (self.sig_0 + Z) * H2
f_trial = (abs(sig_N_tilde - X) - h) * H2
# threshold plasticity
thres_1 = f_trial > 1e-6
delta_lamda = f_trial / \
(E_N / (1 - omega_N) + abs(self.K_N) + self.gamma_N) * thres_1
eps_N_p = eps_N_p + delta_lamda * \
np.sign(sig_N_tilde - X)
z_N = z_N + delta_lamda
alpha_N = alpha_N + delta_lamda * \
np.sign(sig_N_tilde - X)
def R_N(r_N):
return (1.0 / self.Ad) * (-r_N / (1.0 + r_N))
Y_N = 0.5 * H * E_N * (eps_N - eps_N_p)**2.0
Y_0 = 0.5 * E_N * self.eps_0**2.0
f = (Y_N - (Y_0 + R_N(r_N)))
# threshold damage
thres_2 = f > 1e-6
def f_w(Y):
return 1.0 - 1.0 / (1.0 + self.Ad * (Y - Y_0))
omega_N[f > 1e-6] = f_w(Y_N)[f > 1e-6]
r_N[f > 1e-6] = -omega_N[f > 1e-6]
sig_N = (1.0 - H * omega_N) * E_N * (eps_N - eps_N_p)
pos1 = [(eps_N < -1e-6) & (sig_trial > 1e-6)
] # looking for microplanes violating strain boundary
sig_N[pos1[0]] = 0
return sig_N
# -------------------------------------------------------------------------
# microplane constitutive law (Tangential CSD)-(Pressure sensitive cumulative damage)
# -------------------------------------------------------------------------
def get_tangential_law(self, eps_T_a, **Eps):
omega_T, z_T, alpha_T_a, eps_T_p_a, sig_N, = [
Eps[key] for key in [
'omega_T',
'z_T',
'alpha_T_a',
'eps_T_p_a',
'sig_N',
]
]
E_T = self.E_T
# thermodynamic forces
sig_pi_trial = E_T * (eps_T_a - eps_T_p_a)
Z = self.K_T * z_T
X = self.gamma_T * alpha_T_a
norm_1 = np.sqrt(
np.einsum('...na,...na->...n', (sig_pi_trial - X),
(sig_pi_trial - X)))
Y = 0.5 * E_T * np.einsum('...na,...na->...n', (eps_T_a - eps_T_p_a),
(eps_T_a - eps_T_p_a))
# threshold
f = norm_1 - self.tau_pi_bar - Z + self.a * sig_N
plas_1 = f > 1e-6
elas_1 = f < 1e-6
delta_lamda = f / (E_T /
(1.0 - omega_T) + self.gamma_T + self.K_T) * plas_1
norm_2 = 1.0 * elas_1 + np.sqrt(
np.einsum('...na,...na->...n', (sig_pi_trial - X),
(sig_pi_trial - X))) * plas_1
eps_T_p_a[..., 0] += plas_1 * delta_lamda * \
((sig_pi_trial[..., 0] - X[..., 0]) /
(1.0 - omega_T)) / norm_2
eps_T_p_a[..., 1] += plas_1 * delta_lamda * \
((sig_pi_trial[..., 1] - X[..., 1]) /
(1.0 - omega_T)) / norm_2
eps_T_p_a[..., 2] += plas_1 * delta_lamda * \
((sig_pi_trial[..., 2] - X[..., 2]) /
(1.0 - omega_T)) / norm_2
omega_T[...] += ((1.0 - omega_T) ** self.c_T) * \
(delta_lamda * (Y / self.S_T) ** self.r_T) * \
(self.tau_pi_bar / (self.tau_pi_bar - self.a * sig_N)) ** self.e_T
alpha_T_a[..., 0] += plas_1 * delta_lamda * \
(sig_pi_trial[..., 0] - X[..., 0]) / norm_2
alpha_T_a[..., 1] += plas_1 * delta_lamda * \
(sig_pi_trial[..., 1] - X[..., 1]) / norm_2
alpha_T_a[..., 2] += plas_1 * delta_lamda * \
(sig_pi_trial[..., 2] - X[..., 2]) / norm_2
z_T[...] += delta_lamda
sig_T_a = np.einsum('...n,...na->...na', (1 - omega_T),
E_T * (eps_T_a - eps_T_p_a))
return sig_T_a
def get_corr_pred(self, eps_a, t_n1, **Eps):
eps_a_ = np.einsum('...a->a...', eps_a)
eps_N_n1 = eps_a_[0, ...]
eps_T_a_n1 = np.einsum('a...->...a', eps_a_[1:, ...])
sig_N = self.get_normal_law(eps_N_n1, **Eps)
sig_T_a = self.get_tangential_law(eps_T_a_n1, **Eps)
D_ = np.zeros(eps_a.shape + (eps_a.shape[-1], ))
D_[..., 0, 0] = self.E_N # * (1 - omega_N)
D_[..., 1, 1] = self.E_T # * (1 - omega_T)
D_[..., 2, 2] = self.E_T # * (1 - omega_T)
D_[..., 3, 3] = self.E_T # * (1 - omega_T)
sig_a = np.concatenate([sig_N[..., np.newaxis], sig_T_a], axis=-1)
return sig_a, D_
def get_eps_NT_p(self, **Eps):
"""Plastic strain tensor
"""
return Eps['eps_N_p'], Eps['eps_T_p_a']
def plot_idx(self, ax_sig, ax_d_sig, idx=0):
eps_max = self.eps_max
n_eps = self.n_eps
eps1_range = np.linspace(1e-9, eps_max, n_eps)
Eps = {
var: np.zeros((1, ) + shape)
for var, shape in self.state_var_shapes.items()
}
eps_range = np.zeros((n_eps, 4))
eps_range[:, idx] = eps1_range
# monotonic load in the normal direction
sig1_range, d_sig11_range = [], []
for eps_a in eps_range:
sig_a, D_range = self.get_corr_pred(eps_a[np.newaxis, ...], 1,
**Eps)
sig1_range.append(sig_a[0, idx])
d_sig11_range.append(D_range[0, idx, idx])
sig1_range = np.array(sig1_range, dtype=np.float_)
eps1_range = eps1_range[:len(sig1_range)]
ax_sig.plot(eps1_range, sig1_range, color='blue')
d_sig11_range = np.array(d_sig11_range, dtype=np.float_)
ax_d_sig.plot(eps1_range,
d_sig11_range,
linestyle='dashed',
color='gray')
ax_sig.set_xlabel(r'$\varepsilon_{11}$ [-]')
ax_sig.set_ylabel(r'$\sigma_{11}$ [MPa]')
ax_d_sig.set_ylabel(
r'$\mathrm{d} \sigma_{11} / \mathrm{d} \varepsilon_{11}$ [MPa]')
ax_d_sig.plot(eps1_range[:-1], (sig1_range[:-1] - sig1_range[1:]) /
(eps1_range[:-1] - eps1_range[1:]),
color='orange',
linestyle='dashed')
def subplots(self, fig):
ax_sig_N, ax_sig_T = fig.subplots(1, 2)
ax_d_sig_N = ax_sig_N.twinx()
ax_d_sig_T = ax_sig_T.twinx()
return ax_sig_N, ax_d_sig_N, ax_sig_T, ax_d_sig_T
def update_plot(self, axes):
ax_sig_N, ax_d_sig_N, ax_sig_T, ax_d_sig_T = axes
self.plot_idx(ax_sig_N, ax_d_sig_N, 0)
self.plot_idx(ax_sig_T, ax_d_sig_T, 1)
class CyclicLoadingScenario(LoadingScenario):
number_of_cycles = Int(1, BC=True,
enter_set=True, auto_set=False,
symbol='n_\mathrm{cycles}',
unit='-',
desc='for cyclic loading',
)
maximum_loading = Float(1.0, BC=True,
enter_set=True, auto_set=False,
symbol='\phi_{\max}',
desc='load factor at maximum load level',
unit='-')
number_of_increments = Int(20, BC=True,
enter_set=True, auto_set=False,
symbol='n_{\mathrm{incr}}',
unit='-',
desc='number of values within a monotonic load branch')
unloading_ratio = Float(0.5, BC=True,
enter_set=True, auto_set=False,
symbol='\phi_{\mathrm{unload}}',
desc='fraction of maximum load at lowest load level',
unit='-')
amplitude_type = Enum(options=["increasing", "constant"],
enter_set=True, auto_set=False,
symbol='option',
unit='-',
desc='possible values: [increasing, constant]',
BC=True)
loading_range = Enum(options=["non-symmetric", "symmetric"],
enter_set=True, auto_set=False,
symbol='option',
unit='-',
desc='possible values: [non-symmetric, symmetric]',
BC=True)
ipw_view = bu.View(
bu.Item('number_of_cycles'),
bu.Item('maximum_loading'),
bu.Item('number_of_increments'),
bu.Item('unloading_ratio'), # , editor=FloatRangeEditor(low=0, high=1)),
bu.Item('amplitude_type'),
bu.Item('loading_range'),
)
xy_arrays = Property(depends_on="state_changed")
@cached_property
def _get_xy_arrays(self):
if(self.amplitude_type == "increasing" and
self.loading_range == "symmetric"):
d_levels = np.linspace(
0, self.maximum_loading, self.number_of_cycles * 2)
d_levels.reshape(-1, 2)[:, 0] *= -1
d_history = d_levels.flatten()
d_arr = np.hstack([np.linspace(d_history[i], d_history[i + 1],
self.number_of_increments)
for i in range(len(d_levels) - 1)])
if(self.amplitude_type == "increasing" and
self.loading_range == "non-symmetric"):
d_levels = np.linspace(
0, self.maximum_loading, self.number_of_cycles * 2)
d_levels.reshape(-1, 2)[:, 0] *= 0
d_history = d_levels.flatten()
d_arr = np.hstack([np.linspace(d_history[i], d_history[i + 1],
self.number_of_increments)
for i in range(len(d_levels) - 1)])
if(self.amplitude_type == "constant" and
self.loading_range == "symmetric"):
d_levels = np.linspace(
0, self.maximum_loading, self.number_of_cycles * 2)
d_levels.reshape(-1, 2)[:, 0] = -self.maximum_loading
d_levels[0] = 0
d_levels.reshape(-1, 2)[:, 1] = self.maximum_loading
d_history = d_levels.flatten()
d_arr = np.hstack([np.linspace(d_history[i], d_history[i + 1], self.number_of_increments)
for i in range(len(d_levels) - 1)])
if(self.amplitude_type == "constant" and
self.loading_range == "non-symmetric"):
d_levels = np.linspace(
0, self.maximum_loading, self.number_of_cycles * 2)
d_levels.reshape(-1, 2)[:,
0] = self.maximum_loading * self.unloading_ratio
d_levels[0] = 0
d_levels.reshape(-1, 2)[:, 1] = self.maximum_loading
d_history = d_levels.flatten()
d_arr = np.hstack([np.linspace(d_history[i], d_history[i + 1], self.number_of_increments)
for i in range(len(d_levels) - 1)])
t_arr = np.linspace(0, self.t_max, len(d_arr))
return t_arr, d_arr
class ConcreteMaterialModelAdv(ConcreteMatMod, bu.InjectSymbExpr):
name = 'Concrete behavior'
node_name = 'material model'
symb_class = ConcreteMaterialModelAdvExpr
d_a = Float(16, MAT=True) ## dia of steel mm
E_c = Float(28000, MAT=True) ## tensile strength of Concrete in MPa
f_t = Float(3, MAT=True) ## Fracture Energy in N/m
c_1 = Float(3, MAT=True)
c_2 = Float(6.93, MAT=True)
f_c = Float(33.3, MAT=True)
L_fps = Float(50, MAT=True)
a = Float(1.038, MAT=True)
b = Float(0.245, MAT=True)
interlock_factor = Float(1, MAT=True)
ipw_view = View(
Item('d_a', latex=r'd_a'), Item('E_c', latex=r'E_c'),
Item('f_t', latex=r'f_t'), Item('f_c', latex=r'f_c'),
Item('c_1', latex=r'c_1'), Item('c_2', latex=r'c_2'),
Item('L_fps', latex=r'L_{fps}'), Item('a', latex=r'a'),
Item('b', latex=r'b'),
Item('interlock_factor',
latex=r'\gamma_\mathrm{ag}',
editor=FloatRangeEditor(low=0, high=1)),
Item('w_cr', latex=r'w_\mathrm{cr}', readonly=True),
Item('L_c', latex=r'L_\mathrm{c}', readonly=True),
Item('G_f', latex=r'G_\mathrm{f}', readonly=True))
# G_f_baz = tr.Property(depends_on='_ITR, _INC, _GEO, _MAT, _DSC')
# @tr.cached_property
# def _get_G_f_baz(self):
# xi = self.sz_crack_tip_orientation.
# return self.symb.G_f_baz
L_c = tr.Property(Float, depends_on='state_changed')
@tr.cached_property
def _get_L_c(self):
return self.E_c * self.G_f / self.f_t**2
w_cr = tr.Property(Float, depends_on='state_changed')
@tr.cached_property
def _get_w_cr(self):
return (self.f_t / self.E_c) * self._get_L_c()
G_f = tr.Property(Float, depends_on='state_changed')
@tr.cached_property
def _get_G_f(self):
'''Calculating fracture energy
'''
return (0.028 * self.f_c**0.18 * self.d_a**0.32)
def get_w_tc(self):
'''Calculating point of softening curve resulting in 0 stress
'''
return (5.14 * self.G_f_baz / self.f_t)
def get_sig_a(self, u_a): #w, s
'''Calculating stresses
'''
sig_w = self.get_sig_w(u_a[..., 0], u_a[..., 1])
tau_s = self.get_tau_s(u_a[..., 0], u_a[..., 1])
return np.einsum('b...->...b', np.array([sig_w, tau_s],
dtype=np.float_)) #, tau_s
def get_sig_w(self, w, s):
return self.symb.get_sig_w(w, s)
def get_tau_s(self, w, s):
return self.symb.get_tau_s(w, s) * self.interlock_factor
w_min_factor = Float(1.2)
w_max_factor = Float(15)
def plot3d_sig_w(self, ax3d, vot=1.0):
w_min = -(self.f_c / self.E_c * self._get_L_c()) * self.w_min_factor
w_max = self.w_cr * self.w_max_factor
w_range = np.linspace(w_min, w_max, 100)
s_max = 3
s_data = np.linspace(-1.1 * s_max, 1.1 * s_max, 100)
s_, w_ = np.meshgrid(s_data, w_range)
sig_w = self.get_sig_w(w_, s_)
ax3d.plot_surface(w_, s_, sig_w, cmap='viridis', edgecolor='none')
ax3d.set_xlabel(r'$w\;\;\mathrm{[mm]}$', fontsize=12)
ax3d.set_ylabel(r'$s\;\;\mathrm{[mm]}$', fontsize=12)
ax3d.set_zlabel(r'$\sigma_w\;\;\mathrm{[MPa]}$', fontsize=12)
ax3d.set_title('crack opening law', fontsize=12)
# def plot_sig_w(self, ax, vot=1.0):
# w_min = -(self.f_c / self.E_c * self._get_L_c()) * self.w_min_factor
# w_max = self.w_cr * self.w_max_factor
# w_range = np.linspace(w_min, w_max, 100)
# s_max = 3
# s_data = np.linspace(-1.1 * s_max, 1.1 * s_max, 100)
# sig_w = self.get_sig_w(w_range, s_data)
# ax.plot(w_range, sig_w, lw=2, color='red')
# ax.fill_between(w_range, sig_w,
# color='red', alpha=0.2)
# ax.set_xlabel(r'$w\;\;\mathrm{[mm]}$', fontsize=12)
# ax.set_ylabel(r'$\sigma\;\;\mathrm{[MPa]}$', fontsize=12)
# ax.set_title('crack opening law', fontsize=12)
def plot3d_tau_s(self, ax3d, vot=1.0):
w_min = 1e-9 #-1
w_max = 3
w_data = np.linspace(w_min, w_max, 100)
s_max = 3
s_data = np.linspace(-1.1 * s_max, 1.1 * s_max, 100) #-1.1
s_, w_ = np.meshgrid(s_data, w_data)
tau_s = self.get_tau_s(w_, s_)
ax3d.plot_surface(w_, s_, tau_s, cmap='viridis', edgecolor='none')
ax3d.set_xlabel(r'$w\;\;\mathrm{[mm]}$', fontsize=12)
ax3d.set_ylabel(r'$s\;\;\mathrm{[mm]}$', fontsize=12)
ax3d.set_zlabel(r'$\tau\;\;\mathrm{[MPa]}$', fontsize=12)
ax3d.set_title('aggregate interlock law', fontsize=12)
# def subplots(self, fig):
# #ax_2d = fig.add_subplot(1, 2, 2)
# ax_3d_1 = fig.add_subplot(1, 2, 2, projection='3d')
# ax_3d_2 = fig.add_subplot(1, 2, 1, projection='3d')
# return ax_3d_1, ax_3d_2
#
# def update_plot(self, axes):
# '''Plotting function
# '''
# ax_3d_1, ax_3d_2 = axes
# self.plot3d_sig_w(ax_3d_1)
# self.plot3d_tau_s(ax_3d_2)
def get_eps_plot_range(self):
return np.linspace(1.1 * self.eps_cu, 1.1 * self.eps_tu, 300)
def get_sig(self, eps):
return self.factor * self.symb.get_sig_w(eps)
class MATSXDEval(MATSEval):
'''Base class for elastic models.
'''
n_dims = Constant(Float)
'''Number of spatial dimensions of an integration
cell for the material model
'''
E = Float(34e+3,
label="E",
desc="Young's Modulus",
auto_set=False,
MAT=True)
nu = Float(0.2,
label='nu',
desc="Poison's ratio",
auto_set=False,
MAT=True)
def _get_lame_params(self):
# First Lame parameter (bulk modulus)
la = self.E * self.nu / ((1. + self.nu) * (1. - 2. * self.nu))
# second Lame parameter (shear modulus)
mu = self.E / (2. + 2. * self.nu)
return la, mu
D_abef = Property(Array, depends_on='+input')
'''Material stiffness - rank 4 tensor
'''
@cached_property
def _get_D_abef(self):
la, mu = self._get_lame_params()
delta = np.identity(self.n_dims)
return (np.einsum(',ij,kl->ijkl', la, delta, delta) +
np.einsum(',ik,jl->ijkl', mu, delta, delta) +
np.einsum(',il,jk->ijkl', mu, delta, delta))
def get_corr_pred(self, eps_Emab, tn1, **Eps):
'''
Corrector predictor computation.
@param eps_Emab input variable - strain tensor
'''
sigma_Emab = np.einsum('abcd,...cd->...ab', self.D_abef, eps_Emab)
Em_len = len(eps_Emab.shape) - 2
new_shape = tuple([1 for _ in range(Em_len)]) + self.D_abef.shape
D_abef = self.D_abef.reshape(*new_shape)
return sigma_Emab, D_abef
#=========================================================================
# Response variables
#=========================================================================
def get_eps_ab(self, eps_ab, tn1, **Eps):
return eps_ab
def get_sig_ab(self, eps_ab, tn1, **Eps):
'''
Get the stress tensor
:param eps_ab: strain tensor with ab indexes
:param tn1: time - can be used for time dependent properties
:param Eps: dictionary of state variables corresponding to the
specification in state_var_shapes
:return: stress vector with with the shape of input and state variables + ab
spatial indexes.
'''
return self.get_sig(eps_ab, tn1, **Eps)
def get_state_var(self, var_name, eps_ab, tn1, **Eps):
'''
Acess to state variables used for visualization
:param var_name: string with the name of the state variable
:param eps_ab: strain tensor (not used)
:param tn1: time variable (not used)
:param Eps: dictionary of state variables corresponding to the
specification in state_var_shapes
:return: Array with the state variable with the shape corresponding
to the level of the problem
'''
return Eps[var_name]
var_dict = Property(Dict(Str, Callable))
'''Dictionary of functions that deliver the response/state variables
of a material model
'''
@cached_property
def _get_var_dict(self):
var_dict = super(MATSXDEval, self)._get_var_dict()
var_dict.update(eps_ab=self.get_eps_ab, sig_ab=self.get_sig_ab)
var_dict.update({
var_name: lambda eps_ab, tn1, **Eps: self.get_state_var(
var_name, eps_ab, tn1, **Eps)
for var_name in self.state_var_shapes.keys()
})
return var_dict
