exceptions.h

// ---------------------------------------------------------------------
//
// Copyright (C) 1998 - 2018 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE at
// the top level of the deal.II distribution.
//
// ---------------------------------------------------------------------

#ifndef dealii_exceptions_h
#define dealii_exceptions_h

#include <deal.II/base/config.h>

#include <exception>
#include <ostream>
#include <string>
#include <type_traits>

#ifdef DEAL_II_WITH_CUDA
#include <cusolverSp.h>
#include <cusparse.h>
#endif


DEAL_II_NAMESPACE_OPEN


class ExceptionBase : public std::exception
{
public:
  ExceptionBase ();

  ExceptionBase (const ExceptionBase &exc);

  virtual ~ExceptionBase () noexcept;

  ExceptionBase operator= (const ExceptionBase &) = delete;

  void set_fields (const char *file,
                   const int   line,
                   const char *function,
                   const char *cond,
                   const char *exc_name);


  virtual const char *what() const noexcept;

  const char *get_exc_name() const;

  void print_exc_data (std::ostream &out) const;

  virtual void print_info (std::ostream &out) const;

  void print_stack_trace (std::ostream &out) const;

protected:
  const char  *file;

  unsigned int line;

  const char  *function;

  const char  *cond;

  const char  *exc;

  mutable char **stacktrace;

  int n_stacktrace_frames;

#ifdef DEAL_II_HAVE_GLIBC_STACKTRACE

  void *raw_stacktrace[25];
#endif

private:
  void generate_message() const;

  mutable std::string what_str;
};

#ifndef DOXYGEN

#define DeclException0(Exception0)                                        \
  class Exception0 :  public ::ExceptionBase {}


#define DeclExceptionMsg(Exception, defaulttext)                          \
  class Exception :  public ::ExceptionBase                         \
  {                                                                       \
  public:                                                                 \
    Exception (const std::string &msg = defaulttext) : arg (msg) {}       \
    virtual ~Exception () noexcept {}                                     \
    virtual void print_info (std::ostream &out) const {                   \
      out << "    " << arg << std::endl;                                  \
    }                                                                     \
  private:                                                                \
    const std::string arg;                                                \
  }

#define DeclException1(Exception1, type1, outsequence)                    \
  class Exception1 : public ::ExceptionBase {                       \
  public:                                                                 \
    Exception1 (const type1 a1) : arg1 (a1) {}    /*NOLINT*/              \
    virtual ~Exception1 () noexcept {}                                    \
    virtual void print_info (std::ostream &out) const {                   \
      out << "    " outsequence << std::endl;                             \
    }                                                                     \
  private:                                                                \
    const type1 arg1;                                                     \
  }


#define DeclException2(Exception2, type1, type2, outsequence)             \
  class Exception2 : public ::ExceptionBase {                       \
  public:                                                                 \
    Exception2 (const type1 a1, const type2 a2) : /*NOLINT*/              \
      arg1 (a1), arg2(a2) {}                                              \
    virtual ~Exception2 () noexcept {}                                    \
    virtual void print_info (std::ostream &out) const {                   \
      out << "    " outsequence << std::endl;                             \
    }                                                                     \
  private:                                                                \
    const type1 arg1;                                                     \
    const type2 arg2;                                                     \
  }


#define DeclException3(Exception3, type1, type2, type3, outsequence)      \
  class Exception3 : public ::ExceptionBase {                       \
  public:                                                                 \
    Exception3 (const type1 a1, const type2 a2, const type3 a3) : /*NOLINT*/ \
      arg1 (a1), arg2(a2), arg3(a3) {}                                    \
    virtual ~Exception3 () noexcept {}                                    \
    virtual void print_info (std::ostream &out) const {                   \
      out << "    " outsequence << std::endl;                             \
    }                                                                     \
  private:                                                                \
    const type1 arg1;                                                     \
    const type2 arg2;                                                     \
    const type3 arg3;                                                     \
  }


#define DeclException4(Exception4, type1, type2, type3, type4, outsequence) \
  class Exception4 : public ::ExceptionBase {                       \
  public:                                                                 \
    Exception4 (const type1 a1, const type2 a2,   /*NOLINT*/              \
                const type3 a3, const type4 a4) : /*NOLINT*/              \
      arg1 (a1), arg2(a2), arg3(a3), arg4(a4) {}                          \
    virtual ~Exception4 () noexcept {}                                    \
    virtual void print_info (std::ostream &out) const {                   \
      out << "    " outsequence << std::endl;                             \
    }                                                                     \
  private:                                                                \
    const type1 arg1;                                                     \
    const type2 arg2;                                                     \
    const type3 arg3;                                                     \
    const type4 arg4;                                                     \
  }


