Chombo + EB: NWOEBViscousTensorOp.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 _NWOEBVISCOUSTENSOROP_H_
00012 #define _NWOEBVISCOUSTENSOROP_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 "ViscousTensorOpF_F.H"
00023 #include "EBIndexSpace.H"
00024 #include "EBCellFAB.H"
00025 #include "EBCellFactory.H"
00026 
00027 #include "EBLevelDataOps.H"
00028 #include "BaseEBBC.H"
00029 #include "AMRTGA.H"
00030 #include "BaseDomainBC.H"
00031 #include "CFIVS.H"
00032 #include "EBFastFR.H"
00033 #include "EBMGAverage.H"
00034 #include "TimedDataIterator.H"
00035 #include "EBMGInterp.H"
00036 #include "EBTensorCFInterp.H"
00037 #include "EBCoarsen.H"
00038 #include "PolyGeom.H"
00039 #include "NWOEBQuadCFInterp.H"
00040 #include "EBLevelGrid.H"
00041 #include "EBAMRIO.H"
00042 #include "ViscousBaseDomainBC.H"
00043 #include "VCAggStencil.H"
00044 #include "DivergenceStencil.H"
00045 
00046 #include "NamespaceHeader.H"
00047 
00048 // Forward declaration.
00049 class NWOEBViscousTensorOp;
00050 
00051 //! \class NWOEBViscousTensorOp
00052 //! This class implements an operator that solves the equation
00053 //! alpha a I + (divF) = alpha a I + beta*div(eta(grad B + grad B^T) + lambda* I div B ) = rhs
00054 //! where beta, lambda,  and eta are incorporated into the flux F. It uses
00055 //! the AMRLevelOp interface.
00056 //class NWOEBViscousTensorOp: public AMRLevelOp<LevelData<EBCellFAB> >
00057 class NWOEBViscousTensorOp: public LevelTGAHelmOp<LevelData<EBCellFAB>, EBFluxFAB >
00058 {
00059 public:
00060 
00061   static int s_whichLev;
00062   static int s_step;
00063 
00064 
00065   //! Constructs a viscous tensor operator using the given data. This
00066   //! constructor is for time-independent a and b coefficients.
00067   NWOEBViscousTensorOp(const EBLevelGrid &                                a_eblgFine,
00068                        const EBLevelGrid &                                a_eblg,
00069                        const EBLevelGrid &                                a_eblgCoar,
00070                        const EBLevelGrid &                                a_eblgCoarMG,
00071                        const Real&                                        a_alpha,
00072                        const Real&                                        a_beta,
00073                        const RefCountedPtr<LevelData<EBCellFAB> >&        a_acoef,
00074                        const RefCountedPtr<LevelData<EBFluxFAB> >&        a_eta,
00075                        const RefCountedPtr<LevelData<EBFluxFAB> >&        a_lambda,
00076                        const RefCountedPtr<LevelData<BaseIVFAB<Real> > >& a_etaIrreg,
00077                        const RefCountedPtr<LevelData<BaseIVFAB<Real> > >& a_lambdaIrreg,
00078                        const Real&                                        a_dx,
00079                        const Real&                                        a_dxCoar,
00080                        const int&                                         a_refToFine,
00081                        const int&                                         a_refToCoar,
00082                        const RefCountedPtr<ViscousBaseDomainBC>&          a_domainBC,
00083                        const RefCountedPtr<ViscousBaseEBBC>&              a_ebBC,
00084                        const bool&                                        a_hasMGObjects,
00085                        const IntVect&                                     a_ghostPhi,
00086                        const IntVect&                                     a_ghostRHS);
00087 
00088 
00089   ///
00090   /**
00091      minimal define.   ONLY for load balancing purposes (only capable of applying the calling timed relax)
00092      alpha = 1, beta = -1.  coeffs set to constants.  dx forced to 1.0.
00093      BCs left in there because that can affect stencils.
00094   */
00095   NWOEBViscousTensorOp(const EBLevelGrid &                                a_eblg,
00096                        const Real&                                        a_alpha,
00097                        const Real&                                        a_beta,
00098                        const RefCountedPtr<LevelData<EBCellFAB> >&        a_acoef,
00099                        const RefCountedPtr<LevelData<EBFluxFAB> >&        a_eta,
00100                        const RefCountedPtr<LevelData<EBFluxFAB> >&        a_lambda,
00101                        const RefCountedPtr<LevelData<BaseIVFAB<Real> > >& a_etaIrreg,
00102                        const RefCountedPtr<LevelData<BaseIVFAB<Real> > >& a_lambdaIrreg,
00103                        const Real&                                        a_dx,
00104                        const RefCountedPtr<ViscousBaseDomainBC>&          a_domainBC,
00105                        const RefCountedPtr<ViscousBaseEBBC>&              a_ebBC,
00106                        const IntVect&                                     a_ghostPhi,
00107                        const IntVect&                                     a_ghostRHS);
00108 
00109   //this is for load balancing.
00110   void
00111   relaxTimed(LevelData<EBCellFAB>&            a_phi,
00112              const LevelData<EBCellFAB>&      a_rhs,
00113              TimedDataIterator         &      a_dit,
00114              int                              a_iterations);
00115 
00116                     
00117   //! Destructor.
00118   virtual ~NWOEBViscousTensorOp();
00119 
00120   ///for tga to reset stuff
00121   virtual void setAlphaAndBeta(const Real& a_alpha,
00122                                const Real& a_beta);
00123 
00124 #ifdef CH_USE_HDF5
00125   virtual void outputLevel(LevelData<EBCellFAB>& a_rhs, string& a_name)
00126   {
00127     char filename[1024];
00128     sprintf(filename, "%s.ebvto.step%d.lev.%d.hdf5",a_name.c_str(), s_step, s_whichLev );
00129     writeEBLevelname(&a_rhs, filename);
00130   }
00131 
00132 
00133   virtual void outputAMR(Vector< LevelData<EBCellFAB>* >& a_rhs, string& a_name)
00134   {
00135     char filename[1024];
00136     sprintf(filename, "%s.ebvto.step%d.lev.%d.hdf5", a_name.c_str(), s_step, s_whichLev );
00137     writeEBAMRname(&a_rhs, filename);
00138   }
00139 #endif
00140 
00141   ///it's tga's world---we just live in it.
00142   virtual void kappaScale(LevelData<EBCellFAB> & a_rhs)
00143   {
00144     EBLevelDataOps::kappaWeight(a_rhs);
00145   }
00146 
00147   /// compute (tau dot grad u) (for energy equation)
00148   void getShearStressDotGradU(LevelData<EBCellFAB>      & a_source,
00149                               const LevelData<EBCellFAB>& a_gradU,
00150                               int a_level);
00151 
00152   /// compute volfrac(sigma dot grad u) (for energy equation)
00153   void getKappaDivSigmaU(LevelData<EBCellFAB>      & a_divSigmaU,
00154                          const LevelData<EBCellFAB>& a_velocity,
00155                          const LevelData<EBCellFAB>* a_veloCoar,
00156                          int a_level);
00157 
00158   //average surrounding coeffcients onto faces (simple averages)
00159   void getCellCenteredCoefficients(LevelData<EBCellFAB>&    a_etaCell,
00160                                    LevelData<EBCellFAB>& a_lambdaCell);
00161 
00162   //get stress at cell centers given gradient of velocity
00163   void getCCSigma(LevelData<EBCellFAB>      & a_source,
00164                   const LevelData<EBCellFAB>& a_gradU,
00165                   const LevelData<EBCellFAB>& a_eta,
00166                   const LevelData<EBCellFAB>& a_lambda);
00167   ///another tgaism
00168   virtual void diagonalScale(LevelData<EBCellFAB> & a_rhs,
00169                              bool a_kappaWeighted)
00170   {
00171     if (a_kappaWeighted)
00172       EBLevelDataOps::kappaWeight(a_rhs);
00173     for (DataIterator dit = m_eblg.getDBL().dataIterator(); dit.ok(); ++dit)
00174       {
00175         for (int idir = 0; idir < SpaceDim; idir++)
00176           {
00177             int isrc = 0; int idst = idir; int inco = 1;
00178             a_rhs[dit()].mult((*m_acoef)[dit()], isrc, idst, inco);
00179           }
00180       }
00181   }
00182 
00183   virtual void divideByIdentityCoef(LevelData<EBCellFAB> & a_rhs)
00184   {
00185     for (DataIterator dit = m_eblg.getDBL().dataIterator(); dit.ok(); ++dit)
00186       {
00187         for (int idir = 0; idir < SpaceDim; idir++)
00188           {
00189             int isrc = 0; int idst = idir; int inco = 1;
00190             a_rhs[dit()].divide((*m_acoef)[dit()], isrc, idst, inco);
00191           }
00192       }
00193   }
00194 
00195   ///a leveltgaism
00196   virtual void fillGrad(const LevelData<EBCellFAB>& a_phi)
00197   {
00198     //this is a weird artifact of how this was previously implemented
00199   }
00200 
00201   ///another leveltgaism
00202   virtual void getFlux(EBFluxFAB&                    a_flux,
00203                        const LevelData<EBCellFAB>&   a_data,
00204                        const Box&                    a_grid,
00205                        const DataIndex&              a_dit,
00206                        Real                          a_scale);
00207 
00208   void getVelDotSigma(LevelData<EBFluxFAB>      & a_velDotSigma,
00209                       const LevelData<EBFluxFAB>& a_vel,
00210                       const LevelData<EBFluxFAB>& a_sigma);
00211 
00212   void getFlux(EBFaceFAB&                    a_fluxCentroid,
00213                const EBCellFAB&              a_phi,
00214                const Box&                    a_ghostedBox,
00215                const Box&                    a_fabBox,
00216                const ProblemDomain&          a_domain,
00217                const EBISBox&                a_ebisBox,
00218                const Real&                   a_dx,
00219                const DataIndex&              a_datInd,
00220                const int&                    a_idir);
00221 
00222   // This operator may be time-dependent.
00223   void setTime(Real a_oldTime, Real a_mu, Real a_dt);
00224 
00225   /// apply operator without any boundary or coarse-fine boundary conditions and no finer level
00226 
00227   virtual void applyOpNoBoundary(LevelData<EBCellFAB>&       a_opPhi,
00228                                  const LevelData<EBCellFAB>& a_phi)
00229   {
00230     s_turnOffBCs = true;
00231     applyOp(a_opPhi, a_phi, true);
00232     s_turnOffBCs = false;
00233   }
00234 
00235 
00236   //functions used by the wider world
00237 
00238   ///
00239   /** a_residual = a_rhs - L(a_phiFine, a_phi)   no coaser AMR level*/
00240   void AMRResidualNC(LevelData<EBCellFAB>&       a_residual,
00241                      const LevelData<EBCellFAB>& a_phiFine,
00242                      const LevelData<EBCellFAB>& a_phi,
00243                      const LevelData<EBCellFAB>& a_rhs,
00244                      bool a_homogeneousBC,
00245                      AMRLevelOp<LevelData<EBCellFAB> >* a_finerOp);
00246 
00247 
00248   ///
00249   /** apply AMR operator   no coaser AMR level*/
00250   void AMROperatorNC(LevelData<EBCellFAB>&       a_LofPhi,
00251                      const LevelData<EBCellFAB>& a_phiFine,
00252                      const LevelData<EBCellFAB>& a_phi,
00253                      bool a_homogeneousBC,
00254                      AMRLevelOp<LevelData<EBCellFAB> >* a_finerOp);
00255 
00256   ///
00257   /**
00258    */
00259   virtual void residual(LevelData<EBCellFAB>&       a_residual,
00260                         const LevelData<EBCellFAB>& a_phi,
00261                         const LevelData<EBCellFAB>& a_rhs,
00262                         bool                        a_homogeneousPhysBC=false);
00263 
00264   ///
00265   /**
00266    */
00267   virtual void preCond(LevelData<EBCellFAB>&       a_opPhi,
00268                        const LevelData<EBCellFAB>& a_phi);
00269 
00270 
00271   ///
00272   /**
00273    */
00274   virtual void applyOp(LevelData<EBCellFAB>&             a_opPhi,
00275                        const LevelData<EBCellFAB>&       a_phi,
00276                        bool                              a_homogeneousPhysBC);
00277 
00278   
00279   ///
00280   /**
00281    */
00282   virtual void create(LevelData<EBCellFAB>&       a_lhs,
00283                       const LevelData<EBCellFAB>& a_rhs);
00284 
00285   ///
00286   virtual void createCoarsened(LevelData<EBCellFAB>&       a_lhs,
00287                                const LevelData<EBCellFAB>& a_rhs,
00288                                const int&                  a_refRat);
00289 
00290   ///
00291   Real
00292   AMRNorm(const LevelData<EBCellFAB>& a_coarResid,
00293           const LevelData<EBCellFAB>& a_fineResid,
00294           const int& a_refRat,
00295           const int& a_ord);
00296 
00297 
00298   ///
00299   /**
00300    */
00301   virtual void assign(LevelData<EBCellFAB>&       a_lhs,
00302                       const LevelData<EBCellFAB>& a_rhs);
00303 
00304   ///
00305   /**
00306    */
00307   virtual Real dotProduct(const LevelData<EBCellFAB>& a_1,
00308                           const LevelData<EBCellFAB>& a_2);
00309 
00310   ///
00311   /**
00312    */
00313   virtual void incr(LevelData<EBCellFAB>&       a_lhs,
00314                     const LevelData<EBCellFAB>& a_x,
00315                     Real                        a_scale);
00316 
00317   ///
00318   /**
00319    */
00320   virtual void axby(LevelData<EBCellFAB>&       a_lhs,
00321                     const LevelData<EBCellFAB>& a_x,
00322                     const LevelData<EBCellFAB>& a_y,
00323                     Real                        a_a,
00324                     Real                        a_b);
00325 
00326   ///
00327   /**
00328    */
00329   virtual void scale(LevelData<EBCellFAB>& a_lhs,
00330                      const Real&           a_scale);
00331 
00332   ///
00333   /**
00334    */
00335   virtual Real norm(const LevelData<EBCellFAB>& a_rhs,
00336                     int                         a_ord);
00337 
00338   static Real staticMaxNorm(const LevelData<EBCellFAB>& a_rhs, const EBLevelGrid& a_eblg);
00339 
00340   virtual Real localMaxNorm(const LevelData<EBCellFAB>& a_rhs);
00341   ///
00342   /**
00343    */
00344   virtual void setToZero(LevelData<EBCellFAB>& a_lhs);
00345 
00346   ///
00347   /**
00348    */
00349   virtual void setVal(LevelData<EBCellFAB>& a_lhs, const Real& a_value);
00350 
00351   ///
00352   /**
00353    */
00354   virtual void createCoarser(LevelData<EBCellFAB>&       a_coarse,
00355                              const LevelData<EBCellFAB>& a_fine,
00356                              bool                        a_ghosted);
00357 
00358   ///
00359   /**
00360    */
00361   virtual void relax(LevelData<EBCellFAB>&       a_e,
00362                      const LevelData<EBCellFAB>& a_residual,
00363                      int                         a_iterations);
00364 
00365   ///
00366   /**
00367      This does not work anymore because acoef is now wrapped in the stencil
00368      void resetACoefficient(RefCountedPtr<LevelData<EBCellFAB> >& a_acoef)
00369      {
00370      m_acoef = a_acoef;
00371      calculateAlphaWeight();
00372      calculateRelaxationCoefficient();
00373      }
00374   */
00375 
00376   ///
00377   /**
00378      Calculate restricted residual:
00379      a_resCoarse[2h] = I[h->2h] (a_rhsFine[h] - L[h](a_phiFine[h]))
00380   */
00381   virtual void restrictResidual(LevelData<EBCellFAB>&       a_resCoarse,
00382                                 LevelData<EBCellFAB>&       a_phiFine,
00383                                 const LevelData<EBCellFAB>& a_rhsFine);
00384 
00385   ///
00386   /**
00387      Correct the fine solution based on coarse correction:
00388      a_phiThisLevel += I[2h->h] (a_correctCoarse)
00389   */
00390   virtual void prolongIncrement(LevelData<EBCellFAB>&       a_phiThisLevel,
00391                                 const LevelData<EBCellFAB>& a_correctCoarse);
00392 
00393   ///
00394   /** Refinement ratio between this level and coarser level.
00395       Returns 1 when there are no coarser AMRLevelOp objects */
00396   virtual int refToCoarser();
00397 
00398   ///
00399   /** Refinement ratio between this level and coarser level.
00400       Returns 1 when there are no coarser AMRLevelOp objects */
00401   virtual int refToFiner();
00402 
00403   ///
00404   /** a_residual = a_rhs - L(a_phi, a_phiFine, a_phiCoarse) */
00405   virtual void AMRResidual(LevelData<EBCellFAB>& a_residual,
00406                            const LevelData<EBCellFAB>& a_phiFine,
00407                            const LevelData<EBCellFAB>& a_phi,
00408                            const LevelData<EBCellFAB>& a_phiCoarse,
00409                            const LevelData<EBCellFAB>& a_rhs,
00410                            bool a_homogeneousBC,
00411                            AMRLevelOp<LevelData<EBCellFAB> >* a_finerOp);
00412 
00413   ///
00414   /** a_residual = a_rhs - L(a_phi, a_phiCoarse)  */
00415   virtual void AMRResidualNF(LevelData<EBCellFAB>& a_residual,
00416                              const LevelData<EBCellFAB>& a_phi,
00417                              const LevelData<EBCellFAB>& a_phiCoarse,
00418                              const LevelData<EBCellFAB>& a_rhs,
00419                              bool a_homogeneousBC);
00420 
00421 
00422   ///
00423   /** a_residual = a_rhs - L(a_phi, a_phiFine, a_phiCoarse) */
00424   virtual void AMROperator(LevelData<EBCellFAB>& a_LofPhi,
00425                            const LevelData<EBCellFAB>& a_phiFine,
00426                            const LevelData<EBCellFAB>& a_phi,
00427                            const LevelData<EBCellFAB>& a_phiCoarse,
00428                            bool a_homogeneousBC,
00429                            AMRLevelOp<LevelData<EBCellFAB> >* a_finerOp);
00430 
00431   ///
00432   /** a_residual = a_rhs - L(a_phi, a_phiCoarse)  */
00433   virtual void AMROperatorNF(LevelData<EBCellFAB>& a_LofPhi,
00434                              const LevelData<EBCellFAB>& a_phi,
00435                              const LevelData<EBCellFAB>& a_phiCoarse,
00436                              bool a_homogeneousBC);
00437 
00438   ///
00439   /** a_resCoarse = I[h-2h] (a_residual - L(a_correction, a_coarseCorrection)) */
00440   virtual void AMRRestrict(LevelData<EBCellFAB>& a_resCoarse,
00441                            const LevelData<EBCellFAB>& a_residual,
00442                            const LevelData<EBCellFAB>& a_correction,
00443                            const LevelData<EBCellFAB>& a_coarseCorrection, 
00444                            bool a_skip_res = false );
00445 
00446   ///
00447   /** a_correction += I[2h->h](a_coarseCorrection) */
00448   virtual void AMRProlong(LevelData<EBCellFAB>&       a_correction,
00449                           const LevelData<EBCellFAB>& a_coarseCorrection);
00450 
00451   ///
00452   /** a_residual = a_residual - L(a_correction, a_coarseCorrection) */
00453   virtual void AMRUpdateResidual(LevelData<EBCellFAB>&       a_residual,
00454                                  const LevelData<EBCellFAB>& a_correction,
00455                                  const LevelData<EBCellFAB>& a_coarseCorrection);
00456 
00457   ///static for code reuse in bcs
00458   static void 
00459   getFaceCenteredFluxStencil(VoFStencil                                & a_fluxStencil,
00460                              const RefCountedPtr<LevelData<EBFluxFAB> >& a_eta,
00461                              const RefCountedPtr<LevelData<EBFluxFAB> >& a_lambda,
00462                              const Real                                & a_dx,
00463                              const EBLevelGrid                         & a_eblg,
00464                              const FaceIndex                           & a_face,
00465                              const DataIndex                           & a_dit,
00466                              int a_ivar);
00467 
00468   ///static for code reuse in bcs
00469   static void 
00470   getFluxStencil(VoFStencil                                & a_fluxStencil,
00471                  const RefCountedPtr<LevelData<EBFluxFAB> >& a_eta,
00472                  const RefCountedPtr<LevelData<EBFluxFAB> >& a_lambda,
00473                  const Real                                & a_dx,
00474                  const EBLevelGrid                         & a_eblg,
00475                  const FaceIndex                           & a_face,
00476                  const DataIndex                           & a_dit,
00477                  int a_ivar);
00478 
00479   ///static for code reuse in bcs
00480   static void
00481   getDivergenceStencil(VoFStencil&      a_divStencil,
00482                        const FaceIndex& a_face,
00483                        const DataIndex& a_dit,
00484                        const Real     & a_dx,
00485                        const EBLevelGrid& a_eblg);
00486 
00487   ///static for code reuse in bcs
00488   static void
00489   getGradientStencil(VoFStencil&  a_gradStencil,
00490                      int a_ivar,
00491                      int a_diffDir,
00492                      const FaceIndex& a_face,
00493                      const DataIndex& a_dit,
00494                      const Real     & a_dx,
00495                      const EBLevelGrid& a_eblg);
00496 
00497   ///
00498   static void doLazyRelax(bool a_doLazyRelax)
00499   {
00500     s_doLazyRelax = a_doLazyRelax;
00501   }
00502   static void setForceNoEBCF(bool a_forceNoEBCF)
00503   {
00504     s_forceNoEBCF = a_forceNoEBCF;
00505   }
00506 
00507   //! (Re)define the stencils for the given coefficients.
00508   void defineStencils();
00509   void defineStencilsForTimingOnly();
00510 
00511 protected:
00512 
00513   //internal functions not usable without significant context
00514 
00515   void applyOpIrregular(EBCellFAB&             a_lhs,
00516                         const EBCellFAB&       a_phi,
00517                         const bool&            a_homogeneous,
00518                         const DataIndex&       a_datInd);
00519 
00520 
00521   void applyOpRegular(  EBCellFAB&             a_lhs,
00522                         const EBCellFAB&       a_phi,
00523                         const bool&            a_homogeneous,
00524                         const DataIndex&       a_datInd);
00525 
00526   void getFlux(FArrayBox&                    a_flux,
00527                const FArrayBox&              a_phi,
00528                const Box&                    a_faceBox,
00529                const int&                    a_idir,
00530                const DataIndex&              a_datInd);
00531   void
00532   cfinterp(const LevelData<EBCellFAB>&       a_phi,
00533            const LevelData<EBCellFAB>&       a_phiCoarse);
00534 
00535   void reflux(const LevelData<EBCellFAB>& a_phiFine,
00536               const LevelData<EBCellFAB>& a_phi,
00537               LevelData<EBCellFAB>& residual,
00538               AMRLevelOp<LevelData<EBCellFAB> >* a_finerOp);
00539 
00540   void homogeneousCFInterp(LevelData<EBCellFAB>&   a_phi);
00541 
00542   void getVoFStencil(VoFStencil&      a_vofStencil,
00543                      const VolIndex&  a_vof,
00544                      const DataIndex& a_dit,
00545                      int              a_ivar);
00546 
00547   void getDivergenceStencil(VoFStencil&  a_gradStencil,
00548                             const FaceIndex& a_face,
00549                             const DataIndex& a_dit);
00550 
00551   void getGradientStencil(VoFStencil&  a_gradStencil,
00552                           int a_ivar,
00553                           int a_diffDir,
00554                           const FaceIndex& a_face,
00555                           const DataIndex& a_dit);
00556 
00557 
00558   void gsrbColor(LevelData<EBCellFAB>&       a_phi,
00559                  const LevelData<EBCellFAB>& a_rhs,
00560                  const IntVect&              a_color);
00561 
00562   void gsrbColorTimed(LevelData<EBCellFAB>       & a_phi,
00563                       const LevelData<EBCellFAB> & a_rhs,
00564                       const IntVect              & a_color,
00565                       TimedDataIterator          & a_dit);
00566 
00567 
00568   void
00569   fillVelGhost(const EBCellFAB& a_phi, const DataIndex& a_datInd, bool a_homog) const;
00570   void
00571   fillVelGhost(const LevelData<EBCellFAB>& a_phi, bool a_homog) const;
00572 
00573   void
00574   fillVelGhostTimed(const LevelData<EBCellFAB>& a_phi, bool a_homog, TimedDataIterator& a_dit) const;
00575 
00576   void getFaceCenteredFluxStencil(VoFStencil&      a_fluxStencil,
00577                                   const FaceIndex& a_face,
00578                                   const DataIndex& a_dit,
00579                                   int a_ivar);
00580 
00581   void
00582   incrementFRCoar(EBFastFR& a_fr,
00583                   const LevelData<EBCellFAB>& a_phiFine,
00584                   const LevelData<EBCellFAB>& a_phi);
00585 
00586   //simple averaging
00587   void
00588   averageToCells(LevelData<EBCellFAB>&      a_cellCoef,
00589                  const LevelData<EBFluxFAB>& a_faceCoef,
00590                  const LevelData<BaseIVFAB<Real> >& a_irregCoef);
00591 
00592   void
00593   incrementFRFine(EBFastFR& a_fr,
00594                   const LevelData<EBCellFAB>& a_phiFine,
00595                   const LevelData<EBCellFAB>& a_phi,
00596                   AMRLevelOp<LevelData<EBCellFAB> >* a_finerOp);
00597 
00598   //member data, bloated though it may be
00599   static bool s_turnOffBCs;
00600   static bool s_forceNoEBCF;
00601 
00602   static bool s_doLazyRelax;
00603   //locations of coarse fine interfaces
00604   LayoutData<RefCountedPtr<DivergenceStencil> >     m_divergenceStencil;
00605 
00606 
00607   //grid information
00608   EBLevelGrid                                  m_eblgFine;
00609   EBLevelGrid                                  m_eblg;
00610   EBLevelGrid                                  m_eblgCoar;
00611   EBLevelGrid                                  m_eblgCoarMG;
00612 
00613   //operator coefficients
00614   Real                                         m_alpha;
00615   Real                                         m_beta;
00616   //weights that get multiplied by alpha
00617   LayoutData<BaseIVFAB<Real> >       m_alphaDiagWeight;
00618   //weights that get multiplied by beta
00619   LayoutData<BaseIVFAB<Real> >       m_betaDiagWeight;
00620 
00621   //! "Current" (time-interpolated) value of the a coefficient. For a
00622   //! time-independent a coefficient, this is where the coefficient lives.
00623   RefCountedPtr<LevelData<EBCellFAB> >         m_acoef;
00624 
00625   RefCountedPtr<LevelData<EBFluxFAB> >         m_eta;
00626   RefCountedPtr<LevelData<EBFluxFAB> >         m_lambda;
00627   RefCountedPtr<LevelData<BaseIVFAB<Real> > >  m_etaIrreg;
00628   RefCountedPtr<LevelData<BaseIVFAB<Real> > >  m_lambdaIrreg;
00629 
00630 
00631   //flux register with finer level
00632   EBFastFR                                     m_fastFR;
00633 
00634   //grid spacing
00635   //dxcoar not implied by ref ratio--we could be in some MG level where dx > dxcoar
00636   //needed for homogeneous cf interp
00637   Real                                         m_dx;
00638   Real                                         m_dxCoar;
00639   Real getSafety();
00640   virtual void calculateAlphaWeight();
00641   virtual void calculateRelaxationCoefficient();
00642 
00643   //refinement ratios and whether this object has multigrid objects
00644   bool                                         m_hasFine;
00645   bool                                         m_hasCoar;
00646   int                                          m_refToFine;
00647   int                                          m_refToCoar;
00648   bool                                         m_hasMGObjects;
00649 
00650   IntVect                                      m_ghostPhi;
00651   IntVect                                      m_ghostRHS;
00652 
00653   //stencil to apply irregular operator and do irregular relaxation
00654   LayoutData<RefCountedPtr<VCAggStencil> >     m_opEBStencil[CH_SPACEDIM];
00655 
00656   //relaxation coefficent
00657   LevelData<EBCellFAB>                         m_relCoef;
00658 
00659   LayoutData<VoFIterator >                     m_vofIterIrreg;
00660   LayoutData<VoFIterator >                     m_vofIterMulti;
00661   //for domain boundary conditions at ir regular cells
00662   LayoutData<VoFIterator >                     m_vofIterDomLo[CH_SPACEDIM];
00663   LayoutData<VoFIterator >                     m_vofIterDomHi[CH_SPACEDIM];
00664 
00665   //for inhomogeneous cf interpolation
00666   RefCountedPtr<NWOEBQuadCFInterp>             m_interpWithCoarser;
00667 
00668   //averaging operators
00669   EBMGAverage                                  m_ebAverage;
00670   EBMGAverage                                  m_ebAverageMG;
00671 
00672   //interpolation operators
00673   EBMGInterp                                   m_ebInterp;
00674   EBMGInterp                                   m_ebInterpMG;
00675 
00676   //boundary condition operators
00677   RefCountedPtr<ViscousBaseDomainBC>           m_domainBC;
00678   RefCountedPtr<ViscousBaseEBBC>               m_ebBC;
00679   Vector<IntVect>                              m_colors;
00680   Copier                          m_exchangeCopier;
00681 
00682   //scrounged from EBLevelDataOps for performance reasons
00683   void
00684   averageCellToFace(EBFaceFAB           &      a_fluxData,
00685                     const EBCellFAB     &      a_cellData,
00686                     const Box           &      a_grid,
00687                     const EBISBox       &      a_ebisBox,
00688                     const ProblemDomain &      a_domain,
00689                     const DataIndex& a_dit,
00690                     int isrc, int idst, int inco,
00691                     bool a_interpolateToCentroid);
00692 
00693 
00694   //scrounged from EBLevelDataOps for performance reasons
00695   void
00696   averageCellToFace(LevelData<EBFluxFAB>&         a_fluxData,
00697                     const LevelData<EBCellFAB>&   a_cellData,
00698                     const DisjointBoxLayout&      a_grids,
00699                     const EBISLayout&             a_ebisl,
00700                     const ProblemDomain&          a_domain,
00701                     int isrc, int idst, int inco,
00702                     bool a_interpolateToCentroid);
00703 
00704   
00705   //scrounged from EBLevelDataOps for performance reasons
00706   void
00707   faceCenteredAverageCellsToFaces(EBFaceFAB           &      a_faceData,
00708                                   const EBCellFAB     &      a_cellData,
00709                                   const Box           &      ccFluxBox,
00710                                   const EBISBox       &      a_ebisBox,
00711                                   const ProblemDomain &      a_domain,
00712                                   const DataIndex& a_dit,
00713                                   int isrc, int idst, int inco);
00714 
00715   LayoutData<IntVectSet> m_ivsIrregCCFlux;
00716 
00717   bool m_operatorForTimingOnly;
00718 private:
00719   ///weak construction is bad
00720   NWOEBViscousTensorOp()
00721   {
00722     MayDay::Error("invalid operator");
00723   }
00724 
00725   //copy constructor and operator= disallowed for all the usual reasons
00726   NWOEBViscousTensorOp(const NWOEBViscousTensorOp& a_opin)
00727   {
00728     MayDay::Error("invalid operator");
00729   }
00730 
00731   void operator=(const NWOEBViscousTensorOp& a_opin)
00732   {
00733     MayDay::Error("invalid operator");
00734   }
00735 };
00736 
00737 
00738 #include "NamespaceFooter.H"
00739 #endif