IVSFABI.H

Go to the documentation of this file.

/*   _______              __
    / ___/ /  ___  __ _  / /  ___
   / /__/ _ \/ _ \/  V \/ _ \/ _ \
   \___/_//_/\___/_/_/_/_.__/\___/
*/
// CHOMBO Copyright (c) 2000-2004, The Regents of the University of
// California, through Lawrence Berkeley National Laboratory (subject to
// receipt of any required approvals from U.S. Dept. of Energy).  All
// rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// (1) Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// (2) Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// (3) Neither the name of Lawrence Berkeley National Laboratory, U.S.
// Dept. of Energy nor the names of its contributors may be used to endorse
// or promote products derived from this software without specific prior
// written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
// PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
// OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// You are under no obligation whatsoever to provide any bug fixes,
// patches, or upgrades to the features, functionality or performance of
// the source code ("Enhancements") to anyone; however, if you choose to
// make your Enhancements available either publicly, or directly to
// Lawrence Berkeley National Laboratory, without imposing a separate
// written license agreement for such Enhancements, then you hereby grant
// the following license: a non-exclusive, royalty-free perpetual license
// to install, use, modify, prepare derivative works, incorporate into
// other computer software, distribute, and sublicense such Enhancements or
// derivative works thereof, in binary and source code form.
//
// TRADEMARKS. Product and company names mentioned herein may be the
// trademarks of their respective owners.  Any rights not expressly granted
// herein are reserved.
//

#ifndef _IVSFABI_H_
#define _IVSFABI_H_

#include "MayDay.H"
#include "IntVectSet.H"
#include "parstream.H"
#include "SPMD.H"
#include "DebugOut.H"
#include "SPMD.H"

template <class T>
bool IVSFAB<T>::s_verbose = false;

template <class T>
void
IVSFAB<T>::setVerbose(bool a_verbose)
{
  s_verbose = a_verbose;
}
/*************/
template <class T> inline
const IntVectSet&
IVSFAB<T>::getIVS() const
{
  return m_ivs;
}
/******************/
template <class T> inline
IVSFAB<T>::IVSFAB()
{
  setDefaultValues();
}
/******************/
template <class T> inline
IVSFAB<T>::~IVSFAB()
{
  clear();
}
/******************/
template <class T> inline
IVSFAB<T>::IVSFAB(const IntVectSet& a_ivsin,
                        const int&        a_nvarin)
{
  setDefaultValues();
  define(a_ivsin, a_nvarin);
}
/******************/
template <class T> inline
void
IVSFAB<T>::define(const IntVectSet& a_ivsin,
                     const int& a_nvarin)
{
  clear();
  m_isDefined = true;
 CH_assert(a_nvarin > 0);
  m_ivs = a_ivsin;
  m_nComp = a_nvarin;
  m_nIvs = 0;
  if(!a_ivsin.isEmpty())
    {
      Box minbox = a_ivsin.minBox();
      m_ivmap.resize(minbox, 1);
      IVSIterator ivsit(a_ivsin);
      for(ivsit.reset(); ivsit.ok(); ++ivsit)
        {
          const IntVect& iv = ivsit();
          m_ivmap(iv,0) = m_nIvs;
          m_nIvs++;
        }

      if( (m_nIvs > 0) && m_nComp > 0)
        {
          m_dataPtr = new T[m_nComp*m_nIvs];
        }
      else
        {
          m_dataPtr = NULL;
        }
    }
  else
    {
      m_dataPtr = NULL;
    }
  if(m_nIvs > 0)
    {
      //set up face low and high vectors
      for (int dir = 0; dir < CH_SPACEDIM; ++dir)
        {
          m_loVect[dir] = 1;
          m_hiVect[dir] = 1;
        }
      m_hiVect[0] = m_nIvs;

    }
  else
    {
      m_loVect = IntVect::Unit;
      m_hiVect = IntVect::Zero;
      m_dataPtr = NULL;
    }

}
/******************/
template <class T> inline
void
IVSFAB<T>::setVal(const T& a_value)
{
 CH_assert(isDefined());
  for(int ivec = 0; ivec < m_nIvs*m_nComp; ivec++)
    m_dataPtr[ivec] = a_value;
}
/******************/
template <class T> inline
void
IVSFAB<T>::copy(const Box& a_fromBox,
                   const Interval& a_dstInterval,
                   const Box& a_toBox,
                   const IVSFAB<T>& a_src,
                   const Interval& a_srcInterval)
{
 CH_assert(a_fromBox == a_toBox);
 CH_assert(isDefined());
 CH_assert(a_src.isDefined());
 CH_assert(a_srcInterval.size() == a_dstInterval.size());
 CH_assert(a_dstInterval.begin() >= 0);
 CH_assert(a_srcInterval.begin() >= 0);
 CH_assert(a_dstInterval.end()   < m_nComp);
 CH_assert(a_srcInterval.end()   < a_src.m_nComp);

  if((!m_ivs.isEmpty()) && (!a_src.m_ivs.isEmpty()))
    {
      Box intBox = a_fromBox;
      IntVectSet ivsIntersect = m_ivs;
      ivsIntersect &= a_src.m_ivs; //how did this ever work without this line?
      ivsIntersect &= intBox;  //
      IVSFAB<T>& thisFAB = *this;
      int compSize = a_srcInterval.size();
      for(IVSIterator ivit(ivsIntersect); ivit.ok(); ++ivit)
        {
          const IntVect& iv = ivit();
          for(int icomp = 0; icomp < compSize; icomp++)
            {
              int isrccomp = a_srcInterval.begin() + icomp;
              int idstcomp = a_dstInterval.begin() + icomp;
              thisFAB(iv, idstcomp) = a_src(iv, isrccomp);
            }
        }
    }
}
/******************/
template <class T> inline
int IVSFAB<T>::size(const Box& a_region,
                       const Interval& a_comps) const
{
  MayDay::Error();
  return 0; // to prevent compiler error, but function should prolly be void?
}
/********************/
template <class T> inline
void IVSFAB<T>::linearOut(void* a_buf,
                             const Box& a_region,
                             const Interval& a_comps) const
{
  MayDay::Error();
}
/********************/
template <class T> inline
void IVSFAB<T>::linearIn(void* a_buf, const Box& a_region, const Interval& a_comps)
{
  MayDay::Error();
}

