Gradient.H

Go to the documentation of this file.

/* _______              __
  / ___/ /  ___  __ _  / /  ___
 / /__/ _ \/ _ \/  ' \/ _ \/ _ \
 \___/_//_/\___/_/_/_/_.__/\___/ 
*/

// Gradient.H

//
// This software is copyright (C) by the Lawrence Berkeley
// National Laboratory.  Permission is granted to reproduce
// this software for non-commercial purposes provided that
// this notice is left intact.
// 
// It is acknowledged that the U.S. Government has rights to
// this software under Contract DE-AC03-765F00098 between
// the U.S.  Department of Energy and the University of
// California.
//
// This software is provided as a professional and academic
// contribution for joint exchange. Thus it is experimental,
// is provided ``as is'', with no warranties of any kind
// whatsoever, no support, no promise of updates, or printed
// documentation. By using this software, you acknowledge
// that the Lawrence Berkeley National Laboratory and
// Regents of the University of California shall have no
// liability with respect to the infringement of other
// copyrights by any part of this software.
//
// Dan Martin, Fri, Jan 14, 2000

#ifndef _Gradient_H_
#define _Gradient_H_

#include "LevelData.H"
#include "FArrayBox.H"
#include "FluxBox.H"
#include "QuadCFInterp.H"


/*@ManMemo: computes cell-centered level-operator gradient of 
cell-centered phi; if phiCrse != NULL, does coarse-fine boundary
conditions for phi (quadratic interpolation) */
void levelGradientCC(
                     LevelData<FArrayBox>& a_grad,
                     LevelData<FArrayBox>& a_phi,
                     const LevelData<FArrayBox>* a_phiCrsePtr,
                     const Real a_dx,
                     const int a_nRefCrse,
                     const ProblemDomain& a_dProblem);

/*@ManMemo: computes cell-centered level-operator gradient of 
cell-centered phi; if phiCrse != NULL, does coarse-fine boundary
conditions for phi (quadratic interpolation).  This (deprecated)
interface uses a Box instead of a ProblemDomain */
void levelGradientCC(
                     LevelData<FArrayBox>& a_grad,
                     LevelData<FArrayBox>& a_phi,
                     const LevelData<FArrayBox>* a_phiCrsePtr,
                     const Real a_dx,
                     const int a_nRefCrse,
                     const Box& a_dProblem);
                     

/*@ManMemo: computes cell-centered level-operator gradient of 
cell-centered phi; if phiCrse != NULL, does coarse-fine boundary
conditions for phi (quadratic C/F interpolation); predefined 
QuadCFInterp object is passed in for efficiency */
void levelGradientCC(
                     LevelData<FArrayBox>& a_grad,
                     LevelData<FArrayBox>& a_phi,
                     const LevelData<FArrayBox>* a_phiCrsePtr,
                     const Real a_dx,
                     QuadCFInterp& a_cfInterp);

/*@ManMemo: computes cell-centered, level-operator gradient
of cell-centered phi; in this case, assume that all relevant
BC's (coarse-fine and physical) have already been set, so 
phi can be a const variable */
void levelGradientCC(
                     LevelData<FArrayBox>& a_grad, 
                     const LevelData<FArrayBox>& a_phi,
                     const Real a_dx);


/*@ManMemo: computes cell-centered composite gradient of cell centered phi;
   uses same coarse-level C/F BC's as LevelGradientCC, if phiFinePtr !=
   NULL, then also uses one-sided differencing to compute gradient
   on coarse side of coarse-fine interface. */
void compGradientCC(
                    LevelData<FArrayBox>& a_grad,
                    LevelData<FArrayBox>& a_phi,
                    const LevelData<FArrayBox>* a_phiCrsePtr,
                    const LevelData<FArrayBox>* a_phiFinePtr,
                    const Real a_dx,
                    const int a_nRefCrse,
                    const int a_nRefFine,
                    const ProblemDomain& a_dProblem);

/*@ManMemo: computes cell-centered composite gradient of cell centered phi;
   uses same coarse-level C/F BC's as LevelGradientCC, if phiFinePtr !=
   NULL, then also uses one-sided differencing to compute gradient
   on coarse side of coarse-fine interface. This (deprecated) 
   interface uses a Box instead of a ProblemDomain */
