AMReX_ErrorList.H

Go to the documentation of this file.

#ifndef AMREX_ErrorList_H_
#define AMREX_ErrorList_H_
#include <AMReX_Config.H>
 
#include <AMReX_Array.H>
#include <AMReX_ArrayLim.H>
#include <AMReX_Geometry.H>
#include <AMReX_MultiFab.H>
#include <AMReX_Parser.H>
#include <AMReX_REAL.H>
#include <AMReX_TagBox.H>
#include <AMReX_Vector.H>
 
#include <iterator>
#include <memory>
#include <string>
 
namespace amrex {
 
 
extern "C"
{

    using ErrorFuncDefault = void (*)(int* tag, AMREX_ARLIM_P(tlo), AMREX_ARLIM_P(thi),
                                      const int* tagval, const int* clearval,
                                      amrex::Real* data, AMREX_ARLIM_P(data_lo), AMREX_ARLIM_P(data_hi),
                                      const int* lo, const int * hi, const int* nvar,
                                      const int* domain_lo, const int* domain_hi,
                                      const amrex::Real* dx, const amrex::Real* xlo,
                                      const amrex::Real* prob_lo, const amrex::Real* time,
                                      const int* level);
 
    using ErrorFunc2Default = void (*)(int* tag, AMREX_ARLIM_P(tlo), AMREX_ARLIM_P(thi),
                                       const int* tagval, const int* clearval,
                                       amrex::Real* data, AMREX_ARLIM_P(data_lo), AMREX_ARLIM_P(data_hi),
                                       const int* lo, const int * hi, const int* nvar,
                                       const int* domain_lo, const int* domain_hi,
                                       const amrex::Real* dx, const int* level, const amrex::Real* avg);
 

    using ErrorFunc3DDefault = void (*)(int* tag, const int* tlo, const int* thi,
                                        const int* tagval, const int* clearval,
                                        amrex::Real* data, const int* data_lo, const int* data_hi,
                                        const int* lo, const int * hi, const int* nvar,
                                        const int* domain_lo, const int* domain_hi,
                                        const amrex::Real* dx, const amrex::Real* xlo,
                                        const amrex::Real* prob_lo, const amrex::Real* time,
                                        const int* level);
 
}
 

class ErrorRec
{
public:
    //
    // Error types.
    //
    enum ErrorType { Special=0, Standard, UseAverage };
    //
    // Class wrapper around ErrorFuncDefault.
    //
    class ErrorFunc
    {
    public:

        ErrorFunc ();

        // No explicit because some codes rely on it.
        ErrorFunc (ErrorFuncDefault inFunc);

        // No explicit because some codes rely on it.
        ErrorFunc (ErrorFunc3DDefault inFunc);

        [[nodiscard]] virtual ErrorFunc* clone () const;

        virtual ~ErrorFunc () = default;
 
        ErrorFunc (ErrorFunc const&) = default;
        ErrorFunc (ErrorFunc &&) = delete;
        ErrorFunc& operator= (ErrorFunc const&) = default;
        ErrorFunc& operator= (ErrorFunc &&) = delete;

        virtual void operator () (int* tag, AMREX_ARLIM_P(tlo), AMREX_ARLIM_P(thi),
                                  const int* tagval, const int* clearval,
                                  Real* data, AMREX_ARLIM_P(data_lo), AMREX_ARLIM_P(data_hi),
                                  const int* lo, const int * hi, const int* nvar,
                                  const int* domain_lo, const int* domain_hi,
                                  const Real* dx, const Real* xlo,
                                  const Real* prob_lo, const Real* time,
                                  const int* level) const;

        virtual void operator () (int* tag, const int* tlo, const int* thi,
                                  const int* tagval, const int* clearval,
                                  Real* data, const int* dlo, const int* dhi,
                                  const int* lo, const int * hi, const int* nvar,
                                  const int* domain_lo, const int* domain_hi,
                                  const Real* dx, const Real* xlo,
                                  const Real* prob_lo, const Real* time,
                                  const int* level) const;
    protected:
 
        ErrorFuncDefault   m_func{nullptr};
        ErrorFunc3DDefault m_func3D{nullptr};
    };
    class ErrorFunc2
    {
    public:

