CCProjector.H

Go to the documentation of this file.

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

// CCProjector.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 _CCProjector_H_
#define _CCProjector_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 "LevelSolver.H"
#include "AMRSolver.H"
#include "QuadCFInterp.H"
#include "GhostBC.H"
#include "PhysBCUtil.H"

#include "FluxBox.H"

class CCProjector
{

public:
  CCProjector();

  CCProjector(const DisjointBoxLayout& a_grids,
              const DisjointBoxLayout* a_crseGridsPtr,
              const Box& a_domain,
              const Real  a_dx,
              CCProjector* a_finerProj,
              CCProjector* a_crseProj,
              int a_nRefCrse,
              int a_level,
              const PhysBCUtil& a_physBC);

  CCProjector(const DisjointBoxLayout& a_grids,
              const DisjointBoxLayout* a_crseGridsPtr,
              const ProblemDomain& a_domain,
              const Real  a_dx,
              CCProjector* a_finerProj,
              CCProjector* a_crseProj,
              int a_nRefCrse,
              int a_level,
              const PhysBCUtil& a_physBC);

  ~CCProjector();

  void define(const DisjointBoxLayout& a_grids,
              const DisjointBoxLayout* a_crseGridsPtr,
              const Box& a_domain,
              const Real  a_dx,
              CCProjector* a_finerProj,
              CCProjector* a_crseProj,
              int a_nRefCrse,
              int a_level,
              const PhysBCUtil& a_physBC);

  void define(const DisjointBoxLayout& a_grids,
              const DisjointBoxLayout* a_crseGridsPtr,
              const ProblemDomain& a_domain,
              const Real  a_dx,
              CCProjector* a_finerProj,
              CCProjector* a_crseProj,
              int a_nRefCrse,
              int a_level,
              const PhysBCUtil& a_physBC);


  void init(const CCProjector& a_oldProj);

  void variableSetUp();

  void setCrseProj(CCProjector* a_crseProj, int nRefCrse);
  
  void setFineProj(CCProjector* a_fineProj);

  void limitSolverCoarsening(bool a_limitSolverCoarsening);


  void writeCheckpointHeader(HDF5Handle& a_handle) const;

  void  writeCheckpointLevel(HDF5Handle& a_handle) const;

  void readCheckpointHeader(HDF5Handle& a_handle);

  void readCheckpointLevel(HDF5Handle& a_handle);


  /*@ManMemo: do level MAC projection, correct uEdge.  a_oldTime is
    old-time on AMRLevel which is calling the projection.  assumes
    BC's already set on uEdge values */
  void levelMacProject(LevelData<FluxBox>& uEdge,
                       Real a_oldTime, Real a_dt);

  /*@ManMemo: do level projection and correct (cell-centered)
    velocities; assumes physical and exchange (copy) boundary
    conditions already set.    
  */
  void LevelProject(LevelData<FArrayBox>& a_velocity, 
                    LevelData<FArrayBox>* a_crseVelPtr,
                    const Real a_newTime, const Real a_dt);


  /*@ManMemo: defines AMRSolver and calls sync projection
    and freestream preservation solve. assumes all physical
    and copy BC's already set (does C/F BC's however) */
  void doSyncOperations(Vector<LevelData<FArrayBox>* >& a_velocity,
                        Vector<LevelData<FArrayBox>* >& a_lambda,
                        const Real a_newTime, const Real a_dtSync);
                        

  void initialLevelProject(LevelData<FArrayBox>& a_velocity,
                           LevelData<FArrayBox>* a_crseVelPtr,
                           const Real a_oldTime, const Real a_newTime);

  
  /*@ManMemo: defines AMRSolver and calls initial sync projection and
    freestream preservation solves */
  void doInitialSyncOperations(Vector<LevelData<FArrayBox>* >& a_vel,
                               Vector<LevelData<FArrayBox>* >& a_lambda,
                               const Real a_newTime, const Real a_dtSync);
                
  /*@ManMemo: performs multilevel projection on velocity, modifies velocity
    in place. dtSync is used as a scaling factor for coarse-level BC's,
    not used in actual projection.  if homogeneousCFBC is false, C/F bc 
    for l_base is taken from coarse-level eSync, o/w use l_base-1 
    correction field = 0.  if applyCorrection == false, then correction
    is computed, but not applied (can be useful as a diagnostic).
    physical and copy BC's should already be set before this is called.
  */
    
  void initialVelocityProject(Vector<LevelData<FArrayBox>* >& a_velocity,
                              bool a_homogeneousCFBC = true);

  /*@ManMemo: same as other initialVelocityProject function,
    except uses a pre-defined AMRSolver */
  void initialVelocityProject(Vector<LevelData<FArrayBox>* >& a_velocity,
                              AMRSolver& a_solver,
                              bool a_homogeneousCFBC = true);


  /*@ManMemo: This function performs the necessary re-initialization
    after regridding -- does composite projection on new velocity field
    and also recomputes e_lambda and grad_eLambda */

