source: src/molecule_template.hpp@ 8dc761

/*
 * molecule_template.hpp
 *
 *  Created on: Oct 6, 2009
 *      Author: heber
 */

#ifndef MOLECULE_TEMPLATE_HPP_
#define MOLECULE_TEMPLATE_HPP_

/*********************************************** includes ***********************************/

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

#include "atom.hpp"
/********************************************** declarations *******************************/

// ================== Acting on all Vectors ========================== //

// zero arguments
template <typename res> void molecule::ActOnAllVectors( res (Vector::*f)() ) const
    {
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    (((*iter)->node)->*f)();
  }
};
template <typename res> void molecule::ActOnAllVectors( res (Vector::*f)() const ) const
    {
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    (((*iter)->node)->*f)();
  }
};
// one argument
template <typename res, typename T> void molecule::ActOnAllVectors( res (Vector::*f)(T), T t ) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    (((*iter)->node)->*f)(t);
  }
};
template <typename res, typename T> void molecule::ActOnAllVectors( res (Vector::*f)(T) const, T t ) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    (((*iter)->node)->*f)(t);
  }
};
template <typename res, typename T> void molecule::ActOnAllVectors( res (Vector::*f)(T&), T &t ) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    (((*iter)->node)->*f)(t);
  }
};
template <typename res, typename T> void molecule::ActOnAllVectors( res (Vector::*f)(T&) const, T &t ) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    (((*iter)->node)->*f)(t);
  }
};
// two arguments
template <typename res, typename T, typename U> void molecule::ActOnAllVectors( res (Vector::*f)(T, U), T t, U u ) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    (((*iter)->node)->*f)(t, u);
  }
};
template <typename res, typename T, typename U> void molecule::ActOnAllVectors( res (Vector::*f)(T, U) const, T t, U u ) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    (((*iter)->node)->*f)(t, u);
  }
};
// three arguments
template <typename res, typename T, typename U, typename V> void molecule::ActOnAllVectors( res (Vector::*f)(T, U, V), T t, U u, V v) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    (((*iter)->node)->*f)(t, u, v);
  }
};
template <typename res, typename T, typename U, typename V> void molecule::ActOnAllVectors( res (Vector::*f)(T, U, V) const, T t, U u, V v) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    (((*iter)->node)->*f)(t, u, v);
  }
};

// ========================= Summing over each Atoms =================================== //

// zero arguments
template <typename res, typename typ> res molecule::SumPerAtom(res (typ::*f)() ) const
{
  res result = 0;
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    result += ((*iter)->*f)();
  }
  return result;
};
template <typename res, typename typ> res molecule::SumPerAtom(res (typ::*f)() const ) const
{
  res result = 0;
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    result += ((*iter)->*f)();
  }
  return result;
};
// one argument
template <typename res, typename typ, typename T> res molecule::SumPerAtom(res (typ::*f)(T), T t ) const
{
  res result = 0;
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    result += ((*iter)->*f)(t);
  }
  return result;
};
template <typename res, typename typ, typename T> res molecule::SumPerAtom(res (typ::*f)(T) const, T t ) const
{
  res result = 0;
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    result += ((*iter)->*f)(t);
  }
  return result;
};


// ================== Acting with each Atoms on same molecule ========================== //

// zero arguments
template <typename res> void molecule::ActWithEachAtom( res (molecule::*f)(atom *)) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    (*f)((*iter));
  }
};
template <typename res> void molecule::ActWithEachAtom( res (molecule::*f)(atom *) const) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    (*f)((*iter));
  }
};

// ================== Acting with each Atoms on copy molecule ========================== //

// zero arguments
template <typename res> void molecule::ActOnCopyWithEachAtom( res (molecule::*f)(atom *) , molecule *copy) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    (copy->*f)((*iter));
  }
};
template <typename res> void molecule::ActOnCopyWithEachAtom( res (molecule::*f)(atom *) const, molecule *copy) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    (copy->*f)((*iter));
  }
};

// ================== Acting with each Atoms on copy molecule if true ========================== //

// zero arguments
template <typename res> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) () ) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    if (((*iter)->*condition)())
      (copy->*f)((*iter));
  }
};
template <typename res> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) () const ) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    if (((*iter)->*condition)())
      (copy->*f)((*iter));
  }
};
template <typename res> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const , molecule *copy, bool (atom::*condition) () ) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    if (((*iter)->*condition)())
      (copy->*f)((*iter));
  }
};
template <typename res> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) () const ) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    if (((*iter)->*condition)())
      (copy->*f)((*iter));
  }
};
// one argument
template <typename res, typename T> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T), T t ) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    if (((*iter)->*condition)(t))
      (copy->*f)((*iter));
  }
};
template <typename res, typename T> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T) const, T t ) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    if (((*iter)->*condition)(t))
      (copy->*f)((*iter));
  }
};
template <typename res, typename T> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) (T), T t ) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    if (((*iter)->*condition)(t))
      (copy->*f)((*iter));
  }
};
template <typename res, typename T> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) (T) const, T t ) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    if (((*iter)->*condition)(t))
      (copy->*f)((*iter));
  }
};
// two arguments
template <typename res, typename T, typename U> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U), T t, U u ) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    if (((*iter)->*condition)(t,u))
      (copy->*f)((*iter));
  }
};
template <typename res, typename T, typename U> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U) const, T t, U u ) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    if (((*iter)->*condition)(t,u))
      (copy->*f)((*iter));
  }
};
template <typename res, typename T, typename U> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) (T, U), T t, U u ) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    if (((*iter)->*condition)(t,u))
      (copy->*f)((*iter));
  }
};
template <typename res, typename T, typename U> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) (T, U) const, T t, U u ) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    if (((*iter)->*condition)(t,u))
      (copy->*f)((*iter));
  }
};
// three arguments
template <typename res, typename T, typename U, typename V> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U, V), T t, U u, V v ) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    if (((*iter)->*condition)(t,u,v))
      (copy->*f)((*iter));
  }
};
template <typename res, typename T, typename U, typename V> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U, V) const, T t, U u, V v ) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    if (((*iter)->*condition)(t,u,v))
      (copy->*f)((*iter));
  }
};
template <typename res, typename T, typename U, typename V> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) (T, U, V), T t, U u, V v ) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    if (((*iter)->*condition)(t,u,v))
      (copy->*f)((*iter));
  }
};
template <typename res, typename T, typename U, typename V> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) (T, U, V) const, T t, U u, V v ) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    if (((*iter)->*condition)(t,u,v))
      (copy->*f)((*iter));
  }
};

