src/Particle/ParticleAttrib.h

Go to the documentation of this file.

// -*- C++ -*-
/***************************************************************************
 *
 * The IPPL Framework
 * 
 *
 * Visit http://people.web.psi.ch/adelmann/ for more details
 *
 ***************************************************************************/

#ifndef PARTICLE_ATTRIB_H
#define PARTICLE_ATTRIB_H

/*
 * ParticleAttrib - Templated class for all particle attribute classes.
 *
 * This templated class is used to represent a single particle attribute.
 * An attribute is one data element within a particle object, and is
 * stored as an array.  This class stores the type information for the
 * attribute, and provides methods to create and destroy new items, and
 * to perform operations involving this attribute with others.  It also
 * provides iterators to allow the user to operate on single particles
 * instead of the entire array.
 *
 * ParticleAttrib is the primary element involved in expressions for
 * particles (just as Field is the primary element there).  This file
 * defines the necessary templated classes and functions to make
 * ParticleAttrib a capable expression-template participant.
 *
 * For some types such as Vektor, Tenzor, etc. which have multipple items,
 * we want to involve just the Nth item from each data element in an 
 * expression.  The () operator here returns an object of type
 * ParticleAttribElem, which will use the () operator on each individual
 * element to access an item over which one can iterate and get just the
 * Nth item from each data element.  For example, if we have an attribute
 * like this:
 *             ParticleAttrib< Vektor<float, 4> > Data
 * we can involve just the 2nd item of each Vektor in an expression by
 * referring to this as
 *             Data(1)
 * which returns an object of type ParticleAttribElem that knows to return
 * just the 2nd item from each Vektor.  ParticleAttribElem is also expression-
 * template-aware; in fact, it is intended primarily for use in expressions
 * and not in many other situations.  The ParticleAttribElem will use the
 * () operator to get the Nth item out of each data element, so this requires
 * the user to define operator () for the particle attribute type being
 * used (for Vektor, Tenzor, etc., this has already been done).  This same
 * thing has been done for operator () involving either one or two indices,
 * which is needed to get the i,j element of a Tenzor, for example.
 *
 * To perform gather/scatter type operations involving sparse indices, in
 * which the sparse indices represent a list of points in a dense field
 * onto which we want to gather/scatter values, you can use the [] operator
 * to get a SubParticleAttrib object that knows about the particle
 * elements and associated sparse index points.  This allows us to have
 * the syntax
 *    P[S] = expr(A[S])
 * where P is a ParticleAttrib, A is some other object such as a Field that
 * can be indexed by an SIndex, and S is an SIndex object.  In this case,
 * the length of the ParticleAttrib would be changed to match the number
 * of local points in the SIndex, and the expression would be evaluated at
 * all the points in the SIndex and stored into P.  It also allows the
 * syntax
 *    A[S] = expr(B[S], P[S])
 * where A, B are things like Field, S in an SIndex, and P is a ParticleAttrib.
 * Here, the LHS is assigned, at all the points in the SIndex, to the values
 * of the expression, which can include a ParticleAttrib only if it is
 * indexed by an SIndex.  This is because SubParticleAttrib contains the
 * ability to provide an iterator with the right interface for the expression
 * evaluation.
 */

// include files
#include "Particle/ParticleAttribBase.h"
#include "Particle/ParticleAttribElem.h"
#include "SubParticle/SubParticleAttrib.h"
#include "DataSource/DataSource.h"
#include "DataSource/MakeDataSource.h"
#include "PETE/IpplExpressions.h"
#include "Index/NDIndex.h"
#include "Utility/DiscType.h"
#include "Utility/Inform.h"
#include "Utility/IpplStats.h"

#ifdef IPPL_STDSTL
#include <vector>
using std::vector;
#include <utility>
using std::pair;
#else
#include <vector.h>
#include <pair.h>
#endif // IPPL_STDSTL


// forward declarations
template<class T, unsigned Dim> class Vektor;
template<class T, unsigned Dim, class M, class C> class Field;
template <class T> class ParticleAttribIterator;


