def example_1d():
from ibvpy.mats.mats1D.mats1D_elastic.mats1D_elastic import MATS1DElastic
from ibvpy.fets.fets1D.fets1D2l import FETS1D2L
fets_eval = FETS1D2L(mats_eval=MATS1DElastic())
# Discretization
fe_domain = FEDomain()
fe_level1 = FERefinementGrid(domain=fe_domain, fets_eval=fets_eval)
fe_domain1 = FEGrid(coord_max=(3., 0., 0.),
shape=(3,),
level=fe_level1,
fets_eval=fets_eval)
fe_child_domain = FERefinementGrid(parent_domain=fe_level1,
fine_cell_shape=(2,))
fe_child_domain.refine_elem((1,))
ts = TS(domain=fe_domain,
dof_resultants=True,
sdomain=fe_domain,
bcond_list=[BCDof(var='u', dof=0, value=0.),
BCDof(var='f', dof=3, value=1.)]
)
# Add the time-loop control
tloop = TLoop(tstepper=ts, debug=True,
tline=TLine(min=0.0, step=1, max=1.0))
print tloop.eval()
def ghost_bar( ):
fets_eval = FETS1D2L( mats_eval = MATS1DElastic() )
discr = ( 3, )
# Discretization
fe_domain1 = FEGrid( coord_min = (0,0,0),
coord_max = (2,0,0),
shape = discr,
inactive_elems = [0],
fets_eval = fets_eval )
ts = TS( sdomain = fe_domain1,
dof_resultants = True,
bcond_list = [ BCDof( var='u', value = 0., dof = 0 ),
BCDof( var='u', value = 0., dof = 3 ),
BCDof( var='f', value = 1., dof = 1 ) ],
)
# Add the time-loop control
global tloop
tloop = TLoop( tstepper = ts, tolerance = 1e-4, KMAX = 50,
tline = TLine( min = 0.0, step = 1.0, max = 1.0 ))
print tloop.eval()
def eval( self ):
'''Run the time loop.
'''
#
avg_processor = None
if self.avg_radius > 0.0:
avg_processor = RTNonlocalAvg( sd = self.fe_domain,
avg_fn = QuarticAF( radius = self.avg_radius,
correction = True ) )
ts = TS( u_processor = avg_processor,
dof_resultants = True,
sdomain = self.fe_domain,
bcond_list = self.bc_list,
rtrace_list = self.rt_list
)
# Add the time-loop control
tloop = TLoop( tstepper = ts, KMAX = 300, tolerance = 1e-8,
debug = False,
verbose_iteration = False,
verbose_time = False,
tline = TLine( min = 0.0, step = self.step_size, max = 1.0 ) )
tloop.eval()
tloop.accept_time_step()
self.plot_time_function()
self.plot_tracers()
def combined_fe2D4q_with_fe2D4q8u():
fets_eval_4u = FETS2D4Q(mats_eval = MATS2DElastic(E= 1.,nu = 0.))
fets_eval_8u = FETS2D4Q8U(mats_eval = MATS2DElastic())
xfets_eval = FETSCrack(parent_fets = fets_eval_4u) # should be set automatically
# Discretization
fe_domain1 = FEGridDomain( coord_max = (2.,6.,0.),
shape = (1,3),
fets_eval = fets_eval_4u )
fe_subdomain = FESubGridDomain( parent_domain = fe_domain1,
#fets_eval = fets_eval_8u,
fets_eval = fets_eval_4u,
#fets_eval = xfets_eval,
fine_cell_shape = (1,1) )
fe_subdomain.refine_elem( (0,1) )
elem = fe_subdomain.elements
m_elem = fe_domain1.elements
print "nodes ",elem[0]
fe_domain = FEDomainList( subdomains = [ fe_domain1 ] )
ts = TS( dof_resultants = True,
sdomain = fe_domain,
bcond_list = [BCDofGroup(var='u', value = 1., dims = [1],
get_dof_method = fe_domain1.get_top_dofs ),
BCDofGroup(var='u', value = 0., dims = [1],
get_dof_method = fe_domain1.get_bottom_dofs ),
BCDofGroup(var='u', value = 0., dims = [0],
get_dof_method = fe_domain1.get_bottom_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 = 1, warp = True ),
RTraceDomainListField(name = 'Displ' ,
var = 'u', idx = 1, 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()
print "nodes after",elem[0]
from ibvpy.plugins.ibvpy_app import IBVPyApp
ibvpy_app = IBVPyApp( ibv_resource = tloop )
ibvpy_app.main()
def eval(self):
'''Run the time loop.
'''
#
avg_processor = None
if self.avg_radius > 0.0:
avg_processor = RTNonlocalAvg(sd=self.fe_domain,
avg_fn=QuarticAF(
radius=self.avg_radius,
correction=True))
ts = TS(u_processor=avg_processor,
dof_resultants=True,
sdomain=self.fe_domain,
bcond_list=self.bc_list,
rtrace_list=self.rt_list)
# Add the time-loop control
tloop = TLoop(tstepper=ts,
KMAX=300,
tolerance=1e-8,
debug=False,
verbose_iteration=False,
verbose_time=False,
tline=TLine(min=0.0, step=self.step_size, max=1.0))
tloop.eval()
tloop.accept_time_step()
self.plot_time_function()
self.plot_tracers()
def test_bar2():
'''Clamped bar composed of two linked bars loaded at the right end
[00]-[01]-[02]-[03]-[04]-[05]-[06]-[07]-[08]-[09]-[10]
[11]-[12]-[13]-[14]-[15]-[16]-[17]-[18]-[19]-[20]-[21]
u[0] = 0, u[5] = u[16], R[-1] = R[21] = 10
'''
fets_eval = FETS1D2L(mats_eval=MATS1DElastic(E=10., A=1.))
# Discretization
fe_domain1 = FEGrid(coord_max=(10., 0., 0.),
shape=(10, ),
n_nodal_dofs=1,
dof_r=fets_eval.dof_r,
geo_r=fets_eval.geo_r)
fe_domain2 = FEGrid(coord_min=(10., 0., 0.),
coord_max=(20., 0., 0.),
shape=(10, ),
n_nodal_dofs=1,
dof_r=fets_eval.dof_r,
geo_r=fets_eval.geo_r)
ts = TS(iterms=[(fets_eval, fe_domain1), (fets_eval, fe_domain2)],
dof_resultants=True,
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))
u = tloop.eval()
print 'u', u
#
# '---------------------------------------------------------------'
# 'Clamped bar composed of two linked bars control displ at right'
# 'u[0] = 0, u[5] = u[16], u[21] = 1'
# Remove the load and put a unit displacement at the right end
# Note, the load is irrelevant in this case and will be rewritten
#
ts.bcond_list = [
BCDof(var='u', dof=0, value=0.),
BCDof(var='u', dof=5, link_dofs=[16], link_coeffs=[1.], value=0.),
BCDof(var='u', dof=21, value=1.)
]
# system solver
u = tloop.eval()
print 'u', u
def example_1d():
from ibvpy.mats.mats1D.mats1D_elastic.mats1D_elastic import MATS1DElastic
from ibvpy.fets.fets1D.fets1D2l import FETS1D2L
fets_eval = FETS1D2L(mats_eval=MATS1DElastic())
# Discretization
fe_domain = FEDomain()
fe_level1 = FERefinementGrid(domain=fe_domain, fets_eval=fets_eval)
fe_domain1 = FEGrid(coord_max=(3., 0., 0.),
shape=(3, ),
level=fe_level1,
fets_eval=fets_eval)
fe_child_domain = FERefinementGrid(parent_domain=fe_level1,
fine_cell_shape=(2, ))
fe_child_domain.refine_elem((1, ))
ts = TS(domain=fe_domain,
dof_resultants=True,
sdomain=fe_domain,
bcond_list=[
BCDof(var='u', dof=0, value=0.),
BCDof(var='f', dof=3, value=1.)
])
# Add the time-loop control
tloop = TLoop(tstepper=ts,
debug=True,
tline=TLine(min=0.0, step=1, max=1.0))
print tloop.eval()
def screwed_chess_board( ):
'''Clamped bar 3 domains, each with 2 elems (displ at right end)
[0]-[1]-[2] [3]-[4]-[5] [6]-[7]-[8]
u[0] = 0, u[2] = u[3], u[5] = u[6], u[8] = 1'''
mp = MATS2DElastic( E = 34.e3,
nu = 0.2 )
fets_eval = FETS2D4Q(mats_eval = mp )
#fets_eval = FETS2D4Q8U(mats_eval = mp )
nx = 8
ny = 8
discr = ( nx, ny )
inactive_elems = []
for j in range( ny / 2 ):
inactive_elems += [ i*2*ny+(j*2) for i in range( nx / 2 ) ] + \
[ (ny+1)+i*2*ny+(j*2) for i in range( nx / 2 ) ]
load_dof = (ny+1) * 2 * (nx / 2) + ny
# Discretization
fe_domain1 = FEGrid( coord_min = (0,0,0),
coord_max = (2.,2.,0.),
shape = discr,
inactive_elems = inactive_elems,
fets_eval = fets_eval )
ts = TS( sdomain = fe_domain1,
dof_resultants = True,
bcond_list = [ BCDofGroup( var='u', value = 0., dims = [0,1],
get_dof_method = fe_domain1.get_bottom_dofs ),
BCDofGroup( var='u', value = 0, dims = [0,1],
get_dof_method = fe_domain1.get_top_dofs ),
BCDofGroup( var='u', value = 0, dims = [0,1],
get_dof_method = fe_domain1.get_left_dofs ),
BCDofGroup( var='u', value = 0, dims = [0,1],
get_dof_method = fe_domain1.get_right_dofs ),
BCDof( var='f', value = 100., dof = load_dof ),
BCDof( var='f', value = 100., dof = load_dof+1 ),
],
rtrace_list = [ RTraceDomainListField( name = 'Displacement',
var = 'u',
idx = 1, warp = False ),
RTraceDomainListField(name = 'Stress' ,
var = 'sig_app', idx = 0,
record_on = 'update',
warp = True),
]
)
# Add the time-loop control
global tloop
tloop = TLoop( tstepper = ts, tolerance = 1e-4, KMAX = 50,
tline = TLine( min = 0.0, step = 1.0, max = 1.0 ))
tloop.eval()
from ibvpy.plugins.ibvpy_app import IBVPyApp
app = IBVPyApp( ibv_resource = tloop )
app.main()
def example_with_new_domain():
from ibvpy.api import \
TStepper as TS, RTraceGraph, RTraceDomainListField, TLoop, \
TLine, IBVPSolve as IS, DOTSEval
from ibvpy.api import BCDofGroup
from ibvpy.mats.mats1D5.mats1D5bond_elastic_frictional import MATS1D5Bond
from ibvpy.mesh.fe_grid import FEGrid
from mathkit.mfn.mfn_line.mfn_line import MFnLineArray
fets_eval = FETS1D52B6ULRH(mats_eval = MATS1D5Bond(Ef = 17000.,
Af = 2.65e-6/4.,
Am = 2.65e-6/4.,
Em = 17000.,
tau_max = 8.23 * 2,
tau_fr = 8.23 * 2 ,
s_cr = 0.030e-3 * 10 ))
# Discretization
domain = FEGrid( coord_max = (1.,.1,0.), #new domain
shape = (1,1),
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 = [BCDofGroup(var='u', value = 0.,dims = [0],
get_dof_method = domain.get_left_dofs),\
# imposed displacement for all right dofs in y-direction:
# BCDofGroup(var='u', value = 0., dims = [0],
# get_dof_method = domain.get_top_right_dofs ),
BCDofGroup(var='u', value = 1.e-3, dims = [0],
get_dof_method = domain.get_bottom_right_dofs )],
rtrace_list = [ RTraceGraph(name = 'Fi,right over u_right (iteration)' ,
var_y = 'F_int', idx_y = 1,
var_x = 'U_k', idx_x = 1),
RTraceDomainListField(name = 'Debonding' ,
var = 'debonding', 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,
DT = 1.,
tline = TLine( min = 0.0, max = 1.0 ))
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_with_new_domain():
from ibvpy.api import \
TStepper as TS, RTraceGraph, RTraceDomainListField, TLoop, \
TLine, BCDof, IBVPSolve as IS, DOTSEval
from ibvpy.mats.mats1D.mats1D_elastic.mats1D_elastic import MATS1DElastic
fets_eval = FETS1D2L3U( mats_eval = MATS1DElastic( E = 10. ) )
from ibvpy.mesh.fe_grid import FEGrid
# Discretization
domain = FEGrid( coord_max = ( 3., ),
shape = ( 3, ),
fets_eval = fets_eval )
ts = TS( dof_resultants = True,
sdomain = domain,
# conversion to list (square brackets) is only necessary for slicing of
# single dofs, e.g "get_left_dofs()[0,1]"
# bcond_list = [ BCDof(var='u', dof = 0, value = 0.) ] +
# [ BCDof(var='u', dof = 2, value = 0.001 ) ]+
# [ ) ],
bcond_list = [BCDof( var = 'u', dof = 0, value = 0. ),
# BCDof(var='u', dof = 1, link_dofs = [2], link_coeffs = [0.5],
# value = 0. ),
# BCDof(var='u', dof = 2, link_dofs = [3], link_coeffs = [1.],
# value = 0. ),
BCDof( var = 'f', dof = 6, value = 1,
#link_dofs = [2], link_coeffs = [2]
) ],
rtrace_list = [ RTraceGraph( name = 'Fi,right over u_right (iteration)' ,
var_y = 'F_int', idx_y = 0,
var_x = 'U_k', idx_x = 1 ),
RTraceDomainListField( name = 'Stress' ,
var = 'sig_app', idx = 0 ),
RTraceDomainListField( name = 'Displacement' ,
var = 'u', idx = 0 ),
RTraceDomainListField( name = 'N0' ,
var = 'N_mtx', idx = 0,
record_on = 'update' )
]
)
# Add the time-loop control
tloop = TLoop( tstepper = ts,
tline = TLine( min = 0.0, step = 1, max = 1.0 ) )
print '---- result ----'
print tloop.eval()
print ts.F_int
print ts.rtrace_list[0].trace.ydata
# Put the whole stuff into the simulation-framework to map the
# individual pieces of definition into the user interface.
#
from ibvpy.plugins.ibvpy_app import IBVPyApp
app = IBVPyApp( ibv_resource = tloop )
app.main()
def run():
from ibvpy.api import \
TStepper as TS, RTraceGraph, RTraceDomainListField, TLoop, \
TLine, BCDof, IBVPSolve as IS, DOTSEval
from ibvpy.mats.mats1D.mats1D_elastic.mats1D_elastic import MATS1DElastic
from ibvpy.mats.mats1D.mats1D_damage.mats1D_damage import MATS1DDamage
from ibvpy.fets.fets1D.fets1D2l import FETS1D2L
#fets_eval = FETS1D2L( mats_eval = MATS1DElastic( E = 10. ) )
fets_eval = FETS1D2L( mats_eval = MATS1DDamage( E = 10. ) )
from ibvpy.mesh.fe_grid import FEGrid
# Discretization
domain = FEGrid( coord_max = ( 1., 0., 0. ),
shape = ( 10, ),
fets_eval = fets_eval )
right_dof = domain[-1, -1].dofs[0, 0, 0]
ts = TS( nonlocal_avg = True,
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 = right_dof, 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 ),
RTraceDomainListField( name = 'Stress' ,
var = 'sig_app', idx = 0 ),
RTraceDomainListField( name = 'Displacement' ,
var = 'u', idx = 0,
warp = True ),
RTraceDomainListField( name = 'N0' ,
var = 'N_mtx', idx = 0,
record_on = 'update' )
]
)
# Add the time-loop control
tloop = TLoop( tstepper = ts,
tline = TLine( min = 0.0, step = 0.5, max = 1.0 ) )
print '---- result ----'
print tloop.eval()
print ts.F_int
print ts.rtrace_list[0].trace.ydata
def example_3d():
from ibvpy.mats.mats3D.mats3D_elastic.mats3D_elastic import MATS3DElastic
from ibvpy.fets.fets3D.fets3D8h import FETS3D8H
fets_eval = FETS3D8H(mats_eval=MATS3DElastic())
fe_domain = FEDomain()
fe_level1 = FERefinementGrid(domain=fe_domain, fets_eval=fets_eval)
# Discretization
fe_domain1 = FEGrid(coord_max=(2., 5., 3.),
shape=(2, 3, 2),
level=fe_level1,
fets_eval=fets_eval)
fe_child_domain = FERefinementGrid(parent=fe_domain1,
fine_cell_shape=(2, 2, 2))
fe_child_domain.refine_elem((1, 1, 0))
fe_child_domain.refine_elem((0, 1, 0))
fe_child_domain.refine_elem((1, 1, 1))
fe_child_domain.refine_elem((0, 1, 1))
ts = TS(
dof_resultants=True,
sdomain=fe_domain,
bcond_list=[
BCDofGroup(var='f',
value=1.,
dims=[0],
get_dof_method=fe_domain1.get_top_dofs),
BCDofGroup(var='u',
value=0.,
dims=[0, 1],
get_dof_method=fe_domain1.get_bottom_dofs),
],
rtrace_list=[
RTraceGraph(name='Fi,right over u_right (iteration)',
var_y='F_int',
idx_y=0,
var_x='U_k',
idx_x=1),
# RTraceDomainListField(name = 'Stress' ,
# var = 'sig_app', idx = 0, warp = True ),
# RTraceDomainField(name = 'Displacement' ,
# var = 'u', idx = 0),
# RTraceDomainField(name = 'N0' ,
# var = 'N_mtx', idx = 0,
# record_on = 'update')
])
# Add the time-loop control
tloop = TLoop(tstepper=ts, tline=TLine(min=0.0, step=1, max=1.0))
print tloop.eval()
from ibvpy.plugins.ibvpy_app import IBVPyApp
ibvpy_app = IBVPyApp(ibv_resource=tloop)
ibvpy_app.main()
def notched_bended_beam():
fets_eval_4u = FETS2D4Q(mats_eval=MATS2DScalarDamage())
fets_eval_cracked = FETSLSEval(parent_fets=fets_eval_4u)
# Discretization
fe_domain1 = FEGrid(coord_max=(5., 2., 0.),
shape=(3, 2),
fets_eval=fets_eval_4u)
fe_child_domain = FERefinementGrid(parent_domain=fe_domain1,
fets_eval=fets_eval_cracked,
fine_cell_shape=(1, 1))
crack_level_set = lambda X: X[0] - 2.5
fe_child_domain.refine_elem((1, 0), crack_level_set)
dots = fe_child_domain.new_dots()
fe_domain = FEDomainList(subdomains=[fe_domain1])
fe_domain_tree = FEDomainTree(domain_list=fe_domain)
ts = TS(
dof_resultants=True,
sdomain=[fe_domain1, fe_child_domain],
bcond_list=[
BCDofGroup(var='u',
value=0.,
dims=[0, 1],
get_dof_method=fe_domain1.get_left_dofs),
BCDofGroup(var='u',
value=0.,
dims=[0, 1],
get_dof_method=fe_domain1.get_right_dofs),
BCDofGroup(var='f',
value=-1.,
dims=[1],
get_dof_method=fe_domain1.get_top_dofs),
],
rtrace_list=[
# RTraceGraph(name = 'Fi,right over u_right (iteration)' ,
# var_y = 'F_int', idx_y = 0,
# var_x = 'U_k', idx_x = 1),
# RTraceDomainListField(name = 'Stress' ,
# var = 'sig_app', idx = 0, warp = True ),
# RTraceDomainField(name = 'Displacement' ,
# var = 'u', idx = 0),
# RTraceDomainField(name = 'N0' ,
# var = 'N_mtx', idx = 0,
# record_on = 'update')
#
])
# Add the time-loop control
tloop = TLoop(tstepper=ts, tline=TLine(min=0.0, step=1, max=1.0))
print tloop.eval()
def run_example():
from ibvpy.api import \
TStepper as TS, RTraceGraph, RTraceDomainListField, \
RTraceDomainListInteg, TLoop, \
TLine, BCDof, IBVPSolve as IS, DOTSEval
from ibvpy.mats.mats2D.mats2D_conduction.mats2D_conduction import MATS2DConduction
from ibvpy.api import BCDofGroup
fets_eval = FETS2D4Q4T(mats_eval=MATS2DConduction(k=1.))
print fets_eval.vtk_node_cell_data
from ibvpy.mesh.fe_grid import FEGrid
from ibvpy.mesh.fe_refinement_grid import FERefinementGrid
from ibvpy.mesh.fe_domain import FEDomain
from mathkit.mfn import MFnLineArray
# Discretization
fe_grid = FEGrid(coord_max=(1., 1., 0.), shape=(2, 2), fets_eval=fets_eval)
tstepper = TS(
sdomain=fe_grid,
bcond_list=[
BCDofGroup(var='u',
value=0.,
dims=[0],
get_dof_method=fe_grid.get_left_dofs),
# BCDofGroup( var='u', value = 0., dims = [1],
# get_dof_method = fe_grid.get_bottom_dofs ),
BCDofGroup(var='u',
value=.005,
dims=[0],
get_dof_method=fe_grid.get_top_right_dofs)
],
rtrace_list=[
# RTraceDomainListField(name = 'Damage' ,
# var = 'omega', idx = 0,
# record_on = 'update',
# warp = True),
# RTraceDomainListField(name = 'Displacement' ,
# var = 'u', idx = 0,
# record_on = 'update',
# warp = True),
# RTraceDomainListField(name = 'N0' ,
# var = 'N_mtx', idx = 0,
# record_on = 'update')
])
print tstepper.setup()
return
# Add the time-loop control
tloop = TLoop(tstepper=tstepper,
debug=False,
tline=TLine(min=0.0, step=1.0, max=1.0))
tloop.eval()
def example_2d():
from ibvpy.mats.mats2D.mats2D_elastic.mats2D_elastic import MATS2DElastic
from ibvpy.fets.fets2D.fets2D4q import FETS2D4Q
fets_eval = FETS2D4Q(mats_eval=MATS2DElastic(E=2.1e5))
# Discretization
fe_domain1 = FEGrid(coord_max=(2., 5., 0.),
shape=(10, 10),
fets_eval=fets_eval)
fe_subgrid1 = FERefinementLevel(parent=fe_domain1,
fine_cell_shape=(1, 1))
print 'children'
print fe_domain1.children
fe_subgrid1.refine_elem((5, 5))
fe_subgrid1.refine_elem((6, 5))
fe_subgrid1.refine_elem((7, 5))
fe_subgrid1.refine_elem((8, 5))
fe_subgrid1.refine_elem((9, 5))
fe_domain = FEDomain(subdomains=[fe_domain1])
ts = TS(dof_resultants=True,
sdomain=fe_domain,
bcond_list=[BCDofGroup(var='f', value=0.1, dims=[0],
get_dof_method=fe_domain1.get_top_dofs),
BCDofGroup(var='u', value=0., dims=[0, 1],
get_dof_method=fe_domain1.get_bottom_dofs),
],
rtrace_list=[RTraceGraph(name='Fi,right over u_right (iteration)',
var_y='F_int', idx_y=0,
var_x='U_k', idx_x=1),
RTraceDomainListField(name='Stress',
var='sig_app', idx=0, warp=True),
# RTraceDomainField(name = 'Displacement' ,
# var = 'u', idx = 0),
# RTraceDomainField(name = 'N0' ,
# var = 'N_mtx', idx = 0,
# record_on = 'update')
]
)
# Add the time-loop control
tloop = TLoop(tstepper=ts,
tline=TLine(min=0.0, step=1, max=1.0))
#
print tloop.eval()
from ibvpy.plugins.ibvpy_app import IBVPyApp
ibvpy_app = IBVPyApp(ibv_resource=tloop)
ibvpy_app.main()
def example_2d():
from ibvpy.mats.mats2D.mats2D_elastic.mats2D_elastic import MATS2DElastic
from ibvpy.fets.fets2D.fets2D4q import FETS2D4Q
fets_eval = FETS2D4Q(mats_eval = MATS2DElastic( E = 2.1e5 ))
# Discretization
fe_domain1 = FEGrid( coord_max = (2.,5.,0.),
shape = (10,10),
fets_eval = fets_eval )
fe_subgrid1 = FERefinementLevelGrid( parent_domain = fe_domain1,
fine_cell_shape = (1,1) )
print 'children'
print fe_domain1.children
fe_subgrid1.refine_elem( (5,5) )
fe_subgrid1.refine_elem( (6,5) )
fe_subgrid1.refine_elem( (7,5) )
fe_subgrid1.refine_elem( (8,5) )
fe_subgrid1.refine_elem( (9,5) )
fe_domain = FEDomainList( subdomains = [ fe_domain1 ] )
ts = TS( dof_resultants = True,
sdomain = fe_domain,
bcond_list = [BCDofGroup(var='f', value = 0.1, dims = [0],
get_dof_method = fe_domain1.get_top_dofs ),
BCDofGroup(var='u', value = 0., dims = [0,1],
get_dof_method = fe_domain1.get_bottom_dofs ),
],
rtrace_list = [ RTraceGraph(name = 'Fi,right over u_right (iteration)' ,
var_y = 'F_int', idx_y = 0,
var_x = 'U_k', idx_x = 1),
RTraceDomainListField(name = 'Stress' ,
var = 'sig_app', idx = 0, warp = True ),
# RTraceDomainField(name = 'Displacement' ,
# var = 'u', idx = 0),
# RTraceDomainField(name = 'N0' ,
# var = 'N_mtx', idx = 0,
# record_on = 'update')
]
)
# Add the time-loop control
tloop = TLoop( tstepper = ts,
tline = TLine( min = 0.0, step = 1, max = 1.0 ))
#
print tloop.eval()
from ibvpy.plugins.ibvpy_app import IBVPyApp
ibvpy_app = IBVPyApp( ibv_resource = tloop )
ibvpy_app.main()
def demo3d():
# Geometry
#
length = 1.0
from ibvpy.fets.fets3D import FETS3D8H, FETS3D8H20U, FETS3D8H27U, FETS3D8H20U
from ibvpy.mats.mats3D import MATS3DElastic
# Material and FE Formulation
#
lin_x_temperature = TemperatureLinFn(length=length, n_dims=3, offset=0.5)
fets_eval = FETS3D8H20U(mats_eval=MATS3DElastic(
E=30e3, nu=0.2, initial_strain=lin_x_temperature))
fets_eval.vtk_r *= 0.99
# Discretization
#
domain = FEGrid(coord_max=(length, length, length),
shape=(6, 3, 3),
fets_eval=fets_eval)
bcond_list = [
BCSlice(var='u',
dims=[0, 1, 2],
slice=domain[0, 0, 0, 0, 0, 0],
value=0),
BCSlice(var='u',
dims=[0, 1],
slice=domain[0, 0, -1, 0, 0, -1],
value=0),
BCSlice(var='u', dims=[0], slice=domain[0, -1, 0, 0, -1, 0], value=0),
]
rtrace_list = [
sig_trace, eps_trace, eps0_trace, eps1t_trace, max_p_sig_trace, u_trace
]
for rtrace in rtrace_list:
rtrace.position = 'int_pnts'
rtrace.warp = False
corner_dof = domain[-1, -1, -1, -1, -1, -1].dofs[0, 0, 2]
ts = TS(sdomain=domain, bcond_list=bcond_list, rtrace_list=rtrace_list)
# Time integration
#
tloop = TLoop(tstepper=ts, tline=TLine(min=0.0, step=3, max=1.0))
tloop.eval()
# Postprocessing
#
app = IBVPyApp(ibv_resource=tloop)
app.main()
def example_3d():
from ibvpy.mats.mats3D.mats3D_elastic.mats3D_elastic import MATS3DElastic
from ibvpy.fets.fets3D.fets3D8h import FETS3D8H
fets_eval = FETS3D8H(mats_eval=MATS3DElastic())
fe_domain = FEDomain()
fe_level1 = FERefinementGrid(domain=fe_domain, fets_eval=fets_eval)
# Discretization
fe_domain1 = FEGrid(coord_max=(2., 5., 3.),
shape=(2, 3, 2),
level=fe_level1,
fets_eval=fets_eval)
fe_child_domain = FERefinementGrid(parent=fe_domain1,
fine_cell_shape=(2, 2, 2))
fe_child_domain.refine_elem((1, 1, 0))
fe_child_domain.refine_elem((0, 1, 0))
fe_child_domain.refine_elem((1, 1, 1))
fe_child_domain.refine_elem((0, 1, 1))
ts = TS(dof_resultants=True,
sdomain=fe_domain,
bcond_list=[BCDofGroup(var='f', value=1., dims=[0],
get_dof_method=fe_domain1.get_top_dofs),
BCDofGroup(var='u', value=0., dims=[0, 1],
get_dof_method=fe_domain1.get_bottom_dofs),
],
rtrace_list=[ RTraceGraph(name='Fi,right over u_right (iteration)' ,
var_y='F_int', idx_y=0,
var_x='U_k', idx_x=1),
# RTraceDomainListField(name = 'Stress' ,
# var = 'sig_app', idx = 0, warp = True ),
# RTraceDomainField(name = 'Displacement' ,
# var = 'u', idx = 0),
# RTraceDomainField(name = 'N0' ,
# var = 'N_mtx', idx = 0,
# record_on = 'update')
]
)
# Add the time-loop control
tloop = TLoop(tstepper=ts,
tline=TLine(min=0.0, step=1, max=1.0))
print tloop.eval()
from ibvpy.plugins.ibvpy_app import IBVPyApp
ibvpy_app = IBVPyApp(ibv_resource=tloop)
ibvpy_app.main()
def example_with_new_domain():
from ibvpy.api import \
TStepper as TS, RTraceGraph, RTraceDomainField, TLoop, \
TLine, BCDofGroup, IBVPSolve as IS, DOTSEval
from ibvpy.mats.mats1D.mats1D_elastic.mats1D_elastic import MATS1DElastic
fets_eval = FETS1D2Lxfem(mats_eval = MATS1DElastic(E=10., A=1.))
# Tseval for a discretized line domain
tseval = DOTSEval( fets_eval = fets_eval )
from ibvpy.mesh.fe_grid import FEGrid
# Discretization
domain = FEGrid( coord_max = (1.,0.,0.),
shape = (1,),
n_nodal_dofs = fets_eval.n_nodal_dofs,
dof_r = fets_eval.dof_r,
geo_r = fets_eval.geo_r)
ts = TS( tse = tseval,
dof_resultants = True,
sdomain = domain,
bcond_list = [ BCDofGroup( var='u', value = 0., dims = [0],
get_dof_method = domain.get_left_dofs ),
BCDofGroup( var='u', value = 1., 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 = 0,
var_x = 'U_k', idx_x = 1),
RTraceDomainField(name = 'Stress' ,
var = 'sig_app', idx = 0),
RTraceDomainField(name = 'Displacement' ,
var = 'u', idx = 0)
]
)
# Add the time-loop control
tloop = TLoop( tstepper = ts,
tline = TLine( min = 0.0, step = 1, max = 1.0 ))
print '---- result ----'
print tloop.eval()
print ts.F_int
print ts.rtrace_list[0].trace.ydata
# Put the whole stuff into the simulation-framework to map the
# individual pieces of definition into the user interface.
#
from ibvpy.plugins.ibvpy_app import IBVPyApp
app = IBVPyApp( ibv_resource = tloop )
app.main()
def __demo__():
from ibvpy.api import \
TStepper as TS, RTraceGraph, RTraceDomainListField, TLoop, \
TLine, BCDof
from ibvpy.mats.mats1D.mats1D_elastic.mats1D_elastic import MATS1DElastic
fets_eval = FETS1D2L(mats_eval=MATS1DElastic(E=10.))
from ibvpy.mesh.fe_grid import FEGrid
# Discretization
domain = FEGrid(coord_max=(3., ), shape=(3, ), fets_eval=fets_eval)
ts = TS(dof_resultants=True,
sdomain=domain,
bcond_list=[
BCDof(var='u', dof=0, value=0.),
BCDof(
var='f',
dof=3,
value=1,
)
],
rtrace_list=[
RTraceGraph(name='Fi,right over u_right (iteration)',
var_y='F_int',
idx_y=0,
var_x='U_k',
idx_x=1),
RTraceDomainListField(name='Stress', var='sig_app', idx=0),
RTraceDomainListField(name='Displacement',
var='u',
idx=0,
warp=True),
RTraceDomainListField(name='N0',
var='N_mtx',
idx=0,
record_on='update')
])
# Add the time-loop control
tloop = TLoop(tstepper=ts, tline=TLine(min=0.0, step=0.5, max=1.0))
print '---- result ----'
print tloop.eval()
print ts.F_int
print ts.rtrace_list[0].trace.ydata
# Put the whole stuff into the simulation-framework to map the
# individual pieces of definition into the user interface.
#
app = IBVPyApp(ibv_resource=tloop)
app.main()
def test_bar2( ):
'''Clamped bar composed of two linked bars loaded at the right end
[00]-[01]-[02]-[03]-[04]-[05]-[06]-[07]-[08]-[09]-[10]
[11]-[12]-[13]-[14]-[15]-[16]-[17]-[18]-[19]-[20]-[21]
u[0] = 0, u[5] = u[16], R[-1] = R[21] = 10
'''
fets_eval = FETS1D2L(mats_eval = MATS1DElastic(E=10., A=1.))
# Discretization
fe_domain1 = FEGrid( coord_max = (10.,0.,0.),
shape = (10,),
n_nodal_dofs = 1,
dof_r = fets_eval.dof_r,
geo_r = fets_eval.geo_r )
fe_domain2 = FEGrid( coord_min = (10.,0.,0.),
coord_max = (20.,0.,0.),
shape = (10,),
n_nodal_dofs = 1,
dof_r = fets_eval.dof_r,
geo_r = fets_eval.geo_r )
ts = TS( iterms = [ ( fets_eval, fe_domain1 ), (fets_eval, fe_domain2 ) ],
dof_resultants = True,
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 ))
u = tloop.eval()
print 'u', u
#
# '---------------------------------------------------------------'
# 'Clamped bar composed of two linked bars control displ at right'
# 'u[0] = 0, u[5] = u[16], u[21] = 1'
# Remove the load and put a unit displacement at the right end
# Note, the load is irrelevant in this case and will be rewritten
#
ts.bcond_list = [BCDof(var='u', dof = 0, value = 0.),
BCDof(var='u', dof = 5, link_dofs = [16], link_coeffs = [1.],
value = 0. ),
BCDof(var='u', dof = 21, value = 1. ) ]
# system solver
u = tloop.eval()
print 'u',u
def test_bar4( ):
'''Clamped bar 3 domains, each with 2 elems (displ at right end)
[0]-[1]-[2] [3]-[4]-[5] [6]-[7]-[8]
u[0] = 0, u[2] = u[3], u[5] = u[6], u[8] = 1'''
fets_eval = FETS1D2L(mats_eval = MATS1DElastic(E=10., A=1.))
# Discretization
fe_domain1 = FEGrid( coord_max = (2.,0.,0.),
shape = (2,),
n_nodal_dofs = 1,
dof_r = fets_eval.dof_r,
geo_r = fets_eval.geo_r )
fe_domain2 = FEGrid( coord_min = (2.,0.,0.),
coord_max = (4.,0.,0.),
shape = (2,),
n_nodal_dofs = 1,
dof_r = fets_eval.dof_r,
geo_r = fets_eval.geo_r )
fe_domain3 = FEGrid( coord_min = (4.,0.,0.),
coord_max = (6.,0.,0.),
shape = (2,),
n_nodal_dofs = 1,
dof_r = fets_eval.dof_r,
geo_r = fets_eval.geo_r )
ts = TS( iterms = [ ( fets_eval, fe_domain1 ), (fets_eval, fe_domain2 ), (fets_eval, fe_domain3 ) ],
dof_resultants = True,
bcond_list = [BCDof(var='u', dof = 0, value = 0.),
BCDof(var='u', dof = 2, link_dofs = [3], link_coeffs = [1.],
value = 0. ),
BCDof(var='u', dof = 5, link_dofs = [6], link_coeffs = [1.],
value = 0. ),
BCDof(var='u', dof = 8, value = 1) ],
rtrace_list = [ RTraceGraph(name = 'Fi,right over u_right (iteration)' ,
var_y = 'F_int', idx_y = 0,
var_x = 'U_k', idx_x = 1),
RTraceDomainListField( name = 'Displacement', var = 'u', idx = 0 )
]
)
# 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
app = IBVPyApp( ibv_resource = tloop )
app.main()
def notched_bended_beam():
fets_eval_4u = FETS2D4Q( mats_eval = MATS2DScalarDamage() )
fets_eval_cracked = FETSLSEval( parent_fets = fets_eval_4u )
# Discretization
fe_domain1 = FEGrid( coord_max = (5.,2.,0.),
shape = (3,2),
fets_eval = fets_eval_4u )
fe_child_domain = FERefinementGrid( parent_domain = fe_domain1,
fets_eval = fets_eval_cracked,
fine_cell_shape = (1,1) )
crack_level_set = lambda X: X[0] - 2.5
fe_child_domain.refine_elem( (1,0), crack_level_set )
dots = fe_child_domain.new_dots()
fe_domain = FEDomainList( subdomains = [ fe_domain1 ] )
fe_domain_tree = FEDomainTree( domain_list = fe_domain )
ts = TS( dof_resultants = True,
sdomain = [ fe_domain1, fe_child_domain ],
bcond_list = [BCDofGroup(var='u', value = 0., dims = [0,1],
get_dof_method = fe_domain1.get_left_dofs ),
BCDofGroup(var='u', value = 0., dims = [0,1],
get_dof_method = fe_domain1.get_right_dofs ),
BCDofGroup(var='f', value = -1., dims = [1],
get_dof_method = fe_domain1.get_top_dofs ),
],
rtrace_list = [
# RTraceGraph(name = 'Fi,right over u_right (iteration)' ,
# var_y = 'F_int', idx_y = 0,
# var_x = 'U_k', idx_x = 1),
# RTraceDomainListField(name = 'Stress' ,
# var = 'sig_app', idx = 0, warp = True ),
# RTraceDomainField(name = 'Displacement' ,
# var = 'u', idx = 0),
# RTraceDomainField(name = 'N0' ,
# var = 'N_mtx', idx = 0,
# record_on = 'update')
#
]
)
# Add the time-loop control
tloop = TLoop( tstepper = ts,
tline = TLine( min = 0.0, step = 1, max = 1.0 ))
print tloop.eval()
def run_example():
from ibvpy.api import \
TStepper as TS, RTraceGraph, RTraceDomainListField, \
RTraceDomainListInteg, TLoop, \
TLine, BCDof, IBVPSolve as IS, DOTSEval
from ibvpy.mats.mats2D.mats2D_conduction.mats2D_conduction import MATS2DConduction
from ibvpy.api import BCDofGroup
fets_eval = FETS2D4Q4T(mats_eval=MATS2DConduction(k=1.))
print fets_eval.vtk_node_cell_data
from ibvpy.mesh.fe_grid import FEGrid
from ibvpy.mesh.fe_refinement_grid import FERefinementGrid
from ibvpy.mesh.fe_domain import FEDomain
from mathkit.mfn import MFnLineArray
# Discretization
fe_grid = FEGrid(coord_max=(1., 1., 0.),
shape=(2, 2),
fets_eval=fets_eval)
tstepper = TS(sdomain=fe_grid,
bcond_list=[BCDofGroup(var='u', value=0., dims=[0],
get_dof_method=fe_grid.get_left_dofs),
# BCDofGroup( var='u', value = 0., dims = [1],
# get_dof_method = fe_grid.get_bottom_dofs ),
BCDofGroup(var='u', value=.005, dims=[0],
get_dof_method=fe_grid.get_top_right_dofs)],
rtrace_list=[
# RTraceDomainListField(name = 'Damage' ,
# var = 'omega', idx = 0,
# record_on = 'update',
# warp = True),
# RTraceDomainListField(name = 'Displacement' ,
# var = 'u', idx = 0,
# record_on = 'update',
# warp = True),
# RTraceDomainListField(name = 'N0' ,
# var = 'N_mtx', idx = 0,
# record_on = 'update')
]
)
print tstepper.setup()
return
# Add the time-loop control
tloop = TLoop(tstepper=tstepper, debug=False,
tline=TLine(min=0.0, step=1.0, max=1.0))
tloop.eval()
def demo3d():
# Geometry
#
length = 1.0
from ibvpy.fets.fets3D import FETS3D8H, FETS3D8H20U, FETS3D8H27U, FETS3D8H20U
from ibvpy.mats.mats3D import MATS3DElastic
# Material and FE Formulation
#
lin_x_temperature = TemperatureLinFn( length = length, n_dims = 3, offset = 0.5 )
fets_eval = FETS3D8H20U( mats_eval = MATS3DElastic( E = 30e3, nu = 0.2,
initial_strain = lin_x_temperature ) )
fets_eval.vtk_r *= 0.99
# Discretization
#
domain = FEGrid( coord_max = ( length, length, length ),
shape = ( 6, 3, 3 ),
fets_eval = fets_eval )
bcond_list = [BCSlice( var = 'u', dims = [0, 1, 2], slice = domain[0, 0, 0, 0, 0, 0], value = 0 ),
BCSlice( var = 'u', dims = [0], slice = domain[0, -1, 0, 0, -1, 0], value = 0 ),
BCSlice( var = 'u', dims = [0, 1], slice = domain[0, 0, -1, 0, 0, -1], value = 0 ),
]
rtrace_list = [ sig_trace, eps_trace, eps0_trace, eps1t_trace, max_p_sig_trace, u_trace ]
for rtrace in rtrace_list:
rtrace.position = 'int_pnts'
rtrace.warp = False
corner_dof = domain[-1, -1, -1, -1, -1, -1].dofs[0, 0, 2]
ts = TS( sdomain = domain,
bcond_list = bcond_list,
rtrace_list = rtrace_list
)
# Time integration
#
tloop = TLoop( tstepper = ts,
tline = TLine( min = 0.0, step = 3, max = 1.0 ) )
tloop.eval()
# Postprocessing
#
app = IBVPyApp( ibv_resource = tloop )
app.main()
def L_shape( ):
'''L-shaped domain constructed by deleting elements from the quadrangle'''
mp = MATS2DElastic( E = 34.e3,
nu = 0.2 )
fets_eval = FETS2D4Q(mats_eval = mp )
discr = ( 3, 2 )
# Discretization
fe_domain1 = FEGrid( coord_min = (0,0,0),
coord_max = (2.,2.,0.),
shape = discr,
inactive_elems = [3,5],
fets_eval = fets_eval )
ts = TS( sdomain = fe_domain1,
dof_resultants = True,
bcond_list = [ BCDofGroup( var='u', value = 0., dims = [0,1],
get_dof_method = fe_domain1.get_top_dofs ),
BCDofGroup( var='u', value = 0., dims = [0,1],
get_dof_method = fe_domain1.get_left_dofs ),
# BCDof( var='u', value = 0., dof = 20 ),
# BCDof( var='u', value = 0., dof = 21 ),
# BCDof( var='u', value = 0., dof = 16 ),
# BCDof( var='u', value = 0., dof = 17 ),
BCDofGroup( var='f', value = -1, dims = [1],
get_dof_method = fe_domain1.get_right_dofs )
],
rtrace_list = [ RTraceDomainListField( name = 'Displacement',
var = 'u',
idx = 1, warp = False ),
RTraceDomainField(name = 'Stress' ,
var = 'sig_app', idx = 0,
record_on = 'update',
warp = True),
]
)
# Add the time-loop control
global tloop
tloop = TLoop( tstepper = ts, tolerance = 1e-4, KMAX = 50,
tline = TLine( min = 0.0, step = 1.0, max = 1.0 ))
print tloop.eval()
from ibvpy.plugins.ibvpy_app import IBVPyApp
app = IBVPyApp( ibv_resource = tloop )
app.main()
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 __demo__():
from ibvpy.api import \
TStepper as TS, RTraceGraph, RTraceDomainListField, TLoop, \
TLine, BCDof
from ibvpy.mats.mats1D.mats1D_elastic.mats1D_elastic import MATS1DElastic
fets_eval = FETS1D2L(mats_eval=MATS1DElastic(E=10.))
from ibvpy.mesh.fe_grid import FEGrid
# Discretization
domain = FEGrid(coord_max=(3.,),
shape=(3,),
fets_eval=fets_eval)
ts = TS(dof_resultants=True,
sdomain=domain,
bcond_list=[BCDof(var='u', dof=0, value=0.),
BCDof(var='f', dof=3, value=1,)],
rtrace_list=[RTraceGraph(name='Fi,right over u_right (iteration)',
var_y='F_int', idx_y=0,
var_x='U_k', idx_x=1),
RTraceDomainListField(name='Stress',
var='sig_app', idx=0),
RTraceDomainListField(name='Displacement',
var='u', idx=0,
warp=True),
RTraceDomainListField(name='N0',
var='N_mtx', idx=0,
record_on='update')
]
)
# Add the time-loop control
tloop = TLoop(tstepper=ts,
tline=TLine(min=0.0, step=0.5, max=1.0))
print '---- result ----'
print tloop.eval()
print ts.F_int
print ts.rtrace_list[0].trace.ydata
# Put the whole stuff into the simulation-framework to map the
# individual pieces of definition into the user interface.
#
app = IBVPyApp(ibv_resource=tloop)
app.main()
def demo1d():
# Geometry
#
length = 1.0
# Material and FE Formulation
#
from ibvpy.fets.fets1D import FETS1D2L, FETS1D2L3U
from ibvpy.mats.mats1D import MATS1DElastic
mats_eval = MATS1DElastic(E=100.,
initial_strain=TemperatureLinFn(length=length,
n_dims=1,
offset=0.5))
fets_eval = FETS1D2L3U(mats_eval=mats_eval)
fets_eval.vtk_r *= 0.99
# Discretization
#
domain = FEGrid(coord_max=(length, 0., 0.),
n_elems=(10, ),
fets_eval=fets_eval)
bcond_list = [
BCSlice(var='u', dims=[0], slice=domain[0, 0], value=0),
#BCSlice( var = 'u', dims = [0], slice = domain[-1, -1], value = 0 )
]
ts = TS(sdomain=domain,
bcond_list=bcond_list,
rtrace_list=[sig_trace, eps_trace, eps0_trace, eps1t_trace])
# Time integration
#
tloop = TLoop(tstepper=ts, tline=TLine(min=0.0, step=1, max=1.0))
tloop.eval()
# Postprocessing
#
legend = []
plot_sig(eps_trace, 'eps', legend)
plot_sig(eps0_trace, 'eps0', legend)
plot_sig(eps1t_trace, 'eps1t', legend)
p.legend(legend)
p.show()
def example_with_new_domain():
from ibvpy.api import \
TStepper as TS, RTDofGraph, RTraceDomainListField, TLoop, \
TLine, BCDof, IBVPSolve as IS, DOTSEval
from ibvpy.mats.mats1D.mats1D_elastic.mats1D_elastic import MATS1DElastic
fets_eval = FETS1D2L3U(mats_eval=MATS1DElastic(E=10.))
from ibvpy.mesh.fe_grid import FEGrid
# Discretization
domain = FEGrid(coord_max=(3., ),
shape=(3, ),
fets_eval=fets_eval)
ts = TS(dof_resultants=True,
sdomain=domain,
# conversion to list (square brackets) is only necessary for slicing of
# single dofs, e.g "get_left_dofs()[0,1]"
# bcond_list = [ BCDof(var='u', dof = 0, value = 0.) ] +
# [ BCDof(var='u', dof = 2, value = 0.001 ) ]+
# [ ) ],
bcond_list=[BCDof(var='u', dof=0, value=0.),
# BCDof(var='u', dof = 1, link_dofs = [2], link_coeffs = [0.5],
# value = 0. ),
# BCDof(var='u', dof = 2, link_dofs = [3], link_coeffs = [1.],
# value = 0. ),
BCDof(var='f', dof=6, value=1,
# link_dofs = [2], link_coeffs = [2]
)],
rtrace_list=[RTDofGraph(name='Fi,right over u_right (iteration)',
var_y='F_int', idx_y=0,
var_x='U_k', idx_x=1),
RTraceDomainListField(name='Stress',
var='sig_app', idx=0),
RTraceDomainListField(name='Displacement',
var='u', idx=0),
RTraceDomainListField(name='N0',
var='N_mtx', idx=0,
record_on='update')
]
)
# Add the time-loop control
tloop = TLoop(tstepper=ts,
tline=TLine(min=0.0, step=1, max=1.0))
print('---- result ----')
print(tloop.eval())
print(ts.F_int)
print(ts.rtrace_list[0].trace.ydata)
# Put the whole stuff into the simulation-framework to map the
# individual pieces of definition into the user interface.
#
from ibvpy.plugins.ibvpy_app import IBVPyApp
app = IBVPyApp(ibv_resource=tloop)
app.main()
def demo1d():
# Geometry
#
length = 1.0
# Material and FE Formulation
#
from ibvpy.fets.fets1D import FETS1D2L, FETS1D2L3U
from ibvpy.mats.mats1D import MATS1DElastic
mats_eval = MATS1DElastic( E = 100.,
initial_strain = TemperatureLinFn( length = length, n_dims = 1 ) )
fets_eval = FETS1D2L( mats_eval = mats_eval )
fets_eval.vtk_r *= 0.99
# Discretization
#
domain = FEGrid( coord_max = ( length, 0., 0. ),
shape = ( 100, ),
fets_eval = fets_eval )
bcond_list = [BCSlice( var = 'u', dims = [0], slice = domain[0, 0], value = 0 ),
BCSlice( var = 'u', dims = [0], slice = domain[-1, -1], value = 0 )
]
ts = TS( sdomain = domain,
bcond_list = bcond_list,
rtrace_list = [ sig_trace, eps_trace, eps0_trace, eps1t_trace ] )
# Time integration
#
tloop = TLoop( tstepper = ts,
tline = TLine( min = 0.0, step = 1, max = 1.0 ) )
tloop.eval()
# Postprocessing
#
legend = []
plot_sig( eps_trace, 'eps', legend )
plot_sig( eps0_trace, 'eps0', legend )
plot_sig( eps1t_trace, 'eps1t', legend )
p.legend( legend )
p.show()
def example_with_new_domain():
from ibvpy.api import \
TStepper as TS, RTraceGraph, RTraceDomainListField, TLoop, \
TLine, BCDof, IBVPSolve as IS, DOTSEval
# fets_eval = FETS2D4Q( mats_eval = MATS2DElastic( E = 1., nu = 0. ) )
#
#
# # Discretization
# fe_grid1 = FEGrid( coord_max = ( 1., 1., 0. ),
# shape = ( 1, 1 ),
# fets_eval = fets_eval )
ts = TS( dof_resultants = True,
sdomain = fe_grid1,
# conversion to list (square brackets) is only necessary for slicing of
# single dofs, e.g "get_left_dofs()[0,1]"
bcond_list = [
],
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 = True,
adap = ChangeBC(),
tline = TLine( min = 0.0, step = 1., max = 2.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 demo2d():
# Geometry
#
length = 1.0
from ibvpy.fets.fets2D import FETS2D4Q, FETS2D4Q8U, FETS2D4Q16U
from ibvpy.mats.mats2D import MATS2DElastic
# Material and FE Formulation
#
lin_x_temperature = TemperatureLinFn( length = length, n_dims = 2, offset = 0.5 )
fets_eval = FETS2D4Q8U( # use 2x2 integration scheme:
ngp_r = 3, ngp_s = 3,
mats_eval = MATS2DElastic( E = 30e3, nu = 0.2,
initial_strain = lin_x_temperature ) )
fets_eval.vtk_r *= 0.99
# Discretization
#
domain = FEGrid( coord_max = ( length, length, 0. ),
shape = ( 10, 10 ),
fets_eval = fets_eval )
bcond_list = [BCSlice( var = 'u', dims = [0, 1], slice = domain[0, 0, 0, 0], value = 0 ),
BCSlice( var = 'u', dims = [1], slice = domain[0, -1, 0, -1], value = 0 ),
]
rtrace_list = [ sig_trace, eps_trace, eps0_trace, eps1t_trace, u_trace ]
ts = TS( sdomain = domain,
bcond_list = bcond_list,
rtrace_list = rtrace_list,
)
# Time integration
#
tloop = TLoop( tstepper = ts,
tline = TLine( min = 0.0, step = 1, max = 1.0 ) )
tloop.eval()
# Postprocessing
#
app = IBVPyApp( ibv_resource = tloop )
app.main()
def demo2d():
# Geometry
#
length = 1.0
from ibvpy.fets.fets2D import FETS2D4Q, FETS2D4Q8U, FETS2D4Q12U
from ibvpy.mats.mats2D import MATS2DElastic
# Material and FE Formulation
#
lin_x_temperature = TemperatureLinFn(length=length, n_dims=2)
fets_eval = FETS2D4Q12U(mats_eval=MATS2DElastic(
E=30e5, nu=0.2, initial_strain=lin_x_temperature))
fets_eval.vtk_r *= 0.99
# Discretization
#
domain = FEGrid(coord_max=(length, length, 0.),
shape=(10, 10),
fets_eval=fets_eval)
bcond_list = [
BCSlice(var='u', dims=[0, 1], slice=domain[0, 0, 0, 0], value=0),
BCSlice(var='u', dims=[1], slice=domain[0, -1, 0, -1], value=0),
]
rtrace_list = [sig_trace, eps_trace, eps0_trace, eps1t_trace, u_trace]
ts = TS(
sdomain=domain,
bcond_list=bcond_list,
rtrace_list=rtrace_list,
)
# Time integration
#
tloop = TLoop(tstepper=ts, tline=TLine(min=0.0, step=1, max=1.0))
tloop.eval()
# Postprocessing
#
app = IBVPyApp(ibv_resource=tloop)
app.main()
def eval(self):
mats = MATS2DElastic( E = 35000., nu = self.nu, stress_state = "plane_strain" )
fets_eval = FETS2D4Q( mats_eval = mats )
domain = FEGrid( coord_max = ( self.edge_length, self.edge_length, 0.),
shape = ( int( self.shape ), int( self.shape ) ),
fets_eval = fets_eval )
upper_right_corner_dof = domain[-1,-1,-1,-1].dofs
ts = TS(
sdomain = domain,
# # simple shear test: clamped at left side loaded at right side
# bcond_list = [BCSlice( var = 'u', value = 0., dims = [0,1], slice = domain[0, 0, 0, :] ),
# BCSlice( var = 'u', value = 0., dims = [0] , slice = domain[0, 0,-1, :] ),
# BCSlice( var = 'f', value = 1.0, dims = [1] , slice = domain[0, 0,-1, :] )],
# shear test: fixed at 000, one support in x-direction at left top; load at top right
bcond_list = [BCSlice( var = 'u', value = 0., dims = [0,1], slice = domain[0, 0, 0, 0] ),
BCSlice( var = 'u', value = 0., dims = [0] , slice = domain[0, 0, 0,-1] ),
BCSlice( var = 'f', value = 1.0, dims = [1] , slice = domain[0, 0,-1,-1] )],
rtrace_list = [
RTraceDomainListField(name = 'Displacement' ,
var = 'u', idx = 0, warp = True),
RTraceDomainListField(name = 'Stress' ,
var = 'sig_app', idx = 0, warp = True,
record_on = 'update'),
]
)
# Add the time-loop control
tloop = TLoop( tstepper = ts,
tline = TLine( min = 0.0, step = 1., max = 1.0 ) )
tloop.eval()
return tloop
def example_with_new_domain():
from ibvpy.api import \
TStepper as TS, RTraceGraph, RTraceDomainListField, TLoop, \
TLine, BCDof, IBVPSolve as IS, DOTSEval
from ibvpy.mats.mats1D.mats1D_elastic.mats1D_elastic import MATS1DElastic
from ibvpy.fets.fets1D.fets1D2l import FETS1D2L
fets_eval = FETS1D2L( mats_eval = MATS1DElastic( E = 10. ) )
from ibvpy.mesh.fe_grid import FEGrid
# Discretization
domain = FEGrid( coord_max = ( 2., 0., 0. ),
shape = ( 2, ),
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 = 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 = True,
adap = ChangeBC(),
tline = TLine( min = 0.0, step = 1., max = 2.0 ) )
print '---- result ----'
print tloop.eval()
def run():
fets_eval = FETS2D4Q( mats_eval = MATS2DElastic() )
# Discretization
fe_grid = FEGrid( coord_max = ( 10., 4., 0. ),
shape = ( 10, 3 ),
fets_eval = fets_eval )
bcg = BCDofGroup( var = 'u', value = 0., dims = [0],
get_dof_method = fe_grid.get_left_dofs )
bcg.setup( None )
print 'labels', bcg._get_labels()
print 'points', bcg._get_mvpoints()
mf = MFnLineArray( #xdata = arange(10),
ydata = array( [0, 1, 2, 3] ) )
right_dof = 2
tstepper = TS( sdomain = fe_grid,
bcond_list = [ BCDofGroup( var = 'u', value = 0., dims = [0, 1],
get_dof_method = fe_grid.get_left_dofs ),
BCDofGroup( var = 'u', value = .005, dims = [1],
time_function = mf.get_value,
get_dof_method = fe_grid.get_right_dofs ) ],
)
# Add the time-loop control
tloop = TLoop( tstepper = tstepper, KMAX = 300, tolerance = 1e-4,
tline = TLine( min = 0.0, step = 1.0, max = 1.0 ) )
U_k = tloop.eval()
print 'dir', tloop.rtrace_mngr.dir
# RTrace should not contain backward link to RTraceMngr
# The definition should be forward.
#
rt1 = RTraceGraph( sd = tstepper.sdomain,
rmgr = tstepper.rtrace_mngr,
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' )
print 'dir', rt1.dir
def example_2d():
from ibvpy.api import FEDomain, FERefinementGrid, FEGrid, TStepper as TS, \
BCDofGroup, RTraceDomainListField
from ibvpy.api import TLoop, TLine
from ibvpy.mesh.xfe_subdomain import XFESubDomain
from ibvpy.tmodel.mats2D.mats2D_elastic.mats2D_elastic import MATS2DElastic
from ibvpy.tmodel.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.old_dots.state_elem grid')
print(fe_xdomain.dots.state_start_elem_grid)
print('fe_tip_xdomain.old_dots.state_elem grid')
print(fe_tip_xdomain.dots.state_start_elem_grid)
print('fe_xdomain.old_dots.state_end_elem grid')
print(fe_xdomain.dots.state_end_elem_grid)
print('fe_tip_xdomain.old_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.old_dots.state_elem grid')
print(fe_xdomain.dots.state_start_elem_grid)
print('fe_tip_xdomain.old_dots.state_elem grid')
print(fe_tip_xdomain.dots.state_start_elem_grid)
print('fe_xdomain.old_dots.state_end_elem grid')
print(fe_xdomain.dots.state_end_elem_grid)
print('fe_tip_xdomain.old_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()
# RTraceDomainListField(name = 'Deformation' ,
# var = 'eps', idx = 0,
# record_on = 'update'),
RTraceDomainListField(name='Displacement',
var='u',
idx=0,
warp=True),
# RTraceDomainListField(name = 'Stress' ,
# var = 'sig', idx = 0,
# record_on = 'update'),
# RTraceDomainListField(name = 'N0' ,
# var = 'N_mtx', idx = 0,
# record_on = 'update')
])
# Add the time-loop control
tloop = TLoop(tstepper=ts,
KMAX=4,
RESETMAX=0,
tolerance=1e-3,
tline=TLine(min=0.0, step=1.0, max=1.0))
print 'u', 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()
fets_eval=fets_eval
)
ts = TS(sdomain=domain,
dof_resultants=True
)
tloop = TLoop(tstepper=ts,
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 = (10, 0, 0)
domain.shape = (10,)
ts.bcond_list = [BCDof(var='u', dof=0, value=0.),
BCDof(var='u', dof=10, value=1.)]
ts.rtrace_list = [RTDofGraph(name='Fi,right over u_right (iteration)',
var_y='F_int', idx_y=10,
var_x='U_k', idx_x=10)]
u = tloop.eval()
# expected solution
u_ex = array([0., 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.],
dtype=float)
difference = sqrt(norm(u - u_ex))
print('difference')
# compare the reaction at the left end
F = ts.F_int[0]
print(F)
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-')
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=[
RTDofGraph(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)
])
print(tloop.eval())
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 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()
# Add the time-loop control
tloop = TLoop( tstepper = ts,
tolerance = 1e-3,
tline = TLine( min = 0.0, step = 1., max = 1.0 ))
use_profiling = True
start_ui = True
calculate = True
if calculate:
if use_profiling:
import cProfile
cProfile.run('tloop.eval()', 'lost_formwork_tprof' )
import pstats
p = pstats.Stats('lost_formwork_tprof')
p.strip_dirs()
print 'cumulative'
p.sort_stats('cumulative').print_stats(50)
print 'time'
p.sort_stats('time').print_stats(50)
else:
tloop.eval()
if start_ui:
from ibvpy.plugins.ibvpy_app import IBVPyApp
app = IBVPyApp( ibv_resource = tloop )
app.main()
def example():
from ibvpy.api import \
TStepper as TS, RTDofGraph, RTraceDomainListField, TLoop, \
TLine, IBVPSolve as IS, DOTSEval, BCSlice
from ibvpy.mesh.fe_grid import FEGrid
from mathkit.mfn import MFnLineArray
stiffness_concrete = 34000 * 0.03 * 0.03
A_fiber = 1.
E_fiber = 1.
stiffness_fiber = E_fiber * A_fiber
d = 2 * sqrt(Pi)
tau_max = 0.1 * d * Pi
G = 100
u_max = 0.023
f_max = 0.2
mats_eval = MATS1D5Bond(mats_phase1=MATS1DElastic(E=stiffness_fiber),
mats_phase2=MATS1DElastic(E=0),
mats_ifslip=MATS1DPlastic(E=G,
sigma_y=tau_max,
K_bar=0.,
H_bar=0.),
mats_ifopen=MATS1DElastic(E=0))
fets_eval = FETS1D52L4ULRH(mats_eval=mats_eval)
domain = FEGrid(coord_max=(1., 0.2),
shape=(16, 1),
fets_eval=fets_eval)
end_dof = domain[-1, 0, -1, 0].dofs[0, 0, 0]
ts = TS(dof_resultants=True,
sdomain=domain,
# conversion to list (square brackets) is only necessary for slicing of
# single dofs, e.g "get_left_dofs()[0,1]"
bcond_list=[
BCSlice(var='u', value=0., dims=[0],
slice=domain[:, :, :, -1]),
BCSlice(var='u', value=0., dims=[1],
slice=domain[:, :, :, :]),
BCSlice(var='f', value=f_max, dims=[0],
slice=domain[-1, 0, -1, 0])
],
rtrace_list=[RTDofGraph(name='Fi,right over u_right (iteration)',
var_y='F_int', idx_y=end_dof,
var_x='U_k', idx_x=end_dof),
RTraceDomainListField(name='slip',
var='slip', idx=0),
RTraceDomainListField(name='eps1',
var='eps1', idx=0),
RTraceDomainListField(name='eps2',
var='eps2', idx=0),
RTraceDomainListField(name='shear_flow',
var='shear_flow', idx=0),
RTraceDomainListField(name='sig1',
var='sig1', idx=0),
RTraceDomainListField(name='sig2',
var='sig2', idx=0),
RTraceDomainListField(name='Displacement',
var='u', idx=0)
])
# Add the time-loop control
tloop = TLoop(tstepper=ts, KMAX=30, debug=False,
tline=TLine(min=0.0, step=0.1, max=1.0))
print(tloop.eval())
# Put the whole stuff into the simulation-framework to map the
# individual pieces of definition into the user interface.
#
from ibvpy.plugins.ibvpy_app import IBVPyApp
app = IBVPyApp(ibv_resource=tloop)
app.main()
def xtest_L_shaped():
'''Clamped bar 3 domains, each with 2 elems (displ at right end)
[0]-[1]-[2] [3]-[4]-[5] [6]-[7]-[8]
u[0] = 0, u[2] = u[3], u[5] = u[6], u[8] = 1'''
mp = MATS2DScalarDamage(
E=34.e3,
nu=0.2,
epsilon_0=59.e-6,
epsilon_f=3.2e-3,
#epsilon_f = 3.2e-1,
#stiffness = "algorithmic",
strain_norm_type='Mises')
# mp = MATS2DElastic( E = 34.e3,
# nu = 0.2 )
fets_eval = FETS2D4Q(mats_eval=mp)
discr = (10, 10)
# Discretization
fe_domain1 = FEGrid(coord_min=(0, 0, 0),
coord_max=(1., 1., 0.),
shape=discr,
n_nodal_dofs=fets_eval.n_nodal_dofs,
dof_r=fets_eval.dof_r,
geo_r=fets_eval.geo_r)
fe_domain2 = FEGrid(coord_min=(0., 1., 0),
coord_max=(1., 2., 0.),
shape=discr,
n_nodal_dofs=fets_eval.n_nodal_dofs,
dof_r=fets_eval.dof_r,
geo_r=fets_eval.geo_r)
fe_domain3 = FEGrid(coord_min=(1., 1., 0),
coord_max=(2., 2., 0.),
shape=discr,
n_nodal_dofs=fets_eval.n_nodal_dofs,
dof_r=fets_eval.dof_r,
geo_r=fets_eval.geo_r)
ts = TS(
iterms=[(fets_eval, fe_domain1), (fets_eval, fe_domain2),
(fets_eval, fe_domain3)],
dof_resultants=True,
bcond_list=[
BCDofGroup(var='u',
value=0.,
dims=[0, 1],
get_dof_method=fe_domain1.get_bottom_dofs),
BCDofGroup(var='u',
value=0.,
dims=[0, 1],
get_dof_method=fe_domain3.get_left_dofs,
get_link_dof_method=fe_domain2.get_right_dofs,
link_coeffs=[1.]),
BCDofGroup(var='u',
value=0.,
dims=[0, 1],
get_dof_method=fe_domain2.get_bottom_dofs,
get_link_dof_method=fe_domain1.get_top_dofs,
link_coeffs=[1.]),
BCDofGroup(var='u',
value=0.0004,
dims=[1],
get_dof_method=fe_domain3.get_right_dofs)
],
rtrace_list=[
RTraceDomainListField(name='Displacement', var='u', idx=1),
RTraceDomainListField(name='Damage',
var='omega',
idx=0,
record_on='update',
warp=True),
# RTraceDomainListField(name = 'Stress' ,
# var = 'sig_app', idx = 0,
# record_on = 'update',
# warp = False),
# RTraceDomainListField(name = 'Strain' ,
# var = 'eps_app', idx = 0,
# record_on = 'update',
# warp = False),
])
# Add the time-loop control
global tloop
tloop = TLoop(tstepper=ts,
tolerance=1e-4,
KMAX=50,
tline=TLine(min=0.0, step=0.2, max=1.0))
tloop.eval()
# import cProfile
# cProfile.run('tloop.eval()', 'tloop_prof' )
#
# import pstats
# p = pstats.Stats('tloop_prof')
# p.strip_dirs()
# print 'cumulative'
# p.sort_stats('cumulative').print_stats(20)
# print 'time'
# p.sort_stats('time').print_stats(20)
from ibvpy.plugins.ibvpy_app import IBVPyApp
app = IBVPyApp(ibv_resource=tloop)
app.main()
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()
# 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')
])
# Add the time-loop control
#
tloop = TLoop(tstepper=ts, tline=TLine(min=0.0, step=0.5, max=1.0))
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 run():
from ibvpy.api import \
TStepper as TS, RTraceGraph, RTraceDomainListField, TLoop, \
TLine, IBVPSolve as IS, DOTSEval, BCSlice, FEGrid, BCDofGroup
from ibvpy.fets.fets1D5.fets1D52l4uLRH import \
FETS1D52L4ULRH, MATS1DElastic, MATS1DPlastic, MATS1D5Bond
from ibvpy.fets.fets2D.fets2D4q import FETS2D4Q
from ibvpy.mats.mats2D.mats2D_elastic.mats2D_elastic import MATS2DElastic
from mathkit.mfn.mfn_line.mfn_line import \
MFnLineArray
from math import sqrt, pi as Pi
# Concrete parameters
E_concrete = 34000.0 # [MPa] E-Modulus of concrete
nu_concrete = 0.2 # [-] Poisson ratio
# Yarn parameters
A_epoxy = 1.760 # [mm^2] cross-sectional area of epoxy
A_glass = 0.896 # [mm^2] cross-sectional area of glass
A_yarn = A_epoxy + A_glass # [mm^2] cross-sectional area of yarn
P_yarn = sqrt( 4 * A_yarn * Pi ) # [mm] perimeter of the yarn
E_yarn = 17000.0 # [MPa] effective E-Modulus of the impregnated yarn
stiffness_fiber = E_yarn * A_yarn
penalty_stiffness = 1.e6
# Bond parameters
tau_max = 13.0 # [N/mm^2] - frictional shear stress
T_max = tau_max * P_yarn # [N/mm] - frictional shear flow
s_crit = 0.028 # [mm] - onset of inelastic slip
G = T_max / s_crit # [N/mm] - shear flow stiffness
# Geometry
L_e = 5. # [mm] - embedded length
# Loading conditions
u_max = 0.3
# f_max = 1200
# Discretization
fineness_x = 4
fineness_y = 4
# Material model construction
mats_eval_bond = MATS1D5Bond( mats_phase1 = MATS1DElastic( E = stiffness_fiber ),
mats_phase2 = MATS1DElastic( E = 0 ),
mats_ifslip = MATS1DElastic( E = G ),
mats_ifopen = MATS1DElastic( E = penalty_stiffness))
mats_eval_matrix = MATS2DElastic( E = E_concrete,
nu = nu_concrete,
stress_state="plane_strain")
# Finite element construction
fets_eval_bond = FETS1D52L4ULRH( mats_eval = mats_eval_bond )
fets_eval_matrix = FETS2D4Q( mats_eval = mats_eval_matrix )
# Discretization
domain_bond = FEGrid( coord_min = (0., -L_e/5.),
coord_max = (L_e, 0.),
shape = (fineness_x,1),
fets_eval = fets_eval_bond )
domain_matrix1 = FEGrid( coord_max = (L_e, L_e),
shape = (fineness_x,fineness_y),
fets_eval = fets_eval_matrix )
# domain_matrix2 = FEGrid( coord_min = (L_e, 0.),
# coord_max = (L_e*2, L_e),
# shape = (fineness_x,fineness_y),
# fets_eval = fets_eval_matrix )
end_dof = domain_bond[-1,0,-1,0 ].dofs[0,0,0]
ts = TS( dof_resultants = True,
sdomain = [ domain_bond, domain_matrix1],#, domain_matrix2 ],
bcond_list = [
# Fixed fiber at the left end
BCSlice( var='u', value = 0., dims = [0],
slice = domain_bond[0,0,0,0] ),
# Fixed y-displacement - no crack opening
BCSlice( var='u', value = 0., dims = [1],
slice = domain_bond[:,0,:,0] ),
# Loading at the right end of the fiber
BCSlice( var='u', value = u_max, dims = [0],
slice = domain_bond[-1,0,-1,0] ),
# Support the matrix in the horizontal direction
BCSlice( var='u', value = 0., dims = [0],
slice = domain_matrix1[0,:,0,:]),
# # Support the matrix in the vertical direction
# BCSlice( var='u', value = 0., dims = [1],
# slice = domain_matrix1[:,0,:,0]),
# # Connect bond and matrix domains
# BCSlice( var='u', value = 0., dims = [0,1],
# link_slice = domain_bond[:,-1,:,-1],
# slice = domain_matrix1[:,0,:,0],
# link_coeffs = [1.]),
BCDofGroup( var='u', value = 0., dims = [0,1],
get_link_dof_method = domain_bond.get_top_dofs,
get_dof_method = domain_matrix1.get_bottom_dofs,
link_coeffs = [1.] ),
# # Connect two matrix domains
# BCSlice( var='u', value = 0., dims = [0,1],
# slice = domain_matrix1[-1,:,-1,:],
# link_slice = domain_matrix2[0,:,0,:],
# link_coeffs = [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),
RTraceDomainListField(name = 'Stress' ,
var = 'sig_app', idx = 0)
] )
# Add the time-loop control
tloop = TLoop( tstepper = ts, KMAX = 30, debug = False,
tline = TLine( min = 0.0, step = 1.0, 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_with_new_domain():
from ibvpy.api import \
TStepper as TS, RTraceDomainListField, TLoop, \
TLine, BCSlice
from ibvpy.fets.fets2D.fets2D4q8u import FETS2D4Q8U
from ibvpy.mats.mats3D.mats3D_cmdm import \
MATS3DMicroplaneDamage
from ibvpy.mats.matsXD.matsXD_cmdm import PhiFnStrainSoftening
# mats = 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 test_bar4():
'''Clamped bar 3 domains, each with 2 elems (displ at right end)
[0]-[1]-[2] [3]-[4]-[5] [6]-[7]-[8]
u[0] = 0, u[2] = u[3], u[5] = u[6], u[8] = 1'''
fets_eval = FETS1D2L(mats_eval=MATS1DElastic(E=10., A=1.))
# Discretization
fe_domain1 = FEGrid(coord_max=(2., 0., 0.),
shape=(2, ),
n_nodal_dofs=1,
dof_r=fets_eval.dof_r,
geo_r=fets_eval.geo_r)
fe_domain2 = FEGrid(coord_min=(2., 0., 0.),
coord_max=(4., 0., 0.),
shape=(2, ),
n_nodal_dofs=1,
dof_r=fets_eval.dof_r,
geo_r=fets_eval.geo_r)
fe_domain3 = FEGrid(coord_min=(4., 0., 0.),
coord_max=(6., 0., 0.),
shape=(2, ),
n_nodal_dofs=1,
dof_r=fets_eval.dof_r,
geo_r=fets_eval.geo_r)
ts = TS(iterms=[(fets_eval, fe_domain1), (fets_eval, fe_domain2),
(fets_eval, fe_domain3)],
dof_resultants=True,
bcond_list=[
BCDof(var='u', dof=0, value=0.),
BCDof(var='u',
dof=2,
link_dofs=[3],
link_coeffs=[1.],
value=0.),
BCDof(var='u',
dof=5,
link_dofs=[6],
link_coeffs=[1.],
value=0.),
BCDof(var='u', dof=8, value=1)
],
rtrace_list=[
RTraceGraph(name='Fi,right over u_right (iteration)',
var_y='F_int',
idx_y=0,
var_x='U_k',
idx_x=1),
RTraceDomainListField(name='Displacement', var='u', idx=0)
])
# 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
app = IBVPyApp(ibv_resource=tloop)
app.main()
def run():
'''
Pull-Out test with epoxy-impregnated yarn. Publisched in
Konrad, M., Chudoba, R., Tensile Behavior of Cementitous Composite Reinforced
with Epoxy Impregnated Multifilament Yarns, Int. J. for Multiscale
Computational Engineering, 7(2)115-133(2009)
Parameters set in such a way that the Figure 18 gets reproduced.
At the moment no yarn damage assumed.
'''
from ibvpy.api import \
TStepper as TS, RTraceGraph, RTraceDomainListField, TLoop, \
TLine, IBVPSolve as IS, DOTSEval, BCSlice, FEGrid
from ibvpy.fets.fets1D5.fets1D52l4uLRH import \
FETS1D52L4ULRH, MATS1DElastic, MATS1DPlastic, MATS1D5Bond
from ibvpy.fets.fets1D5.fets1D52l6uLRH import FETS1D52L6ULRH
from ibvpy.fets.fets1D5.fets1D52l8uLRH import FETS1D52L8ULRH
from mathkit.mfn.mfn_line.mfn_line import \
MFnLineArray
from math import sqrt, pi as Pi
# Concrete parameters
A_concrete = 30. * 30. # [mm^2] cross-sectional area of concrete
E_concrete = 32000.0 # [MPa] E-Modulus of concrete
stiffness_concrete = E_concrete * A_concrete
# Yarn parameters
A_epoxy = 1.760 # [mm^2] cross-sectional area of epoxy
A_glass = 0.896 # [mm^2] cross-sectional area of glass
A_yarn = A_epoxy + A_glass # [mm^2] cross-sectional area of yarn
P_yarn = sqrt( 4 * A_yarn * Pi ) # [mm] perimeter of the yarn
E_yarn = 17000.0 # [MPa] effective E-Modulus of the impregnated yarn
stiffness_fiber = E_yarn * A_yarn
# Bond parameters
tau_max = 13.0 # [N/mm^2] - frictional shear stress
T_max = tau_max * P_yarn # [N/mm] - frictional shear flow
s_crit = 0.028 # [mm] - onset of inelastic slip
G = T_max / s_crit # [N/mm^2] - shear flow stiffness
# Geometry
L_e = 30. # [mm] - embedded length
# Loading conditions
u_max = 0.1
# f_max = 1200
# Material model construction
mats_eval = MATS1D5Bond( mats_phase1 = MATS1DElastic( E = stiffness_fiber ),
mats_phase2 = MATS1DElastic( E = stiffness_concrete ),
mats_ifslip = MATS1DPlastic(E = G,
sigma_y = T_max,
K_bar = 0.,
H_bar = 0. ),
mats_ifopen = MATS1DElastic( E = 0. ))
# Finite element construction
# fets_eval = FETS1D52L4ULRH( mats_eval = mats_eval ) # bilinear
# fets_eval = FETS1D52L6ULRH( mats_eval = mats_eval ) #quadratic
fets_eval = FETS1D52L6ULRH( mats_eval = mats_eval ) #cubic
# Dicretization
domain = FEGrid( coord_max = (L_e, L_e/5.),
#shape = (16,1), # for bilinear
#shape = (8,1), # for quadratic
shape = (4,1), # for cubic
fets_eval = fets_eval )
end_dof = domain[-1,0,-1,0 ].dofs[0,0,0]
ts = TS( dof_resultants = True,
sdomain = domain,
bcond_list = [
# Matrix is fixed along the whole embedded length
BCSlice( var='u', value = 0., dims = [0], slice = domain[0,0,0,-1] ),
# Fixed fiber at the left end
BCSlice( var='u', value = 0., dims = [0],
slice = domain[0,0,0,0] ),
# Fixed y-displacement - no crack opening
BCSlice( var='u', value = 0., dims = [1], slice = domain[:,:,:,:] ),
# Loading at the right end of the fiber
BCSlice( var='u', value = u_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' ),
RTraceDomainListField(name = 'eps1', var = 'eps1' ),
RTraceDomainListField(name = 'eps2', var = 'eps2' ),
RTraceDomainListField(name = 'shear_flow', var = 'shear_flow' ),
RTraceDomainListField(name = 'sig1', var = 'sig1' ),
RTraceDomainListField(name = 'sig2', var = 'sig2' ),
RTraceDomainListField(name = 'Displacement', var = 'u' )
] )
# 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_with_new_domain():
from ibvpy.api import \
TStepper as TS, RTraceDomainListField, TLoop, TLine
from ibvpy.tmodel.mats2D5.mats2D5_bond.mats2D_bond import MATS2D5Bond
from ibvpy.api import BCDofGroup
from ibvpy.fets.fets2D.fets2D4q import FETS2D4Q
fets_eval = FETS2DTF(parent_fets=FETS2D4Q(),
mats_eval=MATS2D5Bond(E_m=30, nu_m=0.2,
E_f=10, nu_f=0.1,
G=10.))
from ibvpy.mesh.fe_grid import FEGrid
from mathkit.mfn import MFnLineArray
# Discretization
fe_grid = FEGrid(coord_max=(10., 4., 0.),
n_elems=(10, 3),
fets_eval=fets_eval)
mf = MFnLineArray( # xdata = arange(10),
ydata=array([0, 1, 2, 3]))
tstepper = TS(sdomain=fe_grid,
bcond_list=[BCDofGroup(var='u', value=0., dims=[0, 1],
get_dof_method=fe_grid.get_left_dofs),
# BCDofGroup( var='u', value = 0., dims = [1],
# get_dof_method = fe_grid.get_bottom_dofs ),
BCDofGroup(var='u', value=.005, dims=[0],
time_function=mf.get_value,
get_dof_method=fe_grid.get_right_dofs)],
rtrace_list=[
# RTDofGraph(name = 'Fi,right over u_right (iteration)' ,
# var_y = 'F_int', idx_y = right_dof,
# var_x = 'U_k', idx_x = right_dof,
# record_on = 'update'),
# RTraceDomainListField(name = 'Stress' ,
# var = 'sig_app', idx = 0,
# #position = 'int_pnts',
# record_on = 'update'),
# RTraceDomainListField(name = 'Damage' ,
# var = 'omega', idx = 0,
# record_on = 'update',
# warp = True),
RTraceDomainListField(name='Displ matrix',
var='u_m', idx=0,
record_on='update',
warp=True),
RTraceDomainListField(name='Displ reinf',
var='u_f', idx=0,
record_on='update',
warp=True),
# RTraceDomainListField(name = 'N0' ,
# var = 'N_mtx', idx = 0,
# record_on = 'update')
]
)
# Add the time-loop control
#global tloop
tloop = TLoop(tstepper=tstepper, KMAX=300, tolerance=1e-4,
tline=TLine(min=0.0, step=1.0, max=1.0))
#import cProfile
#cProfile.run('tloop.eval()', 'tloop_prof' )
print(tloop.eval())
#import pstats
#p = pstats.Stats('tloop_prof')
# p.strip_dirs()
# print 'cumulative'
# p.sort_stats('cumulative').print_stats(20)
# print 'time'
# p.sort_stats('time').print_stats(20)
# Put the whole thing into the simulation-framework to map the
# individual pieces of definition into the user interface.
#
from ibvpy.plugins.ibvpy_app import IBVPyApp
app = IBVPyApp(ibv_resource=tloop)
app.main()
def 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 = 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 ] ),
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-5 ),
],
rtrace_list = [
RTraceGraph( 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 = 25,
tline = TLine( min = 0.0, step = .5, max = 200.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()
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)])
print tloop.eval()
def example_with_new_domain():
from ibvpy.api import \
TStepper as TS, RTraceGraph, RTraceDomainListField, \
RTraceDomainListInteg, TLoop, \
TLine, BCDof, IBVPSolve as IS, DOTSEval
from ibvpy.mats.mats2D.mats2D_elastic.mats2D_elastic import MATS2DElastic
from ibvpy.mats.mats2D.mats2D_sdamage.mats2D_sdamage import MATS2DScalarDamage
from ibvpy.api import BCDofGroup
mats_eval = MATS2DElastic()
fets_eval = FETS2D4Q(mats_eval=mats_eval)
#fets_eval = FETS2D4Q(mats_eval = MATS2DScalarDamage())
print fets_eval.vtk_node_cell_data
from ibvpy.mesh.fe_grid import FEGrid
from ibvpy.mesh.fe_refinement_grid import FERefinementGrid
from ibvpy.mesh.fe_domain import FEDomain
from mathkit.mfn import MFnLineArray
# Discretization
fe_grid = FEGrid(coord_max=(10., 4., 0.),
shape=(10, 3),
fets_eval=fets_eval)
bcg = BCDofGroup(var='u',
value=0.,
dims=[0],
get_dof_method=fe_grid.get_left_dofs)
bcg.setup(None)
print 'labels', bcg._get_labels()
print 'points', bcg._get_mvpoints()
mf = MFnLineArray( # xdata = arange(10),
ydata=array([0, 1, 2, 3]))
right_dof = 2
tstepper = TS(
sdomain=fe_grid,
bcond_list=[
BCDofGroup(var='u',
value=0.,
dims=[0, 1],
get_dof_method=fe_grid.get_left_dofs),
# BCDofGroup( var='u', value = 0., dims = [1],
# get_dof_method = fe_grid.get_bottom_dofs ),
BCDofGroup(var='u',
value=.005,
dims=[1],
time_function=mf.get_value,
get_dof_method=fe_grid.get_right_dofs)
],
rtrace_list=[
RTraceGraph(name='Fi,right over u_right (iteration)',
var_y='F_int',
idx_y=right_dof,
var_x='U_k',
idx_x=right_dof,
record_on='update'),
RTraceDomainListField(name='Stress',
var='sig_app',
idx=0,
position='int_pnts',
record_on='update'),
# RTraceDomainListField(name = 'Damage' ,
# var = 'omega', idx = 0,
#
# record_on = 'update',
# warp = True),
RTraceDomainListField(name='Displacement',
var='u',
idx=0,
record_on='update',
warp=True),
RTraceDomainListField(name='Strain energy',
var='strain_energy',
idx=0,
record_on='update',
warp=False),
RTraceDomainListInteg(name='Integ strain energy',
var='strain_energy',
idx=0,
record_on='update',
warp=False),
# RTraceDomainListField(name = 'N0' ,
# var = 'N_mtx', idx = 0,
# record_on = 'update')
])
# Add the time-loop control
#global tloop
tloop = TLoop(tstepper=tstepper,
KMAX=300,
tolerance=1e-4,
tline=TLine(min=0.0, step=1.0, max=1.0))
#import cProfile
#cProfile.run('tloop.eval()', 'tloop_prof' )
# print tloop.eval()
#import pstats
#p = pstats.Stats('tloop_prof')
# p.strip_dirs()
# print 'cumulative'
# p.sort_stats('cumulative').print_stats(20)
# print 'time'
# p.sort_stats('time').print_stats(20)
tloop.eval()
# Put the whole thing into the simulation-framework to map the
# individual pieces of definition into the user interface.
#
from ibvpy.plugins.ibvpy_app import IBVPyApp
app = IBVPyApp(ibv_resource=tloop)
app.main()
def 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=[
RTraceGraph(name='Fi,right over u_right (iteration)',
var_y='F_int',
idx_y=0,
var_x='U_k',
idx_x=1),
RTraceDomainListField(name='Stress',
var='sig_app',
idx=0,
warp=True),
# RTraceDomainField(name = 'Displacement' ,
# var = 'u', idx = 0),
# RTraceDomainField(name = 'N0' ,
# var = 'N_mtx', idx = 0,
# record_on = 'update')
])
# Add the time-loop control
tloop = TLoop(tstepper=ts, tline=TLine(min=0.0, step=1, max=1.0))
print tloop.eval()
from ibvpy.plugins.ibvpy_app import IBVPyApp
ibvpy_app = IBVPyApp(ibv_resource=tloop)
ibvpy_app.main()
dims=[1],
get_dof_method=domain.get_bottom_left_dofs),
BCDofGroup(var='u',
value=0.002,
dims=[0],
get_dof_method=domain.get_right_dofs)
],
rtrace_list=[
# RTDofGraph(name = 'Fi,right over u_right (iteration)' ,
# var_y = 'F_int', idx_y = right_dof,
# var_x = 'U_k', idx_x = right_dof),
# RTraceDomainField(name = 'Stress' ,
# var = 'sig_app', idx = 0,
# record_on = 'update'),
RTraceDomainListField(name='Displacement', var='u', idx=0),
# RTraceDomainField(name = 'N0' ,
# var = 'N_mtx', idx = 0,
# record_on = 'update')
])
# Add the time-loop control
tl = TLoop(tstepper=ts, tline=TLine(min=0.0, step=0.5, max=1.0))
tl.eval()
# Put the whole stuff into the simulation-framework to map the
# individual pieces of definition into the user interface.
#
from ibvpy.plugins.ibvpy_app import IBVPyApp
app = IBVPyApp(ibv_resource=tl)
app.main()
def peval( self ):
'''Evaluation procedure.
'''
#mv = MATS1DDamageView( model = mats_eval )
#mv.configure_traits()
self.mats_m.reset_state()
# Discretization
#
length = self.length
domain = FEGrid( coord_min = ( 0., length / 5. ),
coord_max = ( length, 0. ),
shape = ( self.shape, 1 ),
fets_eval = self.fets )
right_dofs = domain[-1, -1, -1, :].dofs[0, :, 0]
print 'concrete_dofs', id( domain ), domain[:, 0, :, 0].dofs
# Response tracers
self.stress_strain = RTraceGraph( name = 'Fi,right over u_right (iteration)' ,
var_y = 'F_int', idx_y = right_dofs[0],
var_x = 'U_k', idx_x = right_dofs[0] )
self.eps_m_field = RTraceDomainListField( name = 'eps_m' , position = 'int_pnts',
var = 'eps1', idx = 0,
warp = True )
self.eps_f_field = RTraceDomainListField( name = 'eps_f' , position = 'int_pnts',
var = 'eps2', idx = 0,
warp = True )
# Response tracers
self.sig_m_field = RTraceDomainListField( name = 'sig_m' , position = 'int_pnts',
var = 'mats_phase1_sig_app', idx = 0 )
self.sig_f_field = RTraceDomainListField( name = 'sig_f' , position = 'int_pnts',
var = 'mats_phase2_sig_app', idx = 0 )
self.omega_m_field = RTraceDomainListField( name = 'omega_m' , position = 'int_pnts',
var = 'mats_phase1_omega', idx = 0,
warp = True )
#
damage_onset_displ = self.mats_m.epsilon_0 * self.length
go_behind = 1.5
finish_displ = go_behind * damage_onset_displ
n_steps = 20
step_size = ( finish_displ - damage_onset_displ ) / n_steps
tmax = 1 + n_steps
def ls( t ):
if t <= 1:
return t
else:
return 1.0 + ( t - 1.0 ) / n_steps * ( go_behind - 1 )
ts = TSCrackLoc(
dof_resultants = True,
on_update = self.plot,
sdomain = domain,
bcond_list = [# define the left clamping
BCSlice( var = 'u', value = 0., dims = [0], slice = domain[ 0, 0, 0, :] ),
# loading at the right edge
BCSlice( var = 'f', value = 1, dims = [0], slice = domain[-1, -1, -1, 0],
time_function = ls ),
# BCSlice(var='u', value = finish_displ, dims = [0], slice = domain[-1,-1,-1, 0],
# time_function = ls ),
# fix horizontal displacement in the top layer
BCSlice( var = 'u', value = 0., dims = [0], slice = domain[:, -1, :, -1] ),
# fix the vertical displacement all over the domain
BCSlice( var = 'u', value = 0., dims = [1], slice = domain[ :, :, :, :] )
],
rtrace_list = [ self.stress_strain,
self.eps_m_field,
self.eps_f_field,
self.sig_m_field,
self.sig_f_field,
self.omega_m_field ]
)
# Add the time-loop control
tloop = TLoop( tstepper = ts, KMAX = 200, debug = True, tolerance = 1e-5,
tline = TLine( min = 0.0, step = 1.0, max = 1.0 ) )
print ts.rte_dict.keys()
U = tloop.eval()
self.plot()
return array( [ U[right_dofs[-1]] ], dtype = 'float_' )
