Chombo + EB: PoissonOp4.H Source File

00001 #ifdef CH_LANG_CC
00002 /*
00003  *      _______              __
00004  *     / ___/ /  ___  __ _  / /  ___
00005  *    / /__/ _ \/ _ \/  V \/ _ \/ _ \
00006  *    \___/_//_/\___/_/_/_/_.__/\___/
00007  *    Please refer to Copyright.txt, in Chombo's root directory.
00008  */
00009 #endif
00010 
00011 #ifndef _POISSONOP4_H_
00012 #define _POISSONOP4_H_
00013 
00014 #include "AMRMultiGrid.H"
00015 #include "REAL.H"
00016 #include "Box.H"
00017 #include "LevelDataOps.H"
00018 #include "BCFunc.H"
00019 #include "FArrayBox.H"
00020 #include "LevelData.H"
00021 #include "NamespaceHeader.H"
00022 
00023 class PoissonOp4 : public MGLevelOp<LevelData<FArrayBox> >
00024 {
00025 public:
00026   PoissonOp4()
00027   {
00028   }
00029 
00030   virtual ~PoissonOp4()
00031   {
00032   }
00033 
00034   static const int m_nGhost = 2;
00035 
00036   /**
00037      \name LinearOp functions */
00038   /*@{*/
00039 
00040   void define(const RealVect& a_dx,
00041               const ProblemDomain& a_domain,
00042               BCFunc a_bc);
00043 
00044   virtual void createCoarsened(LevelData<FArrayBox>& a_lhs,
00045                                const LevelData<FArrayBox>& a_rhs,
00046                                const int& a_refRat);
00047 
00048   virtual void residual(LevelData<FArrayBox>& a_lhs,
00049                         const LevelData<FArrayBox>& a_phi,
00050                         const LevelData<FArrayBox>& a_rhs,
00051                         bool a_homogeneous = false);
00052 
00053   virtual void preCond(LevelData<FArrayBox>& a_correction,
00054                        const LevelData<FArrayBox>& a_residual);
00055 
00056   virtual void applyOp(LevelData<FArrayBox>& a_lhs,
00057                        const LevelData<FArrayBox>& a_phi,
00058                        bool a_homogeneous = false);
00059 
00060   virtual void create(LevelData<FArrayBox>& a_lhs,
00061                       const LevelData<FArrayBox>& a_rhs);
00062 
00063   virtual void assign(LevelData<FArrayBox>& a_lhs,
00064                       const LevelData<FArrayBox>& a_rhs) ;
00065 
00066   virtual Real dotProduct(const LevelData<FArrayBox>& a_1,
00067                           const LevelData<FArrayBox>& a_2) ;
00068 
00069   virtual void incr(LevelData<FArrayBox>& a_lhs,
00070                     const LevelData<FArrayBox>& a_x,
00071                     Real a_scale) ;
00072 
00073   virtual void axby(LevelData<FArrayBox>& a_lhs, 
00074                     const LevelData<FArrayBox>& a_x,
00075                     const LevelData<FArrayBox>& a_y,
00076                     Real a, Real b) ;
00077 
00078   virtual void scale(LevelData<FArrayBox>& a_lhs, 
00079                      const Real& a_scale) ;
00080 
00081   virtual Real norm(const LevelData<FArrayBox>& a_x, int a_ord);
00082 
00083   virtual void setToZero(LevelData<FArrayBox>& a_x);
00084 
00085   /*@}*/
00086 
00087   /**
00088      \name MGLevelOp functions */
00089   /*@{*/
00090 
00091   virtual void relax(LevelData<FArrayBox>& a_e,
00092                      const LevelData<FArrayBox>& a_residual,
00093                      int iterations);
00094 
00095   virtual void createCoarser(LevelData<FArrayBox>& a_coarse,
00096                              const LevelData<FArrayBox>& a_fine,
00097                              bool ghost);
00098   /**
00099      calculate restricted residual
00100      a_resCoarse[2h] = I[h->2h] (rhsFine[h] - L[h](phiFine[h])
00101   */
00102   virtual void restrictResidual(LevelData<FArrayBox>& a_resCoarse,
00103                                 LevelData<FArrayBox>& a_phiFine,
00104                                 const LevelData<FArrayBox>& a_rhsFine);
00105 
00106   /**
00107      correct the fine solution based on coarse correction
00108      a_phiThisLevel += I[2h->h](a_correctCoarse)
00109   */
00110   virtual void prolongIncrement(LevelData<FArrayBox>& a_phiThisLevel,
00111                                 const LevelData<FArrayBox>& a_correctCoarse);
00112 
00113   /*@}*/
00114 
00115 
00116 protected:
00117 
00118   RealVect                m_dx;
00119   RealVect                m_dxCrse;
00120   ProblemDomain           m_domain;
00121   BCFunc                  m_bc;
00122 
00123   LevelDataOps<FArrayBox> m_levelOps;
00124   DisjointBoxLayout       m_coarsenedMGrids;
00125   
00126   void levelGSRB(LevelData<FArrayBox>& a_e,  
00127                  const LevelData<FArrayBox>& a_residual);
00128 
00129 };
00130 
00131 class PoissonOp4Factory : public MGLevelOpFactory<LevelData<FArrayBox> >
00132 {
00133 public:
00134 
00135   PoissonOp4Factory();
00136 
00137   PoissonOp4Factory(RealVect& a_dx, BCFunc a_bc);
00138 
00139   void define(const RealVect& m_dx, BCFunc m_bc);
00140 
00141   virtual ~PoissonOp4Factory()
00142   {
00143   }
00144 
00145   virtual PoissonOp4* MGnewOp(const ProblemDomain& a_FineindexSpace,
00146                                      int   a_depth,
00147                                      bool  a_homoOnly = true);
00148 
00149   virtual void MGreclaim(PoissonOp4* a_reclaim);
00150 
00151   RealVect                m_dx;
00152   BCFunc                  m_bc;
00153 
00154 };
00155 
00156 #include "NamespaceFooter.H"
00157 #endif