---

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.4 2002/03/29 19:23:55 bvs Exp $
//

#ifndef WRAPPER
#include <iostream>

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

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



//@Man:
//@Memo: A Fortran Array of Reals
/*@Doc: 

  Fortran Array Boxes (generally called FABs) are objects constructed
  to interface with arrays in Fortran.  Useful operations can be performed
  upon FABs in C++, and they provide a convenient interface to
  Fortran when it is necessary to retreat into that language for
  doing arithmetic operations when performance matters.

  FArrayBox is derived from BaseFab<Real>.
  FArrayBox adds additional useful capabilities which make sense
  for Real types, such as I/O and L**p norms.

  The C pre-processor macro `CH\_SPACEDIM' must be defined to use
  this class.  The internal precision of FArrayBox objects is
  set by defining either `CH\_USE\_FLOAT' or `CH\_USE\_DOUBLE' 

  This class does NOT provide a copy constructor or assignment operator.  */


class FArrayBox 
: public BaseFab<Real>
{


public:



  FArrayBox ();

  /*@ManDoc: Constructs an initial FArrayBox with the data space
    allocated but not inititialized. ncomp is the number of components
    (variables) at each data point in the Box.  

*/
  FArrayBox (const Box& b, int ncomp);
  void define(const Box& b, int ncomp) {resize(b, ncomp);}


  explicit FArrayBox (std::istream& is);


  virtual ~FArrayBox ();


  /*@ManDoc: Returns the Lp-norm of this FAB using components
    (comp : comp+numcomp-1).  p < 0  -> ERROR.
    p = 0  -> infinity norm (max norm).
    p = 1  -> sum of ABS(FAB)
    p > 1  -> Lp-norm
  */
  virtual Real norm (int p=2,
                     int comp=0,
                     int numcomp=1) const;

  /*@ManDoc: Returns the Lp-norm of this FAB using components (comp :
    comp+numcomp-1) and within the subbox.  p < 0 -> ERROR.  p = 0 ->
    infinity norm (max norm).  p = 1 -> sum of ABS(FAB) p > 1 ->
    Lp-norm 
*/
  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 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;

  /*@ManDoc: Returns location of minimum value in given component  of this FArrayBox in
    given subbox.
  */
  IntVect minIndex (const Box& subbox,
                    int        comp = 0) const;

  IntVect maxIndex (int comp = 0) const;

  /*@ManDoc: Returns location of maximum value in given component of
    this FArrayBox in given subbox.  

*/
  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;

  /*@ManDoc: Returns sum of component of this FArrayBox in given
    subbox.  

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

  /*@ManDoc: Modifies this FArrayBox by pointwise addition of values
    in the argument FArrayBox.  Adds src's components
    (srccomp:srccomp+numcomp-1) to this FArrayBox's components
    (destcomp:destcomp+numcomp-1) where the domains of the two
    FArrayBoxes intersect.  

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

  /*@ManDoc: Modifies this FArrayBox by pointwise addition of values
    in the argument FArrayBox.  Adds src's components
    (srccomp:srccomp+numcomp-1) to this FArrayBox's components
    (destcomp:destcomp+numcomp-1) where the domain of this FArrayBox
    intersects the subbox.  NOTE: subbox must be contained in this
    FAB.  

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

  /*@ManDoc: Modifies this FArrayBox by pointwise addition of values
               in the argument FArrayBox.  Adds src's components
               (srccomp:srccomp+numcomp-1) in the Box srcbox to this
               FArrayBox's components (destcomp:destcomp+numcomp-1) in
               the Box destbox.  Corresponding locations within the
               two FArrayBoxes are indexed relative to srcbox and
               destbox, and will in general not be the same.  The
               srcbox and destbox must be same size.  The results are
               UNDEFINED if the src and dest FArrayBoxes are the same
               and the srcbox and destbox overlap.

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


  FArrayBox& operator-= (Real r);


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


  FArrayBox& minus (const FArrayBox& src);

  /*@ManDoc: Modifies this FArrayBox by pointwise subtraction of values
    in the argument FArrayBox.  Subtracts src's components
    (srccomp:srccomp+numcomp-1) from this FArrayBox's components
    (destcomp:destcomp+numcomp-1) where the domains of the two
    FArrayBoxes intersect.  

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

  /*@ManDoc: Modifies this FArrayBox by pointwise subtraction of values
    in the argument FArrayBox.  Subtracts src's components
    (srccomp:srccomp+numcomp-1) from this FArrayBox's components
    (destcomp:destcomp+numcomp-1) where the domain of this FArrayBox
    intersects the subbox.  NOTE: subbox must be contained in this
    FAB.  

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

  /*@ManDoc: Modifies this FArrayBox by pointwise subtraction of values
               in the argument FArrayBox.  Subtracts src's components
               (srccomp:srccomp+numcomp-1) in the Box srcbox from this
               FArrayBox's components (destcomp:destcomp+numcomp-1) in
               the Box destbox.  Corresponding locations within the
               two FArrayBoxes are indexed relative to srcbox and
               destbox, and will in general not be the same.  The
               srcbox and destbox must be same size.  The results are
               UNDEFINED if the src and dest FArrayBoxes are the same
               and the srcbox and destbox overlap.

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

  /*@ManDoc: Modifies this FArrayBox by pointwise multiplication by values
    in the argument FArrayBox.  Multiplies src's components
    (srccomp:srccomp+numcomp-1) by this FArrayBox's components
    (destcomp:destcomp+numcomp-1) where the domains of the two
    FArrayBoxes intersect.  

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

  /*@ManDoc: Modifies this FArrayBox by pointwise multiplication by values
    in the argument FArrayBox.  Multiplies src's components
    (srccomp:srccomp+numcomp-1) by this FArrayBox's components
    (destcomp:destcomp+numcomp-1) where the domain of this FArrayBox
    intersects the subbox.  NOTE: subbox must be contained in this
    FAB.  

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

  /*@ManDoc: Modifies this FArrayBox by pointwise multiplication by values
               in the argument FArrayBox.  Multiplies src's components
               (srccomp:srccomp+numcomp-1) in the Box srcbox by this
               FArrayBox's components (destcomp:destcomp+numcomp-1) in
               the Box destbox.  Corresponding locations within the
               two FArrayBoxes are indexed relative to srcbox and
               destbox, and will in general not be the same.  The
               srcbox and destbox must be same size.  The results are
               UNDEFINED if the src and dest FArrayBoxes are the same
               and the srcbox and destbox overlap.

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

  /*@ManDoc: Modifies this FArrayBox by pointwise division by values
    in the argument FArrayBox.  Divides this FArrayBox's components
    (destcomp:destcomp+numcomp-1) by src's components
    (srccomp:srccomp+numcomp-1) where the domains of the two
    FArrayBoxes intersect.  

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

  /*@ManDoc: Modifies this FArrayBox by pointwise division by values
    in the argument FArrayBox.  Divides this FArrayBox's components
    (destcomp:destcomp+numcomp-1) by src's components
    (srccomp:srccomp+numcomp-1) where the domain of this FArrayBox
    intersects the subbox.  NOTE: subbox must be contained in this
    FAB.  

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

  /*@ManDoc: Modifies this FArrayBox by pointwise division by values
               in the argument FArrayBox.  Divides this FArrayBox's
               components (destcomp:destcomp+numcomp-1) in the Box
               destbox by src's components (srccomp:srccomp+numcomp-1)
               in the Box srcbox.  Corresponding locations within the
               two FArrayBoxes are indexed relative to srcbox and
               destbox, and will in general not be the same.  The
               srcbox and destbox must be same size.  The results are
               UNDEFINED if the src and dest FArrayBoxes are the same
               and the srcbox and destbox overlap.

  */
  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*/

---