---

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 CH_BINFABIMPLEM_H
#define CH_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()
{
  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)
{
  domain = a_domain;
  nvar = 1;
  numpts = domain.numPts();
  
  BaseFab<List<T> >::define();
  
  m_mesh_spacing = a_mesh_spacing;
  m_origin = a_origin;
  // periodic stuff not implemented yet
  assert (!a_probdomain.isPeriodic());
  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(domain);
  int comp = 0;
  
  for (bit.begin(); bit.ok(); ++bit) 
    {
      const IntVect thisIV = bit();      
      List<T>& thisList = 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;
          //RealVect thisPos;
          
          for (thisLit.rewind(); thisLit; ++thisLit)
            {
              T& thisItem = thisList[thisLit];

#if 0 
              // moved bin-location stuff into separate function
              thisPos = thisItem.position();
              thisPos -= m_origin;
              thisPos /= m_mesh_spacing;
              D_TERM( binLoc[0] = (int) thisPos[0]; ,
                      binLoc[1] = (int) thisPos[1]; ,
                      binLoc[2] = (int) thisPos[2]; );
#endif

              binLoc = locateBin(thisItem);
              
              if (binLoc != thisIV) 
                {
                  // binItem needs to be moved.
                  // note that if binItem moves outside of domain, it is lost
                  
                  if (domain.contains(binLoc)) 
                    operator()(binLoc,comp).append(thisItem);
                  
                  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 (domain.contains(binLoc))
        operator()(binLoc,comp).append(a_item) ;
}

template <class T>
void
BinFab<T>::addItems(const List<T>& a_List)
{
  // loop through items in List, and add to appropriate locations
  ListIterator<T> lit(a_List);

  int comp = 0;
  IntVect binLoc;
  //RealVect thisPos;

  if (a_List.length() > 0) 
    {
      for (lit.rewind(); lit; ++lit)
        {

          // want to put bin-location stuff in a separate function
          const T& thisItem =  a_List[lit];
#if 0          
          // want to put bin-location stuff in a separate function
          thisPos = thisItem.position();
          thisPos -= m_origin;
          thisPos /= m_mesh_spacing;
          
          D_TERM( binLoc[0] = (int) thisPos[0]; ,
                  binLoc[1] = (int) thisPos[1]; ,
                  binLoc[2] = (int) thisPos[2]; );
#endif
          binLoc = locateBin(thisItem);
          
          if (domain.contains(binLoc))
            operator()(binLoc,comp).append(thisItem);
        }
    }
}

template <class T>
void
BinFab<T>::addItemsDestructive(List<T>& a_List)
{
  // loop through items in List, add to appropriate bins, 
  // and remove from List
  ListIterator<T> lit(a_List);
  int comp = 0;
  IntVect binLoc;

  if (a_List.length() > 0) 
    {
      for (lit.rewind(); lit; ++lit)
        {
          const T& thisItem =  a_List[lit];
          binLoc = locateBin(thisItem);
          if (domain.contains(binLoc))
            {
              operator()(binLoc,comp).append(thisItem);
              a_List.remove(lit);
            }
        }
    }
}

template <class T>
void
BinFab<T>::clear()
{
  undefine();
  
  domain = Box();
  nvar = 0;
  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>::size(const Box& box, const Interval& comps) const
{
  int totalSize=0;
  BoxIterator bit(box);

  // first extract the size of the binItem:
  bit.begin();
  const List<T>& thisList = operator()(bit(), comps.begin());
  int sizeOfT = thisList.firstElement().size();

  for (int comp=comps.begin(); comp<= comps.end(); comp++) 
    {
      for (bit.begin(); bit.ok(); ++bit) 
        {
          const List<T>& thisList = 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();
  totalSize += numBins*sizeof(int);

  return totalSize;

}

template <class T> 
void
BinFab<T>::linearOut(void* buf, const Box& R, const Interval& comps) const
{
  // 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 = operator()(bit(), comp);
          int* intBuffer = (int*)buf;
          *intBuffer = thisList.length();

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

template <class T>
void
BinFab<T>::linearIn(void* buf, const Box& R, const Interval& comps)
{
  // should be just the inverse of linearOut
  BoxIterator bit(R);
  for (int comp= comps.begin(); comp<= comps.end(); ++comp)
    {
      for (bit.begin(); bit.ok(); ++bit) 
        {
          List<T>& thisList = operator()(bit(), comp);
          int* intBuffer = (int*)buf;
          int numItems = *intBuffer;
          for (int n=0; n<numItems; ++n)
            {
              T thisBinItem;
              thisBinItem.linearIn(buf);
              thisList.append(thisBinItem);
            }
        }
    }

}

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;

  D_TERM( binLoc[0] = (int) thisPos[0]; ,
          binLoc[1] = (int) thisPos[1]; ,
          binLoc[2] = (int) thisPos[2]; );

  return binLoc;
}

  

#endif 

---