// ParticleAttrib class definition
template <class T>
class ParticleAttrib : public ParticleAttribBase, public DataSource,
                       public PETE_Expr< ParticleAttrib<T> >
{

  friend class ParticleAttribIterator<T>;

public:
  // useful typedefs for type of data contained here
  typedef T Return_t;
  typedef vector<T> ParticleList_t;
  typedef ParticleAttribIterator<T> iterator;
  typedef ParticleAttribBase::SortListIndex_t  SortListIndex_t;
  typedef ParticleAttribBase::SortList_t       SortList_t;

public:
  // default constructor
  ParticleAttrib() : ParticleAttribBase(sizeof(T), DiscType<T>::str()) {
    INCIPPLSTAT(incParticleAttribs);
  }

  // copy constructor
  ParticleAttrib(const ParticleAttrib<T>& pa)
    : ParticleAttribBase(pa), ParticleList(pa.ParticleList) {
    INCIPPLSTAT(incParticleAttribs);
  }

  // destructor: delete the storage of the attribute array
  ~ParticleAttrib() { }

  //
  // bracket operators to access the Nth particle data
  //

  typename ParticleList_t::reference
  operator[](size_t n) {
    return ParticleList[n];
  }

  typename ParticleList_t::const_reference
  operator[](size_t n) const {
    return ParticleList[n];
  }

  //
  // bracket operator to refer to an attrib and an SIndex object
  //

  template<unsigned Dim>
  SubParticleAttrib<ParticleAttrib<T>, T, Dim>
  operator[](const SIndex<Dim> &s) const {
    ParticleAttrib<T> &a = const_cast<ParticleAttrib<T> &>(*this);
    return SubParticleAttrib<ParticleAttrib<T>, T, Dim>(a, s);
  }

  //
  // PETE interface.
  //
  enum { IsExpr = 0 };
  typedef iterator PETE_Expr_t;
  PETE_Expr_t MakeExpression() const { return begin(); }

  // Get begin and end point iterators
  iterator begin() const { return iterator((ParticleList_t&) ParticleList); }
  iterator end()   const {
    return iterator((ParticleList_t&) ParticleList).at_end();
  }

  size_t size(void) const { return ParticleList.size(); }

  //
  // methods to allow the user to access components of multipple-item attribs
  //

  // Create a ParticleAttribElem to allow the user to access just the Nth
  // element of the attribute stored here.
  ParticleAttribElem<T,1U> operator()(unsigned);

  // Same as above, but specifying two indices
  ParticleAttribElem<T,2U> operator()(unsigned, unsigned);

  // Same as above, but specifying three indices
  ParticleAttribElem<T,3U> operator()(unsigned, unsigned, unsigned);

  //
  // Particle <-> Field interaction methods
  //

  // scatter the data from this attribute onto the given Field, using
  // the given Position attribute
  template <unsigned Dim, class M, class C, class PT, class IntOp>
  void
  scatter(Field<T,Dim,M,C>& f,
          const ParticleAttrib< Vektor<PT,Dim> >& pp,
          const IntOp& intop) const {
    TAU_TYPE_STRING(taustr, "void (" + CT(f) + ", " + CT(pp) + ", " 
                    + CT(intop) + ")");
    TAU_PROFILE("ParticleAttrib::scatter()", taustr, TAU_PARTICLE);

    // make sure field is uncompressed and guard cells are zeroed
    f.Uncompress();
    T zero = 0;
    f.setGuardCells(zero);

    const M& mesh = f.get_mesh();
    // iterate through ParticleAttrib data and call scatter operation
    typename ParticleList_t::const_iterator curr, last = ParticleList.end();
    typename ParticleAttrib< Vektor<PT,Dim> >::iterator ppiter=pp.begin();
    for (curr = ParticleList.begin(); curr != last; ++curr, ++ppiter)
      IntOp::scatter(*curr,f,*ppiter,mesh);

    // accumulate values in guard cells (and compress result)
    f.accumGuardCells();

    INCIPPLSTAT(incParticleScatters);
    return;
  }

  // scatter the data from this attribute onto the given Field, using
  // the given Position attribute, and store the mesh information
  template <unsigned Dim, class M, class C, class PT,
            class IntOp, class CacheData>
  void
  scatter(Field<T,Dim,M,C>& f,
          const ParticleAttrib< Vektor<PT,Dim> >& pp,
          const IntOp& intop,
          ParticleAttrib<CacheData>& cache) const {

    TAU_TYPE_STRING(taustr, "void (" + CT(f) + ", " + CT(pp) + ", " 
                    + CT(intop) + ", " + CT(cache) + ")");
    TAU_PROFILE("ParticleAttrib::scatter()", taustr, TAU_PARTICLE);

    // make sure field is uncompressed and guard cells are zeroed
    f.Uncompress();
    T zero = 0;
    f.setGuardCells(zero);

    const M& mesh = f.get_mesh();
    // iterate through ParticleAttrib data and call scatter operation
    typename ParticleList_t::const_iterator curr, last = ParticleList.end();
    typename ParticleAttrib< Vektor<PT,Dim> >::iterator ppiter=pp.begin();
    typename ParticleAttrib<CacheData>::iterator citer=cache.begin();
    for (curr = ParticleList.begin(); curr != last; ++curr, ++ppiter, ++citer)
      IntOp::scatter(*curr,f,*ppiter,mesh,*citer);

    // accumulate values in guard cells (and compress result)
    f.accumGuardCells();

    INCIPPLSTAT(incParticleScatters);
    return;
  }

  // scatter the data from this attribute onto the given Field, using
  // the precomputed mesh information
  template <unsigned Dim, class M, class C, class IntOp, class CacheData>
  void
  scatter(Field<T,Dim,M,C>& f, const IntOp& intop,
          const ParticleAttrib<CacheData>& cache) const {

    TAU_TYPE_STRING(taustr, "void (" + CT(f) + ", " + CT(intop) + ", " 
                    + CT(cache)  + " )" );
    TAU_PROFILE("ParticleAttrib::scatter()", taustr, TAU_PARTICLE);

    // make sure field is uncompressed and guard cells are zeroed
    f.Uncompress();
    T zero = 0;
    f.setGuardCells(zero);

    // iterate through ParticleAttrib data and call scatter operation
    typename ParticleList_t::const_iterator curr, last = ParticleList.end();
    typename ParticleAttrib<CacheData>::iterator citer=cache.begin();
    for (curr = ParticleList.begin(); curr != last; ++curr, ++citer)
      IntOp::scatter(*curr,f,*citer);

    // accumulate values in guard cells (and compress result)
    f.accumGuardCells();

    INCIPPLSTAT(incParticleScatters);
    return;
  }

  // gather the data from the given Field into this attribute, using
  // the given Position attribute
  template <unsigned Dim, class M, class C, class PT, class IntOp>
  void
  gather(const Field<T,Dim,M,C>& f,
         const ParticleAttrib< Vektor<PT,Dim> >& pp,
         const IntOp& intop) {
    TAU_TYPE_STRING(taustr, "void (" + CT(f) + ", " + CT(pp) + ", " 
                    + CT(intop)  + " )" );
    TAU_PROFILE("ParticleAttrib::gather()", taustr, TAU_PARTICLE);

    // make sure field is uncompressed
    f.Uncompress();
    // fill guard cells if they are dirty
    if (f.isDirty())
      f.fillGuardCells(true);

    const M& mesh = f.get_mesh();
    // iterate through ParticleAttrib data and call gather operation
    typename ParticleList_t::iterator curr, last = ParticleList.end();
    typename ParticleAttrib< Vektor<PT,Dim> >::iterator ppiter=pp.begin();
    for (curr = ParticleList.begin(); curr != last; ++curr, ++ppiter)
      IntOp::gather(*curr,f,*ppiter,mesh);

    // try to compress the Field again
    f.Compress();

    INCIPPLSTAT(incParticleGathers);
    return;
  }

  // gather the data from the given Field into this attribute, using
  // the given Position attribute, and store the mesh information
  template <unsigned Dim, class M, class C, class PT,
           class IntOp, class CacheData>
  void
  gather(const Field<T,Dim,M,C>& f,
         const ParticleAttrib< Vektor<PT,Dim> >& pp,
         const IntOp& intop,
         ParticleAttrib<CacheData>& cache) {

    TAU_TYPE_STRING(taustr, "void (" + CT(f) + ", " + CT(pp) + ", " 
                    + CT(intop) + ", " + CT(cache) + ")");
    TAU_PROFILE("ParticleAttrib::gather()", taustr, TAU_PARTICLE);

    // make sure field is uncompressed
    f.Uncompress();
    // fill guard cells if they are dirty
    if (f.isDirty())
      f.fillGuardCells(true);

    const M& mesh = f.get_mesh();
    // iterate through ParticleAttrib data and call gather operation
    typename ParticleList_t::iterator curr, last = ParticleList.end();
    typename ParticleAttrib< Vektor<PT,Dim> >::iterator ppiter=pp.begin();
    typename ParticleAttrib<CacheData>::iterator citer=cache.begin();
    for (curr=ParticleList.begin(); curr != last; ++curr,++ppiter,++citer)
      IntOp::gather(*curr,f,*ppiter,mesh,*citer);

    // try to compress the Field again
    f.Compress();

    INCIPPLSTAT(incParticleGathers);
    return;
  }

  // gather the data from the given Field into this attribute, using
  // the precomputed mesh information
  template <unsigned Dim, class M, class C, class IntOp, class CacheData>
  void
  gather(const Field<T,Dim,M,C>& f, const IntOp& intop,
         const ParticleAttrib<CacheData>& cache) {

    TAU_TYPE_STRING(taustr, "void (" + CT(f) + ", " + CT(intop) + ", " 
                    + CT(cache)  + " )" );
    TAU_PROFILE("ParticleAttrib::gather()", taustr, TAU_PARTICLE);

    // make sure field is uncompressed
    f.Uncompress();
    // fill guard cells if they are dirty
    if (f.isDirty())
      f.fillGuardCells(true);

    // iterate through ParticleAttrib data and call gather operation
    typename ParticleList_t::iterator curr, last = ParticleList.end();
    typename ParticleAttrib<CacheData>::iterator citer=cache.begin();
    for (curr = ParticleList.begin(); curr != last; ++curr, ++citer)
      IntOp::gather(*curr,f,*citer);

    // try to compress the Field again
    f.Compress();

    INCIPPLSTAT(incParticleGathers);
    return;
  }

  //
  // Assignment operators
  //

  // assign a general expression
  template<class T1>
  const ParticleAttrib<T>& operator=(const PETE_Expr<T1>& rhs) {
    assign(*this,rhs);
    return *this;
  }

  // assignment of a ParticleAttrib
  const ParticleAttrib<T>& operator=(const ParticleAttrib<T>& rhs) {
    if (size() != rhs.size()) {
      ERRORMSG("Attempting to copy particle attributes with unequal sizes.");
      ERRORMSG("\n" << size() << " != " << rhs.size() << endl);
    }
    assign(*this,rhs);
    return *this;
  }

  // assignment of a scalar
  const ParticleAttrib<T>& operator=(T rhs) {
    assign(*this,rhs);
    return *this;
  }

  //
  // methods used to manipulate the normal attrib data
  //

  // Create storage for M particle attributes.  The storage is uninitialized.
  // New items are appended to the end of the array.
  virtual void create(size_t);

  // Delete the attribute storage for M particle attributes, starting at
  // the position I.
  // This really erases the data, which will change local indices
  // of the data.  It actually just copies the data from the end of the
  // storage into the selected block
  // Boolean flag indicates whether to use optimized destroy method
  virtual void destroy(size_t M, size_t I, bool optDestroy=true);

  // This version takes a list of particle destroy events
  // Boolean flag indicates whether to use optimized destroy method
  virtual void destroy(const vector< pair<size_t,size_t> >& dlist,
                       bool optDestroy=true);

  // puts M particle's data starting from index I into a Message.
  // Return the number of particles put into the message.
  virtual size_t putMessage(Message&, size_t, size_t);

  // Another version of putMessage, which takes list of indices
  // Return the number of particles put into the message.
  virtual size_t putMessage(Message&, const vector<size_t>&);

  // Get data out of a Message containing N particle's attribute data,
  // and store it here.  Data is appended to the end of the list.  Return
  // the number of particles retrieved.
  virtual size_t getMessage(Message&, size_t);

  //
  // methods used to manipulate the ghost particle data
  //

  // Delete the ghost attrib storage for M particles, starting at pos I.
  // Items from the end of the list are moved up to fill in the space.
  // Return the number of items actually destroyed.
  virtual size_t ghostDestroy(size_t, size_t) {
    return 0;
  }

  // puts M particle's data starting from index I into a Message.
  // Return the number of particles put into the message.  This is for
  // when particles are being swapped to build ghost particle interaction
  // lists.
  virtual size_t ghostPutMessage(Message&, size_t, size_t) {
    return 0;
  }
  // puts data for a list of particles into a Message, for interaction lists.
  // Return the number of particles put into the message.
  virtual size_t ghostPutMessage(Message&, const vector<size_t>&) {
    return 0;
  }

  // Get ghost particle data from a message.
  virtual size_t ghostGetMessage(Message&, size_t) {
    return 0;
  }

  //
  // virtual methods used to sort data
  //

  // Calculate a "sort list", which is an array of data of the same
  // length as this attribute, with each element indicating the
  // (local) index wherethe ith particle shoulkd go.  For example, 
  // if there are four particles, and the sort-list is {3,1,0,2}, that
  // means the particle currently with index=0 should be moved to the third
  // position, the one with index=1 should stay where it is, etc.
  // The optional second argument indicates if the sort should be ascending
  // (true, the default) or descending (false).
  virtual void calcSortList(SortList_t &slist, bool ascending = true);

  // Process a sort-list, as described for "calcSortList", to reorder
  // the elements in this attribute.  All indices in the sort list are
  // considered "local", so they should be in the range 0 ... localnum-1.
  // The sort-list does not have to have been calcualted by calcSortList,
  // it could be calculated by some other means, but it does have to
  // be in the same format.  Note that the routine may need to modify
  // the sort-list temporarily, but it will return it in the same state.
  virtual void sort(SortList_t &slist);

  //
  // other functions
  //

  // Print out information for debugging purposes.
  virtual void printDebug(Inform&);

protected:
  // a virtual function which is called by this base class to get a
  // specific instance of DataSourceObject based on the type of data
  // and the connection method (the argument to the call).
  virtual DataSourceObject *createDataSourceObject(const char *nm,
                                                   DataConnect *dc, int tm) {
    return make_DataSourceObject(nm, dc, tm, *this);
  }

  // storage for particle data
  ParticleList_t ParticleList;
};