#define DeclException5(Exception5, type1, type2, type3, type4, type5, outsequence) \
  class Exception5 : public ::ExceptionBase {                       \
  public:                                                                 \
    Exception5 (const type1 a1, const type2 a2, const type3 a3,/*NOLINT*/ \
                const type4 a4, const type5 a5) :              /*NOLINT*/ \
      arg1 (a1), arg2(a2), arg3(a3), arg4(a4), arg5(a5) {}                \
    virtual ~Exception5 () noexcept {}                                    \
    virtual void print_info (std::ostream &out) const {                   \
      out << "    " outsequence << std::endl;                             \
    }                                                                     \
  private:                                                                \
    const type1 arg1;                                                     \
    const type2 arg2;                                                     \
    const type3 arg3;                                                     \
    const type4 arg4;                                                     \
    const type5 arg5;                                                     \
  }

#else /*ifndef DOXYGEN*/

// Dummy definitions for doxygen:

#define DeclException0(Exception0)                                        \
 \
  static ::ExceptionBase& Exception0 ()

#define DeclExceptionMsg(Exception, defaulttext)                          \
 \
  \
  static ::ExceptionBase& Exception ()

#define DeclException1(Exception1, type1, outsequence)                    \
 \
              \
  static ::ExceptionBase& Exception1 (type1 arg1)


#define DeclException2(Exception2, type1, type2, outsequence)             \
 \
              \
  static ::ExceptionBase& Exception2 (type1 arg1, type2 arg2)


#define DeclException3(Exception3, type1, type2, type3, outsequence)      \
 \
              \
  static ::ExceptionBase& Exception3 (type1 arg1, type2 arg2, type3 arg3)


#define DeclException4(Exception4, type1, type2, type3, type4, outsequence) \
 \
                \
  static ::ExceptionBase& Exception4 (type1 arg1, type2 arg2, type3 arg3, type4 arg4)


#define DeclException5(Exception5, type1, type2, type3, type4, type5, outsequence) \
 \
                       \
  static ::ExceptionBase& Exception5 (type1 arg1, type2 arg2, type3 arg3, type4 arg4, type5 arg5)

#endif /*ifndef DOXYGEN*/


namespace StandardExceptions
{

  DeclExceptionMsg (ExcDivideByZero,
                    "A piece of code is attempting a division by zero. This is "
                    "likely going to lead to results that make no sense.");

  DeclException1 (ExcNumberNotFinite,
                  std::complex<double>,
                  << "In a significant number of places, deal.II checks that some intermediate "
                  << "value is a finite number (as opposed to plus or minus infinity, or "
                  << "NaN/Not a Number). In the current function, we encountered a number "
                  << "that is not finite (its value is " << arg1 << " and therefore "
                  << "violates the current assertion).\n\n"
                  << "This may be due to the fact that some operation in this function "
                  << "created such a value, or because one of the arguments you passed "
                  << "to the function already had this value from some previous "
                  << "operation. In the latter case, this function only triggered the "
                  << "error but may not actually be responsible for the computation of "
                  << "the number that is not finite.\n\n"
                  << "There are two common cases where this situation happens. First, your "
                  << "code (or something in deal.II) divides by zero in a place where this "
                  << "should not happen. Or, you are trying to solve a linear system "
                  << "with an unsuitable solver (such as an indefinite or non-symmetric "
                  << "linear system using a Conjugate Gradient solver); such attempts "
                  << "oftentimes yield an operation somewhere that tries to divide "
                  << "by zero or take the square root of a negative value.\n\n"
                  << "In any case, when trying to find the source of the error, "
                  << "recall that the location where you are getting this error is "
                  << "simply the first place in the program where there is a check "
                  << "that a number (e.g., an element of a solution vector) is in fact "
                  << "finite, but that the actual error that computed the number "
                  << "may have happened far earlier. To find this location, you "
                  << "may want to add checks for finiteness in places of your "
                  << "program visited before the place where this error is produced."
                  << "One way to check for finiteness is to use the 'AssertIsFinite' "
                  << "macro.");

