VolIndex.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 _VOLINDEX_H_
#define _VOLINDEX_H_

#include "REAL.H"
#include "IntVect.H"
#include "SPMD.H"
#include "NamespaceHeader.H"


class VolIndex
{
public:
  inline
  VolIndex();

  //~VolIndex(); compiler generated is fine

  //VolIndex& operator= (const VolIndex& a_vofin);

  inline
  bool operator== (const VolIndex& a_vofin) const;

  inline
  const IntVect& gridIndex() const;

  inline
  int cellIndex() const;

  inline
  bool isDefined() const;

  // VolIndex(const VolIndex& a_vofin);

  void define(const VolIndex& a_vofin);

  inline
  VolIndex(const IntVect& a_ix,const  int& a_vofID);

  inline
  void define(const IntVect& a_ix,const  int& a_vofID);

  inline
  bool operator<(const VolIndex& rhs) const;

  inline
  bool operator!=(const VolIndex& rhs) const;
  int linearSize() const;
  void linearOut(void* const a_outBuf) const;
  void linearIn(const void* const inBuf);
  //  not for users
  static size_t iv_offset, index_offset;
  static int initializeOffsets();

private:

  //cell of the VolIndex
  IntVect m_iv;

  //which VoF in the cell (0 to nVoF-1)
  int m_cellIndex;

  bool m_isDefined;
};

std::ostream& operator<< (std::ostream&       os,
                          const VolIndex& iv);

inline bool VolIndex::operator<(const VolIndex& rhs) const
{
  if(m_iv.lexLT(rhs.m_iv)) return true;
  if(m_iv == rhs.m_iv) {
    return m_cellIndex < rhs.m_cellIndex;
  }
  return false;
}
/*****************************************/
inline
const IntVect&
VolIndex::gridIndex() const
{
  return m_iv;
}

/*****************************************/
inline
int
VolIndex::cellIndex() const
{
  return m_cellIndex;
}
/*****************************************/
inline void
VolIndex::define(const IntVect& a_ix,const int& a_vofID)
{
  m_isDefined = true;
  m_iv = a_ix;
  m_cellIndex = a_vofID;
}
/*****************************************/
inline
VolIndex::VolIndex(const IntVect& a_ix,const int& a_vofID)
  :m_iv(a_ix), m_cellIndex(a_vofID), m_isDefined(true)
{
  ;
}
/*****************************************/
inline bool
VolIndex::isDefined() const
{
  return m_isDefined;
}

/*****************************************/
inline
VolIndex::VolIndex()
  :m_iv(IntVect::Zero), m_cellIndex(-1), m_isDefined(false)
{
  //set index to bogus number to make undefined
  //ones catchable.

}

inline bool
VolIndex::operator== (const VolIndex& a_vofin) const
{
  return ((m_iv == a_vofin.m_iv)&&
          (m_cellIndex == a_vofin.m_cellIndex));
}

inline bool
VolIndex::operator!=(const VolIndex& rhs) const
{
  return !(*this == rhs);
}

#include "NamespaceFooter.H"
#endif

---