//
// iterator for data in a ParticleAttrib
//

template <class T>
class ParticleAttribIterator : public PETE_Expr< ParticleAttribIterator<T> >
{
  public:
    typedef typename ParticleAttrib<T>::ParticleList_t ParticleList_t;

    ParticleAttribIterator() : myList(0), curr(0) { }
#ifdef __MWERKS__
  ParticleAttribIterator(ParticleList_t& pa)
    : myList(&pa), curr(&(*pa.begin())) { }
#else
  // Is this bad C++ or mwerks bug? Certain STL implems this might be wrong:
  //  ParticleAttribIterator(ParticleList_t& pa)
  //    : myList(&pa), curr(pa.begin()) { }
  ParticleAttribIterator(ParticleList_t& pa)
    : myList(&pa), curr(&(*pa.begin())) { }
#endif // __MWERKS
    ParticleAttribIterator(const ParticleAttribIterator<T>& i)
      : myList(i.myList), curr(i.curr) { }

    // PETE interface.
    typedef ParticleAttribIterator<T> PETE_Expr_t;
    typedef T PETE_Return_t;
    PETE_Expr_t MakeExpression() const { return *this; }
    PETE_Return_t& operator*(void) const { return *curr; }

    ParticleAttribIterator<T>& operator++(void) {
      ++curr;
      return *this;
    }
    ParticleAttribIterator<T>& at_end(void) {
#ifdef __MWERKS__
      curr = &*myList->end();
#else
  // Is this bad C++ or mwerks bug? Certain STL implems this might be wrong:
      //      curr = myList->end();
      curr = &*myList->end();
#endif // __MWERKS__
      return *this;
    }
    bool operator==(const ParticleAttribIterator<T>& a) const {
      return  (curr == a.curr);
    }
    bool operator!=(const ParticleAttribIterator<T>& a) const {
      return !(curr == a.curr);
    }
    const ParticleList_t& getParticleList() const { return *myList; }
    T* getP() const { return curr; }

