LevelFluxRegister.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 _LEVELFLUXREGISTER_H_
#define _LEVELFLUXREGISTER_H_

#include "REAL.H"
#include "Vector.H"
#include "FArrayBox.H"
#include "IntVectSet.H"
#include "LoHiSide.H"
#include "LevelData.H"
#include "LayoutData.H"
#include "ProblemDomain.H"
#include "NamespaceHeader.H"


class LevelFluxRegister
{
public:


  LevelFluxRegister();


  LevelFluxRegister(const DisjointBoxLayout& a_dbl,
                    const DisjointBoxLayout& a_dblCoarse,
                    const ProblemDomain&     a_dProblem,
                    int                      a_nRefine,
                    int                      a_nComp,
                    bool                     a_scaleFineFluxes = true);


  LevelFluxRegister(const DisjointBoxLayout& a_dbl,
                    const DisjointBoxLayout& a_dblCoarse,
                    const Box&               a_dProblem,
                    int                      a_nRefine,
                    int                      a_nComp,
                    bool                     a_scaleFineFluxes = true);

  ~LevelFluxRegister();


  void define(const DisjointBoxLayout& a_dbl,
              const DisjointBoxLayout& a_dblCoarse,
              const ProblemDomain&     a_dProblem,
              int                      a_nRefine,
              int                      a_nComp,
              bool                     a_scaleFineFluxes = true);


  void define(const DisjointBoxLayout& a_dbl,
              const DisjointBoxLayout& a_dblCoarse,
              const Box&               a_dProblem,
              int                      a_nRefine,
              int                      a_nComp,
              bool                     a_scaleFineFluxes = true);


  void
  undefine();


  void setToZero();


  void incrementCoarse(
                       FArrayBox& a_coarseFlux,
                       Real a_scale,
                       const DataIndex& a_coarseDataIndex,
                       const Interval& a_srcInterval,
                       const Interval& a_dstInterval,
                       int a_dir);


  void incrementCoarse(
                       FArrayBox& a_coarseFlux,
                       Real a_scale,
                       const DataIndex& a_coarseDataIndex,
                       const Interval& a_srcInterval,
                       const Interval& a_dstInterval,
                       int a_dir,
                       Side::LoHiSide a_sd);


  void incrementFine(
                     FArrayBox& a_fineFlux,
                     Real a_scale,
                     const DataIndex& a_fineDataIndex,
                     const Interval& a_srcInterval,
                     const Interval& a_dstInterval,
                     int a_dir);


  void incrementFine(
                     FArrayBox& a_fineFlux,
                     Real a_scale,
                     const DataIndex& a_fineDataIndex,
                     const Interval& a_srcInterval,
                     const Interval& a_dstInterval,
                     int a_dir,
                     Side::LoHiSide a_sd);


  void reflux(
              LevelData<FArrayBox>& a_uCoarse,
              Real a_scale);



  void reflux(
              LevelData<FArrayBox>& a_uCoarse,
              const Interval& a_coarse_interval,
              const Interval& a_flux_interval,
              Real a_scale);

  void reflux(
              LevelData<FArrayBox>& a_uCoarse,
              Real a_scale,
              const Interval& a_coarseInterv,
              const Interval& a_fluxInterval,
              const LevelData<FArrayBox>& a_beta);


  bool hasCF(const DataIndex& a_fineDataIndex, Side::LoHiSide) const;
  bool hasCF(const DataIndex& a_coarseIndex) const;


  bool isDefined() const;

  void poutCoarseRegisters() const;

  void poutFineRegisters() const;
protected:

  // both of these are defined in the coarse index space,
  // but, m_coarFlux uses the coarse grid layout, and
  // m_fineFlux uses the fine grid layout.
  LevelData<FArrayBox> m_coarFlux;
  LevelData<FArrayBox> m_fineFlux;

  //LayoutData<IntVectSet> m_coarseLocations[CH_SPACEDIM*2];
  LayoutData< Vector<Box> > m_coarseLocations[CH_SPACEDIM*2];

  ProblemDomain m_domain;

  bool m_isDefined;

  int m_nRefine;

  bool m_scaleFineFluxes;

  Copier m_reverseCopier;

private:

  void operator= (const LevelFluxRegister&);
  LevelFluxRegister(const LevelFluxRegister&);
};
#include "NamespaceFooter.H"
#endif

---