  void doPostRegridOps(Vector<LevelData<FArrayBox>* >& a_velocity,
                       Vector<LevelData<FArrayBox>* >& a_lambda,
                       const Real a_dt, const Real a_time);


  int getLevel() const;

  const ProblemDomain& dProblem() const;

  const DisjointBoxLayout& getBoxes() const;

  int nRefCrse() const;
  
  Real dx() const;

  Real etaLambda() const;

  CCProjector* fineProjPtr() const;
  
  CCProjector* crseProjPtr() const;

  LevelData<FArrayBox>& phi();
  
  const LevelData<FArrayBox>& phi() const;

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

  void gradPhi(LevelData<FluxBox>& a_gradPhi) const;

  LevelData<FArrayBox>& Pi();

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

  /*@ManMemo: returns grad(pi) in all directions into 
    SpaceDim-dimensioned gradPi 
  */ 
  void gradPi(LevelData<FArrayBox>& a_gradPi) const;

  LevelData<FArrayBox>& eSync();

  const LevelData<FArrayBox>& eSync() const;
  
  void grad_eSync(LevelData<FArrayBox>& a_grad_eSync, int a_dir) const;

  void grad_eSync(LevelData<FArrayBox>& a_grad_eSync) const;


  LevelData<FArrayBox>& eLambda();

  const LevelData<FArrayBox>& eLambda() const;

  void grad_eLambda(LevelData<FArrayBox>& a_grad_eLambda, int a_dir) const;

  /*@ManMemo: returns edge-centered grad(eLambda) in all directions;
    non-constant reference returned because of need to rescale. */ 
  LevelData<FluxBox>&  grad_eLambda();

  const LevelData<FluxBox>& grad_eLambda() const;
    
  bool doSyncProjection() const;

  bool doMacSync() const;
  
  bool isInitialized() const;

  bool doQuadInterp() const;
  
  QuadCFInterp& quadCFInterpolator();

  bool isFinestLevel() const;

  void isFinestLevel(bool a_finest_level);

  void verbosity(int a_verbosity);

  int verbosity() const;

  void setPhysBC(const PhysBCUtil& a_bc);

  PhysBCUtil* getPhysBCPtr() const;

protected:
  void applyMacCorrection(LevelData<FluxBox>& a_uEdge, Real CFscale);
  
  void correctCCVelocities(LevelData<FArrayBox>& a_velocity,
                           const Real scale) const;
  
  
  /*@ManMemo: do sync projection, with this level as lBase;
    corrects velocity in place*/
  void doSyncProjection(Vector<LevelData<FArrayBox>* >& a_velocity,
                        const Real a_newTime, const Real a_dtSync,
                        AMRSolver& solver);
  
  void initialSyncProjection(Vector<LevelData<FArrayBox>* >& a_velocity,
                             const Real a_newTime, const Real a_dtSync,
                             AMRSolver& a_solver);


  /*@ManMemo: do volume discrepancy solve, with this level as lBase
   */
  void computeVDCorrection(Vector<LevelData<FArrayBox>* >& a_lambda,
                           const Real a_newTime, const Real
                           a_dtSync, AMRSolver& solver);
  
  
/*@ManMemo: apply sync correction vel = vel - scale*G^{comp} eSync 
  (recursively applies correction to all finer levels) */
  void applySyncCorrection(Vector<LevelData<FArrayBox>* >& a_velocity,
                           const Real scale, 
                           LevelData<FArrayBox>* crseCorr);


  void computeGrad_eLambda();


  void rescaleGrad_eLambda(Real a_dx_lbase);


  /*@ManMemo: defines Multilevel AMRSolver used for composite 
    projections -- uses grids in vel, lBase is this level.
    a_freestream solver is true if solver will be used for
    freestream preservation solve. */
  void defineSolver(AMRSolver& a_solver, 
                    const Vector<LevelData<FArrayBox>* >& a_vel,
                    bool a_freestreamSolver);

  void postRestart();

private:

  int m_level;
  
  Real m_dx;

  ProblemDomain m_domain;
  

  QuadCFInterp m_cfInterp;

  CCProjector* m_fineProjPtr;
  CCProjector* m_crseProjPtr;

  int m_nRefCrse;

  LevelData<FArrayBox> m_Pi;

  LevelData<FArrayBox> m_phi;

  LevelData<FArrayBox> m_eSync;
  LevelData<FArrayBox> m_eLambda;

  LevelData<FluxBox> m_grad_eLambda;

  LevelSolver m_levelSolver;

  static bool m_doSyncProjection;
  
  static bool m_applySyncCorrection;

  bool m_isInitialized;

  static bool m_doQuadInterp;
 
  bool m_limitSolverCoarsening;

  static Real m_etaLambda;

  static int s_num_smooth_up;

  static int s_num_smooth_down;

  static bool s_constantLambdaScaling;

  static Real s_lambda_timestep;

  static bool pp_init;

  static int s_verbosity;

  static bool s_applyVDCorrection;

  bool m_finest_level;

  PhysBCUtil* m_physBCPtr;

};

#endif

---