def example_3d():
from ibvpy.mats.mats3D.mats3D_elastic.mats3D_elastic import MATS3DElastic
from ibvpy.fets.fets3D.fets3D8h import FETS3D8H
fets_eval = FETS3D8H(mats_eval=MATS3DElastic())
fe_domain = FEDomain()
fe_level1 = FERefinementGrid(domain=fe_domain, fets_eval=fets_eval)
# Discretization
fe_domain1 = FEGrid(coord_max=(2., 5., 3.),
shape=(2, 3, 2),
level=fe_level1,
fets_eval=fets_eval)
fe_child_domain = FERefinementGrid(parent=fe_domain1,
fine_cell_shape=(2, 2, 2))
fe_child_domain.refine_elem((1, 1, 0))
fe_child_domain.refine_elem((0, 1, 0))
fe_child_domain.refine_elem((1, 1, 1))
fe_child_domain.refine_elem((0, 1, 1))
ts = TS(
dof_resultants=True,
sdomain=fe_domain,
bcond_list=[
BCDofGroup(var='f',
value=1.,
dims=[0],
get_dof_method=fe_domain1.get_top_dofs),
BCDofGroup(var='u',
value=0.,
dims=[0, 1],
get_dof_method=fe_domain1.get_bottom_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 ),
# RTraceDomainField(name = 'Displacement' ,
# var = 'u', idx = 0),
# RTraceDomainField(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 tloop.eval()
from ibvpy.plugins.ibvpy_app import IBVPyApp
ibvpy_app = IBVPyApp(ibv_resource=tloop)
ibvpy_app.main()
def notched_bended_beam():
fets_eval_4u = FETS2D4Q(mats_eval=MATS2DScalarDamage())
fets_eval_cracked = FETSLSEval(parent_fets=fets_eval_4u)
# Discretization
fe_domain1 = FEGrid(coord_max=(5., 2., 0.),
shape=(3, 2),
fets_eval=fets_eval_4u)
fe_child_domain = FERefinementGrid(parent_domain=fe_domain1,
fets_eval=fets_eval_cracked,
fine_cell_shape=(1, 1))
crack_level_set = lambda X: X[0] - 2.5
fe_child_domain.refine_elem((1, 0), crack_level_set)
dots = fe_child_domain.new_dots()
fe_domain = FEDomainList(subdomains=[fe_domain1])
fe_domain_tree = FEDomainTree(domain_list=fe_domain)
ts = TS(
dof_resultants=True,
sdomain=[fe_domain1, fe_child_domain],
bcond_list=[
BCDofGroup(var='u',
value=0.,
dims=[0, 1],
get_dof_method=fe_domain1.get_left_dofs),
BCDofGroup(var='u',
value=0.,
dims=[0, 1],
get_dof_method=fe_domain1.get_right_dofs),
BCDofGroup(var='f',
value=-1.,
dims=[1],
get_dof_method=fe_domain1.get_top_dofs),
],
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 ),
# RTraceDomainField(name = 'Displacement' ,
# var = 'u', idx = 0),
# RTraceDomainField(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(tloop.eval())
def run_example():
from ibvpy.api import \
TStepper as TS, RTraceGraph, RTraceDomainListField, \
RTraceDomainListInteg, TLoop, \
TLine, BCDof, IBVPSolve as IS, DOTSEval
from ibvpy.mats.mats2D.mats2D_conduction.mats2D_conduction import MATS2DConduction
from ibvpy.api import BCDofGroup
fets_eval = FETS2D4Q4T(mats_eval=MATS2DConduction(k=1.))
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=(1., 1., 0.), shape=(2, 2), fets_eval=fets_eval)
tstepper = TS(
sdomain=fe_grid,
bcond_list=[
BCDofGroup(var='u',
value=0.,
dims=[0],
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],
get_dof_method=fe_grid.get_top_right_dofs)
],
rtrace_list=[
# 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 = 'N0' ,
# var = 'N_mtx', idx = 0,
# record_on = 'update')
])
print tstepper.setup()
return
# Add the time-loop control
tloop = TLoop(tstepper=tstepper,
debug=False,
tline=TLine(min=0.0, step=1.0, max=1.0))
tloop.eval()
def example_2d():
from ibvpy.mats.mats2D.mats2D_elastic.mats2D_elastic import MATS2DElastic
from ibvpy.fets.fets2D.fets2D4q import FETS2D4Q
fets_eval = FETS2D4Q(mats_eval=MATS2DElastic(E=2.1e5))
# Discretization
fe_domain1 = FEGrid(coord_max=(2., 5., 0.),
shape=(10, 10),
fets_eval=fets_eval)
fe_subgrid1 = FERefinementLevel(parent=fe_domain1,
fine_cell_shape=(1, 1))
print 'children'
print fe_domain1.children
fe_subgrid1.refine_elem((5, 5))
fe_subgrid1.refine_elem((6, 5))
fe_subgrid1.refine_elem((7, 5))
fe_subgrid1.refine_elem((8, 5))
fe_subgrid1.refine_elem((9, 5))
fe_domain = FEDomain(subdomains=[fe_domain1])
ts = TS(dof_resultants=True,
sdomain=fe_domain,
bcond_list=[BCDofGroup(var='f', value=0.1, dims=[0],
get_dof_method=fe_domain1.get_top_dofs),
BCDofGroup(var='u', value=0., dims=[0, 1],
get_dof_method=fe_domain1.get_bottom_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),
# RTraceDomainField(name = 'Displacement' ,
# var = 'u', idx = 0),
# RTraceDomainField(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 tloop.eval()
from ibvpy.plugins.ibvpy_app import IBVPyApp
ibvpy_app = IBVPyApp(ibv_resource=tloop)
ibvpy_app.main()
# fets_eval = FETS2D4Q12U(mats_eval = MATS2DScalarDamage(strain_norm = Euclidean()))
fets_eval = FETS2D4Q12U(mats_eval=MATS2DElastic())
#fets_eval = FETS2D9Q(mats_eval = MACMDM())
from ibvpy.mesh.fe_grid import FEGrid
# Discretization
domain = FEGrid(coord_max=(1., 1., 0.), shape=(1, 1), fets_eval=fets_eval)
ts = TS(
sdomain=domain,
# conversion to list (square brackets) is only necessary for slicing of
# single dofs, e.g "get_left_dofs()[0,1]"
bcond_list=[
BCDofGroup(var='u',
value=0.,
dims=[0],
get_dof_method=domain.get_left_dofs),
BCDofGroup(var='u',
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' ,
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 _get_bc_list(self):
mid_zone_specimen = self.mid_zone_specmn_fe_grid
load_zone_specimen = self.load_zone_specmn_fe_grid
outer_zone_specimen = self.outer_zone_specmn_fe_grid
if self.elstmr_flag:
elastomer = self.elstmr_fe_grid
#--------------------------------------------------------------
# boundary conditions for the symmetry
#--------------------------------------------------------------
# symmetry in the xz-plane
# (Note: the x-axis corresponds to the axis of symmetry along the longitudinal axis of the beam)
#
bc_outer_zone_symplane_xz = BCSlice(var='u',
value=0.,
dims=[1],
slice=outer_zone_specimen[:,
0, :, :,
0, :])
bc_load_zone_symplane_xz = BCSlice(var='u',
value=0.,
dims=[1],
slice=load_zone_specimen[:, 0, :, :,
0, :])
bc_mid_zone_symplane_xz = BCSlice(var='u',
value=0.,
dims=[1],
slice=mid_zone_specimen[:, 0, :, :,
0, :])
if self.elstmr_flag:
bc_el_symplane_xz = BCSlice(var='u',
value=0.,
dims=[1],
slice=elastomer[:, 0, :, :, 0, :])
# symmetry in the yz-plane
#
bc_mid_zone_symplane_yz = BCSlice(var='u',
value=0.,
dims=[0],
slice=mid_zone_specimen[0, :, :,
0, :, :])
#--------------------------------------------------------------
# boundary conditions for the support
#--------------------------------------------------------------
bc_support_0y0 = BCSlice(var='u',
value=0.,
dims=[2],
slice=outer_zone_specimen[-1, :, 0, -1, :, 0])
#--------------------------------------------------------------
# connect all grids
#--------------------------------------------------------------
link_loadzn_outerzn = BCDofGroup(
var='u',
value=0.,
dims=[0, 1, 2],
get_dof_method=load_zone_specimen.get_right_dofs,
get_link_dof_method=outer_zone_specimen.get_left_dofs,
link_coeffs=[1.])
link_midzn_loadzn = BCDofGroup(
var='u',
value=0.,
dims=[0, 1, 2],
get_dof_method=mid_zone_specimen.get_right_dofs,
get_link_dof_method=load_zone_specimen.get_left_dofs,
link_coeffs=[1.])
if self.elstmr_flag:
link_elstmr_loadzn_z = BCDofGroup(
var='u',
value=0.,
dims=[2],
get_dof_method=elastomer.get_back_dofs,
get_link_dof_method=load_zone_specimen.get_front_dofs,
link_coeffs=[1.])
# hold elastomer in a single point in order to avoid kinematic movement yielding singular K_mtx
#
bc_elstmr_fix = BCSlice(var='u',
value=0.,
dims=[0],
slice=elastomer[0, 0, 0, 0, 0, 0])
#--------------------------------------------------------------
# loading
#--------------------------------------------------------------
# w_max = center displacement:
w_max = self.w_max
if self.elstmr_flag:
# apply displacement at all top nodes of the elastomer (surface load)
#
bc_w = BCSlice(var='u',
value=w_max,
dims=[2],
slice=elastomer[:, :, -1, :, :, -1])
else:
bc_w = BCSlice(
var='u',
value=w_max,
dims=[2],
# slice is only exactly in the center of the loading zone for 'load_zone_shape_x' = 2
# center line of the load zone
slice=load_zone_specimen[0, :, -1, -1, :, -1])
# f_max = 0.010 / 4. / self.sym_width
# bc_line_f = BCSlice(var = 'f', value = f_max, dims = [2],
# # slice is only valid for 'load_zone_shape_x' = 2
# # center line of the load zone
# slice = load_zone_specimen[0, :, -1, -1, :, -1])
bc_list = [
bc_outer_zone_symplane_xz,
bc_load_zone_symplane_xz,
bc_mid_zone_symplane_xz,
bc_mid_zone_symplane_yz,
#
link_midzn_loadzn,
link_loadzn_outerzn,
bc_support_0y0,
#
bc_w,
]
if self.elstmr_flag:
bc_list += [bc_el_symplane_xz, link_elstmr_loadzn_z, bc_elstmr_fix]
return bc_list
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
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()
def xtest_L_shaped():
'''Clamped bar 3 domains, each with 2 elems (displ at right end)
[0]-[1]-[2] [3]-[4]-[5] [6]-[7]-[8]
u[0] = 0, u[2] = u[3], u[5] = u[6], u[8] = 1'''
mp = MATS2DScalarDamage(
E=34.e3,
nu=0.2,
epsilon_0=59.e-6,
epsilon_f=3.2e-3,
#epsilon_f = 3.2e-1,
#stiffness = "algorithmic",
strain_norm_type='Mises')
# mp = MATS2DElastic( E = 34.e3,
# nu = 0.2 )
fets_eval = FETS2D4Q(mats_eval=mp)
discr = (10, 10)
# Discretization
fe_domain1 = FEGrid(coord_min=(0, 0, 0),
coord_max=(1., 1., 0.),
shape=discr,
n_nodal_dofs=fets_eval.n_nodal_dofs,
dof_r=fets_eval.dof_r,
geo_r=fets_eval.geo_r)
fe_domain2 = FEGrid(coord_min=(0., 1., 0),
coord_max=(1., 2., 0.),
shape=discr,
n_nodal_dofs=fets_eval.n_nodal_dofs,
dof_r=fets_eval.dof_r,
geo_r=fets_eval.geo_r)
fe_domain3 = FEGrid(coord_min=(1., 1., 0),
coord_max=(2., 2., 0.),
shape=discr,
n_nodal_dofs=fets_eval.n_nodal_dofs,
dof_r=fets_eval.dof_r,
geo_r=fets_eval.geo_r)
ts = TS(
iterms=[(fets_eval, fe_domain1), (fets_eval, fe_domain2),
(fets_eval, fe_domain3)],
dof_resultants=True,
bcond_list=[
BCDofGroup(var='u',
value=0.,
dims=[0, 1],
get_dof_method=fe_domain1.get_bottom_dofs),
BCDofGroup(var='u',
value=0.,
dims=[0, 1],
get_dof_method=fe_domain3.get_left_dofs,
get_link_dof_method=fe_domain2.get_right_dofs,
link_coeffs=[1.]),
BCDofGroup(var='u',
value=0.,
dims=[0, 1],
get_dof_method=fe_domain2.get_bottom_dofs,
get_link_dof_method=fe_domain1.get_top_dofs,
link_coeffs=[1.]),
BCDofGroup(var='u',
value=0.0004,
dims=[1],
get_dof_method=fe_domain3.get_right_dofs)
],
rtrace_list=[
RTraceDomainListField(name='Displacement', var='u', idx=1),
RTraceDomainListField(name='Damage',
var='omega',
idx=0,
record_on='update',
warp=True),
# RTraceDomainListField(name = 'Stress' ,
# var = 'sig_app', idx = 0,
# record_on = 'update',
# warp = False),
# RTraceDomainListField(name = 'Strain' ,
# var = 'eps_app', idx = 0,
# record_on = 'update',
# warp = False),
])
# Add the time-loop control
global tloop
tloop = TLoop(tstepper=ts,
tolerance=1e-4,
KMAX=50,
tline=TLine(min=0.0, step=0.2, max=1.0))
tloop.eval()
# import cProfile
# cProfile.run('tloop.eval()', 'tloop_prof' )
#
# 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)
from ibvpy.plugins.ibvpy_app import IBVPyApp
app = IBVPyApp(ibv_resource=tloop)
app.main()
level=fe_level1)
# fe_grid1.deactivate( (1,0) )
# fe_grid1.deactivate( (1,1) )
fe_xdomain = XFESubDomain(
domain=fe_domain,
fets_eval=xfets_eval,
# fe_grid_idx_slice = fe_grid1[1,0],
fe_grid_slice=fe_grid1['X - 0.5 -0.1*Y'])
ts = TS(
dof_resultants=True,
sdomain=fe_domain,
bcond_list=[
BCDofGroup(var='u',
value=0.,
dims=[0, 1],
get_dof_method=fe_grid1.get_right_dofs),
BCDofGroup(var='u',
value=0.,
dims=[1],
get_dof_method=fe_grid1.get_left_dofs),
BCDofGroup(var='u',
value=-1.,
dims=[0],
get_dof_method=fe_grid1.get_left_dofs),
],
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' ,
def _get_bc_list(self):
sp_fl_grid = self.specimen_fl_fe_grid
sp_cl_grid = self.specimen_cl_fe_grid
bs_grid = self.buttstrap_fe_grid
bs_clamp_grid = self.buttstrap_clamp_fe_grid
el_grid = self.elastomer_fe_grid
fl_grid = self.friction_fe_grid
link_sp_fl_cl = BCDofGroup(
var='u',
value=0.,
dims=[0, 1],
get_dof_method=sp_cl_grid.get_right_dofs,
get_link_dof_method=sp_fl_grid.get_left_dofs,
link_coeffs=[1.])
link_fl_sp = BCDofGroup(var='u',
value=0.,
dims=[0, 1],
get_dof_method=fl_grid.get_bottom_dofs,
get_link_dof_method=sp_cl_grid.get_top_dofs,
link_coeffs=[1.])
link_el_fl = BCDofGroup(var='u',
value=0.,
dims=[0, 1],
get_dof_method=el_grid.get_bottom_dofs,
get_link_dof_method=fl_grid.get_top_dofs,
link_coeffs=[1.])
link_bs_el = BCDofGroup(var='u',
value=0.,
dims=[0, 1],
get_dof_method=bs_grid.get_bottom_dofs,
get_link_dof_method=el_grid.get_top_dofs,
link_coeffs=[1.])
link_bs_clamp = BCDofGroup(var='u',
value=0.,
dims=[0, 1],
get_dof_method=bs_clamp_grid.get_right_dofs,
get_link_dof_method=bs_grid.get_left_dofs,
link_coeffs=[1.])
symx_bc = BCSlice(var='u',
slice=sp_fl_grid[-1, :, -1, :],
dims=[0],
value=0)
symy_fl_bc = BCSlice(var='u',
slice=sp_fl_grid[:, 0, :, 0],
dims=[1],
value=0)
symy_cl_bc = BCSlice(var='u',
slice=sp_cl_grid[:, 0, :, 0],
dims=[1],
value=0)
cntl_bc = BCSlice(var='u',
slice=bs_clamp_grid[0, :, 0, :],
dims=[0],
value=-0.001)
return [
symx_bc, symy_fl_bc, symy_cl_bc, cntl_bc, link_sp_fl_cl,
link_bs_clamp, link_fl_sp, link_el_fl, link_bs_el
]
def peval(self):
'''Evaluation procedure.
'''
#mv = MATS1DDamageView( model = mats_eval )
#mv.configure_traits()
right_dof_m = self.fe_grid_m[-1, -1].dofs[0, 0, 0]
right_dof_fb = self.fe_grid_fb[-1, -1, -1, -1].dofs[0, 0, 0]
# Response tracers
A = self.A_m + self.A_f
self.sig_eps_m = RTraceGraph(name='F_u_m',
var_y='F_int',
idx_y=right_dof_m,
var_x='U_k',
idx_x=right_dof_m,
transform_y='y / %g' % A)
# Response tracers
self.sig_eps_f = RTraceGraph(name='F_u_f',
var_y='F_int',
idx_y=right_dof_fb,
var_x='U_k',
idx_x=right_dof_fb,
transform_y='y / %g' % A)
self.eps_m_field = RTraceDomainListField(name='eps_m',
position='int_pnts',
var='eps_app',
warp=False)
self.eps_f_field = RTraceDomainListField(name='eps_f',
position='int_pnts',
var='mats_phase2_eps_app',
warp=False)
# Response tracers
self.sig_m_field = RTraceDomainListField(name='sig_m',
position='int_pnts',
var='sig_app')
self.sig_f_field = RTraceDomainListField(name='sig_f',
position='int_pnts',
var='mats_phase2_sig_app')
self.omega_m_field = RTraceDomainListField(name='omega_m',
position='int_pnts',
var='omega',
warp=False)
self.shear_flow_field = RTraceDomainListField(name='shear flow',
position='int_pnts',
var='shear_flow',
warp=False)
self.slip_field = RTraceDomainListField(name='slip',
position='int_pnts',
var='slip',
warp=False)
avg_processor = None
if self.avg_radius > 0.0:
n_dofs = self.fe_domain.n_dofs
avg_processor = RTUAvg(sd=self.fe_m_level,
n_dofs=n_dofs,
avg_fn=QuarticAF(radius=self.avg_radius))
ts = TStepper(
u_processor=avg_processor,
dof_resultants=True,
sdomain=self.fe_domain,
bcond_list=[ # define the left clamping
BCSlice(var='u',
value=0.,
dims=[0],
slice=self.fe_grid_fb[0, 0, 0, :]),
# BCSlice( var = 'u', value = 0., dims = [0], slice = self.fe_grid_m[ 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=self.final_displ,
dims=[0],
slice=self.fe_grid_fb[-1, -1, -1, :],
time_function=self.time_function),
# BCSlice( var = 'u', value = self.final_displ, dims = [0], slice = self.fe_grid_m[-1, -1],
# time_function = self.time_function ),
# 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=self.fe_grid_fb[:, :, :, :]),
# # Connect bond and matrix domains
BCDofGroup(var='u',
value=0.,
dims=[0],
get_link_dof_method=self.fe_grid_fb.get_bottom_dofs,
get_dof_method=self.fe_grid_m.get_all_dofs,
link_coeffs=[1.])
],
rtrace_list=[
self.sig_eps_m,
self.sig_eps_f,
self.eps_m_field,
self.eps_f_field,
self.sig_m_field,
self.sig_f_field,
self.omega_m_field,
self.shear_flow_field,
self.slip_field,
])
# Add the time-loop control
tloop = TLoop(tstepper=ts,
KMAX=300,
tolerance=1e-5,
debug=False,
verbose_iteration=True,
verbose_time=False,
tline=TLine(min=0.0, step=self.step_size, max=1.0))
tloop.on_accept_time_step = self.plot
U = tloop.eval()
self.sig_eps_f.refresh()
max_sig_m = max(self.sig_eps_m.trace.ydata)
return array([U[right_dof_m], max_sig_m], dtype='float_')
def example_1d():
from ibvpy.mats.mats1D.mats1D_elastic.mats1D_elastic import MATS1DElastic
from ibvpy.fets.fets1D.fets1D2l import FETS1D2L
from ibvpy.fets.fets1D.fets1D2l3u import FETS1D2L3U
from ibvpy.fets.fets_ls.fets_crack import FETSCrack
fets_eval = FETS1D2L(mats_eval=MATS1DElastic(E=1.))
xfets_eval = FETSBimaterial(mats_eval=MATS1DElastic(E=1.),
mats_eval2=MATS1DElastic(E=2.),
parent_fets=fets_eval, int_order=1)
# Discretization
fe_domain = FEDomain()
fe_level1 = FERefinementGrid(domain=fe_domain, fets_eval=fets_eval)
fe_grid1 = FEGrid(coord_max=(2., 0., 0.),
shape=(1,),
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 - 0.'])
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=[0],
get_dof_method=fe_grid1.get_left_dofs),
],
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),
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 = 2,
# debug = True, RESETMAX = 2,
tline=TLine(min=0.0, step=1, max=1.0))
# print "elements ",fe_xdomain.elements[0]
if enr:
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.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)
print(tloop.eval())
# #ts.setup()
from ibvpy.plugins.ibvpy_app import IBVPyApp
ibvpy_app = IBVPyApp(ibv_resource=ts)
ibvpy_app.main()
fe_grid5 = FEGrid( name = 'fe_grid5', coord_min = (0, 0, 2.),
coord_max = (2., 6.,2.),
shape = (1,3),
fets_eval = fets_eval_4u,
level = fe_rgrid3 )
fe_grid6 = FEGrid( name = 'fe_grid6', coord_min = (2., 6, 2.),
coord_max = (10, 15, 2.),
shape = (1,3),
fets_eval = fets_eval_4u,
level = fe_rgrid3 )
ts = TS( dof_resultants = True,
sdomain = fe_domain,
bcond_list = [BCDofGroup(var='f', value = 1., dims = [0],
get_dof_method = fe_grid1.get_top_dofs ),
BCDofGroup(var='u', value = 0., dims = [0,1],
get_dof_method = fe_grid1.get_bottom_dofs ),
],
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 = False ),
# RTraceDomainField(name = 'Displacement' ,
# var = 'u', idx = 0),
# RTraceDomainField(name = 'N0' ,
# var = 'N_mtx', idx = 0,
# record_on = 'update')
]
)
def _get_bc_list(self):
specmn = self.specmn_fe_grid
mid_specmn = self.mid_specmn_fe_grid
if self.elstmr_flag:
elstmr = self.elstmr_fe_grid
#--------------------------------------------------------------
# boundary conditions for the symmetry
#--------------------------------------------------------------
# the x-axis corresponds to the axis of symmetry along the longitudinal axis of the beam:
bc_symplane_xz = BCSlice(var='u',
value=0.,
dims=[1],
slice=specmn[:, 0, :, :, 0, :])
bc_mid_symplane_xz = BCSlice(var='u',
value=0.,
dims=[1],
slice=mid_specmn[:, 0, :, :, 0, :])
bc_mid_symplane_yz = BCSlice(var='u',
value=0.,
dims=[0],
slice=mid_specmn[0, :, :, 0, :, :])
if self.elstmr_flag:
bc_el_symplane_xz = BCSlice(var='u',
value=0.,
dims=[1],
slice=elstmr[:, 0, :, :, 0, :])
bc_el_symplane_yz = BCSlice(var='u',
value=0.,
dims=[0],
slice=elstmr[0, :, :, 0, :, :])
#--------------------------------------------------------------
# boundary conditions for the support
#--------------------------------------------------------------
bc_support_0y0 = BCSlice(var='u',
value=0.,
dims=[2],
slice=specmn[-1, :, 0, -1, :, 0])
#--------------------------------------------------------------
# link domains
#--------------------------------------------------------------
link_msp_sp = BCDofGroup(var='u',
value=0.,
dims=[0, 1, 2],
get_dof_method=mid_specmn.get_right_dofs,
get_link_dof_method=specmn.get_left_dofs,
link_coeffs=[1.])
# link_msp_sp_xyz = BCSlice(var = 'u', value = 0., dims = [0, 1, 2],
# slice = specmn[0, :, :, 0, :, :],
# link_slice = mid_specmn[-1 :, :, -1, :, :],
# link_dims = [0, 1, 2],
# link_coeffs = [1.])
# link_msp_sp_y = BCSlice(var = 'u', value = 0., dims = [1],
# slice = specmn[0, :, :, 0, :, :],
# link_slice = mid_specmn[-1 :, :, -1, :, :],
# link_dims = [1],
# link_coeffs = [1.])
#
# link_msp_sp_z = BCSlice(var = 'u', value = 0., dims = [2],
# slice = specmn[0, :, :, 0, :, :],
# link_slice = mid_specmn[-1 :, :, -1, :, :],
# link_dims = [2],
# link_coeffs = [1.])
# link_msp_sp = [ link_msp_sp_xyz ]
if self.elstmr_flag:
link_el_sp = BCDofGroup(
var='u',
value=0.,
dims=[2],
get_dof_method=elstmr.get_back_dofs,
get_link_dof_method=mid_specmn.get_front_dofs,
link_coeffs=[1.])
#--------------------------------------------------------------
# loading
#--------------------------------------------------------------
w_max = self.w_max
# f_max = -0.010 / 0.10 # [MN/m]
if self.elstmr_flag:
# apply displacement at all top node (surface load)
#
bc_w = BCSlice(var='u',
value=w_max,
dims=[2],
slice=elstmr[:, :, -1, :, :, -1])
# apply a single force at the center of the beam (system origin at top of the elastomer
# and us elastomer-domain as load distribution plate with a high stiffness (e.g. steel)
# F_max = -0.010 #[MN]
# bc_F = BCSlice(var = 'f', value = F_max, dims = [2],
# slice = elstmr[0, 0, -1, 0, 0, -1])
else:
# center top nodes (line load)
#
bc_w = BCSlice(var='u',
value=w_max,
dims=[2],
slice=mid_specmn[0, :, -1, 0, :, -1])
# NOTE: the entire symmetry axis (yz)-plane is moved downwards
# in order to avoid large indentations at the top nodes
#
# bc_center_w = BCSlice( var = 'w', value = w_max, dims = [2], slice = mid_specmn[0, :, :, 0, :, :] )
bc_list = [
bc_symplane_xz, bc_mid_symplane_xz, bc_mid_symplane_yz,
bc_support_0y0, link_msp_sp, bc_w
]
if self.elstmr_flag:
bc_list_elstmr = [link_el_sp, bc_el_symplane_xz, bc_el_symplane_yz]
bc_list += bc_list_elstmr
return bc_list
