---

BaseEBFaceFABI.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.
//
//  ANAG, LBNL

#ifndef _BaseEBFaceFABI_H_
#define _BaseEBFaceFABI_H_

/*************/
/*************/
template <class T> inline
const EBISBox& 
BaseEBFaceFAB<T>::getEBISBox() const
{
  return m_ebisBox;
}
/*************/
/*************/
template <class T>
inline void 
BaseEBFaceFAB<T>::copy(const Box& a_regionFrom, 
                       const Interval& a_dstInt, 
                       const Box& a_regionTo,
                       const BaseEBFaceFAB<T>& a_src, 
                       const Interval& a_srcInt)
{
  assert(a_regionFrom == a_regionTo);
  assert(isDefined());
  assert(a_dstInt.size()==a_srcInt.size());
  assert(a_regionTo.cellCentered());
  assert(a_src.m_iDir ==m_iDir);
  assert(a_dstInt.begin()>=0);
  assert(a_srcInt.begin()>=0);
  assert(a_srcInt.end()< a_src.m_nComp);
  assert(a_dstInt.end()< m_nComp);
  assert(a_src.m_region.contains(a_regionTo));
  assert(m_region.contains(a_regionTo));
  Box rcell = a_regionFrom;
  Box RFace = surroundingNodes(rcell, m_iDir);

  assert(m_regionFace.contains(RFace));
  //this one has to be rface because basefab does not know
  //from cell vs edge centered
  m_regFAB.copy(RFace, a_dstInt, RFace, a_src.m_regFAB, a_srcInt);
  //this has to be cell centered because that is how
  //it is defined.
  m_irrFAB.copy(rcell, a_dstInt, rcell, a_src.m_irrFAB, a_srcInt);
}
/**********************/
/**********************/
template <class T> inline
BaseEBFaceFAB<T>::BaseEBFaceFAB()
{
  setDefaultValues();
}

/**********************/
/**********************/
template <class T> inline
BaseEBFaceFAB<T>::BaseEBFaceFAB(const EBISBox& a_ebisBox, 
                                const Box& a_region, 
                                int a_iDir, int a_nComp)
{
  setDefaultValues();
  define(a_ebisBox, a_region, a_iDir, a_nComp);
}

/**********************/
/**********************/
template <class T> inline
void 
BaseEBFaceFAB<T>::define(const EBISBox&  a_ebisBox, 
                         const Box& a_region, 
                         int a_iDir, int a_nComp)
{
  clear();
  m_isDefined = true;
  assert(a_region.cellCentered());
  assert(!a_region.isEmpty());
  assert(a_nComp > 0);
  assert((a_iDir >= 0) && (a_iDir < SpaceDim));

  m_ebisBox = a_ebisBox;
  m_region = a_ebisBox.getRegion() & a_region;
  assert(!m_region.isEmpty());
  m_nComp = a_nComp;
  m_iDir = a_iDir;
  m_regionFace= surroundingNodes(m_region, a_iDir);

  m_regFAB.resize(m_regionFace, m_nComp);
  IntVectSet multiCells = m_ebisBox.getMultiCells(m_region);
  m_irrFAB.define(multiCells, m_ebisBox.getEBGraph(), m_iDir, m_nComp);
}

/**********************/
/**********************/
template <class T> inline
const IntVectSet&
BaseEBFaceFAB<T>::getMultiCells() const
{
  assert(isDefined());
  return(m_irrFAB.getIVS());
}
/**********************/
/**********************/
template <class T> inline
BaseEBFaceFAB<T>::~BaseEBFaceFAB()
{
  clear();
}

/**********************/
/**********************/
template <class T> inline
void
BaseEBFaceFAB<T>::clear()
{
  m_irrFAB.clear();
  m_regFAB.clear();
  m_isDefined = false;
}

/**********************/
/**********************/
template <class T> inline
void 
BaseEBFaceFAB<T>::setVal(T value)
{
  m_irrFAB.setVal(value);
  m_regFAB.setVal(value);
}


/**********************/
/**********************/
template <class T> inline
bool 
BaseEBFaceFAB<T>::isDefined() const
{
  return (m_isDefined);
}

/**********************/
/**********************/
template <class T> inline
int
BaseEBFaceFAB<T>::nComp() const 
{
  assert(isDefined());
  return m_nComp;
}

/**********************/
/**********************/
template <class T> inline
const BaseIFFAB<T>& 
BaseEBFaceFAB<T>::getMultiValuedFAB() const
{
  assert(isDefined());
  return m_irrFAB;
}

/**********************/
/**********************/
template <class T> inline
BaseIFFAB<T>& 
BaseEBFaceFAB<T>::getMultiValuedFAB() 
{
  assert(isDefined());
  return m_irrFAB;
}

/**********************/
/**********************/
template <class T> inline
const BaseFab<T>& 
BaseEBFaceFAB<T>::getSingleValuedFAB() const
{
  assert(isDefined());
  return m_regFAB;
}

/**********************/
/**********************/
template <class T> inline
BaseFab<T>& 
BaseEBFaceFAB<T>::getSingleValuedFAB() 
{
  assert(isDefined());
  return m_regFAB;
}

/**********************/
/**********************/
template <class T> inline
int 
BaseEBFaceFAB<T>::direction() const
{
  assert(isDefined());
  return m_iDir;
}

/**********************/
/**********************/
template <class T> inline
const Box& 
BaseEBFaceFAB<T>::getRegion() const 
{
  assert(isDefined());
  return m_regionFace;
}
/**********************/
/**********************/
template <class T> inline
const Box& 
BaseEBFaceFAB<T>::getCellRegion() const 
{
  assert(isDefined());
  return m_region;
}

/**********************/
/**********************/
template <class T> inline
T&
BaseEBFaceFAB<T>::operator()(const FaceIndex& a_facein, int  a_nCompLoc)
{
  assert(isDefined());
  assert((a_nCompLoc >= 0)&&(a_nCompLoc < m_nComp));
  const IntVect& ivlo = a_facein.gridIndex(Side::Lo);
  const IntVect& ivhi = a_facein.gridIndex(Side::Hi);
  assert(m_regionFace.contains(ivhi));

  const IntVectSet& multiVals = getMultiCells();
  T* returnval;
  if(multiVals.contains(ivlo) || multiVals.contains(ivhi))
    {
      returnval = &m_irrFAB(a_facein, a_nCompLoc);
    }
  else
    {
      returnval = &m_regFAB(ivhi, a_nCompLoc);
    }
  return *returnval;
}

/**********************/
/**********************/
template <class T> inline
const T&
BaseEBFaceFAB<T>::operator() (const FaceIndex& a_facein, int  a_nCompLoc) const
{
  assert(isDefined());
  assert((a_nCompLoc >= 0)&&(a_nCompLoc < m_nComp));
  const IntVect& ivlo = a_facein.gridIndex(Side::Lo);
  const IntVect& ivhi = a_facein.gridIndex(Side::Hi);
  assert(m_regionFace.contains(ivhi));

  const IntVectSet& multiVals = getMultiCells();
  const T* returnval;
  if(multiVals.contains(ivlo) || multiVals.contains(ivhi))
    {
      returnval = &m_irrFAB(a_facein, a_nCompLoc);
    }
  else
    {
      returnval = &m_regFAB(ivhi, a_nCompLoc);
    }
  return *returnval;
}

/**********************/
/**********************/
template <class T> inline
void
BaseEBFaceFAB<T>::setDefaultValues()
{
  m_isDefined = false;
  m_nComp = -1;
  m_iDir = -1;
}


#endif

---