        ErrorFunc2 ();

        // No explicit because some codes rely on it.
        ErrorFunc2 (ErrorFunc2Default inFunc);

        [[nodiscard]] virtual ErrorFunc2* clone () const;

        virtual ~ErrorFunc2 () = default;
 
        ErrorFunc2 (ErrorFunc2 const&) = default;
        ErrorFunc2 (ErrorFunc2 &&) = delete;
        ErrorFunc2& operator= (ErrorFunc2 const&) = default;
        ErrorFunc2& operator= (ErrorFunc2 &&) = delete;


        virtual void operator () (int* tag, AMREX_ARLIM_P(tlo), AMREX_ARLIM_P(thi),
                                  const int* tagval, const int* clearval,
                                  Real* data, AMREX_ARLIM_P(data_lo), AMREX_ARLIM_P(data_hi),
                                  const int* lo, const int * hi, const int* nvar,
                                  const int* domain_lo, const int* domain_hi,
                                  const Real* dx, const int* level, const Real* avg) const;
    protected:
 
        ErrorFunc2Default  m_func{nullptr};
    };

    ErrorRec (std::string nm, int ng, ErrorType etyp,
              const ErrorRec::ErrorFunc2& f2);

    ErrorRec (std::string nm, int ng, ErrorType etyp,
              const ErrorRec::ErrorFunc& f);
 
    virtual ~ErrorRec ();
 
    ErrorRec (ErrorRec const&) = delete;
    ErrorRec (ErrorRec &&) = delete;
    ErrorRec& operator= (ErrorRec const&) = delete;
    ErrorRec& operator= (ErrorRec &&) = delete;

    [[nodiscard]] const std::string& name () const noexcept;

    [[nodiscard]] int nGrow () const noexcept;

    [[nodiscard]] ErrorType errType () const noexcept;

    [[nodiscard]] virtual const ErrorRec::ErrorFunc&  errFunc () const;
    [[nodiscard]] virtual const ErrorRec::ErrorFunc2& errFunc2() const;
 
private:

    std::string derive_name;

    int ngrow;

    ErrorType err_type;

    ErrorFunc*  err_func;
    ErrorFunc2* err_func2;
};
 

class ErrorList
{
public:
    ErrorList() noexcept = default;

    [[nodiscard]] int size () const noexcept;

    void add (const std::string&  name,
              int                 nextra,
              ErrorRec::ErrorType typ,
              const ErrorRec::ErrorFunc&    func);

    void add (const std::string&  name,
              int                 nextra,
              ErrorRec::ErrorType typ,
              const ErrorRec::ErrorFunc2&   func);

    [[nodiscard]] const ErrorRec& operator[] (int k) const noexcept;
 
    void clear (bool rs0 = false) { vec.clear(); if(rs0) { vec.resize(0); } }
 
private:
 
    Vector<std::unique_ptr<ErrorRec> > vec;
};
 
std::ostream& operator << (std::ostream& os, const ErrorList& elst);

  struct AMRErrorTagInfo
  {
    int m_max_level = 1000;
    Real m_min_time = std::numeric_limits<Real>::lowest();
    Real m_max_time = std::numeric_limits<Real>::max();
    int m_volume_weighting = 0;
    int m_derefine = 0;
    RealBox m_realbox;
 
    AMRErrorTagInfo& SetMaxLevel (int max_level) noexcept {
      m_max_level = max_level;
      return *this;
    }
    AMRErrorTagInfo& SetMinTime (amrex::Real min_time) noexcept {
      m_min_time = min_time;
      return *this;
    }
    AMRErrorTagInfo& SetMaxTime (amrex::Real max_time) noexcept {
      m_max_time = max_time;
      return *this;
    }
    AMRErrorTagInfo& SetRealBox (const amrex::RealBox& realbox) noexcept {
      m_realbox = realbox;
      return *this;
    }
    AMRErrorTagInfo& SetVolumeWeighting (int volume_weighting) noexcept {
      m_volume_weighting = volume_weighting;
      return *this;
    }
    AMRErrorTagInfo& SetDerefine (int derefine) noexcept {
      m_derefine = derefine;
      return *this;
    }
  };

