BaseIVFAB.H

Go to the documentation of this file.

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

#ifndef _BASEIVFAB_H_
#define _BASEIVFAB_H_

#include <cmath>
#include <cstdlib>
#include "SPACE.H"
#include "Vector.H"
#include "IntVectSet.H"
#include "VolIndex.H"
#include "BaseFab.H"
#include "EBGraph.H"
#include "NamespaceHeader.H"



template <class T>
class BaseIVFAB
{
public:

  BaseIVFAB();


  BaseIVFAB(const IntVectSet& a_region,
            const EBGraph&    a_ebgraph,
            const int&        a_nvarin);


  BaseIVFAB(const Interval& a_comps,
            BaseIVFAB<T>&   a_original);


  virtual ~BaseIVFAB();


  virtual void define(const IntVectSet& a_region,
              const EBGraph&    a_ebgraph,
              const int&        a_nvarin);


  void setVal(const T& value);


  void setVal(int ivar, const T& value);


  void setVal(const T&   a_value,
              const Box& a_box,
              int        a_nstart,
              int        a_numcomp);
  void copy(const Box& a_fromBox,
            const Interval& a_destInterval,
            const Box& a_toBox,
            const BaseIVFAB<T>& a_src,
            const Interval& a_srcInterval);


  static int preAllocatable()
  {
    return 1; // symmetric allocatable.
  }

  int size(const Box& R, const Interval& comps) const ;

  void linearOut(void* buf, const Box& R, const Interval& comps) const;

  void linearIn(void* buf, const Box& R, const Interval& comps);


  virtual void clear();


  bool
  isDefined() const;


  int numVoFs() const;


  int nComp() const;


  const IntVectSet& getIVS() const;

  const EBGraph& getEBGraph() const;


  T& operator() (const VolIndex& a_vof,const int& varlocin);
  const T& operator() (const VolIndex& a_vof,const int& varlocin) const;


  BaseIVFAB(const Box& a_region, int a_nVar)
  {
    MayDay::Error("invalid constructor called for baseebcellfab");
  }

  static void setVerbose(bool a_verbose);

  static void setVerboseDebug(bool a_verboseDebug);

  T* dataPtr(const int& a_comp);

  const T* dataPtr(const int& a_comp) const;


  virtual T* getIndex(const VolIndex& a_vof,const int& a_comp) const;

  static bool s_verboseDebug;

private:


protected:

  virtual void
  setDefaultValues();

  //has to be this in case someone does a bool
  T* m_data;

  int m_nComp;
  int m_nVoFs;

  EBGraph m_ebgraph;

  //object to store pointers to facilitate fast indexing
  BaseFab<T*> m_fab;
  IntVectSet m_ivs;
  bool m_isDefined;

  static bool s_verbose;
private:
  //disallowed for all the usual reasons
  void operator= (const BaseIVFAB<T>& a_input)
  {
    MayDay::Error("BaseIVFAB operator = not defined");
  }
  BaseIVFAB(const BaseIVFAB<T>& a_input)
  {
    MayDay::Error("invalid operator");
  }
};

#include "NamespaceFooter.H"

#ifndef CH_EXPLICIT_TEMPLATES
#include "BaseIVFABI.H"
#endif

#endif

---