NodeFArrayBox.H

Go to the documentation of this file.

#ifdef CH_LANG_CC
/*
*      _______              __
*     / ___/ /  ___  __ _  / /  ___
*    / /__/ _ \/ _ \/  V \/ _ \/ _ \
*    \___/_//_/\___/_/_/_/_.__/\___/
*    Please refer to Copyright.txt, in Chombo's root directory.
*/
#endif

// NodeFArrayBox.H
// adapted from dMartin/Chombo-IAMR/util/FluxBox.H
// by Dan Martin, Fri, Jan 14, 2000
// petermc, 1 Nov 2000
// 8 Jan 2001 added

#ifndef _NODEFARRAYBOX_H_
#define _NODEFARRAYBOX_H_

#include "FArrayBox.H"
#include "NamespaceHeader.H"


class NodeFArrayBox
{

public:



  NodeFArrayBox();


  NodeFArrayBox(const Box& a_bx, int a_nComp, Real* a_alias = NULL);


  NodeFArrayBox(const Interval& a_comps, NodeFArrayBox& a_original);


  ~NodeFArrayBox();


  void define(const Box& a_bx, int a_nComp=1);

  void resize(const Box& a_bx, int a_nComp=1, Real* a_alias=NULL);



  const Box& box() const;


  FArrayBox& getFab();


  const FArrayBox& getFab() const;

  Real dotProduct(const NodeFArrayBox& a_fab2) const
  {
    return m_fab.dotProduct(a_fab2.m_fab);
  }

  Real dotProduct(const NodeFArrayBox& a_fab2, const Box& box) const
  {
    return m_fab.dotProduct(a_fab2.m_fab, box);
  }



  void copy(const NodeFArrayBox& a_src);


  void copy(const Box& a_regionFrom,
            const Interval& a_Cdest,
            const Box& a_regionTo,
            const NodeFArrayBox& a_src,
            const Interval& a_Csrc);



  int size(const Box& a_R, const Interval& a_comps) const;


  void linearOut(void* a_buf, const Box& a_R, const Interval& a_comps) const;

  void linearIn(void* a_buf, const Box& a_R, const Interval& a_comps);


  void linearOut(void* a_buf) const;
  void linearIn(const void* const a_buf);
  int linearSize(void) const;

  static int preAllocatable() {return 0;}



  void setVal(Real a_x);

  void setVal(Real          a_x,
              const Box& a_bx,
              int        a_nstart,
              int        a_numcomp);


  Real norm(const Box& a_subbox,
            int        a_p = 2,
            int        a_comp = 0,
            int        a_numcomp = 1) const
  {
    return m_fab.norm(a_subbox, a_p, a_comp, a_numcomp);
  }


  Real norm(int a_p = 2,
            int a_comp = 0,
            int a_numcomp = 1) const
  {
    return m_fab.norm(a_p, a_comp, a_numcomp);
  }



  Real sumPow(const Box& a_subbox,
              int        a_p = 2,
              int        a_comp = 0,
              int        a_numcomp = 1) const

  {
    return m_fab.sumPow(a_subbox, a_p, a_comp, a_numcomp);
  }



  Real min(int a_comp = 0) const
  {
    return m_fab.min(a_comp);
  }


  Real min(const Box& a_subbox,
           int        a_comp = 0) const
  {
    return m_fab.min(a_subbox, a_comp);
  }


  Real max(int a_comp = 0) const
  {
    return m_fab.max(a_comp);
  }


  Real max(const Box& a_subbox,
           int        a_comp = 0) const

  {
    return m_fab.max(a_subbox, a_comp);
  }


  IntVect minIndex(int a_comp = 0) const
  {
    return m_fab.minIndex(a_comp);
  }


  IntVect minIndex(const Box& a_subbox,
                   int        a_comp = 0) const
  {
    return m_fab.minIndex(a_subbox, a_comp);
  }


  IntVect maxIndex(int a_comp = 0) const
  {
    return m_fab.maxIndex(a_comp);
  }


  IntVect maxIndex(const Box& a_subbox,
                   int        a_comp = 0) const
  {
    return m_fab.maxIndex(a_subbox, a_comp);
  }