  private:
    ParticleList_t* myList;        // ParticleList I iterate over
    T* curr;                       // iterator current position
};


// Global template functions for gather/scatter operations

// scatter the data from the given attribute onto the given Field, using
// the given Position attribute
template <class FT, unsigned Dim, class M, class C, class PT, class IntOp>
inline
void scatter(const ParticleAttrib<FT>& attrib, Field<FT,Dim,M,C>& f,
             const ParticleAttrib< Vektor<PT,Dim> >& pp, const IntOp& intop) {
  attrib.scatter(f, pp, intop);
}

// scatter the data from the given attribute onto the given Field, using
// the given Position attribute, and save the mesh information for reuse
template <class FT, unsigned Dim, class M, class C, class PT,
          class IntOp, class CacheData>
inline
void scatter(const ParticleAttrib<FT>& attrib, Field<FT,Dim,M,C>& f,
             const ParticleAttrib< Vektor<PT,Dim> >& pp, const IntOp& intop,
             ParticleAttrib<CacheData>& cache) {
  attrib.scatter(f, pp, intop, cache);
}

// scatter the data from the given attribute onto the given Field, using
// the precomputed mesh information
template <class FT, unsigned Dim, class M, class C,
          class IntOp, class CacheData>
inline
void scatter(const ParticleAttrib<FT>& attrib, Field<FT,Dim,M,C>& f,
             const IntOp& intop, const ParticleAttrib<CacheData>& cache) {
  attrib.scatter(f, intop, cache);
}

