exceptions.h

// ---------------------------------------------------------------------
//
// Copyright (C) 1998 - 2019 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.md at
// the top level directory of deal.II.
//
// ---------------------------------------------------------------------

#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 override;

  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 override;

  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 override    \
      {                                               \
        out << "    " << arg << std::endl;            \
      }                                               \
                                                      \
    private:                                          \
      const std::string arg;                          \
    }

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


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


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


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


#  define DeclException5(                                       \
    Exception5, type1, type2, type3, type4, type5, outsequence) \
    class Exception5 : public ::ExceptionBase             \
    {                                                           \
    public:                                                     \
      Exception5(type1 const &a1,                               \
                 type2 const &a2,                               \
                 type3 const &a3,                               \
                 type4 const &a4,                               \
                 type5 const &a5)                               \
        : arg1(a1)                                              \
        , arg2(a2)                                              \
        , arg3(a3)                                              \
        , arg4(a4)                                              \
        , arg5(a5)                                              \
      {}                                                        \
      virtual ~Exception5() noexcept                            \
      {}                                                        \
      virtual void                                              \
      print_info(std::ostream &out) const override              \
      {                                                         \
        out << "    " outsequence << std::endl;                 \
      }                                                         \
                                                                \
    private:                                                    \
      type1 const arg1;                                         \
      type2 const arg2;                                         \
      type3 const arg3;                                         \
      type4 const arg4;                                         \
      type5 const 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,
                 std::string,
                 << "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, const 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 override;

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



namespace deal_II_exceptions
{
  namespace internals
  {
    extern bool allow_abort_on_exception;
  } // namespace internals

  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) noexcept;

    enum ExceptionHandling
    {
      abort_or_throw_on_exception,
      throw_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_or_throw_on_exception:
            {
              if (::deal_II_exceptions::internals::
                    allow_abort_on_exception)
                internals::abort(e);
              else
                {
                  // We are not allowed to abort, so just throw the error:
                  throw 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.
          default:
            throw ::StandardExceptions::ExcInternalError();
        }
    }

    void do_issue_error_nothrow(const ExceptionBase &e) noexcept;

    template <class ExceptionType>
    void
    issue_error_nothrow(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_or_throw_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_or_throw_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(         \
            __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(         \
            __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(static_cast<typename ::internal::argument_type<void(          \
             typename std::common_type<decltype(dim1),                         \
                                       decltype(dim2)>::type)>::type>(dim1) == \
           static_cast<typename ::internal::argument_type<void(        \
             typename std::common_type<decltype(dim1),                         \
                                       decltype(dim2)>::type)>::type>(dim2),   \
         ::ExcDimensionMismatch((dim1), (dim2)))


#define AssertVectorVectorDimension(VEC, DIM1, DIM2) \
  AssertDimension(VEC.size(), DIM1);                 \
  for (const auto &subvector : VEC)                  \
    {                                                \
      (void)subvector;                               \
      AssertDimension(subvector.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)>
  {
    using type = U;
  };
} // namespace internal

#define AssertIndexRange(index, range)                                         \
  Assert(                                                                      \
    static_cast<typename ::internal::argument_type<void(               \
        typename std::common_type<decltype(index), decltype(range)>::type)>::  \
                  type>(index) <                                               \
      static_cast<typename ::internal::argument_type<void(             \
        typename std::common_type<decltype(index), decltype(range)>::type)>::  \
                    type>(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 AssertNothrowCuda(error_code)      \
      AssertNothrow(error_code == cudaSuccess, \
                    ::ExcCudaError(cudaGetErrorString(error_code)))
#  else
#    define AssertNothrowCuda(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 AssertNothrowCusparse(error_code)                               \
      AssertNothrow(                                                        \
        error_code == CUSPARSE_STATUS_SUCCESS,                              \
        ExcCusparseError(                                                   \
          deal_II_exceptions::internals::get_cusparse_error_string(         \
            error_code)))
#  else
#    define AssertNothrowCusparse(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