void compGradientCC(
                    LevelData<FArrayBox>& a_grad,
                    LevelData<FArrayBox>& a_phi,
                    const LevelData<FArrayBox>* a_phiCrsePtr,
                    const LevelData<FArrayBox>* a_phiFinePtr,
                    const Real a_dx,
                    const int a_nRefCrse,
                    const int a_nRefFine,
                    const Box& a_dProblem);

/*@ManMemo: computes cell-centered composite gradient of cell-centered phi;
   uses same coarse-level C/F BC's as LevelGradientCC, if phiFinePtr !=
   NULL, then also uses one-sided differencing to compute gradient
   on coarse side of coarse-fine interface. A predefined QuadCFInterp 
   is also passed in for efficiency.  Note that no fine QuadCFInterp
   is necessary because we use one-sided differencing for coarse
   cells adjacent to finer-level coarse-fine interfaces. Note also
   that gradient is only really defined in valid regions of grids. */
void compGradientCC(
                    LevelData<FArrayBox>& a_grad,
                    LevelData<FArrayBox>& a_phi,
                    const LevelData<FArrayBox>* a_phiCrsePtr,
                    const LevelData<FArrayBox>* a_phiFinePtr,
                    const Real a_dx,
                    const int a_nRefFine,
                    const ProblemDomain& a_dProblem,
                    QuadCFInterp& a_cfInterpCrse);


/*@ManMemo: computes cell-centered composite gradient of cell-centered phi;
   uses same coarse-level C/F BC's as LevelGradientCC, if phiFinePtr !=
   NULL, then also uses one-sided differencing to compute gradient
   on coarse side of coarse-fine interface. A predefined QuadCFInterp 
   is also passed in for efficiency.  Note that no fine QuadCFInterp
   is necessary because we use one-sided differencing for coarse
   cells adjacent to finer-level coarse-fine interfaces. Note also
   that gradient is only really defined in valid regions of grids. 
   This (deprecated) interface uses a Box instead of a ProblemDomain */
void compGradientCC(
                    LevelData<FArrayBox>& a_grad,
                    LevelData<FArrayBox>& a_phi,
                    const LevelData<FArrayBox>* a_phiCrsePtr,
                    const LevelData<FArrayBox>* a_phiFinePtr,
                    const Real a_dx,
                    const int a_nRefFine,
                    const Box& a_dProblem,
                    QuadCFInterp& a_cfInterpCrse);


/*@ManMemo: computes cell-centered composite gradient of cell-centered
  phi; this one assumes that all ghost-cell values have already been set;
  if phiFinePtr != NULL, then also uses one-sided differencing to compute
  gradient on coarse side of corarse-fine interface.  note that gradient 
  is only really defined in valid regions of grids. */
void compGradientCC(
                    LevelData<FArrayBox>& a_Grad,
                    const LevelData<FArrayBox>& a_phi,
                    const LevelData<FArrayBox>* a_phiFinePtr,
                    const Real a_dx,
                    const int a_nRefFine,
                    const ProblemDomain& a_dProblem);


/*@ManMemo: computes cell-centered composite gradient of cell-centered
  phi; this one assumes that all ghost-cell values have already been set;
  if phiFinePtr != NULL, then also uses one-sided differencing to compute
  gradient on coarse side of corarse-fine interface.  note that gradient 
  is only really defined in valid regions of grids. This (deprecated) 
  interface uses a Box instead of a ProblemDomain */
void compGradientCC(
                    LevelData<FArrayBox>& a_Grad,
                    const LevelData<FArrayBox>& a_phi,
                    const LevelData<FArrayBox>* a_phiFinePtr,
                    const Real a_dx,
                    const int a_nRefFine,
                    const Box& a_dProblem);
                    
                    


/*@ManMemo: computes edge-centered level-operator gradient of cell-
  centered field phi; if phiCrsePtr != NULL, does quadratic interpolation
  to compute coarse-fine boundary conditions for phi */
void levelGradientMAC(
                      LevelData<FluxBox>& a_edgeGrad,
                      LevelData<FArrayBox>& a_phi,
                      const LevelData<FArrayBox>* a_phiCrsePtr,
                      const Real a_dx,
                      const int a_nRefCrse, 
                      const ProblemDomain& a_dProblem);