  DeclExceptionMsg (ExcOutOfMemory,
                    "Your program tried to allocate some memory but this "
                    "allocation failed. Typically, this either means that "
                    "you simply do not have enough memory in your system, "
                    "or that you are (erroneously) trying to allocate "
                    "a chunk of memory that is simply beyond all reasonable "
                    "size, for example because the size of the object has "
                    "been computed incorrectly.");

  DeclException1 (ExcMemoryLeak, int,
                  << "Destroying memory handler while " << arg1
                  << " objects are still allocated.");

  DeclExceptionMsg (ExcIO,
                    "An input/output error has occurred. There are a number of "
                    "reasons why this may be happening, both for reading and "
                    "writing operations."
                    "\n\n"
                    "If this happens during an operation that tries to read "
                    "data: First, you may be "
                    "trying to read from a file that doesn't exist or that is "
                    "not readable given its file permissions. Second, deal.II "
                    "uses this error at times if it tries to "
                    "read information from a file but where the information "
                    "in the file does not correspond to the expected format. "
                    "An example would be a truncated file, or a mesh file "
                    "that contains not only sections that describe the "
                    "vertices and cells, but also sections for additional "
                    "data that deal.II does not understand."
                    "\n\n"
                    "If this happens during an operation that tries to write "
                    "data: you may be trying to write to a file to which file "
                    "or directory permissions do not allow you to write. A "
                    "typical example is where you specify an output file in "
                    "a directory that does not exist.");

  DeclException1 (ExcFileNotOpen,
                  char *,
                  << "Could not open file " << arg1 << ".");

  DeclExceptionMsg (ExcNotImplemented,
                    "You are trying to use functionality in deal.II that is "
                    "currently not implemented. In many cases, this indicates "
                    "that there simply didn't appear much of a need for it, or "
                    "that the author of the original code did not have the "
                    "time to implement a particular case. If you hit this "
                    "exception, it is therefore worth the time to look into "
                    "the code to find out whether you may be able to "
                    "implement the missing functionality. If you do, please "
                    "consider providing a patch to the deal.II development "
                    "sources (see the deal.II website on how to contribute).");

  DeclExceptionMsg (ExcInternalError,
                    "This exception -- which is used in many places in the "
                    "library -- usually indicates that some condition which "
                    "the author of the code thought must be satisfied at a "
                    "certain point in an algorithm, is not fulfilled. An "
                    "example would be that the first part of an algorithm "
                    "sorts elements of an array in ascending order, and "
                    "a second part of the algorithm later encounters an "
                    "element that is not larger than the previous one."
                    "\n\n"
                    "There is usually not very much you can do if you "
                    "encounter such an exception since it indicates an error "
                    "in deal.II, not in your own program. Try to come up with "
                    "the smallest possible program that still demonstrates "
                    "the error and contact the deal.II mailing lists with it "
                    "to obtain help.");

  DeclExceptionMsg (ExcPureFunctionCalled,
                    "You (or a place in the library) are trying to call a "
                    "function that is declared as a virtual function in a "
                    "base class but that has not been overridden in your "
                    "derived class."
                    "\n\n"
                    "This exception happens in cases where the base class "
                    "cannot provide a useful default implementation for "
                    "the virtual function, but where we also do not want "
                    "to mark the function as abstract (i.e., with '=0' at the end) "
                    "because the function is not essential to the class in many "
                    "contexts. In cases like this, the base class provides "
                    "a dummy implementation that makes the compiler happy, but "
                    "that then throws the current exception."
                    "\n\n"
                    "A concrete example would be the 'Function' class. It declares "
                    "the existence of 'value()' and 'gradient()' member functions, "
                    "and both are marked as 'virtual'. Derived classes have to "
                    "override these functions for the values and gradients of a "
                    "particular function. On the other hand, not every function "
                    "has a gradient, and even for those that do, not every program "
                    "actually needs to evaluate it. Consequently, there is no "
                    "*requirement* that a derived class actually override the "
                    "'gradient()' function (as there would be had it been marked "
                    "as abstract). But, since the base class cannot know how to "
                    "compute the gradient, if a derived class does not override "
                    "the 'gradient()' function and it is called anyway, then the "
                    "default implementation in the base class will simply throw "
                    "an exception."
                    "\n\n"
                    "The exception you see is what happens in cases such as the "
                    "one just illustrated. To fix the problem, you need to "
                    "investigate whether the function being called should indeed have "
                    "been called; if the answer is 'yes', then you need to "
                    "implement the missing override in your class.");

