def define_regions(self):
regions = {
'Y': 'all',
'Y_m': self.region_selects.matrix,
'Y_c': self.region_selects.inclusion,
'Gamma_mc': ('r.Y_m *v r.Y_c', 'facet'),
}
regions.update(
define_box_regions(self.dim, self.bbox[0], self.bbox[1], 1e-5))
return regions
def define_regions(self):
regions = {
'Y' : ('all', {}),
'Y_m' : self.region_selects.matrix,
'Y_c' : self.region_selects.inclusion,
'Gamma_mc': ('r.Y_m *n r.Y_c', {'can_cells' : False}),
}
regions.update(define_box_regions(self.dim,
self.bbox[0], self.bbox[1], 1e-5))
return regions
def define_regions(self):
regions = {
'Y' : 'all',
'Y_m' : self.region_selects.matrix,
'Y_c' : self.region_selects.inclusion,
'Gamma_mc': ('r.Y_m *v r.Y_c', 'facet'),
}
regions.update(define_box_regions(self.dim,
self.bbox[0], self.bbox[1], 1e-5))
return regions
def define_regions( filename ):
"""Define various subdomain for a given mesh file. This function is called
below."""
regions = {}
dim = 2
regions['Y'] = ('all', {})
eog = 'elements of group %d'
if filename.find( 'osteonT1' ) >= 0:
mat_ids = [11, 39, 6, 8, 27, 28, 9, 2, 4, 14, 12, 17, 45, 28, 15]
regions['Ym'] = (' +e '.join( (eog % im) for im in mat_ids ), {})
wx = 0.865
wy = 0.499
regions['Yc'] = ('r.Y -e r.Ym', {})
# Sides and corners.
regions.update( define_box_regions( 2, (wx, wy) ) )
return dim, regions, mat_ids
def define_regions(filename):
"""Define various subdomain for a given mesh file. This function is called
below."""
regions = {}
dim = 2
regions['Y'] = ('all', {})
eog = 'elements of group %d'
if filename.find('osteonT1') >= 0:
mat_ids = [11, 39, 6, 8, 27, 28, 9, 2, 4, 14, 12, 17, 45, 28, 15]
regions['Ym'] = (' +e '.join((eog % im) for im in mat_ids), {})
wx = 0.865
wy = 0.499
regions['Yc'] = ('r.Y -e r.Ym', {})
# Sides and corners.
regions.update(define_box_regions(2, (wx, wy)))
return dim, regions, mat_ids
def define_regions(filename):
"""
Define various subdomains for a given mesh file.
"""
regions = {}
dim = 2
regions['Y'] = 'all'
eog = 'cells of group %d'
if filename.find('osteonT1') >= 0:
mat_ids = [11, 39, 6, 8, 27, 28, 9, 2, 4, 14, 12, 17, 45, 28, 15]
regions['Ym'] = ' +c '.join((eog % im) for im in mat_ids)
wx = 0.865
wy = 0.499
regions['Yc'] = 'r.Y -c r.Ym'
# Sides and corners.
regions.update(define_box_regions(2, (wx, wy)))
return dim, regions
def define_regions(filename):
"""
Define various subdomains for a given mesh file.
"""
regions = {}
dim = 2
regions['Y'] = 'all'
eog = 'cells of group %d'
if filename.find('osteonT1') >= 0:
mat_ids = [11, 39, 6, 8, 27, 28, 9, 2, 4, 14, 12, 17, 45, 28, 15]
regions['Ym'] = ' +c '.join((eog % im) for im in mat_ids)
wx = 0.865
wy = 0.499
regions['Yc'] = 'r.Y -c r.Ym'
# Sides and corners.
regions.update(define_box_regions(2, (wx, wy)))
return dim, regions
'linearization' : {
'kind' : 'adaptive',
'min_level' : 0, # Min. refinement level to achieve everywhere.
'max_level' : 5, # Max. refinement level.
'eps' : 1e-3, # Relative error tolerance.
},
}
materials = {
'coef' : ({'val' : 1.0},),
}
regions = {
'Omega' : 'all',
}
regions.update(define_box_regions(dim, bbox[0], bbox[1], 1e-5))
fields = {
'temperature' : ('real', 1, 'Omega', 5, 'H1', 'lobatto'),
# Compare with the Lagrange basis.
## 'temperature' : ('real', 1, 'Omega', 5, 'H1', 'lagrange'),
}
variables = {
't' : ('unknown field', 'temperature', 0),
's' : ('test field', 'temperature', 't'),
}
amplitude = 1.0
def ebc_sin(ts, coor, **kwargs):
x0 = 0.5 * (coor[:, 1].min() + coor[:, 1].max())
def define(grid0=100, filename_mesh=None):
eps0 = 0.01 / grid0
if filename_mesh is None:
filename_mesh = osp.join(data_dir, 'piezo_mesh_micro_dfc.vtk')
mesh = Mesh.from_file(filename_mesh)
n_conduct = len(nm.unique(mesh.cmesh.cell_groups)) - 2
sym_eye = 'nm.array([1,1,0])' if mesh.dim == 2 else\
'nm.array([1,1,1,0,0,0])'
bbox = mesh.get_bounding_box()
regions = define_box_regions(mesh.dim, bbox[0], bbox[1], eps=1e-3)
regions.update({
'Y': 'all',
# matrix
'Ym': 'cells of group 1',
'Ym_left': ('r.Ym *v r.Left', 'vertex'),
'Ym_right': ('r.Ym *v r.Right', 'vertex'),
'Ym_bottom': ('r.Ym *v r.Bottom', 'vertex'),
'Ym_top': ('r.Ym *v r.Top', 'vertex'),
'Ym_far': ('r.Ym *v r.Far', 'vertex'),
'Ym_near': ('r.Ym *v r.Near', 'vertex'),
'Gamma_mc': ('r.Ym *v r.Yc', 'facet', 'Ym'),
# channel / inclusion
'Yc': 'cells of group 2',
'Yc0': ('r.Yc -v r.Gamma_cm', 'vertex'),
'Gamma_cm': ('r.Ym *v r.Yc', 'facet', 'Yc'),
})
print('number of cnonductors: %d' % n_conduct)
regions.update({
'Yms': ('r.Ym +v r.Ys', 'cell'),
'Yms_left': ('r.Yms *v r.Left', 'vertex'),
'Yms_right': ('r.Yms *v r.Right', 'vertex'),
'Yms_bottom': ('r.Yms *v r.Bottom', 'vertex'),
'Yms_top': ('r.Yms *v r.Top', 'vertex'),
'Yms_far': ('r.Yms *v r.Far', 'vertex'),
'Yms_near': ('r.Yms *v r.Near', 'vertex'),
'Gamma_ms': ('r.Ym *v r.Ys', 'facet', 'Ym'),
'Gamma_msc': ('r.Yms *v r.Yc', 'facet', 'Yms'),
'Ys': (' +v '.join(['r.Ys%d' % k for k in range(n_conduct)]), 'cell'),
})
options = {
'coefs_filename': 'coefs_poropiezo_%d' % (grid0),
'volume': {
'variables': ['svar'],
'expression': 'd_volume.i2.Y(svar)',
},
'coefs': 'coefs',
'requirements': 'requirements',
'output_dir': osp.join(data_dir, 'results'),
'ls': 'ls',
'file_per_var': True,
'absolute_mesh_path': True,
'multiprocessing': False,
'recovery_hook': recovery_micro_dfc,
}
fields = {
'displacement': ('real', 'vector', 'Yms', 1),
'potential': ('real', 'scalar', 'Ym', 1),
'sfield': ('real', 'scalar', 'Y', 1),
}
variables = {
# displacement
'u': ('unknown field', 'displacement'),
'v': ('test field', 'displacement', 'u'),
'Pi_u': ('parameter field', 'displacement', 'u'),
'U1': ('parameter field', 'displacement', '(set-to-None)'),
'U2': ('parameter field', 'displacement', '(set-to-None)'),
# potential
'r': ('unknown field', 'potential'),
's': ('test field', 'potential', 'r'),
'Pi_r': ('parameter field', 'potential', 'r'),
'R1': ('parameter field', 'potential', '(set-to-None)'),
'R2': ('parameter field', 'potential', '(set-to-None)'),
# aux variable
'svar': ('parameter field', 'sfield', '(set-to-None)'),
}
epbcs, periodic = get_periodic_bc([('u', 'Yms'), ('r', 'Ym')])
mat_g_sc, mat_d_sc = eps0, eps0**2
# BaTiO3 - Miara, Rohan, ... doi: 10.1016/j.jmps.2005.05.006
materials = {
'matrix': ({
'D': {
'Ym':
nm.array([[1.504, 0.656, 0.659, 0, 0, 0],
[0.656, 1.504, 0.659, 0, 0, 0],
[0.659, 0.659, 1.455, 0, 0, 0],
[0, 0, 0, 0.424, 0, 0], [0, 0, 0, 0, 0.439, 0],
[0, 0, 0, 0, 0, 0.439]]) * 1e11,
}
}, ),
'piezo': ({
'g':
nm.array([[0, 0, 0, 0, 11.404, 0], [0, 0, 0, 0, 0, 11.404],
[-4.322, -4.322, 17.360, 0, 0, 0]]) / mat_g_sc,
'd':
nm.array([[1.284, 0, 0], [0, 1.284, 0], [0, 0, 1.505]]) * 1e-8 /
mat_d_sc,
}, ),
'fluid': ({
'gamma': 1.0 / 2.15e9
}, ),
}
functions = {
'match_x_plane': (per.match_x_plane, ),
'match_y_plane': (per.match_y_plane, ),
'match_z_plane': (per.match_z_plane, ),
}
ebcs = {
'fixed_u': ('Corners', {
'u.all': 0.0
}),
'fixed_r': ('Gamma_ms', {
'r.all': 0.0
}),
}
integrals = {
'i2': 2,
'i5': 5,
}
solvers = {
'ls': ('ls.scipy_direct', {}),
'ns_em6': ('nls.newton', {
'i_max': 1,
'eps_a': 1e-6,
'eps_r': 1e-6,
'problem': 'nonlinear'
}),
'ns_em3': ('nls.newton', {
'i_max': 1,
'eps_a': 1e-3,
'eps_r': 1e-6,
'problem': 'nonlinear'
}),
}
coefs = {
# homogenized elasticity, see eq. (46)_1
'A': {
'requires': ['c.A1', 'c.A2'],
'expression': 'c.A1 + c.A2',
'class': cb.CoefEval,
},
'A1': {
'status':
'auxiliary',
'requires': ['pis_u', 'corrs_rs'],
'expression':
'dw_lin_elastic.i2.Yms(matrix.D, U1, U2)',
'set_variables': [('U1', ('corrs_rs', 'pis_u'), 'u'),
('U2', ('corrs_rs', 'pis_u'), 'u')],
'class':
cb.CoefSymSym,
},
'A2': {
'status': 'auxiliary',
'requires': ['corrs_rs'],
'expression': 'dw_diffusion.i2.Ym(piezo.d, R1, R2)',
'set_variables': [('R1', 'corrs_rs', 'r'),
('R2', 'corrs_rs', 'r')],
'class': cb.CoefSymSym,
},
# homogenized Biot coefficient, see eq. (46)_2
'B': {
'requires': ['c.Phi', 'c.B1', 'c.B2'],
'expression': 'c.B1 - c.B2 + c.Phi * %s' % sym_eye,
'class': cb.CoefEval,
},
'B1': {
'status': 'auxiliary',
'requires': ['pis_u', 'corrs_p'],
'expression': 'dw_lin_elastic.i2.Yms(matrix.D, U1, U2)',
'set_variables': [('U1', 'corrs_p', 'u'), ('U2', 'pis_u', 'u')],
'class': cb.CoefSym,
},
'B2': {
'status': 'auxiliary',
'requires': ['pis_u', 'corrs_p'],
'expression': 'dw_piezo_coupling.i2.Ym(piezo.g, U1, R1)',
'set_variables': [('R1', 'corrs_p', 'r'), ('U1', 'pis_u', 'u')],
'class': cb.CoefSym,
},
# homogenized compressibility coefficient, see eq. (46)_6
'M': {
'requires': ['c.Phi', 'c.N'],
'expression': 'c.N + c.Phi * %e' % materials['fluid'][0]['gamma'],
'class': cb.CoefEval,
},
'N': {
'status': 'auxiliary',
'requires': ['corrs_p'],
'expression': 'dw_surface_ltr.i2.Gamma_msc(U1)',
'set_variables': [('U1', 'corrs_p', 'u')],
'class': cb.CoefOne,
},
'Phi': {
'requires': ['c.vol'],
'expression': 'c.vol["fraction_Yc"]',
'class': cb.CoefEval,
},
# volume fractions of Ym, Yc, Ys1, Ys2, ...
'vol': {
'regions': ['Ym', 'Yc'] + ['Ys%d' % k for k in range(n_conduct)],
'expression': 'd_volume.i2.%s(svar)',
'class': cb.VolumeFractions,
},
'eps0': {
'requires': [],
'expression': '%e' % eps0,
'class': cb.CoefEval,
},
'filenames': {},
}
requirements = {
'pis_u': {
'variables': ['u'],
'class': cb.ShapeDimDim,
},
'pis_r': {
'variables': ['r'],
'class': cb.ShapeDim,
},
# local subproblem defined by eq. (41)
'corrs_rs': {
'requires': ['pis_u'],
'ebcs': ['fixed_u', 'fixed_r'],
'epbcs': periodic['per_u'] + periodic['per_r'],
'is_linear': True,
'equations': {
'eq1':
"""dw_lin_elastic.i2.Yms(matrix.D, v, u)
- dw_piezo_coupling.i2.Ym(piezo.g, v, r)
= - dw_lin_elastic.i2.Yms(matrix.D, v, Pi_u)""",
'eq2':
"""
- dw_piezo_coupling.i2.Ym(piezo.g, u, s)
- dw_diffusion.i2.Ym(piezo.d, s, r)
= dw_piezo_coupling.i2.Ym(piezo.g, Pi_u, s)""",
},
'set_variables': [('Pi_u', 'pis_u', 'u')],
'class': cb.CorrDimDim,
'save_name': 'corrs_rs_%d' % grid0,
'dump_variables': ['u', 'r'],
'solvers': {
'ls': 'ls',
'nls': 'ns_em3'
},
},
# local subproblem defined by eq. (42)
'corrs_p': {
'requires': [],
'ebcs': ['fixed_u', 'fixed_r'],
'epbcs': periodic['per_u'] + periodic['per_r'],
'is_linear': True,
'equations': {
'eq1':
"""dw_lin_elastic.i2.Yms(matrix.D, v, u)
- dw_piezo_coupling.i2.Ym(piezo.g, v, r)
= dw_surface_ltr.i2.Gamma_msc(v)""",
'eq2':
"""
- dw_piezo_coupling.i2.Ym(piezo.g, u, s)
- dw_diffusion.i2.Ym(piezo.d, s, r)
= 0"""
},
'class': cb.CorrOne,
'save_name': 'corrs_p_%d' % grid0,
'dump_variables': ['u', 'r'],
'solvers': {
'ls': 'ls',
'nls': 'ns_em6'
},
},
# local subproblem defined by eq. (43)
'corrs_rho': {
'requires': [],
'ebcs': ['fixed_u', 'fixed_r'],
'epbcs': periodic['per_u'] + periodic['per_r'],
'is_linear': True,
'equations': {
'eq1':
"""dw_lin_elastic.i2.Yms(matrix.D, v, u)
- dw_piezo_coupling.i2.Ym(piezo.g, v, r)
= 0""",
'eq2':
"""
- dw_piezo_coupling.i2.Ym(piezo.g, u, s)
- dw_diffusion.i2.Ym(piezo.d, s, r)
=
- dw_surface_integrate.i2.Gamma_mc(s)"""
},
'class': cb.CorrOne,
'save_name': 'corrs_p_%d' % grid0,
'dump_variables': ['u', 'r'],
'solvers': {
'ls': 'ls',
'nls': 'ns_em6'
},
},
}
for k in range(n_conduct):
sk = '%d' % k
regions.update({
'Ys' + sk: 'cells of group %d' % (3 + k),
'Gamma_s' + sk: ('r.Ym *v r.Ys' + sk, 'facet', 'Ym'),
})
materials['matrix'][0]['D'].update({
'Ys' + sk:
stiffness_from_youngpoisson(3, 200e9, 0.25),
})
ebcs.update({
'fixed_r1_k_' + sk: ('Gamma_s' + sk, {
'r.0': 1.0
}),
'fixed_r0_k_' + sk: ('Gamma_s' + sk, {
'r.0': 0.0
}),
})
fixed_r0_k = [
'fixed_r0_k_%d' % ii for ii in range(n_conduct) if not ii == k
]
# local subproblems defined for conductors, see eq. (44)
requirements.update({
'corrs_k' + sk: {
'requires': ['pis_r'],
'ebcs': ['fixed_u', 'fixed_r1_k_' + sk] + fixed_r0_k,
'epbcs': periodic['per_u'] + periodic['per_r'],
'is_linear': True,
'equations': {
'eq1':
"""dw_lin_elastic.i2.Yms(matrix.D, v, u)
- dw_piezo_coupling.i2.Ym(piezo.g, v, r)
= 0""",
'eq2':
"""
- dw_piezo_coupling.i2.Ym(piezo.g, u, s)
- dw_diffusion.i2.Ym(piezo.d, s, r)
= 0"""
},
'class': cb.CorrOne,
'save_name': 'corrs_k' + sk + '_%d' % grid0,
'dump_variables': ['u', 'r'],
'solvers': {
'ls': 'ls',
'nls': 'ns_em6'
},
},
})
coefs.update({
# homogenized coefficient (46)_3
'H' + sk: {
'requires': ['c.H1_' + sk, 'c.H2_' + sk],
'expression': 'c.H1_%s - c.H2_%s' % (sk, sk),
'class': cb.CoefEval,
},
'H1_' + sk: {
'status':
'auxiliary',
'requires': ['pis_u', 'corrs_k' + sk],
'expression':
'dw_lin_elastic.i2.Yms(matrix.D, U1, U2)',
'set_variables': [('U1', 'corrs_k' + sk, 'u'),
('U2', 'pis_u', 'u')],
'class':
cb.CoefSym,
},
'H2_' + sk: {
'status':
'auxiliary',
'requires': ['pis_u', 'corrs_k' + sk],
'expression':
'dw_piezo_coupling.i2.Ym(piezo.g, U1, R1)',
'set_variables': [('R1', 'corrs_k' + sk, 'r'),
('U1', 'pis_u', 'u')],
'class':
cb.CoefSym,
},
# homogenized coefficient (46)_7
'Z' + sk: {
'requires': ['corrs_k' + sk],
'expression': 'dw_surface_ltr.i2.Gamma_msc(U1)',
'set_variables': [('U1', 'corrs_k' + sk, 'u')],
'class': cb.CoefOne,
},
})
return locals()
variables = {
'u': ('unknown field', 'displacement'),
'v': ('test field', 'displacement', 'u'),
'Pi': ('parameter field', 'displacement', 'u'),
'Pi1u': ('parameter field', 'displacement', '(set-to-None)'),
'Pi2u': ('parameter field', 'displacement', '(set-to-None)'),
}
regions = {
'Y': 'all',
'Ym': 'cells of group 1',
'Yc': 'cells of group 2',
}
regions.update(define_box_regions(dim, (0., 0.), (1., 1.)))
ebcs = {
'fixed_u': ('Corners', {'u.all': 0.0}),
}
epbcs = {
'periodic_ux': (['Left', 'Right'], {'u.all': 'u.all'}, 'match_x_plane'),
'periodic_uy': (['Bottom', 'Top'], {'u.all': 'u.all'}, 'match_y_plane'),
}
coefs = {
'A': {
'requires': ['pis', 'corrs_rs'],
'expression': 'dw_nonsym_elastic.3.Y(mat_he.A, Pi1u, Pi2u)',
'set_variables': [('Pi1u', ('pis', 'corrs_rs'), 'u'),
def define(filename_mesh, pars, approx_order, refinement_level, solver_conf,
plane='strain', post_process=False, mesh_eps=1e-8):
io = MeshIO.any_from_filename(filename_mesh)
bbox = io.read_bounding_box()
dim = bbox.shape[1]
options = {
'absolute_mesh_path' : True,
'refinement_level' : refinement_level,
'allow_empty_regions' : True,
'post_process_hook' : 'compute_von_mises' if post_process else None,
}
fields = {
'displacement': ('complex', dim, 'Omega', approx_order),
}
young1, poisson1, density1, young2, poisson2, density2 = pars
materials = {
'm' : ({
'D' : {'Y1' : stiffness(dim, young=young1, poisson=poisson1,
plane=plane),
'Y2' : stiffness(dim, young=young2, poisson=poisson2,
plane=plane)},
'density' : {'Y1' : density1, 'Y2' : density2},
},),
'wave' : 'get_wdir',
}
variables = {
'u' : ('unknown field', 'displacement', 0),
'v' : ('test field', 'displacement', 'u'),
}
regions = {
'Omega' : 'all',
'Y1': 'cells of group 1',
'Y2': 'cells of group 2',
}
regions.update(define_box_regions(dim,
bbox[0], bbox[1], mesh_eps))
ebcs = {
}
if dim == 3:
epbcs = {
'periodic_x' : (['Left', 'Right'], {'u.all' : 'u.all'},
'match_x_plane'),
'periodic_y' : (['Near', 'Far'], {'u.all' : 'u.all'},
'match_y_plane'),
'periodic_z' : (['Top', 'Bottom'], {'u.all' : 'u.all'},
'match_z_plane'),
}
else:
epbcs = {
'periodic_x' : (['Left', 'Right'], {'u.all' : 'u.all'},
'match_y_line'),
'periodic_y' : (['Bottom', 'Top'], {'u.all' : 'u.all'},
'match_x_line'),
}
per.set_accuracy(mesh_eps)
functions = {
'match_x_plane' : (per.match_x_plane,),
'match_y_plane' : (per.match_y_plane,),
'match_z_plane' : (per.match_z_plane,),
'match_x_line' : (per.match_x_line,),
'match_y_line' : (per.match_y_line,),
'get_wdir' : (get_wdir,),
}
integrals = {
'i' : 2 * approx_order,
}
equations = {
'K' : 'dw_lin_elastic.i.Omega(m.D, v, u)',
'S' : 'dw_elastic_wave.i.Omega(m.D, wave.vec, v, u)',
'R' : """1j * dw_elastic_wave_cauchy.i.Omega(m.D, wave.vec, u, v)
- 1j * dw_elastic_wave_cauchy.i.Omega(m.D, wave.vec, v, u)""",
'M' : 'dw_volume_dot.i.Omega(m.density, v, u)',
}
solver_0 = solver_conf.copy()
solver_0['name'] = 'eig'
return locals()
dofs=None)
return out
dim = 3
filename_mesh = data_dir + '/meshes/3d/matrix_fiber.mesh'
region_lbn = (0, 0, 0)
region_rtf = (1, 1, 1)
regions = {
'Y': 'all',
'Ym': 'cells of group 1',
'Yc': 'cells of group 2',
}
regions.update(define_box_regions(dim, region_lbn, region_rtf))
materials = {
'mat': ({'D': {'Ym': stiffness_from_youngpoisson_mixed(dim, 7.0e9, 0.4),
'Yc': stiffness_from_youngpoisson_mixed(dim, 70.0e9, 0.2)},
'gamma': {'Ym': 1.0/bulk_from_youngpoisson(7.0e9, 0.4),
'Yc': 1.0/bulk_from_youngpoisson(70.0e9, 0.2)}},),
}
fields = {
'corrector_u': ('real', dim, 'Y', 1),
'corrector_p': ('real', 1, 'Y', 0),
}
variables = {
'u': ('unknown field', 'corrector_u'),
def define(order=5, basis='lagrange', min_level=0, max_level=5, eps=1e-3):
filename_mesh = UserMeshIO(mesh_hook)
# Get the mesh bounding box.
io = MeshIO.any_from_filename(base_mesh)
bbox, dim = io.read_bounding_box(ret_dim=True)
options = {
'nls': 'newton',
'ls': 'ls',
'post_process_hook': 'post_process',
'linearization': {
'kind': 'adaptive',
'min_level':
min_level, # Min. refinement level applied everywhere.
'max_level': max_level, # Max. refinement level.
'eps': eps, # Relative error tolerance.
},
}
materials = {
'coef': ({
'val': 1.0
}, ),
}
regions = {
'Omega': 'all',
}
regions.update(define_box_regions(dim, bbox[0], bbox[1], 1e-5))
fields = {
'temperature': ('real', 1, 'Omega', order, 'H1', basis),
}
variables = {
't': ('unknown field', 'temperature', 0),
's': ('test field', 'temperature', 't'),
}
amplitude = 1.0
def ebc_sin(ts, coor, **kwargs):
x0 = 0.5 * (coor[:, 1].min() + coor[:, 1].max())
val = amplitude * nm.sin((coor[:, 1] - x0) * 2. * nm.pi)
return val
ebcs = {
't1': ('Left', {
't.0': 'ebc_sin'
}),
't2': ('Right', {
't.0': -0.5
}),
't3': ('Top', {
't.0': 1.0
}),
}
functions = {
'ebc_sin': (ebc_sin, ),
}
equations = {'Temperature': """dw_laplace.10.Omega(coef.val, s, t) = 0"""}
solvers = {
'ls': ('ls.scipy_direct', {}),
'newton': ('nls.newton', {
'i_max': 1,
'eps_a': 1e-10,
}),
}
return locals()
def define(dims=(3, 1, 0.5),
shape=(11, 15, 15),
u_order=1,
refine=0,
ls='ls_d',
u_inlet=None,
mode='lcbc',
term_mode='original',
backend='numpy',
optimize='optimal',
verbosity=0):
"""
Parameters
----------
dims : tuple
The block domain dimensions.
shape : tuple
The mesh resolution: increase to improve accuracy.
u_order : int
The velocity field approximation order.
refine : int
The refinement level.
ls : 'ls_d' or 'ls_i'
The pre-configured linear solver name.
u_inlet : float, optional
The x-component of the inlet velocity.
mode : 'lcbc' or 'penalty'
The alternative formulations.
term_mode : 'original' or 'einsum'
The switch to use either the original or new experimental einsum-based
terms.
backend : str
The einsum mode backend.
optimize : str
The einsum mode optimization (backend dependent).
verbosity : 0, 1, 2, 3
The verbosity level of einsum-based terms.
"""
output('dims: {}, shape: {}, u_order: {}, refine: {}, u_inlet: {}'.format(
dims, shape, u_order, refine, u_inlet))
output('linear solver: {}'.format(ls))
output('mode: {}, term_mode: {}'.format(mode, term_mode))
if term_mode == 'einsum':
output('backend: {}, optimize: {}, verbosity: {}'.format(
backend, optimize, verbosity))
assert_(mode in {'lcbc', 'penalty'})
assert_(term_mode in {'original', 'einsum'})
if u_order > 1:
assert_(mode == 'penalty', msg='set mode=penalty to use u_order > 1!')
dims = nm.array(dims, dtype=nm.float64)
shape = nm.array(shape, dtype=nm.int32)
def mesh_hook(mesh, mode):
"""
Generate the block mesh.
"""
if mode == 'read':
mesh = gen_block_mesh(dims,
shape, [0, 0, 0],
name='user_block',
verbose=False)
return mesh
elif mode == 'write':
pass
filename_mesh = UserMeshIO(mesh_hook)
regions = define_box_regions(3, 0.5 * dims)
regions.update({
'Omega':
'all',
'Edges_v': ("""(r.Near *v r.Bottom) +v
(r.Bottom *v r.Far) +v
(r.Far *v r.Top) +v
(r.Top *v r.Near)""", 'edge'),
'Gamma1_f': ('copy r.Top', 'face'),
'Gamma2_f': ('r.Near +v r.Bottom +v r.Far', 'face'),
'Gamma_f': ('r.Gamma1_f +v r.Gamma2_f', 'face'),
'Gamma_v': ('r.Gamma_f -v r.Edges_v', 'face'),
'Inlet_f': ('r.Left -v r.Gamma_f', 'face'),
})
fields = {
'velocity': ('real', 3, 'Omega', u_order),
'pressure': ('real', 1, 'Omega', 1),
}
def get_u_d(ts, coors, region=None):
"""
Given stator velocity.
"""
out = nm.zeros_like(coors)
out[:] = [1.0, 1.0, 0.0]
return out
functions = {
'get_u_d': (get_u_d, ),
}
variables = {
'u': ('unknown field', 'velocity', 0),
'v': ('test field', 'velocity', 'u'),
'u_d': ('parameter field', 'velocity', {
'setter': 'get_u_d'
}),
'p': ('unknown field', 'pressure', 1),
'q': ('test field', 'pressure', 'p'),
}
materials = {
'm': ({
'nu': 1e-3,
'beta': 1e-2,
'mu': 1e-10,
}, ),
}
ebcs = {}
if u_inlet is not None:
ebcs['inlet'] = ('Inlet_f', {'u.0': u_inlet, 'u.[1, 2]': 0.0})
if mode == 'lcbc':
lcbcs = {
'walls': ('Gamma_v', {
'u.all': None
}, None, 'no_penetration', 'normals_Gamma.vtk'),
'edges': ('Edges_v', [(-0.5, 1.5)], {
'u.all': None
}, None, 'edge_direction', 'edges_Edges.vtk'),
}
if term_mode == 'original':
equations = {
'balance':
"""dw_div_grad.5.Omega(m.nu, v, u)
- dw_stokes.5.Omega(v, p)
+ dw_dot.5.Gamma1_f(m.beta, v, u)
+ dw_dot.5.Gamma2_f(m.beta, v, u)
=
+ dw_dot.5.Gamma1_f(m.beta, v, u_d)""",
'incompressibility':
"""dw_laplace.5.Omega(m.mu, q, p)
+ dw_stokes.5.Omega(u, q) = 0""",
}
else:
equations = {
'balance':
"""de_div_grad.5.Omega(m.nu, v, u)
- de_stokes.5.Omega(v, p)
+ de_dot.5.Gamma1_f(m.beta, v, u)
+ de_dot.5.Gamma2_f(m.beta, v, u)
=
+ de_dot.5.Gamma1_f(m.beta, v, u_d)""",
'incompressibility':
"""de_laplace.5.Omega(m.mu, q, p)
+ de_stokes.5.Omega(u, q) = 0""",
}
else:
materials['m'][0]['np_eps'] = 1e3
if term_mode == 'original':
equations = {
'balance':
"""dw_div_grad.5.Omega(m.nu, v, u)
- dw_stokes.5.Omega(v, p)
+ dw_dot.5.Gamma1_f(m.beta, v, u)
+ dw_dot.5.Gamma2_f(m.beta, v, u)
+ dw_non_penetration_p.5.Gamma1_f(m.np_eps, v, u)
+ dw_non_penetration_p.5.Gamma2_f(m.np_eps, v, u)
=
+ dw_dot.5.Gamma1_f(m.beta, v, u_d)""",
'incompressibility':
"""dw_laplace.5.Omega(m.mu, q, p)
+ dw_stokes.5.Omega(u, q) = 0""",
}
else:
equations = {
'balance':
"""de_div_grad.5.Omega(m.nu, v, u)
- de_stokes.5.Omega(v, p)
+ de_dot.5.Gamma1_f(m.beta, v, u)
+ de_dot.5.Gamma2_f(m.beta, v, u)
+ de_non_penetration_p.5.Gamma1_f(m.np_eps, v, u)
+ de_non_penetration_p.5.Gamma2_f(m.np_eps, v, u)
=
+ de_dot.5.Gamma1_f(m.beta, v, u_d)""",
'incompressibility':
"""de_laplace.5.Omega(m.mu, q, p)
+ de_stokes.5.Omega(u, q) = 0""",
}
solvers = {
'ls_d': ('ls.auto_direct', {}),
'ls_i': (
'ls.petsc',
{
'method': 'bcgsl', # ksp_type
'precond': 'bjacobi', # pc_type
'sub_precond': 'ilu', # sub_pc_type
'eps_a': 0.0, # abstol
'eps_r': 1e-12, # rtol
'eps_d': 1e10, # Divergence tolerance.
'i_max': 200, # maxits
}),
'newton': ('nls.newton', {
'i_max': 1,
'eps_a': 1e-10,
}),
}
options = {
'nls': 'newton',
'ls': ls,
'eterm': {
'verbosity': verbosity,
'backend_args': {
'backend': backend,
'optimize': optimize,
'layout': None,
},
},
'refinement_level': refine,
}
return locals()
def main(cli_args):
dims = parse_argument_list(cli_args.dims, float)
shape = parse_argument_list(cli_args.shape, int)
centre = parse_argument_list(cli_args.centre, float)
material_parameters = parse_argument_list(cli_args.material_parameters,
float)
order = cli_args.order
ts_vals = cli_args.ts.split(',')
ts = {
't0': float(ts_vals[0]),
't1': float(ts_vals[1]),
'n_step': int(ts_vals[2])
}
do_plot = cli_args.plot
### Mesh and regions ###
mesh = gen_block_mesh(dims, shape, centre, name='block', verbose=False)
domain = FEDomain('domain', mesh)
omega = domain.create_region('Omega', 'all')
lbn, rtf = domain.get_mesh_bounding_box()
box_regions = define_box_regions(3, lbn, rtf)
regions = dict(
[[r, domain.create_region(r, box_regions[r][0], box_regions[r][1])]
for r in box_regions])
### Fields ###
scalar_field = Field.from_args('fu',
np.float64,
'scalar',
omega,
approx_order=order - 1)
vector_field = Field.from_args('fv',
np.float64,
'vector',
omega,
approx_order=order)
u = FieldVariable('u', 'unknown', vector_field, history=1)
v = FieldVariable('v', 'test', vector_field, primary_var_name='u')
p = FieldVariable('p', 'unknown', scalar_field, history=1)
q = FieldVariable('q', 'test', scalar_field, primary_var_name='p')
### Material ###
c10, c01 = material_parameters
m = Material(
'm',
mu=2 * c10,
kappa=2 * c01,
)
### Boundary conditions ###
x_sym = EssentialBC('x_sym', regions['Left'], {'u.0': 0.0})
y_sym = EssentialBC('y_sym', regions['Near'], {'u.1': 0.0})
z_sym = EssentialBC('z_sym', regions['Bottom'], {'u.2': 0.0})
disp_fun = Function('disp_fun', get_displacement)
displacement = EssentialBC('displacement', regions['Right'],
{'u.0': disp_fun})
ebcs = Conditions([x_sym, y_sym, z_sym, displacement])
### Terms and equations ###
integral = Integral('i', order=2 * order)
term_neohook = Term.new('dw_tl_he_neohook(m.mu, v, u)',
integral,
omega,
m=m,
v=v,
u=u)
term_mooney = Term.new('dw_tl_he_mooney_rivlin(m.kappa, v, u)',
integral,
omega,
m=m,
v=v,
u=u)
term_pressure = Term.new('dw_tl_bulk_pressure(v, u, p)',
integral,
omega,
v=v,
u=u,
p=p)
term_volume_change = Term.new('dw_tl_volume(q, u)',
integral,
omega,
q=q,
u=u,
term_mode='volume')
term_volume = Term.new('dw_volume_integrate(q)', integral, omega, q=q)
eq_balance = Equation('balance',
term_neohook + term_mooney + term_pressure)
eq_volume = Equation('volume', term_volume_change - term_volume)
equations = Equations([eq_balance, eq_volume])
### Solvers ###
ls = ScipyDirect({})
nls_status = IndexedStruct()
nls = Newton({'i_max': 5}, lin_solver=ls, status=nls_status)
### Problem ###
pb = Problem('hyper', equations=equations)
pb.set_bcs(ebcs=ebcs)
pb.set_ics(ics=Conditions([]))
tss = SimpleTimeSteppingSolver(ts, nls=nls, context=pb)
pb.set_solver(tss)
### Solution ###
axial_stress = []
axial_displacement = []
def stress_strain_fun(*args, **kwargs):
return stress_strain(*args,
order=order,
global_stress=axial_stress,
global_displacement=axial_displacement,
**kwargs)
pb.solve(save_results=True, post_process_hook=stress_strain_fun)
if do_plot:
plot_graphs(material_parameters,
axial_stress,
axial_displacement,
undeformed_length=dims[0])
def define(is_opt=False):
filename_mesh = data_dir + "/meshes/3d/matrix_fiber_rand.vtk"
mesh = Mesh.from_file(filename_mesh)
bbox = mesh.get_bounding_box()
regions = {"Y": "all", "Ym": ("cells of group 7", "cell"), "Yf": ("r.Y -c r.Ym", "cell")}
regions.update(define_box_regions(3, bbox[0], bbox[1]))
functions = {
"get_mat": (lambda ts, coors, mode=None, problem=None, **kwargs: get_mat(coors, mode, problem),),
"match_x_plane": (per.match_x_plane,),
"match_y_plane": (per.match_y_plane,),
"match_z_plane": (per.match_z_plane,),
}
materials = {"mat": "get_mat"}
fields = {"corrector": ("real", 3, "Y", 1)}
variables = {
"u": ("unknown field", "corrector"),
"v": ("test field", "corrector", "u"),
"Pi": ("parameter field", "corrector", "u"),
"Pi1": ("parameter field", "corrector", "(set-to-None)"),
"Pi2": ("parameter field", "corrector", "(set-to-None)"),
}
ebcs = {"fixed_u": ("Corners", {"u.all": 0.0})}
epbcs = {
"periodic_x": (["Left", "Right"], {"u.all": "u.all"}, "match_x_plane"),
"periodic_y": (["Near", "Far"], {"u.all": "u.all"}, "match_y_plane"),
"periodic_z": (["Top", "Bottom"], {"u.all": "u.all"}, "match_z_plane"),
}
all_periodic = ["periodic_%s" % ii for ii in ["x", "y", "z"][:3]]
options = {
"coefs": "coefs",
"requirements": "requirements",
"volume": {"variables": ["u"], "expression": "d_volume.5.Y( u )"},
"output_dir": "output",
"coefs_filename": "coefs_le",
}
equation_corrs = {
"balance_of_forces": """dw_lin_elastic.5.Y(mat.D, v, u)
= - dw_lin_elastic.5.Y(mat.D, v, Pi)"""
}
coefs = {
"D": {
"requires": ["pis", "corrs_rs"],
"expression": "dw_lin_elastic.5.Y(mat.D, Pi1, Pi2 )",
"set_variables": [("Pi1", ("pis", "corrs_rs"), "u"), ("Pi2", ("pis", "corrs_rs"), "u")],
"class": cb.CoefSymSym,
},
"vol": {"regions": ["Ym", "Yf"], "expression": "d_volume.5.%s(u)", "class": cb.VolumeFractions},
"filenames": {},
}
requirements = {
"pis": {"variables": ["u"], "class": cb.ShapeDimDim},
"corrs_rs": {
"requires": ["pis"],
"ebcs": ["fixed_u"],
"epbcs": all_periodic,
"equations": equation_corrs,
"set_variables": [("Pi", "pis", "u")],
"class": cb.CorrDimDim,
"save_name": "corrs_le",
"dump_variables": ["u"],
},
}
solvers = {
"ls": ("ls.scipy_direct", {}),
"newton": ("nls.newton", {"i_max": 1, "eps_a": 1e-4, "problem": "linear"}),
}
if is_opt:
options.update({"parametric_hook": "optimization_hook", "float_format": "%.16e"})
return locals()
def define(filename_mesh=None, cg1=None, cg2=None):
if filename_mesh is None:
filename_mesh = osp.join(data_dir, 'macro_perf.vtk')
cg1, cg2 = 0.0015, 0.0015 # y and z coordinates of center of gravity
mesh = Mesh.from_file(filename_mesh)
poroela_mezo_file = osp.join(data_dir, 'perf_BD2B_mes.py')
material_cache['meso_filename'] = poroela_mezo_file
bbox = mesh.get_bounding_box()
regions = define_box_regions(mesh.dim, bbox[0], bbox[1], eps=1e-6)
regions.update({
'Omega': 'all',
'Wall': ('r.Top +v r.Bottom +v r.Far +v r.Near', 'facet'),
# 'In': ('r.Left -v r.Wall', 'facet'),
# 'Out': ('r.Right -v r.Wall', 'facet'),
'In': ('copy r.Left', 'facet'),
'Out': ('copy r.Right ', 'facet'),
'Out_u': ('r.Out -v (r.Top +v r.Bottom)', 'facet'),
})
val_w1 = 5e3
val_w2 = 5e3
ebcs, bc_funs, mats, lcbcs = define_bc(cg1,
cg2,
is_steady=False,
val_in=val_w1,
val_out=val_w2)
fields = {
'displacement': ('real', 'vector', 'Omega', 1),
'pressure': ('real', 'scalar', 'Omega', 1),
'velocity1': ('real', 'vector', 'Omega', 1),
'velocity2': ('real', 'vector', 'Omega', 1),
'sfield': ('real', "scalar", 'Omega', 1),
}
variables = {
#Displacement
'u': ('unknown field', 'displacement'),
'v': ('test field', 'displacement', 'u'),
#Pressure
'p': ('unknown field', 'pressure'),
'q': ('test field', 'pressure', 'p'),
'ls': ('unknown field', 'pressure'),
'lv': ('test field', 'pressure', 'ls'),
#Velocity
'w1': ('unknown field', 'velocity1'),
'z1': ('test field', 'velocity1', 'w1'),
'w2': ('unknown field', 'velocity2'),
'z2': ('test field', 'velocity2', 'w2'),
'U': ('parameter field', 'displacement', 'u'),
'P': ('parameter field', 'pressure', 'p'),
'W1': ('parameter field', 'velocity1', 'w1'),
'W2': ('parameter field', 'velocity2', 'w2'),
'svar': ('parameter field', 'sfield', '(set-to-none)'),
}
state_vars = ['p', 'u', 'w1', 'w2']
functions = {
'get_homog': (lambda ts, coors, problem, mode=None, **kwargs: \
get_homog(coors,problem, mode, **kwargs),),
'get_u': (lambda ts, coor, mode=None, problem=None, **kwargs:
get_u(tstep, coor),),
}
functions.update(bc_funs)
materials = {
'hom': 'get_homog',
}
materials.update(mats)
#Definition of integrals
integrals = {
'i': 5,
"is": ("s", 5),
}
#Definition of solvers
solvers = {
'ls': ('ls.mumps', {}),
'newton': ('nls.newton', {
'i_max': 1,
'eps_a': 1e-10,
'eps_r': 1e-3,
'problem': 'nonlinear',
})
}
options = {
'output_dir': data_dir + '/results/macro',
'ls': 'ls',
'nls': 'newton',
'micro_filename': poroela_mezo_file,
'absolute_mesh_path': True,
'output_prefix': 'Macro:',
'matrix_hook': 'mtx_hook',
}
#Definition of time solver and equations for steady state and time evolution cases
tstep = TimeStepper(0.0, 1.0, n_step=20)
equations, phook = define_time_equations(tstep)
options.update({'parametric_hook': phook})
return locals()
def define(eps0=0.01,
dt=0.1,
nch=2,
dim=2,
filename_mesh='micro_mesh.vtk',
approx_u=1,
approx_p=1,
multiprocessing=False):
filename_mesh = osp.join(wdir, filename_mesh)
chs = list(nm.arange(nch) + 1)
update_u_by_p = [('corrs_%d' % ch, 'u', 'dp%d_0' % ch) for ch in chs]
update_p_by_p = [('corrs_%d' % ch, 'p', 'dp%d_0' % ch) for ch in chs]
options = {
'coefs': 'coefs',
'requirements': 'requirements',
'volume': {
'expression': 'd_volume.5.Y(u)'
},
'output_dir': osp.join(wdir, 'results'),
'coefs_filename': 'coefs_hp',
# 'chunks_per_worker': 2,
'multiprocessing': multiprocessing,
'file_per_var': True,
'micro_update': {
'coors_prev':
None,
'coors': [('corrs_rs', 'u', 'mtx_e_rel'),
('corrs_p', 'u', None)] + update_u_by_p,
'p': [('corrs_rs', 'p', 'mtx_e_rel'),
('corrs_p', 'p', None)] + update_p_by_p,
'p1': [('corrs_eta1', 'p1', 'gdp1_0', eps0),
('corrs_p1', 'p1', None, eps0), (None, None, 'dp1_0')],
'p2': [('corrs_eta2', 'p2', 'gdp2_0', eps0),
('corrs_p2', 'p2', None, eps0), (None, None, 'dp2_0')],
},
'mesh_update_variable': 'u',
'file_format': 'vtk',
}
fields = {
'displacement': ('real', 'vector', 'Y', approx_u),
'pressure': ('real', 'scalar', 'Ym', approx_p),
}
functions = {
'match_x_plane': (per.match_x_plane, ),
'match_y_plane': (per.match_y_plane, ),
'match_z_plane': (per.match_z_plane, ),
'mat_fce': (def_mat, ),
}
integrals = {
'i': 3,
}
materials = {
'mat_he':
'mat_fce',
'solid': ({
'mu': {
'Ym': 1e6,
'Yc1': .6e6,
'Yc2': .6e6
},
'K': {
'Ym': 1e-11 * nm.eye(dim) / eps0**2,
'Yc1': 1e-6 * nm.eye(dim),
'Yc2': 2e-6 * nm.eye(dim),
},
}, ),
}
variables = {
'u': ('unknown field', 'displacement'),
'v': ('test field', 'displacement', 'u'),
'Piu': ('parameter field', 'displacement', 'u'),
'Pi1u': ('parameter field', 'displacement', '(set-to-None)'),
'Pi2u': ('parameter field', 'displacement', '(set-to-None)'),
'p': ('unknown field', 'pressure'),
'q': ('test field', 'pressure', 'p'),
'Pip': ('parameter field', 'pressure', 'p'),
'Pi1p': ('parameter field', 'pressure', '(set-to-None)'),
'Pi2p': ('parameter field', 'pressure', '(set-to-None)'),
'U': ('parameter field', 'displacement', '(set-to-None)'),
'P': ('parameter field', 'pressure', '(set-to-None)'),
}
regions = {
'Y': 'all',
'Ym': 'cells of group 1',
'Left_': ('r.Left -v r.Corners', 'vertex'),
'Right_': ('r.Right -v r.Corners', 'vertex'),
'Top_': ('r.Top -v r.Corners', 'vertex'),
'Bottom_': ('r.Bottom -v r.Corners', 'vertex'),
'Left0': ('r.Left_ -v r.Gamma_mc', 'vertex'),
'Right0': ('r.Right_ -v r.Gamma_mc', 'vertex'),
'Top0': ('r.Top_ -v r.Gamma_mc', 'vertex'),
'Bottom0': ('r.Bottom_ -v r.Gamma_mc', 'vertex'),
}
if dim == 3:
regions.update({
'Near_': ('r.Near -v r.Corners', 'vertex'),
'Far_': ('r.Far -v r.Corners', 'vertex'),
'Near0': ('r.Near_ -v r.Gamma_mc', 'vertex'),
'Far0': ('r.Far_ -v r.Gamma_mc', 'vertex'),
})
if nch > 1:
regions.update({
'Gamma_mc':
(' +s '.join(['r.Gamma%d' % ii for ii in chs]), 'facet', 'Ym')
})
else:
regions.update({'Gamma_mc': ('copy r.Gamma1', 'facet')})
regions.update(define_box_regions(dim, (0, 0, 0)[:dim], (1, 1, 1)[:dim]))
ebcs = {
'fixed_u': ('Corners', {
'u.all': 0.0
}),
'fixed_p': ('Gamma_mc', {
'p.0': 0.0
}),
}
epbcs = {
'periodic_ux': (['Right_', 'Left_'], {
'u.all': 'u.all'
}, 'match_x_plane'),
'periodic_px': (['Right0', 'Left0'], {
'p.0': 'p.0'
}, 'match_x_plane'),
}
periodic_all = ['periodic_ux', 'periodic_uy', 'periodic_px', 'periodic_py']
if dim == 3:
epbcs.update({
'periodic_uy': (['Near_', 'Far_'], {
'u.all': 'u.all'
}, 'match_y_plane'),
'periodic_uz': (['Bottom_', 'Top_'], {
'u.all': 'u.all'
}, 'match_z_plane'),
'periodic_py': (['Near0', 'Far0'], {
'p.0': 'p.0'
}, 'match_y_plane'),
'periodic_pz': (['Bottom0', 'Top0'], {
'p.0': 'p.0'
}, 'match_z_plane'),
})
periodic_all += ['periodic_uz', 'periodic_pz']
else:
epbcs.update({
'periodic_uy': (['Top_', 'Bottom_'], {
'u.all': 'u.all'
}, 'match_y_plane'),
'periodic_py': (['Top0', 'Bottom0'], {
'p.0': 'p.0'
}, 'match_y_plane'),
})
lcbcs = {}
coefs = {
'A1': {
'status': 'auxiliary',
'requires': ['pis_u', 'corrs_rs'],
'expression': 'dw_nonsym_elastic.i.Y(mat_he.A, Pi1u, Pi2u)',
'set_variables': [('Pi1u', ('pis_u', 'corrs_rs'), 'u'),
('Pi2u', ('pis_u', 'corrs_rs'), 'u')],
'class': MyCoefNonSymNonSym,
},
'A2': {
'status': 'auxiliary',
'requires': ['corrs_rs'],
'expression': 'dw_diffusion.i.Ym(mat_he.KH, Pi1p, Pi2p)',
'set_variables': [('Pi1p', 'corrs_rs', 'p'),
('Pi2p', 'corrs_rs', 'p')],
'class': cb.CoefNonSymNonSym,
},
'A': { # effective viscoelastic incremental tensor, eq. (51)
'requires': ['c.A1', 'c.A2'],
'expression': 'c.A1 + %e * c.A2' % dt,
'class': cb.CoefEval,
},
'S': { # averaged Cauchy stress, eq. (53)
'expression': 'ev_volume_integrate_mat.i.Y(mat_he.S, u)',
'class': cb.CoefOne,
},
'Q1': {
'status': 'auxiliary',
'requires': ['pis_u', 'corrs_p'],
'expression': 'dw_nonsym_elastic.i.Y(mat_he.A, Pi1u, Pi2u)',
'set_variables': [('Pi1u', 'pis_u', 'u'),
('Pi2u', 'corrs_p', 'u')],
'class': cb.CoefNonSym,
},
'Q2': {
'status': 'auxiliary',
'requires': ['pis_u', 'corrs_p'],
'expression': 'dw_biot.i.Ym(mat_he.BI, Pi1u, Pi1p)',
'set_variables': [('Pi1p', 'corrs_p', 'p'),
('Pi1u', 'pis_u', 'u')],
'class': cb.CoefNonSym,
},
'Q': { # retardation stress, eq. (54)
'requires': ['c.Q1', 'c.Q2'],
'expression': 'c.Q1 - c.Q2',
'class': cb.CoefEval,
},
}
requirements = {
'pis_u': {
'variables': ['u'],
'class': cb.ShapeDimDim,
},
'corrs_rs': { # eq. (43)
'requires': ['pis_u'],
'ebcs': ['fixed_u', 'fixed_p'],
'epbcs': periodic_all,
'equations': {
'balance_of_forces':
""" dw_nonsym_elastic.i.Y(mat_he.A, v, u)
- dw_biot.i.Ym(mat_he.BI, v, p)
= - dw_nonsym_elastic.i.Y(mat_he.A, v, Piu)""",
'mass equilibrium':
""" - dw_biot.i.Ym(mat_he.BI, u, q)
-%e * dw_diffusion.i.Ym(mat_he.KH, q, p)
= dw_biot.i.Ym(mat_he.BI, Piu, q)""" % dt,
},
'set_variables': [('Piu', 'pis_u', 'u')],
'class': cb.CorrDimDim,
'save_name': 'corrs_hp_rs',
'solvers': {'ls': 'ls', 'nls': 'nls1', 'ts': None},
},
'corrs_p': { # particular response, eq. (45)
'requires': ['press_m'],
'ebcs': ['fixed_u', 'fixed_p'],
'epbcs': periodic_all,
'equations': {
'balance_of_forces':
""" dw_nonsym_elastic.i.Y(mat_he.A, v, u)
- dw_biot.i.Ym(mat_he.BI, v, p)
= - dw_lin_prestress.i.Y(mat_he.S, v)""",
'mass equilibrium':
""" - dw_biot.i.Ym(mat_he.BI, u, q)
-%e * dw_diffusion.i.Ym(mat_he.KH, q, p)
= %e * dw_diffusion.i.Ym(mat_he.KH, q, Pip)
+ %e * dw_diffusion.i.Ym(mat_he.dK, q, Pip) """ % (dt, dt, dt), # !!! d3(Pip, q)
},
'class': cb.CorrOne,
'set_variables': [('Pip', 'press_m', 'p')],
'save_name': 'corrs_hp_p',
'solvers': {'ls': 'ls', 'nls': 'nls1', 'ts': None},
},
'press_m': {
'variable': 'p',
'class': CorrStatePressureM,
'save_name': 'corrs_hp_press_m',
},
}
for ich in chs:
lab = '%d' % ich
Yc = 'Yc' + lab
fields.update({
'pressure' + lab: ('real', 'scalar', Yc, approx_p),
})
variables.update({
'p' + lab: ('unknown field', 'pressure' + lab),
'q' + lab: ('test field', 'pressure' + lab, 'p' + lab),
'Pip' + lab: ('parameter field', 'pressure' + lab, 'p' + lab),
'Pi1p' + lab:
('parameter field', 'pressure' + lab, '(set-to-None)'),
'Pi2p' + lab:
('parameter field', 'pressure' + lab, '(set-to-None)'),
'P' + lab: ('parameter field', 'pressure' + lab, '(set-to-None)'),
'ls' + lab: ('unknown field', 'pressure' + lab),
'lv' + lab: ('test field', 'pressure' + lab, 'ls' + lab),
})
epbcs.update({
'periodic_px' + lab: (['Left', 'Right'], {
'p%s.0' % lab: 'p%s.0' % lab
}, 'match_x_plane'),
})
periodic_all_p = ['periodic_px' + lab, 'periodic_py' + lab]
if dim == 3:
epbcs.update({
'periodic_py' + lab: (['Near', 'Far'], {
'p%s.0' % lab: 'p%s.0' % lab
}, 'match_y_plane'),
'periodic_pz' + lab: (['Bottom', 'Top'], {
'p%s.0' % lab: 'p%s.0' % lab
}, 'match_z_plane'),
})
periodic_all_p += ['periodic_pz' + lab]
else:
epbcs.update({
'periodic_py' + lab: (['Bottom', 'Top'], {
'p%s.0' % lab: 'p%s.0' % lab
}, 'match_y_plane'),
})
regions.update({
Yc: 'cells of group %d' % (ich + 1),
'Gamma' + lab: ('r.Yc%s *s r.Ym' % lab, 'facet', 'Ym'),
})
ename = 'fixed_p%s_%s_1' % (lab, lab)
ebcs[ename] = ('Gamma' + lab, {'p.0': 1.})
fixed_p_01 = [ename]
chs2 = chs[:]
chs2.remove(ich)
for ich2 in chs2:
lab2 = '%d' % ich2
ename = 'fixed_p%s_%s_0' % (lab, lab2)
ebcs[ename] = ('Gamma' + lab2, {'p.0': 0.})
fixed_p_01.append(ename)
lname = 'imv' + lab
lcbcs[lname] = (Yc, {
'ls%s.0' % lab: None
}, None, 'integral_mean_value')
coefs.update({
'B%s_1' % lab: {
'status': 'auxiliary',
'requires': ['pis_u', 'corrs_' + lab],
'expression': 'dw_biot.i.Ym(mat_he.BI, Pi1u, Pi1p)',
'set_variables': [('Pi1p', 'corrs_' + lab, 'p'),
('Pi1u', 'pis_u', 'u')],
'class': cb.CoefNonSym,
},
'B%s_2' % lab: {
'status': 'auxiliary',
'requires': ['pis_u'],
'expression': 'dw_lin_prestress.i.Yc%s(mat_he.BI, Pi1u)' % lab,
'set_variables': [('Pi1u', 'pis_u', 'u')],
'class': cb.CoefNonSym,
},
'B%s_3' % lab: {
'status': 'auxiliary',
'requires': ['pis_u', 'corrs_' + lab],
'expression': 'dw_nonsym_elastic.i.Y(mat_he.A, Pi1u, Pi2u)',
'set_variables': [('Pi1u', 'pis_u', 'u'),
('Pi2u', 'corrs_' + lab, 'u')],
'class': cb.CoefNonSym,
},
'B' + lab: { # The Biot poroelasticity tensor, eq. (52)
'requires': ['c.B%s_%d' % (lab, ii + 1) for ii in range(3)],
'expression': 'c.B%s_1 + c.B%s_2 - c.B%s_3' % ((lab,) * 3),
'class': cb.CoefEval,
},
'C' + lab: { # channel permeability, eq. (55)
'requires': ['pis_p' + lab, 'corrs_eta' + lab],
'expression': 'dw_diffusion.i.Yc%s(mat_he.KH, Pi1p%s, Pi2p%s)'\
% ((lab,) * 3),
'set_variables': [('Pi1p' + lab,
('pis_p' + lab, 'corrs_eta' + lab), 'p' + lab),
('Pi2p' + lab,
('pis_p' + lab, 'corrs_eta' + lab), 'p' + lab)],
'class': cb.CoefDimDim,
},
'Z%s_1' % lab: {
'status': 'auxiliary',
'requires': ['corrs_p'],
'expression': 'dw_lin_prestress.i.Yc%s(mat_he.BI, Pi1u)' % lab,
'set_variables': [('Pi1u', 'corrs_p', 'u')],
'class': cb.CoefOne,
},
'Z%s_2' % lab: {
'status': 'auxiliary',
'requires': ['corrs_' + lab, 'corrs_p'],
'expression': 'dw_biot.i.Ym(mat_he.BI, Pi1u, Pi1p)',
'set_variables': [('Pi1u', 'corrs_p', 'u'),
('Pi1p', 'corrs_' + lab, 'p')],
'class': cb.CoefOne,
},
'Z%s_3' % lab: {
'status': 'auxiliary',
'requires': ['corrs_' + lab, 'corrs_p', 'press_m'],
'expression': 'dw_diffusion.i.Ym(mat_he.KH, Pi1p, Pi2p)',
'set_variables': [('Pi1p', ('corrs_p', 'press_m'), 'p'),
('Pi2p', 'corrs_' + lab, 'p')],
'class': cb.CoefOne,
},
'Z' + lab: { # effective discharge, eq. (58)
'requires': ['c.Z%s_%d' % (lab, ii + 1) for ii in range(3)],
'expression': 'c.Z%s_1/%e + c.Z%s_2/%e + c.Z%s_3'\
% (lab, dt, lab, dt, lab),
'class': cb.CoefEval,
},
'g%s' % lab: { # effective discharge, eq. (58)
'requires': ['pis_p' + lab, 'press_' + lab, 'corrs_p' + lab],
'expression': """dw_diffusion.i.Yc%s(mat_he.KH, Pi1p%s, Pi2p%s)"""\
% ((lab,) * 3),
'set_variables': [('Pi1p' + lab, ('press_' + lab, 'corrs_p' + lab),
'p' + lab),
('Pi2p' + lab, 'pis_p' + lab, 'p' + lab)],
'class': cb.CoefDim,
},
})
requirements.update({
'corrs_' + lab: { # eq. (44)
'requires': [],
'ebcs': ['fixed_u'] + fixed_p_01,
'epbcs': periodic_all,
'equations': {
'balance_of_forces':
""" dw_nonsym_elastic.i.Y(mat_he.A, v, u)
- dw_biot.i.Ym(mat_he.BI, v, p)
= dw_lin_prestress.i.Yc%s(mat_he.BI, v)""" % lab,
'mass equilibrium':
""" - dw_biot.i.Ym(mat_he.BI, u, q)
-%e * dw_diffusion.i.Ym(mat_he.KH, q, p)
= 0""" % dt,
},
'class': cb.CorrOne,
'save_name': 'corrs_hp_' + lab,
'solvers': {'ls': 'ls', 'nls': 'nls1', 'ts': None},
},
'pis_p' + lab: {
'variables': ['p' + lab],
'class': cb.ShapeDim,
},
'corrs_eta' + lab: { # channel flow correctors, eq. (46)
'requires': ['pis_p' + lab],
'epbcs': periodic_all_p,
'ebcs': [],
'lcbcs': [lname],
'equations': {
'eq':
""" dw_diffusion.i.Yc%s(mat_he.KH, q%s, p%s)
+ dw_volume_dot.i.Yc%s(q%s, ls%s)
=
- dw_diffusion.i.Yc%s(mat_he.KH, q%s, Pip%s)"""\
% ((lab,) * 9),
'eq_imv':
'dw_volume_dot.i.Yc%s(lv%s, p%s) = 0' % ((lab,) * 3),
},
'class': cb.CorrDim,
'set_variables': [('Pip' + lab, 'pis_p' + lab, 'p' + lab)],
'save_name': 'corrs_hp_eta_' + lab,
'solvers': {'ls': 'ls', 'nls': 'nls2', 'ts': None},
},
'corrs_p' + lab: { # particular response, eq. (47)
'requires': ['press_' + lab],
'ebcs': [],
'epbcs': periodic_all_p,
'lcbcs': [lname],
'equations': {
'eq':
""" dw_diffusion.i.Yc%s(mat_he.KH, q%s, p%s)
+ dw_volume_dot.i.Yc%s(q%s, ls%s)
=
dw_diffusion.i.Yc%s(mat_he.dK, q%s, Pip%s)
- dw_diffusion.i.Yc%s(mat_he.H, q%s, Pip%s)"""\
% ((lab,) * 12),
'eq_imv':
'dw_volume_dot.i.Yc%s(lv%s, p%s) = 0' % ((lab,) * 3),
},
'class': cb.CorrOne,
'set_variables': [('Pip' + lab, 'press_' + lab, 'p' + lab)],
'save_name': 'corrs_hp_p_' + lab,
'solvers': {'ls': 'ls', 'nls': 'nls2', 'ts': None},
},
'press_' + lab: {
'variable': 'p' + lab,
'class': CorrStatePressureCh,
'save_name': 'corrs_hp_press_' + lab,
},
})
for ich2 in chs:
lab2 = '%d' % ich2
lab12 = lab + lab2
coefs.update({
'G%s_1' % lab12: {
'status': 'auxiliary',
'requires': ['corrs_' + lab2],
'expression': 'dw_lin_prestress.i.Yc%s(mat_he.BI, Pi1u)' % lab,
'set_variables': [('Pi1u', 'corrs_' + lab2, 'u')],
'class': cb.CoefOne,
},
'G%s_2' % lab12: {
'status': 'auxiliary',
'requires': ['corrs_' + lab, 'corrs_' + lab2],
'expression': 'dw_biot.i.Ym(mat_he.BI, Pi1u, Pi1p)',
'set_variables': [('Pi1u', 'corrs_' + lab, 'u'),
('Pi1p', 'corrs_' + lab2, 'p')],
'class': cb.CoefOne,
},
'G%s_3' % lab12: {
'status': 'auxiliary',
'requires': ['corrs_' + lab, 'corrs_' + lab2],
'expression': 'dw_diffusion.i.Ym(mat_he.KH, Pi1p, Pi2p)',
'set_variables': [('Pi1p', 'corrs_' + lab, 'p'),
('Pi2p', 'corrs_' + lab2, 'p')],
'class': cb.CoefOne,
},
'G%s' % lab12: { # perfusion coefficient , eq. (57)
'requires': ['c.G%s_%d' % (lab12, ii + 1) for ii in range(3)],
'expression': 'c.G%s_1/%e + c.G%s_2/%e + c.G%s_3'\
% (lab12, dt, lab12, dt, lab12),
'class': cb.CoefEval,
},
})
solvers = {
'ls': ('ls.mumps', {
'memory_relaxation': 50,
}),
'nls2': ('nls.newton', {
'i_max': 1,
'eps_a': 1e-16,
'eps_r': 1e-3,
'problem': 'nonlinear',
}),
'nls1': ('nls.newton', {
'i_max': 1,
'eps_a': 1e-6,
'eps_r': 1e-3,
'problem': 'nonlinear',
}),
}
return locals()
def define(filename_mesh=None):
eps0 = 0.01 # given scale parameter
if filename_mesh is None:
filename_mesh = osp.join(data_dir, 'micro_perf_puc.vtk')
mesh = Mesh.from_file(filename_mesh)
dim = 3
sym = (dim + 1) * dim // 2
sym_eye = 'nm.array([1,1,0])' if dim == 2 else 'nm.array([1,1,1,0,0,0])'
bbox = mesh.get_bounding_box()
regions = define_box_regions(mesh.dim, bbox[0], bbox[1], eps=1e-3)
regions.update({
'Y': 'all',
'Gamma_Y': ('vertices of surface', 'facet'),
# solid matrix
'Ys': 'cells of group 1',
'Ys_left': ('r.Ys *v r.Left', 'vertex'),
'Ys_right': ('r.Ys *v r.Right', 'vertex'),
'Ys_bottom': ('r.Ys *v r.Bottom', 'vertex'),
'Ys_top': ('r.Ys *v r.Top', 'vertex'),
'Gamma_Ysf': ('r.Ys *v r.Yf', 'facet', 'Ys'),
# channel
'Yf': 'cells of group 2',
'Yf0': ('r.Yf -v r.Gamma_Yfs', 'vertex'),
'Yf_left': ('r.Yf0 *v r.Left', 'vertex'),
'Yf_right': ('r.Yf0 *v r.Right', 'vertex'),
'Yf_bottom': ('r.Yf0 *v r.Bottom', 'vertex'),
'Yf_top': ('r.Yf0 *v r.Top', 'vertex'),
'Gamma_Yfs': ('r.Ys *v r.Yf', 'facet', 'Yf'),
})
if dim == 3:
regions.update({
'Ys_far': ('r.Ys *v r.Far', 'vertex'),
'Ys_near': ('r.Ys *v r.Near', 'vertex'),
'Yf_far': ('r.Yf0 *v r.Far', 'vertex'),
'Yf_near': ('r.Yf0 *v r.Near', 'vertex'),
})
fields = {
'volume': ('real', 'scalar', 'Y', 1),
'displacement': ('real', 'vector', 'Ys', 1),
'pressure': ('real', 'scalar', 'Yf', 1),
'velocity': ('real', 'vector', 'Yf', 2),
}
variables = {
# displacement
'u': ('unknown field', 'displacement'),
'v': ('test field', 'displacement', 'u'),
'Pi_u': ('parameter field', 'displacement', 'u'),
'U1': ('parameter field', 'displacement', '(set-to-None)'),
'U2': ('parameter field', 'displacement', '(set-to-None)'),
# velocity
'w': ('unknown field', 'velocity'),
'z': ('test field', 'velocity', 'w'),
'Pi_w': ('parameter field', 'velocity', 'w'),
'W1': ('parameter field', 'velocity', '(set-to-None)'),
'W2': ('parameter field', 'velocity', '(set-to-None)'),
# pressure
'p': ('unknown field', 'pressure'),
'q': ('test field', 'pressure', 'p'),
# volume
'volume': ('parameter field', 'volume', '(set-to-None)'),
}
functions = {
'match_x_plane': (per.match_x_plane, ),
'match_y_plane': (per.match_y_plane, ),
'match_z_plane': (per.match_z_plane, ),
}
materials = {
'matrix': ({
'D': stiffness_from_youngpoisson(dim, 1e3, 0.49)
}, ), #Soft tissue
'fluid': (
{
'eta_p': 3.6e-3 / eps0**2, #Rescaled blood viscosity
'aux_compress': 1e-18
}, ), #Auxillary compressibility
}
ebcs = {
'fixed_u': ('Corners', {
'u.all': 0.0
}),
'fixed_w': ('Gamma_Yfs', {
'w.all': 0.0
}),
}
epbcs, periodic = get_periodic_bc([('u', 'Ys'), ('p', 'Yf'), ('w', 'Yf')])
integrals = {
'i': 4,
}
options = {
'coefs': 'coefs',
'coefs_filename': 'coefs_micro',
'requirements': 'requirements',
'volume': {
'variables': ['u', 'p'],
'expression': 'd_volume.i.Ys(u) + d_volume.i.Yf(p)',
},
'output_dir': data_dir + '/results/micro',
'ls': 'ls',
'file_per_var': True,
'absolute_mesh_path': True,
'multiprocessing': True,
'output_prefix': 'micro:',
}
#Definition of used solvers
solvers = {
'ls': ('ls.mumps', {}),
'ns_em9': ('nls.newton', {
'i_max': 1,
'eps_a': 1e-9,
'eps_r': 1e-3,
'problem': 'nonlinear'
}),
'ns_em12': ('nls.newton', {
'i_max': 1,
'eps_a': 1e-12,
'eps_r': 1e-3,
'problem': 'nonlinear'
}),
}
#Definition of homogenized coefficients, see (22) and (23)
coefs = {
#Elasticity coefficient
'A': {
'requires': ['pis_u', 'corrs_omega_ij'],
'expression':
'dw_lin_elastic.i.Ys(matrix.D, U1, U2)',
'set_variables': [('U1', ('corrs_omega_ij', 'pis_u'), 'u'),
('U2', ('corrs_omega_ij', 'pis_u'), 'u')],
'class':
cb.CoefSymSym,
},
#Biot coefficient
'hat_B': {
'status': 'auxiliary',
'requires': ['corrs_omega_ij'],
'expression': '- ev_div.i.Ys(U1)',
'set_variables': [('U1', 'corrs_omega_ij', 'u')],
'class': cb.CoefSym,
},
'B': {
'requires': ['c.phi_f', 'c.hat_B'],
'expression': 'c.hat_B + c.phi_f * %s' % sym_eye,
'class': cb.CoefEval,
},
'M': {
'requires': ['corrs_omega_p'],
'expression':
'dw_lin_elastic.i.Ys(matrix.D, U1, U2)',
'set_variables': [('U1', 'corrs_omega_p', 'u'),
('U2', 'corrs_omega_p', 'u')],
'class':
cb.CoefOne,
},
#Permeability
'K': {
'requires': ['corrs_psi_i'],
'expression':
'dw_div_grad.i.Yf(W1, W2)', # !!!
'set_variables': [('W1', 'corrs_psi_i', 'w'),
('W2', 'corrs_psi_i', 'w')],
'class':
cb.CoefDimDim,
},
#Volume fraction of fluid part
'phi_f': {
'requires': ['c.vol'],
'expression': 'c.vol["fraction_Yf"]',
'class': cb.CoefEval,
},
#Coefficient for storing viscosity
'eta_p': {
'expression': '%e' % materials['fluid'][0]['eta_p'],
'class': cb.CoefEval,
},
#Volume fractions
'vol': {
'regions': ['Ys', 'Yf'],
'expression': 'd_volume.i.%s(volume)',
'class': cb.VolumeFractions,
},
#Surface volume fractions
'surf_vol': {
'regions': ['Ys', 'Yf'],
'expression': 'd_surface.i.%s(volume)',
'class': cb.VolumeFractions,
},
'filenames': {},
}
#Definition of microscopic corrector problems
requirements = {
#Definition of \Pi^{ij}_k
'pis_u': {
'variables': ['u'],
'class': cb.ShapeDimDim,
},
#Correcotr like class returning ones
'pis_w': {
'variables': ['w'],
'class': cb.OnesDim,
},
#Corrector problem related to elasticity, see (17)
'corrs_omega_ij': {
'requires': ['pis_u'],
'ebcs': ['fixed_u'],
'epbcs': periodic['per_u'],
'is_linear': True,
'equations': {
'balance_of_forces':
"""dw_lin_elastic.i.Ys(matrix.D, v, u)
= - dw_lin_elastic.i.Ys(matrix.D, v, Pi_u)"""
},
'set_variables': [('Pi_u', 'pis_u', 'u')],
'class': cb.CorrDimDim,
'save_name': 'corrs_omega_ij',
'dump_variables': ['u'],
'solvers': {'ls': 'ls', 'nls': 'ns_em9'},
},
# Corrector problem related to elasticity, see (18)
'corrs_omega_p': {
'requires': [],
'ebcs': ['fixed_u'],
'epbcs': periodic['per_u'],
'equations': {
'balance_of_forces':
"""dw_lin_elastic.i.Ys(matrix.D, v, u)
= -dw_surface_ltr.i.Gamma_Ysf(v)"""
},
'class': cb.CorrOne,
'save_name': 'corrs_omega_p',
'dump_variables': ['u'],
'solvers': {'ls': 'ls', 'nls': 'ns_em3'},
},
#Corrector problem related to velocity, see (19)
'corrs_psi_i': {
'requires': ['pis_w'],
'ebcs': ['fixed_w'],
'epbcs': periodic['per_w'] + periodic['per_p'],
'is_linear': True,
'equations': {
'balance_of_forces': # !!!
"""dw_div_grad.i.Yf(fluid.eta_p,z, w)
- dw_stokes.i.Yf(z, p)
= dw_volume_dot.i.Yf(z, Pi_w)""",
'incompressibility':
"""dw_stokes.i.Yf(w, q)
+ dw_volume_dot.i.Yf(fluid.aux_compress, q, p)
= 0""",#
},
'set_variables': [('Pi_w', 'pis_w', 'w')],
'class': cb.CorrDim,
'save_name': 'corrs_psi_i',
'dump_variables': ['w', 'p'],
'solvers': {'ls': 'ls', 'nls': 'ns_em12'},
},
}
return locals()
def define(is_opt=False):
filename_mesh = data_dir + '/meshes/3d/matrix_fiber_rand.vtk'
mesh = Mesh.from_file(filename_mesh)
bbox = mesh.get_bounding_box()
regions = {
'Y' : 'all',
'Ym' : ('cells of group 7', 'cell'),
'Yf' : ('r.Y -c r.Ym', 'cell'),
}
regions.update(define_box_regions(3, bbox[0], bbox[1]))
functions = {
'get_mat': (lambda ts, coors, mode=None, problem=None, **kwargs:
get_mat(coors, mode, problem),),
'match_x_plane' : (per.match_x_plane,),
'match_y_plane' : (per.match_y_plane,),
'match_z_plane' : (per.match_z_plane,),
}
materials = {
'mat': 'get_mat',
}
fields = {
'corrector' : ('real', 3, 'Y', 1),
}
variables = {
'u': ('unknown field', 'corrector'),
'v': ('test field', 'corrector', 'u'),
'Pi': ('parameter field', 'corrector', 'u'),
'Pi1': ('parameter field', 'corrector', '(set-to-None)'),
'Pi2': ('parameter field', 'corrector', '(set-to-None)'),
}
ebcs = {
'fixed_u' : ('Corners', {'u.all' : 0.0}),
}
epbcs = {
'periodic_x' : (['Left', 'Right'], {'u.all' : 'u.all'}, 'match_x_plane'),
'periodic_y' : (['Near', 'Far'], {'u.all' : 'u.all'}, 'match_y_plane'),
'periodic_z' : (['Top', 'Bottom'], {'u.all' : 'u.all'}, 'match_z_plane'),
}
all_periodic = ['periodic_%s' % ii for ii in ['x', 'y', 'z'][:3]]
options = {
'coefs': 'coefs',
'requirements': 'requirements',
'volume': { 'variables' : ['u'], 'expression' : 'd_volume.5.Y( u )' },
'output_dir': 'output',
'coefs_filename': 'coefs_le',
}
equation_corrs = {
'balance_of_forces':
"""dw_lin_elastic.5.Y(mat.D, v, u)
= - dw_lin_elastic.5.Y(mat.D, v, Pi)"""
}
coefs = {
'D' : {
'requires' : ['pis', 'corrs_rs'],
'expression' : 'dw_lin_elastic.5.Y(mat.D, Pi1, Pi2 )',
'set_variables': [('Pi1', ('pis', 'corrs_rs'), 'u'),
('Pi2', ('pis', 'corrs_rs'), 'u')],
'class' : cb.CoefSymSym,
},
'vol': {
'regions': ['Ym', 'Yf'],
'expression': 'd_volume.5.%s(u)',
'class': cb.VolumeFractions,
},
'filenames' : {},
}
requirements = {
'pis' : {
'variables' : ['u'],
'class' : cb.ShapeDimDim,
},
'corrs_rs' : {
'requires' : ['pis'],
'ebcs' : ['fixed_u'],
'epbcs' : all_periodic,
'equations' : equation_corrs,
'set_variables' : [('Pi', 'pis', 'u')],
'class' : cb.CorrDimDim,
'save_name' : 'corrs_le',
},
}
solvers = {
'ls' : ('ls.scipy_direct', {}),
'newton' : ('nls.newton', {
'i_max' : 1,
'eps_a' : 1e-4,
'problem': 'linear',
})
}
if is_opt:
options.update({
'parametric_hook': 'optimization_hook',
'float_format': '%.16e',
})
return locals()
def mesh_hook(mesh, mode):
"""
Generate the block mesh.
"""
if mode == 'read':
mesh = gen_block_mesh(dims, shape, [0, 0, 0], name='user_block',
verbose=False)
return mesh
elif mode == 'write':
pass
filename_mesh = UserMeshIO(mesh_hook)
regions = define_box_regions(3, 0.5 * dims)
regions.update({
'Omega' : 'all',
'Gamma1_f' : ('copy r.Top', 'face'),
'Gamma2_f' : ('r.Near +v r.Bottom +v r.Far', 'face'),
'Gamma_f' : ('r.Gamma1_f +v r.Gamma2_f', 'face'),
'Inlet_f' : ('r.Left -v r.Gamma_f', 'face'),
})
fields = {
'velocity' : ('real', 3, 'Omega', 1),
'pressure' : ('real', 1, 'Omega', 1),
}
def get_u_d(ts, coors, region=None):
"""
Generate the block mesh.
"""
if mode == 'read':
mesh = gen_block_mesh(dims,
shape, [0, 0, 0],
name='user_block',
verbose=False)
return mesh
elif mode == 'write':
pass
filename_mesh = UserMeshIO(mesh_hook)
regions = define_box_regions(3, 0.5 * dims)
regions.update({
'Omega':
'all',
'Edges_v': ("""(r.Near *v r.Bottom) +v
(r.Bottom *v r.Far) +v
(r.Far *v r.Top) +v
(r.Top *v r.Near)""", 'edge'),
'Gamma1_f': ('copy r.Top', 'face'),
'Gamma2_f': ('r.Near +v r.Bottom +v r.Far', 'face'),
'Gamma_f': ('r.Gamma1_f +v r.Gamma2_f', 'face'),
'Gamma_v': ('r.Gamma_f -v r.Edges_v', 'face'),
'Inlet_f': ('r.Left -v r.Gamma_f', 'face'),
})
fields = {
def define(filename_mesh, pars, approx_order, refinement_level, solver_conf,
plane='strain', post_process=False):
io = MeshIO.any_from_filename(filename_mesh)
bbox = io.read_bounding_box()
dim = bbox.shape[1]
size = (bbox[1] - bbox[0]).max()
options = {
'absolute_mesh_path' : True,
'refinement_level' : refinement_level,
'allow_empty_regions' : True,
'post_process_hook' : 'compute_von_mises' if post_process else None,
}
fields = {
'displacement': ('complex', dim, 'Omega', approx_order),
}
young1, poisson1, density1, young2, poisson2, density2 = pars
materials = {
'm' : ({
'D' : {'Y1' : stiffness(dim, young=young1, poisson=poisson1,
plane=plane),
'Y2' : stiffness(dim, young=young2, poisson=poisson2,
plane=plane)},
'density' : {'Y1' : density1, 'Y2' : density2},
},),
'wave' : 'get_wdir',
}
variables = {
'u' : ('unknown field', 'displacement', 0),
'v' : ('test field', 'displacement', 'u'),
}
regions = {
'Omega' : 'all',
'Y1': 'cells of group 1',
'Y2': 'cells of group 2',
}
regions.update(define_box_regions(dim,
bbox[0], bbox[1], 1e-8))
ebcs = {
}
if dim == 3:
epbcs = {
'periodic_x' : (['Left', 'Right'], {'u.all' : 'u.all'},
'match_x_plane'),
'periodic_y' : (['Near', 'Far'], {'u.all' : 'u.all'},
'match_y_plane'),
'periodic_z' : (['Top', 'Bottom'], {'u.all' : 'u.all'},
'match_z_plane'),
}
else:
epbcs = {
'periodic_x' : (['Left', 'Right'], {'u.all' : 'u.all'},
'match_y_line'),
'periodic_y' : (['Bottom', 'Top'], {'u.all' : 'u.all'},
'match_x_line'),
}
per.set_accuracy(1e-8 * size)
functions = {
'match_x_plane' : (per.match_x_plane,),
'match_y_plane' : (per.match_y_plane,),
'match_z_plane' : (per.match_z_plane,),
'match_x_line' : (per.match_x_line,),
'match_y_line' : (per.match_y_line,),
'get_wdir' : (get_wdir,),
}
integrals = {
'i' : 2 * approx_order,
}
equations = {
'K' : 'dw_lin_elastic.i.Omega(m.D, v, u)',
'S' : 'dw_elastic_wave.i.Omega(m.D, wave.vec, v, u)',
'R' : """1j * dw_elastic_wave_cauchy.i.Omega(m.D, wave.vec, u, v)
- 1j * dw_elastic_wave_cauchy.i.Omega(m.D, wave.vec, v, u)""",
'M' : 'dw_volume_dot.i.Omega(m.density, v, u)',
}
solver_0 = solver_conf.copy()
solver_0['name'] = 'eig'
return locals()
def define_input(filename, region, bbox):
"""Uses materials, fe of master file, merges regions."""
filename_mesh = filename
dim = bbox.shape[1]
options = {
'coefs' : 'coefs',
'requirements' : 'requirements',
}
functions = {
'match_x_plane' : (match_x_plane,),
'match_y_plane' : (match_y_plane,),
'match_z_plane' : (match_z_plane,),
'match_x_line' : (match_x_line,),
'match_y_line' : (match_y_line,),
}
coefs = {
'elastic' : {
'requires' : ['pis', 'corrs_phono_rs'],
'expression' : expr_elastic % region,
'set_variables' : set_elastic,
'class' : cb.CoefSymSym,
},
}
all_periodic = ['periodic_%s' % ii for ii in ['x', 'y', 'z'][:dim] ]
requirements = {
'pis' : {
'variables' : ['u1'],
'class' : cb.ShapeDimDim,
},
'corrs_phono_rs' : {
'requires' : ['pis'],
'ebcs' : ['fixed_u'],
'epbcs' : all_periodic,
'equations' : expand_regions( eq_rs, (region, region) ),
'set_variables' : [('Pi', 'pis', 'u1')],
'class' : cb.CorrDimDim,
'save_name' : 'corrs_phono',
'dump_variables' : ['u1'],
'save_variables' : ['u1'],
'is_linear' : True,
},
}
field_10 = {
'name' : 'displacement_matrix',
'dtype' : nm.float64,
'shape' : dim,
'region' : region,
'approx_order' : 1,
}
variables = {
'u1' : ('unknown field', 'displacement_matrix', 0),
'v1' : ('test field', 'displacement_matrix', 'u1'),
'Pi' : ('parameter field', 'displacement_matrix', 'u1'),
'Pi1' : ('parameter field', 'displacement_matrix', '(set-to-None)'),
'Pi2' : ('parameter field', 'displacement_matrix', '(set-to-None)'),
}
regions = define_box_regions(dim, bbox[0], bbox[1])
ebcs = {
'fixed_u' : ('Corners', {'u1.all' : 0.0}),
}
##
# Periodic boundary conditions.
if dim == 3:
epbc_10 = {
'name' : 'periodic_x',
'region' : ['Left', 'Right'],
'dofs' : {'u1.all' : 'u1.all'},
'match' : 'match_x_plane',
}
epbc_11 = {
'name' : 'periodic_y',
'region' : ['Near', 'Far'],
'dofs' : {'u1.all' : 'u1.all'},
'match' : 'match_y_plane',
}
epbc_12 = {
'name' : 'periodic_z',
'region' : ['Top', 'Bottom'],
'dofs' : {'u1.all' : 'u1.all'},
'match' : 'match_z_plane',
}
else:
epbc_10 = {
'name' : 'periodic_x',
'region' : ['Left', 'Right'],
'dofs' : {'u1.all' : 'u1.all'},
'match' : 'match_y_line',
}
epbc_11 = {
'name' : 'periodic_y',
'region' : ['Top', 'Bottom'],
'dofs' : {'u1.all' : 'u1.all'},
'match' : 'match_x_line',
}
solver_0 = {
'name' : 'ls',
'kind' : 'ls.scipy_direct', # Direct solver.
}
solver_1 = {
'name' : 'newton',
'kind' : 'nls.newton',
'i_max' : 2,
}
return locals()
#! Mesh
#! ----
dim = 3
filename_mesh = data_dir + '/meshes/3d/matrix_fiber.mesh'
region_lbn = (0, 0, 0)
region_rtf = (1, 1, 1)
#! Regions
#! -------
#! Regions, edges, ...
regions = {
'Y' : 'all',
'Ym' : 'cells of group 1',
'Yc' : 'cells of group 2',
}
regions.update( define_box_regions( dim, region_lbn, region_rtf ) )
#! Materials
#! ---------
materials = {
'mat' : ({'D' : {'Ym': stiffness_from_youngpoisson_mixed(dim, 7.0e9, 0.4),
'Yc': stiffness_from_youngpoisson_mixed(dim, 70.0e9, 0.2)},
'gamma': {'Ym': 1.0/bulk_from_youngpoisson(7.0e9, 0.4),
'Yc': 1.0/bulk_from_youngpoisson(70.0e9, 0.2)}},),
}
#! Fields
#! ------
#! Scalar field for corrector basis functions.
fields = {
'corrector_u' : ('real', dim, 'Y', 1),
'corrector_p' : ('real', 1, 'Y', 0),
}
def define(filename_mesh=None, cg1=None, cg2=None):
if filename_mesh is None:
filename_mesh = osp.join(data_dir, 'macro_perf.vtk')
cg1, cg2 = 0.0015, 0.0015 # y and z coordinates of center of gravity
mesh = Mesh.from_file(filename_mesh)
poroela_mezo_file = osp.join(data_dir, 'perf_BDB_mes.py')
material_cache['meso_filename'] = poroela_mezo_file
bbox = mesh.get_bounding_box()
regions = define_box_regions(mesh.dim, bbox[0], bbox[1], eps=1e-6)
regions.update({
'Omega': 'all',
'Wall': ('r.Top +v r.Bottom +v r.Far +v r.Near', 'facet'),
'In': ('r.Left -v r.Wall', 'facet'),
'Out': ('r.Right -v r.Wall', 'facet'),
})
ebcs, bc_funs, mats, lcbcs = define_bc(cg1, cg2, val_in=1.e4, val_out=1.e4)
fields = {
'displacement': ('real', 'vector', 'Omega', 1),
'pressure': ('real', 'scalar', 'Omega', 1),
'velocity': ('real', 'vector', 'Omega', 2),
}
variables = {
#Displacement
'u': ('unknown field', 'displacement'),
'v': ('test field', 'displacement', 'u'),
#Pressure
'p': ('unknown field', 'pressure'),
'q': ('test field', 'pressure', 'p'),
'ls': ('unknown field', 'pressure'),
'lv': ('test field', 'pressure', 'ls'),
#Velocity
'w': ('unknown field', 'velocity'),
'z': ('test field', 'velocity', 'w'),
}
functions = {
'get_homog': (lambda ts, coors, problem, mode=None, **kwargs: \
get_homog(coors,problem, mode, **kwargs),), }
functions.update(bc_funs)
materials = {
'hom': 'get_homog',
}
materials.update(mats)
integrals = {
'i': 4,
"is": ("s", 4),
}
#Definition of solvers
solvers = {
'ls': ('ls.mumps', {}),
'newton': ('nls.newton', {
'i_max': 2,
'eps_a': 1e-12,
'eps_r': 1e-3,
'problem': 'nonlinear',
})
}
#Definition of macroscopic equations, see (43)
equations = {
'eq1': """
dw_lin_elastic.i.Omega(hom.A, v, u)
- dw_biot.i.Omega(hom.B, v, p)
- dw_v_dot_grad_s.i.Omega(hom.PT, v, p)
- dw_volume_dot.i.Omega(hom.H, v, w)
= 0""",
'eq2': """
dw_diffusion.i.Omega(hom.K, q, p)
- dw_v_dot_grad_s.i.Omega(hom.P, w, q)+ dw_volume_dot.i.Omega( q,ls )
= + dw_surface_integrate.is.In(w_in.val, q) - dw_surface_integrate.is.Out(w_out.val, q)
""",
'eq3': """
dw_lin_elastic.i.Omega(hom.S, z, w)
+ dw_volume_dot.i.Omega(hom.H, z, w)
+ dw_v_dot_grad_s.i.Omega(hom.PT, z, p)
= 0""",
'eq_imv': 'dw_volume_dot.i.Omega( lv, p ) = 0',
}
options = {
'output_dir': data_dir + '/results/macro',
'ls': 'ls',
'nls': 'newton',
'micro_filename': poroela_mezo_file,
'absolute_mesh_path': True,
}
return locals()
def define(is_opt=False):
filename_mesh = data_dir + '/meshes/3d/matrix_fiber_rand.vtk'
mesh = Mesh.from_file(filename_mesh)
bbox = mesh.get_bounding_box()
regions = {
'Y': 'all',
'Ym': ('cells of group 7', 'cell'),
'Yf': ('r.Y -c r.Ym', 'cell'),
}
regions.update(define_box_regions(3, bbox[0], bbox[1]))
functions = {
'get_mat':
(lambda ts, coors, mode=None, problem=None, **kwargs: get_mat(
coors, mode, problem),
),
'match_x_plane': (per.match_x_plane, ),
'match_y_plane': (per.match_y_plane, ),
'match_z_plane': (per.match_z_plane, ),
}
materials = {
'mat': 'get_mat',
}
fields = {
'corrector': ('real', 3, 'Y', 1),
}
variables = {
'u': ('unknown field', 'corrector'),
'v': ('test field', 'corrector', 'u'),
'Pi': ('parameter field', 'corrector', 'u'),
'Pi1': ('parameter field', 'corrector', '(set-to-None)'),
'Pi2': ('parameter field', 'corrector', '(set-to-None)'),
}
ebcs = {
'fixed_u': ('Corners', {
'u.all': 0.0
}),
}
epbcs = {
'periodic_x': (['Left', 'Right'], {
'u.all': 'u.all'
}, 'match_x_plane'),
'periodic_y': (['Near', 'Far'], {
'u.all': 'u.all'
}, 'match_y_plane'),
'periodic_z': (['Top', 'Bottom'], {
'u.all': 'u.all'
}, 'match_z_plane'),
}
all_periodic = ['periodic_%s' % ii for ii in ['x', 'y', 'z'][:3]]
options = {
'coefs': 'coefs',
'requirements': 'requirements',
'volume': {
'variables': ['u'],
'expression': 'ev_volume.5.Y( u )'
},
'output_dir': 'output',
'coefs_filename': 'coefs_le',
}
equation_corrs = {
'balance_of_forces':
"""dw_lin_elastic.5.Y(mat.D, v, u)
= - dw_lin_elastic.5.Y(mat.D, v, Pi)"""
}
coefs = {
'D': {
'requires': ['pis', 'corrs_rs'],
'expression':
'dw_lin_elastic.5.Y(mat.D, Pi1, Pi2 )',
'set_variables': [('Pi1', ('pis', 'corrs_rs'), 'u'),
('Pi2', ('pis', 'corrs_rs'), 'u')],
'class':
cb.CoefSymSym,
},
'vol': {
'regions': ['Ym', 'Yf'],
'expression': 'ev_volume.5.%s(u)',
'class': cb.VolumeFractions,
},
'filenames': {},
}
requirements = {
'pis': {
'variables': ['u'],
'class': cb.ShapeDimDim,
},
'corrs_rs': {
'requires': ['pis'],
'ebcs': ['fixed_u'],
'epbcs': all_periodic,
'equations': equation_corrs,
'set_variables': [('Pi', 'pis', 'u')],
'class': cb.CorrDimDim,
'save_name': 'corrs_le',
},
}
solvers = {
'ls': ('ls.scipy_direct', {}),
'newton': ('nls.newton', {
'i_max': 1,
'eps_a': 1e-4,
'problem': 'linear',
})
}
if is_opt:
options.update({
'parametric_hook': 'optimization_hook',
'float_format': '%.16e',
})
return locals()
def define(eps0=1e-3, filename_mesh='meshes/3d/piezo_mesh_micro.vtk'):
mesh = Mesh.from_file(filename_mesh)
bbox = mesh.get_bounding_box()
regions = define_box_regions(mesh.dim, bbox[0], bbox[1], eps=1e-3)
regions.update({
'Ymc': 'all',
# matrix
'Ym': 'cells of group 1',
'Ym_left': ('r.Ym *v r.Left', 'vertex'),
'Ym_right': ('r.Ym *v r.Right', 'vertex'),
'Ym_bottom': ('r.Ym *v r.Bottom', 'vertex'),
'Ym_top': ('r.Ym *v r.Top', 'vertex'),
'Ym_far': ('r.Ym *v r.Far', 'vertex'),
'Ym_near': ('r.Ym *v r.Near', 'vertex'),
'Gamma_ms': ('r.Ym *v r.Yc', 'facet', 'Ym'),
# conductors
'Yc': ('r.Yc1 +c r.Yc2', 'cell'),
'Yc1': 'cells of group 2',
'Yc2': 'cells of group 3',
'Gamma_s1': ('r.Ym *v r.Yc1', 'facet', 'Ym'),
'Gamma_s2': ('r.Ym *v r.Yc2', 'facet', 'Ym'),
})
options = {
'coefs_filename': 'coefs_piezo',
'volume': {
'value': nm.prod(bbox[1] - bbox[0])
},
'coefs': 'coefs',
'requirements': 'requirements',
'output_dir': 'output',
'file_per_var': True,
'absolute_mesh_path': True,
'multiprocessing': False,
'recovery_hook': recovery_micro,
}
fields = {
'displacement': ('real', 'vector', 'Ymc', 1),
'potential': ('real', 'scalar', 'Ym', 1),
'sfield': ('real', 'scalar', 'Ymc', 1),
}
variables = {
# displacement
'u': ('unknown field', 'displacement'),
'v': ('test field', 'displacement', 'u'),
'Pi_u': ('parameter field', 'displacement', 'u'),
'U1': ('parameter field', 'displacement', '(set-to-None)'),
'U2': ('parameter field', 'displacement', '(set-to-None)'),
# potential
'r': ('unknown field', 'potential'),
's': ('test field', 'potential', 'r'),
'Pi_r': ('parameter field', 'potential', 'r'),
'R1': ('parameter field', 'potential', '(set-to-None)'),
'R2': ('parameter field', 'potential', '(set-to-None)'),
# auxiliary
'svar': ('parameter field', 'sfield', '(set-to-None)'),
}
epbcs = {
'p_ux': (['Left', 'Right'], {
'u.all': 'u.all'
}, 'match_x_plane'),
'p_uy': (['Near', 'Far'], {
'u.all': 'u.all'
}, 'match_y_plane'),
'p_uz': (['Bottom', 'Top'], {
'u.all': 'u.all'
}, 'match_z_plane'),
'p_rx': (['Ym_left', 'Ym_right'], {
'r.0': 'r.0'
}, 'match_x_plane'),
'p_ry': (['Ym_near', 'Ym_far'], {
'r.0': 'r.0'
}, 'match_y_plane'),
'p_rz': (['Ym_bottom', 'Ym_top'], {
'r.0': 'r.0'
}, 'match_z_plane'),
}
periodic = {
'per_u': ['per_u_x', 'per_u_y', 'per_u_z'],
'per_r': ['per_r_x', 'per_r_y', 'per_r_z'],
}
# rescale piezoelectric material parameters
mat_g_sc, mat_d_sc = (eps0, eps0**2)
materials = {
'elastic': ({
'D': {
'Ym':
nm.array([[1.504, 0.656, 0.659, 0, 0, 0],
[0.656, 1.504, 0.659, 0, 0, 0],
[0.659, 0.659, 1.455, 0, 0, 0],
[0, 0, 0, 0.424, 0, 0], [0, 0, 0, 0, 0.439, 0],
[0, 0, 0, 0, 0, 0.439]]) * 1e11,
'Yc':
stiffness_from_youngpoisson(3, 200e9, 0.25)
}
}, ),
'piezo': ({
'g':
nm.array([[0, 0, 0, 0, 11.404, 0], [0, 0, 0, 0, 0, 11.404],
[-4.322, -4.322, 17.360, 0, 0, 0]]) / mat_g_sc,
'd':
nm.array([[1.284, 0, 0], [0, 1.284, 0], [0, 0, 1.505]]) * 1e-8 /
mat_d_sc
}, ),
}
functions = {
'match_x_plane': (per.match_x_plane, ),
'match_y_plane': (per.match_y_plane, ),
'match_z_plane': (per.match_z_plane, ),
}
ebcs = {
'fixed_u': ('Corners', {
'u.all': 0.0
}),
'fixed_r': ('Gamma_ms', {
'r.all': 0.0
}),
'fixed_r1_s1': ('Gamma_s1', {
'r.0': 1.0
}),
'fixed_r0_s1': ('Gamma_s1', {
'r.0': 0.0
}),
'fixed_r1_s2': ('Gamma_s2', {
'r.0': 1.0
}),
'fixed_r0_s2': ('Gamma_s2', {
'r.0': 0.0
}),
}
integrals = {
'i2': 2,
}
solvers = {
'ls_d': ('ls.scipy_direct', {}),
'ls_i': ('ls.scipy_iterative', {}),
'ns_ea6': ('nls.newton', {
'eps_a': 1e6,
'eps_r': 1e-3,
}),
'ns_ea0': ('nls.newton', {
'eps_a': 1e0,
'eps_r': 1e-3,
}),
}
coefs = {
'A1': {
'status':
'auxiliary',
'requires': ['pis_u', 'corrs_rs'],
'expression':
'dw_lin_elastic.i2.Ymc(elastic.D, U1, U2)',
'set_variables': [('U1', ('corrs_rs', 'pis_u'), 'u'),
('U2', ('corrs_rs', 'pis_u'), 'u')],
'class':
cb.CoefSymSym,
},
'A2': {
'status': 'auxiliary',
'requires': ['corrs_rs'],
'expression': 'dw_diffusion.i2.Ym(piezo.d, R1, R2)',
'set_variables': [('R1', 'corrs_rs', 'r'),
('R2', 'corrs_rs', 'r')],
'class': cb.CoefSymSym,
},
'A': {
'requires': ['c.A1', 'c.A2'],
'expression': 'c.A1 + c.A2',
'class': cb.CoefEval,
},
'vol': {
'regions': ['Ym', 'Yc1', 'Yc2'],
'expression': 'ev_volume.i2.%s(svar)',
'class': cb.VolumeFractions,
},
'eps0': {
'requires': [],
'expression': '%e' % eps0,
'class': cb.CoefEval,
},
'filenames': {},
}
requirements = {
'pis_u': {
'variables': ['u'],
'class': cb.ShapeDimDim,
},
'pis_r': {
'variables': ['r'],
'class': cb.ShapeDim,
},
'corrs_rs': {
'requires': ['pis_u'],
'ebcs': ['fixed_u', 'fixed_r'],
'epbcs': ['p_ux', 'p_uy', 'p_uz', 'p_rx', 'p_ry', 'p_rz'],
'equations': {
'eq1':
"""dw_lin_elastic.i2.Ymc(elastic.D, v, u)
- dw_piezo_coupling.i2.Ym(piezo.g, v, r)
= - dw_lin_elastic.i2.Ymc(elastic.D, v, Pi_u)""",
'eq2':
"""
- dw_piezo_coupling.i2.Ym(piezo.g, u, s)
- dw_diffusion.i2.Ym(piezo.d, s, r)
= dw_piezo_coupling.i2.Ym(piezo.g, Pi_u, s)""",
},
'set_variables': [('Pi_u', 'pis_u', 'u')],
'class': cb.CorrDimDim,
'save_name': 'corrs_rs',
'solvers': {
'ls': 'ls_i',
'nls': 'ns_ea6'
},
},
}
# define requirements and coefficients related to conductors
bc_conductors = [
['fixed_r1_s1', 'fixed_r0_s2'], # phi = 1 on S1, phi = 0 on S2
['fixed_r1_s2', 'fixed_r0_s1'], # phi = 0 on S1, phi = 1 on S2
]
for k in range(2):
sk = '%d' % k
requirements.update({
'corrs_k' + sk: {
'requires': ['pis_r'],
'ebcs': ['fixed_u'] + bc_conductors[k],
'epbcs': ['p_ux', 'p_uy', 'p_uz', 'p_rx', 'p_ry', 'p_rz'],
'equations': {
'eq1':
"""dw_lin_elastic.i2.Ymc(elastic.D, v, u)
- dw_piezo_coupling.i2.Ym(piezo.g, v, r)
= 0""",
'eq2':
"""
- dw_piezo_coupling.i2.Ym(piezo.g, u, s)
- dw_diffusion.i2.Ym(piezo.d, s, r)
= 0"""
},
'class': cb.CorrOne,
'save_name': 'corrs_k' + sk,
'solvers': {
'ls': 'ls_d',
'nls': 'ns_ea0'
},
},
})
coefs.update({
'V1_' + sk: {
'status':
'auxiliary',
'requires': ['pis_u', 'corrs_k' + sk],
'expression':
'dw_lin_elastic.i2.Ymc(elastic.D, U1, U2)',
'set_variables': [('U1', 'corrs_k' + sk, 'u'),
('U2', 'pis_u', 'u')],
'class':
cb.CoefSym,
},
'V2_' + sk: {
'status':
'auxiliary',
'requires': ['pis_u', 'corrs_k' + sk],
'expression':
'dw_piezo_coupling.i2.Ym(piezo.g, U1, R1)',
'set_variables': [('R1', 'corrs_k' + sk, 'r'),
('U1', 'pis_u', 'u')],
'class':
cb.CoefSym,
},
'V' + sk: {
'requires': ['c.V1_' + sk, 'c.V2_' + sk],
'expression': 'c.V1_%s - c.V2_%s' % (sk, sk),
'class': cb.CoefEval,
},
})
return locals()
def define(filename_mesh=None):
eta = 3.6e-3
if filename_mesh is None:
filename_mesh = osp.join(data_dir, 'meso_perf_2ch_puc.vtk')
# filename_mesh = osp.join(data_dir, 'perf_mic_2chbx.vtk')
mesh = Mesh.from_file(filename_mesh)
poroela_micro_file = osp.join(data_dir, 'perf_BD2B_mic.py')
dim = 3
sym = (dim + 1) * dim // 2
sym_eye = 'nm.array([1,1,0])' if dim == 2 else 'nm.array([1,1,1,0,0,0])'
bbox = mesh.get_bounding_box()
regions = define_box_regions(mesh.dim, bbox[0], bbox[1], eps=1e-3)
regions.update({
'Z':
'all',
'Gamma_Z': ('vertices of surface', 'facet'),
# matrix
'Zm':
'cells of group 3',
'Zm_left': ('r.Zm *v r.Left', 'vertex'),
'Zm_right': ('r.Zm *v r.Right', 'vertex'),
'Zm_bottom': ('r.Zm *v r.Bottom', 'vertex'),
'Zm_top': ('r.Zm *v r.Top', 'vertex'),
"Gamma_Zm": ('(r.Zm *v r.Zc1) +v (r.Zm *v r.Zc2)', 'facet', 'Zm'),
'Gamma_Zm1': ('r.Zm *v r.Zc1', 'facet', 'Zm'),
'Gamma_Zm2': ('r.Zm *v r.Zc2', 'facet', 'Zm'),
# first canal
'Zc1':
'cells of group 1',
'Zc01': ('r.Zc1 -v r.Gamma_Zc1', 'vertex'),
'Zc1_left': ('r.Zc01 *v r.Left', 'vertex'),
'Zc1_right': ('r.Zc01 *v r.Right', 'vertex'),
# 'Zc1_bottom': ('r.Zc01 *v r.Bottom', 'vertex'),
# 'Zc1_top': ('r.Zc01 *v r.Top', 'vertex'),
'Gamma_Zc1': ('r.Zm *v r.Zc1', 'facet', 'Zc1'),
'Center_c1': ('vertex 973', 'vertex'), # canal center
# 'Center_c1': ('vertex 1200', 'vertex'), # canal center
# second canal
'Zc2':
'cells of group 2',
'Zc02': ('r.Zc2 -v r.Gamma_Zc2', 'vertex'),
'Zc2_left': ('r.Zc02 *v r.Left', 'vertex'),
'Zc2_right': ('r.Zc02 *v r.Right', 'vertex'),
# 'Zc2_bottom': ('r.Zc02 *v r.Bottom', 'vertex'),
# 'Zc2_top': ('r.Zc02 *v r.Top', 'vertex'),
'Gamma_Zc2': ('r.Zm *v r.Zc2', 'facet', 'Zc2'),
'Center_c2': ('vertex 487', 'vertex'), # canal center
# 'Center_c2': ('vertex 1254', 'vertex'), # canal center
})
if dim == 3:
regions.update({
'Zm_far': ('r.Zm *v r.Far', 'vertex'),
'Zm_near': ('r.Zm *v r.Near', 'vertex'),
# 'Zc1_far': ('r.Zc01 *v r.Far', 'vertex'),
# 'Zc1_near': ('r.Zc01 *v r.Near', 'vertex'),
# 'Zc2_far': ('r.Zc02 *v r.Far', 'vertex'),
# 'Zc2_near': ('r.Zc02 *v r.Near', 'vertex'),
})
fields = {
'one': ('real', 'scalar', 'Z', 1),
'displacement': ('real', 'vector', 'Zm', 1),
'pressure_m': ('real', 'scalar', 'Zm', 1),
'pressure_c1': ('real', 'scalar', 'Zc1', 1),
'displacement_c1': ('real', 'vector', 'Zc1', 1),
'velocity1': ('real', 'vector', 'Zc1', 2),
'pressure_c2': ('real', 'scalar', 'Zc2', 1),
'displacement_c2': ('real', 'vector', 'Zc2', 1),
'velocity2': ('real', 'vector', 'Zc2', 2),
}
variables = {
# displacement
'u': ('unknown field', 'displacement', 0),
'v': ('test field', 'displacement', 'u'),
'Pi_u': ('parameter field', 'displacement', 'u'),
'U1': ('parameter field', 'displacement', '(set-to-None)'),
'U2': ('parameter field', 'displacement', '(set-to-None)'),
'uc1': ('unknown field', 'displacement_c1', 6),
'vc1': ('test field', 'displacement_c1', 'uc1'),
'uc2': ('unknown field', 'displacement_c2', 7),
'vc2': ('test field', 'displacement_c2', 'uc2'),
# velocity in canal 1
'w1': ('unknown field', 'velocity1', 1),
'z1': ('test field', 'velocity1', 'w1'),
'Pi_w1': ('parameter field', 'velocity1', 'w1'),
'par1_w1': ('parameter field', 'velocity1', '(set-to-None)'),
'par2_w1': ('parameter field', 'velocity1', '(set-to-None)'),
# velocity in canal 2
'w2': ('unknown field', 'velocity2', 2),
'z2': ('test field', 'velocity2', 'w2'),
'Pi_w2': ('parameter field', 'velocity2', 'w2'),
'par1_w2': ('parameter field', 'velocity2', '(set-to-None)'),
'par2_w2': ('parameter field', 'velocity2', '(set-to-None)'),
# pressure
'pm': ('unknown field', 'pressure_m', 3),
'qm': ('test field', 'pressure_m', 'pm'),
'Pm1': ('parameter field', 'pressure_m', '(set-to-None)'),
'Pm2': ('parameter field', 'pressure_m', '(set-to-None)'),
'Pi_pm': ('parameter field', 'pressure_m', 'pm'),
'pc1': ('unknown field', 'pressure_c1', 4),
'qc1': ('test field', 'pressure_c1', 'pc1'),
'par1_pc1': ('parameter field', 'pressure_c1', '(set-to-None)'),
'par2_pc1': ('parameter field', 'pressure_c1', '(set-to-None)'),
'pc2': ('unknown field', 'pressure_c2', 5),
'qc2': ('test field', 'pressure_c2', 'pc2'),
'par1_pc2': ('parameter field', 'pressure_c2', '(set-to-None)'),
'par2_pc2': ('parameter field', 'pressure_c2', '(set-to-None)'),
# one
'one': ('parameter field', 'one', '(set-to-None)'),
}
functions = {
'match_x_plane': (per.match_x_plane,),
'match_y_plane': (per.match_y_plane,),
'match_z_plane': (per.match_z_plane,),
'get_homog': (lambda ts, coors, mode=None, problem=None, **kwargs:\
get_homog(coors, mode, problem, poroela_micro_file, **kwargs),),
}
materials = {
'hmatrix':
'get_homog',
'fluid': ({
'eta_c': eta * nm.eye(dim2sym(dim)),
}, ),
'mat': ({
'k1': nm.array([[1, 0, 0]]).T,
'k2': nm.array([[0, 1, 0]]).T,
'k3': nm.array([[0, 0, 1]]).T,
}, ),
}
ebcs = {
'fixed_u': ('Corners', {
'um.all': 0.0
}),
'fixed_pm': ('Corners', {
'p.0': 0.0
}),
'fixed_w1': ('Center_c1', {
'w1.all': 0.0
}),
'fixed_w2': ('Center_c2', {
'w2.all': 0.0
}),
}
epbcs, periodic = get_periodic_bc([('u', 'Zm'), ('pm', 'Zm'),
('pc1', 'Zc1'), ('w1', 'Zc1'),
('pc2', 'Zc2'), ('w2', 'Zc2')])
all_periodic1 = periodic['per_w1'] + periodic['per_pc1']
all_periodic2 = periodic['per_w2'] + periodic['per_pc2']
integrals = {
'i': 4,
}
options = {
'coefs': 'coefs',
'coefs_filename': 'coefs_meso',
'requirements': 'requirements',
'volume': {
'variables': ['u', 'pc1', 'pc2'],
'expression':
'd_volume.i.Zm(u) + d_volume.i.Zc1(pc1)+d_volume.i.Zc2(pc2)',
},
'output_dir': data_dir + '/results/meso',
'file_per_var': True,
'save_format': 'vtk', # Global setting.
'dump_format': 'h5', # Global setting.
'absolute_mesh_path': True,
'multiprocessing': False,
'ls': 'ls',
'nls': 'ns_m15',
'output_prefix': 'Meso:',
}
solvers = {
'ls': ('ls.mumps', {}),
'ls_s1': ('ls.schur_mumps', {
'schur_variables': ['pc1'],
'fallback': 'ls'
}),
'ls_s2': ('ls.schur_mumps', {
'schur_variables': ['pc2'],
'fallback': 'ls'
}),
'ns': ('nls.newton', {
'i_max': 1,
'eps_a': 1e-14,
'eps_r': 1e-3,
'problem': 'nonlinear'
}),
'ns_em15': ('nls.newton', {
'i_max': 1,
'eps_a': 1e-15,
'eps_r': 1e-3,
'problem': 'nonlinear'
}),
'ns_em12': ('nls.newton', {
'i_max': 1,
'eps_a': 1e-12,
'eps_r': 1e-3,
'problem': 'nonlinear'
}),
'ns_em9': ('nls.newton', {
'i_max': 1,
'eps_a': 1e-9,
'eps_r': 1e-3,
'problem': 'nonlinear'
}),
'ns_em6': ('nls.newton', {
'i_max': 1,
'eps_a': 1e-4,
'eps_r': 1e-3,
'problem': 'nonlinear'
}),
}
#Definition of homogenized coefficients, see (33)-(35)
coefs = {
'A': {
'requires': ['pis_u', 'corrs_omega_ij'],
'expression':
'dw_lin_elastic.i.Zm(hmatrix.A, U1, U2)',
'set_variables': [('U1', ('corrs_omega_ij', 'pis_u'), 'u'),
('U2', ('corrs_omega_ij', 'pis_u'), 'u')],
'class':
cb.CoefSymSym,
},
'B_aux1': {
'status': 'auxiliary',
'requires': ['corrs_omega_ij'],
'expression': '- dw_surface_ltr.i.Gamma_Zm(U1)', # !!! -
'set_variables': [('U1', 'corrs_omega_ij', 'u')],
'class': cb.CoefSym,
},
'B_aux2': {
'status':
'auxiliary',
'requires': ['corrs_omega_ij', 'pis_u', 'corr_one'],
'expression':
'dw_biot.i.Zm(hmatrix.B, U1, one)',
'set_variables': [('U1', ('corrs_omega_ij', 'pis_u'), 'u'),
('one', 'corr_one', 'one')],
'class':
cb.CoefSym,
},
'B': {
'requires': ['c.B_aux1', 'c.B_aux2', 'c.vol_c'],
'expression': 'c.B_aux1 + c.B_aux2 + c.vol_c* %s' % sym_eye,
'class': cb.CoefEval,
},
'H11': {
'requires': ['corrs_phi_k_1'],
'expression':
'dw_diffusion.i.Zm(hmatrix.K, Pm1, Pm2)',
'set_variables': [('Pm1', 'corrs_phi_k_1', 'pm'),
('Pm2', 'corrs_phi_k_1', 'pm')],
'class':
cb.CoefDimDim,
},
'H12': {
'requires': ['corrs_phi_k_1', 'corrs_phi_k_2'],
'expression':
'dw_diffusion.i.Zm(hmatrix.K, Pm1, Pm2)',
'set_variables': [('Pm1', 'corrs_phi_k_1', 'pm'),
('Pm2', 'corrs_phi_k_2', 'pm')],
'class':
cb.CoefDimDim,
},
'H21': {
'requires': ['corrs_phi_k_1', 'corrs_phi_k_2'],
'expression':
'dw_diffusion.i.Zm(hmatrix.K, Pm1, Pm2)',
'set_variables': [('Pm1', 'corrs_phi_k_2', 'pm'),
('Pm2', 'corrs_phi_k_1', 'pm')],
'class':
cb.CoefDimDim,
},
'H22': {
'requires': ['corrs_phi_k_2'],
'expression':
'dw_diffusion.i.Zm(hmatrix.K, Pm1, Pm2)',
'set_variables': [('Pm1', 'corrs_phi_k_2', 'pm'),
('Pm2', 'corrs_phi_k_2', 'pm')],
'class':
cb.CoefDimDim,
},
'K': {
'requires': ['corrs_pi_k', 'pis_pm'],
'expression':
'dw_diffusion.i.Zm(hmatrix.K, Pm1, Pm2)',
'set_variables': [('Pm1', ('corrs_pi_k', 'pis_pm'), 'pm'),
('Pm2', ('corrs_pi_k', 'pis_pm'), 'pm')],
'class':
cb.CoefDimDim,
},
'Q1': {
'requires': ['corrs_phi_k_1', 'pis_pm'],
'expression':
'dw_diffusion.i.Zm(hmatrix.K, Pm1, Pm2)',
'set_variables': [('Pm1', 'pis_pm', 'pm'),
('Pm2', 'corrs_phi_k_1', 'pm')],
'class':
cb.CoefDimDim,
},
'P1': {
'requires': ['c.Q1', 'c.vol'],
'expression': 'c.vol["fraction_Zc1"] * nm.eye(%d) - c.Q1' % dim,
'class': cb.CoefEval,
},
'P1T': {
'requires': ['c.P1'],
'expression': 'c.P1.T',
'class': cb.CoefEval,
},
'Q2': {
'requires': ['corrs_phi_k_2', 'pis_pm'],
'expression':
'dw_diffusion.i.Zm(hmatrix.K, Pm1, Pm2)',
'set_variables': [('Pm1', 'pis_pm', 'pm'),
('Pm2', 'corrs_phi_k_2', 'pm')],
'class':
cb.CoefDimDim,
},
'P2': {
'requires': ['c.Q2', 'c.vol'],
'expression': 'c.vol["fraction_Zc2"] * nm.eye(%d) - c.Q2' % dim,
'class': cb.CoefEval,
},
'P2T': {
'requires': ['c.P2'],
'expression': 'c.P2.T',
'class': cb.CoefEval,
},
'M_aux1': {
'status': 'auxiliary',
'requires': [],
'expression': 'ev_volume_integrate_mat.i.Zm(hmatrix.M, one)',
'set_variables': [],
'class': cb.CoefOne,
},
'M_aux2': {
'status':
'auxiliary',
'requires': ['corrs_omega_p', 'corr_one'],
'expression':
'dw_biot.i.Zm(hmatrix.B, U1, one)',
'set_variables': [('U1', 'corrs_omega_p', 'u'),
('one', 'corr_one', 'one')],
'class':
cb.CoefOne,
},
'M_aux3': {
'status': 'auxiliary',
'requires': ['corrs_omega_p'],
'expression': ' dw_surface_ltr.i.Gamma_Zm(U1)',
'set_variables': [('U1', 'corrs_omega_p', 'u')],
'class': cb.CoefOne,
},
'M': {
'requires': ['c.M_aux1', 'c.M_aux2', 'c.M_aux3'],
'expression': 'c.M_aux1 + c.M_aux2 -c.M_aux3 ',
'class': cb.CoefEval,
},
'S1': {
'requires': ['corrs_psi_ij_1', 'pis_w1'],
'expression':
'dw_lin_elastic.i.Zc1(fluid.eta_c, par1_w1, par2_w1)',
'set_variables': [('par1_w1', ('corrs_psi_ij_1', 'pis_w1'), 'w1'),
('par2_w1', ('corrs_psi_ij_1', 'pis_w1'), 'w1')],
'class':
cb.CoefSymSym,
},
'S2': {
'requires': ['corrs_psi_ij_2', 'pis_w2'],
'expression':
'dw_lin_elastic.i.Zc2(fluid.eta_c, par1_w2, par2_w2)',
'set_variables': [('par1_w2', ('corrs_psi_ij_2', 'pis_w2'), 'w2'),
('par2_w2', ('corrs_psi_ij_2', 'pis_w2'), 'w2')],
'class':
cb.CoefSymSym,
},
'vol': {
'regions': ['Zm', 'Zc1', 'Zc2'],
'expression': 'd_volume.i.%s(one)',
'class': cb.VolumeFractions,
},
'surf_vol': {
'regions': ['Zm', 'Zc1', 'Zc2'],
'expression': 'd_surface.i.%s(one)',
'class': cb.VolumeFractions,
},
'surf_c': {
'requires': ['c.surf_vol'],
'expression':
'c.surf_vol["fraction_Zc1"]+c.surf_vol["fraction_Zc2"]',
'class': cb.CoefEval,
},
'vol_c': {
'requires': ['c.vol'],
'expression': 'c.vol["fraction_Zc1"]+c.vol["fraction_Zc2"]',
'class': cb.CoefEval,
},
'filenames': {},
}
#Definition of mesoscopic corrector problems
requirements = {
'corr_one': {
'variable': 'one',
'expression':
"nm.ones((problem.fields['one'].n_vertex_dof, 1), dtype=nm.float64)",
'class': cb.CorrEval,
},
'pis_u': {
'variables': ['u'],
'class': cb.ShapeDimDim,
'save_name': 'corrs_pis_u',
'dump_variables': ['u'],
},
'pis_pm': {
'variables': ['pm'],
'class': cb.ShapeDim,
},
'pis_w1': {
'variables': ['w1'],
'class': cb.ShapeDimDim,
},
'pis_w2': {
'variables': ['w2'],
'class': cb.ShapeDimDim,
},
# Corrector problem, see (31)_1
'corrs_omega_ij': {
'requires': ['pis_u'],
'ebcs': ['fixed_u'],
'epbcs': periodic['per_u'],
'is_linear': True,
'equations': {
'balance_of_forces':
"""dw_lin_elastic.i.Zm(hmatrix.A, v, u)
= - dw_lin_elastic.i.Zm(hmatrix.A, v, Pi_u)"""
},
'set_variables': [('Pi_u', 'pis_u', 'u')],
'class': cb.CorrDimDim,
'save_name': 'corrs_omega_ij',
'dump_variables': ['u'],
'solvers': {
'ls': 'ls',
'nls': 'ns_em6'
},
'is_linear': True,
},
# Corrector problem, see (31)_2
'corrs_omega_p': {
'requires': ['corr_one'],
'ebcs': ['fixed_u'],
'epbcs': periodic['per_u'],
'equations': {
'balance_of_forces':
"""dw_lin_elastic.i.Zm(hmatrix.A, v, u)
= dw_biot.i.Zm(hmatrix.B, v, one)
- dw_surface_ltr.i.Gamma_Zm(v)""",
},
'set_variables': [('one', 'corr_one', 'one')],
'class': cb.CorrOne,
'save_name': 'corrs_omega_p',
'dump_variables': ['u'],
'solvers': {
'ls': 'ls',
'nls': 'ns_em9'
},
},
# Corrector problem, see (31)_3
'corrs_pi_k': {
'requires': ['pis_pm'],
'ebcs': [], # ['fixed_pm'],
'epbcs': periodic['per_pm'],
'is_linear': True,
'equations': {
'eq':
"""dw_diffusion.i.Zm(hmatrix.K, qm, pm)
= - dw_diffusion.i.Zm(hmatrix.K, qm, Pi_pm)""",
},
'set_variables': [('Pi_pm', 'pis_pm', 'pm')],
'class': cb.CorrDim,
'save_name': 'corrs_pi_k',
'dump_variables': ['pm'],
'solvers': {
'ls': 'ls',
'nls': 'ns_em12'
},
},
# Corrector problem, see (31)_4
'corrs_phi_k_1': {
'requires': [],
'ebcs': [],
'epbcs': periodic['per_pm'],
'equations': {
'eq':
"""dw_diffusion.i.Zm(hmatrix.K, qm, pm)
= - dw_surface_ndot.i.Gamma_Zm1(mat.k%d, qm)""",
},
'class': cb.CorrEqPar,
'eq_pars': [(ii + 1) for ii in range(dim)],
'save_name': 'corrs_phi_k_1',
'dump_variables': ['pm'],
'solvers': {
'ls': 'ls',
'nls': 'ns_em9'
},
},
'corrs_phi_k_2': {
'requires': [],
'ebcs': [],
'epbcs': periodic['per_pm'],
'equations': {
'eq':
"""dw_diffusion.i.Zm(hmatrix.K, qm, pm)
= - dw_surface_ndot.i.Gamma_Zm2(mat.k%d, qm)""",
},
'class': cb.CorrEqPar,
'eq_pars': [(ii + 1) for ii in range(dim)],
'save_name': 'corrs_phi_k_2',
'dump_variables': ['pm'],
'solvers': {
'ls': 'ls',
'nls': 'ns_em9'
},
},
# Corrector problem, see (32)
'corrs_psi_ij_1': {
'requires': ['pis_w1'],
'ebcs': ['fixed_w1'],
'epbcs': periodic['per_w1'] + periodic['per_pc1'],
'equations': {
'eq1':
"""2*dw_lin_elastic.i.Zc1(fluid.eta_c, z1, w1)
- dw_stokes.i.Zc1(z1, pc1)
= - 2*dw_lin_elastic.i.Zc1(fluid.eta_c, z1, Pi_w1)""",
'eq2':
"""dw_stokes.i.Zc1(w1, qc1)
= - dw_stokes.i.Zc1(Pi_w1, qc1)"""
},
'set_variables': [('Pi_w1', 'pis_w1', 'w1')],
'class': cb.CorrDimDim,
'save_name': 'corrs_psi_ij_1',
'dump_variables': ['w1', 'pc1'],
'solvers': {
'ls': 'ls',
'nls': 'ns_em15'
},
# 'solvers': {'ls': 'ls_s1', 'nls': 'ns_em15'},
'is_linear': True,
},
'corrs_psi_ij_2': {
'requires': ['pis_w2'],
'ebcs': ['fixed_w2'],
'epbcs': periodic['per_w2'] + periodic['per_pc2'],
'equations': {
'eq1':
"""2*dw_lin_elastic.i.Zc2(fluid.eta_c, z2, w2)
- dw_stokes.i.Zc2(z2, pc2)
= - 2*dw_lin_elastic.i.Zc2(fluid.eta_c, z2, Pi_w2)""",
'eq2':
"""dw_stokes.i.Zc2(w2, qc2)
= - dw_stokes.i.Zc2(Pi_w2, qc2)"""
},
'set_variables': [('Pi_w2', 'pis_w2', 'w2')],
'class': cb.CorrDimDim,
'save_name': 'corrs_psi_ij_1',
'dump_variables': ['w2', 'pc2'],
'solvers': {
'ls': 'ls',
'nls': 'ns_em15'
},
# 'solvers': {'ls': 'ls_s2', 'nls': 'ns_em15'},
'is_linear': True,
},
}
return locals()
def main(cli_args):
dims = parse_argument_list(cli_args.dims, float)
shape = parse_argument_list(cli_args.shape, int)
centre = parse_argument_list(cli_args.centre, float)
material_parameters = parse_argument_list(cli_args.material_parameters,
float)
order = cli_args.order
ts_vals = cli_args.ts.split(',')
ts = {
't0' : float(ts_vals[0]), 't1' : float(ts_vals[1]),
'n_step' : int(ts_vals[2])}
do_plot = cli_args.plot
### Mesh and regions ###
mesh = gen_block_mesh(
dims, shape, centre, name='block', verbose=False)
domain = FEDomain('domain', mesh)
omega = domain.create_region('Omega', 'all')
lbn, rtf = domain.get_mesh_bounding_box()
box_regions = define_box_regions(3, lbn, rtf)
regions = dict([
[r, domain.create_region(r, box_regions[r][0], box_regions[r][1])]
for r in box_regions])
### Fields ###
scalar_field = Field.from_args(
'fu', np.float64, 'scalar', omega, approx_order=order-1)
vector_field = Field.from_args(
'fv', np.float64, 'vector', omega, approx_order=order)
u = FieldVariable('u', 'unknown', vector_field, history=1)
v = FieldVariable('v', 'test', vector_field, primary_var_name='u')
p = FieldVariable('p', 'unknown', scalar_field, history=1)
q = FieldVariable('q', 'test', scalar_field, primary_var_name='p')
### Material ###
c10, c01 = material_parameters
m = Material(
'm', mu=2*c10, kappa=2*c01,
)
### Boundary conditions ###
x_sym = EssentialBC('x_sym', regions['Left'], {'u.0' : 0.0})
y_sym = EssentialBC('y_sym', regions['Near'], {'u.1' : 0.0})
z_sym = EssentialBC('z_sym', regions['Bottom'], {'u.2' : 0.0})
disp_fun = Function('disp_fun', get_displacement)
displacement = EssentialBC(
'displacement', regions['Right'], {'u.0' : disp_fun})
ebcs = Conditions([x_sym, y_sym, z_sym, displacement])
### Terms and equations ###
integral = Integral('i', order=2*order)
term_neohook = Term.new(
'dw_tl_he_neohook(m.mu, v, u)',
integral, omega, m=m, v=v, u=u)
term_mooney = Term.new(
'dw_tl_he_mooney_rivlin(m.kappa, v, u)',
integral, omega, m=m, v=v, u=u)
term_pressure = Term.new(
'dw_tl_bulk_pressure(v, u, p)',
integral, omega, v=v, u=u, p=p)
term_volume_change = Term.new(
'dw_tl_volume(q, u)',
integral, omega, q=q, u=u, term_mode='volume')
term_volume = Term.new(
'dw_volume_integrate(q)',
integral, omega, q=q)
eq_balance = Equation('balance', term_neohook+term_mooney+term_pressure)
eq_volume = Equation('volume', term_volume_change-term_volume)
equations = Equations([eq_balance, eq_volume])
### Solvers ###
ls = ScipyDirect({})
nls_status = IndexedStruct()
nls = Newton(
{'i_max' : 5},
lin_solver=ls, status=nls_status
)
### Problem ###
pb = Problem('hyper', equations=equations)
pb.set_bcs(ebcs=ebcs)
pb.set_ics(ics=Conditions([]))
tss = SimpleTimeSteppingSolver(ts, nls=nls, context=pb)
pb.set_solver(tss)
### Solution ###
axial_stress = []
axial_displacement = []
def stress_strain_fun(*args, **kwargs):
return stress_strain(
*args, order=order, global_stress=axial_stress,
global_displacement=axial_displacement, **kwargs)
pb.solve(save_results=True, post_process_hook=stress_strain_fun)
if do_plot:
plot_graphs(
material_parameters, axial_stress, axial_displacement,
undeformed_length=dims[0])
'min_level': 0, # Min. refinement level to achieve everywhere.
'max_level': 5, # Max. refinement level.
'eps': 1e-3, # Relative error tolerance.
},
}
materials = {
'coef': ({
'val': 1.0
}, ),
}
regions = {
'Omega': ('all', {}),
}
regions.update(define_box_regions(dim, bbox[0], bbox[1], 1e-5))
fields = {
'temperature': ('real', 1, 'Omega', 5, 'H1', 'lobatto'),
# Compare with the Lagrange basis.
## 'temperature' : ('real', 1, 'Omega', 5, 'H1', 'lagrange'),
}
variables = {
't': ('unknown field', 'temperature', 0),
's': ('test field', 'temperature', 't'),
}
amplitude = 1.0
variables = {
'u': ('unknown field', 'displacement'),
'v': ('test field', 'displacement', 'u'),
'Pi': ('parameter field', 'displacement', 'u'),
'Pi1u': ('parameter field', 'displacement', '(set-to-None)'),
'Pi2u': ('parameter field', 'displacement', '(set-to-None)'),
}
regions = {
'Y': 'all',
'Ym': 'cells of group 1',
'Yc': 'cells of group 2',
}
regions.update(define_box_regions(dim, (0., 0.), (1., 1.)))
ebcs = {
'fixed_u': ('Corners', {
'u.all': 0.0
}),
}
epbcs = {
'periodic_ux': (['Left', 'Right'], {
'u.all': 'u.all'
}, 'match_x_plane'),
'periodic_uy': (['Bottom', 'Top'], {
'u.all': 'u.all'
}, 'match_y_plane'),
}
def define(eps0=1e-3, filename_mesh='meshes/3d/piezo_mesh_micro.vtk'):
mesh = Mesh.from_file(filename_mesh)
bbox = mesh.get_bounding_box()
regions = define_box_regions(mesh.dim, bbox[0], bbox[1], eps=1e-3)
regions.update({
'Ymc': 'all',
# matrix
'Ym': 'cells of group 1',
'Ym_left': ('r.Ym *v r.Left', 'vertex'),
'Ym_right': ('r.Ym *v r.Right', 'vertex'),
'Ym_bottom': ('r.Ym *v r.Bottom', 'vertex'),
'Ym_top': ('r.Ym *v r.Top', 'vertex'),
'Ym_far': ('r.Ym *v r.Far', 'vertex'),
'Ym_near': ('r.Ym *v r.Near', 'vertex'),
'Gamma_ms': ('r.Ym *v r.Yc', 'facet', 'Ym'),
# conductors
'Yc': ('r.Yc1 +c r.Yc2', 'cell'),
'Yc1': 'cells of group 2',
'Yc2': 'cells of group 3',
'Gamma_s1': ('r.Ym *v r.Yc1', 'facet', 'Ym'),
'Gamma_s2': ('r.Ym *v r.Yc2', 'facet', 'Ym'),
})
options = {
'coefs_filename': 'coefs_piezo',
'volume': {'value': nm.prod(bbox[1] - bbox[0])},
'coefs': 'coefs',
'requirements': 'requirements',
'output_dir': 'output',
'file_per_var': True,
'absolute_mesh_path': True,
'multiprocessing': False,
'recovery_hook': recovery_micro,
}
fields = {
'displacement': ('real', 'vector', 'Ymc', 1),
'potential': ('real', 'scalar', 'Ym', 1),
'sfield': ('real', 'scalar', 'Ymc', 1),
}
variables = {
# displacement
'u': ('unknown field', 'displacement'),
'v': ('test field', 'displacement', 'u'),
'Pi_u': ('parameter field', 'displacement', 'u'),
'U1': ('parameter field', 'displacement', '(set-to-None)'),
'U2': ('parameter field', 'displacement', '(set-to-None)'),
# potential
'r': ('unknown field', 'potential'),
's': ('test field', 'potential', 'r'),
'Pi_r': ('parameter field', 'potential', 'r'),
'R1': ('parameter field', 'potential', '(set-to-None)'),
'R2': ('parameter field', 'potential', '(set-to-None)'),
# auxiliary
'svar': ('parameter field', 'sfield', '(set-to-None)'),
}
epbcs = {
'p_ux': (['Left', 'Right'], {'u.all': 'u.all'}, 'match_x_plane'),
'p_uy': (['Near', 'Far'], {'u.all': 'u.all'}, 'match_y_plane'),
'p_uz': (['Bottom', 'Top'], {'u.all': 'u.all'}, 'match_z_plane'),
'p_rx': (['Ym_left', 'Ym_right'], {'r.0': 'r.0'}, 'match_x_plane'),
'p_ry': (['Ym_near', 'Ym_far'], {'r.0': 'r.0'}, 'match_y_plane'),
'p_rz': (['Ym_bottom', 'Ym_top'], {'r.0': 'r.0'}, 'match_z_plane'),
}
periodic = {
'per_u': ['per_u_x', 'per_u_y', 'per_u_z'],
'per_r': ['per_r_x', 'per_r_y', 'per_r_z'],
}
# rescale piezoelectric material parameters
mat_g_sc, mat_d_sc = (eps0, eps0**2)
materials = {
'elastic': ({
'D': {
'Ym': nm.array([[1.504, 0.656, 0.659, 0, 0, 0],
[0.656, 1.504, 0.659, 0, 0, 0],
[0.659, 0.659, 1.455, 0, 0, 0],
[0, 0, 0, 0.424, 0, 0],
[0, 0, 0, 0, 0.439, 0],
[0, 0, 0, 0, 0, 0.439]]) * 1e11,
'Yc': stiffness_from_youngpoisson(3, 200e9, 0.25)}},),
'piezo': ({
'g': nm.array([[0, 0, 0, 0, 11.404, 0],
[0, 0, 0, 0, 0, 11.404],
[-4.322, -4.322, 17.360, 0, 0, 0]]) / mat_g_sc,
'd': nm.array([[1.284, 0, 0],
[0, 1.284, 0],
[0, 0, 1.505]]) * 1e-8 / mat_d_sc},),
}
functions = {
'match_x_plane': (per.match_x_plane,),
'match_y_plane': (per.match_y_plane,),
'match_z_plane': (per.match_z_plane,),
}
ebcs = {
'fixed_u': ('Corners', {'u.all': 0.0}),
'fixed_r': ('Gamma_ms', {'r.all': 0.0}),
'fixed_r1_s1': ('Gamma_s1', {'r.0': 1.0}),
'fixed_r0_s1': ('Gamma_s1', {'r.0': 0.0}),
'fixed_r1_s2': ('Gamma_s2', {'r.0': 1.0}),
'fixed_r0_s2': ('Gamma_s2', {'r.0': 0.0}),
}
integrals = {
'i2': 2,
}
solvers = {
'ls_d': ('ls.scipy_direct', {}),
'ls_i': ('ls.scipy_iterative', {}),
'ns_ea6': ('nls.newton', {'eps_a': 1e6, 'eps_r': 1e-3,}),
'ns_ea0': ('nls.newton', {'eps_a': 1e0, 'eps_r': 1e-3,}),
}
coefs = {
'A1': {
'status': 'auxiliary',
'requires': ['pis_u', 'corrs_rs'],
'expression': 'dw_lin_elastic.i2.Ymc(elastic.D, U1, U2)',
'set_variables': [('U1', ('corrs_rs', 'pis_u'), 'u'),
('U2', ('corrs_rs', 'pis_u'), 'u')],
'class': cb.CoefSymSym,
},
'A2': {
'status': 'auxiliary',
'requires': ['corrs_rs'],
'expression': 'dw_diffusion.i2.Ym(piezo.d, R1, R2)',
'set_variables': [('R1', 'corrs_rs', 'r'),
('R2', 'corrs_rs', 'r')],
'class': cb.CoefSymSym,
},
'A': {
'requires': ['c.A1', 'c.A2'],
'expression': 'c.A1 + c.A2',
'class': cb.CoefEval,
},
'vol': {
'regions': ['Ym', 'Yc1', 'Yc2'],
'expression': 'd_volume.i2.%s(svar)',
'class': cb.VolumeFractions,
},
'eps0': {
'requires': [],
'expression': '%e' % eps0,
'class': cb.CoefEval,
},
'filenames': {},
}
requirements = {
'pis_u': {
'variables': ['u'],
'class': cb.ShapeDimDim,
},
'pis_r': {
'variables': ['r'],
'class': cb.ShapeDim,
},
'corrs_rs': {
'requires': ['pis_u'],
'ebcs': ['fixed_u', 'fixed_r'],
'epbcs': ['p_ux', 'p_uy', 'p_uz', 'p_rx', 'p_ry', 'p_rz'],
'equations': {
'eq1':
"""dw_lin_elastic.i2.Ymc(elastic.D, v, u)
- dw_piezo_coupling.i2.Ym(piezo.g, v, r)
= - dw_lin_elastic.i2.Ymc(elastic.D, v, Pi_u)""",
'eq2':
"""
- dw_piezo_coupling.i2.Ym(piezo.g, u, s)
- dw_diffusion.i2.Ym(piezo.d, s, r)
= dw_piezo_coupling.i2.Ym(piezo.g, Pi_u, s)""",
},
'set_variables': [('Pi_u', 'pis_u', 'u')],
'class': cb.CorrDimDim,
'save_name': 'corrs_rs',
'solvers': {'ls': 'ls_i', 'nls': 'ns_ea6'},
},
}
# define requirements and coefficients related to conductors
bc_conductors = [
['fixed_r1_s1', 'fixed_r0_s2'], # phi = 1 on S1, phi = 0 on S2
['fixed_r1_s2', 'fixed_r0_s1'], # phi = 0 on S1, phi = 1 on S2
]
for k in range(2):
sk = '%d' % k
requirements.update({
'corrs_k' + sk: {
'requires': ['pis_r'],
'ebcs': ['fixed_u'] + bc_conductors[k],
'epbcs': ['p_ux', 'p_uy', 'p_uz', 'p_rx', 'p_ry', 'p_rz'],
'equations': {
'eq1':
"""dw_lin_elastic.i2.Ymc(elastic.D, v, u)
- dw_piezo_coupling.i2.Ym(piezo.g, v, r)
= 0""",
'eq2':
"""
- dw_piezo_coupling.i2.Ym(piezo.g, u, s)
- dw_diffusion.i2.Ym(piezo.d, s, r)
= 0"""
},
'class': cb.CorrOne,
'save_name': 'corrs_k' + sk,
'solvers': {'ls': 'ls_d', 'nls': 'ns_ea0'},
},
})
coefs.update({
'V1_' + sk: {
'status': 'auxiliary',
'requires': ['pis_u', 'corrs_k' + sk],
'expression': 'dw_lin_elastic.i2.Ymc(elastic.D, U1, U2)',
'set_variables': [('U1', 'corrs_k' + sk, 'u'),
('U2', 'pis_u', 'u')],
'class': cb.CoefSym,
},
'V2_' + sk: {
'status': 'auxiliary',
'requires': ['pis_u', 'corrs_k' + sk],
'expression': 'dw_piezo_coupling.i2.Ym(piezo.g, U1, R1)',
'set_variables': [('R1', 'corrs_k' + sk, 'r'),
('U1', 'pis_u', 'u')],
'class': cb.CoefSym,
},
'V' + sk: {
'requires': ['c.V1_' + sk, 'c.V2_' + sk],
'expression': 'c.V1_%s - c.V2_%s' % (sk, sk),
'class': cb.CoefEval,
},
})
return locals()
