---

AmrProjector.H

Go to the documentation of this file.

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

// AmrProjector.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 _AmrProjector_H_
#define _AmrProjector_H_


#include <cstdlib>
#include <cmath>
#include <cassert>

#include <iostream>
using std::istream;
using std::cout;
using std::cerr;


#include "REAL.H"
#include "IntVect.H"
#include "Box.H"
#include "FArrayBox.H"
#include "Vector.H"
#include "IntVectSet.H"
#include "DisjointBoxLayout.H"
#include "LevelData.H"
#include "AMRSolver.H"
#include "QuadCFInterp.H"
#include "GhostBC.H"
#include "PhysBCUtil.H"

#include "FluxBox.H"

class AmrProjector
{

public:
  AmrProjector();

  AmrProjector(const Vector<DisjointBoxLayout>& a_vectGrids,
               const Vector<ProblemDomain>& a_vectDomain,
               const Vector<Real>&  a_vectDx,
               const Vector<int>& a_vectRefRatio,
               int a_lbase,
               const PhysBCUtil& a_physBC);
  
  ~AmrProjector();
  
  void define(const Vector<DisjointBoxLayout>& a_vectGrids,
              const Vector<ProblemDomain>& a_vectDomain,
              const Vector<Real>&  a_vectDx,
              const Vector<int>& a_vectRefRatio,
              int a_lbase,
              const PhysBCUtil& a_physBC);

  void regrid(const Vector<DisjointBoxLayout>& a_newGrids);


  void setDefaultValues();

  void init(const AmrProjector& a_oldProj);
  
  void variableSetUp();
  
  void writeCheckpointHeader(HDF5Handle& a_handle) const;

  void writeCheckpoint(HDF5Handle& a_handle) const;

  void readCheckpointHeader(HDF5Handle& a_handle);
  
  void readCheckpoint(HDF5Handle& a_handle);
  
  
  /*@ManMemo: do multilevel MAC projection, correct uEdge.  a_oldTime is
    old-time on AMRLevel which is calling the projection.  Assumes
    BC's already set on uEdge values.  a_vectPhi contains the correction 
    field generated by the projection */
  void MacProject(Vector<LevelData<FluxBox>* > & a_uEdge,
                  Vector<LevelData<FArrayBox>* >& a_vectPhi,
                  Real a_oldTime, Real a_dt);
  
  /*@ManMemo: do multilevel projection and correct (cell-centered)
    velocities; assumes physical and exchange (copy) boundary
    conditions already set.  a_vectPi contains the correction (pressure) 
    generated by the projection.
  */
  void CCProject(Vector<LevelData<FArrayBox>* >& a_velocity, 
                 Vector<LevelData<FArrayBox>* >& a_vectPi,
                 const Real a_newTime, const Real a_dt);
  
  
  /*@ManMemo: performs multilevel projection on velocity, modifies velocity
    in place. This differs from the other projections in that it does not 
    return a correction field.    
  */
  
  void initialVelocityProject(Vector<LevelData<FArrayBox>* >& a_velocity);

  

  int finestLevel() const;
  
  const ProblemDomain& dProblem(int a_level) const;

  const DisjointBoxLayout& getBoxes(int a_level) const;

  Real dx(int a_level) const;


  void gradPhi(LevelData<FArrayBox>& a_gradPhi, 
               const LevelData<FArrayBox>& a_phi,
               int a_dir, int a_level) const;

  void gradPhi(LevelData<FluxBox>& a_gradPhi, 
               const LevelData<FArrayBox>& a_phi,
               int a_level) const;


  void gradPi(LevelData<FArrayBox>& a_gradPi, 
              const LevelData<FArrayBox>& a_Pi,
              int a_dir, int a_level) const;


  void gradPi(LevelData<FArrayBox>& a_gradPi, 
              const LevelData<FArrayBox>& a_Pi,
              int a_level) const;
  

  void setPressureBCs(Vector<LevelData<FArrayBox>* >& a_vectPressure) const;

  bool isInitialized() const;

  bool doQuadInterp() const;
  
  void verbosity(int a_verbosity);

  int verbosity() const;

  void setPhysBC(const PhysBCUtil& a_bc);

  PhysBCUtil* getPhysBCPtr() const;

protected:
  void applyMacCorrection(Vector<LevelData<FluxBox>* >& a_uEdge, 
                          Vector<LevelData<FArrayBox>* >& a_vectPhi);

  
  void correctCCVelocities(Vector<LevelData<FArrayBox>* >& a_velocity,
                           const Vector<LevelData<FArrayBox>* >& a_vectPi,
                           const Real scale) const;
  
  
  /*@ManMemo: defines Multilevel AMRSolver used for composite 
    projections -- uses grids in m_vectGrids, lBase is this level.
    Physical BC's come from the DomainGhostBC
  */
  void defineSolver(AMRSolver& a_solver, 
                    const DomainGhostBC& a_physBC);


  void postRestart();

  void clearStorage();


  bool isDefined() const {return m_isInitialized;};

private:

  int m_finestLevel;
  
  int m_lbase;

  Vector<Real> m_vectDx;

  Vector<ProblemDomain> m_vectDomain; 

  Vector<DisjointBoxLayout> m_vectGrids;

  Vector<int> m_vectRefRatio;

  Vector<QuadCFInterp*> m_vectCFInterp;

  Vector<QuadCFInterp*> m_vectVelCFInterp;

  Vector<LevelFluxRegister*> m_vectFR;

  bool m_isInitialized;

  static bool s_doQuadInterp;
 
  static int s_num_smooth_up;

  static int s_num_smooth_down;

  static Real s_solver_tol;

  static bool s_limitSolverCoarsening;

  static bool pp_init;

  static int s_verbosity;

  PhysBCUtil* m_physBCPtr;
  
};

#endif

---