  DeclException0 (ExcNotInitialized);

  DeclException0 (ExcInvalidState);

  DeclException1 (ExcImpossibleInDim,
                  int,
                  << "You are trying to execute functionality that is "
                  << "impossible in " << arg1
                  << "d or simply does not make any sense.");

  DeclException2 (ExcImpossibleInDimSpacedim,
                  int, int,
                  << "You are trying to execute functionality that is "
                  << "impossible in dimensions <" << arg1 << "," << arg2
                  << "> or simply does not make any sense.");


  DeclExceptionMsg(ExcZero,
                   "In a check in the code, deal.II encountered a zero in "
                   "a place where this does not make sense. See the condition "
                   "that was being checked and that is printed further up "
                   "in the error message to get more information on what "
                   "the erroneous zero corresponds to.");

  DeclExceptionMsg(ExcEmptyObject,
                   "The object you are trying to access is empty but it makes "
                   "no sense to attempt the operation you are trying on an "
                   "empty object.");

  DeclException2 (ExcDimensionMismatch,
                  std::size_t, std::size_t,
                  << "Dimension " << arg1 << " not equal to " << arg2 << ".");

  DeclException3 (ExcDimensionMismatch2,
                  int, int, int,
                  << "Dimension " << arg1 << " neither equal to " << arg2
                  << " nor to " << arg3 << ".");

  DeclException3 (ExcIndexRange,
                  int, int, int,
                  << "Index " << arg1 << " is not in the half-open range [" << arg2 << ","
                  << arg3 << ")."
                  << (arg2==arg3 ?
                      " In the current case, this half-open range is in fact empty, "
                      "suggesting that you are accessing an element of an empty "
                      "collection such as a vector that has not been set to the "
                      "correct size."
                      :
                      ""));

  template <typename T>
  DeclException3 (ExcIndexRangeType,
                  T,T,T,
                  << "Index " << arg1 << " is not in the half-open range [" << arg2 << ","
                  << arg3 << ")."
                  << (arg2==arg3 ?
                      " In the current case, this half-open range is in fact empty, "
                      "suggesting that you are accessing an element of an empty "
                      "collection such as a vector that has not been set to the "
                      "correct size."
                      :
                      ""));

  DeclException2 (ExcLowerRange,
                  int, int,
                  << "Number " << arg1 << " must be larger than or equal "
                  << arg2 << ".");

  template <typename T>
  DeclException2 (ExcLowerRangeType,
                  T, T,
                  << "Number " << arg1 << " must be larger than or equal "
                  << arg2 << ".");

  DeclException2 (ExcNotMultiple,
                  int, int,
                  << "Division " << arg1 << " by " << arg2
                  << " has remainder different from zero.");

  DeclExceptionMsg (ExcInvalidIterator,
                    "You are trying to use an iterator, but the iterator is "
                    "in an invalid state. This may indicate that the iterator "
                    "object has not been initialized, or that it has been "
                    "moved beyond the end of the range of valid elements.");

  DeclExceptionMsg (ExcIteratorPastEnd,
                    "You are trying to use an iterator, but the iterator is "
                    "pointing past the end of the range of valid elements. "
                    "It is not valid to dereference the iterator in this "
                    "case.");

  DeclException1 (ExcMessage,
                  std::string,
                  << arg1);

  DeclExceptionMsg (ExcGhostsPresent,
                    "You are trying an operation on a vector that is only "
                    "allowed if the vector has no ghost elements, but the "
                    "vector you are operating on does have ghost elements. "
                    "Specifically, vectors with ghost elements are read-only "
                    "and cannot appear in operations that write into these "
                    "vectors."
                    "\n\n"
                    "See the glossary entry on 'Ghosted vectors' for more "
                    "information.");

  DeclExceptionMsg (ExcScalarAssignmentOnlyForZeroValue,
                    "You are trying an operation of the form 'vector=s' with "
                    "a nonzero scalar value 's'. However, such assignments "
                    "are only allowed if the right hand side is zero.");

  DeclExceptionMsg (ExcNeedsLAPACK,
                    "You are attempting to use functionality that is only available "
                    "if deal.II was configured to use LAPACK, but cmake did not "
                    "find a valid LAPACK library.");

  DeclExceptionMsg (ExcNeedsNetCDF,
                    "You are attempting to use functionality that is only available "
                    "if deal.II was configured to use NetCDF, but cmake did not "
                    "find a valid NetCDF library.");