  int maskLT(BaseFab<int>& a_mask,
             Real          a_val,
             int           a_comp = 0) const
  {
    return m_fab.maskLT(a_mask, a_val, a_comp);
  }



  int maskLE(BaseFab<int>& a_mask,
             Real          a_val,
             int           a_comp = 0) const
  {
    return m_fab.maskLE(a_mask, a_val, a_comp);
  }


  int maskEQ(BaseFab<int>& a_mask,
             Real          a_val,
             int           a_comp = 0) const
  {
    return m_fab.maskEQ(a_mask, a_val, a_comp);
  }


  int maskGT(BaseFab<int>& a_mask,
             Real          a_val,
             int           a_comp = 0) const
  {
    return m_fab.maskGT(a_mask, a_val, a_comp);
  }



  int maskGE(BaseFab<int>& a_mask,
             Real          a_val,
             int           a_comp = 0) const
  {
    return m_fab.maskGE(a_mask, a_val, a_comp);
  }


  void abs()
  {
    m_fab.abs();
  }


  int nComp() const
  {
    return m_fab.nComp();
  }


  void abs(int a_comp,
           int a_numcomp = 1)
  {
    m_fab.abs(a_comp, a_numcomp);
  }


  void abs (const Box& a_subbox,
            int        a_comp = 0,
            int        a_numcomp = 1)
  {
    m_fab.abs(a_subbox, a_comp, a_numcomp);
  }



  Real sum(int a_comp,
           int a_numcomp = 1) const
  {
    return m_fab.sum(a_comp, a_numcomp);
  }


  Real sum(const Box& a_subbox,
           int        a_comp,
           int        a_numcomp = 1) const
  {
    return m_fab.sum(a_subbox, a_comp, a_numcomp);
  }



  NodeFArrayBox& invert(Real a_r)
  {
    m_fab.invert(a_r);
    return *this;
  }



  NodeFArrayBox& invert(Real a_r,
                        int  a_comp,
                        int  a_numcomp = 1)
  {
    m_fab.invert(a_r, a_comp, a_numcomp);
    return *this;
  }


  NodeFArrayBox& invert(Real       a_r,
                        const Box& a_subbox,
                        int        a_comp = 0,
                        int        a_numcomp = 1)
  {
    m_fab.invert(a_r, a_subbox, a_comp, a_numcomp);
    return *this;
  }


  NodeFArrayBox& negate(const Box& a_subbox,
                        int        a_comp = 0,
                        int        a_numcomp = 1)
  {
    m_fab.negate(a_subbox, a_comp, a_numcomp);
    return *this;
  }


  NodeFArrayBox& negate(int a_comp,
                        int a_numcomp = 1)
  {
    m_fab.negate(a_comp, a_numcomp);
    return *this;
  }


  NodeFArrayBox& negate()
  {
    m_fab.negate();
    return *this;
  }



  NodeFArrayBox& plus(Real       a_r,
                      const Box& a_subbox,
                      int        a_comp = 0,
                      int        a_numcomp = 1)
  {
    m_fab.plus(a_r, a_subbox, a_comp, a_numcomp);
    return *this;
  }


  NodeFArrayBox& plus(Real a_r,
                      int  a_comp,
                      int  a_numcomp = 1)
  {
    m_fab.plus(a_r,  a_comp, a_numcomp);
    return *this;
  }

  Real& operator() (const IntVect& a_p,
                    int N = 0)
  {
    return m_fab(a_p,N);
  }

  const Real& operator() (const IntVect& a_p,
                          int N = 0) const
  {
    return m_fab(a_p,N);
  }

  NodeFArrayBox& operator += (Real a_r)
  {
    m_fab += a_r;
    return *this;
  }


  NodeFArrayBox& operator += (const NodeFArrayBox& a_x)
  {
    m_fab += a_x.m_fab;
    return *this;
  }



  NodeFArrayBox& plus(Real a_r)
  {
    m_fab += a_r;
    return *this;
  }

  NodeFArrayBox& plus_real(Real a_r)
  {
    return this->plus(a_r);
  }


