FArrayBox.H

Go to the documentation of this file.

/* _______              __
   / ___/ /  ___  __ _  / /  ___
   / /__/ _ \/ _ \/  ' \/ _ \/ _ \
   \___/_//_/\___/_/_/_/_.__/\___/ 
*/
//
// This software is copyright (C) by the Lawrence Berkeley
// National Laboratory.  Permission is granted to reproduce
// this software for non-commercial purposes provided that
// this notice is left intact.
// 
// It is acknowledged that the U.S. Government has rights to
// this software under Contract DE-AC03-765F00098 between
// the U.S.  Department of Energy and the University of
// California.
//
// This software is provided as a professional and academic
// contribution for joint exchange. Thus it is experimental,
// is provided ``as is'', with no warranties of any kind
// whatsoever, no support, no promise of updates, or printed
// documentation. By using this software, you acknowledge
// that the Lawrence Berkeley National Laboratory and
// Regents of the University of California shall have no
// liability with respect to the infringement of other
// copyrights by any part of this software.
//

#ifndef CH_FARRAYBOX_H
#define CH_FARRAYBOX_H

//
// $Id: FArrayBox.H,v 1.9 2003/11/12 22:07:58 graves Exp $
//

#ifndef WRAPPER
#include <iostream>

//#include <Pointers.H>
#include "Box.H"
#include "BaseFab.H"
#endif

#include "REAL.H"
#include "SPACE.H"




