EBAMRPoissonOpFactory.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 _EBAMRPOISSONOPFACTORY_H_
#define _EBAMRPOISSONOPFACTORY_H_

#include "REAL.H"
#include "Box.H"
#include "FArrayBox.H"
#include "Vector.H"
#include <map>
#include "RefCountedPtr.H"

#include "AMRMultiGrid.H"

#include "EBIndexSpace.H"
#include "EBCellFAB.H"
#include "EBCellFactory.H"

#include "EBLevelDataOps.H"
#include "BaseEBBC.H"
#include "BaseDomainBC.H"
#include "CFIVS.H"
#include "EBFluxRegister.H"
#include "EBMGAverage.H"
#include "EBMGInterp.H"
#include "EBCoarsen.H"
#include "PolyGeom.H"
#include "EBAMRPoissonOp.H"
#include "EBLevelGrid.H"
#include "NamespaceHeader.H"



class EBAMRPoissonOpFactory: public AMRLevelOpFactory<LevelData<EBCellFAB> >
{
public:
  virtual ~EBAMRPoissonOpFactory();


  EBAMRPoissonOpFactory(const Vector<EBLevelGrid>&                    a_eblgs,
                        const Vector<int>&                            a_refRatio,
                        const Vector<RefCountedPtr<EBQuadCFInterp> >& a_quadCFI,
                        const RealVect&                               a_dxCoarse,
                        const RealVect&                               a_origin,
                        const int&                                    a_numPreCondIters,
                        const int&                                    a_relaxType,
                        RefCountedPtr<BaseDomainBCFactory>            a_domainBCFactory,
                        RefCountedPtr<BaseEBBCFactory>                a_ebBcFactory,
                        const Real&                                   a_alpha,
                        const Real&                                   a_beta,
                        const Real&                                   a_time,
                        const IntVect&                                a_ghostCellsPhi,
                        const IntVect&                                a_ghostCellsRhs,
                        int a_numLevels = -1);

  virtual EBAMRPoissonOp*
  MGnewOp(const ProblemDomain& a_FineindexSpace,
          int                  a_depth,
          bool                 a_homoOnly = true);

  EBAMRPoissonOp* createOperator(const EBLevelGrid&             a_eblgMGLevel,
                                 const EBLevelGrid&             a_eblgCoarMG,
                                 const bool&                    a_hasMGObjects,
                                 const bool&                    a_layoutChanged,
                                 const RealVect&                a_dxMGLevel,
                                 const RealVect&                a_dxCoar,
                                 RefCountedPtr<EBQuadCFInterp>& a_quadCFIMGLevel,
                                 const int&                     a_whichLevel);
  virtual void reclaim(MGLevelOp<LevelData<EBCellFAB> >* a_reclaim);

  virtual EBAMRPoissonOp*
  AMRnewOp(const ProblemDomain& a_FineindexSpace);

  virtual void AMRreclaim(EBAMRPoissonOp* a_reclaim);


  virtual int refToFiner(const ProblemDomain& a_domain) const;

protected:
  bool     m_isDefined;
  int      m_numPreCondIters;
  int      m_relaxType;
  int      m_numLevels;


  Vector<EBLevelGrid>     m_eblgVec;
  Vector<RefCountedPtr<EBQuadCFInterp> > m_quadCFIVec;

  Vector< Vector<EBLevelGrid> >       m_eblgVecMG;
  std::vector< bool  >                m_hasMGObjects;
  std::vector< bool  >                m_layoutChanged;
  std::vector< std::vector<bool> >    m_layoutChangedMG;

  Vector<int>               m_refRatioVec;
  Vector<RealVect>          m_dxVec;
  RealVect                  m_origin;
  Real                      m_alpha;
  Real                      m_beta;
  Real                      m_time;
  const IntVect             m_ghostCellsPhi;
  const IntVect             m_ghostCellsRHS;

  RefCountedPtr<BaseDomainBCFactory>   m_domainBCFactory;
  RefCountedPtr<BaseEBBCFactory>       m_ebBCFactory;

private:
  EBAMRPoissonOpFactory()
  {
    MayDay::Error("invalid operator");
  }

  //copy constructor and operator= disallowed for all the usual reasons
  EBAMRPoissonOpFactory(const EBAMRPoissonOpFactory& a_opin)
  {
    MayDay::Error("invalid operator");
  }

  void operator=(const EBAMRPoissonOpFactory& a_opin)
  {
    MayDay::Error("invalid operator");
  }
};

#include "NamespaceFooter.H"
#endif

---