EBCompositeCCProjector.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 _EBCOMPOSITECCPROJECTOR_H_
#define _EBCOMPOSITECCPROJECTOR_H_

#include "EBLevelCCProjector.H"
#include "DisjointBoxLayout.H"
#include "EBISLayout.H"
#include "Box.H"
#include "REAL.H"
#include "LevelData.H"
#include "EBFluxFAB.H"
#include "EBCellFAB.H"
#include "EBSimpleSolver.H"
#include "EBAMRPoissonOp.H"
#include "MultiGrid.H"
#include "LevelFluxRegister.H"
#include "EBQuadCFInterp.H"
#include "EBCompositeMACProjector.H"
#include "NamespaceHeader.H"


class EBCompositeCCProjector
{
public:

  ~EBCompositeCCProjector();


  EBCompositeCCProjector(const Vector<EBLevelGrid>&                      a_dbl,
                         const Vector<int>&                              a_refRat,
                         const Vector<RefCountedPtr<EBQuadCFInterp> >&   a_quadCFI,
                         const RealVect&                                 a_coarsestDx,
                         const RealVect&                                 a_origin,
                         const RefCountedPtr<BaseDomainBCFactory>&       a_baseDomainBCVel,
                         const RefCountedPtr<BaseDomainBCFactory>&       a_baseDomainBCPhi,
                         const RefCountedPtr<BaseEBBCFactory>&           a_ebbcPhi,
                         const bool&                                     a_subtractOffMean,
                         const int&                                      a_numLevels,
                         const int&                                      a_verbosity,
                         const int&                                      a_numPreCondIters,
                         const Real&                                     a_time,
                         const int&                                      a_relaxType,
                         const int&                                      a_bottomSolverType,
                         EBCompositeMACProjector*                        a_inputMAC= NULL);


  int
  project(Vector<LevelData<EBCellFAB>* >&               a_velocity,
          Vector<LevelData<EBCellFAB>* >&               a_gradient,
          const Real&                                   a_gradCoef=1.0,
          const Real&                                   a_divuCoef=1.0,
          const Vector<LevelData<BaseIVFAB<Real> >* >*  a_boundaryVelo=NULL);

  Vector<LevelData<EBFluxFAB>* >& getMacVelocity()
  {
    return m_macVelo;
  }

  const Vector<LevelData<EBFluxFAB>* >& getMacVelocity() const
  {
    return m_macVelo;
  }

  void
  setSolverParams(int  a_numSmooth,
                  int  a_itermax,
                  int  a_mgcycle,
                  Real a_hang,
                  Real a_tolerance,
                  int  a_verbosity=3,
                  Real a_normThresh=1.e-12);

  void
  gradient(Vector<LevelData<EBCellFAB>* >&  a_gradient,
           Vector<LevelData<EBCellFAB>* >&  a_phi);

  void kappaDivergence(Vector<LevelData<EBCellFAB>* >&              a_divu,
                       Vector<LevelData<EBCellFAB>* >&              a_velo,
                       const Vector<LevelData<BaseIVFAB<Real> >* >* a_boundaryVelo = NULL);

  void
  averageVelocityToFaces(Vector<LevelData<EBFluxFAB>* >&        a_macVelo,
                         Vector<LevelData<EBCellFAB>* >&  a_velocity);

  void
  averageFaceToCells(Vector<LevelData<EBCellFAB>* >&         a_cellData,
                     const Vector<LevelData<EBFluxFAB>* >&   a_faceData);

  Vector<LevelData<EBCellFAB>* >& getPhi()
  {return m_macProjector->getPhi();}


  void
  setInitialPhi(Vector<LevelData<EBCellFAB>* >&  a_phi)
  {m_macProjector->setInitialPhi(a_phi);}

  protected:

  //mac projection objects
  EBCompositeMACProjector*         m_macProjector;
  //whether mac projection was sent in or not
  bool                             m_externMAC;
  bool                             m_subtractOffMean;
  Vector<LevelData<EBFluxFAB>* >   m_macVelo;
  Vector<LevelData<EBFluxFAB>* >   m_macGrad;

  //grid information
  Vector<EBLevelGrid>                      m_eblg;
  Vector<RefCountedPtr<EBQuadCFInterp> >   m_quadCFI;
  Vector<RealVect>                         m_dx;
  Vector<int>                              m_refRat;
  int                                      m_numLevels;

private:

  EBCompositeCCProjector()
  {
    MayDay::Error("Weak construction is bad where there is this much memory management");
  }

  EBCompositeCCProjector(const EBCompositeCCProjector& a_input)
  {
    MayDay::Error("We disallow copy construction for objects with pointered data");
  }

  void operator=(const EBCompositeCCProjector& a_input)
  {
    MayDay::Error("We disallow assignment for objects with pointered data");
  }

};

#include "NamespaceFooter.H"
#endif

---