class FArrayBox 
  : public BaseFab<Real>
{


public:


  FArrayBox ();

  FArrayBox (const Box& b, int ncomp, Real* alias=NULL);
  void define(const Box& b, int ncomp, Real* alias = NULL) {resize(b, ncomp, alias);}


  FArrayBox(const Interval& a_comps, FArrayBox& a_original)
    : BaseFab<Real>(a_comps, a_original) { }

  void define(const Interval& a_comps, FArrayBox& a_original)
  {
    BaseFab<Real>::define(a_comps, a_original);
  }


  explicit FArrayBox (std::istream& is);


  virtual ~FArrayBox ();


  virtual Real norm (int p=2,
                     int comp=0,
                     int numcomp=1) const;


  virtual Real norm (const Box& subbox,
                     int        p=2,
                     int        comp=0,
                     int        numcomp=1) const;


  virtual Real sumPow(const Box& subbox,
                      int        p=2,
                      int        comp=0,
                      int        numcomp=1) const;


  Real dotProduct(const FArrayBox& fab2) const;



  Real min (int comp = 0) const;


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


  Real max (int comp = 0) const;


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


  IntVect minIndex (int comp = 0) const;


  IntVect minIndex (const Box& subbox,
                    int        comp = 0) const;

  IntVect maxIndex (int comp = 0) const;


  IntVect maxIndex (const Box& subbox,
                    int        comp = 0) const;


  int maskLT (BaseFab<int>& mask,
              Real             val,
              int           comp = 0) const;


  int maskLE (BaseFab<int>& mask,
              Real             val,
              int           comp = 0) const;

  int maskEQ (BaseFab<int>& mask,
              Real             val,
              int           comp = 0) const;

  int maskGT (BaseFab<int>& mask,
              Real             val,
              int           comp = 0) const;


  int maskGE (BaseFab<int>& mask,
              Real             val,
              int           comp = 0) const;



  void abs ();


  void abs (int comp,
            int numcomp=1);


  void abs (const Box& subbox,
            int        comp = 0,
            int        numcomp=1);


  Real sum (int comp,
            int numcomp = 1) const;


  Real sum (const Box& subbox,
            int        comp,
            int        numcomp = 1) const;


  FArrayBox& invert (Real v);

  FArrayBox& invert (Real          v,
                     const Box& subbox,
                     int        comp=0,
                     int        numcomp=1);

  FArrayBox& invert (Real   v,
                     int comp,
                     int numcomp=1);




  FArrayBox& negate (const Box& subbox,
                     int        comp=0,
                     int        numcomp=1);

  FArrayBox& negate (int comp,
                     int numcomp=1);

  FArrayBox& negate ();


  FArrayBox& plus (Real          r,
                   const Box& b,
                   int        comp=0,
                   int        numcomp=1);


  FArrayBox& plus (Real   r,
                   int comp,
                   int numcomp=1);



  FArrayBox& operator+= (Real r);


  FArrayBox& operator+= (const FArrayBox& f);


  FArrayBox& plus (const FArrayBox& src);


  FArrayBox& plus (Real r);
  FArrayBox& plus_real (Real r) {return this->plus(r);}


  FArrayBox& plus (const FArrayBox& src, const Real& scale);


  FArrayBox& plus (const FArrayBox& src, const Real& scale, 
                   int                srccomp,
                   int                destcomp,
                   int                numcomp=1);



  FArrayBox& plus (const FArrayBox& src,
                   int                srccomp,
                   int                destcomp,
                   int                numcomp=1);



  FArrayBox& plus (const FArrayBox& src,
                   const Box&         subbox,
                   int                srccomp,
                   int                destcomp,
                   int                numcomp=1);



  FArrayBox& plus (const FArrayBox& src,
                   const Box&         srcbox,
                   const Box&         destbox,
                   int                srccomp,
                   int                destcomp,
                   int                numcomp=1);

  FArrayBox& plus (const FArrayBox& src,
                   const Box&         srcbox,
                   const Box&         destbox,
                   const Real&        scale,
                   int                srccomp,
                   int                destcomp,
                   int                numcomp=1);


  FArrayBox& operator-= (Real r);


  FArrayBox& operator-= (const FArrayBox& f);


  FArrayBox& minus (const FArrayBox& src);

  FArrayBox& minus (const FArrayBox& src,
                    int                srccomp,
                    int                destcomp,
                    int                numcomp=1);

  FArrayBox& minus (const FArrayBox& src,
                    const Box&         subbox,
                    int                srccomp,
                    int                destcomp,
                    int                numcomp=1);


  FArrayBox& minus (const FArrayBox& src,
                    const Box&         srcbox,
                    const Box&         destbox,
                    int                srccomp,
                    int                destcomp,
                    int                numcomp=1);


  FArrayBox& operator*= (Real r);


  FArrayBox& mult (Real r);


  FArrayBox& mult (Real   r,
                   int comp,
                   int numcomp=1);


  FArrayBox& mult (Real          r,
                   const Box& b,
                   int        comp=0,
                   int        numcomp=1);


  FArrayBox& operator*= (const FArrayBox& f);


  FArrayBox& mult (const FArrayBox& src);


  FArrayBox& mult (const FArrayBox& src,
                   int                srccomp,
                   int                destcomp,
                   int                numcomp=1);


  FArrayBox& mult (const FArrayBox& src,
                   const Box&         subbox,
                   int                srccomp,
                   int                destcomp,
                   int                numcomp=1);


  FArrayBox& mult (const FArrayBox& src,
                   const Box&         srcbox,
                   const Box&         destbox,
                   int                srccomp,
                   int                destcomp,
                   int                numcomp=1);


  FArrayBox& operator/= (Real r);


  FArrayBox& divide (Real r);


  FArrayBox& divide (Real   r,
                     int comp,
                     int numcomp=1);


  FArrayBox& divide (Real          r,
                     const Box& b,
                     int        comp=0,
                     int        numcomp=1);


  FArrayBox& operator/= (const FArrayBox& src);


  FArrayBox& divide (const FArrayBox& src);


  FArrayBox& divide (const FArrayBox& src,
                     int                srccomp,
                     int                destcomp,
                     int                numcomp=1);


  FArrayBox& divide (const FArrayBox& src,
                     const Box&         subbox,
                     int                srccomp,
                     int                destcomp,
                     int                numcomp=1);


  FArrayBox& divide (const FArrayBox& src,
                     const Box&         srcbox,
                     const Box&         destbox,
                     int                srccomp,
                     int                destcomp,
                     int                numcomp=1);

  Real get(const IntVect& iv, int comp) const { return this->operator()(iv, comp);}

  void set(const IntVect& iv, int comp, Real val) {  this->operator()(iv, comp) = val;}

protected:

  virtual void performCopy (const BaseFab<Real>& src,
                            const Box&        srcbox,
                            int               srccomp,
                            const Box&        destbox,
                            int               destcomp,
                            int               numcomp);

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


#endif /*CH_FARRAYBOX_H*/

---