  NodeFArrayBox& plus(const NodeFArrayBox& a_x)
  {
    m_fab += a_x.m_fab;
    return *this;
  }


  NodeFArrayBox& plus(const NodeFArrayBox& a_src,
                      const Real&          a_scale)
  {
    m_fab.plus(a_src.m_fab, a_scale);
    return *this;
  }


  NodeFArrayBox& plus(const NodeFArrayBox& a_src,
                      const Real&      a_scale,
                      int              a_srccomp,
                      int              a_destcomp,
                      int              a_numcomp = 1)
  {
    m_fab.plus(a_src.m_fab, a_scale, a_srccomp, a_destcomp, a_numcomp);
    return *this;
  }


  NodeFArrayBox& plus(const NodeFArrayBox& a_src,
                      int              a_srccomp,
                      int              a_destcomp,
                      int              a_numcomp = 1)
  {
    m_fab.plus(a_src.m_fab,  a_srccomp, a_destcomp, a_numcomp);
    return *this;
  }


  NodeFArrayBox& plus(const NodeFArrayBox& a_src,
                      const Box&       a_subbox,
                      int              a_srccomp,
                      int              a_destcomp,
                      int              a_numcomp = 1)
  {
    m_fab.plus(a_src.m_fab, a_subbox,  a_srccomp, a_destcomp, a_numcomp);
    return *this;
  }



  NodeFArrayBox& plus(const NodeFArrayBox& a_src,
                      const Box&       a_srcbox,
                      const Box&       a_destbox,
                      int              a_srccomp,
                      int              a_destcomp,
                      int              a_numcomp = 1)
  {
    m_fab.plus(a_src.m_fab, a_srcbox, a_destbox,  a_srccomp, a_destcomp, a_numcomp);
    return *this;
  }


  NodeFArrayBox& plus(const NodeFArrayBox& a_src,
                      const Box&       a_srcbox,
                      const Box&       a_destbox,
                      const Real&      a_scale,
                      int              a_srccomp,
                      int              a_destcomp,
                      int              a_numcomp = 1)
  {
    m_fab.plus(a_src.m_fab, a_srcbox, a_destbox,  a_scale, a_srccomp, a_destcomp, a_numcomp);
    return *this;
  }


  NodeFArrayBox& operator -= (Real a_r)
  {
    m_fab -= a_r;
    return *this;
  }


  NodeFArrayBox& operator -= (const NodeFArrayBox& a_x)
  {
    m_fab -= a_x.m_fab;
    return *this;
  }


  NodeFArrayBox& minus(const NodeFArrayBox& a_x)
  {
    m_fab -= a_x.m_fab;
    return *this;
  }

  NodeFArrayBox& minus(const NodeFArrayBox& a_src,
                       int              a_srccomp,
                       int              a_destcomp,
                       int              a_numcomp = 1)
  {
    m_fab.minus(a_src.m_fab, a_srccomp, a_destcomp, a_numcomp);
    return *this;
  }

  NodeFArrayBox& minus(const NodeFArrayBox& a_src,
                       const Box&       a_subbox,
                       int              a_srccomp,
                       int              a_destcomp,
                       int              a_numcomp = 1)
  {
    m_fab.minus(a_src.m_fab, a_subbox, a_srccomp, a_destcomp, a_numcomp);
    return *this;
  }



  NodeFArrayBox& minus(const NodeFArrayBox& a_src,
                       const Box&       a_srcbox,
                       const Box&       a_destbox,
                       int              a_srccomp,
                       int              a_destcomp,
                       int              a_numcomp = 1)
  {
    m_fab.minus(a_src.m_fab, a_srcbox, a_destbox, a_srccomp, a_destcomp, a_numcomp);
    return *this;
  }



  NodeFArrayBox& operator *= (Real a_r)
  {
    m_fab *= a_r;
    return *this;
  }


  NodeFArrayBox& mult(Real a_r)
  {
    m_fab *= a_r;
    return *this;
  }


  NodeFArrayBox& mult(Real a_r,
                      int  a_comp,
                      int  a_numcomp = 1)
  {
    m_fab.mult(a_r, a_comp, a_numcomp);
    return *this;
  }



