v0.12.1
definitions.h
Go to the documentation of this file.
1 /** \file definitions.h
2  * \brief useful compiler directives and definitions
3  */
4 
5 /* MoFEM is free software: you can redistribute it and/or modify it under
6  * the terms of the GNU Lesser General Public License as published by the
7  * Free Software Foundation, either version 3 of the License, or (at your
8  * option) any later version.
9  *
10  * MoFEM is distributed in the hope that it will be useful, but WITHOUT
11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
13  * License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with MoFEM. If not, see <http://www.gnu.org/licenses/>
17  */
18 
19 #ifndef __DEFINITONS_H__
20 #define __DEFINITONS_H__
21 
22 #ifndef DEPRECATED
23 // taken from http://stackoverflow.com/questions/295120/c-mark-as-deprecated
24 #ifdef __GNUC__
25 #define DEPRECATED __attribute__((deprecated))
26 #elif defined(_MSC_VER)
27 #define DEPRECATED __declspec(deprecated)
28 #else
29 #pragma message("WARNING: You need to implement DEPRECATED for this compiler")
30 #define DEPRECATED
31 #endif
32 #endif
33 
34 /** \brief Error handling
35  *
36  * This is complementary to PETSC error codes. The numerical values for
37  * these are defined in include/petscerror.h. The names are defined in err.c
38  *
39  * MoAB error messages are defined in moab/Types.hpp
40  *
41  */
54  MOFEM_MOAB_ERROR = 110
55 };
56 
57 const static char *const MoFEMErrorCodesNames[] = {
58  "MOFEM_SUCCESS",
59  "MOFEM_DATA_INCONSISTENCY",
60  "MOFEM_NOT_IMPLEMENTED",
61  "MOFEM_NOT_FOUND",
62  "MOFEM_OPERATION_UNSUCCESSFUL",
63  "MOFEM_IMPOSIBLE_CASE",
64  "MOFEM_INVALID_DATA",
65  "MOFEM_MOFEMEXCEPTION_THROW",
66  "MOFEM_STD_EXCEPTION_THROW",
67  "MOFEM_ATOM_TEST_INVALID",
68  "MOFEM_MOAB_ERROR"};
69 
70 /// \brief approximation base
72  NOBASE = 0,
74  1, ///< Ainsworth Cole (Legendre) approx. base \cite NME:NME847
75  AINSWORTH_LOBATTO_BASE, ///< Like AINSWORTH_LEGENDRE_BASE but with Lobatto
76  ///< base instead Legendre \cite beriot2015efficient
77  AINSWORTH_BERNSTEIN_BEZIER_BASE, ///< See \cite ainsworth2011bernstein and
78  ///< \cite ainsworth2018bernstein
79  DEMKOWICZ_JACOBI_BASE, ///< Construction of base is by Demkowicz \cite
80  ///< fuentes2015orientation
81  USER_BASE, ///< user implemented approximation base
82  LASTBASE
83 };
84 
85 const static char *const ApproximationBaseNames[] = {
86  "NOBASE",
87  "AINSWORTH_LEGENDRE_BASE",
88  "AINSWORTH_LOBATTO_BASE",
89  "AINSWORTH_BERNSTEIN_BEZIER_BASE",
90  "DEMKOWICZ_JACOBI_BASE",
91  "USER_BASE",
92  "LASTBASE"};
93 
94 /// \brief approximation spaces
95 enum FieldSpace {
96  NOSPACE = 0,
97  NOFIELD = 1, ///< scalar or vector of scalars describe (no true field)
98  H1, ///< continuous field
99  HCURL, ///< field with continuous tangents
100  HDIV, ///< field with continuous normal traction
101  L2, ///< field with C-1 continuity
102  LASTSPACE ///< FieldSpace in [ 0, LASTSPACE )
103 };
104 
105 const static char *const FieldSpaceNames[] = {
106  "NOSPACE", "NOFIELD", "H1", "HCURL", "HDIV", "L2", "LASTSPACE"};
107 
108 /// \brief Those types control how functions respond on arguments, f.e. error
109 /// handling
111  MF_ZERO = 0,
112  MF_EXCL = 1 << 0,
113  MF_EXIST = 1 << 1,
114  MF_NOT_THROW = 1 << 2
115 };
116 
117 /**
118  * @brief Coordinate system names
119  *
120  */
121 const static char *const CoordinateTypesNames[] = {"Cartesian", "Polar",
122  "Cylindrical", "Spherical"};
123 /**
124  * @brief Coodinate system
125  *
126  */
133 };
134 
135 /// \brief RowColData
137 
138 /**
139  * Controls adjency multi_index container (e.g. BYROW is adjacenciecy by field
140  * on on rows), see \ref MoFEM::FieldEntityEntFiniteElementAdjacencyMap
141  *
142  */
143 enum ByWhat {
144  BYROW = 1 << 0,
145  BYCOL = 1 << 1,
146  BYDATA = 1 << 2,
147  BYROWDATA = 1 << 0 | 1 << 2,
148  BYCOLDATA = 1 << 1 | 1 << 2,
149  BYROWCOL = 1 << 0 | 1 << 1,
150  BYALL = 1 << 0 | 1 << 1 | 1 << 2
151 };
152 
153 /**
154  * \brief Types of sets and boundary conditions
155  *
156  */
157 enum CubitBC {
159  NODESET = 1 << 0,
160  SIDESET = 1 << 1,
161  BLOCKSET = 1 << 2,
162  MATERIALSET = 1 << 3,
163  DISPLACEMENTSET = 1 << 4,
164  FORCESET = 1 << 5,
165  PRESSURESET = 1 << 6,
166  VELOCITYSET = 1 << 7,
167  ACCELERATIONSET = 1 << 8,
168  TEMPERATURESET = 1 << 9,
169  HEATFLUXSET = 1 << 10,
170  INTERFACESET = 1 << 11,
171  UNKNOWNNAME = 1 << 12,
172  MAT_ELASTICSET = 1 << 13, ///< block name is "MAT_ELASTIC"
173  MAT_INTERFSET = 1 << 14,
174  MAT_THERMALSET = 1 << 15, ///< block name is "MAT_THERMAL"
175  BODYFORCESSET = 1 << 16, ///< block name is "BODY_FORCES"
176  MAT_MOISTURESET = 1 << 17, ///< block name is "MAT_MOISTURE"
177  DIRICHLET_BC = 1 << 18,
178  NEUMANN_BC = 1 << 19,
179  LASTSET_BC = 1 << 20
180 };
181 
182 // OFF_DEPRECATED static const unsigned int UNKNOWNCUBITNAME = UNKNOWNNAME;
183 // OFF_DEPRECATED static const unsigned int LASTCUBITSET = LASTSET_BC;
184 
185 /**
186  * \brief Names of types of sets and boundary conditions
187  */
188 const static char *const CubitBCNames[] = {
189  "UNKNOWNSET", "NODESET", "SIDESET", "BLOCKSET",
190  "MATERIALSET", "DISPLACEMENTSET", "FORCESET", "PRESSURESET",
191  "VELOCITYSET", "ACCELERATIONSET", "TEMPERATURESET", "HEATFLUXSET",
192  "INTERFACESET", "UNKNOWNNAME", "MAT_ELASTICSET", "MAT_INTERFSET",
193  "MAT_THERMALSET", "BODYFORCESSET", "MAT_MOISTURESET", "DIRICHLET_BC",
194  "NEUMANN_BC", "LASTSET_BC"};
195 
196 /**
197  * \brief Format in rows of vectorial base functions
198  */
200 
201 /**
202  * \brief Format in rows of vectorial base gradients of base functions
203  */
205  HVEC0_0 = 0,
213  HVEC2_2
214 };
215 
216 /**
217  * \brief Verbosity levels
218  */
221  QUIET = 0,
225  VERY_NOISY
226 };
227 
228 #define MYPCOMM_INDEX 0 ///< default communicator number PCOMM
229 
230 #define MAX_CORE_TMP 1 ///< maximal number of cores
231 #define BITREFEDGES_SIZE 32 ///< number refined edges
232 #define BITREFLEVEL_SIZE 128 ///< max number of refinements
233 #define BITFIELDID_SIZE 32 ///< max number of fields
234 #define BITFEID_SIZE 32 ///< max number of finite elements
235 #define BITPROBLEMID_SIZE 32 ///< max number of problems
236 #define BITINTERFACEUID_SIZE 32
237 
238 // This Is form MOAB
239 #define MB_TYPE_WIDTH 4
240 #define MB_ID_WIDTH (8 * sizeof(EntityHandle) - MB_TYPE_WIDTH)
241 #define MB_TYPE_MASK ((EntityHandle)0xF << MB_ID_WIDTH)
242 // 2^MB_TYPE_WIDTH-1 ------^
243 
244 #define MB_START_ID ((EntityID)1) ///< All entity id's currently start at 1
245 #define MB_END_ID \
246  ((EntityID)MB_ID_MASK) ///< Last id is the complement of the MASK
247 #define MB_ID_MASK (~MB_TYPE_MASK)
248 
249 #define MAX_DOFS_ON_ENTITY 512 ///< Maximal number of DOFs on entity
250 #define MAX_PROCESSORS_NUMBER 1024 ///< Maximal number of processors
251 #define DOF_UID_MASK \
252  (MAX_DOFS_ON_ENTITY - 1) ///< Mask for DOF number on entity form UId
253 #define ENTITY_UID_MASK (~DOF_UID_MASK)
254 
255 #define NOT_USED(x) ((void)(x))
256 
257 /** \brief set barrier start
258  * Run code in sequence, starting from process 0, and ends on last process.
259  *
260  * It can be only used for testing. Do not use that function as a part of these
261  * code.
262  *
263  */
264 #define BARRIER_PCOMM_RANK_START(PCMB) \
265  { \
266  for (unsigned int i = 0; i < PCMB->proc_config().proc_rank(); i++) \
267  MPI_Barrier(PCMB->proc_config().proc_comm()); \
268  };
269 
270 /** \deprecated Do use this macro, instead use BARRIER_PCOMM_RANK_START
271  */
272 #define BARRIER_RANK_START(PCMB) \
273  { \
274  macro_is_deprecated_using_deprecated_function(); \
275  for (unsigned int i = 0; i < PCMB->proc_config().proc_rank(); i++) \
276  MPI_Barrier(PCMB->proc_config().proc_comm()); \
277  };
278 
279 /** \brief set barrier start
280  * Run code in sequence, starting from process 0, and ends on last process.
281  *
282  * It can be only used for testing. Do not use that function as a part of these
283  * code.
284  *
285  */
286 #define BARRIER_PCOMM_RANK_END(PCMB) \
287  { \
288  for (unsigned int i = PCMB->proc_config().proc_rank(); \
289  i < PCMB->proc_config().proc_size(); i++) \
290  MPI_Barrier(PCMB->proc_config().proc_comm()); \
291  };
292 
293 /** \deprecated Do use this macro, instead use BARRIER_PCOMM_RANK_START
294  */
295 #define BARRIER_RANK_END(PCMB) \
296  { \
297  macro_is_deprecated_using_deprecated_function(); \
298  for (unsigned int i = PCMB->proc_config().proc_rank(); \
299  i < PCMB->proc_config().proc_size(); i++) \
300  MPI_Barrier(PCMB->proc_config().proc_comm()); \
301  };
302 
303 /** \brief set barrier start
304  * Run code in sequence, starting from process 0, and ends on last process.
305  *
306  * It can be only used for testing. Do not use that function as a part of these
307  * code.
308  *
309  */
310 #define BARRIER_MOFEM_RANK_START(MOFEM) \
311  { \
312  for (int i = 0; i < (MOFEM)->get_comm_rank(); i++) \
313  MPI_Barrier((MOFEM)->get_comm()); \
314  };
315 
316 /** \brief set barrier start
317  * Run code in sequence, starting from process 0, and ends on last process.
318  *
319  * It can be only used for testing. Do not use that function as a part of these
320  * code.
321  *
322  */
323 #define BARRIER_MOFEM_RANK_END(MOFEM) \
324  { \
325  for (int i = (MOFEM)->get_comm_rank(); i < (MOFEM)->get_comm_size(); i++) \
326  MPI_Barrier((MOFEM)->get_comm()); \
327  };
328 
329 #ifdef __cplusplus
330 extern "C" {
331 #endif
332 
333 /**
334  * \brief Is used to indicate that macro is deprecated
335  * Do nothing just triggers error at the compilation
336  */
338 
339 #ifdef __cplusplus
340 }
341 #endif
342 
343 /**
344  * \brief First executable line of each MoFEM function, used for error handling.
345  Final line of MoFEM functions should be MoFEMFunctionReturn(0);
346 
347  \node Not collective
348 
349  Example
350  \code
351  PetscErrorCode fun() {
352  int something;
353  MoFEMFunctionBegin;
354  MoFEMFunctionReturn(0);
355  }
356  \endcode
357 
358  */
359 #define MoFEMFunctionBegin \
360  PetscFunctionBegin; \
361  try {
362 
363 /**
364  * @brief \brief Catch errors
365  *
366  * Usage in main functions
367  * \code
368  * int main(int argc, char *argv[]) {
369  *
370  * MoFEM::Core::Initialize(&argc, &argv, (char *)0, help);
371  *
372  * try {
373  *
374  * // More code here
375  *
376  * }
377  * CATCH_ERRORS;
378  *
379  * return MoFEM::Core::Finalize();
380  *
381  * }
382  * \endcode
383  *
384  */
385 #define CATCH_ERRORS \
386  catch (MoFEMExceptionInitial const &ex) { \
387  return PetscError(PETSC_COMM_SELF, ex.lINE, PETSC_FUNCTION_NAME, __FILE__, \
388  ex.errorCode, PETSC_ERROR_INITIAL, ex.what()); \
389  } \
390  catch (MoFEMExceptionRepeat const &ex) { \
391  return PetscError(PETSC_COMM_SELF, ex.lINE, PETSC_FUNCTION_NAME, __FILE__, \
392  ex.errorCode, PETSC_ERROR_REPEAT, " "); \
393  } \
394  catch (MoFEMException const &ex) { \
395  SETERRQ(PETSC_COMM_SELF, ex.errorCode, ex.errorMessage); \
396  } \
397  catch (boost::bad_weak_ptr & ex) { \
398  std::string message("Boost bad weak ptr: " + std::string(ex.what()) + \
399  " at " + boost::lexical_cast<std::string>(__LINE__) + \
400  " : " + std::string(__FILE__) + " in " + \
401  std::string(PETSC_FUNCTION_NAME)); \
402  SETERRQ(PETSC_COMM_SELF, MOFEM_STD_EXCEPTION_THROW, message.c_str()); \
403  } \
404  catch (std::out_of_range & ex) { \
405  std::string message("Std out of range error: " + std::string(ex.what()) + \
406  " at " + boost::lexical_cast<std::string>(__LINE__) + \
407  " : " + std::string(__FILE__) + " in " + \
408  std::string(PETSC_FUNCTION_NAME)); \
409  SETERRQ(PETSC_COMM_SELF, MOFEM_STD_EXCEPTION_THROW, message.c_str()); \
410  } \
411  catch (std::exception const &ex) { \
412  std::string message("Std error: " + std::string(ex.what()) + " at " + \
413  boost::lexical_cast<std::string>(__LINE__) + " : " + \
414  std::string(__FILE__) + " in " + \
415  std::string(PETSC_FUNCTION_NAME)); \
416  SETERRQ(PETSC_COMM_SELF, MOFEM_STD_EXCEPTION_THROW, message.c_str()); \
417  }
418 
419 /**
420  * \brief Last executable line of each PETSc function used for error handling.
421  * Replaces return()
422  * @param a error code
423  *
424  * \note MoFEMFunctionReturn has to be used with MoFEMFunctionBegin and can be
425  * used only at the end of the function. If is need to return function in
426  * earlier use MoFEMFunctionReturnHot
427  *
428  */
429 #define MoFEMFunctionReturn(a) \
430  } \
431  CATCH_ERRORS \
432  PetscFunctionReturn(a)
433 
434 /**
435  * \brief First executable line of each MoFEM function, used for error
436  handling. Final line of MoFEM functions should be MoFEMFunctionReturn(0); Use
437  of this function allows for lighter profiling by default.
438 
439  \node Not collective
440 
441  Example:
442  \code
443  PetscErrorCode fun() {
444  int something;
445  MoFEMFunctionBeginHot;
446 
447  // some work here
448 
449  MoFEMFunctionReturnHot(0);
450  }
451  \endcode
452 */
453 #define MoFEMFunctionBeginHot PetscFunctionBeginHot
454 
455 /**
456  * \brief Last executable line of each PETSc function used for error handling.
457  * Replaces return()
458  * @param a error code
459  */
460 #define MoFEMFunctionReturnHot(a) PetscFunctionReturn(a)
461 
462 #define CHKERRQ_PETSC(n) CHKERRQ(n)
463 /**
464  * \brief check error code of MoAB function
465  * @param a MoABErrorCode
466  */
467 #define CHKERRQ_MOAB(a) \
468  if (PetscUnlikely(MB_SUCCESS != (a))) { \
469  std::string error_str = (unsigned)(a) <= (unsigned)MB_FAILURE \
470  ? moab::ErrorCodeStr[a] \
471  : "INVALID ERROR CODE"; \
472  std::string str("MOAB error (" + boost::lexical_cast<std::string>((a)) + \
473  ") " + error_str + " at line " + \
474  boost::lexical_cast<std::string>(__LINE__) + " : " + \
475  std::string(__FILE__)); \
476  SETERRQ(PETSC_COMM_SELF, MOFEM_MOAB_ERROR, str.c_str()); \
477  }
478 
479 /**
480  * \brief Check error code of MoFEM/MOAB/PETSc function
481  * @param a MoFEMErrorCode
482  *
483  * \code
484  * MoFEMErrorCode fun() {
485  * MoFEMFunctionBeginHot;
486  * rval = fun_moab(); CHKERRG(rval);
487  * ierr = fun_petsc(); CHKERRG(ierr);
488  * merr = fun_mofem(); CHKERRG(merr);
489  * MoFEMFunctionReturnHot(0);
490  * \endcode
491  *
492  * \note Function detect type of errocode using specialized template function
493  * getErrorType, i.e. condition is evaluated at compilation time.
494  *
495  */
496 #define CHKERRG(n) \
497  if ((boost::is_same<BOOST_TYPEOF((n)), \
498  MoFEMErrorCodeGeneric<PetscErrorCode>>::value)) { \
499  CHKERRQ_PETSC((n)); \
500  } else if (boost::is_same<BOOST_TYPEOF((n)), \
501  MoFEMErrorCodeGeneric<moab::ErrorCode>>::value) { \
502  CHKERRQ_MOAB((n)); \
503  }
504 
505 /**
506  * @brief Inline error check
507  *
508  * \code
509  *
510  * MoFEMErrorCode foo() {
511  * MoFEMFunctionBegin;
512  *
513  * // Call other functions
514  * CHKERR fun_moab();
515  * CHKERR fun_petsc();
516  * CHKERR fun_mofem();
517  *
518  * // Throw error
519  * SETERRQ(PETSC_COMM_WORLD, MOFEM_DATA_INCONSISTENCY, "Some error message");
520  *
521  * MoFEMFunctionReturn(0);
522  * }
523  *
524  * int main(int argc, char *argv[]) {
525  *
526  * // Initailise MoFEM and Petsc
527  * MoFEM::Core::Initialize(&argc, &argv, (char *)0, help);
528  *
529  * try {
530  *
531  * moab::Core mb_instance; // MoAB database
532  * moab::Interface &moab = mb_instance;
533  * MoFEM::Core core(moab); // MOFEM database
534  * MoFEM::CoreInterface &m_field = core;
535  *
536  * CHKERR foo(); // Call function
537  *
538  * }
539  * CATCH_ERRORS;
540  *
541  * return MoFEM::Core::Finalize();
542  *
543  * }
544  *
545  * \endcode
546  *
547  */
548 #define CHKERR MoFEM::ErrorChecker<__LINE__>() <<
549 
550 /**
551  * \brief Check error code of MoAB function and throw MoFEM exception
552  * @param err MoABErrorCode
553  */
554 #define MOAB_THROW(err) \
555  { \
556  if (PetscUnlikely(MB_SUCCESS != (err))) { \
557  std::string error_str = (unsigned)(err) <= (unsigned)MB_FAILURE \
558  ? moab::ErrorCodeStr[err] \
559  : "INVALID ERROR CODE"; \
560  throw MoFEMException(MOFEM_MOAB_ERROR, \
561  ("MOAB error (" + \
562  boost::lexical_cast<std::string>((err)) + ") " + \
563  error_str + " at line " + \
564  boost::lexical_cast<std::string>(__LINE__) + \
565  " : " + std::string(__FILE__)) \
566  .c_str()); \
567  } \
568  }
569 
570 /**
571  * \brief Throw MoFEM exception
572  * @param msg message
573  */
574 #define THROW_MESSAGE(msg) \
575  { \
576  throw MoFEM::MoFEMException( \
577  MOFEM_MOFEMEXCEPTION_THROW, \
578  ("MoFEM error " + boost::lexical_cast<std::string>((msg)) + \
579  " at line " + boost::lexical_cast<std::string>(__LINE__) + " : " + \
580  std::string(__FILE__)) \
581  .c_str()); \
582  }
583 
584 /**
585  * \brief Check error code of MoAB function and throw MoFEM exception
586  * @param err MoABErrorCode
587  * @param msg error message
588  */
589 #define CHK_MOAB_THROW(err, msg) \
590  { \
591  if (PetscUnlikely(MB_SUCCESS != (err))) { \
592  std::string str; \
593  throw MoFEMException( \
594  MOFEM_MOAB_ERROR, \
595  ("MOAB error (" + boost::lexical_cast<std::string>((err)) + ") " + \
596  boost::lexical_cast<std::string>((msg)) + " at line " + \
597  boost::lexical_cast<std::string>(__LINE__) + " : " + \
598  std::string(__FILE__)) \
599  .c_str()); \
600  } \
601  }
602 
603 /**
604  * \brief Check and throw MoFEM exception
605  * @param err error code
606  * @param msg message
607  */
608 #define CHK_THROW_MESSAGE(err, msg) \
609  { \
610  if (PetscUnlikely((err) != MOFEM_SUCCESS)) \
611  THROW_MESSAGE(msg); \
612  }
613 
614 /**
615  * \brief Convert number to string
616  * @param x number
617  */
618 #define SSTR(x) toString(x)
619 
620 #define TENSOR1_VEC_PTR(VEC) &VEC[0], &VEC[1], &VEC[2]
621 
622 #define SYMMETRIC_TENSOR4_MAT_PTR(MAT) \
623  &MAT(0, 0), &MAT(0, 1), &MAT(0, 2), &MAT(0, 3), &MAT(0, 4), &MAT(0, 5), \
624  &MAT(1, 0), &MAT(1, 1), &MAT(1, 2), &MAT(1, 3), &MAT(1, 4), &MAT(1, 5), \
625  &MAT(2, 0), &MAT(2, 1), &MAT(2, 2), &MAT(2, 3), &MAT(2, 4), &MAT(2, 5), \
626  &MAT(3, 0), &MAT(3, 1), &MAT(3, 2), &MAT(3, 3), &MAT(3, 4), &MAT(3, 5), \
627  &MAT(4, 0), &MAT(4, 1), &MAT(4, 2), &MAT(4, 3), &MAT(4, 4), &MAT(4, 5), \
628  &MAT(5, 0), &MAT(5, 1), &MAT(5, 2), &MAT(5, 3), &MAT(5, 4), &MAT(5, 5)
629 
630 #define TENSOR4_MAT_PTR(MAT) &MAT(0, 0), MAT.size2()
631 
632 #define TENSOR2_MAT_PTR(MAT) \
633  &MAT(0, 0), &MAT(1, 0), &MAT(2, 0), &MAT(3, 0), &MAT(4, 0), &MAT(5, 0), \
634  &MAT(6, 0), &MAT(7, 0), &MAT(8, 0)
635 
636 #define SYMMETRIC_TENSOR2_MAT_PTR(MAT) \
637  &MAT(0, 0), &MAT(0, 1), &MAT(0, 2), &MAT(0, 3), &MAT(0, 4), &MAT(0, 5)
638 
639 #define SYMMETRIC_TENSOR2_VEC_PTR(VEC) \
640  &VEC[0], &VEC[1], &VEC[2], &VEC[3], &VEC[4], &VEC[5]
641 
642 #endif //__DEFINITONS_H__
VERBOSITY_LEVELS
Verbosity levels.
Definition: definitions.h:219
@ VERY_VERBOSE
Definition: definitions.h:223
@ QUIET
Definition: definitions.h:221
@ DEFAULT_VERBOSITY
Definition: definitions.h:220
@ NOISY
Definition: definitions.h:224
@ VERBOSE
Definition: definitions.h:222
@ VERY_NOISY
Definition: definitions.h:225
static const char *const MoFEMErrorCodesNames[]
Definition: definitions.h:57
RowColData
RowColData.
Definition: definitions.h:136
@ LASTROWCOLDATA
Definition: definitions.h:136
@ COL
Definition: definitions.h:136
@ DATA
Definition: definitions.h:136
@ ROW
Definition: definitions.h:136
DEPRECATED void macro_is_deprecated_using_deprecated_function()
Is used to indicate that macro is deprecated Do nothing just triggers error at the compilation.
Definition: Core.cpp:24
MoFEMTypes
Those types control how functions respond on arguments, f.e. error handling.
Definition: definitions.h:110
@ MF_NOT_THROW
Definition: definitions.h:114
@ MF_ZERO
Definition: definitions.h:111
@ MF_EXIST
Definition: definitions.h:113
@ MF_EXCL
Definition: definitions.h:112
FieldApproximationBase
approximation base
Definition: definitions.h:71
@ LASTBASE
Definition: definitions.h:82
@ AINSWORTH_LEGENDRE_BASE
Ainsworth Cole (Legendre) approx. base .
Definition: definitions.h:73
@ AINSWORTH_LOBATTO_BASE
Definition: definitions.h:75
@ USER_BASE
user implemented approximation base
Definition: definitions.h:81
@ NOBASE
Definition: definitions.h:72
@ DEMKOWICZ_JACOBI_BASE
Definition: definitions.h:79
@ AINSWORTH_BERNSTEIN_BEZIER_BASE
Definition: definitions.h:77
static const char *const CoordinateTypesNames[]
Coordinate system names.
Definition: definitions.h:121
FieldSpace
approximation spaces
Definition: definitions.h:95
@ L2
field with C-1 continuity
Definition: definitions.h:101
@ LASTSPACE
FieldSpace in [ 0, LASTSPACE )
Definition: definitions.h:102
@ NOFIELD
scalar or vector of scalars describe (no true field)
Definition: definitions.h:97
@ H1
continuous field
Definition: definitions.h:98
@ NOSPACE
Definition: definitions.h:96
@ HCURL
field with continuous tangents
Definition: definitions.h:99
@ HDIV
field with continuous normal traction
Definition: definitions.h:100
static const char *const FieldSpaceNames[]
Definition: definitions.h:105
CubitBC
Types of sets and boundary conditions.
Definition: definitions.h:157
@ TEMPERATURESET
Definition: definitions.h:168
@ MATERIALSET
Definition: definitions.h:162
@ PRESSURESET
Definition: definitions.h:165
@ BODYFORCESSET
block name is "BODY_FORCES"
Definition: definitions.h:175
@ NEUMANN_BC
Definition: definitions.h:178
@ MAT_ELASTICSET
block name is "MAT_ELASTIC"
Definition: definitions.h:172
@ ACCELERATIONSET
Definition: definitions.h:167
@ FORCESET
Definition: definitions.h:164
@ HEATFLUXSET
Definition: definitions.h:169
@ DIRICHLET_BC
Definition: definitions.h:177
@ NODESET
Definition: definitions.h:159
@ SIDESET
Definition: definitions.h:160
@ UNKNOWNNAME
Definition: definitions.h:171
@ VELOCITYSET
Definition: definitions.h:166
@ MAT_INTERFSET
Definition: definitions.h:173
@ DISPLACEMENTSET
Definition: definitions.h:163
@ LASTSET_BC
Definition: definitions.h:179
@ MAT_THERMALSET
block name is "MAT_THERMAL"
Definition: definitions.h:174
@ MAT_MOISTURESET
block name is "MAT_MOISTURE"
Definition: definitions.h:176
@ UNKNOWNSET
Definition: definitions.h:158
@ BLOCKSET
Definition: definitions.h:161
@ INTERFACESET
Definition: definitions.h:170
HVecFormatting
Format in rows of vectorial base functions.
Definition: definitions.h:199
@ HVEC0
Definition: definitions.h:199
@ HVEC1
Definition: definitions.h:199
@ HVEC2
Definition: definitions.h:199
MoFEMErrorCodes
Error handling.
Definition: definitions.h:42
@ MOFEM_NOT_FOUND
Definition: definitions.h:46
@ MOFEM_IMPOSIBLE_CASE
Definition: definitions.h:48
@ MOFEM_NOT_INSTALLED
Definition: definitions.h:50
@ MOFEM_STD_EXCEPTION_THROW
Definition: definitions.h:52
@ MOFEM_MOFEMEXCEPTION_THROW
Definition: definitions.h:51
@ MOFEM_MOAB_ERROR
Definition: definitions.h:54
@ MOFEM_OPERATION_UNSUCCESSFUL
Definition: definitions.h:47
@ MOFEM_ATOM_TEST_INVALID
Definition: definitions.h:53
@ MOFEM_DATA_INCONSISTENCY
Definition: definitions.h:44
@ MOFEM_SUCCESS
Definition: definitions.h:43
@ MOFEM_INVALID_DATA
Definition: definitions.h:49
@ MOFEM_NOT_IMPLEMENTED
Definition: definitions.h:45
static const char *const ApproximationBaseNames[]
Definition: definitions.h:85
CoordinateTypes
Coodinate system.
Definition: definitions.h:127
@ LAST_COORDINATE_SYSTEM
Definition: definitions.h:132
@ CYLINDRICAL
Definition: definitions.h:130
@ POLAR
Definition: definitions.h:129
@ CARTESIAN
Definition: definitions.h:128
@ SPHERICAL
Definition: definitions.h:131
static const char *const CubitBCNames[]
Names of types of sets and boundary conditions.
Definition: definitions.h:188
#define DEPRECATED
Definition: definitions.h:30
ByWhat
Definition: definitions.h:143
@ BYCOL
Definition: definitions.h:145
@ BYALL
Definition: definitions.h:150
@ BYCOLDATA
Definition: definitions.h:148
@ BYROWDATA
Definition: definitions.h:147
@ BYROWCOL
Definition: definitions.h:149
@ BYDATA
Definition: definitions.h:146
@ BYROW
Definition: definitions.h:144
HVecDiffFormatting
Format in rows of vectorial base gradients of base functions.
Definition: definitions.h:204
@ HVEC1_1
Definition: definitions.h:209
@ HVEC0_1
Definition: definitions.h:208
@ HVEC1_0
Definition: definitions.h:206
@ HVEC2_1
Definition: definitions.h:210
@ HVEC1_2
Definition: definitions.h:212
@ HVEC2_2
Definition: definitions.h:213
@ HVEC2_0
Definition: definitions.h:207
@ HVEC0_2
Definition: definitions.h:211
@ HVEC0_0
Definition: definitions.h:205