def strains(self):
mfn = MFnLineArray()
mfn.xdata, mfn.ydata = self.values
strains_fn = frompyfunc(mfn.get_diff, 1, 1)
strains = strains_fn(mfn.xdata)
strains[0] = strains[1]
strains[-2] = strains[-1]
return strains
def ppf( self, x ):
self.check()
if len( self.cdf_values ) != 0:
xx, cdf = self.x_values, self.cdf_values
else:
xx, cdf = self.x_values, self.cdf( self.x_values )
ppf_mfn_line = MFnLineArray( xdata = cdf, ydata = xx )
return ppf_mfn_line.get_values( x )
def _get_cached_pdf( self ):
if len( self.pdf_values ) == 0:
cdf_line = MFnLineArray( xdata = self.x_values, ydata = self.cdf_values )
pdf = []
for x in self.x_values:
pdf.append( cdf_line.get_diff( x ) )
return MFnLineArray( xdata = self.x_values, ydata = pdf )
else:
return MFnLineArray( xdata = self.x_values, ydata = self.pdf_values )
def _get_pdf_array( self ):
# get the normed histogram implemented in the base class YMBHist
h, b = self.normed_hist
b_cen = ( b[1:] + b[:-1] ) / 2.
mask = ( h != 0. )
h = h[mask]
b_cen = b_cen[mask]
b = hstack( [min( b ), b_cen, max( b )] )
h = hstack( [0, h, 0] )
h = h / trapz( h, b )
p = MFnLineArray( xdata=b, ydata=h )
return p.get_values( self.x_array )
n = 200 # number of increments
s_levels = np.linspace(0, 0.00125, 2)
s_levels.reshape(-1, 2)[:, 0] = 0.0
#s_levels.reshape(-1, 2)[:, 1] = -0.005
s_levels[0] = 0
s_history_1 = s_levels.flatten()
d_array = np.hstack([
np.linspace(s_history_1[i], s_history_1[i + 1], n)
for i in range(len(s_levels) - 1)
])
t_max = 1.0
t_arr = np.linspace(0, t_max, len(d_array))
print 't_arr ', t_arr
time_func = MFnLineArray(xdata=t_arr, ydata=d_array)
time_func.extrapolate = 'constant'
print 'time_func', time_func
time_func_2 = interp1d(t_arr, d_array)
print 'time_func_2', time_func_2
# ts.bc_list = [BCDof(var='u', dof=0, value=0.0), BCDof(var='f', dof=n_dofs - 1, time_function=loading_scenario.time_func)]
if False:
tloop.bc_list = [
BCSlice(slice=dots.mesh[0, :, 0, :], var='u', dims=[0, 1],
value=0),
BCSlice(slice=dots.mesh[25, -1, :, -1],
var='u',
dims=[1],
value=-50),
def _mfn_default(self):
return MFnLineArray()
def example_with_new_domain():
from ibvpy.api import \
TStepper as TS, RTraceDomainListField, TLoop, TLine
from ibvpy.mats.mats2D5.mats2D5_bond.mats2D_bond import MATS2D5Bond
from ibvpy.api import BCDofGroup
from ibvpy.fets.fets2D.fets2D4q import FETS2D4Q
fets_eval = FETS2DTF(parent_fets=FETS2D4Q(),
mats_eval=MATS2D5Bond(E_m=30,
nu_m=0.2,
E_f=10,
nu_f=0.1,
G=10.))
from ibvpy.mesh.fe_grid import FEGrid
from mathkit.mfn import MFnLineArray
# Discretization
fe_grid = FEGrid(coord_max=(10., 4., 0.),
n_elems=(10, 3),
fets_eval=fets_eval)
mf = MFnLineArray( # xdata = arange(10),
ydata=array([0, 1, 2, 3]))
tstepper = TS(
sdomain=fe_grid,
bcond_list=[
BCDofGroup(var='u',
value=0.,
dims=[0, 1],
get_dof_method=fe_grid.get_left_dofs),
# BCDofGroup( var='u', value = 0., dims = [1],
# get_dof_method = fe_grid.get_bottom_dofs ),
BCDofGroup(var='u',
value=.005,
dims=[0],
time_function=mf.get_value,
get_dof_method=fe_grid.get_right_dofs)
],
rtrace_list=[
# RTDofGraph(name = 'Fi,right over u_right (iteration)' ,
# var_y = 'F_int', idx_y = right_dof,
# var_x = 'U_k', idx_x = right_dof,
# record_on = 'update'),
# RTraceDomainListField(name = 'Stress' ,
# var = 'sig_app', idx = 0,
# #position = 'int_pnts',
# record_on = 'update'),
# RTraceDomainListField(name = 'Damage' ,
# var = 'omega', idx = 0,
# record_on = 'update',
# warp = True),
RTraceDomainListField(name='Displ matrix',
var='u_m',
idx=0,
record_on='update',
warp=True),
RTraceDomainListField(name='Displ reinf',
var='u_f',
idx=0,
record_on='update',
warp=True),
# RTraceDomainListField(name = 'N0' ,
# var = 'N_mtx', idx = 0,
# record_on = 'update')
])
# Add the time-loop control
#global tloop
tloop = TLoop(tstepper=tstepper,
KMAX=300,
tolerance=1e-4,
tline=TLine(min=0.0, step=1.0, max=1.0))
#import cProfile
#cProfile.run('tloop.eval()', 'tloop_prof' )
print(tloop.eval())
#import pstats
#p = pstats.Stats('tloop_prof')
# p.strip_dirs()
# print 'cumulative'
# p.sort_stats('cumulative').print_stats(20)
# print 'time'
# p.sort_stats('time').print_stats(20)
# Put the whole thing into the simulation-framework to map the
# individual pieces of definition into the user interface.
#
from ibvpy.plugins.ibvpy_app import IBVPyApp
app = IBVPyApp(ibv_resource=tloop)
app.main()
def _get_PDFx(self):
pdfx_line = MFnLineArray(xdata=self.x_values, ydata=self.pdf_x)
return pdfx_line
def _get_transf_line(self):
x = np.linspace(self.x_values[0], self.x_values[-1], 500)
y = self.transf_eqn(x)
return MFnLineArray(xdata=x, ydata=y, extrapolate='diff')
def _bond_fn_default(self):
return MFnLineArray(xdata=[0., 1.], ydata=[0., 1.])
def app():
avg_radius = 0.03
md = MATS2DScalarDamage(
E=20.0e3,
nu=0.2,
epsilon_0=1.0e-4,
epsilon_f=8.0e-4,
#epsilon_f = 12.0e-4, #test doubling the e_f
stress_state="plane_strain",
stiffness="secant",
#stiffness = "algorithmic",
strain_norm=Rankine())
mdm = MATS2DMicroplaneDamage(
E=20.0e3,
nu=0.2,
#epsilon_f = 12.0e-4, #test doubling the e_f
stress_state="plane_strain",
model_version='compliance',
phi_fn=PhiFnStrainSoftening(G_f=0.0014,
f_t=2.0,
md=0.0,
h=2. * avg_radius))
# mp = MATSProxy( mats_eval = mdm )
# mp.varpars['epsilon_0'].switch = 'varied'
# mp.varpars['epsilon_0'].spatial_fn = MFnNDGrid( shape = ( 8, 5, 1 ),
# active_dims = ['x', 'y'],
# x_mins = GridPoint( x = 0., y = 0. ),
# x_maxs = GridPoint( x = length, y = heigth ) )
# mp.varpars['epsilon_0'].spatial_fn.set_values_in_box( 500., [0, 0, 0], [0.2, 0.2, 0.] )
# mp.varpars['epsilon_0'].spatial_fn.set_values_in_box( 500., [0.8, 0, 0], [1., 0.2, 0.] )
# mp.varpars['epsilon_0'].spatial_fn.set_values_in_box( 50., [0., 0.46, 0], [1., 0.5, 0.] )
# me = MATS2DElastic( E = 20.0e3,
# nu = 0.2,
# stress_state = "plane_strain" )
fets_eval = FETS2D4Q(mats_eval=mdm) #, ngp_r = 3, ngp_s = 3)
n_el_x = 20 # 60
# Discretization
fe_grid = FEGrid(coord_max=(.6, .15, 0.),
shape=(n_el_x, n_el_x / 4),
fets_eval=fets_eval)
mf = MFnLineArray(xdata=array([0, 1, 2]), ydata=array([0, 3., 3.2]))
#averaging function
avg_processor = RTNonlocalAvg(
avg_fn=QuarticAF(radius=avg_radius, correction=True))
loading_dof = fe_grid[n_el_x / 2, -1, 0, -1].dofs.flatten()[1]
print('loading_dof', loading_dof)
ts = TS(
sdomain=fe_grid,
u_processor=avg_processor,
bcond_list=[
# constraint for all left dofs in y-direction:
BCSlice(var='u', slice=fe_grid[0, 0, 0, 0], dims=[0, 1], value=0.),
BCSlice(var='u', slice=fe_grid[-1, 0, -1, 0], dims=[1], value=0.),
BCSlice(var='u',
slice=fe_grid[n_el_x / 2, -1, 0, -1],
dims=[1],
time_function=mf.get_value,
value=-2.0e-4),
],
rtrace_list=[
RTDofGraph(name='Fi,right over u_right (iteration)',
var_y='F_int',
idx_y=loading_dof,
var_x='U_k',
idx_x=loading_dof,
record_on='update'),
RTraceDomainListField(name='Deformation',
var='eps_app',
idx=0,
record_on='update'),
RTraceDomainListField(name='Deformation',
var='sig_app',
idx=0,
record_on='update'),
RTraceDomainListField(name='Displacement',
var='u',
idx=1,
record_on='update',
warp=True),
RTraceDomainListField(name='fracture_energy',
var='fracture_energy',
idx=0,
record_on='update',
warp=True),
RTraceDomainListField(name='Damage',
var='omega_mtx',
idx=0,
warp=True,
record_on='update'),
# RTraceDomainField(name = 'Stress' ,
# var = 'sig', idx = 0,
# record_on = 'update'),
# RTraceDomainField(name = 'N0' ,
# var = 'N_mtx', idx = 0,
# record_on = 'update')
])
# Add the time-loop control
#
tl = TLoop(tstepper=ts,
tolerance=5.0e-5,
KMAX=200,
tline=TLine(min=0.0, step=.1, max=1.0))
tl.eval()
# Put the whole stuff into the simulation-framework to map the
# individual pieces of definition into the user interface.
#
from ibvpy.plugins.ibvpy_app import IBVPyApp
ibvpy_app = IBVPyApp(ibv_resource=ts)
ibvpy_app.main()
class MATS1D5Bond(MATSEval):
'''
Scalar Damage Model.
'''
implements(IMATSEval)
Ef = Float(
1., #34e+3,
label="E",
desc="Young's Modulus Fiber",
auto_set=False,
enter_set=True)
Af = Float(
1., #34e+3,
label="A",
desc="Cross Section Fiber",
auto_set=False,
enter_set=True)
Em = Float(
1., #34e+3,
label="E",
desc="Young's Modulus Matrix",
auto_set=False,
enter_set=True)
Am = Float(
1., #34e+3,
label="A",
desc="Cross Section Matrix",
auto_set=False,
enter_set=True)
G = Float(
1., #34e+3,
label="G",
desc="Shear Stiffness",
auto_set=False,
enter_set=True)
bond_fn = Trait(MFnLineArray(ydata=[0, 1]),
label="Bond",
desc="Bond Function",
auto_set=False)
traits_view = View(Item('Ef'),
Item('Af'),
Item('Em'),
Item('Am'),
Item('G'),
Item('bond_fn', editor=mpl_matplotlib_editor),
resizable=True,
scrollable=True,
height=0.5,
width=0.5,
buttons=['OK', 'Cancel'])
def _bond_fn_default(self):
return MFnLineArray(xdata=[0., 1.], ydata=[0., 1.])
# This event can be used by the clients to trigger an action upon
# the completed reconfiguration of the material model
#
changed = Event
#---------------------------------------------------------------------------------------------
# View specification
#---------------------------------------------------------------------------------------------
#-----------------------------------------------------------------------------------------------
# Private initialization methods
#-----------------------------------------------------------------------------------------------
#-----------------------------------------------------------------------------------------------
# Setup for computation within a supplied spatial context
#-----------------------------------------------------------------------------------------------
def setup(self, sctx):
'''
Intialize state variables.
'''
def new_cntl_var(self):
return zeros(4, float_) #TODO: adapt for 4-5..
def new_resp_var(self):
return zeros(4, float_) #TODO: adapt for 4-5..
#-----------------------------------------------------------------------------------------------
# Evaluation - get the corrector and predictor
#-----------------------------------------------------------------------------------------------
def get_corr_pred(self, sctx, eps_app_eng, d_eps, tn, tn1):
'''
Corrector predictor computation.
@param eps_app_eng input variable - engineering strain
'''
if eps_app_eng.shape[0] == 4:
D_mtx = zeros((4, 4))
sigma = zeros(4)
elif eps_app_eng.shape[0] == 5:
D_mtx = zeros((5, 5))
sigma = zeros(5)
D_mtx[2, 2] = self.bond_fn.get_diff(eps_app_eng[2])
sigma[2] = self.bond_fn.get_value(eps_app_eng[2]) #tau_m
else:
print "MATS1D5Bond: Unsupported number of strain components"
D_mtx[0, 0] = self.bond_fn.get_diff(eps_app_eng[0])
D_mtx[1, 1] = self.bond_fn.get_diff(eps_app_eng[1])
D_mtx[-2, -2] = self.Ef * self.Af
D_mtx[-1, -1] = self.Em * self.Am
sigma[0] = self.bond_fn.get_value(eps_app_eng[0]) #tau_l
sigma[1] = self.bond_fn.get_value(eps_app_eng[1]) #tau_r
sigma[-2] = self.Ef * self.Af * eps_app_eng[-2] #sig_f
sigma[-1] = self.Em * self.Am * eps_app_eng[-1] #sig_m
# You print the stress you just computed and the value of the apparent E
return sigma, D_mtx
#---------------------------------------------------------------------------------------------
# Subsidiary methods realizing configurable features
#---------------------------------------------------------------------------------------------
def get_sig_app(self, sctx, eps_app_eng, *args, **kw):
# @TODO
# the stress calculation is performed twice - it might be
# cached.
sig_eng, D_mtx = self.get_corr_pred(sctx, eps_app_eng, 0, 0, 0)
r_pnt = sctx.loc
s_tensor = zeros((3, 3))
if r_pnt[1] >= 0.:
s_tensor[0, 0] = sig_eng[-1]
else:
s_tensor[0, 0] = sig_eng[-2]
return s_tensor
def get_shear(self, sctx, eps_app_eng):
# @TODO
# the stress calculation is performed twice - it might be
# cached.
sig_eng, D_mtx = self.get_corr_pred(sctx, eps_app_eng, 0, 0, 0)
r_pnt = sctx.loc
if eps_app_eng.shape[0] == 4:
if r_pnt[0] >= 0.:
sig_pos = [sig_eng[1]]
else:
sig_pos = [sig_eng[0]]
elif eps_app_eng.shape[0] == 5:
if r_pnt[0] >= 0.5:
sig_pos = [sig_eng[1]]
elif r_pnt[0] <= -0.5:
sig_pos = [sig_eng[0]]
else:
sig_pos = [sig_eng[2]]
return sig_pos
def get_eps_app(self, sctx, eps_app_eng):
r_pnt = sctx.loc
if r_pnt[1] >= 0.:
eps_pos = [eps_app_eng[-1]]
else:
eps_pos = [eps_app_eng[-2]]
return eps_pos
def get_slip(self, sctx, eps_app_eng):
r_pnt = sctx.loc
if eps_app_eng.shape[0] == 4:
if r_pnt[0] >= 0.:
eps_pos = [eps_app_eng[1]]
else:
eps_pos = [eps_app_eng[0]]
if eps_app_eng.shape[0] == 5:
if r_pnt[0] >= 0.5:
eps_pos = [eps_app_eng[1]]
elif r_pnt[0] <= -0.5:
eps_pos = [eps_app_eng[0]]
else:
eps_pos = [eps_app_eng[2]]
return eps_pos
#---------------------------------------------------------------------------------------------
# Response trace evaluators
#---------------------------------------------------------------------------------------------
# Declare and fill-in the rte_dict - it is used by the clients to
# assemble all the available time-steppers.
#
rte_dict = Trait(Dict)
def _rte_dict_default(self):
return {
'sig_app_t1d': self.get_sig_app,
'eps_app_t1d': self.get_eps_app,
'shear_s': self.get_shear,
'slip_s': self.get_slip,
'msig_pos': self.get_msig_pos,
'msig_pm': self.get_msig_pm
}
def example_with_new_domain():
from ibvpy.api import \
TStepper as TS, RTDofGraph, RTraceDomainListField, \
RTraceDomainListInteg, TLoop, \
TLine, BCDof, DOTSEval
from ibvpy.mats.mats2D.mats2D_elastic.mats2D_elastic import MATS2DElastic
from ibvpy.mats.mats2D.mats2D_sdamage.mats2D_sdamage import MATS2DScalarDamage
from ibvpy.api import BCDofGroup
mats_eval = MATS2DElastic()
fets_eval = FETS2D4Q(mats_eval=mats_eval)
#fets_eval = FETS2D4Q(mats_eval = MATS2DScalarDamage())
print(fets_eval.vtk_node_cell_data)
from ibvpy.mesh.fe_grid import FEGrid
from ibvpy.mesh.fe_refinement_grid import FERefinementGrid
from ibvpy.mesh.fe_domain import FEDomain
from mathkit.mfn import MFnLineArray
# Discretization
fe_grid = FEGrid(coord_max=(10., 4., 0.),
shape=(10, 3),
fets_eval=fets_eval)
bcg = BCDofGroup(var='u',
value=0.,
dims=[0],
get_dof_method=fe_grid.get_left_dofs)
bcg.setup(None)
print('labels', bcg._get_labels())
print('points', bcg._get_mvpoints())
mf = MFnLineArray( # xdata = arange(10),
ydata=np.array([0, 1, 2, 3]))
right_dof = 2
tstepper = TS(
sdomain=fe_grid,
bcond_list=[
BCDofGroup(var='u',
value=0.,
dims=[0, 1],
get_dof_method=fe_grid.get_left_dofs),
# BCDofGroup( var='u', value = 0., dims = [1],
# get_dof_method = fe_grid.get_bottom_dofs ),
BCDofGroup(var='u',
value=.005,
dims=[1],
time_function=mf.get_value,
get_dof_method=fe_grid.get_right_dofs)
],
rtrace_list=[
RTDofGraph(name='Fi,right over u_right (iteration)',
var_y='F_int',
idx_y=right_dof,
var_x='U_k',
idx_x=right_dof,
record_on='update'),
RTraceDomainListField(name='Stress',
var='sig_app',
idx=0,
position='int_pnts',
record_on='update'),
# RTraceDomainListField(name = 'Damage' ,
# var = 'omega', idx = 0,
#
# record_on = 'update',
# warp = True),
RTraceDomainListField(name='Displacement',
var='u',
idx=0,
record_on='update',
warp=True),
RTraceDomainListField(name='Strain energy',
var='strain_energy',
idx=0,
record_on='update',
warp=False),
RTraceDomainListInteg(name='Integ strain energy',
var='strain_energy',
idx=0,
record_on='update',
warp=False),
# RTraceDomainListField(name = 'N0' ,
# var = 'N_mtx', idx = 0,
# record_on = 'update')
])
# Add the time-loop control
#global tloop
tloop = TLoop(tstepper=tstepper,
KMAX=300,
tolerance=1e-4,
tline=TLine(min=0.0, step=1.0, max=1.0))
#import cProfile
#cProfile.run('tloop.eval()', 'tloop_prof' )
# print tloop.eval()
#import pstats
#p = pstats.Stats('tloop_prof')
# p.strip_dirs()
# print 'cumulative'
# p.sort_stats('cumulative').print_stats(20)
# print 'time'
# p.sort_stats('time').print_stats(20)
tloop.eval()
# Put the whole thing into the simulation-framework to map the
# individual pieces of definition into the user interface.
#
from ibvpy.plugins.ibvpy_app import IBVPyApp
app = IBVPyApp(ibv_resource=tloop)
app.main()
def reset_stress_strain_curve(self):
self._stress_strain_curve = MFnLineArray(ydata=[0., self.E],
xdata=[0., 1.])
from mathkit.mfn import MFnLineArray
from matresdev.db.exdb.ex_run_view import ExRunView
from matresdev.db.exdb.ex_run import ExRun
ex_path = os.path.join(simdb.exdata_dir, 'bending_tests', 'three_point',
'2012-10-11_BT-3PT-6c-2cm-0-TU_bs',
'BT-6c-2cm-0-TU-V1.csv')
exrun = ExRun(ex_path)
print 'F_max', np.max(exrun.ex_type.F)
eps_c = exrun.ex_type.eps_c_smoothed
M = exrun.ex_type.M_smoothed
eps_c_M_fn = MFnLineArray(xdata=M, ydata=eps_c)
eps_c_M_vct_fn = np.vectorize(eps_c_M_fn.get_value)
M_max = M[-1]
eps_c_max = np.min(eps_c)
n_states = 4
#M_arr = np.linspace(0, M_max, n_states + 1)[1:]
cf = np.linspace(0.8, 1.0, n_states)
print 'cf', cf
M_arr = cf * M_max
eps_c_arr = eps_c_M_vct_fn(M_arr)
print 'eps_c_max', eps_c_max
print 'M_arr', M_arr
print 'eps_c_arr', eps_c_arr
def __stress_strain_curve_default(self):
return MFnLineArray(ydata=[0., self.E], xdata=[0., 1.])
eps1_sig1 = tl.rtrace_mngr.rtrace_bound_list[1]
# eps0_sig0 = tl.rv_mngr.rv_list[0]
# eps1_sig1 = tl.rv_mngr.rv_list[1]
sig0_midx = argmax(np.fabs(eps0_sig0.trace.ydata))
sig1_midx = argmax(np.fabs(eps1_sig1.trace.ydata))
sig0_m = eps0_sig0.trace.ydata[sig0_midx]
sig1_m = eps1_sig1.trace.ydata[sig1_midx]
eps0_m = eps0_sig0.trace.xdata[sig0_midx]
eps1_m = eps1_sig1.trace.xdata[sig1_midx]
sig0_m_list.append(sig0_m)
sig1_m_list.append(sig1_m)
eps0_m_list.append(eps0_m)
eps1_m_list.append(eps1_m)
sig_plot = MFnLineArray(xdata=sig0_m_list, ydata=sig1_m_list)
eps_plot = MFnLineArray(xdata=eps0_m_list, ydata=eps1_m_list)
# sig_plot.configure_traits()
print('sig_plot.xdata', sig_plot.ydata)
p.plot(sig_plot.xdata, sig_plot.ydata)
p.show()
# Put the time-loop into the simulation-framework and map the
# object to the user interface.
#
TStepper as TS, RTraceGraph, RTraceDomainListField, TLoop, \
TLine, BCDofGroup, IBVPSolve as IS, DOTSEval
from ibvpy.fets.fets3D import FETS3D8H16U
from mathkit.mfn import MFnLineArray
#from lib.mats.mats2D.mats_cmdm2D.mats_mdm2d import MACMDM
from ibvpy.mats.mats2D.mats2D_sdamage.mats2D_sdamage import MATS2DScalarDamage
from ibvpy.mats.mats2D.mats2D_sdamage.strain_norm2d import *
from ibvpy.mats.mats3D.mats3D_elastic.mats3D_elastic import MATS3DElastic, MATS3DElasticNL
E = 28e+3
fets_eval = FETS3D8H16U(
mats_eval=MATS3DElasticNL(stress_strain_curve=MFnLineArray(
ydata=[E, 0., 0.1], xdata=[-1, 0., 1.])), )
from ibvpy.mesh.fe_grid import FEGrid
# Discretization
domain = FEGrid(coord_max=(3., 3., 3.),
shape=(3, 3, 3),
fets_eval=fets_eval)
# Put the tseval (time-stepper) into the spatial context of the
# discretization and specify the response tracers to evaluate there.
right_dof = 2
ts = TS(
sdomain=domain,
# conversion to list (square brackets) is only necessary for slicing of
# single dofs, e.g "get_left_dofs()[0,1]" which elsewise retuns an integer only
def _mfn_default(self):
return MFnLineArray(xdata=[0, 1], ydata=[1, 1])
def _get_mfn_line_array_target(self):
xdata, ydata = self.get_target_data_exdb_tensile_test()
print 'xdata[-1]', xdata[-1]
return MFnLineArray(xdata=xdata, ydata=ydata)
def app():
avg_radius = 0.03
md = MATS2DScalarDamage(E=20.0e3,
nu=0.2,
epsilon_0=1.0e-4,
epsilon_f=8.0e-4,
#epsilon_f = 12.0e-4, #test doubling the e_f
stress_state="plane_strain",
stiffness="secant",
#stiffness = "algorithmic",
strain_norm=Rankine())
me = MATS2DElastic(E=20.0e3,
nu=0.2,
stress_state="plane_strain")
fets_eval = FETS2D4Q(mats_eval=md)#, ngp_r = 3, ngp_s = 3)
n_el_x = 40
# Discretization
fe_grid = FEGrid(coord_max=(.6, .2, 0.),
shape=(n_el_x, n_el_x / 3),
fets_eval=fets_eval)
mf = MFnLineArray(xdata=array([0, 1, 2, 3, 4 ]),
ydata=array([0, 2., 2.5, 3., 3.2 ]))
#averaging function
avg_processor = RTNonlocalAvg(avg_fn=QuarticAF(radius=avg_radius,
correction=True))
ts = TS(sdomain=fe_grid,
u_processor=avg_processor,
bcond_list=[
# constraint for all left dofs in y-direction:
BCSlice(var='u', slice=fe_grid[0, 0, 0, 0], dims=[0, 1], value=0.),
BCSlice(var='u', slice=fe_grid[-1, 0, -1, 0], dims=[1], value=0.),
BCSlice(var='u', slice=fe_grid[n_el_x / 2, -1, 0, -1], dims=[1],
time_function=mf.get_value,
value= -2.0e-5),
],
rtrace_list=[
RTraceGraph(name='Fi,right over u_right (iteration)' ,
var_y='F_int', idx_y=right_dof,
var_x='U_k', idx_x=right_dof,
record_on='update'),
RTraceDomainListField(name='Strain' ,
var='eps_app', idx=0,
record_on='update'),
RTraceDomainListField(name='Displacement' ,
var='u', idx=1,
record_on='update',
warp=True),
RTraceDomainListField(name='Damage' ,
var='omega', idx=0,
record_on='update',
warp=True),
# RTraceDomainField(name = 'Stress' ,
# var = 'sig', idx = 0,
# record_on = 'update'),
# RTraceDomainField(name = 'N0' ,
# var = 'N_mtx', idx = 0,
# record_on = 'update')
]
)
# Add the time-loop control
#
tl = TLoop(tstepper=ts,
tolerance=5.0e-5,
KMAX=50,
tline=TLine(min=0.0, step=1., max=10.0))
tl.eval()
# Put the whole stuff into the simulation-framework to map the
# individual pieces of definition into the user interface.
#
from ibvpy.plugins.ibvpy_app import IBVPyApp
ibvpy_app = IBVPyApp(ibv_resource=ts)
ibvpy_app.main()
def _get_mfn(self):
return MFnLineArray(xdata=self.eps_arr, ydata=self.sig_arr)
