---

BaseEBCellFABI.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 _BaseEBCellFABI_H_
#define _BaseEBCellFABI_H_

#include "BoxIterator.H"
/**********************/
/**********************/
template <class T>
 void
BaseEBCellFAB<T>::setCoveredCellVal(const T& a_val,
                                    const int& a_comp)
{
  assert(a_comp >= 0);
  assert(a_comp < m_nComp);

  if(m_ebisBox.isAllRegular())
    {
      return;
    }
  else if(m_ebisBox.isAllCovered())
    {
      m_regFAB.setVal(a_val, a_comp);
    }
  else
    {
      for(BoxIterator bit(m_region); bit.ok(); ++bit)
        {
          const IntVect& iv = bit();
          if(m_ebisBox.isCovered(iv))
            {
              m_regFAB(iv, a_comp) = a_val;
            }
        }
      //also set the multivalued cells
      for(IVSIterator ivsit(getMultiCells()); 
          ivsit.ok(); ++ivsit)
        {
          const IntVect& iv = ivsit();
          m_regFAB(iv, a_comp) = a_val;
        }
      //also set the multivalued cells
    }
}
/*************/
/*************/
template <class T>
 void 
BaseEBCellFAB<T>::copy(const Box& a_RegionFrom, 
                       const Interval& a_dstInt, 
                       const Box& a_RegionTo, 
                       const BaseEBCellFAB<T>& a_src, 
                       const Interval& a_srcInt)
{
  assert(a_RegionFrom == a_RegionTo);
  assert(isDefined());
  assert(a_dstInt.size()==a_srcInt.size());
  assert(a_dstInt.begin()>=0);
  assert(a_srcInt.begin()>=0);
  assert(a_srcInt.end()< a_src.m_nComp);
  assert(a_dstInt.end()< m_nComp);
  Box domain = m_ebisBox.getDomain();

  Box rboxFrom = a_RegionFrom & domain;
  Box rboxTo = a_RegionTo & domain;
  
  if(!rboxFrom.isEmpty() && !rboxTo.isEmpty())
    {
      assert(a_src.m_region.contains(rboxFrom));
      assert(m_region.contains(rboxTo));

      m_regFAB.copy(rboxFrom, a_dstInt,rboxTo, a_src.m_regFAB, a_srcInt);
      m_irrFAB.copy(rboxFrom, a_dstInt,rboxTo, a_src.m_irrFAB, a_srcInt);
    }
}

/*************/
/*************/
/*************/
/*************/
template <class T> 
 int
BaseEBCellFAB<T>::size(const Box& R, const Interval& comps) const
{
  int retval =  regSize(R, comps);
  retval += m_irrFAB.size(R, comps);
  return retval;
}

/*************/
/*************/
template <class T> 
 int
BaseEBCellFAB<T>::regSize(const Box& R, const Interval& comps) const
{
  Box subbox = R & m_region;
  int retval= sizeof(Real)*subbox.numPts()*comps.size();
  return retval;
}

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

template <class T> 
 void 
BaseEBCellFAB<T>::regLinearOut(void* buf, const Box& R, const Interval& comps)
  const
{
  Box subbox = R & m_region;
  Real* dataOut = (Real*) buf;
  int idataOut = 0;
  int irealsize = regSize(R,comps)/sizeof(Real);

  for(BoxIterator bit(subbox); bit.ok(); ++bit)
    {
      const IntVect& iv = bit();
      for(int ivar = comps.begin(); ivar <= comps.end(); ++ivar)
        {
          assert(idataOut < irealsize);
          dataOut[idataOut] = m_regFAB(iv, ivar);
          idataOut++;
        }
    }
}
/*************/
/*************/
template <class T> 
 void 
BaseEBCellFAB<T>::regLinearIn(void* buf, const Box& R, const Interval& comps)
{
  const Real* dataIn = (const Real*) buf;
  int idataIn = 0;
  int irealsize = regSize(R,comps)/sizeof(Real);
  Box subbox = R & m_region;
  
  for(BoxIterator bit(subbox); bit.ok(); ++bit)
    {
      const IntVect& iv = bit();
      for(int ivar = comps.begin(); ivar <= comps.end(); ++ivar)
        {
          assert(idataIn < irealsize);
          Real inputVal = dataIn[idataIn] ;
          m_regFAB(iv, ivar) = inputVal;
          idataIn++;
        }
    }
}
/*************/
/*************/
template <class T> 
 void 
BaseEBCellFAB<T>::linearOut(void* buf, const Box& R, const Interval& comps)
  const
{
  regLinearOut(buf, R, comps);
  unsigned char* buffer = (unsigned char*)buf;
  buffer+= regSize(R, comps);
  m_irrFAB.linearOut(buffer, R, comps);
}
/*************/
/*************/
template <class T> 
 void 
BaseEBCellFAB<T>::linearIn(void* buf, const Box& R, const Interval& comps)
{
  regLinearIn(buf, R, comps);
  unsigned char* buffer = (unsigned char*)buf;
  buffer+= regSize(R, comps);
  m_irrFAB.linearIn(buffer, R, comps);
}


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

