GraphNode.H

Go to the documentation of this file.

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

//  ANAG, LBNL

#ifndef _GRAPHNODE_H_
#define _GRAPHNODE_H_

#include "REAL.H"
#include "ProblemDomain.H"
#include "IntVect.H"
#include "VolIndex.H"
#include "FaceIndex.H"
#include "Vector.H"
#include "NamespaceHeader.H"


class GraphNodeImplem
{
public:
  inline
  GraphNodeImplem();

  inline
  ~GraphNodeImplem();

  GraphNodeImplem& operator=(const GraphNodeImplem& a_impin);

  GraphNodeImplem(const GraphNodeImplem& a_impin);



  Vector<int>      m_arc[2*SpaceDim];


  int              m_coarserNode;

  // (for construction) index into node vector.
  int m_nodeInd;

  Vector<VolIndex> m_finerNodes;

  inline int index(int a_idir, Side::LoHiSide a_side) const;

  int linearSize() const;

  void linearOut(void* buffer ) const;

  void linearIn(void* buffer );

};


class GraphNode
{
public:

  inline GraphNode();


  inline ~GraphNode();

  int size() const;


  inline void clear();

  inline bool isRegular() const;


  inline bool isCovered() const;


  inline bool isIrregular() const;


  inline void defineAsRegular();


  inline void defineAsCovered();


  Vector<FaceIndex>
  getFaces(const VolIndex&       a_vof,
           const int&            a_idir,
           const Side::LoHiSide& a_sd,
           const ProblemDomain&  a_domain) const;

  Vector<FaceIndex>
  getFaces(const IntVect&        a_iv,
           const int&            a_idir,
           const Side::LoHiSide& a_sd,
           const ProblemDomain&  a_domain) const;


  Vector<VolIndex>
  getVoFs(const IntVect& a_iv) const;

  const GraphNode& operator=(const GraphNode& ebiin);

  GraphNode(const GraphNode& ebiin);


  Vector<VolIndex> refine(const VolIndex& a_coarVoF) const;


  VolIndex coarsen(const VolIndex& a_fineVoF) const;


  void addIrregularNode(const GraphNodeImplem& a_nodein, int cellIndex);

  void addIrregularNode(const GraphNodeImplem& a_nodein);


  Vector<Vector<VolIndex> >  getVoFSets(const Box& a_box) const;

  int linearSize() const;

  void linearOut(void* buffer ) const;

  void linearIn(void* buffer );

  inline void setDefaults();


  Vector<GraphNodeImplem>* m_cellList;

};

/*  inline functions */
/*******************************/
inline GraphNode::
~GraphNode()
{
  clear();
}
/*******************************/
inline bool GraphNode::
isRegular() const
{
  return (m_cellList==((Vector<GraphNodeImplem>*) 1));
}
/*******************************/
inline bool GraphNode::
isCovered() const
{
  return (m_cellList==((Vector<GraphNodeImplem>*) 0));
}
/*******************************/
inline bool GraphNode::
isIrregular() const
{
  return ((!isRegular()) && (!isCovered()));
}
/*******************************/
inline void GraphNode::
setDefaults()
{
  m_cellList = (Vector<GraphNodeImplem>*)1;
}

/*******************************/
inline GraphNode::
GraphNode()
{
  setDefaults();
}

/*******************************/
inline void GraphNode::
clear()
{
  if(isIrregular())
    {
      delete m_cellList;
    }
  setDefaults();
}

/*******************************/

inline void GraphNode::
defineAsRegular()
{
  clear();
  m_cellList = (Vector<GraphNodeImplem>*) 1;
}
/*******************************/

inline void GraphNode::
defineAsCovered()
{
  clear();
  m_cellList = (Vector<GraphNodeImplem>*) 0;
}

/*******************************/
inline GraphNodeImplem::
GraphNodeImplem()
  : m_coarserNode(-1), m_nodeInd(-1)
{
}
/*******************************/
inline GraphNodeImplem::
~GraphNodeImplem()
{
}

/*******************************/
inline int GraphNodeImplem::
index(int a_idir, Side::LoHiSide a_sd) const
{
  CH_assert(a_idir >= 0 && a_idir < SpaceDim);
  return a_idir + a_sd*CH_SPACEDIM;
}
/*
  if(a_sd == Side::Lo)
    {
      retval = a_idir;
    }
  else
    {
      retval = a_idir + SpaceDim;
    }
  return retval;
}
*/
#include "NamespaceFooter.H"
#endif

---