/*@ManMemo: computes edge-centered level-operator gradient of cell-
  centered field phi; if phiCrsePtr != NULL, does quadratic interpolation
  to compute coarse-fine boundary conditions for phi. This (deprecated) 
  interface uses a Box instead of a ProblemDomain */
void levelGradientMAC(
                      LevelData<FluxBox>& a_edgeGrad,
                      LevelData<FArrayBox>& a_phi,
                      const LevelData<FArrayBox>* a_phiCrsePtr,
                      const Real a_dx,
                      const int a_nRefCrse, 
                      const Box& a_dProblem);


/*@ManMemo: computes edge-centered level-operator gradient of cell-
  centered field phi; if phiCrsePtr != NULL, does quadratic interpolation
  to compute coarse-fine boundary conditions for phi.  A predefined
  QuadCFInterp object is passed in for efficiency */
void levelGradientMAC(
                      LevelData<FluxBox>& a_edgeGrad,
                      LevelData<FArrayBox>& a_phi,
                      const LevelData<FArrayBox>* a_phiCrsePtr,
                      const Real a_dx,
                      QuadCFInterp& a_cfInterpCrse);


/*@ManMemo: computes edge-centered level-operator gradient of cell-
  centered field phi; assumes _ALL_ ghost cell values have been 
  preset (so phi can be const) */
void levelGradientMAC(
                      LevelData<FluxBox>& a_edgeGrad,
                      const LevelData<FArrayBox>& a_phi,
                      const Real a_dx);

                      

/*@ManMemo: computes edge-centered composite gradient of cell-centered
field phi; if phiCrsePtr != NULL, does quadratic interpolation to compute
coarse-fine boundary conditions for phi; since the edge between this level
and finer levels is not considered to be a part of this level, there is
no fine-level coarse-fine BC.  because of this, this function produces
exactly the same results as LevelGradientMAC -- it's just included for
completeness... */
void compGradientMAC(
                     LevelData<FluxBox>& a_edgeGrad,
                     LevelData<FArrayBox>& a_phi,
                     const LevelData<FArrayBox>* a_phiCrse,
                     const LevelData<FArrayBox>* a_phiFine,
                     const Real a_dx,
                     const int a_nRefCrse,
                     const int a_nRefFine,
                     const Box& a_dProblem);


/*@ManMemo: computes edge-centered composite gradient of cell-centered
field phi; if phiCrsePtr != NULL, does quadratic interpolation to compute
coarse-fine boundary conditions for phi; since the edge between this level
and finer levels is not considered to be a part of this level, there is
no fine-level coarse-fine BC.  because of this, this function produces
exactly the same results as LevelGradientMAC -- it's just included for
completeness... */
void compGradientMAC(
                     LevelData<FluxBox>& a_edgeGrad,
                     LevelData<FArrayBox>& a_phi,
                     const LevelData<FArrayBox>* a_phiCrse,
                     const LevelData<FArrayBox>* a_phiFine,
                     const Real a_dx,
                     const int a_nRefCrse,
                     const int a_nRefFine,
                     const ProblemDomain& a_dProblem);




/*@ManMemo: computes edge-centered composite gradient of cell-centered
field phi; if phiCrsePtr != NULL, does quadratic interpolation to compute
coarse-fine boundary conditions for phi; since the edge between this level
and finer levels is not considered to be a part of this level, there is
no fine-level coarse-fine BC.  because of this, this function produces
exactly the same results as LevelGradientMAC -- it's just included for
completeness... In this one, a predefined QuadCFInterp object is passed 
in.  This (deprecated) interface uses a Box instead of a ProblemDomain 
object */
void compGradientMAC(
                     LevelData<FluxBox>& a_edgeGrad,
                     LevelData<FArrayBox>& a_phi,
                     const LevelData<FArrayBox>* a_phiCrse,
                     const LevelData<FArrayBox>* a_phiFine,
                     const Real a_dx,
                     const int a_nRefFine,
                     QuadCFInterp& a_cfInterpCrse);



                     



#endif

---