template <class T> inline
int
IVSFAB<T>::getIndex(const IntVect& a_iv, const int& a_comp) const
{
 CH_assert(isDefined());
 CH_assert(m_ivs.contains(a_iv));
 CH_assert((a_comp >= 0) && (a_comp < m_nComp));

  int ioffset = m_ivmap(a_iv, 0);
 CH_assert(ioffset >= 0);
 CH_assert(ioffset < m_nIvs);
  //now add offset from componentnitude
  ioffset += m_nIvs*a_comp;
  return ioffset;
}
/********************/
template <class T> inline
void
IVSFAB<T>::clear()
{
  m_nComp = 0;
  m_nIvs = 0;
  m_ivs.makeEmpty();
  m_ivmap.clear();
  if(m_dataPtr != NULL)
    {
      delete[] m_dataPtr;
      m_dataPtr = NULL;
    }
  m_isDefined = false;
}
/*************************/
template <class T> inline
bool
IVSFAB<T>::isDefined() const
{
  return (m_isDefined);
}
/*************************/
template <class T> inline
int
IVSFAB<T>::numIvs() const
{
  return m_nIvs;
}
/*************************/
template <class T> inline
int
IVSFAB<T>::nComp() const
{
  return m_nComp;
}
/*************************/
template <class T> inline
T&
IVSFAB<T>::operator() (const IntVect& a_ndin,
                       const int& a_comp)
{
 CH_assert(isDefined());
 CH_assert(a_comp >= 0);
 CH_assert(a_comp < m_nComp);
  int iloc = getIndex(a_ndin, a_comp);
  return(m_dataPtr[iloc]);
}
/**************************/
template <class T> inline
const T&
IVSFAB<T>::operator() (const IntVect& a_ndin,
                       const int& a_comp) const
{
 CH_assert(isDefined());
 CH_assert(a_comp >= 0);
 CH_assert(a_comp < m_nComp);
  int iloc = getIndex(a_ndin, a_comp);
  return(m_dataPtr[iloc]);
}
/******************/
template <class T> inline
const T*
IVSFAB<T>::dataPtr(const int& a_comp) const
{
 CH_assert(isDefined());
 CH_assert(a_comp >= 0);
 CH_assert(a_comp < m_nComp);
  return m_dataPtr + a_comp*m_nIvs;
}
/******************/
template <class T> inline
T*
IVSFAB<T>::dataPtr(const int& a_comp)
{
 CH_assert(isDefined());
 CH_assert(a_comp >= 0);
 CH_assert(a_comp < m_nComp);
  return m_dataPtr + a_comp*m_nIvs;
}
/******************/
template <class T> inline
const int*
IVSFAB<T>::loVect() const
{
  return m_loVect.getVect();
}
/******************/
template <class T> inline
const int*
IVSFAB<T>::hiVect() const
{
  return m_hiVect.getVect();
}
/******************/
template <class T> inline
void
IVSFAB<T>::setDefaultValues()
{
  m_isDefined = false;
  m_dataPtr = NULL;
  m_nIvs = 0;
  m_nComp = 0;
  m_loVect = IntVect::Unit;
  m_hiVect = IntVect::Zero;
}
/******************/
template <class T> inline
IVSFAB<T>&
IVSFAB<T>::operator= (const IVSFAB<T>& a_input)
{
  MayDay::Error("IVSFAB operator = not defined");
  return *this;
}
/******************/
template <class T> inline
IVSFAB<T>::IVSFAB (const IVSFAB<T>& a_input)
{
  MayDay::Error("IVSFAB copy constructor not defined");
}

#endif

---