10#ifndef __ENTITIES_FIELD_DATA_HPP__
11#define __ENTITIES_FIELD_DATA_HPP__
13using namespace boost::numeric;
23using VectorDofs = ublas::vector<FEDofEntity *, DofsAllocator>;
44 std::bitset<LASTBASE>
bAse;
48 std::array<std::bitset<LASTSPACE>, MBMAXTYPE>
50 std::array<std::bitset<LASTBASE>, MBMAXTYPE>
52 std::array<std::bitset<LASTBASE>,
LASTSPACE>
54 std::array<std::bitset<LASTBASE>,
LASTSPACE>
56 std::array<boost::ptr_vector<EntData>, MBMAXTYPE>
115 const boost::shared_ptr<EntitiesFieldData> &data_ptr);
119 const boost::shared_ptr<EntitiesFieldData>
dataPtr;
143 EntData(
const bool allocate_base_matrices =
true);
217 template <
int Tensor_Dim>
233 template <
int Tensor_Dim0,
int Tensor_Dim1>
235 Tensor_Dim0, Tensor_Dim1>
250 template <
int Tensor_Dim>
286 virtual boost::shared_ptr<MatrixDouble> &
293 virtual boost::shared_ptr<MatrixDouble> &
299 virtual boost::shared_ptr<MatrixDouble> &
426 const int gg,
const int nb_base_functions);
455 const int nb_base_functions);
469 const int nb_base_functions);
503 template <
int DIM0,
int DIM1>
513 template <
int DIM0,
int DIM1>
523 template <
int DIM0,
int DIM1>
525 const int dof,
const int gg);
533 template <
int DIM0,
int DIM1>
612 template <
int Tensor_Dim>
632 template <
int Tensor_Dim>
654 template <
int Tensor_Dim>
677 template <
int Tensor_Dim>
706 template <
int Tensor_Dim>
734 template <
int Tensor_Dim0,
int Tensor_Dim1>
736 Tensor_Dim0, Tensor_Dim1>
742 template <
int Tensor_Dim0,
int Tensor_Dim1>
744 Tensor_Dim0, Tensor_Dim1>
749 template <
int Tensor_Dim0,
int Tensor_Dim1>
751 Tensor_Dim0, Tensor_Dim1>
759 template <
int Tensor_Dim0,
int Tensor_Dim1>
761 Tensor_Dim0, Tensor_Dim1>
768 template <
int Tensor_Dim0,
int Tensor_Dim1,
int Tensor_Dim2>
771 Tensor_Dim0, Tensor_Dim1, Tensor_Dim2>
776 template <
int Tensor_Dim0,
int Tensor_Dim1,
int Tensor_Dim2>
779 Tensor_Dim0, Tensor_Dim1, Tensor_Dim2>
798 template <
int Tensor_Dim>
816 template <
int Tensor_Dim>
845 template <
int Tensor_Dim0,
int Tensor_Dim1>
847 Tensor_Dim0, Tensor_Dim1>
872 template <
int Tensor_Dim0,
int Tensor_Dim1>
auto getFTensor2N();
900 template <
int Tensor_Dim0,
int Tensor_Dim1>
902 Tensor_Dim0, Tensor_Dim1>
926 template <
int Tensor_Dim0,
int Tensor_Dim1>
935 friend std::ostream &
operator<<(std::ostream &os,
964 virtual boost::shared_ptr<MatrixInt> &
970 virtual boost::shared_ptr<MatrixDouble> &
976 virtual const boost::shared_ptr<MatrixDouble> &
982 virtual boost::shared_ptr<MatrixDouble> &
988 virtual const boost::shared_ptr<MatrixDouble> &
991 virtual std::map<std::string, boost::shared_ptr<MatrixInt>> &
999 virtual std::map<std::string, boost::shared_ptr<MatrixDouble>> &
getBBNMap();
1007 virtual std::map<std::string, boost::shared_ptr<MatrixDouble>> &
1016 virtual boost::shared_ptr<MatrixInt> &
1025 virtual boost::shared_ptr<MatrixDouble> &
1034 virtual boost::shared_ptr<MatrixDouble> &
1081 std::vector<EntityType>
1084 std::array<std::array<boost::shared_ptr<MatrixDouble>,
LASTBASE>,
1089 std::array<boost::shared_ptr<MatrixDouble>,
LASTBASE>
1094 std::map<std::string, boost::shared_ptr<MatrixDouble>>
bbN;
1095 std::map<std::string, boost::shared_ptr<MatrixDouble>>
bbDiffN;
1096 std::map<std::string, boost::shared_ptr<MatrixInt>>
1140 const boost::shared_ptr<EntitiesFieldData::EntData> &ent_data_ptr);
1147 boost::shared_ptr<MatrixDouble> &
1151 boost::shared_ptr<MatrixDouble> &
1154 boost::shared_ptr<MatrixDouble> &
1157 const boost::shared_ptr<MatrixDouble> &
1160 const boost::shared_ptr<MatrixDouble> &
1163 inline boost::shared_ptr<MatrixDouble> &
1166 inline boost::shared_ptr<MatrixDouble> &
1169 boost::shared_ptr<MatrixInt> &
1175 boost::shared_ptr<MatrixDouble> &
1181 const boost::shared_ptr<MatrixDouble> &
1187 boost::shared_ptr<MatrixDouble> &
1193 const boost::shared_ptr<MatrixDouble> &
1220 unsigned int size = 0;
1221 if (
auto dof = dOfs[0]) {
1222 size = dof->getOrderNbDofs(
order) * dof->getNbOfCoeffs();
1223 size = size < iNdices.size() ? size : iNdices.size();
1225 int *data = &*iNdices.data().begin();
1226 return VectorIntAdaptor(size, ublas::shallow_array_adaptor<int>(size, data));
1230 return localIndices;
1235 unsigned int size = 0;
1236 if (
auto dof = dOfs[0]) {
1237 size = dof->getOrderNbDofs(
order) * dof->getNbOfCoeffs();
1238 size = size < localIndices.size() ? size : localIndices.size();
1240 int *data = &*localIndices.data().begin();
1241 return VectorIntAdaptor(size, ublas::shallow_array_adaptor<int>(size, data));
1251 return localIndices;
1260 unsigned int size = 0;
1261 if (
auto dof = dOfs[0]) {
1262 size = dof->getOrderNbDofs(
order) * dof->getNbOfCoeffs();
1263 size = size < fieldData.size() ? size : fieldData.size();
1265 double *data = &*fieldData.data().begin();
1278 return fieldEntities;
1283 return fieldEntities;
1286template <
int Tensor_Dim>
1289 std::stringstream s;
1290 s <<
"Not implemented for this dimension dim = " << Tensor_Dim;
1294template <
int Tensor_Dim0,
int Tensor_Dim1>
1296 Tensor_Dim0, Tensor_Dim1>
1298 std::stringstream s;
1299 s <<
"Not implemented for this dimension dim0 = " << Tensor_Dim0;
1300 s <<
" and dim1 " << Tensor_Dim1;
1304template <
int Tensor_Dim>
1306 FTensor::PackPtr<
double *, (Tensor_Dim * (Tensor_Dim + 1)) / 2>, Tensor_Dim>
1308 std::stringstream s;
1309 s <<
"Not implemented for this dimension dim = " << Tensor_Dim;
1320 if (!getNSharedPtr(base)) {
1321 MOFEM_LOG_C(
"SELF", Sev::error,
"Ptr to base %s functions is null",
1324 "Null pointer to base functions");
1327 return *(getNSharedPtr(base));
1333 MOFEM_LOG_C(
"SELF", Sev::error,
"Ptr to field %s base functions is null ",
1336 "Null pointer to base functions");
1346 return *(getDiffNSharedPtr(base));
1353 if (!getNSharedPtr(base, derivative)) {
1355 "Ptr to base %s functions derivative %d is null",
1360 return *(getNSharedPtr(base, derivative));
1368 "Null pointer to base functions derivative");
1378 return getN(
bAse, derivative);
1384 int size = getN(base).size2();
1385 double *data = &getN(base)(gg, 0);
1386 return VectorAdaptor(size, ublas::shallow_array_adaptor<double>(size, data));
1390 return getN(
bAse, gg);
1399 if (getN(base).size1() == getDiffN(base).size1()) {
1400 int size = getN(base).size2();
1401 int dim = getDiffN(base).size2() / size;
1402 double *data = &getDiffN(base)(gg, 0);
1404 getN(base).size2(), dim,
1405 ublas::shallow_array_adaptor<double>(getDiffN(base).size2(), data));
1410 getN(base).size1(), getN(base).size2(),
1411 ublas::shallow_array_adaptor<double>(getDiffN(base).data().size(),
1412 &getDiffN(base).data()[0]));
1417 return getDiffN(
bAse, gg);
1422 const int gg,
const int nb_base_functions) {
1423 (void)getN()(gg, nb_base_functions -
1425 double *data = &getN(base)(gg, 0);
1426 return VectorAdaptor(nb_base_functions, ublas::shallow_array_adaptor<double>(
1427 nb_base_functions, data));
1432 return getN(
bAse, gg, nb_base_functions);
1438 const int nb_base_functions) {
1442 if (getN(base).size1() == getDiffN(base).size1()) {
1443 (void)getN(base)(gg,
1446 int dim = getDiffN(base).size2() / getN(base).size2();
1447 double *data = &getDiffN(base)(gg, 0);
1449 nb_base_functions, dim,
1450 ublas::shallow_array_adaptor<double>(dim * nb_base_functions, data));
1455 getN(base).size1(), getN(base).size2(),
1456 ublas::shallow_array_adaptor<double>(getDiffN(base).data().size(),
1457 &getDiffN(base).data()[0]));
1463 const int nb_base_functions) {
1464 return getDiffN(
bAse, gg, nb_base_functions);
1471 if (PetscUnlikely(getN(base).size2() % DIM)) {
1475 const int nb_base_functions = getN(base).size2() / DIM;
1476 double *data = &getN(base)(gg, 0);
1478 nb_base_functions, DIM,
1479 ublas::shallow_array_adaptor<double>(DIM * nb_base_functions, data));
1484 return getVectorN<DIM>(
bAse, gg);
1487template <
int DIM0,
int DIM1>
1491 if (PetscUnlikely(getDiffN(base).size2() % (DIM0 *
DIM1))) {
1495 const int nb_base_functions = getN(base).size2() / (DIM0 *
DIM1);
1496 double *data = &getN(base)(gg, 0);
1498 ublas::shallow_array_adaptor<double>(
1499 DIM0 *
DIM1 * nb_base_functions, data));
1502template <
int DIM0,
int DIM1>
1504 return getVectorDiffN<DIM0, DIM1>(
bAse, gg);
1507template <
int DIM0,
int DIM1>
1510 const int dof,
const int gg) {
1514 ublas::shallow_array_adaptor<double>(DIM0 *
DIM1, data));
1517template <
int DIM0,
int DIM1>
1520 return getVectorDiffN<DIM0, DIM1>(
bAse, dof, gg);
1525 double *ptr = &*getN(base).data().begin();
1531 return getFTensor0N(
bAse);
1536 const int gg,
const int bb) {
1537 double *ptr = &getN(base)(gg, bb);
1543 return getFTensor0N(
bAse, gg, bb);
1547 return getFTensor1N<Tensor_Dim>(
bAse);
1550template <
int Tensor_Dim>
1552 return getFTensor1N<Tensor_Dim>(
bAse, gg, bb);
1555template <
int Tensor_Dim0,
int Tensor_Dim1>
1557 return getFTensor2N<Tensor_Dim0, Tensor_Dim1>(
bAse);
1560template <
int Tensor_Dim0,
int Tensor_Dim1>
1562 return getFTensor2N<Tensor_Dim0, Tensor_Dim1>(
bAse, gg, bb);
1572 return *getBBAlphaIndicesSharedPtr(bbFieldName);
1581boost::shared_ptr<MatrixDouble> &
1587boost::shared_ptr<MatrixDouble> &
1610template <
typename T = EntityStorage>
1613 const double *ptr, InsertMode iora) {
1614 static_assert(!std::is_same<T, T>::value,
1615 "VecSetValues value for this data storage is not implemented");
1622 const double *ptr, InsertMode iora) {
1642template <
typename T = EntityStorage>
1665template <
typename T = EntityStorage>
1669 const double *ptr, InsertMode iora) {
1670 static_assert(!std::is_same<T, T>::value,
1671 "MatSetValues value for this data storage is not implemented");
1691template <
typename T = EntityStorage>
1696 return MatSetValues<T>(M, row_data, col_data, &*mat.data().begin(), iora);
1703 const double *ptr, InsertMode iora) {
1720 const int gg,
const int bb);
1754 const int gg,
const int bb);
#define MOFEM_LOG_C(channel, severity, format,...)
EntitiesFieldData::EntData EntData
Data on entities.
FieldApproximationBase
approximation base
#define CHK_THROW_MESSAGE(err, msg)
Check and throw MoFEM exception.
FieldSpace
approximation spaces
@ LASTSPACE
FieldSpace in [ 0, LASTSPACE )
@ MOFEM_DATA_INCONSISTENCY
static const char *const ApproximationBaseNames[]
#define BITFEID_SIZE
max number of finite elements
#define THROW_MESSAGE(msg)
Throw MoFEM exception.
PetscErrorCode MoFEMErrorCode
MoFEM/PETSc error code.
VectorShallowArrayAdaptor< int > VectorIntAdaptor
int ApproximationOrder
Approximation on the entity.
UBlasMatrix< int > MatrixInt
UBlasMatrix< double > MatrixDouble
VectorShallowArrayAdaptor< double > VectorAdaptor
MatrixShallowArrayAdaptor< double > MatrixAdaptor
Matrix adaptor.
UBlasVector< double > VectorDouble
UBlasVector< int > VectorInt
implementation of Data Operators for Forces and Sources
auto getVectorAdaptor(T1 ptr, const size_t n)
Get Vector adaptor.
ublas::unbounded_array< FEDofEntity *, std::allocator< FEDofEntity * > > DofsAllocator
DEPRECATED typedef DerivedEntitiesFieldData DerivedDataForcesAndSourcesCore
DEPRECATED typedef EntitiesFieldData DataForcesAndSourcesCore
ublas::vector< FieldEntity *, FieldEntAllocator > VectorFieldEntities
ublas::unbounded_array< FieldEntity *, std::allocator< FieldEntity * > > FieldEntAllocator
MoFEMErrorCode MatSetValues(Mat M, const EntitiesFieldData::EntData &row_data, const EntitiesFieldData::EntData &col_data, const double *ptr, InsertMode iora)
Assemble PETSc matrix.
ublas::vector< FEDofEntity *, DofsAllocator > VectorDofs
MoFEMErrorCode VecSetValues< EntityStorage >(Vec V, const EntitiesFieldData::EntData &data, const double *ptr, InsertMode iora)
MoFEMErrorCode MatSetValues< EntityStorage >(Mat M, const EntitiesFieldData::EntData &row_data, const EntitiesFieldData::EntData &col_data, const double *ptr, InsertMode iora)
MoFEMErrorCode VecSetValues(Vec V, const EntitiesFieldData::EntData &data, const double *ptr, InsertMode iora)
Assemble PETSc vector.
constexpr auto field_name
Derived ata on single entity (This is passed as argument to DataOperator::doWork)
boost::shared_ptr< MatrixDouble > & getBBNSharedPtr(const std::string &field_name)
boost::shared_ptr< MatrixDouble > & getDerivedDiffNSharedPtr(const FieldApproximationBase base)
const boost::shared_ptr< EntitiesFieldData::EntData > entDataPtr
MoFEMErrorCode baseSwap(const std::string &field_name, const FieldApproximationBase base)
Used by Bernstein base to keep temporally pointer.
std::vector< BitRefLevel > & getEntDataBitRefLevel()
int getSense() const
get entity sense, need to calculate base functions with conforming approximation fields
boost::shared_ptr< MatrixInt > & getBBAlphaIndicesSharedPtr(const std::string &field_name)
boost::shared_ptr< MatrixDouble > & getBBDiffNSharedPtr(const std::string &field_name)
boost::shared_ptr< MatrixDouble > & getDiffNSharedPtr(const FieldApproximationBase base)
DerivedEntData(const boost::shared_ptr< EntitiesFieldData::EntData > &ent_data_ptr)
boost::shared_ptr< MatrixDouble > & getNSharedPtr(const FieldApproximationBase base, const BaseDerivatives derivative)
boost::shared_ptr< MatrixDouble > & getDerivedNSharedPtr(const FieldApproximationBase base)
this class derive data form other data structure
MoFEMErrorCode setElementType(const EntityType type)
const boost::shared_ptr< EntitiesFieldData > dataPtr
DerivedEntitiesFieldData(const boost::shared_ptr< EntitiesFieldData > &data_ptr)
Data on single entity (This is passed as argument to DataOperator::doWork)
std::vector< int > dofBrokenSideVec
Map side to dofs number.
std::array< boost::shared_ptr< MatrixDouble >, MaxBernsteinBezierOrder > bbDiffNByOrder
BB base functions derivatives by order.
boost::shared_ptr< MatrixDouble > swapBaseDiffNPtr
Used by Bernstein base to keep temporally pointer.
virtual std::array< boost::shared_ptr< MatrixDouble >, MaxBernsteinBezierOrder > & getBBDiffNByOrderArray()
FieldSpace sPace
Entity space.
const VectorIntAdaptor getIndicesUpToOrder(int order)
get global indices of dofs on entity up to given order
virtual std::array< boost::shared_ptr< MatrixDouble >, MaxBernsteinBezierOrder > & getBBNByOrderArray()
int sEnse
Entity sense (orientation)
auto getFTensor2N()
Get base functions for Hdiv space.
VectorDouble fieldData
Field data on entity.
FTensor::Tensor1< FTensor::PackPtr< double *, Tensor_Dim >, Tensor_Dim > getFTensor1DiffN(const int gg, const int bb)
Get derivatives of base functions (Loop by integration points)
MatrixDouble & getN()
get base functions this return matrix (nb. of rows is equal to nb. of Gauss pts, nb....
FieldApproximationBase & getBase()
Get approximation base.
boost::shared_ptr< MatrixDouble > swapBaseNPtr
Used by Bernstein base to keep temporally pointer.
ApproximationOrder getOrder() const
get approximation order
std::map< std::string, boost::shared_ptr< MatrixInt > > bbAlphaIndices
Indices for Bernstein-Bezier (BB) base.
friend std::ostream & operator<<(std::ostream &os, const EntitiesFieldData::EntData &e)
VectorInt localIndices
Local indices on entity.
const MatrixAdaptor getVectorDiffN(FieldApproximationBase base, const int gg)
get DiffHdiv of base functions at Gauss pts
const VectorFieldEntities & getFieldEntities() const
get field entities
virtual std::array< boost::shared_ptr< MatrixInt >, MaxBernsteinBezierOrder > & getBBAlphaIndicesByOrderArray()
virtual std::map< std::string, boost::shared_ptr< MatrixInt > > & getBBAlphaIndicesMap()
const VectorIntAdaptor getLocalIndicesUpToOrder(int order)
get local indices of dofs on entity up to given order
const VectorAdaptor getFieldDataUpToOrder(int order)
get dofs values up to given order
FTensor::Tensor1< FTensor::PackPtr< double *, Tensor_Dim >, Tensor_Dim > getFTensor1DiffN()
Get derivatives of base functions.
std::vector< BitRefLevel > entDataBitRefLevel
Bit ref level in entity.
FTensor::Tensor2< FTensor::PackPtr< double *, Tensor_Dim0 *Tensor_Dim1 >, Tensor_Dim0, Tensor_Dim1 > getFTensor2DiffN(const int gg, const int bb)
Get derivatives of base functions for Hdiv space at integration pts.
static constexpr size_t MaxBernsteinBezierOrder
VectorInt iNdices
Global indices on entity.
virtual boost::shared_ptr< MatrixDouble > & getNSharedPtr(const FieldApproximationBase base, const BaseDerivatives derivative)
virtual boost::shared_ptr< MatrixInt > & getBBAlphaIndicesSharedPtr(const std::string &field_name)
const VectorDouble & getFieldData() const
get dofs values
VectorInt bbNodeOrder
order of nodes
virtual boost::shared_ptr< MatrixDouble > & getBBDiffNByOrderSharedPtr(const size_t o)
get BB base derivative by order
FTensor::Tensor3< FTensor::PackPtr< double *, Tensor_Dim0 *Tensor_Dim1 *Tensor_Dim2 >, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 > getFTensor3Diff2N(FieldApproximationBase base)
Get second derivatives of base functions for Hvec space.
virtual std::map< std::string, boost::shared_ptr< MatrixDouble > > & getBBNMap()
get hash map of base function for BB base, key is a field name
const MatrixAdaptor getVectorN(const FieldApproximationBase base, const int gg)
get Hdiv of base functions at Gauss pts
virtual MoFEMErrorCode baseSwap(const std::string &field_name, const FieldApproximationBase base)
Swap bases functions.
const VectorInt & getLocalIndices() const
get local indices of dofs on entity
ApproximationOrder oRder
Entity order.
FTensor::Tensor1< FTensor::PackPtr< double *, Tensor_Dim >, Tensor_Dim > getFTensor1FieldData()
Return FTensor of rank 1, i.e. vector from field data coefficients.
std::vector< EntityType > dofBrokenTypeVec
Map type of entity to dof number.
virtual std::map< std::string, boost::shared_ptr< MatrixDouble > > & getBBDiffNMap()
get hash map of derivatives base function for BB base, key is a field name
virtual std::vector< BitRefLevel > & getEntDataBitRefLevel()
virtual int getSense() const
get entity sense, need to calculate base functions with conforming approximation fields
VectorFieldEntities fieldEntities
Field entities.
virtual ~EntData()=default
FTensor::Tensor0< FTensor::PackPtr< double *, 1 > > getFTensor0N()
Get base function as Tensor0.
FTensor::Tensor0< FTensor::PackPtr< double *, 1 > > getFTensor0FieldData()
Resturn scalar files as a FTensor of rank 0.
MatrixInt & getBBAlphaIndices()
Get file BB indices.
std::array< boost::shared_ptr< MatrixInt >, MaxBernsteinBezierOrder > bbAlphaIndicesByOrder
BB alpha indices by order.
MatrixDouble & getDiffN()
get derivatives of base functions
VectorInt & getBBNodeOrder()
Get orders at the nodes.
std::string bbFieldName
field name
virtual boost::shared_ptr< MatrixInt > & getBBAlphaIndicesByOrderSharedPtr(const size_t o)
get ALpha indices for BB base by order
std::array< boost::shared_ptr< MatrixDouble >, LASTBASE > & diffN
Derivatives of base functions.
std::map< std::string, boost::shared_ptr< MatrixDouble > > bbDiffN
MoFEMErrorCode resetFieldDependentData()
const VectorDofs & getFieldDofs() const
get dofs data stature FEDofEntity
FTensor::Tensor2_symmetric< FTensor::PackPtr< double *,(Tensor_Dim *(Tensor_Dim+1))/2 >, Tensor_Dim > getFTensor2SymmetricFieldData()
Return symmetric FTensor rank 2, i.e. matrix from field data coefficients.
FTensor::Tensor3< FTensor::PackPtr< double *, Tensor_Dim0 *Tensor_Dim1 *Tensor_Dim2 >, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 > getFTensor3Diff2N()
Get second derivatives of base functions for Hvec space.
FieldSpace & getSpace()
Get field space.
auto getFTensor1N()
Get base functions for Hdiv space.
virtual boost::shared_ptr< MatrixDouble > & getBBNSharedPtr(const std::string &field_name)
std::array< boost::shared_ptr< MatrixDouble >, MaxBernsteinBezierOrder > bbNByOrder
BB base functions by order.
std::array< std::array< boost::shared_ptr< MatrixDouble >, LASTBASE >, LastDerivative > baseFunctionsAndBaseDerivatives
FTensor::Tensor2< FTensor::PackPtr< double *, Tensor_Dim0 *Tensor_Dim1 >, Tensor_Dim0, Tensor_Dim1 > getFTensor2DiffN()
Get derivatives of base functions for Hdiv space.
std::map< std::string, boost::shared_ptr< MatrixDouble > > bbN
VectorDofs dOfs
DoFs on entity.
virtual boost::shared_ptr< MatrixDouble > & getDiffNSharedPtr(const FieldApproximationBase base)
FTensor::Tensor2< FTensor::PackPtr< double *, Tensor_Dim0 *Tensor_Dim1 >, Tensor_Dim0, Tensor_Dim1 > getFTensor2FieldData()
Return FTensor rank 2, i.e. matrix from field data coefficients.
virtual boost::shared_ptr< MatrixDouble > & getBBNByOrderSharedPtr(const size_t o)
get BB base by order
const VectorInt & getIndices() const
Get global indices of dofs on entity.
FieldApproximationBase bAse
Field approximation base.
virtual boost::shared_ptr< MatrixDouble > & getBBDiffNSharedPtr(const std::string &field_name)
std::array< boost::shared_ptr< MatrixDouble >, LASTBASE > & N
Base functions.
data structure for finite element entity
friend std::ostream & operator<<(std::ostream &os, const EntitiesFieldData &e)
MoFEMErrorCode resetFieldDependentData()
MatrixInt facesNodes
nodes on finite element faces
std::array< std::bitset< LASTSPACE >, MBMAXTYPE > spacesOnEntities
spaces on entity types
std::bitset< LASTBASE > bAse
bases on element
std::array< boost::ptr_vector< EntData >, MBMAXTYPE > dataOnEntities
std::array< std::bitset< LASTBASE >, LASTSPACE > basesOnSpaces
base on spaces
virtual ~EntitiesFieldData()=default
virtual MoFEMErrorCode baseSwap(const std::string &field_name, const FieldApproximationBase base)
Swap approximation base.
virtual MoFEMErrorCode setElementType(const EntityType type)
std::array< std::bitset< LASTBASE >, LASTSPACE > brokenBasesOnSpaces
base on spaces
MatrixInt facesNodesOrder
order of face nodes on element
std::array< std::bitset< LASTBASE >, MBMAXTYPE > basesOnEntities
bases on entity types
keeps information about indexed dofs for the finite element
Struct keeps handle to entity in the field.
Operator to project base functions from parent entity to child.