source: src/Atom/AtomSet.hpp@ 2f3905

/*
 * AtomSet.hpp
 *
 *  Created on: Jul 30, 2010
 *      Author: crueger
 */

#ifndef ATOMSET_HPP_
#define ATOMSET_HPP_

// include config.h
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif



#include <algorithm>
#include <functional>
#include <limits>
#include <numeric>

#include <boost/bind.hpp>
#include <boost/foreach.hpp>

/**
 * A simple mixin to give any STL conforming structure fast Vector abilities
 *
 * TODO: make this work for maps
 */

#include "atom.hpp"

// this tests, whether we actually have a Vector
template <class V>
struct is_atom{};

template <>
struct is_atom<atom*>{
  typedef void wrong_type;
};

template <>
struct is_atom<const atom*>{
  typedef void wrong_type;
};

template <class container_type,
          class iterator_type = typename container_type::iterator,
          class const_iterator_type = typename container_type::const_iterator>
class AtomSetMixin : public container_type
{
  // when our set carries something besides a atom* this will produce an error
  typedef typename is_atom<typename container_type::value_type>::wrong_type check_for_atom;
public:
  // typedefs for STL conforming structure
  typedef iterator_type iterator;
  typedef const_iterator_type const_iterator;

  AtomSetMixin() :
    container_type()
  {}

  AtomSetMixin(const container_type& src) :
    container_type(src)
  {}
  virtual ~AtomSetMixin(){}

  /**
   * translate all Atoms within this set by a specified amount
   */
  void translate(const Vector &translater);
  void addVelocityAtStep(const Vector velocity, unsigned int step);

  template<class Function>
  void transformNodes(Function f);
  double totalMass() const;
  double totalTemperatureAtStep(unsigned int step) const;
  Vector totalMomentumAtStep(unsigned int step) const;

  size_t getMaxTrajectorySize() const;

  void sortByIds();

private:
  template<class Function>
  struct workOnNodePointer {
    workOnNodePointer(Function &_f) : f(_f){}
    void operator()(atom *atom){
      atom->setPosition(f(atom->getPosition()));
    }
    Function &f;
  };

  template<class T>
  struct valueSum {
    valueSum(T (AtomInfo::*_f)() const,T startValue) :
      f(_f),
      value(startValue)
    {}
    T operator+(const AtomInfo *atom){
      return value + (atom->*f)();
    }
    T operator=(T _value){
      value = _value;
      return value;
    }
    T (AtomInfo::*f)() const;
    T value;
  };

  template<class T>
  struct valueMax {
    valueMax(T (AtomInfo::*_f)() const,T startValue) :
      f(_f),
      value(startValue)
    {}
    T operator+(const AtomInfo *atom){
      const T temp = (atom->*f)();
      return value < temp ? temp : value;
    }
    T operator=(T _value){
      value = _value;
      return value;
    }
    T (AtomInfo::*f)() const;
    T value;
  };

  template<class T>
  struct stepValueSum {
    stepValueSum(unsigned int _step, T (AtomInfo::*_f)(unsigned int) const,T startValue) :
      step(_step),
      f(_f),
      value(startValue)
    {}
    T operator+(const AtomInfo *atom){
      return value + (atom->*f)(step);
    }
    T operator=(T _value){
      value = _value;
      return value;
    }
    unsigned int step;
    T (AtomInfo::*f)(unsigned int) const;
    T value;
  };
};

template <class container_type,
          class iterator_type,
          class const_iterator_type>
inline void AtomSetMixin<container_type,iterator_type,const_iterator_type>::translate(const Vector &translater){
  BOOST_FOREACH(AtomInfo *atom,*this){
    *(atom) += translater;
  }
}

template <class container_type,
          class iterator_type,
          class const_iterator_type>
inline void AtomSetMixin<container_type,iterator_type,const_iterator_type>::addVelocityAtStep(const Vector velocity, unsigned int step){
  BOOST_FOREACH(AtomInfo *atom,*this){
    atom->setAtomicVelocityAtStep(step, atom->getAtomicVelocityAtStep(step)+velocity);
  }
}

template <class container_type,
          class iterator_type,
          class const_iterator_type>
template<class Function>
inline void AtomSetMixin<container_type,iterator_type,const_iterator_type>::transformNodes(Function f){
  std::for_each(this->begin(),
                this->end(),
                AtomSetMixin::workOnNodePointer<Function>(f));
}

template <class container_type,
          class iterator_type,
          class const_iterator_type>
inline double AtomSetMixin<container_type,iterator_type,const_iterator_type>::totalMass() const{
  return accumulate(this->begin(),this->end(),valueSum<double>(&AtomInfo::getMass,0)).value;
}

template <class container_type,
          class iterator_type,
          class const_iterator_type>
inline size_t AtomSetMixin<container_type,iterator_type,const_iterator_type>::getMaxTrajectorySize() const
{
  return accumulate(this->begin(),this->end(),valueMax<size_t>(&AtomInfo::getTrajectorySize,(size_t)1)).value;
}

template <class container_type,
          class iterator_type,
          class const_iterator_type>
inline double AtomSetMixin<container_type,iterator_type,const_iterator_type>::totalTemperatureAtStep(unsigned int step) const{
  return accumulate(this->begin(),this->end(),stepValueSum<double>(step,&AtomInfo::getKineticEnergy,0)).value;
}

template <class container_type,
          class iterator_type,
          class const_iterator_type>
inline Vector AtomSetMixin<container_type,iterator_type,const_iterator_type>::totalMomentumAtStep(unsigned int step) const{
  return accumulate(this->begin(),this->end(),stepValueSum<Vector>(step,&AtomInfo::getMomentum,Vector())).value;
}

template <class container_type,
          class iterator_type,
          class const_iterator_type>
inline void AtomSetMixin<container_type,iterator_type,const_iterator_type>::sortByIds(){
  std::sort(this->begin(), this->end(),
      boost::bind(std::less<atomId_t>(),
          boost::bind(&atom::getId, _1),
          boost::bind(&atom::getId, _2)));
}

// allows simpler definition of AtomSets
#define ATOMSET(container_type) AtomSetMixin<container_type<atom*> >
#define CONSTATOMSET(container_type) AtomSetMixin<container_type<const atom*> >

#endif /* ATOMSET_HPP_ */