def app():
mdm = MATS2DElastic()
fets_eval = FETS2D4Q(mats_eval=mdm)
fe_domain = FEDomain()
fe_rgrid = FERefinementGrid(name='fe_grid1', fets_eval=fets_eval, domain=fe_domain)
fe_grid = FEGrid(coord_max=(2.0, 1.0),
shape=(2, 1),
fets_eval=fets_eval,
level=fe_rgrid)
for i in range(0, 1):
fe_grid.deactivate((1, 0))
ts = TS(sdomain=fe_grid,
bcond_list=[
BCSlice(var='u', slice=fe_grid[-1, :, -1, :], dims=[0, 1], value=0.),
BCSlice(var='u', slice=fe_grid[0, 0, :-1, :], dims=[0, 1], value=0.),
BCSlice(var='u', slice=fe_grid[-1, 0, 0, -1], dims=[1],
value= -1.0),
],
rtrace_list=[
RTraceDomainListField(name='Strain' ,
var='eps_app', idx=0,
record_on='update'),
RTraceDomainListField(name='Stress' ,
var='sig_app', idx=0,
record_on='update'),
RTraceDomainListField(name='Displacement' ,
var='u', idx=1,
record_on='update',
warp=True)
]
)
tl = TLoop(tstepper=ts,
tolerance=5.0e-5,
KMAX=200,
tline=TLine(min=0.0, step=.1, max=0.1))
tl.eval()
from ibvpy.plugins.ibvpy_app import IBVPyApp
ibvpy_app = IBVPyApp(ibv_resource=ts)
ibvpy_app.main()
def example_1d():
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.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. ) ) #, A=1.))
#xfets_eval = fets_eval # use the same element for the enrichment
xfets_eval = FETSCrack( parent_fets = fets_eval )
# Discretization
fe_domain = FEDomain()
fe_level1 = FERefinementGrid( domain = fe_domain, fets_eval = fets_eval )
fe_grid1 = FEGrid( coord_max = ( 4., 0., 0. ),
shape = ( 4, ),
fets_eval = fets_eval,
level = fe_level1 )
enr = True
if enr:
fe_xdomain = XFESubDomain( domain = fe_domain,
fets_eval = xfets_eval,
fe_grid_slice = fe_grid1[ '(X - 2) **2 - 0.5 ' ] )
fe_xdomain.deactivate_sliced_elems()
print 'elem_dof_map', fe_xdomain.elem_dof_map
fe_domain = FEDomain()
fe_level1 = FERefinementGrid( domain = fe_domain, fets_eval = fets_eval )
fe_grid1 = FEGrid( coord_max = ( 4 * 3.14, 0., 0. ),
shape = ( 8, ),
fets_eval = fets_eval,
level = fe_level1 )
enr = True
if enr:
fe_xdomain = XFESubDomain( domain = fe_domain,
fets_eval = xfets_eval,
fe_grid_slice = fe_grid1[ 'cos(X) - 0.5' ] )
fe_xdomain.deactivate_sliced_elems()
print 'elem_dof_map2', fe_xdomain.elem_dof_map
def app():
avg_radius = 30
thickness = 50.0 # mm
md = MATS2DScalarDamage(E=30.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_stress",
stiffness="secant",
# stiffness = "algorithmic",
strain_norm=Rankine())
mdm = MATS2DMicroplaneDamage(E=30.0e3,
nu=0.2,
# epsilon_f = 12.0e-4, #test doubling the e_f
# 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() stress_state="plane_strain",
model_version='compliance',
phi_fn=PhiFnStrainSoftening(
G_f=0.124,
f_t=3.3,
md=0.0,
h=12.5))
fets_eval = FETS2D4Q(mats_eval=mdm) # , ngp_r = 3, ngp_s = 3)
fe_domain = FEDomain()
fe_rgrid = FERefinementGrid(name='fe_grid1', fets_eval=fets_eval, domain=fe_domain)
n_half = 30
n_el_x = n_half * 2 + 1
n_el_y = n_el_x / 10
# Discretization
fe_grid = FEGrid(coord_max=(2000.0, 200.0, 0.),
shape=(n_el_x, n_el_y),
fets_eval=fets_eval,
level=fe_rgrid)
for i in range(0, n_el_y / 2):
fe_grid.deactivate((n_half, i))
mf = MFnLineArray(xdata=array([0, 1]),
ydata=array([0, 1]))
# 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]
loading_dofs = fe_grid[n_el_x / 2, -1, (0, -1), -1].dofs.flatten()
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), -1], dims=[1],
time_function=mf.get_value,
value= -0.5),
],
rtrace_list=[RTraceGraph(name='Fi,right over u_right (iteration)' ,
var_y='F_int', idx_y_arr=loading_dofs,
var_x='U_k', idx_x=loading_dof,
transform_x='-x', transform_y='-y*%g' % thickness,
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=0.2))
tl.setup()
# print avg_processor.C_mtx
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 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 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()
return rte_dict
#----------------------- example --------------------
if __name__ == '__main__':
from ibvpy.api import \
TStepper as TS, FEGrid, RTraceGraph, RTraceDomainField, TLoop, \
TLine, BCDof, DOTSEval, RTraceDomainListField
fets_eval = FEQ4T()
single_elem = True
if single_elem:
quad_elem = FEGrid(coord_min=(-5, -5),
coord_max=(10, 10),
fets_eval=fets_eval,
shape=(1, 1))
print quad_elem.dof_grid_spec.node_coords
print 'xxxx'
ts = TS(
sdomain=quad_elem,
bcond_list=[BCDof(var='u', dof=i, value=0.) for i in [0, 3]] +
[BCDof(var='f', dof=i, value=10) for i in [1, 2]],
rtrace_list=[
RTraceDomainListField(name='Temperature',
var='u',
warp=False,
idx=0,
record_on='update'),
RTraceDomainListField(name='Flux',
var='eps',
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()
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
from ibvpy.fets.fets_ls.fets_crack import FETSCrack
fets_eval = FETS2D4Q(mats_eval = MATS2DElastic(E= 1.,nu=0.))
xfets_eval = FETSCrack( parent_fets = fets_eval, int_order = 5 )
# Discretization
fe_domain = FEDomain()
fe_level1 = FERefinementGrid( domain = fe_domain, fets_eval = fets_eval )
fe_grid1 = FEGrid( coord_max = (1.,1.,0.),
shape = (1,1),
fets_eval = fets_eval,
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 '] )
print 'test',fe_grid1.get_right_dofs()
ts = TS( dof_resultants = True,
sdomain = fe_domain,
bcond_list = [BCDofGroup(var='u', value = 0., dims = [0,1],
get_dof_method = fe_grid1.get_left_dofs ),
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()
from ibvpy.api import FEDomain, FEGrid, FERefinementGrid, TStepper as TS
from ibvpy.fets.fets2D.fets2D4q import FETS2D4Q
if __name__ == '__main__':
fets_eval_4u = FETS2D4Q(mats_eval=MATS2DElastic())
fe_domain = FEDomain()
fe_rgrid1 = FERefinementGrid(name='fe_rgrid1',
fets_eval=fets_eval_4u,
domain=fe_domain)
fe_grid1 = FEGrid(name='fe_grid1',
coord_max=(2., 6., 0.),
shape=(1, 3),
fets_eval=fets_eval_4u,
level=fe_rgrid1)
fe_grid2 = FEGrid(name='fe_grid2',
coord_min=(2., 6, 0.),
coord_max=(10, 15, 0.),
shape=(3, 2),
fets_eval=fets_eval_4u,
level=fe_rgrid1)
print(fe_grid2[1, 0].elems)
fe_grid2.deactivate((1, 0))
print('activation map')
print(fe_grid2.activation_map)
def _get_sdomain(self):
return FEGrid(coord_min=(0., ),
coord_max=(self.L_x, ),
shape=(self.n_E, ),
fets_eval=self.fets_eval)
# Created on Jan 21, 2011 by: rch
from ibvpy.mats.mats2D.mats2D_elastic.mats2D_elastic import MATS2DElastic
from ibvpy.mats.mats1D.mats1D_elastic.mats1D_elastic import MATS1DElastic
from ibvpy.api import FEDomain, FEGrid, FERefinementGrid, TStepper as TS, TLoop, \
BCSlice, RTraceDomainListField
from ibvpy.fets.fets2D.fets2D4q import FETS2D4Q
from ibvpy.fets.fets1D.fets1D2l import FETS1D2L
if __name__ == '__main__':
if True:
fets_eval_4u = FETS2D4Q( mats_eval = MATS2DElastic() )
fe_grid = FEGrid( name = 'fe_grid1', coord_max = ( 4., 4. ),
shape = ( 4, 4 ),
fets_eval = fets_eval_4u )
interior_elems = fe_grid[ 1:3, 1:3, :, : ].elems
interior_bc = fe_grid[ 1, 1, 1:, 1: ]
bcond_list = [BCSlice( var = 'u', dims = [0, 1], slice = fe_grid[ :, 0, :, 0 ], value = 0.0 ),
BCSlice( var = 'u', dims = [0, 1], slice = interior_bc,
link_slice = fe_grid[1, 0, 0, 0], link_coeffs = [0], value = 0.0 ),
BCSlice( var = 'f', dims = [1], slice = fe_grid[ 0, -1, :, -1 ], value = 1.0 ) ]
else:
fets_eval_1d = FETS1D2L( mats_eval = MATS1DElastic() )
fe_grid = FEGrid( name = 'fe_grid1', coord_max = ( 4., ),
shape = ( 4, ),
fets_eval = fets_eval_1d )
def app():
avg_radius = 10
thickness = 50.0 # mm
md = MATS2DScalarDamage(E=30.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_stress",
stiffness="secant",
# stiffness = "algorithmic",
strain_norm=Rankine())
mdm = MATS2DMicroplaneDamage(E=30.0e3,
nu=0.2,
model_version='compliance',
phi_fn=PhiFnStrainSoftening(
G_f=0.1,
f_t=3.0,
md=0.0,
h=2. * avg_radius))
# mdm = MATS2DElastic()
fets_eval = FETS2D4Q9U(mats_eval=mdm)
fe_domain = FEDomain()
fe_rgrid = FERefinementGrid(name='fe_grid1', fets_eval=fets_eval, domain=fe_domain)
n_half = 10
n_el = n_half * 2 + 1
# Discretization
fe_grid = FEGrid(coord_max=(200.0, 200.0, 0.),
shape=(n_el, n_el),
fets_eval=fets_eval,
level=fe_rgrid)
# numer of elements to deactivate from each side
n_dact = 3 * n_half / 10
print n_dact
for i in range(0, n_dact):
fe_grid.deactivate((i, n_half))
for j in range(n_el - n_dact, n_el):
fe_grid.deactivate((j, n_half))
Ps_fn = MFnLineArray(xdata=array([0, 0.5, 1 ]),
ydata=array([0, 1., 1 ]))
P_fn = MFnLineArray(xdata=array([0, 0.5, 1 ]),
ydata=array([0, 0., 1 ]))
# averaging function
avg_processor = RTNonlocalAvg(avg_fn=QuarticAF(radius=avg_radius,
correction=True))
bc_slice_up = fe_grid[:, -1, :, -1]
print 'BC Up', bc_slice_up.elems.flatten()
bc_slice_left = fe_grid[0, n_half + 1:, 0, :]
print 'BC Left', bc_slice_left.elems.flatten()
bc_slice_right = fe_grid[-1, 0:n_half, -1, :]
print 'BC Right', bc_slice_right.elems.flatten()
bc_slice_down = fe_grid[:, 0, (1, 2), 0]
print 'BC Down', bc_slice_down.elems.flatten()
bc_loading = fe_grid[0, 0, 0, 0]
loading_dof_ps = bc_loading.dofs.flatten()[0]
loading_dof_p = bc_loading.dofs.flatten()[1]
print 'loading_dof_ps', loading_dof_ps
print 'loading_dof_p', loading_dof_p
print 'dofs right', bc_slice_right.dofs.flatten()
print 'dofs down', bc_slice_down.dofs.flatten()
redundant_dofs_left = fe_grid[0:n_dact, n_half, :-1, 1]
print 'redundant dofs left' , redundant_dofs_left.dofs.flatten()
redundant_dofs_right = fe_grid[n_el - n_dact:n_el, n_half, 1:, 1]
print 'redundant dofs right' , redundant_dofs_right.dofs.flatten()
aa_x = np.hstack((loading_dof_ps, np.unique(bc_slice_down.dofs[:, :, 0].flatten()), np.unique(bc_slice_right.dofs[:, :, 0].flatten())))
aa_y = np.hstack((loading_dof_p, np.unique(bc_slice_down.dofs[:, :, 1].flatten()), np.unique(bc_slice_right.dofs[:, :, 1].flatten())))
print 'aa_x', aa_x
print 'aa_y', aa_y
# delta measurement points
p_a = fe_grid[2, 6, -1, -1]
p_b = fe_grid[17, 6, -1, -1]
p_c = fe_grid[17, 13, -1, -1]
p_d = fe_grid[2, 13, -1, -1]
print 'point A' , p_a.geo_nodes.flatten()
print 'point B' , p_b.geo_nodes.flatten()
print 'point C' , p_c.geo_nodes.flatten()
print 'point D' , p_d.geo_nodes.flatten()
link_right = BCSlice(var='u', value=0., dims=[0, 1],
slice=bc_slice_right,
link_slice=bc_loading,
link_dims=[0, 1],
link_coeffs=[1.])
link_down = BCSlice(var='u', value=0., dims=[0, 1],
slice=bc_slice_down,
link_slice=bc_loading,
link_dims=[0, 1],
link_coeffs=[1.])
ts = TS(sdomain=fe_grid,
u_processor=avg_processor,
bcond_list=[
# constraint for all left dofs in y-direction:
link_right, link_down,
# constraint for all left dofs in y-direction:
BCSlice(var='u', slice=bc_slice_up, dims=[0, 1], value=0.),
BCSlice(var='u', slice=bc_slice_left, dims=[0, 1], value=0.),
BCSlice(var='u', slice=redundant_dofs_left, dims=[0, 1], value=0.),
BCSlice(var='u', slice=redundant_dofs_right, dims=[0, 1], value=0.),
BCSlice(var='f', slice=bc_loading, dims=[0],
time_function=Ps_fn.get_value,
value= -200),
BCSlice(var='u', slice=bc_loading, dims=[1],
time_function=P_fn.get_value,
value= -0.05),
],
rtrace_list=[
RTraceGraph(name='Ps' ,
var_y='F_int', idx_y_arr=aa_x,
var_x='U_k', idx_x=loading_dof_ps,
transform_x='-x', transform_y='-y*%g' % thickness,
record_on='update'),
RTraceGraph(name='P' ,
var_y='F_int', idx_y_arr=aa_y,
var_x='U_k', idx_x=loading_dof_p,
transform_x='-x', transform_y='-y*%g' % thickness,
record_on='update'),
RTraceGraph(name='Point A' ,
var_y='F_int', idx_y=p_a.dofs.flatten()[1],
var_x='U_k', idx_x=p_a.dofs.flatten()[1],
transform_x='-x', transform_y='-y*%g' % thickness,
record_on='update'),
RTraceGraph(name='Point B' ,
var_y='F_int', idx_y=p_b.dofs.flatten()[1],
var_x='U_k', idx_x=p_b.dofs.flatten()[1],
transform_x='-x', transform_y='-y*%g' % thickness,
record_on='update'),
RTraceGraph(name='Point C' ,
var_y='F_int', idx_y=p_c.dofs.flatten()[1],
var_x='U_k', idx_x=p_c.dofs.flatten()[1],
transform_x='-x', transform_y='-y*%g' % thickness,
record_on='update'),
RTraceGraph(name='Point D' ,
var_y='F_int', idx_y=p_d.dofs.flatten()[1],
var_x='U_k', idx_x=p_d.dofs.flatten()[1],
transform_x='-x', transform_y='-y*%g' % thickness,
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'),
]
)
# Add the time-loop control
#
tl = TLoop(tstepper=ts,
tolerance=5.0e-4,
KMAX=200,
tline=TLine(min=0.0, step=.05, max=0.7))
tl.eval()
u_a = ts.rtrace_list[2].trace.xdata
u_b = ts.rtrace_list[3].trace.xdata
u_c = ts.rtrace_list[4].trace.xdata
u_d = ts.rtrace_list[5].trace.xdata
delta_r = (u_b + u_c) / 2
delta_l = (u_a + u_d) / 2
delta = (delta_l + delta_r) / 2
with open("4b.txt") as f:
data = f.read()
data = data.split('\n')
x = [row.split(' ')[0] for row in data]
y = [row.split(' ')[1] for row in data]
fig = plt.figure()
ax = fig.add_subplot(111)
print ts.rtrace_list
P = ts.rtrace_list[1].trace
ax.set_title("Load-displacement diagramm")
ax.set_xlabel(r'$\delta$ (mm)')
ax.set_ylabel('P (N)')
ax.plot(x, y, 'r--', label='Test Load Path 4b')
ax.plot(delta, P.ydata, c='b', label='Simulation (MDM)')
leg = ax.legend()
plt.show()
# # 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()
from ibvpy.mesh.xfe_subdomain import XFESubDomain
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 = FETSCrack(parent_fets=fets_eval, int_order=5)
# Discretization
fe_domain = FEDomain()
fe_level1 = FERefinementGrid(domain=fe_domain, fets_eval=fets_eval)
fe_grid1 = FEGrid(coord_max=(1., 1., 0.),
shape=(1, 1),
rt_tol=0.1,
fets_eval=fets_eval,
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=[
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 app():
avg_radius = 30
thickness = 50
md = MATS2DScalarDamage(E=30.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_stress",
stiffness="secant",
# stiffness = "algorithmic",
strain_norm=Rankine())
mdm = MATS2DMicroplaneDamage(E=30.0e3,
nu=0.2,
model_version='compliance',
phi_fn=PhiFnStrainSoftening(
G_f=0.1,
f_t=3.0,
md=0.0,
h=25))
fets_eval = FETS2D4Q9U(mats_eval=mdm) # , ngp_r = 3, ngp_s = 3)
fe_domain = FEDomain()
fe_rgrid = FERefinementGrid(name='fe_grid1', fets_eval=fets_eval, domain=fe_domain)
n_half = 5
n_el = n_half * 2 + 1
# Discretization
fe_grid = FEGrid(coord_max=(200.0, 200.0, 0.),
shape=(n_el, n_el),
fets_eval=fets_eval,
level=fe_rgrid)
# numer of elements to deactivate from each side
n_dact = 3 * n_half / 10
print n_dact
for i in range(0, n_dact):
fe_grid.deactivate((i, n_half))
for j in range(n_el - n_dact, n_el):
fe_grid.deactivate((j, n_half))
Ps_fn = MFnLineArray(xdata=array([0, 0.5, 1 ]),
ydata=array([0, 1., 1 ]))
P_fn = MFnLineArray(xdata=array([0, 0.5, 1 ]),
ydata=array([0, 0., 1 ]))
# averaging function
avg_processor = RTNonlocalAvg(avg_fn=QuarticAF(radius=avg_radius,
correction=True))
bc_slice_up = fe_grid[:, -1, :, -1]
print 'BC Up', bc_slice_up.elems.flatten()
bc_slice_left = fe_grid[0, n_half + 1:, 0, :]
print 'BC Left', bc_slice_left.elems.flatten()
bc_slice_right = fe_grid[-1, 0:n_half, -1, :]
print 'BC Right', bc_slice_right.elems.flatten()
bc_slice_down = fe_grid[:, 0, (1, 2), 0]
print 'BC Down', bc_slice_down.elems.flatten()
bc_loading = fe_grid[0, 0, 0, 0]
loading_dof_ps = bc_loading.dofs.flatten()[0]
loading_dof_p = bc_loading.dofs.flatten()[1]
print 'loading_dof_ps', loading_dof_ps
print 'loading_dof_p', loading_dof_p
print 'dofs right', bc_slice_right.dofs.flatten()
print 'dofs down', bc_slice_down.dofs.flatten()
redundant_dofs_left = fe_grid[0:n_dact, n_half, :-1, 1]
print 'redundant dofs left' , redundant_dofs_left.dofs.flatten()
redundant_dofs_right = fe_grid[n_el - n_dact:n_el, n_half, 1:, 1]
print 'redundant dofs right' , redundant_dofs_right.dofs.flatten()
aa_x = np.hstack((loading_dof_ps, np.unique(bc_slice_down.dofs[:, :, 0].flatten()), np.unique(bc_slice_right.dofs[:, :, 0].flatten())))
aa_y = np.hstack((loading_dof_p, np.unique(bc_slice_down.dofs[:, :, 1].flatten()), np.unique(bc_slice_right.dofs[:, :, 1].flatten())))
print 'aa_x', aa_x
print 'aa_y', aa_y
link_right = BCSlice(var='u', value=0., dims=[0, 1],
slice=bc_slice_right,
link_slice=bc_loading,
link_dims=[0, 1],
link_coeffs=[1.])
link_down = BCSlice(var='u', value=0., dims=[0, 1],
slice=bc_slice_down,
link_slice=bc_loading,
link_dims=[0, 1],
link_coeffs=[1.])
ts = TS(sdomain=fe_grid,
u_processor=avg_processor,
bcond_list=[
link_right, link_down,
# constraint for all left dofs in y-direction:
BCSlice(var='u', slice=bc_slice_up, dims=[0, 1], value=0.),
BCSlice(var='u', slice=bc_slice_left, dims=[0, 1], value=0.),
BCSlice(var='u', slice=redundant_dofs_left, dims=[0, 1], value=0.),
BCSlice(var='u', slice=redundant_dofs_right, dims=[0, 1], value=0.),
BCSlice(var='f', slice=bc_loading, dims=[0],
time_function=Ps_fn.get_value,
value= -100),
BCSlice(var='u', slice=bc_loading, dims=[1],
time_function=P_fn.get_value,
value= -0.05),
],
rtrace_list=[
RTraceGraph(name='Ps' ,
var_y='F_int', idx_y_arr=aa_x,
var_x='U_k', idx_x=loading_dof_ps,
transform_x='-x', transform_y='-y*%g' % thickness,
record_on='update'),
RTraceGraph(name='P' ,
var_y='F_int', idx_y_arr=aa_y,
var_x='U_k', idx_x=loading_dof_p,
transform_x='-x', transform_y='-y*%g' % thickness,
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'),
]
)
# Add the time-loop control
#
tl = TLoop(tstepper=ts,
tolerance=5.0e-5,
KMAX=200, # debug=True,
tline=TLine(min=0.0, step=.05, max=0.7))
tl.setup()
# print avg_processor.C_mtx
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_mesh(self):
return FEGrid(coord_max=(self.L_x, self.L_y, self.L_z),
shape=(self.n_x, self.n_y, self.n_z),
fets_eval=self.fets)
#
# Created on Jan 21, 2011 by: rch
from ibvpy.mats.mats2D.mats2D_elastic.mats2D_elastic import MATS2DElastic
from ibvpy.mats.mats1D.mats1D_elastic.mats1D_elastic import MATS1DElastic
from ibvpy.api import FEDomain, FEGrid, FERefinementGrid, TStepper as TS, TLoop, \
BCSlice, RTraceDomainListField
from ibvpy.fets.fets2D.fets2D4q import FETS2D4Q
from ibvpy.fets.fets1D.fets1D2l import FETS1D2L
if __name__ == '__main__':
if True:
fets_eval_4u = FETS2D4Q(mats_eval=MATS2DElastic())
fe_grid = FEGrid(name='fe_grid1',
coord_max=(4., 4.),
shape=(4, 4),
fets_eval=fets_eval_4u)
interior_elems = fe_grid[1:3, 1:3, :, :].elems
interior_bc = fe_grid[1, 1, 1:, 1:]
bcond_list = [
BCSlice(var='u', dims=[0, 1], slice=fe_grid[:, 0, :, 0],
value=0.0),
BCSlice(var='u',
dims=[0, 1],
slice=interior_bc,
link_slice=fe_grid[1, 0, 0, 0],
link_coeffs=[0],
value=0.0),
BCSlice(var='f', dims=[1], slice=fe_grid[0, -1, :, -1], value=1.0)
print 'N_im.shape', N_im.shape
print 'dN_ima', dN_imr
print 'dN_ima.shape', dN_imr.shape
print '*************************'
class FETS2D4u4x(FETSEval):
dof_r = tr.Array(value=[[-1, -1], [1, -1], [1, 1], [-1, 1]])
geo_r = tr.Array(value=[[-1, -1], [1, -1], [1, 1], [-1, 1]])
vtk_r = [[-1, -1], [1, -1], [1, 1], [-1, 1]]
n_nodal_dofs = 2
# Discretization
L_x, L_y = 100, 100
mesh = FEGrid(coord_max=(L_x, L_y), shape=(100, 30), fets_eval=FETS2D4u4x())
x_Ia = mesh.X_Id
# print 'x_Ia', x_Ia
n_I, n_a = x_Ia.shape
dof_Ia = np.arange(n_I * n_a, dtype=np.int_).reshape(n_I, -1)
# print 'dof_Ia', dof_Ia
I_Ei = mesh.I_Ei
# print 'I_Ei', I_Ei
x_Eia = x_Ia[I_Ei, :]
# print 'x_Eia', x_Eia
dof_Eia = dof_Ia[I_Ei]
if __name__ == '__main__':
fets_eval_4u = FETS2D4Q(mats_eval = MATS2DElastic())
fe_domain = FEDomain()
fe_rgrid1 = FERefinementGrid( name = 'fe_rgrid1', fets_eval = fets_eval_4u, domain = fe_domain )
fe_grid1 = FEGrid( name = 'fe_grid1', coord_max = (2.,6.,0.),
shape = (1,3),
fets_eval = fets_eval_4u,
level = fe_rgrid1 )
fe_grid2 = FEGrid( name = 'fe_grid2', coord_min = (2., 6, 0.),
coord_max = (10, 15, 0.),
shape = (3,2),
fets_eval = fets_eval_4u,
level = fe_rgrid1 )
print fe_grid2[ 1, 0 ].elems
fe_grid2.deactivate( ( 1, 0 ) )
print 'activation map'
print fe_grid2.activation_map
ts = TS( sdomain = fe_domain )
from ibvpy.plugins.ibvpy_app import IBVPyApp
ibvpy_app = IBVPyApp( ibv_resource = ts )
ibvpy_app.main()
