v0.8.23
FieldMultiIndices.hpp
Go to the documentation of this file.
1 /** \file FieldMultiIndices.hpp
2  * \brief Field data structure storing information about space, approximation
3  * base, coordinate systems, etc.
4  *
5  * Also, it stores data needed for book keeping, like tags to data on the
6  * mesh.
7  *
8  * Each filed has unique ID and name. This data structure is shared between
9  * entities on which is spanning and DOFs on those entities.
10  */
11 
12 /*
13  * MoFEM is free software: you can redistribute it and/or modify it under
14  * the terms of the GNU Lesser General Public License as published by the
15  * Free Software Foundation, either version 3 of the License, or (at your
16  * option) any later version.
17  *
18  * MoFEM is distributed in the hope that it will be useful, but WITHOUT
19  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
20  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
21  * License for more details.
22  *
23  * You should have received a copy of the GNU Lesser General Public
24  * License along with MoFEM. If not, see <http://www.gnu.org/licenses/>
25  */
26 
27 #ifndef __FIELDMULTIINDICES_HPP__
28 #define __FIELDMULTIINDICES_HPP__
29 
30 namespace MoFEM {
31 
32 /** \brief user adjacency function
33  * \ingroup fe_multi_indices
34  */
35 typedef boost::function<int(const int order)> FieldOrderFunct;
36 
37 /** \brief user adjacency function table
38  * \ingroup dof_multi_indices
39  */
40 typedef FieldOrderFunct FieldOrderTable[MBMAXTYPE];
41 
42 struct FieldEntity;
43 struct DofEntity;
44 
45 /**
46  * \brief Provide data structure for (tensor) field approximation.
47  * \ingroup dof_multi_indices
48  *
49  * The Field is intended to provide support for fields, with a strong bias
50  * towards supporting first and best the capabilities required for scientific
51  * computing applications. Since we work with discrete spaces, data structure
52  * has to carry information about type of approximation space, its regularity.
53  *
54  *
55  * Field data structure storing information about space, approximation base,
56  * coordinate systems, etc. It stores additional data needed for book keeping,
57  * like tags to data on the mesh.
58  *
59  * Each filed has unique ID and name. This
60  * data structure is shared between entities on which is spanning and DOFs on
61  * those entities.
62  *
63  */
64 struct Field {
65 
66  typedef multi_index_container<boost::weak_ptr<std::vector<FieldEntity>>,
67  indexed_by<sequenced<>>>
69 
70  typedef multi_index_container<boost::weak_ptr<std::vector<DofEntity>>,
71  indexed_by<sequenced<>>>
73 
74  typedef std::array<std::array<int, MAX_DOFS_ON_ENTITY>, MBMAXTYPE>
76 
77  moab::Interface &moab;
78 
79  EntityHandle meshSet; ///< keeps entities for this meshset
80  boost::shared_ptr<CoordSys>
81  coordSysPtr; ///< Pointer to field coordinate system data structure
82 
83  TagType th_FieldDataVertsType; // Tag type for storing data on vertices
84  Tag th_FieldDataVerts; ///< Tag storing field values on vertices in the field
85  Tag th_FieldData; ///< Tag storing field values on entity in the field
86  Tag th_AppOrder; ///< Tag storing approximation order on entity
87 
88  BitFieldId *tagId; ///< tag keeps field id
89  FieldSpace *tagSpaceData; ///< tag keeps field space
90  FieldApproximationBase *tagBaseData; ///< tag keeps field base
91 
92  /// tag keeps field rank (dimension, f.e. Temperature field has rank 1,
93  /// displacements field in 3d has rank 3)
95  const void *tagName; ///< tag keeps name of the field
96  int tagNameSize; ///< number of bits necessary to keep field name
97  const void *tagNamePrefixData; ///< tag keeps name prefix of the field
98  int tagNamePrefixSize; ///< number of bits necessary to keep field name
99  ///< prefix
100  FieldOrderTable forderTable; ///< nb. DOFs table for entities
101 
102  /**
103  * @brief Get the Field Order Table
104  *
105  * @return FieldOrderTable&
106  */
108 
109  /**
110  * Field Id is bit set. Each field has only one bit on, bitNumber stores
111  * number of set bit
112  */
113  unsigned int bitNumber;
114 
115  static UId generateGlobalUniqueIdForTypeLo(const char bit_number,
116  const EntityType type,
117  const int owner_proc) {
118  constexpr int ent_shift = 8 * sizeof(EntityHandle);
119  return (static_cast<UId>(type) << MB_ID_WIDTH |
120  static_cast<UId>(bit_number) << 8 * sizeof(EntityHandle) |
121  static_cast<UId>(owner_proc) << 5 + ent_shift)
122  << 9;
123  }
124 
125  UId generateGlobalUniqueIdForTypeLo(const EntityType type,
126  const int owner_proc) const {
127  return generateGlobalUniqueIdForTypeLo(bitNumber, type, owner_proc);
128  }
129 
130  static UId generateGlobalUniqueIdForTypeHi(const char bit_number,
131  const EntityType type,
132  const int owner_proc) {
133  constexpr int ent_shift = 8 * sizeof(EntityHandle);
134  return (static_cast<UId>(type) << MB_ID_WIDTH |
135  static_cast<UId>(bit_number) << ent_shift |
136  static_cast<UId>(owner_proc) << 5 + ent_shift)
137  << 9;
138  }
139 
140  UId generateGlobalUniqueIdForTypeHi(const EntityType type,
141  const int owner_proc) const {
142  return generateGlobalUniqueIdForTypeHi(bitNumber, type, owner_proc);
143  }
144 
145  /**
146  * \brief constructor for moab field
147  *
148  * \param meshset which keeps entities for this field
149  */
150  Field(const moab::Interface &moab, const EntityHandle meshset,
151  const boost::shared_ptr<CoordSys> coord_sys_ptr);
152 
153  /**
154  * \brief Get field meshset
155  *
156 
157  * To meshsets entity are attached Tags which keeps basic information about
158  * field. Those information is field name, approximation base, approximation
159  * space, id, etc.
160 
161  * In meshset contains entities on which given filed is sparing. Type of
162  entities
163  * depended on approximations space.
164 
165  * @return EntityHandle
166  */
167  inline EntityHandle getMeshset() const { return meshSet; }
168 
169  /**
170  * \brief Get dimension of general two-point tensor \ref
171  MoFEM::CoordSys::getDim
172 
173  See details here \ref MoFEM::CoordSys::getDim
174 
175  */
176  inline int getCoordSysDim(const int d = 0) const {
177  return coordSysPtr->getDim(d);
178  }
179 
180  /**
181  * \brief Get reference base vectors
182  * @param Array where coefficients (covariant) are returned
183  * @return Error code
184  */
185  inline MoFEMErrorCode get_E_Base(const double m[]) const {
187  MoFEMFunctionReturnHot(coordSysPtr->get_E_Base(m));
188  }
189 
190  /**
191  * \brief Get reference dual base vectors
192  * @param Array where coefficients (contravariant) are returned
193  * @return Error code
194  */
195  inline MoFEMErrorCode get_E_DualBase(const double m[]) const {
197  MoFEMFunctionReturnHot(coordSysPtr->get_E_DualBase(m));
198  }
199 
200  /**
201  * \brief Get current dual base vectors
202  * @param Array where coefficients (covariant) are returned
203  * @return Error code
204  */
205  inline MoFEMErrorCode get_e_Base(const double m[]) const {
207  MoFEMFunctionReturnHot(coordSysPtr->get_e_Base(m));
208  }
209 
210  /**
211  * \brief Get current dual base vectors
212  * @param Array where coefficients (covariant) are returned
213  * @return Error code
214  */
215  inline MoFEMErrorCode get_e_DualBase(const double m[]) const {
217  MoFEMFunctionReturnHot(coordSysPtr->get_e_DualBase(m));
218  }
219 
220  /**
221  * \brief Returns meshset on which Tags defining coordinate system are stored
222  * @return Coordinate system EntityHandle
223  */
225  return coordSysPtr->getMeshset();
226  }
227 
228  /**
229  * \brief Get coordinate system name
230  * @return Coordinate system name
231  */
232  inline std::string getCoordSysName() const { return coordSysPtr->getName(); }
233 
234  /**
235  * \brief Get coordinate system name
236  * @return Return string_ref with name.
237  */
238  inline boost::string_ref getCoordSysNameRef() const {
239  return coordSysPtr->getNameRef();
240  }
241 
242  /**
243  * \brief Get unique field id.
244  * @return Filed ID
245  */
246  inline const BitFieldId &getId() const { return *((BitFieldId *)tagId); }
247 
248  /**
249  * \brief Get string reference to field name
250  * @return Field name
251  */
252  inline boost::string_ref getNameRef() const {
253  return boost::string_ref((char *)tagName, tagNameSize);
254  }
255 
256  /**
257  * \brief Get field name
258  * @return Field name
259  */
260  inline std::string getName() const {
261  return std::string((char *)tagName, tagNameSize);
262  }
263 
264  /**
265  * \brief Get field approximation space
266  * @return approximation space
267  */
268  inline FieldSpace getSpace() const { return *tagSpaceData; }
269 
270  /**
271  * \brief Get approximation base
272  * @return Approximation base
273  */
275 
276  /** \brief Get number of field coefficients
277  *
278 
279  * Scalar field has only one coefficient, vector field in 3D has three. In
280  * general number determine space needed to keep data on entities. What
281  coefficient
282  * means depend on interpretation and associated coordinate system. For
283  example
284  * 3 coefficient means could be covariant or contravariant, or mean three
285  temperatures
286  * for mixture of solid, air and water, etc.
287 
288 
289  */
291  return *tagNbCoeffData;
292  };
293 
294  /**
295  * \brief Get number of set bit in Field ID.
296  * Each field has uid, get getBitNumber get number of bit set for given field.
297  * Field ID has only one bit set for each field.
298  */
299  inline unsigned int getBitNumber() const { return bitNumber; }
300 
301  /**
302  * \brief Calculate number of set bit in Field ID.
303  * Each field has uid, get getBitNumber get number of bit set for given field.
304  * Field ID has only one bit set for each field.
305  */
306  inline unsigned int getBitNumberCalculate() const {
307  int b = ffsl(((BitFieldId *)tagId)->to_ulong());
308  if (b != 0)
309  return b;
310  for (int ll = 1; ll < BITFIELDID_SIZE / 32; ll++) {
311  BitFieldId id;
312  id = (*tagId) >> ll * 32;
313  b = ll * 32 + ffsl(id.to_ulong());
314  if (b != 0)
315  return b;
316  }
317  return 0;
318  }
319 
320  friend std::ostream &operator<<(std::ostream &os, const Field &e);
321 
322  /**
323  * \brief Get reference to sequence data container
324  *
325  * In sequence data container data are physically stored. The purpose of this
326  * is to allocate MoFEMEntities data in bulk, having only one allocation
327  * instead each time entity is inserted. That makes code efficient.
328  *
329  * The vector in sequence is destroyed if last entity inside that vector is
330  * destroyed. All MoFEM::MoFEMEntities have aliased shared_ptr which points to
331  * the vector.
332  *
333  * @return MoFEM::Field::SequenceEntContainer
334  */
336  return sequenceEntContainer;
337  }
338 
339  /**
340  * \brief Get reference to sequence data container
341  *
342  * In sequence data container data are physically stored. The purpose of this
343  * is to allocate DofEntity data in bulk, having only one allocation instead
344  * each time entity is inserted. That makes code efficient.
345  *
346  * The vector in sequence is destroyed if last entity inside that vector is
347  * destroyed. All MoFEM::MoFEMEntities have aliased shared_ptr which points to
348  the vector.
349 
350  * Not all DOFs are starred in this way, currently such cases are considered;
351  * - DOFs on vertices. That is exploited that for H1 space, there is some
352  * fixed number of DOFs on each vertex
353 
354  * For other cases, DOFs are stored locally in each MoFEM::MoFEMEntities.
355 
356  * @return MoFEM::Field::SequenceDofContainer
357  */
359  return sequenceDofContainer;
360  }
361 
362  /**
363  * \brief get hash-map relating dof index on entity with its order
364  *
365  * Dofs of given field are indexed on entity
366  * of the same type, same space, approximation base and number of
367  * coefficients, are sorted in the way.
368  *
369  */
370  inline std::array<int, MAX_DOFS_ON_ENTITY> &
371  getDofOrderMap(const EntityType type) const {
372  return dofOrderMap[type];
373  }
374 
375  /**
376  * \brief get hash-map relating dof index on entity with its order
377  *
378  * Dofs of given field are indexed on entity
379  * of the same type, same space, approximation base and number of
380  * coefficients, are sorted in the way.
381  *
382  */
383  inline DofsOrderMap &getDofOrderMap() const {
384  return const_cast<DofsOrderMap&>(dofOrderMap);
385  }
386 
388 
389 private:
393 };
394 
395 /**
396  * \brief Pointer interface for MoFEM::Field
397  *
398  * MoFEM::Field class is keeps data and methods. This class is interface to that
399  * class, and all other classes, like MoFEMEntities, DofEntity and derived form
400  * them inherits pointer interface, not MoFEM::Field class directly.
401  *
402  * \ingroup dof_multi_indices
403  */
404 template <typename T> struct interface_Field {
405 
406  mutable boost::shared_ptr<T> sFieldPtr;
407 
408  interface_Field(const boost::shared_ptr<T> &field_ptr)
409  : sFieldPtr(field_ptr) {}
410 
412  : sFieldPtr(interface.getFieldPtr()) {}
413 
414  virtual ~interface_Field() {}
415 
416  inline EntityHandle getMeshset() const {
417  return this->sFieldPtr->getMeshset();
418  }
419 
420  inline int getCoordSysId() const { return this->sFieldPtr->getCoordSysId(); }
421 
422  /**
423  * \brief Get dimension of general two-point tensor \ref
424  MoFEM::CoordSys::getDim
425 
426  See details here \ref MoFEM::CoordSys::getDim
427 
428  */
429  inline int getCoordSysDim(const int d = 0) const {
430  return this->sFieldPtr->getCoordSysDim(d);
431  }
432 
433  inline MoFEMErrorCode get_E_Base(const double m[]) const {
435  MoFEMFunctionReturnHot(this->sFieldPtr->get_E_Base(m));
436  }
437  inline MoFEMErrorCode get_E_DualBase(const double m[]) const {
439  MoFEMFunctionReturnHot(this->sFieldPtr->get_E_DualBase(m));
440  }
441  inline MoFEMErrorCode get_e_Base(const double m[]) const {
443  MoFEMFunctionReturnHot(this->sFieldPtr->get_e_Base(m));
444  }
445 
446  inline MoFEMErrorCode get_e_DualBase(const double m[]) const {
448  MoFEMFunctionReturnHot(this->sFieldPtr->get_e_DualBase(m));
449  }
450 
451  /// @return return meshset for coordinate system
453  return this->sFieldPtr->getCoordSysMeshSet();
454  }
455 
456  /// @return return coordinate system name for field
457  inline std::string getCoordSysName() const {
458  return this->sFieldPtr->getCoordSysName();
459  }
460 
461  /// @return return coordinate system name for field
462  inline boost::string_ref getCoordSysNameRef() const {
463  return this->sFieldPtr->getCoordSysNameRef();
464  }
465 
466  /// @return get field Id
467  inline const BitFieldId &getId() const { return this->sFieldPtr->getId(); }
468 
469  /// @return get field name
470  inline boost::string_ref getNameRef() const {
471  return this->sFieldPtr->getNameRef();
472  }
473 
474  /// @return get field name
475  inline std::string getName() const { return this->sFieldPtr->getName(); }
476 
477  /// @return get approximation space
478  inline FieldSpace getSpace() const { return this->sFieldPtr->getSpace(); }
479 
480  /// @return get approximation base
482  return this->sFieldPtr->getApproxBase();
483  }
484 
485  /// @return get number of coefficients for DOF
487  return this->sFieldPtr->getNbOfCoeffs();
488  }
489 
490  /// @return get bit number if filed Id
491  inline unsigned int getBitNumber() const {
492  return this->sFieldPtr->getBitNumber();
493  }
494 
495  /// @return get pointer to the field data structure
496  inline boost::shared_ptr<T> &getFieldPtr() const { return this->sFieldPtr; }
497 
498  /**
499  * \brief get hash-map relating dof index on entity with its order
500  *
501  * Dofs of given field are indexed on entity
502  * of the same type, same space, approximation base and number of
503  * coefficients, are sorted in the way.
504  *
505  */
506  inline std::vector<ApproximationOrder> &
507  getDofOrderMap(const EntityType type) const {
508  return this->sFieldPtr->getDofOrderMap(type);
509  }
510 };
511 
512 /**
513  * @relates multi_index_container
514  * \brief Field_multiIndex for Field
515  *
516  */
517 typedef multi_index_container<
518  boost::shared_ptr<Field>,
519  indexed_by<
520  hashed_unique<tag<BitFieldId_mi_tag>,
521  const_mem_fun<Field, const BitFieldId &, &Field::getId>,
522  HashBit<BitFieldId>, EqBit<BitFieldId>>,
523  ordered_unique<tag<Meshset_mi_tag>,
524  member<Field, EntityHandle, &Field::meshSet>>,
525  ordered_unique<
526  tag<FieldName_mi_tag>,
527  const_mem_fun<Field, boost::string_ref, &Field::getNameRef>>,
528  ordered_non_unique<tag<BitFieldId_space_mi_tag>,
529  const_mem_fun<Field, FieldSpace, &Field::getSpace>>>>
531 
532 typedef multi_index_container<
533  boost::shared_ptr<Field>,
534  indexed_by<
535  ordered_unique<tag<BitFieldId_mi_tag>,
536  const_mem_fun<Field, const BitFieldId &, &Field::getId>,
537  LtBit<BitFieldId>>>>
539 
540 /** \brief Set field coordinate system
541  * \ingroup ent_multi_indices
542  */
544  boost::shared_ptr<CoordSys> csPtr;
545  FieldChangeCoordinateSystem(const boost::shared_ptr<CoordSys> &cs_ptr)
546  : csPtr(cs_ptr) {}
547  void operator()(boost::shared_ptr<Field> &e) { e->coordSysPtr = csPtr; }
548 };
549 
550 } // namespace MoFEM
551 
552 #endif // __FIELDMULTIINDICES_HPP__
unsigned int getBitNumber() const
std::vector< ApproximationOrder > & getDofOrderMap(const EntityType type) const
get hash-map relating dof index on entity with its order
Tag th_AppOrder
Tag storing approximation order on entity.
std::string getName() const
Get field name.
interface_Field(const interface_Field< T > &interface)
const void * tagName
tag keeps name of the field
SequenceDofContainer sequenceDofContainer
MoFEMErrorCode get_E_Base(const double m[]) const
MoFEMErrorCode get_E_DualBase(const double m[]) const
Get reference dual base vectors.
int getCoordSysDim(const int d=0) const
Get dimension of general two-point tensor MoFEM::CoordSys::getDim.
FieldChangeCoordinateSystem(const boost::shared_ptr< CoordSys > &cs_ptr)
EntityHandle getCoordSysMeshSet() const
Provide data structure for (tensor) field approximation.The Field is intended to provide support for ...
keeps information about DOF on the entity
friend std::ostream & operator<<(std::ostream &os, const Field &e)
const void * tagNamePrefixData
tag keeps name prefix of the field
void operator()(boost::shared_ptr< Field > &e)
#define MoFEMFunctionBeginHot
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:501
TagType th_FieldDataVertsType
interface_Field(const boost::shared_ptr< T > &field_ptr)
EntityHandle meshSet
keeps entities for this meshset
FieldCoefficientsNumber getNbOfCoeffs() const
multi_index_container< boost::shared_ptr< Field >, indexed_by< hashed_unique< tag< BitFieldId_mi_tag >, const_mem_fun< Field, const BitFieldId &, &Field::getId >, HashBit< BitFieldId >, EqBit< BitFieldId > >, ordered_unique< tag< Meshset_mi_tag >, member< Field, EntityHandle, &Field::meshSet > >, ordered_unique< tag< FieldName_mi_tag >, const_mem_fun< Field, boost::string_ref, &Field::getNameRef > >, ordered_non_unique< tag< BitFieldId_space_mi_tag >, const_mem_fun< Field, FieldSpace, &Field::getSpace > > > > Field_multiIndex
Field_multiIndex for Field.
boost::string_ref getCoordSysNameRef() const
boost::function< int(const int order)> FieldOrderFunct
user adjacency function
FieldOrderFunct FieldOrderTable[MBMAXTYPE]
user adjacency function table
FieldCoefficientsNumber getNbOfCoeffs() const
Get number of field coefficients.
MoFEMErrorCode get_e_DualBase(const double m[]) const
Get current dual base vectors.
boost::string_ref getNameRef() const
Get string reference to field name.
SequenceEntContainer & getEntSequenceContainer() const
Get reference to sequence data container.
Struct keeps handle to entity in the field.
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:508
MoFEMErrorCode get_E_DualBase(const double m[]) const
Field(const moab::Interface &moab, const EntityHandle meshset, const boost::shared_ptr< CoordSys > coord_sys_ptr)
constructor for moab field
Pointer interface for MoFEM::Field.
implementation of Data Operators for Forces and Sources
Definition: Common.hpp:21
FieldSpace getSpace() const
Get field approximation space.
MoFEMErrorCode rebuildDofsOrderMap() const
boost::string_ref getNameRef() const
EntityHandle getMeshset() const
FieldOrderTable forderTable
nb. DOFs table for entities
SequenceDofContainer & getDofSequenceContainer() const
Get reference to sequence data container.
std::string getName() const
std::string getCoordSysName() const
Get coordinate system name.
FieldSpace * tagSpaceData
tag keeps field space
EntityHandle getCoordSysMeshSet() const
Returns meshset on which Tags defining coordinate system are stored.
FieldSpace getSpace() const
const Tensor1_Expr< const dTensor0< T, Dim, i >, typename promote< T, double >::V, Dim, i > d(const Tensor0< T * > &a, const Index< i, Dim > index, const Tensor1< int, Dim > &d_ijk, const Tensor1< double, Dim > &d_xyz)
Definition: dTensor0.hpp:27
FieldApproximationBase
approximation base
Definition: definitions.h:143
FieldCoefficientsNumber * tagNbCoeffData
SequenceEntContainer sequenceEntContainer
boost::string_ref getCoordSysNameRef() const
Get coordinate system name.
#define BITFIELDID_SIZE
max number of fields
Definition: definitions.h:280
PetscErrorCode MoFEMErrorCode
MoFEM/PETSc error code.
Definition: Exceptions.hpp:66
int getCoordSysDim(const int d=0) const
Get dimension of general two-point tensor MoFEM::CoordSys::getDim.
const BitFieldId & getId() const
Get unique field id.
boost::shared_ptr< CoordSys > coordSysPtr
Pointer to field coordinate system data structure.
multi_index_container< boost::shared_ptr< Field >, indexed_by< ordered_unique< tag< BitFieldId_mi_tag >, const_mem_fun< Field, const BitFieldId &, &Field::getId >, LtBit< BitFieldId > > > > Field_multiIndex_view
FieldApproximationBase getApproxBase() const
Get approximation base.
UId generateGlobalUniqueIdForTypeHi(const EntityType type, const int owner_proc) const
FieldApproximationBase getApproxBase() const
const BitFieldId & getId() const
std::array< std::array< int, MAX_DOFS_ON_ENTITY >, MBMAXTYPE > DofsOrderMap
multi_index_container< boost::weak_ptr< std::vector< DofEntity > >, indexed_by< sequenced<> > > SequenceDofContainer
Tag th_FieldDataVerts
Tag storing field values on vertices in the field.
FieldSpace
approximation spaces
Definition: definitions.h:168
FieldOrderTable & getFieldOrderTable()
Get the Field Order Table.
FieldApproximationBase * tagBaseData
tag keeps field base
std::bitset< BITFIELDID_SIZE > BitFieldId
Field Id.
Definition: Types.hpp:53
DofsOrderMap dofOrderMap
static UId generateGlobalUniqueIdForTypeLo(const char bit_number, const EntityType type, const int owner_proc)
unsigned int getBitNumberCalculate() const
Calculate number of set bit in Field ID. Each field has uid, get getBitNumber get number of bit set f...
unsigned int getBitNumber() const
Get number of set bit in Field ID. Each field has uid, get getBitNumber get number of bit set for giv...
MoFEMErrorCode get_e_Base(const double m[]) const
Get current dual base vectors.
boost::shared_ptr< T > & getFieldPtr() const
multi_index_container< boost::weak_ptr< std::vector< FieldEntity > >, indexed_by< sequenced<> > > SequenceEntContainer
int tagNameSize
number of bits necessary to keep field name
MoFEMErrorCode get_e_Base(const double m[]) const
MoFEMErrorCode get_E_Base(const double m[]) const
Get reference base vectors.
moab::Interface & moab
UId generateGlobalUniqueIdForTypeLo(const EntityType type, const int owner_proc) const
EntityHandle getMeshset() const
Get field meshset.
static UId generateGlobalUniqueIdForTypeHi(const char bit_number, const EntityType type, const int owner_proc)
#define MB_ID_WIDTH
Definition: definitions.h:289
DofsOrderMap & getDofOrderMap() const
get hash-map relating dof index on entity with its order
std::string getCoordSysName() const
uint128_t UId
Unique Id.
Definition: Types.hpp:41
Set field coordinate system.
unsigned int bitNumber
boost::shared_ptr< T > sFieldPtr
Tag th_FieldData
Tag storing field values on entity in the field.
const int order
approximation order
std::array< int, MAX_DOFS_ON_ENTITY > & getDofOrderMap(const EntityType type) const
get hash-map relating dof index on entity with its order
boost::shared_ptr< CoordSys > csPtr
BitFieldId * tagId
tag keeps field id
MoFEMErrorCode get_e_DualBase(const double m[]) const