  DeclExceptionMsg (ExcNeedsFunctionparser,
                    "You are attempting to use functionality that is only available "
                    "if deal.II was configured to use the function parser which "
                    "relies on the muparser library, but cmake did not "
                    "find a valid muparser library on your system and also did "
                    "not choose the one that comes bundled with deal.II.");

  DeclExceptionMsg (ExcNeedsAssimp,
                    "You are attempting to use functionality that is only available "
                    "if deal.II was configured to use Assimp, but cmake did not "
                    "find a valid Assimp library.");

#ifdef DEAL_II_WITH_CUDA

  DeclException1 (ExcCudaError,
                  char *,
                  << arg1);
  DeclException1 (ExcCusparseError,
                  std::string,
                  << "There was an error in a cuSPARSE function: "
                  << arg1);
#endif


#ifdef DEAL_II_WITH_MPI

  class ExcMPI : public ::ExceptionBase
  {
  public:
    ExcMPI (const int error_code);

    virtual void print_info (std::ostream &out) const;

    const int error_code;
  };
#endif // DEAL_II_WITH_MPI
} /*namespace StandardExceptions*/



namespace deal_II_exceptions
{

  void set_additional_assert_output (const char *const p);

  void suppress_stacktrace_in_exceptions ();

  void disable_abort_on_exception ();

  namespace internals
  {

    [[noreturn]]
    void abort (const ExceptionBase &exc);

    enum ExceptionHandling
    {
      abort_on_exception,
      throw_on_exception,
      abort_nothrow_on_exception
    };

    template <class ExceptionType>
    [[noreturn]]
    void issue_error_noreturn (ExceptionHandling  handling,
                               const char       *file,
                               int               line,
                               const char       *function,
                               const char       *cond,
                               const char       *exc_name,
                               ExceptionType     e)
    {
      // Fill the fields of the exception object
      e.set_fields (file, line, function, cond, exc_name);

      switch (handling)
        {
        case abort_on_exception:
          ::deal_II_exceptions::internals::abort(e);
        case throw_on_exception:
          throw e;
        // this function should never return (and AssertNothrow can);
        // something must have gone wrong in the error handling code for us
        // to get this far, so throw an exception.
        case abort_nothrow_on_exception:
        default:
          throw ::StandardExceptions::ExcInternalError();
        }
    }

    void
    do_issue_error_nothrow(const ExceptionBase &e) noexcept;

    template <class ExceptionType>
    void issue_error_nothrow (ExceptionHandling,
                              const char    *file,
                              int            line,
                              const char    *function,
                              const char    *cond,
                              const char    *exc_name,
                              ExceptionType  e) noexcept
    {
      static_assert(std::is_base_of<ExceptionBase, ExceptionType>::value,
      "The provided exception must inherit from ExceptionBase.");
      // Fill the fields of the exception object
      e.set_fields (file, line, function, cond, exc_name);
      // avoid moving a bunch of code into the header by dispatching to
      // another function:
      do_issue_error_nothrow(e);
    }
#ifdef DEAL_II_WITH_CUDA

    std::string get_cusparse_error_string(const cusparseStatus_t error_code);

    std::string get_cusolver_error_string(const cusolverStatus_t error_code);
#endif
  } /*namespace internals*/

} /*namespace deal_II_exceptions*/



