Index: src/molecule.cpp
===================================================================
--- src/molecule.cpp	(revision 32ea5695f81eb947c7da924c8808ff91acc4f552)
+++ src/molecule.cpp	(revision 8fd9346e5c090b879b93dad5c7820919964e4a47)
@@ -1046,11 +1046,4 @@
 };
 
-void molecule::SetIndexedArrayForEachAtomTo ( atom **array, int ParticleInfo::*index) const
-{
-  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
-    array[((*iter)->*index)] = (*iter);
-  }
-};
-
 void molecule::flipActiveFlag(){
   ActiveFlag = !ActiveFlag;
Index: src/molecule.hpp
===================================================================
--- src/molecule.hpp	(revision 32ea5695f81eb947c7da924c8808ff91acc4f552)
+++ src/molecule.hpp	(revision 8fd9346e5c090b879b93dad5c7820919964e4a47)
@@ -165,64 +165,4 @@
   bool IsEmpty() const ;
   bool IsEnd() const ;
-
-  // templates for allowing global manipulation of molecule with each atom as single argument
-  template <typename res> void ActWithEachAtom( res (molecule::*f)(atom *) ) const;
-  template <typename res> void ActWithEachAtom( res (molecule::*f)(atom *) const) const;
-
-  // templates for allowing global copying of molecule with each atom as single argument
-  template <typename res> void ActOnCopyWithEachAtom( res (molecule::*f)(atom *) , molecule *copy) const;
-  template <typename res> void ActOnCopyWithEachAtom( res (molecule::*f)(atom *) const, molecule *copy) const;
-
-  // templates for allowing global manipulation of all atoms
-  template <typename res, typename typ> void ActOnAllAtoms( res (typ::*f)() ) const;
-  template <typename res, typename typ> void ActOnAllAtoms( res (typ::*f)() const) const;
-  template <typename res, typename typ, typename T> void ActOnAllAtoms( res (typ::*f)(T), T t ) const;
-  template <typename res, typename typ, typename T> void ActOnAllAtoms( res (typ::*f)(T) const, T t ) const;
-  template <typename res, typename typ, typename T, typename U> void ActOnAllAtoms( res (typ::*f)(T, U), T t, U u ) const;
-  template <typename res, typename typ, typename T, typename U> void ActOnAllAtoms( res (typ::*f)(T, U) const, T t, U u ) const;
-  template <typename res, typename typ, typename T, typename U, typename V> void ActOnAllAtoms( res (typ::*f)(T, U, V), T t, U u, V v) const;
-  template <typename res, typename typ, typename T, typename U, typename V> void ActOnAllAtoms( res (typ::*f)(T, U, V) const, T t, U u, V v) const;
-  template <typename res, typename typ, typename T, typename U, typename V, typename W> void ActOnAllAtoms( res (typ::*f)(T, U, V, W), T t, U u, V v, W w) const;
-  template <typename res, typename typ, typename T, typename U, typename V, typename W> void ActOnAllAtoms( res (typ::*f)(T, U, V, W) const, T t, U u, V v, W w) const;
-
-  // templates for allowing conditional global copying of molecule with each atom as single argument
-  template <typename res> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) () ) const;
-  template <typename res> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) () const ) const;
-  template <typename res> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const , molecule *copy, bool (atom::*condition) () ) const;
-  template <typename res> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const , molecule *copy, bool (atom::*condition) () const ) const;
-  template <typename res, typename T> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T), T t ) const;
-  template <typename res, typename T> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T) const, T t ) const;
-  template <typename res, typename T> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const , molecule *copy, bool (atom::*condition) (T), T t ) const;
-  template <typename res, typename T> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const , molecule *copy, bool (atom::*condition) (T) const, T t ) const;
-  template <typename res, typename T, typename U> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U), T t, U u ) const;
-  template <typename res, typename T, typename U> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U) const, T t, U u ) const;
-  template <typename res, typename T, typename U> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const , molecule *copy, bool (atom::*condition) (T, U), T t, U u ) const;
-  template <typename res, typename T, typename U> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const , molecule *copy, bool (atom::*condition) (T, U) const, T t, U u ) const;
-  template <typename res, typename T, typename U, typename V> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U, V), T t, U u, V v ) const;
-  template <typename res, typename T, typename U, typename V> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U, V) const, T t, U u, V v ) const;
-  template <typename res, typename T, typename U, typename V> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const , molecule *copy, bool (atom::*condition) (T, U, V), T t, U u, V v ) const;
-  template <typename res, typename T, typename U, typename V> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const , molecule *copy, bool (atom::*condition) (T, U, V) const, T t, U u, V v ) const;
-
-  // templates for allowing global manipulation of an array with one entry per atom
-  void SetIndexedArrayForEachAtomTo ( atom **array, int ParticleInfo::* index) const;
-  template <typename T> void SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::* index, void (*Setor)(T *, T *)) const;
-  template <typename T> void SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::* index, void (*Setor)(T *, T *), T t) const;
-  template <typename T> void SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::* index, void (*Setor)(T *, T *), T *t) const;
-  template <typename T> void SetIndexedArrayForEachAtomTo ( T *array, int element::* index, void (*Setor)(T *, T *)) const;
-  template <typename T> void SetIndexedArrayForEachAtomTo ( T *array, int element::* index, void (*Setor)(T *, T *), T t) const;
-  template <typename T> void SetIndexedArrayForEachAtomTo ( T *array, int element::* index, void (*Setor)(T *, T *), T *t) const;
-  template <typename T, typename typ> void SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &), typ atom::*value) const;
-  template <typename T, typename typ> void SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &) const, typ atom::*value) const;
-  template <typename T, typename typ> void SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &), typ &vect ) const;
-  template <typename T, typename typ> void SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &) const, typ &vect ) const;
-
-  // templates for allowing global manipulation of each atom by entries in an array
-  template <typename T, typename typ, typename typ2> void SetAtomValueToIndexedArray ( T *array, int typ::*index, T typ2::*value ) const;
-  template <typename T, typename typ> void SetAtomValueToValue ( T value, T typ::*ptr ) const;
-
-  template <typename res, typename typ> res SumPerAtom(res (typ::*f)() ) const;
-  template <typename res, typename typ> res SumPerAtom(res (typ::*f)() const ) const;
-  template <typename res, typename typ, typename T> res SumPerAtom(res (typ::*f)(T) , T t ) const;
-  template <typename res, typename typ, typename T> res SumPerAtom(res (typ::*f)(T) const, T t ) const;
 
   /// remove atoms from molecule.
@@ -347,6 +287,4 @@
 void DeleteMolecule(molecule* mol);
 
-#include "molecule_template.hpp"
-
 /** A list of \a molecule classes.
  */
Index: src/molecule_template.hpp
===================================================================
--- src/molecule_template.hpp	(revision 32ea5695f81eb947c7da924c8808ff91acc4f552)
+++ 	(revision )
@@ -1,363 +1,0 @@
-/*
- * 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 *******************************/
-
-
-// ========================= 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)->getType()->*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)->getType()->*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)->getType()->*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_ */