/*************/
/*************/
template <class T> 
BaseEBCellFAB<T>::BaseEBCellFAB()
{
  setDefaultValues();
}

/*************/
/*************/
template <class T> 
BaseEBCellFAB<T>::BaseEBCellFAB(const EBISBox& a_ebisBox, 
                                const Box& a_region, int a_nVar)
{
  setDefaultValues();
  define(a_ebisBox, a_region, a_nVar);
}

/*************/
/*************/
template <class T> 
void 
BaseEBCellFAB<T>::define(const EBISBox& a_ebisBox, 
                         const Box& a_region, int a_nVar)
{
  clear();
  m_isDefined = true;
  assert(a_region.cellCentered());
  assert(a_nVar > 0);
  assert(!a_region.isEmpty());
  m_region = a_region & a_ebisBox.getRegion();
  assert(!m_region.isEmpty());
  m_nComp = a_nVar;
  m_ebisBox = a_ebisBox;

  m_regFAB.resize(m_region, m_nComp);
  m_isMultiValued.resize(m_region, 1);
  m_isMultiValued.setVal(false);
  //add all the multi-valued
  //cells to m_multiValued
  IntVectSet multiCells = 
    m_ebisBox.getMultiCells(m_region);

  for(IVSIterator ivsit(multiCells); ivsit.ok(); ++ivsit)
    m_isMultiValued(ivsit(), 0) = true;

  //define irregular fab to be over multi-valued cells.
  m_irrFAB.define(multiCells, m_ebisBox.getEBGraph(), m_nComp);
}

/*************/
/*************/
template <class T> 

BaseEBCellFAB<T>::~BaseEBCellFAB()
{
  clear();
}

/*************/
/*************/
template <class T> 
void
BaseEBCellFAB<T>::clear()
{
  m_irrFAB.clear();
  m_regFAB.clear();
  m_isMultiValued.clear();
  m_nComp = 0;
  m_isDefined = false;
}
/*************/
/*************/
template <class T> 
void
BaseEBCellFAB<T>::setVal(T value)
{
  m_irrFAB.setVal(value);
  m_regFAB.setVal(value);
}

/*************/
/*************/
template <class T> 
bool 
BaseEBCellFAB<T>::isDefined() const
{
  return (m_isDefined);
}
/*************/
/*************/
template <class T> 
int 
BaseEBCellFAB<T>::nComp() const 
{
  assert(isDefined());
  return m_nComp;
}
/*************/
/*************/
template <class T> 
const Box& 
BaseEBCellFAB<T>::getRegion() const 
{
  assert(isDefined());
  return m_region;
}
/*************/
/*************/
template <class T>
const Box&
BaseEBCellFAB<T>::box() const
{
    return getRegion();
}


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

//
/*************/
/*************/
template <class T> 
BaseIVFAB<T>& 
BaseEBCellFAB<T>::getMultiValuedFAB() 
{
  assert(isDefined());
  return m_irrFAB;
}

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

//
/*************/
/*************/
template <class T> 
BaseFab<T>& 
BaseEBCellFAB<T>::getSingleValuedFAB() 
{
  assert(isDefined());
  return m_regFAB;
}
/*************/
/*************/
template <class T> 
const T&
BaseEBCellFAB<T>::operator()(const VolIndex& a_ndin,int  a_nVarLoc) const
{
  assert(isDefined());
  assert(!m_ebisBox.isCovered(a_ndin.gridIndex()));
  assert(m_region.contains(a_ndin.gridIndex()));
  assert((a_nVarLoc >= 0)&&(a_nVarLoc < m_nComp));

  const T* returnval = NULL;
  if(m_isMultiValued(a_ndin.gridIndex()))
    {
      returnval = &(m_irrFAB(a_ndin,a_nVarLoc));
    }
  else
    {
      returnval = &(m_regFAB(a_ndin.gridIndex(), a_nVarLoc));
    }
  return *returnval;
}
/*************/
/*************/
template <class T> 
T&
BaseEBCellFAB<T>::operator()(const VolIndex& a_ndin,int  a_nVarLoc)
{
  assert(isDefined());
  assert(m_region.contains(a_ndin.gridIndex()));
  assert((a_nVarLoc >= 0)&&(a_nVarLoc < m_nComp));
  assert(!m_ebisBox.isCovered(a_ndin.gridIndex()));

  T* returnval = NULL;
  if(m_isMultiValued(a_ndin.gridIndex()))
    {
      returnval = &(m_irrFAB(a_ndin,a_nVarLoc));
    }
  else
    {
      returnval = &(m_regFAB(a_ndin.gridIndex(), a_nVarLoc));
    }
  return *returnval;
}
/*************/
/*************/
template <class T> 
void
BaseEBCellFAB<T>:: setDefaultValues()
{
  m_isDefined = false;
  m_nComp = 0;
}
/*************/
/*************/
template <class T> 
const EBISBox& 
BaseEBCellFAB<T>::getEBISBox() const
{
  return m_ebisBox;
}

#endif

---