MultiFab.H

Go to the documentation of this file.

/*
** (c) 1996-2000 The Regents of the University of California (through
** E.O. Lawrence Berkeley National Laboratory), subject to approval by
** the U.S. Department of Energy.  Your use of this software is under
** license -- the license agreement is attached and included in the
** directory as license.txt or you may contact Berkeley Lab's Technology
** Transfer Department at TTD@lbl.gov.  NOTICE OF U.S. GOVERNMENT RIGHTS.
** The Software was developed under funding from the U.S. Government
** which consequently retains certain rights as follows: the
** U.S. Government has been granted for itself and others acting on its
** behalf a paid-up, nonexclusive, irrevocable, worldwide license in the
** Software to reproduce, prepare derivative works, and perform publicly
** and display publicly.  Beginning five (5) years after the date
** permission to assert copyright is obtained from the U.S. Department of
** Energy, and subject to any subsequent five (5) year renewals, the
** U.S. Government is granted for itself and others acting on its behalf
** a paid-up, nonexclusive, irrevocable, worldwide license in the
** Software to reproduce, prepare derivative works, distribute copies to
** the public, perform publicly and display publicly, and to permit
** others to do so.
*/

#ifndef BL_MULTIFAB_H
#define BL_MULTIFAB_H
//
// $Id: MultiFab.H,v 1.43 2001/08/02 16:01:44 car Exp $
//
#include <winstd.H>

#include <BLassert.H>
#include <FArrayBox.H>
#include <FabArray.H>
//
// Forward declaration.
//
typedef FabArrayId MultiFabId;

class MultiFabCopyDescriptor;

class MultiFab;

namespace BoxLib
{
    void linInterpAddBox (MultiFabCopyDescriptor& fabCopyDesc,
                          BoxList*                returnUnfilledBoxes,
                          Array<FillBoxId>&       returnedFillBoxIds,
                          const Box&              subbox,
                          const MultiFabId&       faid1,
                          const MultiFabId&       faid2,
                          Real                    t1,
                          Real                    t2,
                          Real                    t,
                          int                     src_comp,
                          int                     dest_comp,
                          int                     num_comp,
                          bool                    extrap);

    void linInterpFillFab (MultiFabCopyDescriptor& fabCopyDesc,
                           const Array<FillBoxId>& fillBoxIds,
                           const MultiFabId&       faid1,
                           const MultiFabId&       faid2,
                           FArrayBox&              dest,
                           Real                    t1,
                           Real                    t2,
                           Real                    t,
                           int                     src_comp,
                           int                     dest_comp,
                           int                     num_comp,
                           bool                    extrap);
}

//
// :

class MultiFab
    :
    public FabArray<FArrayBox>
{
public:

    MultiFab ();

    MultiFab (const BoxArray& bs,
              int             ncomp,
              int             ngrow,
              FabAlloc        mem_mode = Fab_allocate);

    MultiFab (const BoxArray& bs,
              int             ncomp,
              int             ngrow,
              const DistributionMapping& dm,
              FabAlloc        mem_mode);


    void operator= (const Real& r);
    Real min (int comp,
              int nghost = 0) const;

    Real min (const Box& b,
              int        comp,
              int        nghost = 0) const;

    Real max (int comp,
              int nghost = 0) const;

    Real max (const Box& b,
              int        comp,
              int        nghost = 0) const;

    void plus (Real val,
               int  comp,
               int  num_comp,
               int  nghost = 0);

    void plus (Real       val,
               const Box& region,
               int        comp,
               int        num_comp,
               int        nghost = 0);

    void plus (Real val,
               int  nghost);

    void plus (Real       val,
               const Box& region,
               int        nghost);

    void mult (Real val,
               int  comp,
               int  num_comp,
               int  nghost = 0);

    void mult (Real       val,
               const Box& region,
               int        comp,
               int        num_comp,
               int        nghost = 0);

    void mult (Real val,
               int  nghost = 0);

    void mult (Real       val,
               const Box& region,
               int        nghost = 0);

    void invert (Real numerator,
                 int  comp,
                 int  num_comp,
                 int  nghost = 0);

    void invert (Real       numerator,
                 const Box& region,
                 int        comp,
                 int        num_comp,
                 int        nghost = 0);

    void invert (Real numerator,
                 int  nghost);

    void invert (Real       numerator,
                 const Box& region,
                 int        nghost);

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

    void plus (const MultiFab& mf,
               int             strt_comp,
               int             num_comp,
               int             nghost);

    void minus (const MultiFab& mf,
                int             strt_comp,
                int             num_comp,
                int             nghost);

    void FillBoundary ();

    void FillBoundary (int src_comp,
                       int num_comp);
    //
    //
    static void FlushSICache ();
    //
    //
    static int SICacheSize ();

    static void Copy (MultiFab&       dst,
                      const MultiFab& src,
                      int             srccomp,
                      int             dstcomp,
                      int             numcomp,
                      int             nghost);
private:
    //
    // These are disabled.
    //
    MultiFab (const MultiFab& rhs);
    MultiFab& operator= (const MultiFab& rhs);
};

class MultiFabCopyDescriptor
    :
    public FabArrayCopyDescriptor<FArrayBox>
{
  public:

    MultiFabCopyDescriptor ()
        :
        FabArrayCopyDescriptor<FArrayBox>() {}

    MultiFabId RegisterMultiFab (MultiFab* mf)
    {
        return RegisterFabArray(mf);
    }

  private:
    //
    // These are disallowed.
    //
    MultiFabCopyDescriptor (const MultiFabCopyDescriptor&);
    MultiFabCopyDescriptor& operator= (const MultiFabCopyDescriptor&);
};

#endif /*BL_MULTIFAB_H*/

---