libMesh
Loading...
Searching...
No Matches
libmesh_common.h
Go to the documentation of this file.
1// The libMesh Finite Element Library.
2// Copyright (C) 2002-2026 Benjamin S. Kirk, John W. Peterson, Roy H. Stogner
3
4// This library is free software; you can redistribute it and/or
5// modify it under the terms of the GNU Lesser General Public
6// License as published by the Free Software Foundation; either
7// version 2.1 of the License, or (at your option) any later version.
8
9// This library is distributed in the hope that it will be useful,
10// but WITHOUT ANY WARRANTY; without even the implied warranty of
11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12// Lesser General Public License for more details.
13
14// You should have received a copy of the GNU Lesser General Public
15// License along with this library; if not, write to the Free Software
16// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
18
19
20#ifndef LIBMESH_LIBMESH_COMMON_H
21#define LIBMESH_LIBMESH_COMMON_H
22
23// These flags should never be used together. -DDEBUG means "turn on
24// all the ridiculously expensive error checking"; -DNDEBUG means
25// "turn off all the somewhat affordable error checking"
26#if defined(DEBUG) && defined(NDEBUG)
27# error DEBUG and NDEBUG should never be defined simultaneously
28#endif
29
30// The library configuration options
31#include "libmesh/libmesh_config.h"
32
33// Device compilation support — must be included before assert macros
34// so that LIBMESH_DEVICE_ASSERT is available for the Kokkos path.
35#include "libmesh/libmesh_device.h"
36
37// Use actual timestamps or constant dummies (to aid ccache)
38#ifdef LIBMESH_ENABLE_TIMESTAMPS
39# define LIBMESH_TIME __TIME__
40# define LIBMESH_DATE __DATE__
41#else
42# define LIBMESH_TIME "notime"
43# define LIBMESH_DATE "nodate"
44#endif
45
46// C/C++ includes everyone should know about
47#include <cstdlib>
48#ifdef __PGI
49// BSK, Thu Feb 20 08:32:06 CST 2014 - For some reason, unless PGI gets
50// <cmath> early this nonsense shows up:
51// "/software/x86_64/pgi/12.9/linux86-64/12.9/include/CC/cmath", line 57: error:
52// the global scope has no "abs"
53// using _STLP_VENDOR_CSTD::abs;
54// So include <cmath> as early as possible under the PGI compilers.
55# include <cmath>
56#endif
57#include <complex>
58#include <typeinfo> // std::bad_cast
59#include <type_traits> // std::decay
60#include <functional> // std::less, etc
61#include <string>
62
63// Include the MPI definition
64#ifdef LIBMESH_HAVE_MPI
65# include "libmesh/ignore_warnings.h"
66# include <mpi.h>
67# include "libmesh/restore_warnings.h"
68#endif
69
70// Quad precision if we need it
71#ifdef LIBMESH_DEFAULT_QUADRUPLE_PRECISION
72#include "libmesh/float128_shims.h"
73#endif
74
75// _basic_ library functionality
76#include "libmesh/libmesh_base.h"
77#include "libmesh/libmesh_exceptions.h"
78
79// Proxy class for libMesh::out/err output
80#include "libmesh/ostream_proxy.h"
81
82// Make sure the libmesh_nullptr define is available for backwards
83// compatibility, although we no longer use it in the library.
84#include "libmesh/libmesh_nullptr.h"
85
86// C++ headers
87#include <iomanip> // setprecision, in assertion macros
88
89namespace libMesh
90{
91namespace Threads
92{
93// For thread-safe error-messaging. Definitions in threads.h
96}
97
98// Let's define a couple output streams - these will default
99// to cout/cerr, but LibMeshInit (or the user) can also set them to
100// something more sophisticated.
101//
102// We use a proxy class rather than references so they can be
103// reseated at runtime.
104
105extern OStreamProxy out;
106extern OStreamProxy err;
107
108// A namespace for functions used in the bodies of the macros below.
109// The macros generally call these functions with __FILE__, __LINE__,
110// __DATE__, and __TIME__ in the appropriate order. These should not
111// be called by users directly! The implementations can be found in
112// libmesh_common.C.
113namespace MacroFunctions
114{
115void here(const char * file, int line, const char * date, const char * time, std::ostream & os = libMesh::err);
116void stop(const char * file, int line, const char * date, const char * time);
117void report_error(const char * file, int line, const char * date, const char * time, std::ostream & os = libMesh::err);
118}
119
120// Undefine any existing macros
121#ifdef Real
122# undef Real
123#endif
124
125//#ifdef REAL
126//# undef REAL
127//#endif
128
129#ifdef Complex
130# undef Complex
131#endif
132
133#ifdef COMPLEX
134# undef COMPLEX
135#endif
136
137// Check to see if TOLERANCE has been defined by another
138// package, if so we might want to change the name...
139#ifdef TOLERANCE
140DIE A HORRIBLE DEATH HERE...
141# undef TOLERANCE
142#endif
143
144
145
146// Define the type to use for real numbers
147
148typedef LIBMESH_DEFAULT_SCALAR_TYPE Real;
149
150// Define a corresponding tolerance. This is what should be
151// considered "good enough" when doing floating point comparisons.
152// For example, v == 0 is changed to std::abs(v) < TOLERANCE.
153
154#ifdef LIBMESH_DEFAULT_SINGLE_PRECISION
155static constexpr Real TOLERANCE = 2.5e-3;
156# if defined (LIBMESH_DEFAULT_TRIPLE_PRECISION) || \
157 defined (LIBMESH_DEFAULT_QUADRUPLE_PRECISION)
158# error Cannot define multiple precision levels
159# endif
160#endif
161
162#ifdef LIBMESH_DEFAULT_TRIPLE_PRECISION
163static constexpr Real TOLERANCE = 1.e-8;
164# if defined (LIBMESH_DEFAULT_QUADRUPLE_PRECISION)
165# error Cannot define multiple precision levels
166# endif
167#endif
168
169#ifdef LIBMESH_DEFAULT_QUADRUPLE_PRECISION
170static constexpr Real TOLERANCE = 1.e-11;
171#endif
172
173#if !defined (LIBMESH_DEFAULT_SINGLE_PRECISION) && \
174 !defined (LIBMESH_DEFAULT_TRIPLE_PRECISION) && \
175 !defined (LIBMESH_DEFAULT_QUADRUPLE_PRECISION)
176static constexpr Real TOLERANCE = 1.e-6;
177#endif
178
179// Define the type to use for complex numbers
180// Always use std::complex<double>, as required by Petsc?
181// If your version of Petsc doesn't support
182// std::complex<other_precision>, then you'd better just leave
183// Real==double
184typedef std::complex<Real> Complex;
185typedef std::complex<Real> COMPLEX;
186
187
188// Helper functions for complex/real number components, to clean up
189// #ifdef LIBMESH_USE_COMPLEX_NUMBERS elsewhere
190//
191// Some of these are just backwards compatibility shims for old code
192// that predated C++11
193template<typename T> LIBMESH_DEVICE_INLINE T libmesh_real(T a) { return a; }
194template<typename T> LIBMESH_DEVICE_INLINE T libmesh_imag(T /*a*/) { return 0; }
195template<typename T> LIBMESH_DEVICE_INLINE T libmesh_conj(T a) { return a; }
196
197template<typename T>
198LIBMESH_DEVICE_INLINE T libmesh_real(std::complex<T> a) { return std::real(a); }
199
200template<typename T>
201LIBMESH_DEVICE_INLINE T libmesh_imag(std::complex<T> a) { return std::imag(a); }
202
203template<typename T>
204LIBMESH_DEVICE_INLINE std::complex<T> libmesh_conj(std::complex<T> a) { return std::conj(a); }
205
206// Helper functions for complex/real number classification, because
207// for some reason std:: never added isfinite/isinf/isnan overloads
208// for std::complex.
209
210template <typename T>
211LIBMESH_DEVICE_INLINE bool libmesh_isinf(T x) { using std::isinf; return isinf(x); }
212
213template <typename T>
214LIBMESH_DEVICE_INLINE bool libmesh_isnan(T x) { using std::isnan; return isnan(x); }
215
216// You'd think we'd treat inf,NaN pairs as NaN rather than infinite,
217// but that's not what the C/C++ standards recommend (ever since C99
218// Annex G), so we'll follow their lead.
219//
220// Anyone who doesn't care about these subtle NaN/inf distinctions
221// should just test isfinite() in their code, and can also probably
222// speed up their arithmetic greatly by using -fcx-limited-range
223// and/or -fcx-fortran-rules
224template <typename T>
225LIBMESH_DEVICE_INLINE bool libmesh_isinf(std::complex<T> a)
226{ return (std::isinf(std::real(a)) || std::isinf(std::imag(a))); }
227
228// Treats inf,NaN pairs as infinite rather than NaN
229template <typename T>
230LIBMESH_DEVICE_INLINE bool libmesh_isnan(std::complex<T> a)
231{ return ((std::isnan(std::real(a)) || std::isnan(std::imag(a))) &&
232 !std::isinf(std::real(a)) && !std::isinf(std::imag(a))); }
233
234template <typename T>
235LIBMESH_DEVICE_INLINE bool isfinite(std::complex<T> a)
236{
237 return (std::isfinite(std::real(a)) && std::isfinite(std::imag(a)));
238}
239
240template <typename T>
241LIBMESH_DEVICE_INLINE bool isinf(std::complex<T> a)
242{
243 return (std::isinf(std::real(a)) || std::isinf(std::imag(a)));
244}
245
246template <typename T>
247LIBMESH_DEVICE_INLINE bool isnan(std::complex<T> a)
248{
249{ return ((std::isnan(std::real(a)) || std::isnan(std::imag(a))) &&
250 !std::isinf(std::real(a)) && !std::isinf(std::imag(a))); }
251}
252
253// Define the value type for unknowns in simulations.
254// This is either Real or Complex, depending on how
255// the library was configures
256#if defined (LIBMESH_USE_REAL_NUMBERS)
257typedef Real Number;
258#elif defined (LIBMESH_USE_COMPLEX_NUMBERS)
259typedef Complex Number;
260#else
261DIE A HORRIBLE DEATH HERE...
262#endif
263
264
265// Define the value type for error estimates.
266// Since AMR/C decisions don't have to be precise,
267// we default to float for memory efficiency.
268typedef float ErrorVectorReal;
269#define MPI_ERRORVECTORREAL MPI_FLOAT
270
271
272#ifdef LIBMESH_HAVE_MPI
273
277extern MPI_Comm GLOBAL_COMM_WORLD;
278#else
279
285#endif
286
287// This global variable is to help us deprecate AutoPtr. We can't
288// just use libmesh_deprecated() because then you get one print out
289// per template instantiation, instead of one total print out.
290extern bool warned_about_auto_ptr;
291
292// These are useful macros that behave like functions in the code.
293// If you want to make sure you are accessing a section of code just
294// stick a libmesh_here(); in it, for example
295#define libmesh_here() \
296 do { \
297 libMesh::MacroFunctions::here(__FILE__, __LINE__, LIBMESH_DATE, LIBMESH_TIME); \
298 } while (0)
299
300// the libmesh_stop() macro will stop the code until a SIGCONT signal
301// is received. This is useful, for example, when determining the
302// memory used by a given operation. A libmesh_stop() could be
303// inserted before and after a questionable operation and the delta
304// memory can be obtained from a ps or top. This macro only works for
305// serial cases.
306#define libmesh_stop() \
307 do { \
308 libMesh::MacroFunctions::stop(__FILE__, __LINE__, LIBMESH_DATE, LIBMESH_TIME); \
309 } while (0)
310
311// The libmesh_dbg_var() macro indicates that an argument to a function
312// is used only in debug and devel modes (i.e., when NDEBUG is not defined).
313#ifndef NDEBUG
314#define libmesh_dbg_var(var) var
315#else
316#define libmesh_dbg_var(var)
317#endif
318
319// The libmesh_inf_var() macro indicates that an argument to a function
320// is used only when infinite elements are enabled
321#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
322#define libmesh_inf_var(var) var
323#else
324#define libmesh_inf_var(var)
325#endif
326
327// The libmesh_assert() macro acts like C's assert(), but throws a
328// libmesh_error() (including stack trace, etc) instead of just exiting.
329//
330// In .K translation units (ACSM_KOKKOS_COMPILATION defined),
331// LIBMESH_DEVICE_ASSERT is provided by libmesh_device.h using
332// printf + Kokkos::abort() — device-safe across CUDA/HIP/SYCL.
333// The assert macros delegate to it so that both host and device
334// code in the same file get assertion checking.
335#ifdef NDEBUG
336
337#define libmesh_assert_msg(asserted, msg) ((void) 0)
338#define libmesh_exceptionless_assert_msg(asserted, msg) ((void) 0)
339#define libmesh_assert_equal_to_msg(expr1,expr2, msg) ((void) 0)
340#define libmesh_assert_not_equal_to_msg(expr1,expr2, msg) ((void) 0)
341#define libmesh_assert_less_msg(expr1,expr2, msg) ((void) 0)
342#define libmesh_assert_greater_msg(expr1,expr2, msg) ((void) 0)
343#define libmesh_assert_less_equal_msg(expr1,expr2, msg) ((void) 0)
344#define libmesh_assert_greater_equal_msg(expr1,expr2, msg) ((void) 0)
345
346#elif defined(ACSM_KOKKOS_COMPILATION)
347
348// Kokkos compilation: use the device-safe assert from libmesh_device.h.
349#define libmesh_assert_msg(asserted, msg) LIBMESH_DEVICE_ASSERT(asserted)
350#define libmesh_exceptionless_assert_msg(asserted, msg) LIBMESH_DEVICE_ASSERT(asserted)
351#define libmesh_assert_equal_to_msg(expr1,expr2, msg) LIBMESH_DEVICE_ASSERT((expr1) == (expr2))
352#define libmesh_assert_not_equal_to_msg(expr1,expr2, msg) LIBMESH_DEVICE_ASSERT((expr1) != (expr2))
353#define libmesh_assert_less_msg(expr1,expr2, msg) LIBMESH_DEVICE_ASSERT((expr1) < (expr2))
354#define libmesh_assert_greater_msg(expr1,expr2, msg) LIBMESH_DEVICE_ASSERT((expr1) > (expr2))
355#define libmesh_assert_less_equal_msg(expr1,expr2, msg) LIBMESH_DEVICE_ASSERT((expr1) <= (expr2))
356#define libmesh_assert_greater_equal_msg(expr1,expr2, msg) LIBMESH_DEVICE_ASSERT((expr1) >= (expr2))
357
358#else
359
360#define libmesh_assertion_types(expr1,expr2) \
361 typedef typename std::decay<decltype(expr1)>::type libmesh_type1; \
362 typedef typename std::decay<decltype(expr2)>::type libmesh_type2
363
364#define libmesh_assert_msg(asserted, msg) \
365 do { \
366 if (!(asserted)) { \
367 libmesh_error_msg("Assertion `" #asserted "' failed.\n" << msg); \
368 } } while (0)
369
370#define libmesh_exceptionless_assert_msg(asserted, msg) \
371 do { \
372 if (!(asserted)) { \
373 libMesh::Threads::lock_singleton_spin_mutex(); \
374 libMesh::err << "Assertion `" #asserted "' failed." << std::endl; \
375 libMesh::Threads::unlock_singleton_spin_mutex(); \
376 libmesh_exceptionless_error(); \
377 } } while (0)
378
379#define libmesh_assert_equal_to_msg(expr1,expr2, msg) \
380 do { \
381 if (!((expr1) == (expr2))) { \
382 libmesh_error_msg(std::setprecision(17) << "Assertion `" #expr1 " == " #expr2 "' failed.\n" #expr1 " = " << (expr1) << "\n" #expr2 " = " << (expr2) << '\n' << msg << std::endl); \
383 } } while (0)
384
385#define libmesh_assert_not_equal_to_msg(expr1,expr2, msg) \
386 do { \
387 if (!((expr1) != (expr2))) { \
388 libmesh_error_msg(std::setprecision(17) << "Assertion `" #expr1 " != " #expr2 "' failed.\n" #expr1 " = " << (expr1) << "\n" #expr2 " = " << (expr2) << '\n' << msg << std::endl); \
389 } } while (0)
390
391template <template <class> class Comp>
393
394 template <typename T1, typename T2>
395 bool operator()(const T1 & e1, const T2 & e2) const
396 {
397 typedef typename std::decay<T1>::type DT1;
398 typedef typename std::decay<T2>::type DT2;
399 return (Comp<DT2>()(static_cast<DT2>(e1), e2) &&
400 Comp<DT1>()(e1, static_cast<DT1>(e2)));
401 }
402
403 template <typename T1>
404 bool operator()(const T1 & e1, const T1 & e2) const
405 {
406 return Comp<T1>()(e1, e2);
407 }
408};
409
410#define libmesh_assert_less_msg(expr1,expr2, msg) \
411 do { \
412 if (!libMesh::casting_compare<std::less>()(expr1, expr2)) { \
413 libmesh_error_msg(std::setprecision(17) << "Assertion `" #expr1 " < " #expr2 "' failed.\n" #expr1 " = " << (expr1) << "\n" #expr2 " = " << (expr2) << '\n' << msg << std::endl); \
414 } } while (0)
415
416#define libmesh_assert_greater_msg(expr1,expr2, msg) \
417 do { \
418 if (!libMesh::casting_compare<std::greater>()(expr1, expr2)) { \
419 libmesh_error_msg(std::setprecision(17) << "Assertion `" #expr1 " > " #expr2 "' failed.\n" #expr1 " = " << (expr1) << "\n" #expr2 " = " << (expr2) << '\n' << msg << std::endl); \
420 } } while (0)
421
422#define libmesh_assert_less_equal_msg(expr1,expr2, msg) \
423 do { \
424 if (!libMesh::casting_compare<std::less_equal>()(expr1, expr2)) { \
425 libmesh_error_msg(std::setprecision(17) << "Assertion `" #expr1 " <= " #expr2 "' failed.\n" #expr1 " = " << (expr1) << "\n" #expr2 " = " << (expr2) << '\n' << msg << std::endl); \
426 } } while (0)
427
428#define libmesh_assert_greater_equal_msg(expr1,expr2, msg) \
429 do { \
430 if (!libMesh::casting_compare<std::greater_equal>()(expr1, expr2)) { \
431 libmesh_error_msg(std::setprecision(17) << "Assertion `" #expr1 " >= " #expr2 "' failed.\n" #expr1 " = " << (expr1) << "\n" #expr2 " = " << (expr2) << '\n' << msg << std::endl); \
432 } } while (0)
433
434#endif
435
436
437#define libmesh_assert(asserted) libmesh_assert_msg(asserted, "")
438#define libmesh_exceptionless_assert(asserted) libmesh_exceptionless_assert_msg(asserted, "")
439#define libmesh_assert_equal_to(expr1,expr2) libmesh_assert_equal_to_msg(expr1,expr2, "")
440#define libmesh_assert_not_equal_to(expr1,expr2) libmesh_assert_not_equal_to_msg(expr1,expr2, "")
441#define libmesh_assert_less(expr1,expr2) libmesh_assert_less_msg(expr1,expr2, "")
442#define libmesh_assert_greater(expr1,expr2) libmesh_assert_greater_msg(expr1,expr2, "")
443#define libmesh_assert_less_equal(expr1,expr2) libmesh_assert_less_equal_msg(expr1,expr2, "")
444#define libmesh_assert_greater_equal(expr1,expr2) libmesh_assert_greater_equal_msg(expr1,expr2, "")
445
446// The libmesh_error() macro prints a message and throws a LogicError
447// exception
448//
449// The libmesh_not_implemented() macro prints a message and throws a
450// NotImplemented exception
451//
452// The libmesh_file_error(const std::string & filename) macro prints a message
453// and throws a FileError exception
454//
455// The libmesh_convergence_failure() macro
456// throws a ConvergenceFailure exception
457//
458// The libmesh_degenerate_mapping() macro prints a message into and
459// throws a DegenerateMap exception
460//
461// The libmesh_terminate() macro prints a message and throws a
462// TerminationException exception
463#if LIBMESH_IN_DEVICE_CODE
464#define libmesh_error_msg(msg) \
465 do { \
466 LIBMESH_DEVICE_ERROR_MSG(msg); \
467 } while (0)
468#else
469#define libmesh_error_msg(msg) \
470 do { \
471 std::stringstream message_stream; \
472 message_stream << msg << '\n'; \
473 libMesh::MacroFunctions::report_error(__FILE__, __LINE__, LIBMESH_DATE, LIBMESH_TIME, message_stream); \
474 LIBMESH_THROW(libMesh::LogicError(message_stream.str())); \
475 } while (0)
476#endif
477
478#define libmesh_error() libmesh_error_msg("")
479
480#define libmesh_error_msg_if(cond, msg) \
481 do { \
482 if (cond) \
483 libmesh_error_msg(msg); \
484 } while (0)
485
486#define libmesh_exceptionless_error_msg(msg) \
487 do { \
488 libMesh::Threads::lock_singleton_spin_mutex(); \
489 libMesh::err << msg << '\n'; \
490 libMesh::Threads::unlock_singleton_spin_mutex(); \
491 libmesh_try { libMesh::MacroFunctions::report_error(__FILE__, __LINE__, LIBMESH_DATE, LIBMESH_TIME); } \
492 libmesh_catch (...) {} \
493 std::terminate(); \
494 } while (0)
495
496#define libmesh_exceptionless_error() libmesh_exceptionless_error_msg("")
497
498#define libmesh_not_implemented_msg(msg) \
499 do { \
500 std::stringstream message_stream; \
501 message_stream << msg << '\n'; \
502 libMesh::MacroFunctions::report_error(__FILE__, __LINE__, LIBMESH_DATE, LIBMESH_TIME, message_stream); \
503 LIBMESH_THROW(libMesh::NotImplemented(message_stream.str())); \
504 } while (0)
505
506#define libmesh_not_implemented() libmesh_not_implemented_msg("")
507
508#define libmesh_file_error_msg(filename, msg) \
509 do { \
510 std::stringstream message_stream; \
511 message_stream << msg << '\n'; \
512 libMesh::MacroFunctions::report_error(__FILE__, __LINE__, LIBMESH_DATE, LIBMESH_TIME, message_stream); \
513 LIBMESH_THROW(libMesh::FileError(filename, message_stream.str())); \
514 } while (0)
515
516#define libmesh_file_error(filename) libmesh_file_error_msg(filename,"")
517
518#define libmesh_convergence_failure() \
519 do { \
520 LIBMESH_THROW(libMesh::ConvergenceFailure()); \
521 } while (0)
522
523#define libmesh_degenerate_mapping_msg(msg) \
524 do { \
525 std::stringstream message_stream; \
526 message_stream << msg << '\n'; \
527 LIBMESH_THROW(libMesh::DegenerateMap(message_stream.str())); \
528 } while (0)
529
530#define libmesh_degenerate_mapping(filename) libmesh_degenerate_mapping_msg("")
531
532#define libmesh_terminate() \
533 do { \
534 LIBMESH_THROW(libMesh::TerminationException()); \
535 } while (0)
536
537// The libmesh_example_requires() macro prints a message and calls
538// "return 77;" if the condition specified by the macro is not true. This
539// macro is used in the example executables, which should run when the
540// configure-time libMesh options support them but which should exit
541// without failure otherwise.
542//
543// This macro only works in main(), because we have no better way than
544// "return" from main to immediately exit successfully - std::exit()
545// gets seen by at least some MPI stacks as failure.
546//
547// 77 is the automake code for a skipped test.
548
549#define libmesh_example_requires(condition, option) \
550 do { \
551 if (!(condition)) { \
552 libMesh::out << "Configuring libMesh with " << option << " is required to run this example." << std::endl; \
553 return 77; \
554 } } while (0)
555
556// The libmesh_do_once macro helps us avoid redundant repeated
557// repetitions of the same warning messages
558#undef libmesh_do_once
559#define libmesh_do_once(do_this) \
560 do { \
561 static bool did_this_already = false; \
562 if (!did_this_already) { \
563 did_this_already = true; \
564 do_this; \
565 } } while (0)
566
567
568// The libmesh_warning macro outputs a file/line/time stamped warning
569// message, if warnings are enabled.
570#ifdef LIBMESH_ENABLE_WARNINGS
571#define libmesh_warning(message) \
572 libmesh_do_once(libMesh::out << message \
573 << __FILE__ << ", line " << __LINE__ << ", compiled " << LIBMESH_DATE << " at " << LIBMESH_TIME << " ***" << std::endl;)
574#else
575#define libmesh_warning(message) ((void) 0)
576#endif
577
578// The libmesh_experimental macro warns that you are using
579// bleeding-edge code
580#undef libmesh_experimental
581#define libmesh_experimental() \
582 libmesh_warning("*** Warning, This code is untested, experimental, or likely to see future API changes: ");
583
584
585// The libmesh_deprecated macro warns that you are using obsoleted code
586#undef libmesh_deprecated
587#ifndef LIBMESH_ENABLE_DEPRECATED
588#define libmesh_deprecated() \
589 libmesh_error_msg("*** Error, This code is deprecated, and likely to be removed in future library versions! ");
590#else
591#define libmesh_deprecated() \
592 libmesh_warning("*** Warning, This code is deprecated, and likely to be removed in future library versions! ");
593#endif
594
595// A function template for ignoring unused variables. This is a way
596// to shut up unused variable compiler warnings on a case by case
597// basis.
598template<class ...Args> inline void libmesh_ignore( const Args&... ) { }
599
600
601// Workaround for incomplete C++17 support in some compilers/libs
602
603#ifdef LIBMESH_HAVE_CXX17_SPLICING
604template <typename T>
605void libmesh_merge_move(T & target, T & source)
606{
607 target.merge(std::move(source));
608}
609#else
610template <typename T>
611void libmesh_merge_move(T & target, T & source)
612{
613 target.insert(source.begin(), source.end());
614 source.clear(); // Avoid forwards-incompatibility
615}
616#endif // LIBMESH_HAVE_CXX17_SPLICING
617
621 std::string demangle(const char * name);
622
623// cast_ref and cast_ptr do a dynamic cast and assert
624// the result, if we have RTTI enabled and we're in debug or
625// development modes, but they just do a faster static cast if we're
626// in optimized mode.
627//
628// Use these casts when you're certain that a cast will succeed in
629// correct code but you want to be able to double-check.
630template <typename Tnew, typename Told>
631inline Tnew cast_ref(Told & oldvar)
632{
633#if !defined(NDEBUG) && defined(LIBMESH_HAVE_RTTI) && defined(LIBMESH_ENABLE_EXCEPTIONS)
634 try
635 {
636 Tnew newvar = dynamic_cast<Tnew>(oldvar);
637 return newvar;
638 }
639 catch (std::bad_cast &)
640 {
641 libMesh::err << "Failed to convert " << demangle(typeid(Told).name())
642 << " reference to " << demangle(typeid(Tnew).name())
643 << std::endl;
644 libMesh::err << "The " << demangle(typeid(Told).name())
645 << " appears to be a "
646 << demangle(typeid(*(&oldvar)).name()) << std::endl;
647 libmesh_error();
648 }
649#else
650 return(static_cast<Tnew>(oldvar));
651#endif
652}
653
654// We use two different function names to avoid an odd overloading
655// ambiguity bug with icc 10.1.008
656template <typename Tnew, typename Told>
657inline Tnew cast_ptr (Told * oldvar)
658{
659#if !defined(NDEBUG) && defined(LIBMESH_HAVE_RTTI)
660 Tnew newvar = dynamic_cast<Tnew>(oldvar);
661 if (!newvar)
662 {
663 libMesh::err << "Failed to convert " << demangle(typeid(Told).name())
664 << " pointer to " << demangle(typeid(Tnew).name())
665 << std::endl;
666 libMesh::err << "The " << demangle(typeid(Told).name())
667 << " appears to be a "
668 << demangle(typeid(*oldvar).name()) << std::endl;
669 libmesh_error();
670 }
671 return newvar;
672#else
673 return(static_cast<Tnew>(oldvar));
674#endif
675}
676
677
678#ifdef LIBMESH_ENABLE_DEPRECATED
679template <typename Tnew, typename Told>
680inline Tnew libmesh_cast_ptr (Told * oldvar)
681{
682 libmesh_deprecated();
683
684 // we use the less redundantly named libMesh::cast_ptr now
685 return cast_ptr<Tnew>(oldvar);
686}
687#endif // LIBMESH_ENABLE_DEPRECATED
688
689
690// cast_int asserts that the value of the castee is within the
691// bounds which are exactly representable by the output type, if we're
692// in debug or development modes, but it just does a faster static
693// cast if we're in optimized mode.
694//
695// Use these casts when you're certain that a cast will succeed in
696// correct code but you want to be able to double-check.
697template <typename Tnew, typename Told>
698inline Tnew cast_int (Told oldvar)
699{
700 libmesh_assert_equal_to
701 (oldvar, static_cast<Told>(static_cast<Tnew>(oldvar)));
702
703 return(static_cast<Tnew>(oldvar));
704}
705
706
707template <typename Tnew, typename Told>
708inline Tnew libmesh_cast_int (Told oldvar)
709{
710 // we use the less redundantly named libMesh::cast_int now
711 return cast_int<Tnew>(oldvar);
712}
713
714
725template <typename Tnew, typename Told>
726inline Tnew restrict_int (Told oldvar)
727{
728 if constexpr (!std::is_same_v<Tnew, Told>)
729 {
730 const Tnew returnval = static_cast<Tnew>(oldvar);
731
732 libmesh_error_msg_if (oldvar != static_cast<Told>(returnval),
733 "restrict_int failed: " << oldvar << " does not fit in type " << typeid(returnval).name());
734 }
735
736 return oldvar;
737}
738
744template <class T>
745constexpr std::false_type always_false{};
746
747static constexpr std::size_t libmesh_dim = LIBMESH_DIM;
748
749// build a integer representation of version
750#define LIBMESH_VERSION_ID(major,minor,patch) (((major) << 16) | ((minor) << 8) | ((patch) & 0xFF))
751
752
753// libmesh_override is simply a synonym for override as we now require
754// a C++11 compiler that supports this keyword.
755#define libmesh_override override
756
757// libmesh_delete is simply a synonym for '=delete' as we now require
758// a C++11 compiler that supports this keyword.
759#define libmesh_delete =delete
760
761// libmesh_final is simply a synonym for 'final' as we now require
762// a C++11 compiler that supports this keyword.
763#define libmesh_final final
764
765// Define backwards-compatible fallthrough attribute. We could
766// eventually also add support for other compiler-specific fallthrough
767// attributes.
768#ifdef LIBMESH_HAVE_CXX17_FALLTHROUGH_ATTRIBUTE
769#define libmesh_fallthrough() [[fallthrough]]
770#elif defined(LIBMESH_HAVE_DOUBLE_UNDERSCORE_ATTRIBUTE_FALLTHROUGH)
771#define libmesh_fallthrough() __attribute__((fallthrough))
772#else
773#define libmesh_fallthrough() ((void) 0)
774#endif
775
776template <typename T>
778{
779 friend T;
780 constexpr PassKey() = default;
781};
782} // namespace libMesh
783
784
785// Backwards compatibility
787{
788using namespace libMesh;
789}
790
791// Backwards compatibility with pre-TIMPI reference
792namespace TIMPI {}
793
794namespace libMesh {
795 namespace Parallel {
796 using namespace TIMPI;
797 }
798}
799
800
801// Here we add missing types to the standard namespace. For example,
802// std::max(double, float) etc... are well behaved but not defined
803// by the standard. This also includes workarounds for super-strict
804// implementations, for example Sun Studio and PGI C++. However,
805// this necessarily requires breaking the ISO-C++ standard, and is
806// really just a hack. As such, only do it if we are building the
807// libmesh library itself. Specifically, *DO NOT* export this to
808// user code or install this header.
809//
810// We put this at the end of libmesh_common.h so we can make use of
811// any exotic definitions of Real above.
812#ifdef LIBMESH_IS_COMPILING_ITSELF
813# include "libmesh/libmesh_augment_std_namespace.h"
814#endif
815
816
817#ifdef _MSC_VER
818#define LIBMESH_EXPORT __declspec(dllexport)
819#else
820#define LIBMESH_EXPORT
821#endif
822
823
824#endif // LIBMESH_LIBMESH_COMMON_H
This class is intended to be reseatable like a pointer-to-ostream for flexibility,...
constexpr PassKey()=default
void here(const char *file, int line, const char *date, const char *time, std::ostream &os=libMesh::err)
void stop(const char *file, int line, const char *date, const char *time)
void report_error(const char *file, int line, const char *date, const char *time, std::ostream &os=libMesh::err)
void lock_singleton_spin_mutex()
Definition threads.C:35
void unlock_singleton_spin_mutex()
Definition threads.C:36
The libMesh namespace provides an interface to certain functionality in the library.
std::complex< Real > COMPLEX
OStreamProxy err
LIBMESH_DEVICE_INLINE bool libmesh_isinf(T x)
static constexpr std::size_t libmesh_dim
DIE A HORRIBLE DEATH HERE typedef float ErrorVectorReal
bool warned_about_auto_ptr
LIBMESH_DEVICE_INLINE bool isfinite(std::complex< T > a)
Tnew restrict_int(Told oldvar)
restrict_int checks that the value of the castee is within the bounds which are exactly representable...
Tnew cast_ref(Told &oldvar)
LIBMESH_DEVICE_INLINE bool isnan(std::complex< T > a)
std::string demangle(const char *name)
Mostly system independent demangler.
std::complex< Real > Complex
void libmesh_ignore(const Args &...)
OStreamProxy out
LIBMESH_DEVICE_INLINE T libmesh_imag(T)
LIBMESH_DEVICE_INLINE bool libmesh_isnan(T x)
LIBMESH_DEVICE_INLINE T libmesh_real(T a)
LIBMESH_DEVICE_INLINE bool isinf(std::complex< T > a)
Tnew libmesh_cast_int(Told oldvar)
void libmesh_merge_move(T &target, T &source)
static constexpr Real TOLERANCE
MPI_Comm GLOBAL_COMM_WORLD
MPI Communicator used to initialize libMesh.
Tnew cast_ptr(Told *oldvar)
constexpr std::false_type always_false
This is a helper variable template for cases when we want to use a default compile-time error with co...
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
Tnew libmesh_cast_ptr(Told *oldvar)
LIBMESH_DEVICE_INLINE T libmesh_conj(T a)
boost::multiprecision::float128 real(const boost::multiprecision::float128 in)
boost::multiprecision::float128 imag(const boost::multiprecision::float128)
bool operator()(const T1 &e1, const T2 &e2) const
bool operator()(const T1 &e1, const T1 &e2) const