def __init__(self, name, dtype, shape, region, approx_order=None,
**kwargs):
"""
Create a Bezier element isogeometric analysis field.
Parameters
----------
name : str
The field name.
dtype : numpy.dtype
The field data type: float64 or complex128.
shape : int/tuple/str
The field shape: 1 or (1,) or 'scalar', space dimension (2, or (2,)
or 3 or (3,)) or 'vector', or a tuple. The field shape determines
the shape of the FE base functions and is related to the number of
components of variables and to the DOF per node count, depending
on the field kind.
region : Region
The region where the field is defined.
approx_order : str or tuple, optional
The field approximation order string or tuple with the first
component in the form 'iga+<nonnegative int>'. Other components are
ignored. The nonnegative int corresponds to the number of times the
degree is elevated by one w.r.t. the domain NURBS description.
**kwargs : dict
Additional keyword arguments.
"""
shape = parse_shape(shape, region.domain.shape.dim)
if approx_order is None:
elevate_times = 0
else:
if isinstance(approx_order, basestr): approx_order = (approx_order,)
elevate_times = parse_approx_order(approx_order[0])
Struct.__init__(self, name=name, dtype=dtype, shape=shape,
region=region, elevate_times=elevate_times)
self.domain = self.region.domain
self.nurbs = self.domain.nurbs.elevate(elevate_times)
self._setup_kind()
self.n_components = nm.prod(self.shape)
self.val_shape = self.shape
self.n_nod = self.nurbs.weights.shape[0]
self.n_efun = nm.prod(self.nurbs.degrees + 1)
self.approx_order = self.nurbs.degrees.max()
self.mappings = {}
self.is_surface = False
def __init__(self, name, dtype, shape, region, approx_order=None,
**kwargs):
"""
Create a Bezier element isogeometric analysis field.
Parameters
----------
name : str
The field name.
dtype : numpy.dtype
The field data type: float64 or complex128.
shape : int/tuple/str
The field shape: 1 or (1,) or 'scalar', space dimension (2, or (2,)
or 3 or (3,)) or 'vector', or a tuple. The field shape determines
the shape of the FE base functions and is related to the number of
components of variables and to the DOF per node count, depending
on the field kind.
region : Region
The region where the field is defined.
approx_order : str or tuple, optional
The field approximation order string or tuple with the first
component in the form 'iga+<nonnegative int>'. Other components are
ignored. The nonnegative int corresponds to the number of times the
degree is elevated by one w.r.t. the domain NURBS description.
**kwargs : dict
Additional keyword arguments.
"""
shape = parse_shape(shape, region.domain.shape.dim)
if approx_order is None:
elevate_times = 0
else:
if isinstance(approx_order, basestr): approx_order = (approx_order,)
elevate_times = parse_approx_order(approx_order[0])
Struct.__init__(self, name=name, dtype=dtype, shape=shape,
region=region, elevate_times=elevate_times)
self.domain = self.region.domain
self.nurbs = self.domain.nurbs.elevate(elevate_times)
self._setup_kind()
self.n_components = nm.prod(self.shape)
self.val_shape = self.shape
self.n_nod = self.nurbs.weights.shape[0]
self.n_efun = nm.prod(self.nurbs.degrees + 1)
self.approx_order = self.nurbs.degrees.max()
self.mappings = {}
self.is_surface = False
def __init__(self, name, dtype, shape, region, approx_order=1):
"""
Create a finite element field.
Parameters
----------
name : str
The field name.
dtype : numpy.dtype
The field data type: float64 or complex128.
shape : int/tuple/str
The field shape: 1 or (1,) or 'scalar', space dimension (2, or (2,)
or 3 or (3,)) or 'vector', or a tuple. The field shape determines
the shape of the FE base functions and is related to the number of
components of variables and to the DOF per node count, depending
on the field kind.
region : Region
The region where the field is defined.
approx_order : int or tuple
The FE approximation order. The tuple form is (order, has_bubble),
e.g. (1, True) means order 1 with a bubble function.
Notes
-----
Assumes one cell type for the whole region!
"""
shape = parse_shape(shape, region.domain.shape.dim)
if not self._check_region(region):
raise ValueError('unsuitable region for field %s! (%s)' %
(name, region.name))
Struct.__init__(self, name=name, dtype=dtype, shape=shape,
region=region)
self.domain = self.region.domain
self._set_approx_order(approx_order)
self._setup_geometry()
self._setup_kind()
self._setup_shape()
self.surface_data = {}
self.point_data = {}
self.ori = None
self._create_interpolant()
self._setup_global_base()
self.setup_coors()
self.clear_mappings(clear_all=True)
self.clear_qp_base()
self.basis_transform = None
self.econn0 = None
self.unused_dofs = None
self.stored_subs = None
def __init__(self, name, dtype, shape, region, approx_order=1):
"""
Create a finite element field.
Parameters
----------
name : str
The field name.
dtype : numpy.dtype
The field data type: float64 or complex128.
shape : int/tuple/str
The field shape: 1 or (1,) or 'scalar', space dimension (2, or (2,)
or 3 or (3,)) or 'vector', or a tuple. The field shape determines
the shape of the FE base functions and is related to the number of
components of variables and to the DOF per node count, depending
on the field kind.
region : Region
The region where the field is defined.
approx_order : int or tuple
The FE approximation order. The tuple form is (order, has_bubble),
e.g. (1, True) means order 1 with a bubble function.
Notes
-----
Assumes one cell type for the whole region!
"""
shape = parse_shape(shape, region.domain.shape.dim)
if not self._check_region(region):
raise ValueError('unsuitable region for field %s! (%s)' %
(name, region.name))
Struct.__init__(self, name=name, dtype=dtype, shape=shape,
region=region)
self.domain = self.region.domain
self._set_approx_order(approx_order)
self._setup_geometry()
self._setup_kind()
self._setup_shape()
self.surface_data = {}
self.point_data = {}
self.ori = None
self._create_interpolant()
self._setup_global_base()
self.setup_coors()
self.clear_mappings(clear_all=True)
self.clear_qp_base()
self.basis_transform = None
self.econn0 = None
self.unused_dofs = None
self.stored_subs = None
def __init__(self, name, dtype, shape, region, **kwargs):
"""
Create a Bezier element isogeometric analysis field.
Parameters
----------
name : str
The field name.
dtype : numpy.dtype
The field data type: float64 or complex128.
shape : int/tuple/str
The field shape: 1 or (1,) or 'scalar', space dimension (2, or (2,)
or 3 or (3,)) or 'vector', or a tuple. The field shape determines
the shape of the FE base functions and is related to the number of
components of variables and to the DOF per node count, depending
on the field kind.
region : Region
The region where the field is defined.
**kwargs : dict
Additional keyword arguments.
"""
shape = parse_shape(shape, region.domain.shape.dim)
Struct.__init__(self,
name=name,
dtype=dtype,
shape=shape,
region=region)
self.domain = self.region.domain
self.nurbs = self.domain.nurbs
self._setup_kind()
self.n_components = nm.prod(self.shape)
self.val_shape = self.shape
self.n_nod = self.nurbs.weights.shape[0]
self.n_efun = nm.prod(self.nurbs.degrees + 1)
self.mappings = {}
self.igs = self.region.igs
self.is_surface = False
def __init__(self, name, dtype, shape, region, **kwargs):
"""
Create a Bezier element isogeometric analysis field.
Parameters
----------
name : str
The field name.
dtype : numpy.dtype
The field data type: float64 or complex128.
shape : int/tuple/str
The field shape: 1 or (1,) or 'scalar', space dimension (2, or (2,)
or 3 or (3,)) or 'vector', or a tuple. The field shape determines
the shape of the FE base functions and is related to the number of
components of variables and to the DOF per node count, depending
on the field kind.
region : Region
The region where the field is defined.
**kwargs : dict
Additional keyword arguments.
"""
shape = parse_shape(shape, region.domain.shape.dim)
Struct.__init__(self, name=name, dtype=dtype, shape=shape,
region=region)
self.domain = self.region.domain
self.nurbs = self.domain.nurbs
self._setup_kind()
self.n_components = nm.prod(self.shape)
self.val_shape = self.shape
self.n_nod = self.nurbs.weights.shape[0]
self.n_efun = nm.prod(self.nurbs.degrees + 1)
self.mappings = {}
self.igs = self.region.igs
self.is_surface = False
def __init__(self,
name,
dtype,
shape,
region,
space="H1",
poly_space_base="legendre",
approx_order=1,
integral=None):
"""
Creates DGField, with Legendre polyspace and default integral
corresponding to 2 * approx_order.
Parameters
----------
name : string
dtype : type
shape : string
'vector', 'scalar' or something else
region : sfepy.discrete.common.region.Region
space : string
default "H1"
poly_space_base : PolySpace
optionally force polyspace
approx_order : 0 for FVM, default 1
integral : Integral
if None integral of order 2*approx_order is created
"""
shape = parse_shape(shape, region.domain.shape.dim)
Struct.__init__(self,
name=name,
dtype=dtype,
shape=shape,
region=region)
if isinstance(approx_order, tuple):
self.approx_order = approx_order[0]
else:
self.approx_order = approx_order
# geometry
self.domain = region.domain
self.region = region
self.dim = region.tdim
self._setup_geometry()
self._setup_connectivity()
# TODO treat domains embedded into higher dimensional spaces?
self.n_el_facets = self.dim + 1 if self.gel.is_simplex else 2**self.dim
# approximation space
self.space = space
self.poly_space_base = poly_space_base
self.force_bubble = False
self._create_interpolant()
# DOFs
self._setup_shape()
self._setup_all_dofs()
self.ravel_sol = get_raveler(self.n_el_nod, self.n_cell)
self.unravel_sol = get_unraveler(self.n_el_nod, self.n_cell)
# integral
self.clear_qp_base()
self.clear_facet_qp_base()
if integral is None:
self.integral = Integral("dg_fi", order=2 * self.approx_order)
else:
self.integral = integral
self.ori = None
self.basis_transform = None
# mapping
self.mappings = {}
self.mapping = self.create_mapping(self.region,
self.integral,
"volume",
return_mapping=True)[1]
self.mappings0 = {}
# neighbour facet mapping and data caches
# TODO use lru cache or different method?
self.clear_facet_neighbour_idx_cache()
self.clear_normals_cache()
self.clear_facet_vols_cache()
self.boundary_facet_local_idx = {}
