Chombo + EB + MF: EBArith.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 _EBARITH_H_
00012 #define _EBARITH_H_
00013 
00014 #include <fstream>
00015 
00016 #include "EBCellFAB.H"
00017 #include "EBISBox.H"
00018 #include "EBISLayout.H"
00019 #include "EBFaceFAB.H"
00020 #include "BoxLayout.H"
00021 #include "BoxLayoutData.H"
00022 #include "Stencils.H"
00023 #include "LayoutData.H"
00024 #include "Tuple.H"
00025 #include "EBFluxFAB.H"
00026 #include "EBCellFAB.H"
00027 #include "NamespaceHeader.H"
00028 ///
00029 /**
00030    enumeration class to ennumerate the different
00031    extents of norm covereage. sometimes one
00032    wants to only take a norm over the irregular
00033    cells.  sometimes one only wants to take a norm
00034    over the regular cells, and sometimes one wants
00035    both.
00036  */
00037 class EBNormType
00038 {
00039 public:
00040 
00041   ///
00042   /**
00043      OverOnlyRegular means take the norm only over
00044      regular cells. \\
00045      OverOnlyirregular means take the norm only over
00046      irregular cells. \\
00047      OverBoth means use all uncovered cells. \\
00048      All norms exclude covered cells.
00049    */
00050   enum  NormMode
00051   {
00052     OverOnlyRegular=0,
00053     OverOnlyIrregular,
00054     OverBoth
00055   };
00056 };
00057 
00058 ///
00059 /**
00060    class to encapsulate the common arithmatic operations
00061    for ebfabs
00062  */
00063 class EBArith
00064 {
00065 public:
00066 
00067   ///
00068   /**
00069      Gets the stencil to take the first derivative of  cell centered data.
00070      no high order one sided stuff (to keep stencil close)
00071   */
00072   static int
00073   getFirstDerivStencilWidthOne(VoFStencil&      a_sten,
00074                                const VolIndex&  a_vof,
00075                                const EBISBox&   a_ebisBox,
00076                                const int&       a_idir,
00077                                const Real&      a_dx,
00078                                IntVectSet*    a_cfivsPtr,
00079                                int ivar);
00080 
00081   ///
00082   /**
00083      Least square sten using all cells in a monotone path of radius a_rad
00084    */
00085   static void
00086   getLeastSquaresGradStenAllVoFsRad(VoFStencil&          a_stencil,
00087                                     Real&                a_weight,
00088                                     const RealVect&      a_normal,
00089                                     const RealVect&      a_centroid,
00090                                     const VolIndex&      a_vof,
00091                                     const EBISBox&       a_ebisBox,
00092                                     const RealVect&      a_dx,
00093                                     const ProblemDomain& a_domain,
00094                                     int                  a_ivar,
00095                                     int                  a_rad);
00096 
00097   static int
00098   getFirstOrderExtrapolationStencil(VoFStencil&     a_stencil,
00099                                     const RealVect& a_dist,
00100                                     const RealVect& a_dx,
00101                                     const VolIndex& a_startVoF,
00102                                     const EBISBox&  a_ebisBox,
00103                                     int a_noExtrapThisDir,
00104                                     IntVectSet*    a_cfivsPtr,
00105                                     int ivar);
00106   ///
00107   /**
00108    */
00109   static int orderScript(int icomp, int inorm, int ncomp);
00110 
00111   ///
00112   /**
00113    */
00114   static void
00115   compareError(Vector<Real>&                            a_orders,
00116                const Vector< LevelData<EBCellFAB>* >&   a_errorFine,
00117                const Vector< LevelData<EBCellFAB>* >&   a_errorCoar,
00118                const Vector< DisjointBoxLayout >&       a_gridsFine,
00119                const Vector< DisjointBoxLayout >&       a_gridsCoar,
00120                const Vector< EBISLayout >&              a_ebislFine,
00121                const Vector< EBISLayout >&              a_ebislCoar,
00122                const Vector<int>&                       a_refRat,
00123                const Box&                               a_coarseDom,
00124                int                                      a_testverbosity,
00125                fstream*                                 a_fout = NULL,
00126                Vector<string> names = Vector<string>());
00127 
00128   ///
00129   static void shrinkIVS(IntVectSet& a_ivs, const int& a_numShrink);
00130 
00131   static void
00132   timeInterpolate(LevelData<EBCellFAB>&       a_U,
00133                   const LevelData<EBCellFAB>& a_UOld,
00134                   const LevelData<EBCellFAB>& a_UNew,
00135                   const DisjointBoxLayout&    a_grids,
00136                   const Real&                 a_time,
00137                   const Real&                 a_told,
00138                   const Real&                 a_tnew);
00139   ///
00140   static Real
00141   getDiagWeight(  VoFStencil&     a_vofStencil,
00142                   const VolIndex& a_vof,
00143                   int a_var = 0);
00144 
00145   ///
00146   static void getMultiColors(Vector<IntVect>& a_colors);
00147 
00148   ///
00149   static void
00150   interpolateCFH(EBCellFAB&                  a_phi,
00151                  const int  &                a_idir,
00152                  const Side::LoHiSide&       a_hiorlo,
00153                  const EBISBox&              a_ebisBox,
00154                  const Real&                 a_dxfine,
00155                  const Real&                 a_dxcoar,
00156                  const IntVectSet&           a_interpIVS);
00157 
00158   ///
00159   /**
00160      returns the order of the extrapolation.
00161      the reason for the last argument is that you might not want the stencil
00162      to leak over in the noExtrap direction even though you have set a_dist to zero.
00163      This happens in CF interpolation where you have to really worry about stencil width.
00164    **/
00165   static int
00166   getExtrapolationStencil(VoFStencil&     a_stencil,
00167                           const RealVect& a_dist,
00168                           const RealVect& a_dx,
00169                           const VolIndex& a_startVoF,
00170                           const EBISBox&  a_ebisBox,
00171                           int a_noExtrapThisDirection = -1,
00172                           IntVectSet*    a_cfivsPtr = NULL,
00173                           int ivar = 0);
00174 
00175   ///
00176   /**
00177      returns the order of the extrapolation.
00178      the reason for the last argument is that you might not want the stencil
00179      to leak over in the noExtrap direction even though you have set a_dist to zero.
00180      This happens in CF interpolation where you have to really worry about stencil width.
00181    **/
00182   static int
00183   get1stOrderExtrapolationStencil(VoFStencil&     a_stencil,
00184                                   const RealVect& a_dist,
00185                                   const RealVect& a_dx,
00186                                   const VolIndex& a_startVoF,
00187                                   const EBISBox&  a_ebisBox,
00188                                   int a_noExtrapThisDirection = -1,
00189                                   IntVectSet*    a_cfivsPtr = NULL,
00190                                   int ivar = 0);
00191 
00192   ///
00193   /**
00194    **/
00195   static void
00196   getDir1Dir2(int& a_dir1, int& a_dir2, const int& a_dir);
00197 
00198   ///
00199   /**
00200      send null ivs if you do not want lohicenter to care about cfivs
00201    **/
00202   static void
00203   loHiCenter(Box&                 a_loBox,
00204              int&                 a_hasLo,
00205              Box&                 a_hiBox,
00206              int&                 a_hasHi,
00207              Box&                 a_centerBox,
00208              const ProblemDomain  &   a_eblg,
00209              const Box&           a_inBox,
00210              const int&           a_dir,
00211              IntVectSet*    a_cfivsPtr = NULL);
00212 
00213   ///
00214   /**
00215    **/
00216   static void
00217   loHi(Box&                 a_loBox,
00218        int&                 a_hasLo,
00219        Box&                 a_hiBox,
00220        int&                 a_hasHi,
00221        const ProblemDomain& a_eblg,
00222        const Box&           a_inBox,
00223        const int&           a_dir);
00224 
00225   ///
00226   /**
00227      testRef is the size of the coarsest domain allowed in multigrid. If testRef=2,
00228      then the coarsest domain in multigrid will be 2x2(x2)
00229    **/
00230   static bool getCoarserLayouts(DisjointBoxLayout&       a_dblCoar,
00231                                 ProblemDomain&           a_domainCoar,
00232                                 const DisjointBoxLayout& a_dblFine,
00233                                 const ProblemDomain&     a_domainFine,
00234                                 int                      a_refToCoar,
00235                                 int                      a_maxBoxSize,
00236                                 bool&                    a_layoutChanged,
00237                                 int                      a_testRef = 2);
00238 
00239   ///
00240   /**
00241      Gets the stencil to take the first derivative in the given direction
00242      of  cell centered data.
00243      Returns the expected order of the derivative.
00244      When we need them, we prefer
00245      first derivataves to be second order if at all possible, so we take some pains
00246      to achieve that
00247   */
00248   static int
00249   getFirstDerivStencil(VoFStencil&      a_sten,
00250                        const VolIndex&  a_vof,
00251                        const EBISBox&   a_ebisBox,
00252                        const int&       a_idir,
00253                        const Real&      a_dx,
00254                        IntVectSet*    a_cfivsPtr = NULL,
00255                        int ivar = 0);
00256 
00257 
00258   ///
00259   /**
00260      Gets the stencil to take the mixed (in the given directions)
00261      derivative of  cell centered data.
00262      Returns the expected order of the derivative.
00263      When we need them, we usually only need second derivatives to O(h), so
00264      this just shifts stencil when it has to.
00265   */
00266   static int
00267   getMixedDerivStencil(VoFStencil&      a_sten,
00268                        const VolIndex&  a_vof,
00269                        const EBISBox&   a_ebisBox,
00270                        const int&       a_dir1,
00271                        const int&       a_dir2,
00272                        const Real&      a_dx1,
00273                        const Real&      a_dx2,
00274                        IntVectSet*    a_cfivsPtr = NULL,
00275                        int ivar = 0);
00276 
00277   ///
00278   /**
00279      Gets the stencil to take the second derivative in the given direction)
00280      of  cell centered data.
00281      Returns the expected order of the derivative.
00282      When we need them, we usually only need second derivatives to O(h), so
00283      this just shifts stencil when it has to.
00284   */
00285   static int
00286   getSecondDerivStencil(VoFStencil&      a_sten,
00287                         const VolIndex&  a_vof,
00288                         const EBISBox&   a_ebisBox,
00289                         const int&       a_idir,
00290                         const Real&      a_dx,
00291                         IntVectSet*    a_cfivsPtr = NULL,
00292                         int ivar = 0);
00293 
00294   ///
00295   /**
00296      a function that could possibly take over the world.
00297   */
00298   static void
00299   getVoFsDir(bool& a_hasClose, VolIndex& a_closeVoF,
00300              bool& a_hasFar,   VolIndex& a_farVoF,
00301              const EBISBox& a_ebisBox,
00302              const VolIndex& a_vof,
00303              int a_idir, Side::LoHiSide a_sd,
00304              IntVectSet*    a_cfivsPtr);
00305 
00306   ///
00307   /**
00308      define an intvectset of ghost cells which live on
00309      the coarse fine interface.  includes corner cells.
00310    */
00311   static void
00312   defineCFIVS(LayoutData<IntVectSet>&   a_cfivs,
00313               const DisjointBoxLayout&  a_grids,
00314               const ProblemDomain&      a_probDom);
00315 
00316   ///
00317   static Real
00318   extrapFaceGradToOutflow(const FaceIndex&      a_bndryFace,
00319                           const Side::LoHiSide& a_side,
00320                           const int&            a_idir,
00321                           const EBGraph&        a_ebGraph,
00322                           const EBFaceFAB&      a_faceData,
00323                           const int&            a_comp);
00324 
00325   ///
00326   static Real
00327   extrapFaceValueToDomain(const FaceIndex&      a_bndryFace,
00328                           const Side::LoHiSide& a_side,
00329                           const int&            a_idir,
00330                           const EBGraph&        a_ebGraph,
00331                           const EBFaceFAB&      a_faceData,
00332                           const int&            a_comp);
00333 
00334   ///
00335   static Real
00336   extrapFaceVelToOutflow(const FaceIndex&      a_bndryFace,
00337                          const Side::LoHiSide& a_side,
00338                          const int&            a_idir,
00339                          const EBGraph&        a_ebGraph,
00340                          const EBFaceFAB&      a_faceData,
00341                          const int&            a_comp);
00342 
00343   ///
00344   static Real
00345   interpolateVel(const EBFaceFAB& a_vel,
00346                  const EBISBox&   a_ebisBox,
00347                  const FaceIndex& a_face);
00348 
00349   ///
00350   static Real
00351   deInterpolateVel(const Real&      a_centroidVel,
00352                    const EBFaceFAB& a_vel,
00353                    const EBISBox&   a_ebisBox,
00354                    const FaceIndex& a_face);
00355 
00356   ///
00357   static Real
00358   getFaceVelForDivFreeCell(const FaceIndex&      a_face,
00359                            const VolIndex&       a_vof,
00360                            const int&            a_idir,
00361                            const Side::LoHiSide& a_side,
00362                            const EBFluxFAB&      a_vel,
00363                            const RealVect&       a_dx,
00364                            const EBISBox&        a_ebisBox);
00365   ///
00366   /**
00367      evaluates integral(a_divu dV)/integral(dV) over a hierarchy.
00368      pval = -1--->assumes volfrac already multiplied in
00369      pval = -2--->multiply by volume fraction
00370    */
00371   static void
00372   meanOverHierarchy(Real&                                   a_mean,
00373                     const Vector<LevelData<EBCellFAB> *>&   a_divu,
00374                     const Vector<DisjointBoxLayout>&        a_grids,
00375                     const Vector<EBISLayout>&               a_ebisl,
00376                     const Vector<int>&                      a_refRat,
00377                     const ProblemDomain&                    a_domainCoarsest,
00378                     const RealVect&                         a_dxCoarsest,
00379                     const int& a_comp,
00380                     int pval= -1);
00381 
00382   ///
00383   /**
00384    //gets the weight of a vof to interpolate (linear in 2d, bilinear in 3d) to an interpolation point in the plane
00385    //this is used to get one of the points along the johansen ray
00386    */
00387   static Real
00388   getJohanVoFWeight(const VolIndex& a_whichVoF,     //vof for which we are trying to find weight
00389                     const RealVect& a_intersectLoc, //location of intersection in real space
00390                     const IntVect&  a_intersectIV,  //intvect through which ray passes
00391                     const int&      a_nMaxDir,      //direction of largest normal
00392                     const RealVect& a_dx);           //grid spacing but you knew that.
00393 
00394   ///version which uses incoming normal, boundary centroid
00395   /**
00396      splitting up stuff this way to facillitate multifluid
00397      which can have multiple normals and boundary centroids per cell.
00398    */
00399   static void
00400   johanStencil(bool&               a_dropOrder,
00401                Vector<VoFStencil>& a_pointStencils,
00402                Vector<Real>&       a_distanceAlongLine,
00403                const RealVect&     a_normal,
00404                const RealVect&     a_bndryCentroid,
00405                const VolIndex&     a_vof,
00406                const EBISBox&      a_ebisBox,
00407                const RealVect&     a_dx,
00408                const IntVectSet&   a_cfivs,
00409                int a_ivar = 0);
00410 
00411   ///
00412   /**
00413      Gets the stencils to get the data points along the Johansen ray.   If a_dropOrder
00414      returns true then the stencil does not exist.  Also returns the distances along the ray
00415      to each point.
00416    */
00417   static void
00418   johanStencil(bool&               a_dropOrder,
00419                Vector<VoFStencil>& a_pointStencils,
00420                Vector<Real>&       a_distanceAlongLine,
00421                const VolIndex&     a_vof,
00422                const EBISBox&      a_ebisBox,
00423                const RealVect&     a_dx,
00424                const IntVectSet&   a_cfivs,
00425                int a_ivar = 0);
00426 
00427   ///standard interface
00428   /**
00429      gets the normal and calls the other version
00430    */
00431   static void
00432   getLeastSquaresGradSten(VoFStencil&     a_stencil,
00433                           Real&           a_weight,
00434                           const VolIndex& a_vof,
00435                           const EBISBox&  a_ebisBox,
00436                           const RealVect& a_dx,
00437                           const ProblemDomain& a_domain,
00438                           int a_ivar = 0);
00439 
00440   ///version which uses incoming normal, boundary centroid
00441   /**
00442      splitting up stuff this way to facillitate multifluid
00443      which can have multiple normals and boundary centroids per cell.
00444    */
00445   static void
00446   getLeastSquaresGradSten(VoFStencil&     a_stencil,
00447                           Real&           a_weight,
00448                           const RealVect& a_normal  ,
00449                           const RealVect& a_centroid,
00450                           const VolIndex& a_vof,
00451                           const EBISBox&  a_ebisBox,
00452                           const RealVect& a_dx,
00453                           const ProblemDomain& a_domain,
00454                           int a_ivar = 0);
00455 
00456 
00457   ///version which uses incoming normal, boundary centroid
00458   /**
00459      splitting up stuff this way to facillitate multifluid
00460      which can have multiple normals and boundary centroids per cell.
00461    */
00462   static void
00463   getLeastSquaresGradSten(VoFStencil&     a_stencil,
00464                           Real&           a_weight,
00465                           const RealVect& a_normal  ,
00466                           const RealVect& a_centroid,
00467                           const IntVect&  a_quadrant,
00468                           const VolIndex& a_vof,
00469                           const EBISBox&  a_ebisBox,
00470                           const RealVect& a_dx,
00471                           const ProblemDomain& a_domain,
00472                           int a_ivar = 0);
00473 
00474   ///version which uses incoming normal, boundary centroid, and
00475   /// all available VoFs.
00476   /**
00477      splitting up stuff this way to facillitate multifluid
00478      which can have multiple normals and boundary centroids per cell.
00479    */
00480   static void
00481   getLeastSquaresGradStenAllVoFs(VoFStencil&          a_stencil,
00482                                  Real&                a_weight,
00483                                  const RealVect&      a_normal,
00484                                  const RealVect&      a_centroid,
00485                                  const VolIndex&      a_vof,
00486                                  const EBISBox&       a_ebisBox,
00487                                  const RealVect&      a_dx,
00488                                  const ProblemDomain& a_domain,
00489                                  int                  a_ivar);
00490 
00491   ///version which uses incoming normal, boundary centroid, and
00492   /// all quadrants.
00493   /**
00494      splitting up stuff this way to facillitate multifluid
00495      which can have multiple normals and boundary centroids per cell.
00496    */
00497   static void
00498   getLeastSquaresGradStenAllQuad(VoFStencil&          a_stencil,
00499                                  Real&                a_weight,
00500                                  const RealVect&      a_normal,
00501                                  const RealVect&      a_centroid,
00502                                  const VolIndex&      a_vof,
00503                                  const EBISBox&       a_ebisBox,
00504                                  const RealVect&      a_dx,
00505                                  const ProblemDomain& a_domain,
00506                                  int                  a_ivar,
00507                                  bool                 a_doSymmetric = false);
00508 
00509   /**
00510      split matrix computations for least squares into separate
00511      routine that is independent of stencil size, so that the
00512      code can be reused
00513    */
00514   static void
00515   calculateWeightingMatrix(RealVect           x0,
00516                            Vector<RealVect>&  xp,
00517                            Vector<RealVect>&  weightMatrix,
00518                            bool&              detZero);
00519 
00520   static void
00521   calculateWeightingMatrixRed(RealVect           x0,
00522                               Vector<RealVect>&  xp,
00523                               IntVect            dimm,
00524                               Vector<RealVect>&  weightMatrix,
00525                               bool&              deadRed);
00526 
00527   ///gets the normal of a domain face
00528   static RealVect  getDomainNormal(int a_idir, Side::LoHiSide a_side);
00529 
00530   ///gets the location in real space of a face center
00531   static RealVect  getFaceLocation(const FaceIndex& a_face,
00532                                    const RealVect&  a_dx,
00533                                    const RealVect&  a_probLo);
00534 
00535   ///get stencils for points along a line (generalized johansen stencil)
00536   static void dataRayCast(bool&               a_dropOrder,
00537                           Vector<VoFStencil>& a_pointStencils,
00538                           Vector<Real>&       a_distanceAlongLine,
00539                           const RealVect&     a_normal,
00540                           const RealVect&     a_bndryCentroid,
00541                           const VolIndex&     a_vof,
00542                           const EBISBox&      a_ebisBox,
00543                           const RealVect&     a_dx,
00544                           const IntVectSet&   a_cfivs,
00545                           int a_ivar,
00546                           int a_numPoints);
00547 
00548   ///gets the location in real space of a cell center
00549   static RealVect  getVofLocation(const VolIndex&  a_vof,
00550                                   const RealVect&  a_dx,
00551                                   const RealVect&  a_probLo);
00552 
00553   ///gets the location in real space of a cell center
00554   static RealVect  getIVLocation(const IntVect&   a_iv,
00555                                  const RealVect&  a_dx,
00556                                  const RealVect&  a_probLo);
00557 
00558   ///
00559   /**
00560      A very easy to screw up piece of code that was in four places.
00561    */
00562   static void
00563   defineFluxInterpolant(LevelData<BaseIFFAB<Real> >& a_fluxInterpolant,
00564                         LayoutData<IntVectSet>     & a_irregSetsGrown,
00565                         const DisjointBoxLayout    & a_dbl,
00566                         const EBISLayout           & a_ebisl,
00567                         const ProblemDomain        & a_domain,
00568                         const int                  & a_ncomp,
00569                         const int                  & a_faceDir);
00570 
00571   ///
00572   static void
00573   interpolateFluxToCentroids(LevelData<EBFluxFAB>&       a_centroidFlux,
00574                              const LevelData<EBFluxFAB>& a_faceCentFlux,
00575                              const DisjointBoxLayout&    a_grids,
00576                              const EBISLayout&           a_ebisl,
00577                              const ProblemDomain&        a_domain);
00578 
00579   ///
00580   static void
00581   interpolateFluxToCentroids(EBFaceFAB&                  a_centroidFlux,
00582                              const EBFaceFAB&            a_faceCentFlux,
00583                              const Box&                  a_box,
00584                              const EBISBox&              a_ebisBox,
00585                              const ProblemDomain&        a_domain,
00586                              const int&                  a_idir);
00587 
00588   ///
00589   static void
00590   irregNorm(Real& a_ebIrregNorm,
00591             const BaseIVFAB<Real>& a_ebiError,
00592             const IntVectSet& a_ivsIrreg,
00593             const EBISBox& a_ebisBox,
00594             const int& a_comp,
00595             const int& a_normtype);
00596 
00597   ///
00598   static FaceStencil getInterpStencil(const FaceIndex&     a_face,
00599                                       const IntVectSet&    a_coarseFineIVS,
00600                                       const EBISBox&       a_ebisBox,
00601                                       const ProblemDomain& a_domainBox);
00602 
00603   ///
00604   static void getInterpStencil2D(FaceStencil&          a_sten,
00605                                  const FaceIndex&      a_face,
00606                                  const IntVectSet&     a_coarseFineIVS,
00607                                  const EBISBox&        a_ebisBox,
00608                                  const ProblemDomain&  a_domainBox) ;
00609 
00610   ///
00611   static void getInterpStencil3D(FaceStencil&         a_sten,
00612                                  const FaceIndex&     a_face,
00613                                  const IntVectSet&    a_coarseFineIVS,
00614                                  const EBISBox&       a_ebisBox,
00615                                  const ProblemDomain& a_domainBox);
00616 
00617   ///
00618   /**
00619      Return true if there is unique vof associated with a_cell
00620      that lies in the a_vofsStencil. If so, a_vof = vof. Else return false.
00621   */
00622   static bool
00623   isVoFHere(VolIndex& a_vof,
00624             const Vector<VolIndex>& a_vofsStencil,
00625             const IntVect& a_cell );
00626 
00627   ///
00628   static bool
00629   isVoFHere(VolIndex& a_vof, int& a_whichVoF,
00630             const Vector<VolIndex>& a_vofsStencil,
00631             const IntVect& a_cell );
00632 
00633   ///
00634   /** Returns all vofs that can be reached from a_vof via a
00635       monotone path of length <= than radius
00636   */
00637   static void
00638   getAllVoFsInMonotonePath(Vector<VolIndex>& a_vofList,
00639                            const VolIndex&   a_vof,
00640                            const EBISBox&    a_ebisBox,
00641                            const int&        a_redistRad);
00642 
00643   ///get volume of a vof in rz coords
00644   static void
00645   getKVolRZ(Real&           a_kvol,
00646             Real&           a_cellVol,
00647             const EBISBox&  a_ebisBox,
00648             const Real&     a_dx,
00649             const VolIndex& a_vof);
00650 
00651   ///get volume of a vof in rz coords
00652   static void
00653   getKVolRZNoDx(Real&           a_kvol,
00654                 Real&           a_cellVolDx3,
00655                 const EBISBox&  a_ebisBox,
00656                 const VolIndex& a_vof);
00657 
00658   ///
00659   /**
00660      Return true if there is a unique adjacent face in the
00661      given direction.  False if either covered or multivalued.
00662    */
00663   static
00664   bool
00665   getAdjacentFace(FaceIndex& a_adjacentFace,
00666                   const FaceIndex& a_face,
00667                   const EBISBox& a_ebisBox,
00668                   const ProblemDomain& a_domain,
00669                   const int& a_idir,
00670                   const Side::LoHiSide& a_side);
00671 
00672   ///
00673   /**
00674      compute a stencil for one of our fancy interpolated
00675      gradients.
00676    */
00677   static
00678   void computeGradFluxStencil(VoFStencil& a_thisStencil,
00679                               const FaceIndex& a_thisFace,
00680                               const EBISBox& a_ebisBox,
00681                               const ProblemDomain& a_domain,
00682                               const int& a_dir);
00683 
00684   ///
00685   /**
00686      compute a stencil for one of our fancy interpolated
00687      fluxes.
00688    */
00689   static
00690   void computeInterpStencil(FaceStencil& a_thisStencil,
00691                             const FaceIndex& a_thisFace,
00692                             const EBISBox& a_ebisBox,
00693                             const ProblemDomain& a_domain,
00694                             const int& a_dir);
00695 
00696   ///
00697   /**
00698      return lp-norm of component comp of a_src,
00699      weighted by local volume fraction.
00700      not normalized by number of points or anything like that.
00701      if p==0, volume returned is one
00702      and norm returned is Max(abs(a_src)) over
00703      uncovered regions.  otherwise,
00704      returns sum(volfrac*a_src(iv,comp)**p)  of component comp of a_src
00705      weighted by local volume fraction and
00706      also returns volume of uncovered regions.
00707      Only uncovered regions count here.
00708    */
00709   static
00710   void
00711   volWeightedSum(Real&              a_norm,
00712                  Real&              a_volume,
00713                  const EBCellFAB&   a_src,
00714                  const Box&         a_region,
00715                  const EBISBox&     a_ebisBox,
00716                  const RealVect&    a_dx,
00717                  const IntVectSet&  a_ivsExclude,
00718                  const int&         a_comp,
00719                  const int&         a_p,
00720                  EBNormType::NormMode = EBNormType::OverBoth);
00721 
00722 
00723   static void
00724   getCompVolRZ(Real&           a_compVol,
00725                const EBISBox&  a_ebisBox,
00726                const Real&     a_dx,
00727                const VolIndex& a_vof,
00728                bool a_verbose = false);
00729   ///
00730   /**
00731      return volume-weighted sum of component comp of a_src,
00732      weighted by local volume fraction.
00733      and norm returned is Max(abs(a_src)) over
00734      uncovered regions.  otherwise,
00735      returns sum(volfrac*a_src(iv,comp)**p)  of component comp of a_src
00736      weighted by local volume fraction and
00737      also returns volume of uncovered regions.
00738      Only uncovered regions count here.
00739    */
00740   static
00741   void
00742   computeSum(Real&              a_norm,
00743              Real&              a_volume,
00744              const EBCellFAB&   a_src,
00745              const Box&         a_region,
00746              const EBISBox&     a_ebisBox,
00747              const RealVect&    a_dx,
00748              const IntVectSet&  a_ivsExclude,
00749              const int&         a_comp,
00750              EBNormType::NormMode = EBNormType::OverBoth);
00751 
00752 
00753   ///
00754   /**
00755      return volume-weighted sum of component comp of a_src,
00756      weighted by local volume fraction.
00757      and norm returned is Max(abs(a_src)) over
00758      uncovered regions.  otherwise,
00759      returns sum(volfrac*a_src(iv,comp)**p)  of component comp of a_src
00760      weighted by local volume fraction and
00761      also returns volume of uncovered regions.
00762      Only uncovered regions count here.
00763    */
00764   static
00765   void
00766   computeUnweightedSum(Real&             a_norm,
00767                        Real&             a_volume,
00768                        const EBCellFAB&  a_src,
00769                        const Box&        a_region,
00770                        const EBISBox&    a_ebisBox,
00771                        const RealVect&   a_dx,
00772                        const IntVectSet& a_ivsExclude,
00773                        const int&        a_comp,
00774                        EBNormType::NormMode = EBNormType::OverBoth);
00775 
00776   ///
00777   /** return l-p norm of a_src.
00778       if p==0, v
00779       norm returned is Max(abs(a_src)) over
00780       uncovered regions.  otherwise,
00781       returns 1/vol(sum(volfrac*a_src(iv,comp)**p)^(1/p))
00782       of component comp of a_src
00783       weighted by local volume fraction and
00784       also returns volume of uncovered regions.
00785       Only uncovered regions count here.
00786       The data must have the same layout as a_layout with
00787       the possible exception of ghost cells.
00788 
00789       int pmode = -2;  //norm = (1/v)(sum(phi dv)) ---no absolute values and multiply kappa as you go
00790       int pmode = -1;  //norm = (1/v)(sum(phi dv)) ---no absolute values and assume kappa already multiplied in
00791 
00792    */
00793   static
00794   Real
00795   norm(const BoxLayoutData<EBCellFAB >& a_dataOne,
00796        const BoxLayout& a_layout,
00797        const EBISLayout& a_ebisl,
00798        const int& comp,
00799        const int&  p,
00800        EBNormType::NormMode = EBNormType::OverBoth);
00801 
00802   static
00803   Real
00804   norm(const Vector<LevelData<EBCellFAB>* >& a_data,
00805        const Vector< DisjointBoxLayout > &   a_layout,
00806        const Vector< EBISLayout >&           a_ebisl,
00807        const Vector< int >&                  a_refRatio,
00808        const int& comp,
00809        const int&  p,
00810        EBNormType::NormMode = EBNormType::OverBoth);
00811 
00812   ///
00813   static
00814   void
00815   computeCoveredFaces(Vector<VolIndex>&     a_coveredFace,
00816                       IntVectSet&           a_coveredSets,
00817                       IntVectSet&           a_irregIVS,
00818                       const int&            a_idir,
00819                       const Side::LoHiSide& a_sd,
00820                       const EBISBox&        a_ebisBox,
00821                       const Box&            a_region);
00822 
00823   //testing interface
00824   static
00825   Real
00826   norm(Real& volume, const BoxLayoutData<EBCellFAB >& a_dataOne,
00827        const BoxLayout& a_layout,
00828        const EBISLayout& a_ebisl,
00829        const int& comp,
00830        const int&  p,
00831        EBNormType::NormMode = EBNormType::OverBoth);
00832 
00833   ///
00834   /** return l-p norm of a_src.
00835       if p==0, v
00836       norm returned is Max(abs(a_src)) over
00837       uncovered regions.  otherwise,
00838       returns 1/vol(sum(volfrac*a_src(iv,comp)**p)^(1/p))
00839       of component comp of a_src
00840       weighted by local volume fraction and
00841       also returns volume of uncovered regions.
00842       Only uncovered regions count here.
00843       The data must have the same layout as a_layout with
00844       the possible exception of ghost cells.
00845    */
00846   static
00847   Real
00848   norm(const EBCellFAB& a_dataOne,
00849        const Box&       a_grid,
00850        const EBISBox&   a_ebisl,
00851        const int&       a_comp,
00852        const int&       a_p,
00853        EBNormType::NormMode = EBNormType::OverBoth);
00854 
00855   static
00856   Real
00857   norm(Real& volume, const EBCellFAB& a_dataOne,
00858        const Box&       a_grid,
00859        const EBISBox&   a_ebisl,
00860        const int&       a_comp,
00861        const int&       a_p,
00862        EBNormType::NormMode = EBNormType::OverBoth);
00863 
00864   ///
00865   /** return l-p norm of a_src.
00866       if p==0, v
00867       norm returned is Max(abs(a_src)) over
00868       uncovered regions.  otherwise,
00869       returns sum(volfrac*a_src(iv,comp)**p)  of component comp of a_src
00870       weighted by local volume fraction and
00871       also returns volume of uncovered regions.
00872       Only uncovered regions count here.
00873       The data must have the same layout as a_layout with
00874       the possible exception of ghost cells.
00875    */
00876   static
00877   void
00878   volWeightedSum(Real&                            a_sum,
00879                  Real&                            a_volume,
00880                  const BoxLayoutData<EBCellFAB >& a_dataOne,
00881                  const BoxLayout&                 a_layout,
00882                  const EBISLayout&                a_ebisl,
00883                  const RealVect&                  a_dx,
00884                  const IntVectSet&                a_ivsExclude,
00885                  const int&                       a_comp,
00886                  const int&                       a_p,
00887                  EBNormType::NormMode = EBNormType::OverBoth);
00888 
00889   ///
00890   /** return the sum of all irregular boundary areas
00891    */
00892   static
00893   void
00894   sumBndryArea(Real&               a_area,
00895                const BoxLayout&    a_region,
00896                const EBISLayout&   a_ebisl);
00897 
00898   ///
00899   /** return the dotproduct of two leveldatas of ebfabs,
00900       Only uncovered regions count here.
00901    */
00902   static
00903   Real
00904   dotProduct(const BoxLayoutData<EBCellFAB >& a_dataOne,
00905              const BoxLayoutData<EBCellFAB >& a_dataTwo,
00906              const BoxLayout& a_layout,
00907              const EBISLayout& a_ebisl,
00908              const int& a_comp);
00909 
00910   ///
00911   /** return the dotproduct of two  ebfabs,
00912       Only uncovered regions count here.
00913    */
00914   static
00915   Real
00916   dotProduct(const EBCellFAB& a_dataOne,
00917              const EBCellFAB& a_dataTwo,
00918              const Box& a_layout,
00919              const EBISBox& a_ebisBox,
00920              const int& a_comp);
00921 
00922   ///
00923   /** Given a VoF, a_vof1, and a cell, a_cell2, determine if there is a vector of
00924       VoFs in a_cell2 that connects to a_vof1 via a monotone path.
00925       A vector of VolIndices is returned, even if empty.
00926    */
00927   static
00928   void
00929   monotonePathVoFToCellMultiVoFs(Vector<VolIndex>& a_vofsInCell,
00930                                  const Vector<VolIndex>& a_vofsInPath,
00931                                  const IntVect& a_cell2,
00932                                  const EBISBox& a_ebisBox);
00933   ///
00934   /** Given a VoF, a_vof1, and a cell, a_cell2, determine if there is a single
00935       VoF in a_cell2 that connects to a_vof1 via a monotone path.  If there is
00936       one such VoF then TRUE is returned (and the VolIndex is returned,
00937       a_vof2).  If there is no such VoF or if there are more than one such
00938       VoF then FALSE is returned (and a_vof2 is unchanged).
00939    */
00940   static
00941   bool
00942   monotonePathVoFToCellVoF(VolIndex& a_vof2,
00943                            const VolIndex& a_vof1,
00944                            const IntVect& a_cell2,
00945                            const EBISBox& a_ebisBox);
00946   ///
00947   /** Returns all vofs that can be reached from a_vof via a
00948       monotone path of length <= than radius
00949   */
00950   static
00951   void
00952   getAllVoFsInMonotonePath(Vector<VolIndex>& a_vofs,
00953                            const IntVect&    a_timesMoved,
00954                            const IntVect&    a_pathSign,
00955                            const VolIndex&   a_vof,
00956                            const EBISBox&    a_ebisBox,
00957                            const int&        a_radius);
00958 
00959   static VolIndex& getVoFMax()
00960   {
00961     return s_vofMax;
00962   }
00963   static Real&     getValMax()
00964   {
00965     return s_valMax;
00966   }
00967 
00968   static void setMinVolumeFraction(Real a_minVolFrac)
00969   {
00970     s_minVolFrac = a_minVolFrac;
00971   }
00972 
00973 private:
00974   static VolIndex s_vofMax;
00975   static Real     s_valMax;
00976   static Real     s_minVolFrac;
00977 
00978 };
00979 
00980 extern IntVect ebcoarsen (const IntVect& b,
00981                           int        refinement_ratio);
00982 
00983 extern
00984 Box ebrefine (const Box& b,
00985               int        refinement_ratio);
00986 extern
00987 ProblemDomain ebrefine (const ProblemDomain& b,
00988                         int        refinement_ratio);
00989 
00990 extern Box ebcoarsen (const Box& b,
00991                       int        refinement_ratio);
00992 extern ProblemDomain ebcoarsen (const ProblemDomain& b,
00993                                 int        refinement_ratio);
00994 
00995 extern void ebrefine(DisjointBoxLayout& output,
00996                      const DisjointBoxLayout& input,
00997                      int refinement);
00998 
00999 extern void ebcoarsen(DisjointBoxLayout& output,
01000                       const DisjointBoxLayout& input,
01001                       int refinement);
01002 
01003 #include "NamespaceFooter.H"
01004 #endif