NodeLevelMG.H

Go to the documentation of this file.

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

// NodeLevelMG.H
// adapted from LevelMG by DTGraves, Fri, July 16, 1999
// petermc, 30 May 2001

#ifndef NODELEVELMG_H
#define NODELEVELMG_H

#include <iostream>
#include <cmath>
#include "SPACE.H"
#include <cstdlib>
#include "REAL.H"
#include "ProblemDomain.H"
#include "DisjointBoxLayout.H"
#include "NodeFArrayBox.H"
#include "LevelData.H"
#include "NodeCoarseAverage.H"
#include "NodeLevelOp.H"

#include "UsingNamespace.H"


class NodeLevelMG
{
public:



  NodeLevelMG();


  NodeLevelMG(const DisjointBoxLayout& a_grids,
              const DisjointBoxLayout* a_gridsCoarsePtr,
              const ProblemDomain&     a_domain,
              Real                     a_dx,
              int                      a_refToCoarse,
              const NodeLevelOp* const a_opin,
              int                      a_nCoarserLevels);


  NodeLevelMG(const DisjointBoxLayout& a_grids,
              const DisjointBoxLayout* a_gridsCoarsePtr,
              const Box&               a_domain,
              Real                     a_dx,
              int                      a_refToCoarse,
              const NodeLevelOp* const a_opin,
              int                      a_nCoarserLevels);


  ~NodeLevelMG();


  NodeLevelMG(NodeLevelMG&       a_L,
              int                a_refToCoarse,
              const NodeLevelOp* a_opin);


  void define(
              const DisjointBoxLayout& a_grids,
              const DisjointBoxLayout* a_gridsCoarsePtr,
              const ProblemDomain&     a_domain,
              Real                     a_dx,
              // refinement ratio to next coarser level (if any)
              int                      a_refToCoarse,
              const NodeLevelOp* const a_opin,
              int                      a_nCoarserLevels);


  void define(
              const DisjointBoxLayout& a_grids,
              const DisjointBoxLayout* a_gridsCoarsePtr,
              const Box&               a_domain,
              Real                     a_dx,
              // refinement ratio to next coarser level (if any)
              int                      a_refToCoarse,
              const NodeLevelOp* const a_opin,
              int                      a_nCoarserLevels);


  void define(
              const NodeLevelMG& a_L,
              int                a_refToCoarse,
              const NodeLevelOp* a_opin);

  // void clear();



  bool isDefined() const;



  void setnumSmoothUp(int a_numSmoothUp);


  void setnumSmoothDown(int a_numSmoothDown);


  void setVerbose(bool a_verbose);



  void mgRelax(
               LevelData<NodeFArrayBox>&       a_phi,
               const LevelData<NodeFArrayBox>& a_rhs,
               bool                            a_bottomsolveflag);

  NodeLevelOp* levelOpPtr();

  NodeLevelMG* lCoarsePtr();

protected:

  void setDefaultValues();

  void clearMemory();

  bool m_isDefined;

  bool m_verbose;

  //these are owned by NodeLevelMG

  LevelData<NodeFArrayBox> m_resid;

  LevelData<NodeFArrayBox> m_crseResid;

  LevelData<NodeFArrayBox> m_crseCorr;

  DisjointBoxLayout m_grids;

  DisjointBoxLayout m_coarsenedGrids;

  const DisjointBoxLayout* m_gridsCoarsePtr;

  Real m_dx;

  ProblemDomain m_domain;

  int m_nCoarserLevels;

  NodeLevelMG* m_lCoarsePtr;

  NodeLevelOp* m_levelopPtr;

  int m_numBottomPoints;

  int m_numSmoothUp;

  int m_numSmoothDown;

  int m_refToCoarsened;

  NodeCoarseAverage m_averageOp;

  Box m_boxRef;

  FArrayBox m_weights;

private:

  void crseCorrect(LevelData<NodeFArrayBox>& a_phi);

  void operator=(const NodeLevelMG& a_levmgin){};

  NodeLevelMG(const NodeLevelMG& a_levmgin) {};
};

#endif

---