// gather the data from the given Field into the given attribute, using
// the given Position attribute
template <class FT, unsigned Dim, class M, class C, class PT, class IntOp>
inline
void gather(ParticleAttrib<FT>& attrib, const Field<FT,Dim,M,C>& f,
            const ParticleAttrib< Vektor<PT,Dim> >& pp, const IntOp& intop) {
  attrib.gather(f, pp, intop);
}

// gather the data from the given Field into the given attribute, using
// the given Position attribute, and save the mesh information for reuse
template <class FT, unsigned Dim, class M, class C, class PT,
          class IntOp, class CacheData>
inline
void gather(ParticleAttrib<FT>& attrib, const Field<FT,Dim,M,C>& f,
            const ParticleAttrib< Vektor<PT,Dim> >& pp, const IntOp& intop,
            ParticleAttrib<CacheData>& cache) {
  attrib.gather(f, pp, intop, cache);
}

// gather the data from the given Field into the given attribute, using
// the precomputed mesh information
template <class FT, unsigned Dim, class M, class C,
          class CacheData, class IntOp>
inline
void gather(ParticleAttrib<FT>& attrib, const Field<FT,Dim,M,C>& f,
            const IntOp& intop, const ParticleAttrib<CacheData>& cache) {
  attrib.gather(f, intop, cache);
}

