AMReX_iMultiFab.H

Go to the documentation of this file.

 
#ifndef BL_IMULTIFAB_H
#define BL_IMULTIFAB_H
#include <AMReX_Config.H>
 
#include <AMReX_BLassert.H>
#include <AMReX_IArrayBox.H>
#include <AMReX_FabArray.H>
#include <AMReX_FabArrayUtility.H>
#include <AMReX_Geometry.H>
#include <memory>
 
namespace amrex {
 
/*
* A Collection of IArrayBoxes
*
* The iMultiFab class is publicly derived from the
* FabArray<int,IArrayBox> class.  It is a collection (stored as an array) of
* IArrayBoxes useful for storing integer data on a domain defined by
* a union of rectangular regions embedded in a uniform index space.  The
* iMultiFab class extends the function of the underlying FabArray class just
* as the IArrayBox class extends the function of BaseFab<int>.  Additional
* member functions are defined for I/O and simple arithmetic operations on
* these aggregate objects.
*
* This class does NOT provide a copy constructor or assignment operator.
*/
class iMultiFab
    :
    public FabArray<IArrayBox>
{
public:
 
    iMultiFab () noexcept = default;
 
    explicit iMultiFab (Arena* a) noexcept;
 
    iMultiFab (const BoxArray&            bxs,
               const DistributionMapping& dm,
               int                        ncomp,
               int                        ngrow,
#ifdef AMREX_STRICT_MODE
               const MFInfo&              info,
               const FabFactory<IArrayBox>& factory);
#else
               const MFInfo&              info = MFInfo(),
               const FabFactory<IArrayBox>& factory = DefaultFabFactory<IArrayBox>());
#endif
 
    iMultiFab (const BoxArray&            bxs,
               const DistributionMapping& dm,
               int                        ncomp,
               const IntVect&             ngrow,
#ifdef AMREX_STRICT_MODE
               const MFInfo&              info,
               const FabFactory<IArrayBox>& factory);
#else
               const MFInfo&              info = MFInfo(),
               const FabFactory<IArrayBox>& factory = DefaultFabFactory<IArrayBox>());
#endif
 
    iMultiFab (const iMultiFab& rhs, MakeType maketype, int scomp, int ncomp);
 
    ~iMultiFab () = default;
 
    iMultiFab (iMultiFab&& rhs) noexcept = default;
    iMultiFab& operator= (iMultiFab&& rhs) noexcept = default;
 
    iMultiFab (const iMultiFab& rhs) = delete;
    iMultiFab& operator= (const iMultiFab& rhs) = delete;
 
    iMultiFab& operator= (int r);
 
    [[nodiscard]] int min (int comp,
             int nghost = 0,
             bool local = false) const;
 
    [[nodiscard]] int min (const Box& region,
             int        comp,
             int        nghost = 0,
             bool       local = false) const;
 
    [[nodiscard]] int max (int comp,
             int nghost = 0,
             bool local = false) const;
 
    [[nodiscard]] int max (const Box& region,
             int        comp,
             int        nghost = 0,
             bool       local = false) const;
 
    [[nodiscard]] Long sum (int comp, int nghost = 0, bool local = false) const;
 
    [[nodiscard]] Long sum (Box const& region, int comp = 0, bool local = false) const;
 
    void plus (int val,
               int  comp,
               int  num_comp,
               int  nghost = 0);
 
    void plus (int       val,
               const Box& region,
               int        comp,
               int        num_comp,
               int        nghost = 0);
 
    void plus (int val,
               int  nghost);
 
    void plus (int       val,
               const Box& region,
               int        nghost);
 
    void mult (int val,
               int  comp,
               int  num_comp,
               int  nghost = 0);
 
    void mult (int       val,
               const Box& region,
               int        comp,
               int        num_comp,
               int        nghost = 0);
 
    void mult (int val,
               int  nghost = 0);
 
    void mult (int       val,
               const Box& region,
               int        nghost = 0);
 
    void negate (int comp,
                 int num_comp,
                 int nghost = 0);
 
    void negate (const Box& region,
                 int        comp,
                 int        num_comp,
                 int        nghost = 0);
 
    void negate (int nghost = 0);
 
    void negate (const Box& region,
                 int        nghost = 0);
 
    [[nodiscard]] IntVect minIndex (int comp,
                      int nghost = 0) const;
 
    [[nodiscard]] IntVect maxIndex (int comp,
                      int nghost = 0) const;
 
    void plus (const iMultiFab& mf,
               int             strt_comp,
               int             num_comp,
               int             nghost);
 
    void minus (const iMultiFab& mf,
                int             strt_comp,
                int             num_comp,
                int             nghost);
 
    void divide (const iMultiFab& mf,
                 int             strt_comp,
                 int             num_comp,
                 int             nghost);
 
    static void Add (iMultiFab&       dst,
                     const iMultiFab& src,
                     int             srccomp,
                     int             dstcomp,
                     int             numcomp,
                     int             nghost);
 
    static void Copy (iMultiFab&       dst,
                      const iMultiFab& src,
                      int             srccomp,
                      int             dstcomp,
                      int             numcomp,
                      int             nghost);
 
    static void Copy (iMultiFab&       dst,
                      const iMultiFab& src,
                      int             srccomp,
                      int             dstcomp,
                      int             numcomp,
                      const IntVect&  nghost);
 
    static void Subtract (iMultiFab&       dst,
                          const iMultiFab& src,
                          int             srccomp,
                          int             dstcomp,
                          int             numcomp,
                          int             nghost);
 
    static void Multiply (iMultiFab&       dst,
                          const iMultiFab& src,
                          int             srccomp,
                          int             dstcomp,
                          int             numcomp,
                          int             nghost);
 
    static void Divide (iMultiFab&       dst,
                        const iMultiFab& src,
                        int             srccomp,
                        int             dstcomp,
                        int             numcomp,
                        int             nghost);
 
    void define (const BoxArray&            bxs,
                 const DistributionMapping& dm,
                 int                        nvar,
                 const IntVect&             ngrow,
#ifdef AMREX_STRICT_MODE
                 const MFInfo&              info,
                 const FabFactory<IArrayBox>& factory);
#else
                 const MFInfo&              info = MFInfo(),
                 const FabFactory<IArrayBox>& factory = DefaultFabFactory<IArrayBox>());
#endif
 
    void define (const BoxArray&            bxs,
                 const DistributionMapping& dm,
                 int                        nvar,
                 int                        ngrow,
#ifdef AMREX_STRICT_MODE
                 const MFInfo&              info,
                 const FabFactory<IArrayBox>& factory);
#else
                 const MFInfo&              info = MFInfo(),
                 const FabFactory<IArrayBox>& factory = DefaultFabFactory<IArrayBox>());
#endif
 
    static void Initialize ();
    static void Finalize ();
};
 
// ngrow != IntVect{0} is a special case that should not be used in normal cases,
// because it may mark valid cells as non-owner and ghost cells as owners.
std::unique_ptr<iMultiFab>
OwnerMask (FabArrayBase const& mf, const Periodicity& period, const IntVect& ngrow=IntVect{0});
 
}
 
#endif /*BL_IMULTIFAB_H*/