AMRNodeLevelMG.H

Go to the documentation of this file.

#ifdef CH_LANG_CC
/*
*      _______              __
*     / ___/ /  ___  __ _  / /  ___
*    / /__/ _ \/ _ \/  V \/ _ \/ _ \
*    \___/_//_/\___/_/_/_/_.__/\___/
*    Please refer to Copyright.txt, in Chombo's root directory.
*/
#endif

// AMRNodeLevelMG.H
// adapted from AMRLevelMG by DTGraves, Tues, July 6, 1999
// petermc, Tues, Nov 28, 2000

#ifndef AMRNODELEVELMG_H
#define AMRNODELEVELMG_H

#include <stdlib.h>
#include <iostream>
#include "SPACE.H"
#include <math.h>
#include "REAL.H"
#include "IntVect.H"
#include "ProblemDomain.H"
#include "NodeFArrayBox.H"
#include "DisjointBoxLayout.H"
#include "LevelData.H"
#include "BaseFab.H"
#include "NodeLevelMG.H"
#include "NodeMGInterp.H"

#include "UsingNamespace.H"

// forward declaration of AMRNodeSolver
// C++ism:  don't need to #include AMRNodeSolver.H unless you have
// a data field that's an AMRNodeSolver
class AMRNodeSolver;

class AMRNodeLevelMG
{
public:
  friend class AMRNodeSolver;



  AMRNodeLevelMG();


  AMRNodeLevelMG(const AMRNodeSolver* const a_parent,
                 int a_level,
                 const NodeLevelOp* const a_opin);


  ~AMRNodeLevelMG();


  void define(
              const AMRNodeSolver* const a_parent,
              int a_level,
              const NodeLevelOp* const a_opin);



  bool isDefined() const;


  Real computeResidualNorm(
                           int a_normType) const;



  void setnumSmoothUp(int a_numSmoothUp);


  void setnumSmoothDown(int a_numSmoothDown);


  void setVerbose(bool a_verbose);



  void applyAMROperator(
                        LevelData<NodeFArrayBox>& a_Lofphi,
                        Vector<LevelData<NodeFArrayBox> *>& a_phiLevel);


  void applyAMRGradient(
                        LevelData<NodeFArrayBox>& a_gradPhi,
                        Vector<LevelData<NodeFArrayBox> *>& a_phiLevel);


  void computeAMRResidual(
                          Vector<LevelData<NodeFArrayBox> *>& a_phiLevel,
                          const Vector<LevelData<NodeFArrayBox> *>& a_rhsLevel);


  void upSweep(
               Vector<LevelData<NodeFArrayBox> *>& a_phiLevel,
               const Vector<LevelData<NodeFArrayBox> *>& a_rhsLevel);


  void downSweep(
                 Vector<LevelData<NodeFArrayBox> *>& a_phiLevel,
                 const Vector<LevelData<NodeFArrayBox> *>& a_rhsLevel);

protected:

  Real computeNorm(
                   const LevelData<NodeFArrayBox>& a_mfinput,
                   int a_normType) const;

  void smooth(
              LevelData<NodeFArrayBox>& a_phi,
              const LevelData<NodeFArrayBox>& a_rhs);

  void projectFineInterior(LevelData<NodeFArrayBox>& a_phi,
                           const LevelData<NodeFArrayBox>& a_phiFine);

  void clearMemory();

  void setDefaultValues();

  const AMRNodeSolver* m_parent;

  NodeLevelMG m_levelMG;

  NodeMGInterp m_mginterp;

  bool m_isDefined;

  bool m_verbose;

  DisjointBoxLayout m_coarsenedGrids;

  LevelData<NodeFArrayBox> m_resid;

  // LevelData<NodeFArrayBox> m_residInterior;

  LevelData<NodeFArrayBox> m_corr;

  LevelData<NodeFArrayBox> m_dcorr;

  LevelData<NodeFArrayBox> m_LofPhi;

  LevelData<NodeFArrayBox> m_phiSave;

  LevelData<NodeFArrayBox> m_residCoarsened;

  int m_level;

  Real m_dx;

  NodeLevelOp* m_levelOpPtr;

  NodeCoarseAverage m_averageOp;

  ProblemDomain m_domain;

  DisjointBoxLayout m_finerGrids;

  DisjointBoxLayout m_coarsenedFineGrids;

  LayoutData< Vector<IntVectSet> > m_IVSV;

  LayoutData< Vector<IntVectSet> > m_IVSVext;

  LayoutData< Vector<IntVectSet> > m_IVSVcoarsened;

  LayoutData< Vector<IntVectSet> > m_IVSVcoarsenedFine;

private:

  AMRNodeLevelMG& operator = (const AMRNodeLevelMG&);
  AMRNodeLevelMG(const AMRNodeLevelMG&);

};

#endif

---