  NodeFArrayBox& mult(Real       a_r,
                      const Box& a_subbox,
                      int        a_comp = 0,
                      int        a_numcomp = 1)
  {
    m_fab.mult(a_r, a_subbox, a_comp, a_numcomp);
    return *this;
  }



  NodeFArrayBox& operator *= (const NodeFArrayBox& a_x)
  {
    m_fab *= a_x.m_fab;
    return *this;
  }


  NodeFArrayBox& mult(const NodeFArrayBox& a_x)
  {
    m_fab *= a_x.m_fab;
    return *this;
  }


  NodeFArrayBox& mult(const NodeFArrayBox& a_src,
                      int              a_srccomp,
                      int              a_destcomp,
                      int              a_numcomp = 1)
  {
    m_fab.mult(a_src.m_fab, a_srccomp, a_destcomp, a_numcomp);
    return *this;
  }



  NodeFArrayBox& mult(const NodeFArrayBox& a_src,
                      const Box&       a_subbox,
                      int              a_srccomp,
                      int              a_destcomp,
                      int              a_numcomp = 1)
  {
    m_fab.mult(a_src.m_fab, a_subbox, a_srccomp, a_destcomp, a_numcomp);
    return *this;
  }


  NodeFArrayBox& mult(const NodeFArrayBox& a_src,
                      const Box&       a_srcbox,
                      const Box&       a_destbox,
                      int              a_srccomp,
                      int              a_destcomp,
                      int              a_numcomp = 1)
  {
    m_fab.mult(a_src.m_fab, a_srcbox, a_destbox, a_srccomp, a_destcomp, a_numcomp);
    return *this;
  }



  NodeFArrayBox& operator /= (Real a_r)
  {
    m_fab /= a_r;
    return *this;
  }


  NodeFArrayBox& divide(Real a_r)
  {
    m_fab /= a_r;
    return *this;
  }



  NodeFArrayBox& divide(Real a_r,
                        int  a_comp,
                        int  a_numcomp = 1)
  {
    m_fab.divide(a_r, a_comp, a_numcomp);
    return *this;
  }



  NodeFArrayBox& divide(Real       a_r,
                        const Box& a_subbox,
                        int        a_comp = 0,
                        int        a_numcomp = 1)
  {
    m_fab.divide(a_r, a_subbox, a_comp, a_numcomp);
    return *this;
  }



  NodeFArrayBox& operator /= (const NodeFArrayBox& a_x)
  {
    m_fab /= a_x.m_fab;
    return *this;
  }


  NodeFArrayBox& divide(const NodeFArrayBox& a_x)
  {
    m_fab /= a_x.m_fab;
    return *this;
  }


  NodeFArrayBox& divide(const NodeFArrayBox& a_src,
                        int              a_srccomp,
                        int              a_destcomp,
                        int              a_numcomp = 1)
  {
    m_fab.divide(a_src.m_fab, a_srccomp, a_destcomp, a_numcomp);
    return *this;
  }



  NodeFArrayBox& divide(const NodeFArrayBox& a_src,
                        const Box&       a_subbox,
                        int              a_srccomp,
                        int              a_destcomp,
                        int              a_numcomp = 1)
  {
    m_fab.divide(a_src.m_fab, a_subbox, a_srccomp, a_destcomp, a_numcomp);
    return *this;
  }



  NodeFArrayBox& divide(const NodeFArrayBox& a_src,
                        const Box&       a_srcbox,
                        const Box&       a_destbox,
                        int              a_srccomp,
                        int              a_destcomp,
                        int              a_numcomp = 1)
  {
    m_fab.divide(a_src.m_fab, a_srcbox, a_destbox, a_srccomp, a_destcomp, a_numcomp);
    return *this;
  }



protected:

  // CELL-centered box. data are defined on the surrounding nodes.
  Box m_box;

  // NODE-centered data
  FArrayBox m_fab;

private:

  NodeFArrayBox (const NodeFArrayBox&);
  NodeFArrayBox& operator = (const NodeFArrayBox&);

};

#include "NamespaceFooter.H"
#endif

---