Chombo + EB: AMRNodeOp.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 _AMRNODEOP_H_
00012 #define _AMRNODEOP_H_
00013 
00014 #include "AMRMultiGrid.H"
00015 #include "REAL.H"
00016 #include "Box.H"
00017 #include "LevelDataOps.H"
00018 #include "NodeBCFunc.H"
00019 #include "NodeFArrayBox.H"
00020 #include "NodeCFIVS.H"
00021 #include "NodeQCFI.H"
00022 #include "CoarseAverage.H"
00023 #include "LevelFluxRegister.H"
00024 #include "AMRNodeOpF_F.H"
00025 #include "NodeCoarseAverage.H"
00026 #include "NodeLevelDataOps.H"
00027 #include "NamespaceHeader.H"
00028 
00029 ///
00030 /**
00031  */
00032 class AMRNodeOp : public AMRLevelOp<LevelData<NodeFArrayBox> >
00033 {
00034 public:
00035   ///
00036   /**
00037    */
00038   AMRNodeOp();
00039 
00040   ///
00041   /**
00042    */
00043   virtual ~AMRNodeOp()
00044   {
00045   }
00046 
00047   /**
00048      \name LinearOp functions */
00049   /*@{*/
00050 
00051   ///
00052   /**
00053    */
00054   void define(const DisjointBoxLayout& a_grids,
00055               const Real&              a_dx,
00056               const ProblemDomain&     a_domain,
00057               NodeBCFunc                   a_bc);
00058 
00059   ///
00060   /**
00061      define function for AMRLevelOp which has no finer AMR level
00062    */
00063   void define(const DisjointBoxLayout& a_grids,
00064               const DisjointBoxLayout& a_baseBAPtr,
00065               const Real&              a_dxLevel,
00066               int                      a_refRatio,
00067               const ProblemDomain&     a_domain,
00068               NodeBCFunc                   a_bc);
00069 
00070   ///
00071   /** full define function for AMRLevelOp with both coarser and finer levels */
00072   void define(const DisjointBoxLayout& a_grids,
00073               const DisjointBoxLayout& a_gridsFiner,
00074               const DisjointBoxLayout& a_gridsCoarser,
00075               const Real&              a_dxLevel,
00076               int                      a_refRatio,
00077               int                      a_refRatioFiner,
00078               const ProblemDomain&     a_domain,
00079               NodeBCFunc                   a_bc);
00080 
00081   ///
00082   /** full define function for AMRLevelOp with finer levels, but no coarser */
00083   void define(const DisjointBoxLayout& a_grids,
00084               const DisjointBoxLayout& a_gridsFiner,
00085               const Real&              a_dxLevel,
00086               int                      a_refRatio, //  dummy argument, send in 1
00087               int                      a_refRatioFiner,
00088               const ProblemDomain&     a_domain,
00089               NodeBCFunc                   a_bc);
00090 
00091   void projectFineInterior(LevelData<NodeFArrayBox>&       a_phi,
00092                            const LevelData<NodeFArrayBox>& a_phiFine);
00093 
00094   virtual void residual(  LevelData<NodeFArrayBox>& a_lhs,
00095                           const LevelData<NodeFArrayBox>& a_phi,
00096                           const LevelData<NodeFArrayBox>& a_rhs,
00097                           bool a_homogeneous = false);
00098 
00099   virtual void preCond(   LevelData<NodeFArrayBox>& a_correction,
00100                           const LevelData<NodeFArrayBox>& a_residual);
00101 
00102   virtual void applyOpOnly(   LevelData<NodeFArrayBox>& a_lhs,
00103                               const LevelData<NodeFArrayBox>& a_phi);
00104 
00105   virtual void applyOp(   LevelData<NodeFArrayBox>& a_lhs,
00106                           const LevelData<NodeFArrayBox>& a_phi,
00107                           bool a_homogeneous = false);
00108   virtual void create(    LevelData<NodeFArrayBox>& a_lhs,
00109                           const LevelData<NodeFArrayBox>& a_rhs);
00110   virtual void createCoarsened(    LevelData<NodeFArrayBox>& a_lhs,
00111                                    const LevelData<NodeFArrayBox>& a_rhs,
00112                                    const int& a_refRat);
00113 
00114   virtual void assign(    LevelData<NodeFArrayBox>& a_lhs,
00115                           const LevelData<NodeFArrayBox>& a_rhs) ;
00116   virtual Real dotProduct(const LevelData<NodeFArrayBox>& a_1,
00117                           const LevelData<NodeFArrayBox>& a_2) ;
00118   virtual void incr( LevelData<NodeFArrayBox>& a_lhs,
00119                      const LevelData<NodeFArrayBox>& a_x,
00120                      Real a_scale) ;
00121   virtual void axby( LevelData<NodeFArrayBox>& a_lhs, const LevelData<NodeFArrayBox>& a_x,
00122                      const LevelData<NodeFArrayBox>& a_y,
00123                      Real a, Real b) ;
00124   virtual void scale(LevelData<NodeFArrayBox>& a_lhs, const Real& a_scale) ;
00125 
00126   virtual Real norm(const LevelData<NodeFArrayBox>& a_x, int a_ord);
00127 
00128   virtual void setToZero( LevelData<NodeFArrayBox>& a_x);
00129 
00130   virtual void relax(LevelData<NodeFArrayBox>& a_e,
00131                      const LevelData<NodeFArrayBox>& a_residual,
00132                      int iterations);
00133 
00134   virtual void createCoarser(LevelData<NodeFArrayBox>& a_coarse,
00135                              const LevelData<NodeFArrayBox>& a_fine,
00136                              bool ghosted);
00137 
00138   ///
00139   /**
00140      calculate restricted residual
00141      a_resCoarse[2h] = I[h->2h] (rhsFine[h] - L[h](phiFine[h])
00142   */
00143   virtual void restrictResidual(LevelData<NodeFArrayBox>& a_resCoarse,
00144                                 LevelData<NodeFArrayBox>& a_phiFine,
00145                                 const LevelData<NodeFArrayBox>& a_rhsFine);
00146 
00147   ///
00148   /**
00149      correct the fine solution based on coarse correction
00150      a_phiThisLevel += I[2h->h](a_correctCoarse)
00151   */
00152   virtual void prolongIncrement(LevelData<NodeFArrayBox>& a_phiThisLevel,
00153                                 const LevelData<NodeFArrayBox>& a_correctCoarse);
00154 
00155   ///
00156   virtual int refToCoarser()
00157   {
00158     return m_refToCoarser;
00159   }
00160 
00161   ///
00162   /** a_residual = a_rhs - L(a_phi, a_phiFine, a_phiCoarse) */
00163   virtual void AMRResidual(LevelData<NodeFArrayBox>& a_residual,
00164                            const LevelData<NodeFArrayBox>& a_phiFine,
00165                            const LevelData<NodeFArrayBox>& a_phi,
00166                            const LevelData<NodeFArrayBox>& a_phiCoarse,
00167                            const LevelData<NodeFArrayBox>& a_rhs,
00168                            bool a_homogeneousPhysBC,
00169                            AMRLevelOp<LevelData<NodeFArrayBox> >* a_finerOp);
00170 
00171   ///
00172   /** residual assuming no more coarser AMR levels */
00173   virtual void AMRResidualNC(LevelData<NodeFArrayBox>& a_residual,
00174                              const LevelData<NodeFArrayBox>& a_phiFine,
00175                              const LevelData<NodeFArrayBox>& a_phi,
00176                              const LevelData<NodeFArrayBox>& a_rhs,
00177                              bool a_homogeneousPhysBC,
00178                              AMRLevelOp<LevelData<NodeFArrayBox> >* a_finerOp);
00179 
00180   ///
00181   /** a_residual = a_rhs - L(a_phi, a_phiCoarse)  */
00182   virtual void AMRResidualNF(LevelData<NodeFArrayBox>& a_residual,
00183                              const LevelData<NodeFArrayBox>& a_phi,
00184                              const LevelData<NodeFArrayBox>& a_phiCoarse,
00185                              const LevelData<NodeFArrayBox>& a_rhs,
00186                              bool a_homogeneousPhysBC);
00187 
00188   ///
00189   /** apply AMR operator */
00190   virtual void AMROperator(LevelData<NodeFArrayBox>& a_LofPhi,
00191                            const LevelData<NodeFArrayBox>& a_phiFine,
00192                            const LevelData<NodeFArrayBox>& a_phi,
00193                            const LevelData<NodeFArrayBox>& a_phiCoarse,
00194                            bool a_homogeneousPhysBC,
00195                            AMRLevelOp<LevelData<NodeFArrayBox> >* a_finerOp);
00196 
00197   ///
00198   /** apply AMR operator, assuming no more coarser AMR levels */
00199   virtual void AMROperatorNC(LevelData<NodeFArrayBox>& a_LofPhi,
00200                              const LevelData<NodeFArrayBox>& a_phiFine,
00201                              const LevelData<NodeFArrayBox>& a_phi,
00202                              bool a_homogeneousPhysBC,
00203                              AMRLevelOp<LevelData<NodeFArrayBox> >* a_finerOp);
00204 
00205   ///
00206   /** AMR operator, assuming no finer AMR levels */
00207   virtual void AMROperatorNF(LevelData<NodeFArrayBox>& a_LofPhi,
00208                              const LevelData<NodeFArrayBox>& a_phi,
00209                              const LevelData<NodeFArrayBox>& a_phiCoarse,
00210                              bool a_homogeneousPhysBC);
00211 
00212   ///
00213   /** a_resCoarse = I[h-2h]( a_residual - L(a_correction, a_coarseCorrection))
00214       it is assumed that a_resCoarse has already been filled in with the coarse
00215       version of AMRResidualNF and that this operation is free to overwrite
00216       in the overlap regions.
00217   */
00218   virtual void AMRRestrict(LevelData<NodeFArrayBox>& a_resCoarse,
00219                            const LevelData<NodeFArrayBox>& a_residual,
00220                            const LevelData<NodeFArrayBox>& a_correction,
00221                            const LevelData<NodeFArrayBox>& a_coarseCorrection,
00222                             bool a_skip_res = false);
00223 
00224   /** a_correction += I[h->h](a_coarseCorrection) */
00225   virtual void AMRProlong(LevelData<NodeFArrayBox>& a_correction,
00226                           const LevelData<NodeFArrayBox>& a_coarseCorrection);
00227 
00228   /** a_residual = a_residual - L(a_correction, a_coarseCorrection) */
00229   virtual void AMRUpdateResidual(LevelData<NodeFArrayBox>& a_residual,
00230                                  const LevelData<NodeFArrayBox>& a_correction,
00231                                  const LevelData<NodeFArrayBox>& a_coarseCorrection);
00232 
00233   ///
00234   /**
00235      compute norm over all cells on coarse not covered by finer
00236   */
00237   virtual Real AMRNorm(const LevelData<NodeFArrayBox>& a_coarseResid,
00238                        const LevelData<NodeFArrayBox>& a_fineResid,
00239                        const int&                  a_refRat,
00240                        const int&                  a_ord);
00241 
00242   /*@}*/
00243 
00244   Real m_alpha, m_beta;
00245 
00246 protected:
00247   //internal--for code reuse
00248   void prolongIncrement(LevelData<NodeFArrayBox>&       a_phiThisLevel,
00249                         const LevelData<NodeFArrayBox>& a_correctCoarse,
00250                         int a_refRat);
00251 
00252   ProblemDomain m_domainInteriorNodes;
00253   Real                    m_dx;
00254   Real                    m_dxCrse;
00255   ProblemDomain           m_domain;
00256   NodeLevelDataOps        m_levelOps;
00257   NodeBCFunc              m_bc;
00258   LayoutData<NodeCFIVS>   m_loCFIVS[SpaceDim];
00259   LayoutData<NodeCFIVS>   m_hiCFIVS[SpaceDim];
00260   Copier                  m_exchangeCopier;
00261   NodeQCFI                m_interpWithCoarser;
00262   NodeCoarseAverage       m_averageOpMG;
00263   int                     m_refToCoarser;
00264   int                     m_refToFiner;
00265   DisjointBoxLayout       m_coarsenedFineGrids;
00266   bool                    m_hasFiner;
00267 
00268   void levelGSRB(LevelData<NodeFArrayBox>& a_e,
00269                  const LevelData<NodeFArrayBox>& a_residual);
00270 
00271   void homogeneousCFInterp(LevelData<NodeFArrayBox>& a_phif);
00272   void homogeneousCFInterp(LevelData<NodeFArrayBox>& a_phif,
00273                            const DataIndex& a_datInd,
00274                            int a_idir,
00275                            Side::LoHiSide a_hiorlo);
00276 
00277   /** interior boundary nodes
00278    */
00279   LayoutData< Vector<IntVectSet> > m_IVSV;
00280 
00281   /** whether each section of m_IVSV is a complete box
00282    */
00283   LayoutData< BitSet > m_IVSVfull;
00284 
00285   // exterior boundary nodes
00286   LayoutData< Vector<IntVectSet> > m_IVSVext;
00287 
00288   /** interior boundary nodes of the coarsened grids at this level
00289    */
00290   LayoutData< Vector<IntVectSet> > m_IVSVcoarsened;
00291 
00292   /** interior boundary nodes of the coarsened grids at next finer level
00293    */
00294   LayoutData< Vector<IntVectSet> > m_IVSVcoarsenedFine;
00295 
00296   void setCFIVS(const DisjointBoxLayout& a_grids);
00297 };
00298 
00299 class AMRNodeOpFactory: public AMRLevelOpFactory<LevelData<NodeFArrayBox> >
00300 {
00301 public:
00302   virtual ~AMRNodeOpFactory()
00303   {
00304   }
00305 
00306   /// full AMR definition function
00307   void define(const ProblemDomain& a_coarseDomain,
00308               const Vector<DisjointBoxLayout>& a_grids,
00309               const Vector<int> a_refRatios,
00310               const Real&       a_coarsedx,
00311               NodeBCFunc a_bc,
00312               Real   a_alpha = 0.,
00313               Real   a_beta  = 1.);
00314 
00315   /// regular multigrid definition function
00316   void define(const ProblemDomain& a_domain,
00317               const DisjointBoxLayout& a_grid,
00318               const Real&    a_dx,
00319               NodeBCFunc a_bc,
00320               int maxDepth = -1,
00321               Real   a_alpha = 0.,
00322               Real   a_beta  = 1.);
00323 
00324   /**
00325      \name MGLevelOpFactory functions */
00326   /*@{*/
00327   virtual AMRNodeOp*
00328   MGnewOp(const ProblemDomain& a_FineindexSpace,
00329           int depth,
00330           bool homoOnly = true);
00331 
00332   /*@}*/
00333 
00334   /**
00335      \name AMRLevelOpFactory functions */
00336   /*@{*/
00337   virtual  AMRNodeOp* AMRnewOp(const ProblemDomain& a_indexSpace);
00338 
00339   virtual int refToFiner(const ProblemDomain&) const;
00340 
00341 private:
00342   Vector<ProblemDomain>     m_domains;
00343   Vector<DisjointBoxLayout> m_boxes;
00344   Vector<Real>              m_dx;
00345   Vector<int>               m_refRatios; // refinement to next coarser level
00346   NodeBCFunc                m_bc;
00347   Real m_alpha, m_beta;
00348 
00349 };
00350 
00351 #include "NamespaceFooter.H"
00352 #endif