#ifdef DEBUG
#  ifdef DEAL_II_HAVE_BUILTIN_EXPECT
#    define Assert(cond, exc)                                                \
{                                                                            \
  if (__builtin_expect(!(cond), false))                                      \
    ::deal_II_exceptions::internals:: issue_error_noreturn(                  \
        ::deal_II_exceptions::internals::abort_on_exception,                 \
        __FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, #exc, exc);          \
}
#  else /*ifdef DEAL_II_HAVE_BUILTIN_EXPECT*/
#    define Assert(cond, exc)                                                \
{                                                                            \
  if (!(cond))                                                               \
    ::deal_II_exceptions::internals:: issue_error_noreturn(                  \
        ::deal_II_exceptions::internals::abort_on_exception,                 \
        __FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, #exc, exc);          \
}
#  endif /*ifdef DEAL_II_HAVE_BUILTIN_EXPECT*/
#else
#define Assert(cond, exc)                                                    \
  {}
#endif



#ifdef DEBUG
#  ifdef DEAL_II_HAVE_BUILTIN_EXPECT
#    define AssertNothrow(cond, exc)                                             \
{                                                                                \
  if (__builtin_expect(!(cond), false))                                          \
    ::deal_II_exceptions::internals::issue_error_nothrow(                        \
        ::deal_II_exceptions::internals::abort_nothrow_on_exception,             \
        __FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, #exc, exc);              \
}
#  else /*ifdef DEAL_II_HAVE_BUILTIN_EXPECT*/
#    define AssertNothrow(cond, exc)                                             \
{                                                                                \
  if (!(cond))                                                                   \
    ::deal_II_exceptions::internals::issue_error_nothrow(                        \
        ::deal_II_exceptions::internals::abort_nothrow_on_exception,             \
        __FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, #exc, exc);              \
}
#  endif /*ifdef DEAL_II_HAVE_BUILTIN_EXPECT*/
#else
#define AssertNothrow(cond, exc)                                                 \
  {}
#endif

#ifdef DEAL_II_HAVE_BUILTIN_EXPECT
#define AssertThrow(cond, exc)                                                 \
{                                                                              \
  if (__builtin_expect(!(cond), false))                                        \
    ::deal_II_exceptions::internals:: issue_error_noreturn(                    \
        ::deal_II_exceptions::internals::throw_on_exception,                   \
        __FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, #exc, exc);            \
}
#else /*ifdef DEAL_II_HAVE_BUILTIN_EXPECT*/
#define AssertThrow(cond, exc)                                                 \
{                                                                              \
  if (!(cond))                                                                 \
    ::deal_II_exceptions::internals::issue_error_noreturn(                     \
        ::deal_II_exceptions::internals::throw_on_exception,                   \
        __FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, #exc, exc);            \
}
#endif /*ifdef DEAL_II_HAVE_BUILTIN_EXPECT*/

#define AssertDimension(dim1,dim2) \
  Assert((dim1) == (dim2), ::ExcDimensionMismatch((dim1),(dim2)))


#define AssertVectorVectorDimension(vec,dim1,dim2)                              \
  AssertDimension((vec).size(), (dim1));                                        \
  for (unsigned int i=0;i<dim1;++i) {AssertDimension((vec)[i].size(), (dim2));}

namespace internal
{
  // Workaround to allow for commas in template parameter lists
  // in preprocessor macros as found in
  // https://stackoverflow.com/questions/13842468/comma-in-c-c-macro
  template<typename T> struct argument_type;
  template<typename T, typename U> struct argument_type<T(U)>
  {
    typedef U type;
  };
}

#define AssertIndexRange(index,range)                                          \
Assert((index) < (range),                                                      \
       ExcIndexRangeType<typename ::internal::argument_type<                   \
       void(typename std::common_type<decltype(index),                         \
            decltype(range)>::type)>::type>((index),0,(range)))

#define AssertIsFinite(number)                                                 \
Assert(::numbers::is_finite(number),                                     \
       ::ExcNumberNotFinite(std::complex<double>(number)))

#ifdef DEAL_II_WITH_MPI

#define AssertThrowMPI(error_code)                                             \
AssertThrow(error_code == MPI_SUCCESS, ::ExcMPI(error_code))
#else
#define AssertThrowMPI(error_code) {}
#endif // DEAL_II_WITH_MPI

#ifdef DEAL_II_WITH_CUDA

#ifdef DEBUG
#define AssertCuda(error_code) Assert(error_code == cudaSuccess, \
                                      ::ExcCudaError(cudaGetErrorString(error_code)))
#else
#define AssertCuda(error_code) { (void) (error_code); }
#endif

#ifdef DEBUG
#define AssertCusparse(error_code) Assert(error_code == CUSPARSE_STATUS_SUCCESS, \
                                          ExcCusparseError(         \
                                              deal_II_exceptions::internals::         \
                                              get_cusparse_error_string(error_code)))
#else
#define AssertCusparse(error_code) { (void) (error_code); }
#endif

#ifdef DEBUG
#define AssertCusolver(error_code) Assert(error_code == CUSOLVER_STATUS_SUCCESS, \
                                          ExcCusparseError(         \
                                              deal_II_exceptions::internals::         \
                                              get_cusolver_error_string(error_code)))
#else
#define AssertCusolver(error_code) { (void) (error_code); }
#endif

#endif

using namespace StandardExceptions;

DEAL_II_NAMESPACE_CLOSE

#endif