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