  class AMRErrorTag
  {
  public:
 
    enum TEST {GRAD=0, RELGRAD, LESS, GREATER, VORT, BOX, USER, PARSER};
 
    struct UserFunc
    {
      virtual ~UserFunc () = default;
 
      UserFunc (UserFunc const&) = default;
      UserFunc (UserFunc &&) = default;
      UserFunc& operator= (UserFunc const&) = default;
      UserFunc& operator= (UserFunc &&) = default;
 
      virtual void operator() (const amrex::Box&                       bx,
                               amrex::Array4<const amrex::Real> const& dat,
                               amrex::Array4<char> const&              tag,
                               amrex::Real                             time,
                               int                                     level,
                               char                                    tagval,
                               char                                    clearval) = 0;
    };

    explicit AMRErrorTag (const AMRErrorTagInfo& info = AMRErrorTagInfo()) noexcept
      : m_info(info), m_ngrow(SetNGrow()) {}

    AMRErrorTag (amrex::Real            value,
                 AMRErrorTag::TEST      test,
                 std::string            field,
                 const AMRErrorTagInfo& info = AMRErrorTagInfo()) noexcept
      : m_value((info.m_max_level > 0) ? info.m_max_level : 1, value),
        m_test(test), m_field(std::move(field)), m_info(info),
        m_ngrow(SetNGrow())
      {
      }

    AMRErrorTag (amrex::Vector<amrex::Real> const& value,
                 AMRErrorTag::TEST                test,
                 std::string                      field,
                 const AMRErrorTagInfo&           info = AMRErrorTagInfo()) noexcept
      : m_test(test), m_field(std::move(field)), m_info(info), m_ngrow(SetNGrow())
      {
          AMREX_ALWAYS_ASSERT_WITH_MESSAGE(!value.empty(),
              "AMRErrorTag: value must not be empty");
          m_value.resize((info.m_max_level > 0) ? info.m_max_level : 1);
          for (int i = 0; i < m_value.size() && i < value.size(); ++i) {
              m_value[i] = value[i];
          }
          // If the user didn't provided a value for every level,
          // assume the last value holds for all higher levels.
          for (auto i = int(value.size()); i < m_value.size(); ++i) {
              m_value[i] = value[value.size()-1];
          }
      }

    AMRErrorTag (AMRErrorTag::UserFunc* userfunc,
                 std::string            field,
                 int                    ngrow,
                 const AMRErrorTagInfo& info = AMRErrorTagInfo()) noexcept
      : m_userfunc(userfunc), m_field(std::move(field)), m_info(info), m_ngrow(ngrow) {}

    explicit AMRErrorTag (Parser parser,
                          const AMRErrorTagInfo& info = AMRErrorTagInfo());

    void operator() (amrex::TagBoxArray&    tb,
                     const amrex::MultiFab* mf,
                     char                   clearval,
                     char                   tagval,
                     amrex::Real            time,
                     int                    level,
                     const amrex::Geometry& geom) const;
 
    [[nodiscard]] int NGrow() const noexcept {return m_ngrow;}
    [[nodiscard]] const std::string& Field () const noexcept {return m_field;}
 
    [[nodiscard]] AMRErrorTagInfo& GetInfo () noexcept {return m_info;}
    [[nodiscard]] AMRErrorTagInfo const& GetInfo () const noexcept {return m_info;}
    void SetInfo (AMRErrorTagInfo const& info) noexcept
    {
        if (!m_value.empty() && info.m_max_level > std::ssize(m_value)) {
            m_value.resize(info.m_max_level, m_value.back());
        }
        m_info = info;
    }
 
  protected:
    [[nodiscard]] int SetNGrow () const noexcept;
 
    Vector<Real> m_value;
    TEST m_test{BOX};
    UserFunc* m_userfunc = nullptr;
    std::unique_ptr<Parser> m_parser;
    ParserExecutor<4> m_parser_exe; // 4: (x,y,z,t)
    std::string m_field;
    AMRErrorTagInfo m_info;
    int m_ngrow = 0;
  };
}
 
#endif