Chombo + EB: EBConductivityOp.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 _EBCONDUCTIVITYOP_H_
00012 #define _EBCONDUCTIVITYOP_H_
00013 
00014 #include "REAL.H"
00015 #include "Box.H"
00016 #include "FArrayBox.H"
00017 #include "Vector.H"
00018 #include <map>
00019 #include "RefCountedPtr.H"
00020 
00021 #include "AMRMultiGrid.H"
00022 #include "EBAMRPoissonOp.H"
00023 
00024 #include "EBIndexSpace.H"
00025 #include "EBCellFAB.H"
00026 #include "EBCellFactory.H"
00027 #include "EBStencil.H"
00028 
00029 #include "EBLevelDataOps.H"
00030 #include "BaseEBBC.H"
00031 #include "BaseDomainBC.H"
00032 #include "CFIVS.H"
00033 #include "EBFluxRegister.H"
00034 #include "EBFastFR.H"
00035 #include "EBMGAverage.H"
00036 #include "EBMGInterp.H"
00037 #include "PolyGeom.H"
00038 #include "EBQuadCFInterp.H"
00039 #include "EBLevelGrid.H"
00040 #include "AMRTGA.H"
00041 #include "AMRPoissonOp.H"
00042 #include "CFRegion.H"
00043 #include "ConductivityBaseDomainBC.H"
00044 #include "NamespaceHeader.H"
00045 
00046 
00047 #if CH_SPACEDIM==2
00048 #define EBAMRPOVC_NUMSTEN 4
00049 #elif CH_SPACEDIM==3
00050 #define EBAMRPOVC_NUMSTEN 8
00051 #else
00052 void THIS_IS_AN_ERROR_MESSAGE(void)
00053 {
00054   THIS_WILL_ONLY_COMPILE_WHEN_CH_SPACEDIM_IS_2_OR_3;
00055 }
00056 #endif
00057 
00058 //! \class EBConductivityOp
00059 //! This class implements an operator that solves the equation
00060 //! (alpha a + beta div (b grad) )phi = rhs
00061 //! using the AMRLevelOp interface.
00062 class EBConductivityOp: public LevelTGAHelmOp<LevelData<EBCellFAB>, EBFluxFAB >
00063 {
00064   public:
00065 
00066 #ifdef CH_USE_HDF5
00067   ///for debugging
00068   virtual void dumpAMR(Vector<LevelData<EBCellFAB>*>& a_data, string name)
00069   {
00070     writeEBAMRname(&a_data, name.c_str());
00071   }
00072 
00073   ///for debugging
00074   virtual void dumpLevel(LevelData<EBCellFAB>& a_data, string name)
00075   {
00076     writeEBLevelname(&a_data, name.c_str());
00077   }
00078 #endif
00079   //! Constructs a conductivity operator using the given data. This
00080   //! constructor is for time-independent a and b coefficients.
00081   //! If you are approaching this operator from this interface, consider backing away and using
00082   //! EBConductivityOpFactory to generate these objects. Really.
00083   //! Ghost cell arguments are there for caching reasons. Once you set them,
00084   //! an error is thrown if you send in data that does not match.
00085   //! \param a_eblgFine grid at finer  level
00086   //! \param a_eblg grid at this  level
00087   //! \param a_eblgCoar grid at coarser level
00088   //! \param a_eblgCoarMG grid at intermediate multigrid level
00089   //! \param a_domainBC domain boundary conditions at this level
00090   //! \param a_ebBC eb boundary conditions at this level
00091   //! \param a_dx grid spacing at this level
00092   //! \param a_origin offset to lowest corner of the domain
00093   //! \param a_refToFine refinement ratio to finer level
00094   //! \param a_refToCoar refinement ratio to coarser level
00095   //! \param a_hasFiner true if there is a finer AMR level, false otherwise.
00096   //! \param a_hasCoarser true if there is a coarser AMR level.
00097   //! \param a_hasCoarserMG true if there is a coarser MultiGrid level.
00098   //! \param a_preCondIters number of iterations to do for pre-conditioning
00099   //! \param a_relaxType 0 means point Jacobi, 1 is Gauss-Seidel.
00100   //! \param a_acoef coefficent of identity
00101   //! \param a_bcoef coefficient of gradient.
00102   //! \param a_ghostCellsPhi Number of ghost cells in phi, correction
00103   //! \param a_ghostCellsRhs Number of ghost cells in RHS, residual, lphi
00104   EBConductivityOp(const EBLevelGrid &                                  a_eblgFine,
00105                    const EBLevelGrid &                                  a_eblg,
00106                    const EBLevelGrid &                                  a_eblgCoar,
00107                    const EBLevelGrid &                                  a_eblgCoarMG,
00108                    const RefCountedPtr<EBQuadCFInterp>&                 a_quadCFI,
00109                    const RefCountedPtr<ConductivityBaseDomainBC>&       a_domainBC,
00110                    const RefCountedPtr<ConductivityBaseEBBC>&           a_ebBC,
00111                    const Real    &                                      a_dx,
00112                    const Real    &                                      a_dxCoar,
00113                    const int&                                           a_refToFine,
00114                    const int&                                           a_refToCoar,
00115                    const bool&                                          a_hasFine,
00116                    const bool&                                          a_hasCoar,
00117                    const bool&                                          a_hasMGObjects,
00118                    const bool&                                          a_layoutChanged,
00119                    const Real&                                          a_alpha,
00120                    const Real&                                          a_beta,
00121                    const RefCountedPtr<LevelData<EBCellFAB> >&          a_acoef,
00122                    const RefCountedPtr<LevelData<EBFluxFAB> >&          a_bcoef,
00123                    const RefCountedPtr<LevelData<BaseIVFAB<Real> > >&   a_bcoIrreg,
00124                    const IntVect&                                       a_ghostCellsPhi,
00125                    const IntVect&                                       a_ghostCellsRHS,
00126                    const int&                                           a_relaxType);
00127 
00128 
00129   //! Destructor.
00130   ~EBConductivityOp();
00131 
00132   Real getSafety();
00133 
00134   ///
00135   /**
00136      This sets the data storage for the a coefficient to a different
00137      object and recalculates the stuff it depends on. Use this only if you know what you're doing.
00138   */
00139   virtual void resetACoefficient(RefCountedPtr<LevelData<EBCellFAB> >& a_acoef)
00140   {
00141 
00142     m_acoef = a_acoef;
00143     calculateAlphaWeight();
00144     calculateRelaxationCoefficient();
00145   }
00146 
00147   //only weights by kappa.  time and tga have their demands.
00148   virtual void kappaScale(LevelData<EBCellFAB> & a_rhs);
00149 
00150   ///returns m_dx, such function is required by some LinearSolvers
00151   Real dx() const
00152   {
00153     return m_dx;
00154   }
00155 
00156   ///
00157   /** a_residual = a_rhs - L(a_phiFine, a_phi)   no coaser AMR level*/
00158   void AMRResidualNC(LevelData<EBCellFAB>&       a_residual,
00159                      const LevelData<EBCellFAB>& a_phiFine,
00160                      const LevelData<EBCellFAB>& a_phi,
00161                      const LevelData<EBCellFAB>& a_rhs,
00162                      bool a_homogeneousBC,
00163                      AMRLevelOp<LevelData<EBCellFAB> >* a_finerOp);
00164 
00165 
00166   ///
00167   /** apply AMR operator   no coaser AMR level*/
00168   void AMROperatorNC(LevelData<EBCellFAB>&       a_LofPhi,
00169                      const LevelData<EBCellFAB>& a_phiFine,
00170                      const LevelData<EBCellFAB>& a_phi,
00171                      bool a_homogeneousBC,
00172                      AMRLevelOp<LevelData<EBCellFAB> >* a_finerOp);
00173 
00174   //------------------------------------
00175   // Overridden methods for base classes
00176   //------------------------------------
00177 
00178   void setAlphaAndBeta(const Real& a_alpha,
00179                        const Real& a_beta);
00180 
00181   void diagonalScale(LevelData<EBCellFAB> & a_rhs,
00182                      bool a_kappaWeighted);
00183 
00184   void divideByIdentityCoef(LevelData<EBCellFAB> & a_rhs);
00185 
00186   void fillGrad(const LevelData<EBCellFAB>& a_phi);
00187 
00188   void getFlux(EBFluxFAB&                    a_flux,
00189                const LevelData<EBCellFAB>&   a_data,
00190                const Box&                    a_grid,
00191                const DataIndex&              a_dit,
00192                Real                          a_scale);
00193 
00194   void getFlux(EBFaceFAB&                    a_fluxCentroid,
00195                const EBCellFAB&              a_phi,
00196                const Box&                    a_ghostedBox,
00197                const Box&                    a_fabBox,
00198                const ProblemDomain&          a_domain,
00199                const EBISBox&                a_ebisBox,
00200                const Real&                   a_dx,
00201                const DataIndex&              a_datInd,
00202                const int&                    a_idir);
00203 
00204   // This operator may be time-dependent.
00205   void setTime(Real a_oldTime, Real a_mu, Real a_dt);
00206 
00207   //! This is called on multigrid operators when their AMR operators
00208   //! are altered.
00209   void finerOperatorChanged(const MGLevelOp<LevelData<EBCellFAB> >& a_operator,
00210                             int a_coarseningFactor);
00211 
00212   //MGOp operations.  no finer or coarser
00213 
00214   ///
00215   /**
00216    */
00217   virtual void residual(LevelData<EBCellFAB>&       a_residual,
00218                         const LevelData<EBCellFAB>& a_phi,
00219                         const LevelData<EBCellFAB>& a_rhs,
00220                         bool                        a_homogeneousPhysBC=false);
00221 
00222   ///
00223   /**
00224    */
00225   virtual void preCond(LevelData<EBCellFAB>&       a_opPhi,
00226                        const LevelData<EBCellFAB>& a_phi);
00227 
00228   ///
00229   /**
00230      This function assumes that coarse-fine boundary condtions have
00231      been dealt with.
00232   */
00233   virtual void applyOp(LevelData<EBCellFAB>&             a_opPhi,
00234                        const LevelData<EBCellFAB>&       a_phi,
00235                        const LevelData<EBCellFAB>* const a_phiCoarse,
00236                        const bool&                       a_homogeneousPhysBC,
00237                        const bool&                       a_homogeneousCFBC);
00238 
00239   /// virtual function called by LevelTGA
00240   virtual void applyOpNoBoundary(LevelData<EBCellFAB>&        a_opPhi,
00241                                  const LevelData<EBCellFAB>&  a_phi);
00242 
00243   ///
00244   /**
00245      this is the linearop function.  CFBC is set to homogeneous.  phic is null
00246   */
00247   virtual void applyOp(LevelData<EBCellFAB>&             a_opPhi,
00248                        const LevelData<EBCellFAB>&       a_phi,
00249                        bool                              a_homogeneousPhysBC);
00250 
00251   ///
00252   /**
00253    */
00254   virtual void create(LevelData<EBCellFAB>&       a_lhs,
00255                       const LevelData<EBCellFAB>& a_rhs);
00256 
00257   ///
00258   virtual void createCoarsened(LevelData<EBCellFAB>&       a_lhs,
00259                                const LevelData<EBCellFAB>& a_rhs,
00260                                const int&                  a_refRat);
00261 
00262   Real
00263   AMRNorm(const LevelData<EBCellFAB>& a_coarResid,
00264           const LevelData<EBCellFAB>& a_fineResid,
00265           const int& a_refRat,
00266           const int& a_ord);
00267 
00268   ///
00269   /**
00270    */
00271   virtual void assign(LevelData<EBCellFAB>&       a_lhs,
00272                       const LevelData<EBCellFAB>& a_rhs);
00273 
00274   ///
00275   /**
00276    */
00277   virtual Real dotProduct(const LevelData<EBCellFAB>& a_1,
00278                           const LevelData<EBCellFAB>& a_2);
00279 
00280   ///
00281   /**
00282    */
00283   virtual void incr(LevelData<EBCellFAB>&       a_lhs,
00284                     const LevelData<EBCellFAB>& a_x,
00285                     Real                        a_scale);
00286 
00287   ///
00288   /**
00289    */
00290   virtual void axby(LevelData<EBCellFAB>&       a_lhs,
00291                     const LevelData<EBCellFAB>& a_x,
00292                     const LevelData<EBCellFAB>& a_y,
00293                     Real                        a_a,
00294                     Real                        a_b);
00295 
00296   ///
00297   /**
00298    */
00299   virtual void scale(LevelData<EBCellFAB>& a_lhs,
00300                      const Real&           a_scale);
00301 
00302   ///
00303   /**
00304    */
00305   virtual Real norm(const LevelData<EBCellFAB>& a_rhs,
00306                     int                         a_ord);
00307 
00308   virtual Real localMaxNorm(const LevelData<EBCellFAB>& a_rhs);
00309   ///
00310   /**
00311    */
00312   virtual void setToZero(LevelData<EBCellFAB>& a_lhs);
00313 
00314   ///
00315   /**
00316    */
00317   virtual void setVal(LevelData<EBCellFAB>& a_lhs, const Real& a_value);
00318 
00319   ///
00320   /**
00321    */
00322   virtual void createCoarser(LevelData<EBCellFAB>&       a_coarse,
00323                              const LevelData<EBCellFAB>& a_fine,
00324                              bool                        a_ghosted);
00325 
00326   ///
00327   /**
00328    */
00329   virtual void relax(LevelData<EBCellFAB>&       a_e,
00330                      const LevelData<EBCellFAB>& a_residual,
00331                      int                         a_iterations);
00332 
00333 
00334   virtual void relaxGauSai(LevelData<EBCellFAB>&       a_e,
00335                           const LevelData<EBCellFAB>& a_residual,
00336                           int                         a_iterations);
00337 
00338   virtual void relaxPoiJac(LevelData<EBCellFAB>&       a_e,
00339                            const LevelData<EBCellFAB>& a_residual,
00340                            int                         a_iterations);
00341 
00342 
00343   virtual void relaxGSRBFast(LevelData<EBCellFAB>&       a_e,
00344                              const LevelData<EBCellFAB>& a_residual,
00345                              int                         a_iterations);
00346 
00347   ///
00348   /**
00349      Calculate restricted residual:
00350      a_resCoarse[2h] = I[h->2h] (a_rhsFine[h] - L[h](a_phiFine[h]))
00351   */
00352   virtual void restrictResidual(LevelData<EBCellFAB>&       a_resCoarse,
00353                                 LevelData<EBCellFAB>&       a_phiFine,
00354                                 const LevelData<EBCellFAB>& a_rhsFine);
00355 
00356   ///
00357   /**
00358      Correct the fine solution based on coarse correction:
00359      a_phiThisLevel += I[2h->h] (a_correctCoarse)
00360   */
00361   virtual void prolongIncrement(LevelData<EBCellFAB>&       a_phiThisLevel,
00362                                 const LevelData<EBCellFAB>& a_correctCoarse);
00363 
00364   ///
00365   /** Refinement ratio between this level and coarser level.
00366       Returns 1 when there are no coarser AMRLevelOp objects */
00367   virtual int refToCoarser();
00368 
00369   ///
00370   /** Refinement ratio between this level and coarser level.
00371       Returns 1 when there are no coarser AMRLevelOp objects */
00372   virtual int refToFiner();
00373 
00374   ///
00375   /** a_residual = a_rhs - L(a_phi, a_phiFine, a_phiCoarse) */
00376   virtual void AMRResidual(LevelData<EBCellFAB>& a_residual,
00377                            const LevelData<EBCellFAB>& a_phiFine,
00378                            const LevelData<EBCellFAB>& a_phi,
00379                            const LevelData<EBCellFAB>& a_phiCoarse,
00380                            const LevelData<EBCellFAB>& a_rhs,
00381                            bool a_homogeneousBC,
00382                            AMRLevelOp<LevelData<EBCellFAB> >* a_finerOp);
00383 
00384   ///
00385   /** a_residual = a_rhs - L(a_phi, a_phiCoarse)  */
00386   virtual void AMRResidualNF(LevelData<EBCellFAB>& a_residual,
00387                              const LevelData<EBCellFAB>& a_phi,
00388                              const LevelData<EBCellFAB>& a_phiCoarse,
00389                              const LevelData<EBCellFAB>& a_rhs,
00390                              bool a_homogeneousBC);
00391 
00392 
00393   ///
00394   /** a_residual = a_rhs - L(a_phi, a_phiFine, a_phiCoarse) */
00395   virtual void AMROperator(LevelData<EBCellFAB>& a_LofPhi,
00396                            const LevelData<EBCellFAB>& a_phiFine,
00397                            const LevelData<EBCellFAB>& a_phi,
00398                            const LevelData<EBCellFAB>& a_phiCoarse,
00399                            bool a_homogeneousBC,
00400                            AMRLevelOp<LevelData<EBCellFAB> >* a_finerOp);
00401 
00402   ///
00403   /** a_residual = a_rhs - L(a_phi, a_phiCoarse)  */
00404   virtual void AMROperatorNF(LevelData<EBCellFAB>& a_LofPhi,
00405                              const LevelData<EBCellFAB>& a_phi,
00406                              const LevelData<EBCellFAB>& a_phiCoarse,
00407                              bool a_homogeneousBC);
00408 
00409   ///
00410   /** a_resCoarse = I[h-2h] (a_residual - L(a_correction, a_coarseCorrection)) */
00411   virtual void AMRRestrict(LevelData<EBCellFAB>& a_resCoarse,
00412                            const LevelData<EBCellFAB>& a_residual,
00413                            const LevelData<EBCellFAB>& a_correction,
00414                            const LevelData<EBCellFAB>& a_coarseCorrection, 
00415                            bool a_skip_res = false );
00416 
00417   ///
00418   /** a_correction += I[2h->h](a_coarseCorrection) */
00419   virtual void AMRProlong(LevelData<EBCellFAB>&       a_correction,
00420                           const LevelData<EBCellFAB>& a_coarseCorrection);
00421 
00422   ///
00423   /** a_residual = a_residual - L(a_correction, a_coarseCorrection) */
00424   virtual void AMRUpdateResidual(LevelData<EBCellFAB>&       a_residual,
00425                                  const LevelData<EBCellFAB>& a_correction,
00426                                  const LevelData<EBCellFAB>& a_coarseCorrection);
00427 
00428   void reflux(LevelData<EBCellFAB>& a_residual,
00429               const LevelData<EBCellFAB>& a_phiFine,
00430               const LevelData<EBCellFAB>& a_phi,
00431               AMRLevelOp<LevelData<EBCellFAB> >* a_finerOp);
00432 
00433   void gsrbColor(LevelData<EBCellFAB>&       a_phi,
00434                  const LevelData<EBCellFAB>& a_lph,
00435                  const LevelData<EBCellFAB>& a_rhs,
00436                  const IntVect&              a_color);
00437 
00438   void getDivFStencil(VoFStencil&      a_vofStencil,
00439                       const VolIndex&  a_vof,
00440                       const DataIndex& a_dit);
00441 
00442   void getFluxStencil(VoFStencil&      a_fluxStencil,
00443                       const FaceIndex& a_face,
00444                       const DataIndex& a_dit);
00445 
00446   void getFaceCenteredFluxStencil(VoFStencil&      a_fluxStencil,
00447                                   const FaceIndex& a_face,
00448                                   const DataIndex& a_dit);
00449 
00450   void incrOpRegularDir(EBCellFAB&             a_lhs,
00451                         const EBCellFAB&       a_phi,
00452                         const bool&            a_homogeneous,
00453                         const int&             a_dir,
00454                         const DataIndex&       a_datInd);
00455   void applyOpIrregular(EBCellFAB&             a_lhs,
00456                         const EBCellFAB&       a_phi,
00457                         const bool&            a_homogeneous,
00458                         const DataIndex&       a_datInd);
00459 
00460   //this is needed to do wacky things like reset the a coefficient.
00461   //not for the faint of heart
00462   //but none but the brave deserve the fair
00463   const EBLevelGrid& getEBLG() const
00464   {
00465     return m_eblg;
00466   }
00467   static void setForceNoEBCF(bool a_forceNoEBCF)
00468   {
00469     s_forceNoEBCF = a_forceNoEBCF;
00470   }
00471   ///do not call this one unless you really know what you are doing
00472   void defineStencils();
00473 
00474     //adding suplementary methods for petsc solver
00475   void getAlphaDiagWeight(LayoutData<BaseIVFAB<Real> > const*& a_alphaDiagWeight)
00476   {
00477     a_alphaDiagWeight = &m_alphaDiagWeight;
00478   }
00479 
00480   void getAlphaBeta(Real& a_alpha, Real& a_beta)
00481   {
00482     a_alpha = m_alpha;
00483     a_beta  = m_beta;
00484   }
00485   const RefCountedPtr<BaseDomainBC> getDomainBC()
00486   {
00487       return m_domainBC;
00488   }
00489 
00490   const RefCountedPtr<LevelData<EBCellFAB> > getAScalingCoefficients()
00491   {
00492       return m_acoef;
00493   }
00494 
00495   const  RefCountedPtr<LevelData<EBFluxFAB> > getBScalingCoefficients()
00496   {
00497       return m_bcoef;
00498   }
00499     
00500   void getEBBCFluxStencil(LayoutData<BaseIVFAB<VoFStencil> > const*& a_ebbcFluxStencil)  
00501   {
00502       a_ebbcFluxStencil = m_ebBC->getFluxStencil(0);
00503   }
00504 
00505   static int                      s_numComps;
00506   static int                      s_whichComp;
00507 
00508 protected:
00509   void incrOpRegularAllDirs(Box * a_loBox,
00510                             Box * a_hiBox,
00511                             int * a_hasLo,
00512                             int * a_hasHi,
00513                             Box & a_curDblBox,
00514                             Box & a_curPhiBox,
00515                             int a_nComps,
00516                             BaseFab<Real> & a_curOpPhiFAB,
00517                             const BaseFab<Real> & a_curPhiFAB,
00518                             bool a_homogeneousPhysBC,
00519                             const DataIndex& a_dit);
00520 
00521   void applyDomainFlux(Box * a_loBox,
00522                        Box * a_hiBox,
00523                        int * a_hasLo,
00524                        int * a_hasHi,
00525                        Box & a_dblBox,
00526                        int a_nComps,
00527                        BaseFab<Real> & a_phiFAB,
00528                        bool a_homogeneousPhysBC,
00529                        const DataIndex& a_dit);
00530 
00531   void GSColorAllIrregular(EBCellFAB&                        a_phi,
00532                            const EBCellFAB&                  a_rhs,
00533                            const int&                        a_icolor,
00534                            const DataIndex&                  a_dit);
00535 
00536   static bool                     s_turnOffBCs;
00537   static bool                     s_forceNoEBCF;
00538   static IntVect                  s_ivDebug;
00539   void dumpFABPoint(const EBCellFAB& a_fab, const DataIndex& a_dit, const string& a_blab);
00540   void dumpLevelPoint(const LevelData<EBCellFAB>& a_res, const string& a_blab);
00541 
00542   virtual void calculateAlphaWeight();
00543   virtual void calculateRelaxationCoefficient();
00544 
00545   void defineColorStencils(Box a_ideBoxLo[SpaceDim],
00546                            Box a_ideBoxHi[SpaceDim]);
00547   //EBCF gymnastics
00548   void defineEBCFStencils();
00549   void getFluxEBCF(EBFaceFAB&                    a_flux,
00550                    const EBCellFAB&              a_phi,
00551                    const Box&                    a_ghostedBox,
00552                    Vector<FaceIndex>&            a_faceitEBCF,
00553                    Vector<VoFStencil>&           a_stenEBCF);
00554 
00555   void getFluxRegOnly(EBFaceFAB&                    a_fluxCentroid,
00556                       const EBCellFAB&              a_phi,
00557                       const Box&                    a_ghostedBox,
00558                       const Real&                   a_dx,
00559                       const DataIndex&              a_datInd,
00560                       const int&                    a_idir);
00561 
00562   //stuff to make EBCF go faster
00563   LayoutData< Vector<FaceIndex>  >   m_faceitCoar[2*SpaceDim];
00564   LayoutData< Vector<VoFStencil> >  m_stencilCoar[2*SpaceDim];
00565 
00566   //stuff to make relaxation go faster
00567   //not for the faint of heart
00568   LayoutData<VoFIterator >         m_vofItIrregColorDomLo[EBAMRPOVC_NUMSTEN][SpaceDim];
00569   LayoutData<VoFIterator >         m_vofItIrregColorDomHi[EBAMRPOVC_NUMSTEN][SpaceDim];
00570   LayoutData<BaseIVFAB<Real> >     m_cacheEBxDomainFluxLo[EBAMRPOVC_NUMSTEN][SpaceDim];
00571   LayoutData<BaseIVFAB<Real> >     m_cacheEBxDomainFluxHi[EBAMRPOVC_NUMSTEN][SpaceDim];
00572   LayoutData<RefCountedPtr<EBStencil> >  m_colorEBStencil[EBAMRPOVC_NUMSTEN];
00573 
00574 
00575 
00576   int                             m_relaxType;
00577   const IntVect                   m_ghostCellsPhi;
00578   const IntVect                   m_ghostCellsRHS;
00579 
00580   RefCountedPtr<EBQuadCFInterp>   m_quadCFIWithCoar;
00581 
00582   EBLevelGrid                     m_eblg;
00583   EBLevelGrid                     m_eblgFine;
00584   EBLevelGrid                     m_eblgCoar;
00585   EBLevelGrid                     m_eblgCoarMG;
00586   EBLevelGrid                     m_eblgCoarsenedFine;
00587 
00588   // RefCountedPtr<ConductivityBaseDomainBC>     m_domainBC;
00589   // RefCountedPtr<ConductivityBaseEBBC>         m_ebBC;
00590   RefCountedPtr<BaseDomainBC>     m_domainBC;
00591   RefCountedPtr<BaseEBBC>         m_ebBC;
00592 
00593   Real                            m_dxFine;
00594   Real                            m_dx;
00595   Real                            m_dxCoar;
00596 
00597   //! "Current" (time-interpolated) value of the a coefficient. For a
00598   //! time-independent a coefficient, this is where the coefficient lives.
00599   RefCountedPtr<LevelData<EBCellFAB> >          m_acoef;
00600 
00601   //! "Current" (time-interpolated) value of the b coefficient. For a
00602   //! time-independent a coefficient, this is where the coefficient lives.
00603   RefCountedPtr<LevelData<EBFluxFAB> >          m_bcoef;
00604 
00605   //! "Current" (time-interpolated) value of the b coefficient on irregular
00606   //! cells.
00607   RefCountedPtr<LevelData<BaseIVFAB<Real> > >   m_bcoIrreg;
00608 
00609   Real                            m_alpha;
00610   Real                            m_beta;
00611   //weights that get multiplied by alpha
00612   LayoutData<BaseIVFAB<Real> >       m_alphaDiagWeight;
00613   //weights that get multiplied by beta
00614   LayoutData<BaseIVFAB<Real> >       m_betaDiagWeight;
00615   int                             m_refToFine;
00616   int                             m_refToCoar;
00617   bool                            m_hasEBCF;
00618   bool                            m_hasFine;
00619   bool                            m_hasInterpAve;
00620   bool                            m_hasCoar;
00621 
00622   //restriction object
00623   EBMGAverage                    m_ebAverage;
00624   //prolongation object
00625   EBMGInterp                     m_ebInterp;
00626 
00627   //stencils for operator evaluation
00628   LayoutData<RefCountedPtr<EBStencil> >  m_opEBStencil;
00629   //stencils for operator evaluation on gauss-seidel colors
00630 
00631   //! Multigrid relaxation coefficient
00632   LevelData<EBCellFAB>       m_relCoef;
00633 
00634   //cache the vofiterators
00635   //for irregular cell iteration (includes buffer around multivalued cells)
00636   LayoutData<VoFIterator >                     m_vofIterIrreg;
00637   LayoutData<VoFIterator >                     m_vofIterMulti;
00638   //for domain boundary conditions at ir regular cells
00639   LayoutData<VoFIterator >                     m_vofIterDomLo[CH_SPACEDIM];
00640   LayoutData<VoFIterator >                     m_vofIterDomHi[CH_SPACEDIM];
00641 
00642 
00643   // Coarse-fine stencils for homogeneous CFInterp
00644   LayoutData<CFIVS> m_loCFIVS[SpaceDim];
00645   LayoutData<CFIVS> m_hiCFIVS[SpaceDim];
00646 
00647   //flux register with finer level
00648   EBFastFR       m_fastFR;
00649   //special mg objects for when we do not have
00650   //a coarser level or when the refinement to coarse
00651   //is greater than two
00652   //flag for when we need special MG objects
00653   bool                        m_hasMGObjects;
00654   bool                        m_layoutChanged;
00655   //stuff below is only defined if m_hasMGObjects==true
00656   EBMGAverage                 m_ebAverageMG;
00657   EBMGInterp                  m_ebInterpMG;
00658   DisjointBoxLayout           m_dblCoarMG;
00659   EBISLayout                  m_ebislCoarMG;
00660   ProblemDomain               m_domainCoarMG;
00661 
00662   Vector<IntVect> m_colors;
00663 
00664 private:
00665 
00666   void incrementFRCoar(EBFastFR&                   a_fluxReg,
00667                        const LevelData<EBCellFAB>& a_phiFine,
00668                        const LevelData<EBCellFAB>& a_phi);
00669 
00670   void incrementFRFine(EBFastFR&                   a_fluxReg,
00671                        const LevelData<EBCellFAB>& a_phiFine,
00672                        const LevelData<EBCellFAB>& a_phi,
00673                        AMRLevelOp<LevelData<EBCellFAB> >* a_finerOp);
00674 
00675   void getFlux(FArrayBox&                    a_flux,
00676                const FArrayBox&              a_phi,
00677                const Box&                    a_faceBox,
00678                const int&                    a_idir,
00679                const Real&                   a_dx,
00680                const DataIndex&              a_datInd);
00681 
00682 
00683 
00684   void applyCFBCs(LevelData<EBCellFAB>&             a_phi,
00685                   const LevelData<EBCellFAB>* const a_phiCoarse,
00686                   bool a_homogeneousCFBC);
00687 
00688   void getOpVoFStencil(VoFStencil&     a_stencil,
00689                        const EBISBox&  a_ebisbox,
00690                        const VolIndex& a_vof);
00691 
00692   void getOpVoFStencil(VoFStencil&             a_stencil,
00693                        const int&              a_dir,
00694                        const Vector<VolIndex>& a_allMonotoneVoFs,
00695                        const EBISBox&          a_ebisbox,
00696                        const VolIndex&         a_vof,
00697                        const bool&             a_lowOrder);
00698 
00699 
00700   void getOpFaceStencil(VoFStencil&             a_stencil,
00701                         const Vector<VolIndex>& a_allMonotoneVofs,
00702                         const EBISBox&          a_ebisbox,
00703                         const VolIndex&         a_vof,
00704                         int                     a_dir,
00705                         const Side::LoHiSide&   a_side,
00706                         const FaceIndex&        a_face,
00707                         const bool&             a_lowOrder);
00708 
00709   void levelJacobi(LevelData<EBCellFAB>&       a_phi,
00710                    const LevelData<EBCellFAB>& a_rhs);
00711 
00712   void applyHomogeneousCFBCs(LevelData<EBCellFAB>&   a_phi);
00713 
00714   void applyHomogeneousCFBCs(EBCellFAB&            a_phi,
00715                              const DataIndex&      a_datInd,
00716                              int                   a_idir,
00717                              Side::LoHiSide        a_hiorlo);
00718 private:
00719 
00720   //! Default constructor. Creates an undefined conductivity operator.
00721   EBConductivityOp();
00722 
00723   //copy constructor and operator= disallowed for all the usual reasons
00724   EBConductivityOp(const EBConductivityOp& a_opin)
00725   {
00726     MayDay::Error("invalid operator");
00727   }
00728 
00729   void operator=(const EBConductivityOp& a_opin)
00730   {
00731     MayDay::Error("invalid operator");
00732   }
00733 };
00734 
00735 
00736 #include "NamespaceFooter.H"
00737 #endif