def _get_rt_list(self):
'''Prepare the list of tracers
'''
right_dof = self.fe_grid[-1, -1].dofs[0, 0, 0]
eps_app = RTraceDomainListField(name='Strain',
position='int_pnts',
var='eps_app',
warp=False)
damage = RTraceDomainListField(name='Damage',
position='int_pnts',
var='omega',
warp=False)
disp = RTraceDomainListField(name='Displacement',
position='int_pnts',
var='u',
warp=False)
sig_app = RTraceDomainListField(name='Stress',
position='int_pnts',
var='sig_app')
rt_fu = RTraceGraph(name='Fi,right over u_right (iteration)',
var_y='F_int',
idx_y=right_dof,
var_x='U_k',
idx_x=right_dof)
return [rt_fu, eps_app, damage, sig_app, disp]
def example_with_new_domain():
from ibvpy.api import \
TStepper as TS, RTDofGraph, RTraceDomainListField, TLoop, \
TLine, BCDof, IBVPSolve as IS, DOTSEval
from ibvpy.mats.mats1D.mats1D_elastic.mats1D_elastic import MATS1DElastic
fets_eval = FETS1D2L3U(mats_eval=MATS1DElastic(E=10.))
from ibvpy.mesh.fe_grid import FEGrid
# Discretization
domain = FEGrid(coord_max=(3., ),
shape=(3, ),
fets_eval=fets_eval)
ts = TS(dof_resultants=True,
sdomain=domain,
# conversion to list (square brackets) is only necessary for slicing of
# single dofs, e.g "get_left_dofs()[0,1]"
# bcond_list = [ BCDof(var='u', dof = 0, value = 0.) ] +
# [ BCDof(var='u', dof = 2, value = 0.001 ) ]+
# [ ) ],
bcond_list=[BCDof(var='u', dof=0, value=0.),
# BCDof(var='u', dof = 1, link_dofs = [2], link_coeffs = [0.5],
# value = 0. ),
# BCDof(var='u', dof = 2, link_dofs = [3], link_coeffs = [1.],
# value = 0. ),
BCDof(var='f', dof=6, value=1,
# link_dofs = [2], link_coeffs = [2]
)],
rtrace_list=[RTDofGraph(name='Fi,right over u_right (iteration)',
var_y='F_int', idx_y=0,
var_x='U_k', idx_x=1),
RTraceDomainListField(name='Stress',
var='sig_app', idx=0),
RTraceDomainListField(name='Displacement',
var='u', idx=0),
RTraceDomainListField(name='N0',
var='N_mtx', idx=0,
record_on='update')
]
)
# Add the time-loop control
tloop = TLoop(tstepper=ts,
tline=TLine(min=0.0, step=1, max=1.0))
print('---- result ----')
print(tloop.eval())
print(ts.F_int)
print(ts.rtrace_list[0].trace.ydata)
# 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
app = IBVPyApp(ibv_resource=tloop)
app.main()
def __demo__():
from ibvpy.api import \
TStepper as TS, RTDofGraph, RTraceDomainListField, TLoop, \
TLine, BCDof
from ibvpy.tmodel.mats1D.mats1D_elastic.mats1D_elastic import MATS1DElastic
fets_eval = FETS1D2L(mats_eval=MATS1DElastic(E=10.))
from ibvpy.mesh.fe_grid import FEGrid
# Discretization
domain = FEGrid(coord_max=(3., ), shape=(3, ), fets_eval=fets_eval)
ts = TS(dof_resultants=True,
sdomain=domain,
bcond_list=[
BCDof(var='u', dof=0, value=0.),
BCDof(
var='f',
dof=3,
value=1,
)
],
rtrace_list=[
RTDofGraph(name='Fi,right over u_right (iteration)',
var_y='F_int',
idx_y=0,
var_x='U_k',
idx_x=1),
RTraceDomainListField(name='Stress', var='sig_app', idx=0),
RTraceDomainListField(name='Displacement',
var='u',
idx=0,
warp=True),
RTraceDomainListField(name='N0',
var='N_mtx',
idx=0,
record_on='update')
])
# Add the time-loop control
tloop = TLoop(tstepper=ts, tline=TLine(min=0.0, step=0.5, max=1.0))
print('---- result ----')
print(tloop.eval())
print(ts.F_int)
print(ts.rtrace_list[0].trace.ydata)
# Put the whole stuff into the simulation-framework to map the
# individual pieces of definition into the user interface.
#
app = IBVPyApp(ibv_resource=tloop)
app.main()
def _get_fracture_energy(self):
return RTraceDomainListField(
name='Fracture energy',
# position = 'int_pnts',
var='fracture_energy',
record_on='update',
)
def _get_u(self):
return RTraceDomainListField(
name='displacement',
var='u',
warp=True,
record_on='update',
)
def _get_phi_pdc(self):
return RTraceDomainListField(
name='principal damage',
# position = 'int_pnts',
var='phi_pdc',
record_on='update',
)
def _get_max_omega_i(self):
return RTraceDomainListField(
name='max_omega_i',
# position = 'int_pnts',
var='max_omega_i',
record_on='update',
)
def _get_sig_app(self):
return RTraceDomainListField(
name='sig_app',
position='int_pnts',
var='sig_app',
record_on='update',
)
def _get_max_princ_stress(self):
return RTraceDomainListField(
name='max principle stress',
idx=0,
# position = 'int_pnts',
var='max_principle_sig',
record_on='update',
)
def _max_princ_stress_default(self):
return RTraceDomainListField(
name='max principle stress',
idx=0,
var='max_principle_sig',
warp=True,
# position = 'int_pnts',
record_on='update',
)
slice=interior_bc,
link_slice=fe_grid[0, 0],
link_coeffs=[0],
value=0.0),
BCSlice(var='u', dims=[0], slice=fe_grid[-1, -1], value=1.0)
]
fe_grid.inactive_elems = list(interior_elems)
print('elems', interior_bc.elems)
print('dofs', interior_bc.dofs)
print('nodes', interior_bc.dof_nodes)
rtrace_list = [
RTraceDomainListField(
name='sig_app',
var='sig_app',
record_on='update',
)
]
ts = TS(
sdomain=fe_grid,
bcond_list=bcond_list,
rtrace_list=rtrace_list,
)
tloop = TLoop(tstepper=ts, )
u = tloop.eval()
# from ibvpy.plugins.ibvpy_app import IBVPyApp
# ibvpy_app = IBVPyApp( ibv_resource = tloop )
def __demo__():
from ibvpy.api import \
TStepper as TS, RTraceGraph, RTraceDomainListField, TLoop, \
TLine, BCSlice, FEDomain, FERefinementGrid
from ibvpy.mats.mats1D.mats1D_elastic.mats1D_elastic import MATS1DElastic
fets_eval = FETS1D2L(mats_eval = MATS1DElastic(E = 10.))
from ibvpy.mesh.fe_grid import FEGrid
fe_domain = FEDomain()
r1 = FERefinementGrid(fets_eval = fets_eval,
domain = fe_domain)
r2 = FERefinementGrid(fets_eval = fets_eval,
domain = fe_domain)
# Discretization
domain1 = FEGrid(coord_max = (3.,),
shape = (3,),
fets_eval = fets_eval,
level = r1)
domain2 = FEGrid(coord_min = (3.,),
coord_max = (6.,),
shape = (3,),
fets_eval = fets_eval,
level = r2)
ts = TS(dof_resultants = True,
sdomain = fe_domain,
bcond_list = [BCSlice(var = 'u', dims = [0], value = 0, slice = domain1[0, 0]),
BCSlice(var = 'u', dims = [0], value = 0, slice = domain1[-1, -1],
link_slice = domain2[0, 0], link_coeffs = [1.]),
BCSlice(var = 'f', dims = [0], value = 1, slice = domain2[-1, -1])
],
rtrace_list = [RTraceGraph(name = 'Fi,right over u_right (iteration)' ,
var_y = 'F_int', idx_y = 0,
var_x = 'U_k', idx_x = 1),
RTraceDomainListField(name = 'Stress' ,
var = 'sig_app', idx = 0),
RTraceDomainListField(name = 'Displacement' ,
var = 'u', idx = 0,
warp = True),
RTraceDomainListField(name = 'N0' ,
var = 'N_mtx', idx = 0,
record_on = 'update')
]
)
# Add the time-loop control
tloop = TLoop(tstepper = ts,
tline = TLine(min = 0.0, step = 0.5, max = 1.0))
print '---- result ----'
print tloop.eval()
print ts.F_int
print ts.rtrace_list[0].trace.ydata
# 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
app = IBVPyApp(ibv_resource = tloop)
app.main()
def example_2d():
from ibvpy.api import FEDomain, FERefinementGrid, FEGrid, TStepper as TS, \
BCDofGroup, RTraceDomainListField
from ibvpy.core.tloop import TLoop, TLine
from ibvpy.mesh.xfe_subdomain import XFESubDomain
from ibvpy.mats.mats2D.mats2D_elastic.mats2D_elastic import MATS2DElastic
from ibvpy.mats.mats2D import MATS2DPlastic
from ibvpy.fets.fets2D.fets2D4q import FETS2D4Q
from ibvpy.fets.fets2D import FETS2D9Q
from ibvpy.fets.fets2D.fets2D4q8u import FETS2D4Q8U
from ibvpy.fets.fets_ls.fets_crack import FETSCrack
#fets_eval = FETS2D4Q( mats_eval = MATS2DPlastic( E = 1., nu = 0. ) )
fets_eval = FETS2D4Q8U(mats_eval=MATS2DPlastic(E=1., nu=0.))
xfets_eval = FETSCrack(parent_fets=fets_eval,
int_order=5,
tri_subdivision=1)
# Discretization
fe_domain = FEDomain()
fe_level1 = FERefinementGrid(domain=fe_domain, fets_eval=fets_eval)
fe_grid1 = FEGrid(coord_max=(1., 1.),
shape=(8, 8),
fets_eval=fets_eval,
level=fe_level1)
#ls_function = lambda X, Y: X - Y - 0.13
ls_function = lambda X, Y: (X - 0.52)**2 + (Y - 0.72)**2 - 0.51**2
bls_function = lambda X, Y: -((X - 0.5)**2 + (Y - 0.21)**2 - 0.28**2)
bls_function2 = lambda X, Y: -((X - 0.5)**2 + (Y - 0.21)**2 - 0.38**2)
# design deficits:
# - How to define a level set spanned over several fe_grids
# (i.e. it is defined over the hierarchy of FESubDomains)
# - Patching of subdomains within the FEPatchedGrid (FERefinementGrid)
# - What are the compatibility conditions?
# - What is the difference between FEGridLeveSetSlice
# and FELSDomain?
# FELSDomain is associated with a DOTS - Slice is not.
# FEGrid has a multidimensional array - elem_grid
# it can be accessed through this index.
# it is masked by the activity map. The activity map can
# be defined using slices and level sets.
# the elems array enumerates the elements using the activity map.
# in this way, the specialization of grids is available implicitly.
#
fe_xdomain = FELSDomain(
domain=fe_domain,
fets_eval=xfets_eval,
fe_grid=fe_grid1,
ls_function=ls_function,
bls_function=bls_function,
)
fe_tip_xdomain = FELSDomain(
domain=fe_domain,
fets_eval=xfets_eval,
fe_grid=fe_xdomain,
ls_function=bls_function,
)
# deactivation must be done only after the dof enumeration has been completed
fe_xdomain.deactivate_intg_elems_in_parent()
fe_tip_xdomain.deactivate_intg_elems_in_parent()
fe_xdomain.bls_function = bls_function2
fe_tip_xdomain.ls_function = bls_function2
# deactivation must be done only after the dof enumeration has been completed
fe_xdomain.deactivate_intg_elems_in_parent()
fe_tip_xdomain.deactivate_intg_elems_in_parent()
#
# General procedure:
# 1) define the level sets with the boundaries
# 2) use the bls to identify the tips of the level set
# 3) use independent level sets to introduce indpendently junctions.
#
# get the extended dofs of the bls_elems and constrain it
#
cdofs = fe_tip_xdomain.elem_xdof_map.flatten()
bc_list = [BCDof(var='u', dof=dof, value=0.0) for dof in cdofs]
# construct the time stepper
ts = TS(
dof_resultants=True,
sdomain=fe_domain,
bcond_list=[
BCSlice(
var='u', value=-0.1, dims=[1], slice=fe_grid1[:, 0, :, 0]),
BCSlice(
var='u', value=0., dims=[0], slice=fe_grid1[:, 0, :, 0]),
BCSlice(var='u',
value=0.,
dims=[0, 1],
slice=fe_grid1[:, -1, :, -1])
] + bc_list,
rtrace_list=[
# RTDofGraph(name = 'Fi,right over u_right (iteration)' ,
# var_y = 'F_int', idx_y = 0,
# var_x = 'U_k', idx_x = 1),
RTraceDomainListField(name='Stress',
var='sig_app',
idx=0,
warp=True),
RTraceDomainListField(name='Displacement',
var='u',
idx=0,
warp=True),
# RTraceDomainField(name = 'N0' ,
# var = 'N_mtx', idx = 0,
# record_on = 'update')
])
#
do = 'print'
if do == 'print':
p = 'state'
if p == 'grids':
print('fe_xdomain.ls mask')
print(fe_xdomain.ls_mask)
print('fe_xdomain.idx mask')
print(fe_xdomain.idx_mask)
print('fe_xdomain.intg mask')
print(fe_xdomain.intg_mask)
print('fe_xdomain.xelems_mask')
print(fe_xdomain.xelems_mask)
print('fe_xdomain.xelems_grid_ix')
print(fe_xdomain.xelems_grid_ix)
print('fe_xdomain.ls_elem_grid')
print(fe_xdomain.ls_elem_grid)
print('fe_xdomain.ls_ielem_grid')
print(fe_xdomain.ls_ielem_grid)
print('fe_xdomain.intg_elem_grid')
print(fe_xdomain.intg_elem_grid)
print('fe_tip_xdomain.ls_mask`')
print(fe_tip_xdomain.ls_mask)
print('fe_tip_xdomain.intg_mask`')
print(fe_tip_xdomain.intg_mask)
print('fe_tip_xdomain.idx_mask`')
print(fe_tip_xdomain.idx_mask)
print('fe_tip_xdomain.xelems_mask')
print(fe_tip_xdomain.xelems_mask)
print('fe_tip_xdomain.xelems_grid_ix')
print(fe_tip_xdomain.xelems_grid_ix)
print('fe_tip_xdomain.ls_elem_grid')
print(fe_tip_xdomain.ls_elem_grid)
print('fe_tip_xdomain.ls_ielems_grid')
print(fe_tip_xdomain.ls_ielem_grid)
print('fe_tip_xdomain.intg_elem_grid')
print(fe_tip_xdomain.intg_elem_grid)
if p == 'maps':
print('fe_xdomain.elem_dof_map')
print(fe_xdomain.elem_dof_map)
print('fe_tip_xdomain.elem_dof_map')
print(fe_tip_xdomain.elem_dof_map)
print('fe_xdomain.elems')
print(fe_xdomain.elems)
print('fe_tip_xdomain.elems')
print(fe_tip_xdomain.elems)
print('fe_xdomain.elem_X_map')
print(fe_xdomain.elem_X_map)
print('fe_tip_xdomain.elem_X_map')
print(fe_tip_xdomain.elem_X_map)
if p == 'fields':
print("ls_values ", fe_xdomain.dots.dof_node_ls_values)
print("tip ls_values ", fe_tip_xdomain.dots.dof_node_ls_values)
print('intersection points ', fe_xdomain.ls_intersection_r)
print('tip intersection points ',
fe_tip_xdomain.ls_intersection_r)
print("triangles ", fe_xdomain.dots.rt_triangles)
print("vtk points ", fe_xdomain.dots.vtk_X)
print("vtk data ",
fe_xdomain.dots.get_vtk_cell_data('blabla', 0, 0))
print('ip_triangles', fe_xdomain.dots.int_division)
print('ip_coords', fe_xdomain.dots.ip_coords)
print('ip_weigths', fe_xdomain.dots.ip_weights)
print('ip_offset', fe_xdomain.dots.ip_offset)
print('ip_X_coords', fe_xdomain.dots.ip_X)
print('ip_ls', fe_xdomain.dots.ip_ls_values)
print('vtk_ls', fe_xdomain.dots.vtk_ls_values)
print('J_det ', fe_xdomain.dots.J_det_grid)
if p == 'state':
# Add the time-loop control
print('STATE: initial')
print('fe_xdomain.dots.state_elem grid')
print(fe_xdomain.dots.state_start_elem_grid)
print('fe_tip_xdomain.dots.state_elem grid')
print(fe_tip_xdomain.dots.state_start_elem_grid)
print('fe_xdomain.dots.state_end_elem grid')
print(fe_xdomain.dots.state_end_elem_grid)
print('fe_tip_xdomain.dots.state_end_elem grid')
print(fe_tip_xdomain.dots.state_end_elem_grid)
fe_xdomain.dots.state_array[:] = 25.5
print('state_array 25', fe_xdomain.dots.state_array)
fe_tip_xdomain.dots.state_array[:] = 58
bls_function3 = lambda X, Y: -((X - 0.5)**2 +
(Y - 0.21)**2 - 0.58**2)
fe_xdomain.bls_function = bls_function3
fe_tip_xdomain.ls_function = bls_function3
print('STATE: changed')
print('fe_xdomain.dots.state_elem grid')
print(fe_xdomain.dots.state_start_elem_grid)
print('fe_tip_xdomain.dots.state_elem grid')
print(fe_tip_xdomain.dots.state_start_elem_grid)
print('fe_xdomain.dots.state_end_elem grid')
print(fe_xdomain.dots.state_end_elem_grid)
print('fe_tip_xdomain.dots.state_end_elem grid')
print(fe_tip_xdomain.dots.state_end_elem_grid)
print('state_array 25', fe_xdomain.dots.state_array.shape)
print('state_array 25', fe_xdomain.dots.state_array[570:])
print('state_array 58', fe_tip_xdomain.dots.state_array.shape)
elif do == 'ui':
tloop = TLoop(tstepper=ts,
debug=False,
tolerance=1e-4,
KMAX=3,
RESETMAX=0,
tline=TLine(min=0.0, step=1, max=1.0))
tloop.eval()
from ibvpy.plugins.ibvpy_app import IBVPyApp
ibvpy_app = IBVPyApp(ibv_resource=ts)
ibvpy_app.main()
def _get_tloop(self):
#--------------------------------------------------------------
# ts
#--------------------------------------------------------------
mid_zone_spec = self.mid_zone_specmn_fe_grid
load_zone_spec = self.load_zone_specmn_fe_grid
outer_zone_spec = self.outer_zone_specmn_fe_grid
if self.elstmr_flag:
# ELSTRMR TOP SURFACE
# dofs at elastomer top surface (used to integrate the force)
#
elastomer = self.elstmr_fe_grid
elstmr_top_dofs_z = elastomer[:, :, -1, :, :,
-1].dofs[:, :, 2].flatten()
load_dofs_z = np.unique(elstmr_top_dofs_z)
print 'load_dofs_z', load_dofs_z
else:
# LINE LOAD TOP OF LOAD ZONE
# dofs at center line of the specmn load zone (used to integrate the force)
# note slice index in x-direction is only valid for load_zone_shape_x = 2 !
#
load_zone_spec_topline_dofs_z = load_zone_spec[
0, :, -1, -1, :, -1].dofs[:, :, 2].flatten()
load_dofs_z = np.unique(load_zone_spec_topline_dofs_z)
print 'load_dofs_z', load_dofs_z
# SUPPRT LINE
# dofs at support line of the specmn (used to integrate the force)
#
outer_zone_spec_supprtline_dofs_z = outer_zone_spec[
-1, :, 0, -1, :, 0].dofs[:, :, 2].flatten()
supprt_dofs_z = np.unique(outer_zone_spec_supprtline_dofs_z)
print 'supprt_dofs_z', supprt_dofs_z
# CENTER DOF (used for tracing of the displacement)
#
center_bottom_dof = mid_zone_spec[0, 0, 0, 0, 0, 0].dofs[0, 0, 2]
print 'center_bottom_dof', center_bottom_dof
# THIRDPOINT DOF (used for tracing of the displacement)
# dofs at center middle of the laod zone at the bottom side
#
# NOTE: slice index in x-direction is only valid for load_zone_shape_x = 2 !
thirdpoint_bottom_dof = load_zone_spec[0, 0, 0, -1, 0, 0].dofs[0, 0, 2]
print 'thirdpoint_bottom_dof', thirdpoint_bottom_dof
# force-displacement-diagram (CENTER)
#
self.f_w_diagram_center = RTraceGraph(
name='displacement_elasttop (center) - force',
var_x='U_k',
idx_x=center_bottom_dof,
var_y='F_int',
idx_y_arr=load_dofs_z,
record_on='update',
transform_x='-x * 1000', # %g * x' % ( fabs( w_max ),),
# due to symmetry the total force sums up from four parts of the beam (2 symmetry axis):
#
transform_y='-4000. * y')
# force-displacement-diagram_supprt (SUPPRT)
#
self.f_w_diagram_supprt = RTraceGraph(
name='displacement_supprtline (center) - force',
var_x='U_k',
idx_x=center_bottom_dof,
var_y='F_int',
idx_y_arr=supprt_dofs_z,
record_on='update',
transform_x='-x * 1000', # %g * x' % ( fabs( w_max ),),
# due to symmetry the total force sums up from four parts of the beam (2 symmetry axis):
#
transform_y='4000. * y')
# force-displacement-diagram (THIRDPOINT)
#
self.f_w_diagram_thirdpoint = RTraceGraph(
name='displacement_elasttop (thirdpoint) - force',
var_x='U_k',
idx_x=thirdpoint_bottom_dof,
var_y='F_int',
idx_y_arr=load_dofs_z,
record_on='update',
transform_x='-x * 1000', # %g * x' % ( fabs( w_max ),),
# due to symmetry the total force sums up from four parts of the beam (2 symmetry axis):
#
transform_y='-4000. * y')
ts = TS(
sdomain=self.fe_domain,
bcond_list=self.bc_list,
rtrace_list=[
self.f_w_diagram_center,
self.f_w_diagram_thirdpoint,
self.f_w_diagram_supprt,
RTraceDomainListField(name='Displacement',
var='u',
idx=0,
warp=True),
# RTraceDomainListField(name = 'Stress' ,
# var = 'sig_app', idx = 0, warp = True,
# record_on = 'update'),
# RTraceDomainListField(name = 'Strain' ,
# var = 'eps_app', idx = 0, warp = True,
# record_on = 'update'),
# RTraceDomainListField(name = 'Damage' ,
# var = 'omega_mtx', idx = 0, warp = True,
# record_on = 'update'),
RTraceDomainListField(name='max_omega_i',
warp=True,
var='max_omega_i',
idx=0,
record_on='update'),
# RTraceDomainListField(name = 'IStress' ,
# position = 'int_pnts',
# var = 'sig_app', idx = 0,
# record_on = 'update'),
# RTraceDomainListField(name = 'IStrain' ,
# position = 'int_pnts',
# var = 'eps_app', idx = 0,
# record_on = 'update'),
])
# Add the time-loop control
tloop = TLoop(tstepper=ts,
KMAX=50,
tolerance=self.tolerance,
RESETMAX=0,
tline=TLine(min=0.0, step=self.tstep, max=self.tmax),
ord=self.ord)
return tloop
def example_with_new_domain():
from ibvpy.api import \
TStepper as TS, RTraceGraph, RTraceDomainListField, \
RTraceDomainListInteg, TLoop, \
TLine, BCDof, IBVPSolve as IS, 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=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=[
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='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 example():
from ibvpy.api import \
TStepper as TS, RTDofGraph, RTraceDomainListField, TLoop, \
TLine, IBVPSolve as IS, DOTSEval, BCSlice
from ibvpy.mesh.fe_grid import FEGrid
from mathkit.mfn import MFnLineArray
stiffness_concrete = 34000 * 0.03 * 0.03
A_fiber = 1.
E_fiber = 1.
stiffness_fiber = E_fiber * A_fiber
d = 2 * sqrt(Pi)
tau_max = 0.1 * d * Pi
G = 100
u_max = 0.023
f_max = 0.2
mats_eval = MATS1D5Bond(mats_phase1=MATS1DElastic(E=stiffness_fiber),
mats_phase2=MATS1DElastic(E=0),
mats_ifslip=MATS1DPlastic(E=G,
sigma_y=tau_max,
K_bar=0.,
H_bar=0.),
mats_ifopen=MATS1DElastic(E=0))
fets_eval = FETS1D52L4ULRH(mats_eval=mats_eval)
domain = FEGrid(coord_max=(1., 0.2),
shape=(16, 1),
fets_eval=fets_eval)
end_dof = domain[-1, 0, -1, 0].dofs[0, 0, 0]
ts = TS(dof_resultants=True,
sdomain=domain,
# conversion to list (square brackets) is only necessary for slicing of
# single dofs, e.g "get_left_dofs()[0,1]"
bcond_list=[
BCSlice(var='u', value=0., dims=[0],
slice=domain[:, :, :, -1]),
BCSlice(var='u', value=0., dims=[1],
slice=domain[:, :, :, :]),
BCSlice(var='f', value=f_max, dims=[0],
slice=domain[-1, 0, -1, 0])
],
rtrace_list=[RTDofGraph(name='Fi,right over u_right (iteration)',
var_y='F_int', idx_y=end_dof,
var_x='U_k', idx_x=end_dof),
RTraceDomainListField(name='slip',
var='slip', idx=0),
RTraceDomainListField(name='eps1',
var='eps1', idx=0),
RTraceDomainListField(name='eps2',
var='eps2', idx=0),
RTraceDomainListField(name='shear_flow',
var='shear_flow', idx=0),
RTraceDomainListField(name='sig1',
var='sig1', idx=0),
RTraceDomainListField(name='sig2',
var='sig2', idx=0),
RTraceDomainListField(name='Displacement',
var='u', idx=0)
])
# Add the time-loop control
tloop = TLoop(tstepper=ts, KMAX=30, debug=False,
tline=TLine(min=0.0, step=0.1, max=1.0))
print(tloop.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
app = IBVPyApp(ibv_resource=tloop)
app.main()
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 = 60
# Discretization
fe_grid = FEGrid(coord_max=(.6, .15, 0.),
shape=(n_el_x, 15),
fets_eval=fets_eval)
mf = MFnLineArray(xdata=array([0, 1, 2, 7, 8 , 28]),
ydata=array([0, 3., 3.2, 3.3, 3.32, 3.72 ]))
#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=[
# 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='Deformation' ,
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-4,
KMAX=100,
tline=TLine(min=0.0, step=.25, 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 eval(self):
elem_length = self.length / float(self.shape)
flaw_radius = self.flaw_radius
mats = MATS1DElasticWithFlaw(E=10.,
flaw_position=self.flaw_position,
flaw_radius=flaw_radius,
reduction_factor=self.reduction_factor)
#fets_eval = FETS1D2L( mats_eval = mats )
fets_eval = FETS1D2L3U(mats_eval=mats)
domain = FEGrid(coord_max=(self.length, 0., 0.),
shape=(self.shape, ),
fets_eval=fets_eval)
avg_processor = RTNonlocalAvg(
avg_fn=QuarticAF(radius=self.avg_radius, correction=True))
eps_app = RTraceDomainListField(name='Strain',
position='int_pnts',
var='eps_app',
warp=False)
damage = RTraceDomainListField(name='Damage',
position='int_pnts',
var='omega',
warp=False)
disp = RTraceDomainListField(name='Displacement',
position='int_pnts',
var='u',
warp=False)
sig_app = RTraceDomainListField(name='Stress',
position='int_pnts',
var='sig_app')
right_dof = domain[-1, -1].dofs[0, 0, 0]
rt_fu = RTDofGraph(name='Fi,right over u_right (iteration)',
var_y='F_int',
idx_y=right_dof,
var_x='U_k',
idx_x=right_dof)
ts = TS(
u_processor=avg_processor,
dof_resultants=True,
sdomain=domain,
# conversion to list (square brackets) is only necessary for slicing of
# single dofs, e.g "get_left_dofs()[0,1]"
# bcond_list = [ BCDof(var='u', dof = 0, value = 0.) ] +
# [ BCDof(var='u', dof = 2, value = 0.001 ) ]+
# [ ) ],
bcond_list=[
BCDof(var='u', dof=0, value=0.),
# BCDof(var='u', dof = 1, link_dofs = [2], link_coeffs = [0.5],
# value = 0. ),
# BCDof(var='u', dof = 2, link_dofs = [3], link_coeffs = [1.],
# value = 0. ),
BCDof(
var='u',
dof=right_dof,
value=0.01,
)
],
rtrace_list=[
rt_fu,
eps_app,
# damage,
sig_app,
disp,
])
# Add the time-loop control
tloop = TLoop(tstepper=ts,
KMAX=100,
tolerance=1e-5,
verbose_iteration=False,
tline=TLine(min=0.0, step=1.0, max=1.0))
U = tloop.eval()
p.subplot(221)
rt_fu.refresh()
rt_fu.trace.plot(p)
eps = eps_app.subfields[0]
xdata = eps.vtk_X[:, 0]
ydata = eps.field_arr[:, 0, 0]
idata = argsort(xdata)
p.subplot(222)
p.plot(xdata[idata], ydata[idata], 'o-')
disp = disp.subfields[0]
xdata = disp.vtk_X[:, 0]
ydata = disp.field_arr[:, 0]
idata = argsort(xdata)
p.subplot(223)
p.plot(xdata[idata], ydata[idata], 'o-')
sig = sig_app.subfields[0]
xdata = sig.vtk_X[:, 0]
ydata = sig.field_arr[:, 0, 0]
idata = argsort(xdata)
p.subplot(224)
p.plot(xdata[idata], ydata[idata], 'o-')
def peval( self ):
'''Evaluation procedure.
'''
#mv = MATS1DDamageView( model = mats_eval )
#mv.configure_traits()
self.mats_m.reset_state()
# Discretization
#
length = self.length
domain = FEGrid( coord_min = ( 0., length / 5. ),
coord_max = ( length, 0. ),
shape = ( self.shape, 1 ),
fets_eval = self.fets )
right_dofs = domain[-1, -1, -1, :].dofs[0, :, 0]
print 'concrete_dofs', id( domain ), domain[:, 0, :, 0].dofs
# Response tracers
self.stress_strain = RTraceGraph( name = 'Fi,right over u_right (iteration)' ,
var_y = 'F_int', idx_y = right_dofs[0],
var_x = 'U_k', idx_x = right_dofs[0] )
self.eps_m_field = RTraceDomainListField( name = 'eps_m' , position = 'int_pnts',
var = 'eps1', idx = 0,
warp = True )
self.eps_f_field = RTraceDomainListField( name = 'eps_f' , position = 'int_pnts',
var = 'eps2', idx = 0,
warp = True )
# Response tracers
self.sig_m_field = RTraceDomainListField( name = 'sig_m' , position = 'int_pnts',
var = 'mats_phase1_sig_app', idx = 0 )
self.sig_f_field = RTraceDomainListField( name = 'sig_f' , position = 'int_pnts',
var = 'mats_phase2_sig_app', idx = 0 )
self.omega_m_field = RTraceDomainListField( name = 'omega_m' , position = 'int_pnts',
var = 'mats_phase1_omega', idx = 0,
warp = True )
#
damage_onset_displ = self.mats_m.epsilon_0 * self.length
go_behind = 1.5
finish_displ = go_behind * damage_onset_displ
n_steps = 20
step_size = ( finish_displ - damage_onset_displ ) / n_steps
tmax = 1 + n_steps
def ls( t ):
if t <= 1:
return t
else:
return 1.0 + ( t - 1.0 ) / n_steps * ( go_behind - 1 )
ts = TSCrackLoc(
dof_resultants = True,
on_update = self.plot,
sdomain = domain,
bcond_list = [# define the left clamping
BCSlice( var = 'u', value = 0., dims = [0], slice = domain[ 0, 0, 0, :] ),
# loading at the right edge
BCSlice( var = 'f', value = 1, dims = [0], slice = domain[-1, -1, -1, 0],
time_function = ls ),
# BCSlice(var='u', value = finish_displ, dims = [0], slice = domain[-1,-1,-1, 0],
# time_function = ls ),
# fix horizontal displacement in the top layer
BCSlice( var = 'u', value = 0., dims = [0], slice = domain[:, -1, :, -1] ),
# fix the vertical displacement all over the domain
BCSlice( var = 'u', value = 0., dims = [1], slice = domain[ :, :, :, :] )
],
rtrace_list = [ self.stress_strain,
self.eps_m_field,
self.eps_f_field,
self.sig_m_field,
self.sig_f_field,
self.omega_m_field ]
)
# Add the time-loop control
tloop = TLoop( tstepper = ts, KMAX = 200, debug = True, tolerance = 1e-5,
tline = TLine( min = 0.0, step = 1.0, max = 1.0 ) )
print ts.rte_dict.keys()
U = tloop.eval()
self.plot()
return array( [ U[right_dofs[-1]] ], dtype = 'float_' )
def __demo__():
from ibvpy.api import \
TStepper as TS, RTraceDomainListField, TLoop, \
TLine, BCSlice, FEDomain, FERefinementGrid, FEGrid
from ibvpy.mats.mats2D.mats2D_elastic.mats2D_elastic import MATS2DElastic
fets_eval = FETS2D4Q8U(mats_eval=MATS2DElastic())
fe_domain = FEDomain()
r1 = FERefinementGrid(fets_eval=fets_eval, domain=fe_domain)
r2 = FERefinementGrid(fets_eval=fets_eval, domain=fe_domain)
# Discretization
domain1 = FEGrid(coord_max=(3., 3.),
shape=(10, 4),
fets_eval=fets_eval,
level=r1)
domain2 = FEGrid(coord_min=(3., 0.),
coord_max=(6., 3),
shape=(10, 4),
fets_eval=fets_eval,
level=r2)
ts = TS(
dof_resultants=True,
sdomain=[domain1, domain2], # fe_domain,
bcond_list=[
# Fix the left edge of domain1
BCSlice(var='u', dims=[0, 1], value=0, slice=domain1[0, :, 0, :]),
# Link the right edge of domain1 with the left edge of domain2
#
# note that following arrays must have the same lengths:
# slice and link_slice
# dims, link_dims and link_coeffs must have the same lengths
# VAR-1:
# linking along the complete line between 'domain1' and 'domain2'
# all nodes along the y-axis
# (used linking of more nodes at once in 'BCSlice')
#
BCSlice(var='u',
dims=[0, 1],
value=0.0,
slice=domain1[-1, :, -1, :],
link_slice=domain2[0, :, 0, :],
link_dims=[0, 1],
link_coeffs=[1., 1.]),
# VAR-2:
# linking along individual points between 'domain1' and 'domain2'
# (used linking of single nodes in 'BCSlice')
#
# BCSlice(var='u', dims=[0, 1], value=0.0,
# slice=domain1[-1, -1, -1, -1],
# link_slice=domain2[0, -1, 0, -1],
# link_dims=[0, 1],
# link_coeffs=[1., 1.]),
# BCSlice(var='u', dims=[0, 1], value=0.0,
# slice=domain1[-1, 0, -1, 0],
# link_slice=domain2[0, 0, 0, 0],
# link_dims=[0, 1],
# link_coeffs=[1., 1.]),
# Load the right edge of domain2
BCSlice(var='f', dims=[0], value=1, slice=domain2[-1, :, -1, :])
],
rtrace_list=[
RTraceDomainListField(name='Stress', var='sig_app', idx=0),
RTraceDomainListField(name='Displacement',
var='u',
idx=0,
warp=True),
])
# Add the time-loop control
tloop = TLoop(tstepper=ts,
debug=False,
tline=TLine(min=0.0, step=1.0, max=1.0))
print '---- result ----'
print tloop.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
app = IBVPyApp(ibv_resource=tloop)
app.main()
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()
def simgrid(
fets_eval,
cube_size,
shape,
support_slices,
support_dirs,
loading_slice,
load_dir=0,
load_max=0.01,
n_load_steps=1,
vars=[],
ivars=[],
var_type='u',
):
'''Construct an idealization and run simulation with primary variable
fixed on support slices and with unit load on loading slices applied in load dir.
Return the solution vector and the fields specified in vars.
'''
# Discretization
domain = FEGrid(coord_max=cube_size, shape=shape, fets_eval=fets_eval)
u_max = load_max
support_bcond = [
BCSlice(var='u',
value=0,
dims=support_dir,
slice=domain[support_slice])
for support_slice, support_dir in zip(support_slices, support_dirs)
]
load_bcond = [
BCSlice(var=var_type,
value=u_max,
dims=[load_dir],
slice=domain[loading_slice])
]
bcond = support_bcond + load_bcond
loading_dofs = domain[loading_slice].dofs[:, :, load_dir].flatten()
graphs = [
RTraceGraph(name='Force in one node / Displ.',
var_y='F_int',
idx_x=loading_dof,
var_x='U_k',
idx_y=loading_dof) for loading_dof in loading_dofs
]
rtrace_list = [
RTraceDomainListField(
name=var,
var=var,
warp=True,
#position = 'int_pnts',
record_on='update') for var in vars
]
irtrace_list = [
RTraceDomainListInteg(name='Integ(' + var + ')',
var=var,
record_on='update') for var in ivars
]
ts = TS(sdomain=domain,
bcond_list=bcond,
rtrace_list=graphs + rtrace_list + irtrace_list)
load_step = 1. / float(n_load_steps)
# Add the time-loop control
tloop = TLoop(tstepper=ts,
KMAX=15,
RESETMAX=0,
tolerance=1e-5,
tline=TLine(min=0.0, step=load_step, max=1.0))
u = tloop.eval()
fields = [rtrace.subfields[0].field_arr for rtrace in rtrace_list]
integs = [rtrace.integ_val for rtrace in irtrace_list]
for graph in graphs:
graph.redraw()
traces = [graph.trace for graph in graphs]
xydata = (traces[0].xdata, column_stack([trace.ydata for trace in traces]))
return tloop, u, fields, integs, xydata
def example_with_new_domain():
from ibvpy.api import \
TStepper as TS, RTraceDomainListField, TLoop, TLine
from ibvpy.tmodel.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()
value=0.002,
dims=[1],
get_dof_method=domain.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),
# RTraceDomainListField(name = 'Stress' ,
# var = 'sig_app', idx = 0,
# record_on = 'update'),
# RTraceDomainListField(name = 'Displacement' ,
# var = 'u', idx = 1),
RTraceDomainListField(
name='Stress',
#position = 'int_pnts',
var='sig_app',
idx=1),
# RTraceDomainListField(name = 'N0' ,
# var = 'N_mtx', idx = 0,
# record_on = 'update')
])
# Add the time-loop control
#
tl = TLoop(tstepper=ts, 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.
#
def example_2d():
from ibvpy.mats.mats2D.mats2D_elastic.mats2D_elastic import MATS2DElastic
from ibvpy.fets.fets2D.fets2D4q import FETS2D4Q
from ibvpy.fets.fets2D.fets2D4q8u import FETS2D4Q8U
from ibvpy.fets.fets2D.fets2D4q9u import FETS2D4Q9U
from ibvpy.fets.fets2D.fets2D9q import FETS2D9Q
fets_eval = FETS2D4Q(mats_eval=MATS2DElastic(E=1., nu=0.))
xfets_eval = FETSBimaterial(parent_fets=fets_eval,
int_order=3,
mats_eval=MATS2DElastic(E=1., nu=0.),
mats_eval2=MATS2DElastic(E=5., nu=0.))
# Discretization
fe_domain = FEDomain()
fe_level1 = FERefinementGrid(domain=fe_domain, fets_eval=fets_eval)
fe_grid1 = FEGrid(coord_max=(3., 1., 0.),
shape=(3, 1),
fets_eval=fets_eval,
level=fe_level1)
fe_xdomain = XFESubDomain(
domain=fe_domain,
fets_eval=xfets_eval,
#fe_grid_idx_slice = fe_grid1[1,0],
fe_grid_slice=fe_grid1['X - 1.5'])
ts = TS(
dof_resultants=True,
sdomain=fe_domain,
bcond_list=[
BCDofGroup(var='u',
value=1.,
dims=[0],
get_dof_method=fe_grid1.get_right_dofs),
BCDofGroup(var='u',
value=0.,
dims=[1],
get_dof_method=fe_grid1.get_right_dofs),
BCDofGroup(var='u',
value=0.,
dims=[0, 1],
get_dof_method=fe_grid1.get_left_dofs),
],
rtrace_list=[
# RTraceGraph(name = 'Fi,right over u_right (iteration)' ,
# var_y = 'F_int', idx_y = 0,
# var_x = 'U_k', idx_x = 1),
# RTraceDomainListField(name = 'Stress' ,
# var = 'sig_app', idx = 0, warp = True ),
RTraceDomainListField(name='Displacement',
var='u',
idx=0,
warp=True),
RTraceDomainListField(name='Strain',
var='eps',
idx=0,
warp=True),
# RTraceDomainField(name = 'N0' ,
# var = 'N_mtx', idx = 0,
# record_on = 'update')
])
#
# # Add the time-loop control
tloop = TLoop(
tstepper=ts,
# tolerance = 1e-4, KMAX = 4,
# debug = True, RESETMAX = 2,
tline=TLine(min=0.0, step=1., max=1.0))
#print "elements ",fe_xdomain.elements[0]
fe_xdomain.deactivate_sliced_elems()
print 'parent elems ', fe_xdomain.fe_grid_slice.elems
print 'parent dofs ', fe_xdomain.fe_grid_slice.dofs
print "dofmap ", fe_xdomain.elem_dof_map
print "ls_values ", fe_xdomain.dots.dof_node_ls_values
print 'intersection points ', fe_xdomain.fe_grid_slice.r_i
print "triangles ", fe_xdomain.dots.rt_triangles
print "vtk points ", fe_xdomain.dots.vtk_X
print "vtk data ", fe_xdomain.dots.get_vtk_cell_data('blabla', 0, 0)
print 'ip_triangles', fe_xdomain.dots.int_division
print 'ip_coords', fe_xdomain.dots.ip_coords
print 'ip_weigths', fe_xdomain.dots.ip_weights
print 'ip_offset', fe_xdomain.dots.ip_offset
print 'ip_X_coords', fe_xdomain.dots.ip_X
print 'ip_ls', fe_xdomain.dots.ip_ls_values
print 'vtk_ls', fe_xdomain.dots.vtk_ls_values
print 'J_det ', fe_xdomain.dots.J_det_grid
print tloop.eval()
# #ts.setup()
from ibvpy.plugins.ibvpy_app import IBVPyApp
ibvpy_app = IBVPyApp(ibv_resource=ts)
ibvpy_app.main()
def example_with_new_domain():
from ibvpy.api import \
TStepper as TS, RTraceDomainListField, TLoop, \
TLine, BCSlice
from ibvpy.fets.fets2D.fets2D4q8u import FETS2D4Q8U
from ibvpy.tmodel.mats3D.mats3D_cmdm import \
MATS3DMicroplaneDamage
from ibvpy.tmodel.matsXD.matsXD_cmdm import PhiFnStrainSoftening
# tmodel = MATS2DElastic(E=2,nu= .2,
# stress_state= 'rotational_symetry')
mats = MATS3DMicroplaneDamage(model_version='stiffness',
E=34e3,
nu=0.2,
phi_fn=PhiFnStrainSoftening(G_f=0.001117,
f_t=2.8968))
fets_eval = FETS2Drotsym(prototype_fets=FETS2D4Q8U(),
mats_eval=mats)
fets_eval.vtk_r *= 0.9
from ibvpy.mesh.fe_grid import FEGrid
radius = sqrt(1. / pi)
# f_i = (radius/2.)*2*pi
# f_o = (radius)*2*pi
# print 'f ',f_i,' ', f_o
# Discretization
fe_grid = FEGrid( # coord_min = (0.,radius/2.,0.),
coord_max=(1., radius, 0.),
shape=(20, 20),
fets_eval=fets_eval)
tstepper = TS(sdomain=fe_grid,
bcond_list=[
BCSlice(var='u', value=0., dims=[0],
slice=fe_grid[0, :, 0, :]),
BCSlice(var='u', value=0., dims=[1],
slice=fe_grid[0, 0, 0, 0]),
BCSlice(var='u', value=1.e-3, dims=[0],
slice=fe_grid[-1, :, -1, :]),
],
rtrace_list=[
RTraceDomainListField(name='Stress',
var='sig_app', idx=0, warp=True,
record_on='update'),
RTraceDomainListField(name='fracture_energy',
var='fracture_energy', idx=0, warp=True,
record_on='update'),
RTraceDomainListField(name='Displacement',
var='u', 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()
get_dof_method=domain.get_bottom_left_dofs),
BCDofGroup(var='u',
value=0.002,
dims=[0],
get_dof_method=domain.get_right_dofs)
],
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 = 'Deformation' ,
# var = 'eps', idx = 0,
# record_on = 'update'),
RTraceDomainListField(name='Displacement',
var='u',
idx=0,
warp=True),
# RTraceDomainListField(name = 'Stress' ,
# var = 'sig', idx = 0,
# record_on = 'update'),
# RTraceDomainListField(name = 'N0' ,
# var = 'N_mtx', idx = 0,
# record_on = 'update')
])
# Add the time-loop control
tloop = TLoop(tstepper=ts,
KMAX=4,
RESETMAX=0,
tolerance=1e-3,
tline=TLine(min=0.0, step=1.0, max=1.0))
BCDofGroup(var='u',
value=0.,
dims=[1, 2],
get_dof_method=domain.get_bottom_left_dofs),
BCDofGroup(var='u',
value=0.002,
dims=[0],
get_dof_method=domain.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='Deformation',
var='eps_app',
idx=0,
record_on='update'),
RTraceDomainListField(name='Displacement', var='u', idx=0),
# RTraceDomainListField(name = 'Stress' ,
# var = 'sig', idx = 0,
# record_on = 'update'),
# RTraceDomainListField(name = 'N0' ,
# var = 'N_mtx', idx = 0,
# record_on = 'update')
])
# Add the time-loop control
tloop = TLoop(tstepper=ts, tline=TLine(min=0.0, step=0.5, max=1.0))
tloop.eval()
value=0.,
dims=[1],
get_dof_method=domain.get_bottom_left_dofs),
BCDofGroup(var='u',
value=0.002,
dims=[0],
get_dof_method=domain.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),
# RTraceDomainField(name = 'Stress' ,
# var = 'sig_app', idx = 0,
# record_on = 'update'),
RTraceDomainListField(name='Displacement', var='u', idx=0),
# RTraceDomainField(name = 'N0' ,
# var = 'N_mtx', idx = 0,
# record_on = 'update')
])
# Add the time-loop control
tl = TLoop(tstepper=ts, tline=TLine(min=0.0, step=0.5, 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
app = IBVPyApp(ibv_resource=tl)
app.main()
def example_1d():
fets_eval = FETS1D2L3U(mats_eval=MATS1DElastic(E=20.))
xfets_eval = FETSCrack(parent_fets=fets_eval, int_order=2)
# Discretization
fe_domain = FEDomain()
fe_level1 = FERefinementGrid(domain=fe_domain, fets_eval=fets_eval)
fe_grid1 = FEGrid(coord_max=(2., 0., 0.),
shape=(2, ),
fets_eval=fets_eval,
level=fe_level1)
enr = True
if enr:
fe_xdomain = XFESubDomain(
domain=fe_domain,
fets_eval=xfets_eval,
#fe_grid_idx_slice = fe_grid1[1,0],
fe_grid_slice=fe_grid1['X - .75'])
fe_xdomain.deactivate_sliced_elems()
ts = TS(
dof_resultants=True,
sdomain=fe_domain,
bcond_list=[
BCSlice(var='u',
value=-1. / 2.,
dims=[0],
slice=fe_grid1[0, 0]),
BCSlice(var='u', value=0., dims=[0], slice=fe_grid1[-1, -1]),
],
rtrace_list=[
# RTDofGraph(name = 'Fi,right over u_right (iteration)' ,
# var_y = 'F_int', idx_y = 0,
# var_x = 'U_k', idx_x = 1),
RTraceDomainListField(name='Stress',
var='eps',
idx=0,
warp=True),
RTraceDomainListField(name='Displacement',
var='u',
idx=0,
warp=True),
# RTraceDomainField(name = 'N0' ,
# var = 'N_mtx', idx = 0,
# record_on = 'update')
])
#
# # Add the time-loop control
tloop = TLoop(tstepper=ts,
debug=True,
tolerance=1e-4,
RESETMAX=0,
tline=TLine(min=0.0, step=1, max=1.0))
#print "elements ",fe_xdomain.elements[0]
if enr:
print('parent elems ', fe_xdomain.fe_grid_slice.elems)
print('parent dofs ', fe_xdomain.fe_grid_slice.dofs)
print("dofmap ", fe_xdomain.elem_dof_map)
print("ls_values ", fe_xdomain.dots.dof_node_ls_values)
print('intersection points ', fe_xdomain.fe_grid_slice.r_i) #
print("triangles ", fe_xdomain.dots.int_division)
print('ip_coords', fe_xdomain.dots.ip_coords)
print('ip_weigths', fe_xdomain.dots.ip_weights)
print('ip_offset ', fe_xdomain.dots.ip_offset)
print('ip_X_coords', fe_xdomain.dots.ip_X)
print('ip_ls', fe_xdomain.dots.ip_ls_values)
print('vtk_X ', fe_xdomain.dots.vtk_X)
print('vtk triangles ', fe_xdomain.dots.rt_triangles)
print("vtk data ",
fe_xdomain.dots.get_vtk_cell_data('blabla', 0, 0))
print('vtk_ls', fe_xdomain.dots.vtk_ls_values)
print('J_det ', fe_xdomain.dots.J_det_grid)
tloop.eval()
from ibvpy.plugins.ibvpy_app import IBVPyApp
ibvpy_app = IBVPyApp(ibv_resource=ts)
ibvpy_app.main()
