---

NodeLevelMG.H

Go to the documentation of this file.

/*  _______              __
   / ___/ /  ___  __ _  / /  ___
  / /__/ _ \/ _ \/  ' \/ _ \/ _ \
  \___/_//_/\___/_/_/_/_.__/\___/ 
*/
//
// 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.
//

// 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 <assert.h>
#include <cstdlib>
#include "REAL.H"
#include "ProblemDomain.H"
#include "DisjointBoxLayout.H"
#include "NodeFArrayBox.H"
#include "LevelData.H"
#include "NodeMaskAverage.H"
#include "NodeMaskLevelOp.H"
#include "NodeMGInterp.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 NodeMaskLevelOp* 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 NodeMaskLevelOp* const a_opin,
              int                          a_nCoarserLevels);

  ~NodeLevelMG();


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


  void define(const DisjointBoxLayout&     a_grids,
              const DisjointBoxLayout*     a_gridsCoarsePtr,
              const ProblemDomain&         a_domain,
              Real                         a_dx,
              int                          a_refToCoarse,
              const NodeMaskLevelOp* const a_opin,
              int                          a_nCoarserLevels);

  void define(const DisjointBoxLayout&     a_grids,
              const DisjointBoxLayout*     a_gridsCoarsePtr,
              const Box&                   a_domain,
              Real                         a_dx,
              int                          a_refToCoarse,
              const NodeMaskLevelOp* const a_opin,
              int                          a_nCoarserLevels);


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

  void clear();



  bool isDefined() const;



  void setnumBottomGSRB(int a_numBottomGSRB);


  void setnumSmoothUp(int a_numSmoothUp);


  void setnumSmoothDown(int a_numSmoothDown);


  void setVerbose(bool a_verbose)
  {m_verbose = a_verbose;}



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

  // this is a dangerous access function that should not generally be used.
  NodeMaskLevelOp* levelOpPtr();

  // this is another access function that is kinda bad
  NodeLevelMG* lCoarsePtr();

protected:
  
  void setDefaultValues();
  void clearMemory();
  bool m_isDefined;

  bool m_verbose;

  //these are owned by NodeLevelMG
  // residual at this level
  LevelData<NodeFArrayBox> m_resid;

  // residual at next coarser level
  LevelData<NodeFArrayBox> m_crseResid;

  // correction at next coarser level
  LevelData<NodeFArrayBox> m_crseCorr;
  
  // grids at this level
  DisjointBoxLayout m_grids;

  // grids at next coarser level
  DisjointBoxLayout m_coarsenedGrids;

  // pointer to grids at next coarser level, or NULL if no coarser level
  const DisjointBoxLayout* m_gridsCoarsePtr;
    
  // mesh spacing at this level
  Real m_dx;
    
  // physical domain at this level
  ProblemDomain m_domain;

  // number of coarser levels
  int m_nCoarserLevels;

  // coarser level
  NodeLevelMG* m_lCoarsePtr;

  // das operator
  NodeMaskLevelOp* m_levelopPtr;
    
  //
  int m_numBottomGSRB;

  //
  int m_numSmoothUp;

  //
  int m_numSmoothDown;

  // refinement ratio to next coarser level
  int m_refToCoarsened;

  //
  NodeMaskAverage m_averageOp;

  //
  NodeMGInterp m_mginterp;

private:
  // correct a_phi on intersection with m_crseCorr
  //should only be called internally because this
  //is not written for general LevelData<NodeFArrayBox>es
  void crseCorrect(LevelData<NodeFArrayBox>& a_phi);

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

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

#endif

---