BinFabImplem.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.
//

#ifndef _BINFABIMPLEM_H_
#define _BINFABIMPLEM_H_

#include "BoxIterator.H"
#include "List.H"

//
// Implementation.=====================================
//

template <class T>
BinFab<T>::BinFab()
  : BaseFab<List<T> >(),
    m_origin(D_DECL(1.0e8, 1.0e8, 1.0e8)),
    m_mesh_spacing(D_DECL(0,0,0))
{
}

template <class T>
BinFab<T>::BinFab(const Box&           a_domain,
                  const RealVect&      a_mesh_spacing,
                  const RealVect&      a_origin,
                  const ProblemDomain& a_probdomain)
{
  define(a_domain, a_mesh_spacing, a_origin, a_probdomain);
}

template <class T>
BinFab<T>::BinFab(const BinFab& a_binfab)
{
  define(a_binfab.domain, a_binfab.m_mesh_spacing, a_binfab.m_origin,
         a_binfab.m_probdomain);

  copy(a_binfab);
}

template <class T>
BinFab<T>::~BinFab()
{
  this->undefine();
}

template <class T>
void BinFab<T>::define(const Box&           a_domain,
                       const RealVect&      a_mesh_spacing,
                       const RealVect&      a_origin,
                       const ProblemDomain& a_probdomain)
{
  this->domain = a_domain;
  this->nvar = 1;
  this->numpts = this->domain.numPts();

  BaseFab<List<T> >::define();

  m_mesh_spacing = a_mesh_spacing;
  m_origin = a_origin;
  m_probdomain = a_probdomain;
}

template <class T>
void BinFab<T>::reBin()
{
  // loop through each bin and determine if each binItem is
  // in the correct bin.
  BoxIterator bit(this->domain);
  int comp = 0;

  for (bit.begin(); bit.ok(); ++bit)
    {
      const IntVect thisIV = bit();
      List<T>& thisList = this->operator()(thisIV,comp);

      if (thisList.length() > 0)
        {
          // now index through the List and figure out which bin this
          // particle should be in
          ListIterator<T> thisLit(thisList);
          IntVect binLoc;

          for (thisLit.rewind(); thisLit; ++thisLit)
            {
              T& thisItem = thisList[thisLit];
              binLoc = locateBin(thisItem);

              if (binLoc != thisIV)
                {
                  // binItem needs to be moved.
                  // note that if binItem moves outside of domain, it is lost
                  if (this->domain.contains(binLoc))
                    this->operator()(binLoc,comp).append(thisItem);
#ifndef NDEBUG
                  else
                    cerr << "warning: BinFab::reBin() lost an item at " << binLoc << endl;
#endif
                  thisList.remove(thisLit);
                }
            } // end loop over items in this List of binItems
        } // end if this list has items
    } // end loop over bins
}

template <class T>
void BinFab<T>::addItem(const T& a_item)
{
    int comp = 0;
    IntVect binLoc = locateBin(a_item);

    if (this->domain.contains(binLoc))
      {
        this->operator()(binLoc,comp).append(a_item);
      }
}

template <class T>
void
BinFab<T>::addItems(const List<T>& a_List)
{
  if (a_List.length() > 0)
    {
      // loop through items in List, and add to appropriate locations
      ListIterator<T> lit(a_List);
      int comp = 0;
      IntVect binLoc;

      for (lit.rewind(); lit; ++lit)
        {
          const T& thisItem =  a_List[lit];
          binLoc = locateBin(thisItem);

          if (this->domain.contains(binLoc))
          {
            this->operator()(binLoc,comp).append(thisItem);
          }
        }
    }
}

//  [NOTE: this is mostly the same as the previous version, except for the inner loop]
template <class T>
void
BinFab<T>::addItemsDestructive(List<T>& a_List)
{
 if (a_List.length() > 0)
    {
      // loop through items in List, add to appropriate bins,
      // and remove from List
      ListIterator<T> lit(a_List);
      int comp = 0;
      IntVect binLoc;

      for (lit.rewind(); lit; )
        {
          const T& thisItem =  a_List[lit];
          binLoc = locateBin(thisItem);

          if (this->domain.contains(binLoc))  //[NOTE: BaseFab domain, not problem domain]
            {
              this->operator()(binLoc,comp).append(thisItem);
              a_List.remove(lit);
            }
          else
            {
              // removing a list element has the side-effect of moving the
              // iterator forward, so only increment explicitly if not removed
              ++lit;
            }
        }
    }
}


//  [NOTE: this is mostly the same as the previous version, except for the inner loop]
template <class T>
void
BinFab<T>::addItemsDestructive(List<T>& a_List ,const Box& a_valid ,bool a_in)
{
  assert( a_valid.cellCentered() );
  if (a_List.length() > 0) 
    {
      // loop through items in List, add to appropriate bins, 
      // and remove from List
      ListIterator<T> lit(a_List);
      int comp = 0;
      IntVect binLoc;

      for (lit.rewind(); lit; )
        {
          const T& thisItem =  a_List[lit];
          binLoc = locateBin(thisItem);
          if (this->domain.contains(binLoc))  //[NOTE: BaseFab domain, not problem domain]
            {
              this->operator()(binLoc,comp).append(thisItem);
              // If the a_in flag is true, then delete the particle from the
              // List if it is in the valid Box; if the a_in flag is false,
              // delete the particle if it is NOT in the Box.
              // Removing a list element has the side-effect of moving the
              // iterator forward, so explicitly increment the iterator only
              // if the particle was not removed.
              if( a_valid.contains(binLoc) )
                {
                  if( a_in ) a_List.remove(lit);
                  else     ++lit ;
                }
              else
                {
                  if( a_in ) ++lit;
                  else     a_List.remove(lit);
                }
            }
          else
            {
              // not added or removed, so increment the iterator
              ++lit;
            }
        }
    }  
}