// ================== Acting on all Atoms ========================== //

// zero arguments
template <typename res, typename typ> void molecule::ActOnAllAtoms( res (typ::*f)()) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    ((*iter)->*f)();
  }
};
template <typename res, typename typ> void molecule::ActOnAllAtoms( res (typ::*f)() const) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    ((*iter)->*f)();
  }
};
// one argument
template <typename res, typename typ, typename T> void molecule::ActOnAllAtoms( res (typ::*f)(T), T t ) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    ((*iter)->*f)(t);
  }
};
template <typename res, typename typ, typename T> void molecule::ActOnAllAtoms( res (typ::*f)(T) const, T t ) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    ((*iter)->*f)(t);
  }
};
// two argument
template <typename res, typename typ, typename T, typename U> void molecule::ActOnAllAtoms( res (typ::*f)(T, U), T t, U u ) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    ((*iter)->*f)(t, u);
  }
};
template <typename res, typename typ, typename T, typename U> void molecule::ActOnAllAtoms( res (typ::*f)(T, U) const, T t, U u ) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    ((*iter)->*f)(t, u);
  }
};
// three argument
template <typename res, typename typ, typename T, typename U, typename V> void molecule::ActOnAllAtoms( res (typ::*f)(T, U, V), T t, U u, V v) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    ((*iter)->*f)(t, u, v);
  }
};
template <typename res, typename typ, typename T, typename U, typename V> void molecule::ActOnAllAtoms( res (typ::*f)(T, U, V) const, T t, U u, V v) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    ((*iter)->*f)(t, u, v);
  }
};
// four arguments
template <typename res, typename typ, typename T, typename U, typename V, typename W> void molecule::ActOnAllAtoms( res (typ::*f)(T, U, V, W), T t, U u, V v, W w) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    ((*iter)->*f)(t, u, v, w);
  }
};
template <typename res, typename typ, typename T, typename U, typename V, typename W> void molecule::ActOnAllAtoms( res (typ::*f)(T, U, V, W) const, T t, U u, V v, W w) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    ((*iter)->*f)(t, u, v, w);
  }
};

// ===================== Accessing arrays indexed by some integer for each atom ======================

// for atom ints
template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, void (*Setor)(T *, T *) ) const
{
  int inc = 1;
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    (*Setor) (&array[((*iter)->*index)], &inc);
  }
};
template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, void (*Setor)(T *, T *), T value ) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    (*Setor) (&array[((*iter)->*index)], &value);
  }
};
template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, void (*Setor)(T *, T *), T *value ) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    (*Setor) (&array[((*iter)->*index)], value);
  }
};
// for element ints
template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int element::*index, void (*Setor)(T *, T *) ) const
{
  int inc = 1;
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    (*Setor) (&array[((*iter)->type->*index)], &inc);
  }
};
template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int element::*index, void (*Setor)(T *, T *), T value ) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    (*Setor) (&array[((*iter)->type->*index)], &value);
  }
};
template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int element::*index, void (*Setor)(T *, T *), T *value ) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    (*Setor) (&array[((*iter)->type->*index)], value);
  }
};

template <typename T, typename typ> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &), typ atom::*value ) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    array[((*iter)->*index)] = ((*iter)->*Setor) ((*iter)->*value);
  }
};
template <typename T, typename typ> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &) const, typ atom::*value ) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    array[((*iter)->*index)] = ((*iter)->*Setor) ((*iter)->*value);
  }
};
template <typename T, typename typ> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &), typ &vect ) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    array[((*iter)->*index)] = ((*iter)->*Setor) (vect);
  }
};
template <typename T, typename typ> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &) const, typ &vect ) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    array[((*iter)->*index)] = ((*iter)->*Setor) (vect);
  }
};
template <typename T, typename typ, typename typ2> void molecule::SetAtomValueToIndexedArray ( T *array, int typ::*index, T typ2::*value ) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    (*iter)->*value = array[((*iter)->*index)];
    //Log() << Verbose(2) << *(*iter) << " gets " << ((*iter)->*value); << endl;
  }
};

template <typename T, typename typ> void molecule::SetAtomValueToValue ( T value, T typ::*ptr ) const
{
  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    (*iter)->*ptr = value;
    //Log() << Verbose(2) << *(*iter) << " gets " << ((*iter)->*ptr) << endl;
  }
};


#endif /* MOLECULE_TEMPLATE_HPP_ */