v0.8.17
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  moab::Interface &moab;
75 
76  EntityHandle meshSet; ///< keeps entities for this meshset
77  boost::shared_ptr<CoordSys>
78  coordSysPtr; ///< Pointer to field coordinate system data structure
79 
80  TagType th_FieldDataVertsType; // Tag type for storing data on vertices
81  Tag th_FieldDataVerts; ///< Tag storing field values on vertices in the field
82  Tag th_FieldData; ///< Tag storing field values on entity in the field
83  Tag th_AppOrder; ///< Tag storing approximation order on entity
84 
85  BitFieldId *tagId; ///< tag keeps field id
86  FieldSpace *tagSpaceData; ///< tag keeps field space
87  FieldApproximationBase *tagBaseData; ///< tag keeps field base
88 
89  /// tag keeps field rank (dimension, f.e. Temperature field has rank 1,
90  /// displacements field in 3d has rank 3)
92  const void *tagName; ///< tag keeps name of the field
93  int tagNameSize; ///< number of bits necessary to keep field name
94  const void *tagNamePrefixData; ///< tag keeps name prefix of the field
95  int tagNamePrefixSize; ///< number of bits necessary to keep field name
96  ///< prefix
97  FieldOrderTable forderTable; ///< nb. DOFs table for entities
98 
99  /**
100  * @brief Get the Field Order Table
101  *
102  * @return FieldOrderTable&
103  */
105 
106  /**
107  * Field Id is bit set. Each field has only one bit on, bitNumber stores
108  * number of set bit
109  */
110  unsigned int bitNumber;
111 
112  static UId generateGlobalUniqueIdForTypeLo(const char bit_number,
113  const EntityType type,
114  const int owner_proc) {
115  constexpr int ent_shift = 8 * sizeof(EntityHandle);
116  return (static_cast<UId>(type) << MB_ID_WIDTH |
117  static_cast<UId>(bit_number) << 8 * sizeof(EntityHandle) |
118  static_cast<UId>(owner_proc) << 5 + ent_shift)
119  << 9;
120  }
121 
122  UId generateGlobalUniqueIdForTypeLo(const EntityType type,
123  const int owner_proc) const {
124  return generateGlobalUniqueIdForTypeLo(bitNumber, type, owner_proc);
125  }
126 
127  static UId generateGlobalUniqueIdForTypeHi(const char bit_number,
128  const EntityType type,
129  const int owner_proc) {
130  constexpr int ent_shift = 8 * sizeof(EntityHandle);
131  return (static_cast<UId>(type) << MB_ID_WIDTH |
132  static_cast<UId>(bit_number) << ent_shift |
133  static_cast<UId>(owner_proc) << 5 + ent_shift)
134  << 9;
135  }
136 
137  UId generateGlobalUniqueIdForTypeHi(const EntityType type,
138  const int owner_proc) const {
139  return generateGlobalUniqueIdForTypeHi(bitNumber, type, owner_proc);
140  }
141 
142  /**
143  * \brief constructor for moab field
144  *
145  * \param meshset which keeps entities for this field
146  */
147  Field(const Interface &moab, const EntityHandle meshset,
148  const boost::shared_ptr<CoordSys> coord_sys_ptr);
149 
150  /**
151  * \brief Get field meshset
152  *
153 
154  * To meshsets entity are attached Tags which keeps basic information about
155  * field. Those information is field name, approximation base, approximation
156  * space, id, etc.
157 
158  * In meshset contains entities on which given filed is sparing. Type of
159  entities
160  * depended on approximations space.
161 
162  * @return EntityHandle
163  */
164  inline EntityHandle getMeshset() const { return meshSet; }
165 
166  /**
167  * \brief Get dimension of general two-point tensor \ref
168  MoFEM::CoordSys::getDim
169 
170  See details here \ref MoFEM::CoordSys::getDim
171 
172  */
173  inline int getCoordSysDim(const int d = 0) const {
174  return coordSysPtr->getDim(d);
175  }
176 
177  /**
178  * \brief Get reference base vectors
179  * @param Array where coefficients (covariant) are returned
180  * @return Error code
181  */
182  inline MoFEMErrorCode get_E_Base(const double m[]) const {
184  MoFEMFunctionReturnHot(coordSysPtr->get_E_Base(m));
185  }
186 
187  /**
188  * \brief Get reference dual base vectors
189  * @param Array where coefficients (contravariant) are returned
190  * @return Error code
191  */
192  inline MoFEMErrorCode get_E_DualBase(const double m[]) const {
194  MoFEMFunctionReturnHot(coordSysPtr->get_E_DualBase(m));
195  }
196 
197  /**
198  * \brief Get current dual base vectors
199  * @param Array where coefficients (covariant) are returned
200  * @return Error code
201  */
202  inline MoFEMErrorCode get_e_Base(const double m[]) const {
204  MoFEMFunctionReturnHot(coordSysPtr->get_e_Base(m));
205  }
206 
207  /**
208  * \brief Get current dual base vectors
209  * @param Array where coefficients (covariant) are returned
210  * @return Error code
211  */
212  inline MoFEMErrorCode get_e_DualBase(const double m[]) const {
214  MoFEMFunctionReturnHot(coordSysPtr->get_e_DualBase(m));
215  }
216 
217  /**
218  * \brief Returns meshset on which Tags defining coordinate system are stored
219  * @return Coordinate system EntityHandle
220  */
222  return coordSysPtr->getMeshset();
223  }
224 
225  /**
226  * \brief Get coordinate system name
227  * @return Coordinate system name
228  */
229  inline std::string getCoordSysName() const { return coordSysPtr->getName(); }
230 
231  /**
232  * \brief Get coordinate system name
233  * @return Return string_ref with name.
234  */
235  inline boost::string_ref getCoordSysNameRef() const {
236  return coordSysPtr->getNameRef();
237  }
238 
239  /**
240  * \brief Get unique field id.
241  * @return Filed ID
242  */
243  inline const BitFieldId &getId() const { return *((BitFieldId *)tagId); }
244 
245  /**
246  * \brief Get string reference to field name
247  * @return Field name
248  */
249  inline boost::string_ref getNameRef() const {
250  return boost::string_ref((char *)tagName, tagNameSize);
251  }
252 
253  /**
254  * \brief Get field name
255  * @return Field name
256  */
257  inline std::string getName() const {
258  return std::string((char *)tagName, tagNameSize);
259  }
260 
261  /**
262  * \brief Get field approximation space
263  * @return approximation space
264  */
265  inline FieldSpace getSpace() const { return *tagSpaceData; }
266 
267  /**
268  * \brief Get approximation base
269  * @return Approximation base
270  */
272 
273  /** \brief Get number of field coefficients
274  *
275 
276  * Scalar field has only one coefficient, vector field in 3D has three. In
277  * general number determine space needed to keep data on entities. What
278  coefficient
279  * means depend on interpretation and associated coordinate system. For
280  example
281  * 3 coefficient means could be covariant or contravariant, or mean three
282  temperatures
283  * for mixture of solid, air and water, etc.
284 
285 
286  */
288  return *tagNbCoeffData;
289  };
290 
291  /**
292  * \brief Get number of set bit in Field ID.
293  * Each field has uid, get getBitNumber get number of bit set for given field.
294  * Field ID has only one bit set for each field.
295  */
296  inline unsigned int getBitNumber() const { return bitNumber; }
297 
298  /**
299  * \brief Calculate number of set bit in Field ID.
300  * Each field has uid, get getBitNumber get number of bit set for given field.
301  * Field ID has only one bit set for each field.
302  */
303  inline unsigned int getBitNumberCalculate() const {
304  int b = ffsl(((BitFieldId *)tagId)->to_ulong());
305  if (b != 0)
306  return b;
307  for (int ll = 1; ll < BITFIELDID_SIZE / 32; ll++) {
308  BitFieldId id;
309  id = (*tagId) >> ll * 32;
310  b = ll * 32 + ffsl(id.to_ulong());
311  if (b != 0)
312  return b;
313  }
314  return 0;
315  }
316 
317  friend std::ostream &operator<<(std::ostream &os, const Field &e);
318 
319  /**
320  * \brief Get reference to sequence data container
321  *
322  * In sequence data container data are physically stored. The purpose of this
323  * is to allocate MoFEMEntities data in bulk, having only one allocation
324  * instead each time entity is inserted. That makes code efficient.
325  *
326  * The vector in sequence is destroyed if last entity inside that vector is
327  * destroyed. All MoFEM::MoFEMEntities have aliased shared_ptr which points to
328  * the vector.
329  *
330  * @return MoFEM::Field::SequenceEntContainer
331  */
332  inline boost::shared_ptr<SequenceEntContainer> &
334  return sequenceEntContainer;
335  }
336 
337  /**
338  * \brief Get reference to sequence data container
339  *
340  * In sequence data container data are physically stored. The purpose of this
341  * is to allocate DofEntity data in bulk, having only one allocation instead
342  * each time entity is inserted. That makes code efficient.
343  *
344  * The vector in sequence is destroyed if last entity inside that vector is
345  * destroyed. All MoFEM::MoFEMEntities have aliased shared_ptr which points to
346  the vector.
347 
348  * Not all DOFs are starred in this way, currently such cases are considered;
349  * - DOFs on vertices. That is exploited that for H1 space, there is some
350  * fixed number of DOFs on each vertex
351 
352  * For other cases, DOFs are stored locally in each MoFEM::MoFEMEntities.
353 
354  * @return MoFEM::Field::SequenceDofContainer
355  */
356  inline boost::shared_ptr<SequenceDofContainer> &
358  return sequenceDofContainer;
359  }
360 
361  /**
362  * \brief get hash-map relating dof index on entity with its order
363  *
364  * Dofs of given field are indexed on entity
365  * of the same type, same space, approximation base and number of
366  * coefficients, are sorted in the way.
367  *
368  */
369  inline std::vector<ApproximationOrder> &
370  getDofOrderMap(const EntityType type) const {
371  return dofOrderMap[type];
372  }
373 
374 private:
375  mutable boost::shared_ptr<SequenceEntContainer> sequenceEntContainer;
376  mutable boost::shared_ptr<SequenceDofContainer> sequenceDofContainer;
377 
378  mutable std::map<EntityType, std::vector<int>> dofOrderMap;
379 };
380 
381 /**
382  * \brief Pointer interface for MoFEM::Field
383  *
384  * MoFEM::Field class is keeps data and methods. This class is interface to that
385  * class, and all other classes, like MoFEMEntities, DofEntity and derived form
386  * them inherits pointer interface, not MoFEM::Field class directly.
387  *
388  * \ingroup dof_multi_indices
389  */
390 template <typename T> struct interface_Field {
391 
392  mutable boost::shared_ptr<T> sFieldPtr;
393 
394  interface_Field(const boost::shared_ptr<T> &field_ptr)
395  : sFieldPtr(field_ptr) {}
396 
398  : sFieldPtr(interface.getFieldPtr()) {}
399 
400  virtual ~interface_Field() {}
401 
402  inline EntityHandle getMeshset() const {
403  return this->sFieldPtr->getMeshset();
404  }
405 
406  inline int getCoordSysId() const { return this->sFieldPtr->getCoordSysId(); }
407 
408  /**
409  * \brief Get dimension of general two-point tensor \ref
410  MoFEM::CoordSys::getDim
411 
412  See details here \ref MoFEM::CoordSys::getDim
413 
414  */
415  inline int getCoordSysDim(const int d = 0) const {
416  return this->sFieldPtr->getCoordSysDim(d);
417  }
418 
419  inline MoFEMErrorCode get_E_Base(const double m[]) const {
421  MoFEMFunctionReturnHot(this->sFieldPtr->get_E_Base(m));
422  }
423  inline MoFEMErrorCode get_E_DualBase(const double m[]) const {
425  MoFEMFunctionReturnHot(this->sFieldPtr->get_E_DualBase(m));
426  }
427  inline MoFEMErrorCode get_e_Base(const double m[]) const {
429  MoFEMFunctionReturnHot(this->sFieldPtr->get_e_Base(m));
430  }
431 
432  inline MoFEMErrorCode get_e_DualBase(const double m[]) const {
434  MoFEMFunctionReturnHot(this->sFieldPtr->get_e_DualBase(m));
435  }
436 
437  /// @return return meshset for coordinate system
439  return this->sFieldPtr->getCoordSysMeshSet();
440  }
441 
442  /// @return return coordinate system name for field
443  inline std::string getCoordSysName() const {
444  return this->sFieldPtr->getCoordSysName();
445  }
446 
447  /// @return return coordinate system name for field
448  inline boost::string_ref getCoordSysNameRef() const {
449  return this->sFieldPtr->getCoordSysNameRef();
450  }
451 
452  /// @return get field Id
453  inline const BitFieldId &getId() const { return this->sFieldPtr->getId(); }
454 
455  /// @return get field name
456  inline boost::string_ref getNameRef() const {
457  return this->sFieldPtr->getNameRef();
458  }
459 
460  /// @return get field name
461  inline std::string getName() const { return this->sFieldPtr->getName(); }
462 
463  /// @return get approximation space
464  inline FieldSpace getSpace() const { return this->sFieldPtr->getSpace(); }
465 
466  /// @return get approximation base
468  return this->sFieldPtr->getApproxBase();
469  }
470 
471  /// @return get number of coefficients for DOF
473  return this->sFieldPtr->getNbOfCoeffs();
474  }
475 
476  /// @return get bit number if filed Id
477  inline unsigned int getBitNumber() const {
478  return this->sFieldPtr->getBitNumber();
479  }
480 
481  /// @return get pointer to the field data structure
482  inline boost::shared_ptr<T> &getFieldPtr() const { return this->sFieldPtr; }
483 
484  /**
485  * \brief get hash-map relating dof index on entity with its order
486  *
487  * Dofs of given field are indexed on entity
488  * of the same type, same space, approximation base and number of
489  * coefficients, are sorted in the way.
490  *
491  */
492  inline std::vector<ApproximationOrder> &
493  getDofOrderMap(const EntityType type) const {
494  return this->sFieldPtr->getDofOrderMap(type);
495  }
496 };
497 
498 /**
499  * @relates multi_index_container
500  * \brief Field_multiIndex for Field
501  *
502  */
503 typedef multi_index_container<
504  boost::shared_ptr<Field>,
505  indexed_by<
506  hashed_unique<tag<BitFieldId_mi_tag>,
507  const_mem_fun<Field, const BitFieldId &, &Field::getId>,
508  HashBit<BitFieldId>, EqBit<BitFieldId>>,
509  ordered_unique<tag<Meshset_mi_tag>,
510  member<Field, EntityHandle, &Field::meshSet>>,
511  ordered_unique<
512  tag<FieldName_mi_tag>,
513  const_mem_fun<Field, boost::string_ref, &Field::getNameRef>>,
514  ordered_non_unique<tag<BitFieldId_space_mi_tag>,
515  const_mem_fun<Field, FieldSpace, &Field::getSpace>>>>
517 
518 typedef multi_index_container<
519  boost::shared_ptr<Field>,
520  indexed_by<
521  ordered_unique<tag<BitFieldId_mi_tag>,
522  const_mem_fun<Field, const BitFieldId &, &Field::getId>,
523  LtBit<BitFieldId>>>>
525 
526 /** \brief Set field coordinate system
527  * \ingroup ent_multi_indices
528  */
530  boost::shared_ptr<CoordSys> csPtr;
531  FieldChangeCoordinateSystem(const boost::shared_ptr<CoordSys> &cs_ptr)
532  : csPtr(cs_ptr) {}
533  void operator()(boost::shared_ptr<Field> &e) { e->coordSysPtr = csPtr; }
534 };
535 
536 } // namespace MoFEM
537 
538 #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
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)
PetscErrorCode MoFEMErrorCode
MoFEM/PETSc error code.
Definition: Common.hpp:60
EntityHandle getCoordSysMeshSet() const
std::vector< ApproximationOrder > & getDofOrderMap(const EntityType type) const
get hash-map relating dof index on entity with its order
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:491
TagType th_FieldDataVertsType
interface_Field(const boost::shared_ptr< T > &field_ptr)
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
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::shared_ptr< SequenceEntContainer > & getEntSequenceContainer() const
Get reference to sequence data container.
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.
std::bitset< BITFIELDID_SIZE > BitFieldId
Definition: Common.hpp:149
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:498
MoFEMErrorCode get_E_DualBase(const double m[]) const
Pointer interface for MoFEM::Field.
uint128_t UId
Unique Id.
Definition: Common.hpp:136
implementation of Data Operators for Forces and Sources
Definition: Common.hpp:21
FieldSpace getSpace() const
Get field approximation space.
boost::string_ref getNameRef() const
EntityHandle getMeshset() const
FieldOrderTable forderTable
nb. DOFs table for entities
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
FieldApproximationBase
approximation base
Definition: definitions.h:140
FieldCoefficientsNumber * tagNbCoeffData
boost::string_ref getCoordSysNameRef() const
Get coordinate system name.
#define BITFIELDID_SIZE
max number of fields
Definition: definitions.h:277
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
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:165
boost::shared_ptr< SequenceEntContainer > sequenceEntContainer
FieldOrderTable & getFieldOrderTable()
Get the Field Order Table.
FieldApproximationBase * tagBaseData
tag keeps field base
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
boost::shared_ptr< SequenceDofContainer > sequenceDofContainer
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.
Field(const Interface &moab, const EntityHandle meshset, const boost::shared_ptr< CoordSys > coord_sys_ptr)
constructor for moab field
static UId generateGlobalUniqueIdForTypeHi(const char bit_number, const EntityType type, const int owner_proc)
boost::shared_ptr< SequenceDofContainer > & getDofSequenceContainer() const
Get reference to sequence data container.
#define MB_ID_WIDTH
Definition: definitions.h:286
std::string getCoordSysName() const
std::map< EntityType, std::vector< int > > dofOrderMap
Set field coordinate system.
unsigned int bitNumber
boost::shared_ptr< T > sFieldPtr
Tag th_FieldData
Tag storing field values on entity in the field.
boost::shared_ptr< CoordSys > csPtr
BitFieldId * tagId
tag keeps field id
MoFEMErrorCode get_e_DualBase(const double m[]) const