def example():
from ibvpy.api import \
TStepper as TS, RTraceGraph, RTraceDomainListField, TLoop, \
TLine
from ibvpy.mesh.fe_grid import FEGrid
A_fiber = 1.
E_fiber = 1.
stiffness_fiber = E_fiber * A_fiber
d = 2 * sqrt(Pi)
tau_max = 0.1 * d * Pi
G = 100
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 = FETS1D52L8ULRH(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=[
RTraceGraph(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 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()
ts = TS(
sdomain=domain,
# conversion to list (square brackets) is only necessary for slicing of
# single dofs, e.g "get_left_dofs()[0,1]" which elsewise retuns an integer only
bcond_list=[
BCDofGroup(var='u',
value=0.,
dims=[0],
get_dof_method=domain.get_left_dofs),
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', idx = 0,
# record_on = 'update'),
# RTraceDomainListField(name = 'Displacement_ip' ,
# var = 'u', idx = 0,
# position = 'int_pnts'),
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')
])
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()
def combined_fe2D4q_with_fe2D4q8u():
fets_eval_4u_conc = FETS2D4Q(mats_eval=MATS2DElastic(E=28500, nu=0.2))
fets_eval_4u_steel = FETS2D4Q(mats_eval=MATS2DElastic(E=210000, nu=0.25))
fets_eval_8u = FETS2D4Q8U(mats_eval=MATS2DElastic())
# Discretization
fe_domain = FEDomain()
fe_grid_level1 = FERefinementGrid(name='master grid',
fets_eval=fets_eval_4u_conc,
domain=fe_domain)
fe_grid = FEGrid(level=fe_grid_level1,
coord_max=(2., 6., 0.),
shape=(11, 30),
fets_eval=fets_eval_4u_conc)
fe_grid_level2 = FERefinementGrid(name='refinement grid',
parent=fe_grid_level1,
fets_eval=fets_eval_4u_steel,
fine_cell_shape=(1, 1))
# fe_grid_level1[ 5, :5 ].refine_using( fe_grid_level2 )
# 1. first get the slice for the level - distinguish it from the slice at the subgrid
# this includes slicing in the subgrids. what if the subgrid does not exist?
#
# Each subgrid must hold its own slice within the level. The index operator fills
# the grid [...] instanciates the whole grid and returns the instance of
# FEGridLevelSlice. The expanded subgrid contains its constructor slice.
#
# 2. If the slice is within an existing slice no change in the FESubgrid is required
# only the instance of the slice is returned. The FEGridLevelSlice goes always into
# an expanded part of FEGrid.
#
# 3. If the slice does not fit into any existing slice - all domain with an intersection
# of the existing slice must be constructed as well.
#
# 2. deactivate elements
# 3.
# BUT how to impose the boundary conditions on the particular refinement? The
# slice has an attribute
fe_grid_level2.refine_elem((5, 0))
fe_grid_level2.refine_elem((5, 1))
fe_grid_level2.refine_elem((5, 2))
fe_grid_level2.refine_elem((5, 3))
fe_grid_level2.refine_elem((5, 4))
fe_grid_level2.refine_elem((5, 5))
# apply the boundary condition on a subgrid
#
print(fe_grid_level2.fe_subgrids)
fe_first_grid = fe_grid_level2.fe_subgrids[0]
ts = TS(
dof_resultants=True,
sdomain=fe_domain,
bcond_list=[
BCSlice(var='f', value=1., dims=[0], slice=fe_grid[:, -1, :, -1]),
BCSlice(var='u',
value=0.,
dims=[0, 1],
slice=fe_first_grid[:, 0, :, 0])
],
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())
from ibvpy.plugins.ibvpy_app import IBVPyApp
ibvpy_app = IBVPyApp(ibv_resource=tloop)
ibvpy_app.main()
def example_with_new_domain():
from ibvpy.api import \
TStepper as TS, RTDofGraph, RTraceDomainListField, \
RTraceDomainListInteg, TLoop, \
TLine, BCDof, DOTSEval
from ibvpy.mats.mats2D.mats2D_elastic.mats2D_elastic import MATS2DElastic
from ibvpy.mats.mats2D.mats2D_sdamage.mats2D_sdamage import MATS2DScalarDamage
from ibvpy.api import BCDofGroup
mats_eval = MATS2DElastic()
fets_eval = FETS2D4Q(mats_eval=mats_eval)
#fets_eval = FETS2D4Q(mats_eval = MATS2DScalarDamage())
print(fets_eval.vtk_node_cell_data)
from ibvpy.mesh.fe_grid import FEGrid
from ibvpy.mesh.fe_refinement_grid import FERefinementGrid
from ibvpy.mesh.fe_domain import FEDomain
from mathkit.mfn import MFnLineArray
# Discretization
fe_grid = FEGrid(coord_max=(10., 4., 0.),
shape=(10, 3),
fets_eval=fets_eval)
bcg = BCDofGroup(var='u',
value=0.,
dims=[0],
get_dof_method=fe_grid.get_left_dofs)
bcg.setup(None)
print('labels', bcg._get_labels())
print('points', bcg._get_mvpoints())
mf = MFnLineArray( # xdata = arange(10),
ydata=np.array([0, 1, 2, 3]))
right_dof = 2
tstepper = TS(
sdomain=fe_grid,
bcond_list=[
BCDofGroup(var='u',
value=0.,
dims=[0, 1],
get_dof_method=fe_grid.get_left_dofs),
# BCDofGroup( var='u', value = 0., dims = [1],
# get_dof_method = fe_grid.get_bottom_dofs ),
BCDofGroup(var='u',
value=.005,
dims=[1],
time_function=mf.get_value,
get_dof_method=fe_grid.get_right_dofs)
],
rtrace_list=[
RTDofGraph(name='Fi,right over u_right (iteration)',
var_y='F_int',
idx_y=right_dof,
var_x='U_k',
idx_x=right_dof,
record_on='update'),
RTraceDomainListField(name='Stress',
var='sig_app',
idx=0,
position='int_pnts',
record_on='update'),
# RTraceDomainListField(name = 'Damage' ,
# var = 'omega', idx = 0,
#
# record_on = 'update',
# warp = True),
RTraceDomainListField(name='Displacement',
var='u',
idx=0,
record_on='update',
warp=True),
RTraceDomainListField(name='Strain energy',
var='strain_energy',
idx=0,
record_on='update',
warp=False),
RTraceDomainListInteg(name='Integ strain energy',
var='strain_energy',
idx=0,
record_on='update',
warp=False),
# RTraceDomainListField(name = 'N0' ,
# var = 'N_mtx', idx = 0,
# record_on = 'update')
])
# Add the time-loop control
#global tloop
tloop = TLoop(tstepper=tstepper,
KMAX=300,
tolerance=1e-4,
tline=TLine(min=0.0, step=1.0, max=1.0))
#import cProfile
#cProfile.run('tloop.eval()', 'tloop_prof' )
# print tloop.eval()
#import pstats
#p = pstats.Stats('tloop_prof')
# p.strip_dirs()
# print 'cumulative'
# p.sort_stats('cumulative').print_stats(20)
# print 'time'
# p.sort_stats('time').print_stats(20)
tloop.eval()
# Put the whole thing into the simulation-framework to map the
# individual pieces of definition into the user interface.
#
from ibvpy.plugins.ibvpy_app import IBVPyApp
app = IBVPyApp(ibv_resource=tloop)
app.main()
def 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=[
# 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_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()
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()
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_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=[
# 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 = 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 sys_matrix import SysSparseMtx, SysDenseMtx
from ibvpy.api import \
TStepper as TS, RTDofGraph, TLoop, \
TLine, BCDof
from ibvpy.fets.fets1D.fets1D2l import FETS1D2L
from ibvpy.mats.mats1D.mats1D_elastic.mats1D_elastic import MATS1DElastic
from ibvpy.mesh.fe_grid import FEGrid
if __name__ == '__main__':
fets_eval = FETS1D2L(mats_eval=MATS1DElastic(E=10.))
# Discretization
domain = FEGrid(coord_max=(10., 0., 0.), shape=(1, ), fets_eval=fets_eval)
ts = TS(sdomain=domain, dof_resultants=True)
tloop = TLoop(tstepper=ts,
debug=False,
tline=TLine(min=0.0, step=1, max=1.0))
'''Clamped bar loaded at the right end with unit displacement
[00]-[01]-[02]-[03]-[04]-[05]-[06]-[07]-[08]-[09]-[10]
'u[0] = 0, u[10] = 1'''
domain.coord_max = (1, 0, 0)
domain.shape = (3, )
ts.bcond_list = [
BCDof(var='u', dof=0, value=0.),
BCDof(var='u', dof=1, link_dofs=[2], link_coeffs=[0.5]),
BCDof(var='u', dof=3, value=1.)
]
ts.rtrace_list = [
'''
Additionally handle the constraints
'''
dG = dG_n(u_k)
G = G_n(u_k)
return G, dG
def update_state(self, sctx, U):
pass
if __name__ == '__main__':
from ibvpy.api import TLoop, TLine, BCDof
tl = TLoop(tstepper=TS(tse=TSFn2D()),
tline=TLine(min=0.0, step=1.0, max=20.0))
tl.tstepper.bcond_list = [
BCDof(var='f',
dof=0,
value=20.0,
time_function=lambda t: 1.0 + 0.33 * t**2),
BCDof(var='f',
dof=1,
value=20.0,
time_function=lambda t: 1.0 + 0.3 * t**2)
]
tl.tstepper.rtrace_list = [
RTraceGraph(name='u01 vs. u1',
var_x='U_k',
idx_x=0,
ts = TS(
tse=fets_eval,
sdomain=quad_elem,
bcond_list=[BCDof(var='u', dof=i, value=0.) for i in [0, 1, 3]] +
[BCDof(var='f', dof=i, value=10) for i in [5, 7]],
rtrace_list=[
RTraceElemField(name='Displacement',
var='u',
idx=0,
record_on='update'),
RTraceElemField(name='Deformation',
var='eps',
idx=0,
record_on='update'),
RTraceElemField(name='Jacobi determinant',
var='J_det',
idx=0,
record_on='update'),
RTraceElemField(name='N0',
var='N_mtx',
idx=0,
record_on='update'),
RTraceElemField(name='B0',
var='B_mtx0',
idx=0,
record_on='update'),
RTraceElemField(name='B1',
var='B_mtx1',
idx=0,
record_on='update'),
RTraceElemField(name='B2',
var='B_mtx2',
idx=0,
record_on='update')
])
def _get_tloop(self):
#fets_eval.mats_eval.nu = self.nu
specmn = self.specmn_fe_grid
if False:
elstmr = self.elstmr_fe_grid
supprt = self.supprt_fe_grid
self.fe_domain.n_dofs
self.center_top_dofs = specmn[0, 0, -1, 0, 0, -1].dofs
center_bottom_dofs = specmn[0, 0, 0, 0, 0, 0].dofs
support_elem = self.shape_y - 4
#--------------------------------------------------------------
# boundary conditions for the symmetry and the single support
#--------------------------------------------------------------
bc_symplane_yz = BCSlice(var='u',
value=0.,
dims=[0],
slice=specmn[0, :, :, 0, :, :])
bc_symplane_xz = BCSlice(var='u',
value=0.,
dims=[1],
slice=specmn[:, 0, :, :, 0, :])
#--------------------------------------------------------------
# boundary conditions for the symmetry and the single support
#--------------------------------------------------------------
support_slice = specmn[-1, support_elem, :, -1, 0, :]
support_000 = BCSlice(var='u',
value=0.,
dims=[0, 2],
slice=support_slice)
#--------------------------------------------------------------
# loading
#--------------------------------------------------------------
# w_max = center displacement:
w_max = -0.07 # [m]
time_function = MFnLineArray(xdata=[0.0, 0.2, 0.4, 1.0],
ydata=[0.0, 0.2, 0.75, 1.0])
bc_el_w = BCSlice(
var='u',
value=w_max,
dims=[2], #time_function = time_function.get_value,
slice=specmn[0, 0, 0, 0, 0, 0])
p_max = -0.0042 / (0.2 * 0.2)
p_slice = specmn[:, 0, -1, :, :, -1]
bc_el_w = BCSlice(
var='f',
value=p_max,
dims=[2],
integ_domain='local', #time_function = time_function.get_value,
slice=p_slice)
#--------------------------------------------------------------
# ts
#--------------------------------------------------------------
center_dof = center_bottom_dofs[0, 0, 2]
# center_top_line_dofs
#
#ctl_dofs = elstmr[:, :, -1, :, :, -1].dofs[:, :, 2].flatten()
# force-displacement-diagram
#
self.f_w_diagram_center = RTraceGraph(
name='displacement (center) - reaction 2',
var_x='U_k',
idx_x=center_dof,
# elastomer load
var_y='F_int',
idx_y_arr=support_slice.dofs[:, :, 2].flatten(),
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='-2 * 1000. * y')
bcond_list = [
bc_symplane_yz,
bc_symplane_xz,
support_000,
# var 1:
bc_el_w,
# bc_center_w,
# # var 2:
# bc_center_w_elem,
# # var 3:
# bc_center_w_xline, bc_center_w_yline
]
rtrace_list = [
self.f_w_diagram_center,
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 principle stress',
idx=0,
var='max_principle_sig',
warp=True,
# position = 'int_pnts',
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'),
]
ts = TS(sdomain=self.fe_domain,
bcond_list=bcond_list,
rtrace_list=rtrace_list)
print 'tstep', self.tstep
# Add the time-loop control
tloop = TLoop(
tstepper=ts,
# # allow only a low tolerance
# #
# KMAX = 50,
# tolerance = 5e-4,
# allow a high tolerance
#
KMAX=100,
tolerance=0.001,
# # allow a very high tolerance
# #
# KMAX = 50,
# tolerance = 0.01,
RESETMAX=0,
debug=False,
tline=TLine(min=0.0, step=self.tstep, max=1))
return tloop
def example_with_new_domain():
from ibvpy.api import \
TStepper as TS, RTraceDomainListField, TLoop, TLine
from ibvpy.mats.mats2D5.mats2D5_bond.mats2D_bond import MATS2D5Bond
from ibvpy.api import BCDofGroup
from ibvpy.fets.fets2D.fets2D4q import FETS2D4Q
fets_eval = FETS2DTF(parent_fets=FETS2D4Q(),
mats_eval=MATS2D5Bond(E_m=30,
nu_m=0.2,
E_f=10,
nu_f=0.1,
G=10.))
from ibvpy.mesh.fe_grid import FEGrid
from mathkit.mfn import MFnLineArray
# Discretization
fe_grid = FEGrid(coord_max=(10., 4., 0.),
n_elems=(10, 3),
fets_eval=fets_eval)
mf = MFnLineArray( # xdata = arange(10),
ydata=array([0, 1, 2, 3]))
tstepper = TS(
sdomain=fe_grid,
bcond_list=[
BCDofGroup(var='u',
value=0.,
dims=[0, 1],
get_dof_method=fe_grid.get_left_dofs),
# BCDofGroup( var='u', value = 0., dims = [1],
# get_dof_method = fe_grid.get_bottom_dofs ),
BCDofGroup(var='u',
value=.005,
dims=[0],
time_function=mf.get_value,
get_dof_method=fe_grid.get_right_dofs)
],
rtrace_list=[
# RTDofGraph(name = 'Fi,right over u_right (iteration)' ,
# var_y = 'F_int', idx_y = right_dof,
# var_x = 'U_k', idx_x = right_dof,
# record_on = 'update'),
# RTraceDomainListField(name = 'Stress' ,
# var = 'sig_app', idx = 0,
# #position = 'int_pnts',
# record_on = 'update'),
# RTraceDomainListField(name = 'Damage' ,
# var = 'omega', idx = 0,
# record_on = 'update',
# warp = True),
RTraceDomainListField(name='Displ matrix',
var='u_m',
idx=0,
record_on='update',
warp=True),
RTraceDomainListField(name='Displ reinf',
var='u_f',
idx=0,
record_on='update',
warp=True),
# RTraceDomainListField(name = 'N0' ,
# var = 'N_mtx', idx = 0,
# record_on = 'update')
])
# Add the time-loop control
#global tloop
tloop = TLoop(tstepper=tstepper,
KMAX=300,
tolerance=1e-4,
tline=TLine(min=0.0, step=1.0, max=1.0))
#import cProfile
#cProfile.run('tloop.eval()', 'tloop_prof' )
print(tloop.eval())
#import pstats
#p = pstats.Stats('tloop_prof')
# p.strip_dirs()
# print 'cumulative'
# p.sort_stats('cumulative').print_stats(20)
# print 'time'
# p.sort_stats('time').print_stats(20)
# Put the whole thing into the simulation-framework to map the
# individual pieces of definition into the user interface.
#
from ibvpy.plugins.ibvpy_app import IBVPyApp
app = IBVPyApp(ibv_resource=tloop)
app.main()
slice=domain[0, 0, 0, 0, 0, 0])
vertical_load = BCSlice(var='f',
value=-1.00,
dims=[2],
slice=domain[:, :, -1, :, :, -1])
# horizontal_load = BCSlice( var = 'f', value = 1.00, dims = [0, 1],
# slice = domain[-1, -1, -1, -1, -1, -1] )
ts = TS(
sdomain=domain,
bcond_list=[
support_z, support_y, support_xyz, vertical_load
# horizontal_load,
],
rtrace_list=[
RTraceDomainListField(name='Deformation',
var='eps_app',
idx=0,
record_on='update'),
RTraceDomainListField(name='Displacement', var='u', idx=0),
])
# Add the time-loop control
tloop = TLoop(tstepper=ts, tline=TLine(min=0.0, step=0.5, max=1.0))
tloop.eval()
dofs = support_z.slice.dofs
print "dofs", dofs
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 )
# ibvpy_app.main()
def example_with_new_domain():
from ibvpy.api import \
TStepper as TS, RTDofGraph, RTraceDomainListField, TLoop, \
TLine, BCDof, IBVPSolve as IS, DOTSEval
from ibvpy.tmodel.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()
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=[
RTraceGraph(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=0),
# RTraceDomainListField(name = 'N0' ,
# var = 'N_mtx', idx = 0,
# record_on = 'update')
])
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()
ts = TS(
sdomain=domain,
# conversion to list (square brackets) is only necessary for slicing of
# single dofs, e.g "get_left_dofs()[0,1]"
# Boundary conditions for three-point-bendig:
# bcond_list = [ BCDof(var='u', dof = i, value = 0.) for i in [domain.get_bottom_left_dofs()[0,0]] ] +
# [ BCDof(var='u', dof = i, value = 0.) for i in [domain.get_bottom_left_dofs()[0,1]] ] +
# [ BCDof(var='u', dof = i, value = 0.) for i in [domain.get_bottom_right_dofs()[0,1]] ] +
# [ BCDof(var='u', dof = i, value = 0.002 ) for i in [domain.get_top_middle_dofs()[0,1]] ],
# Boundary conditions for shear force applied at the right border:
bcond_list=[
BCDofGroup(var='u',
value=0.,
dims=[0, 1],
get_dof_method=domain.get_left_dofs),
# BCDofGroup( var='u', value = 0., dims = [1],
# get_dof_method = domain.get_bottom_right_dofs ),
BCDofGroup(var='u',
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')
])
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()
ts = TS(
sdomain=domain,
bcond_list=[
BCDofGroup(var='u',
value=0.,
dims=[0],
get_dof_method=domain.get_left_dofs),
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')
])
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' ,
# 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')
])
coord_min = ( 2., ),
coord_max = ( 3., ),
shape = ( 1, ),
fets_eval = fets_eval )
dofs_left = fe_grid_left[-1, -1].dofs[0, :, 0]
dofs_right = fe_grid_right[0, 0].dofs[0, :, 0]
spring_arr = FESpringArray( domain = fe_domain,
dofs_1 = dofs_left,
dofs_2 = dofs_right, k_value = 1.0 )
ts = TS( dof_resultants = True,
sdomain = fe_domain,
bcond_list = [BCSlice( var = 'u', value = 1., dims = [0],
slice = fe_grid_right[ -1, -1 ] ),
BCSlice( var = 'u', value = 0., dims = [0],
slice = fe_grid_left[ 0, 0 ] )
],
rtrace_list = [ ]
)
# Add the time-loop control
tloop = TLoop( tstepper = ts,
tline = TLine( min = 0.0, step = 1, max = 1.0 ) )
u = tloop.eval()
print(u)
import pylab as p
spring_arr.plot_spring_forces( u, p )
p.show()
coord_max = (6., 0., 0.),
shape = (3, ),
fets_eval = fets_eval)
fe_domain = FEDomainList(subdomains=[fe_domain1, fe_domain2])
ts = TS(dof_resultants=True,
sdomain=fe_domain,
bcond_list=[BCDof(var='u', dof=0, value=0.),
BCDof(var='u', dof=4, link_dofs=[3], link_coeffs=[1.],
value=0.),
BCDof(var='f', dof=7, value=1,
link_dofs=[2], link_coeffs=[2])],
rtrace_list=[RTraceGraph(name='Fi,right over u_right (iteration)',
var_y='F_int', idx_y=0,
var_x='U_k', idx_x=1),
# RTraceDomainField(name = 'Stress' ,
# var = 'sig_app', idx = 0),
# 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 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 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-')
fe_domain1 = FEGrid(coord_max=(10., 0., 0.),
shape=(10,),
fets_eval=fets_eval)
fe_domain2 = FEGrid(coord_min=(10., 0., 0.),
coord_max=(20., 0., 0.),
shape=(10,),
fets_eval=fets_eval)
fe_domain = FEDomain(subdomains=[fe_domain1, fe_domain2])
ts = TS(dof_resultants=True,
sdomain=fe_domain,
bcond_list=[BCDof(var='u', dof=0, value=0.),
BCDof(
var='u', dof=5, link_dofs=[16], link_coeffs=[1.], value=0.),
BCDof(var='f', dof=21, value=10)],
rtrace_list=[RTraceGraph(name='Fi,right over u_right (iteration)',
var_y='F_int', idx_y=0,
var_x='U_k', idx_x=1),
]
)
# Add the time-loop control
tloop = TLoop(tstepper=ts, tline=TLine(min=0.0, step=1, max=1.0))
ts.set(sdomain=FEDomain(subdomains=[fe_domain1, fe_domain2]))
ts.set(bcond_list=[BCDof(var='u', dof=0, value=0.),
BCDof(
var='u', dof=5, link_dofs=[16], link_coeffs=[1.], value=0.),
BCDof(var='f', dof=21, value=10)])
ts = TS(
dof_resultants=True,
tse=tse,
sdomain=tse.sdomain,
# 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=tse.sdomain[0, 0]),
BCSlice(var='u', value=0.1, dims=[1], slice=tse.sdomain[-1, -1])
],
# rtrace_list=[RTraceGraph(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