template <class T>
void BinFab<T>::clear()
{
  this->undefine();

  this->domain = Box();
  this->nvar = 0;
  this->numpts = 0;
  m_origin = RealVect(D_DECL(1.0e8, 1.0e8, 1.0e8));
  m_mesh_spacing = RealVect(D_DECL(1.0e8, 1.0e8, 1.0e8));
}

template <class T>
int BinFab<T>::numItems(const Box& a_box, const Interval& a_comps) const
{
  int totalSize = 0;

  // default is an empty box, so use this BinFab's box instead
  // [NOTE: this leaves the caller no way to ask for an empty box;
  //       it must avoid calling this routine in that case. Sorry.]
  Box ibox = a_box;
  if (ibox.isEmpty())
    {
      ibox = this->box();
    }

  // default is an empty interval, so use all comps
  //[NOTE: see above NOTE]
  Interval comps = a_comps;
  if (comps.size() == 0)
    {
      comps = this->interval();
    }

  // iterate over all bins and components in the BinFab
  // [NOTE: making the "c" loop be inner would have better cache
  //       efficiency for large #s of comps, but would take more
  //       instructions and that will dominate for small ncomps.
  for (int c = comps.begin(); c <= comps.end(); ++c)
    {
      for (BoxIterator bi(ibox); bi.ok(); ++bi)
        {
          totalSize += this->operator()(bi(),c).length();
        }
    }

  return totalSize;
}

template <class T>
int
BinFab<T>::size(const Box& box, const Interval& comps) const
{
  int totalSize = 0;

  // First extract the size of the binItem.
  // Assumes all the items are the same size.
  int sizeOfT ;
  {
    T tmp ;
    sizeOfT = tmp.size() ;
  }

  // Count the number of items in the fab
  BoxIterator bit(box);
  for (int comp=comps.begin(); comp<=comps.end(); ++comp)
    {
      for (bit.begin(); bit.ok(); ++bit)
        {
          const List<T>& thisList = this->operator()(bit(), comp);
          totalSize += thisList.length();
        }
    }

  // totalSize now has total number of binItems.  now compute total size
  totalSize *= sizeOfT;

  // will also need to add an integer for each list to determine how
  // many binItems are in each list. (is this the right thing to do?)
  // alternate approach would be to simply unpack a List<T> on the other
  // end and then do an addItems call with that list.  that will probably
  // be slower, though.
  int numBins = box.numPts() * comps.size();
  totalSize += numBins * sizeof(int);

  return totalSize;
}

template <class T>
void BinFab<T>::linearOut(void* buf, const Box& R, const Interval& comps) const
{
  char* buf_ch = (char*)buf;
  // all we do in this function is loop over the box (and components),
  // and call linearOut on the individual items...
  BoxIterator bit(R);
  for (int comp=comps.begin(); comp<= comps.end(); ++comp)
    {
      for (bit.begin(); bit.ok(); ++bit)
        {
          const List<T>& thisList = this->operator()(bit(), comp);
          int *intBuffer = (int*)buf_ch;

          *intBuffer = thisList.length();
          buf_ch += sizeof(int);

          // now loop over the items in the list.
          ListIterator<T> lit(thisList);
          for (lit.rewind(); lit; ++lit)
            {
              thisList[lit].linearOut(buf_ch);
              buf_ch += thisList[lit].size();
            }
        }
    }
}

template <class T>
void BinFab<T>::linearIn(void* buf, const Box& R, const Interval& comps)
{
  // should be just the inverse of linearOut
  char *buf_ch = (char*)buf;

  BoxIterator bit(R);
  for (int comp = comps.begin(); comp <= comps.end(); ++comp)
    {
      for (bit.begin(); bit.ok(); ++bit)
        {
          List<T>& thisList = this->operator()(bit(), comp);
          int numItems = *((int*)buf_ch);

          buf_ch += sizeof(int);

          if (numItems > 100000)
            {
              cout << " [error: numItems=" << numItems << "] ";
              numItems = 1;
            }

          for (int n = 0; n < numItems; ++n)
            {
              T thisBinItem;

              thisBinItem.linearIn( buf_ch );
              thisList.append(thisBinItem);
              buf_ch += thisBinItem.size();
            }
        }
    }
}

template <class T>
IntVect BinFab<T>::locateBin(const T& a_binItem) const
{
  IntVect binLoc;
  RealVect thisPos = a_binItem.position();

  thisPos -= m_origin;
  thisPos /= m_mesh_spacing;

  for (int d=0; d<SpaceDim; ++d)
    {
      // handle periodic domain
      if (m_probdomain.isPeriodic(d))
        {
          binLoc[d] = (int) thisPos[d] % m_probdomain.domainBox().size(d);
        }
      else
        {
          binLoc[d] = (int) thisPos[d];
          // need to shift by one if negative
          if (thisPos[d] < 0) --binLoc[d];
        }
    }

  return binLoc;
}

#endif

---