// This scatter function computes the particle number density by 
// scattering the scalar value val for each particle into the Field.
template <class FT, unsigned Dim, class M, class C, class PT, class IntOp>
void scatter(Field<FT,Dim,M,C>& f, const ParticleAttrib< Vektor<PT,Dim> >& pp,
             const IntOp& intop, FT val);

// version which also caches mesh info
template <class FT, unsigned Dim, class M, class C, class PT,
          class IntOp, class CacheData>
void scatter(Field<FT,Dim,M,C>& f, const ParticleAttrib< Vektor<PT,Dim> >& pp,
             const IntOp& intop, ParticleAttrib<CacheData>& cache,
             FT val);

// version which uses cached mesh info
template <class FT, unsigned Dim, class M, class C,
          class IntOp, class CacheData>
void scatter(Field<FT,Dim,M,C>& f, const IntOp& intop,
             const ParticleAttrib<CacheData>& cache, FT val);

// mwerks: addeded this to work around default-arg bug:
// This scatter function computes the particle number density by 
// scattering the scalar value val for each particle into the Field.
template <class FT, unsigned Dim, class M, class C, class PT, class IntOp>
void scatter(Field<FT,Dim,M,C>& f, const ParticleAttrib< Vektor<PT,Dim> >& pp,
             const IntOp& intop){
  scatter(f, pp, intop, FT(1));
}

// mwerks: addeded this to work around default-arg bug:
// version which also caches mesh info
template <class FT, unsigned Dim, class M, class C, class PT,
          class IntOp, class CacheData>
void scatter(Field<FT,Dim,M,C>& f, const ParticleAttrib< Vektor<PT,Dim> >& pp,
             const IntOp& intop, ParticleAttrib<CacheData>& cache) {
  scatter(f, pp, intop, cache, FT(1));
}

// mwerks: addeded this to work around default-arg bug:
// version which uses cached mesh info
template <class FT, unsigned Dim, class M, class C,
          class IntOp, class CacheData>
void scatter(Field<FT,Dim,M,C>& f, const IntOp& intop,
             const ParticleAttrib<CacheData>& cache) {
  scatter(f, intop, cache, FT(1));
}

#include "Particle/ParticleAttrib.cpp"

#endif // PARTICLE_ATTRIB_H

/***************************************************************************
 * $RCSfile: ParticleAttrib.h,v $   $Author: adelmann $
 * $Revision: 1.1.1.1 $   $Date: 2003/01/23 07:40:28 $
 * IPPL_VERSION_ID: $Id: ParticleAttrib.h,v 1.1.1.1 2003/01/23 07:40:28 adelmann Exp $ 
 ***************************************************************************/

---