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