Changeset e1fe7e for src

Timestamp:

Jun 27, 2014, 9:32:55 PM (11 years ago)

Author:

Frederik Heber <heber@…>

Branches:

Action_Thermostats, Add_AtomRandomPerturbation, Add_FitFragmentPartialChargesAction, Add_RotateAroundBondAction, Add_SelectAtomByNameAction, Added_ParseSaveFragmentResults, AddingActions_SaveParseParticleParameters, Adding_Graph_to_ChangeBondActions, Adding_MD_integration_tests, Adding_ParticleName_to_Atom, Adding_StructOpt_integration_tests, AtomFragments, Automaking_mpqc_open, AutomationFragmentation_failures, Candidate_v1.5.4, Candidate_v1.6.0, Candidate_v1.6.1, Candidate_v1.7.0, ChangeBugEmailaddress, ChangingTestPorts, ChemicalSpaceEvaluator, CombiningParticlePotentialParsing, Combining_Subpackages, Debian_Package_split, Debian_package_split_molecuildergui_only, Disabling_MemDebug, Docu_Python_wait, EmpiricalPotential_contain_HomologyGraph, EmpiricalPotential_contain_HomologyGraph_documentation, Enable_parallel_make_install, Enhance_userguide, Enhanced_StructuralOptimization, Enhanced_StructuralOptimization_continued, Example_ManyWaysToTranslateAtom, Exclude_Hydrogens_annealWithBondGraph, FitPartialCharges_GlobalError, Fix_BoundInBox_CenterInBox_MoleculeActions, Fix_ChargeSampling_PBC, Fix_ChronosMutex, Fix_FitPartialCharges, Fix_FitPotential_needs_atomicnumbers, Fix_ForceAnnealing, Fix_IndependentFragmentGrids, Fix_ParseParticles, Fix_ParseParticles_split_forward_backward_Actions, Fix_PopActions, Fix_QtFragmentList_sorted_selection, Fix_Restrictedkeyset_FragmentMolecule, Fix_StatusMsg, Fix_StepWorldTime_single_argument, Fix_Verbose_Codepatterns, Fix_fitting_potentials, Fixes, ForceAnnealing_goodresults, ForceAnnealing_oldresults, ForceAnnealing_tocheck, ForceAnnealing_with_BondGraph, ForceAnnealing_with_BondGraph_continued, ForceAnnealing_with_BondGraph_continued_betteresults, ForceAnnealing_with_BondGraph_contraction-expansion, FragmentAction_writes_AtomFragments, FragmentMolecule_checks_bonddegrees, GeometryObjects, Gui_Fixes, Gui_displays_atomic_force_velocity, ImplicitCharges, IndependentFragmentGrids, IndependentFragmentGrids_IndividualZeroInstances, IndependentFragmentGrids_IntegrationTest, IndependentFragmentGrids_Sole_NN_Calculation, JobMarket_RobustOnKillsSegFaults, JobMarket_StableWorkerPool, JobMarket_unresolvable_hostname_fix, MoreRobust_FragmentAutomation, ODR_violation_mpqc_open, PartialCharges_OrthogonalSummation, PdbParser_setsAtomName, PythonUI_with_named_parameters, QtGui_reactivate_TimeChanged_changes, Recreated_GuiChecks, Rewrite_FitPartialCharges, RotateToPrincipalAxisSystem_UndoRedo, SaturateAtoms_findBestMatching, SaturateAtoms_singleDegree, StoppableMakroAction, Subpackage_CodePatterns, Subpackage_JobMarket, Subpackage_LinearAlgebra, Subpackage_levmar, Subpackage_mpqc_open, Subpackage_vmg, Switchable_LogView, ThirdParty_MPQC_rebuilt_buildsystem, TrajectoryDependenant_MaxOrder, TremoloParser_IncreasedPrecision, TremoloParser_MultipleTimesteps, TremoloParser_setsAtomName, Ubuntu_1604_changes, stable

Children:

550f2a

Parents:

16227a

git-author:

Frederik Heber <heber@…> (02/27/14 20:15:41)

git-committer:

Frederik Heber <heber@…> (06/27/14 21:32:55)

Message:

FunctionModel now uses list_of_arguments to split sequence of subsets of distances.

• this fixes ambiguities with the set of distances: Imagine the distances within a water molecule as OH (A) and HH (B). We then may have a sequence of argument_t as AABAAB. And with the current implementation of CompoundPotential::splitUpArgumentsByModels() we would always choose the latter (and more complex) model. Hence, we make two calls to TriplePotential_Angle, instead of calls twice to PairPotential_Harmonic for A, one to PairPotential_Harmonic for B, and once to TriplePotential_Angle for AAB.
• now, we new list looks like A,A,B,AAB where each tuple of distances can be uniquely associated with a specific potential.
• changed signatures of EmpiricalPotential::operator(), ::derivative(), ::parameter_derivative(). This involved changing all of the current specific potentials and CompoundPotential.
• TrainingData must discern between the InputVector_t (just all distances) and the FilteredInputVector_t (tuples of subsets of distances).
• FunctionApproximation now has list_of_arguments_t as parameter to evaluate() and evaluate_derivative().
• DOCU: docu change in TrainingData.

Location:

src

Files:

• Actions/PotentialAction/FitPotentialAction.cpp (modified) (1 diff)
• FunctionApproximation/Extractors.cpp (modified) (6 diffs)
• FunctionApproximation/Extractors.hpp (modified) (3 diffs)
• FunctionApproximation/FunctionApproximation.cpp (modified) (3 diffs)
• FunctionApproximation/FunctionApproximation.hpp (modified) (3 diffs)
• FunctionApproximation/FunctionModel.hpp (modified) (5 diffs)
• FunctionApproximation/TrainingData.cpp (modified) (6 diffs)
• FunctionApproximation/TrainingData.hpp (modified) (5 diffs)
• FunctionApproximation/unittests/ExtractorsUnitTest.cpp (modified) (1 diff)
• Potentials/CompoundPotential.cpp (modified) (10 diffs)
• Potentials/CompoundPotential.hpp (modified) (2 diffs)
• Potentials/EmpiricalPotential.hpp (modified) (1 diff)
• Potentials/Specifics/ConstantPotential.cpp (modified) (1 diff)
• Potentials/Specifics/ConstantPotential.hpp (modified) (2 diffs)
• Potentials/Specifics/FourBodyPotential_Torsion.cpp (modified) (1 diff)
• Potentials/Specifics/FourBodyPotential_Torsion.hpp (modified) (2 diffs)
• Potentials/Specifics/ManyBodyPotential_Tersoff.cpp (modified) (2 diffs)
• Potentials/Specifics/ManyBodyPotential_Tersoff.hpp (modified) (2 diffs)
• Potentials/Specifics/PairPotential_Harmonic.cpp (modified) (1 diff)
• Potentials/Specifics/PairPotential_Harmonic.hpp (modified) (2 diffs)
• Potentials/Specifics/PairPotential_LennardJones.cpp (modified) (1 diff)
• Potentials/Specifics/PairPotential_LennardJones.hpp (modified) (2 diffs)
• Potentials/Specifics/PairPotential_Morse.cpp (modified) (2 diffs)
• Potentials/Specifics/PairPotential_Morse.hpp (modified) (2 diffs)
• Potentials/Specifics/ThreeBodyPotential_Angle.cpp (modified) (1 diff)
• Potentials/Specifics/ThreeBodyPotential_Angle.hpp (modified) (2 diffs)
• Potentials/Specifics/unittests/ConstantPotentialUnitTest.cpp (modified) (3 diffs)
• Potentials/Specifics/unittests/FourBodyPotential_ImproperUnitTest.cpp (modified) (4 diffs)
• Potentials/Specifics/unittests/FourBodyPotential_TorsionUnitTest.cpp (modified) (4 diffs)
• Potentials/Specifics/unittests/ManyBodyPotential_TersoffUnitTest.cpp (modified) (5 diffs)
• Potentials/Specifics/unittests/PairPotential_HarmonicUnitTest.cpp (modified) (4 diffs)
• Potentials/Specifics/unittests/PairPotential_LennardJonesUnitTest.cpp (modified) (4 diffs)
• Potentials/Specifics/unittests/PairPotential_MorseUnitTest.cpp (modified) (5 diffs)
• Potentials/Specifics/unittests/ThreeBodyPotential_AngleUnitTest.cpp (modified) (4 diffs)
• Potentials/helpers.hpp (modified) (1 diff)
• Potentials/unittests/CompoundPotentialUnitTest.cpp (modified) (5 diffs)
• UIElements/Views/Qt4/QtHomologyList.cpp (modified) (1 diff)

src/Actions/PotentialAction/FitPotentialAction.cpp

@@ -244 +244 @@
       size_t counter=1;
       if (DoLog(3)) {
-        const FunctionModel::arguments_t &inputs = data.getTrainingInputs()[0];
+        const FunctionModel::arguments_t &inputs = data.getAllArguments()[0];
         for (FunctionModel::arguments_t::const_iterator iter = inputs.begin();
             iter != inputs.end(); ++iter) {

src/FunctionApproximation/Extractors.cpp

@@ -532 +532 @@
 }
 
-FunctionModel::arguments_t Extractors::reorderArgumentsByIncreasingDistance(
-    const FunctionModel::arguments_t &args
-    )
-{
-  FunctionModel::arguments_t returnargs(args);
-  std::sort(returnargs.begin(), returnargs.end(), argument_t::DistanceComparator);
+FunctionModel::list_of_arguments_t Extractors::reorderArgumentsByIncreasingDistance(
+    const FunctionModel::list_of_arguments_t &listargs
+    )
+{
+  FunctionModel::list_of_arguments_t returnargs;
+  for (FunctionModel::list_of_arguments_t::const_iterator iter = listargs.begin();
+      iter != listargs.end(); ++iter) {
+    const FunctionModel::arguments_t &args = *iter;
+    FunctionModel::arguments_t sortedargs(args);
+    std::sort(sortedargs.begin(), sortedargs.end(), argument_t::DistanceComparator);
+    returnargs.push_back(sortedargs);
+  }
   return returnargs;
 }
@@ -587 +593 @@
 }
 
-FunctionModel::arguments_t Extractors::reorderArgumentsByParticleTypes(
+FunctionModel::list_of_arguments_t Extractors::reorderArgumentsByParticleTypes(
+    const FunctionModel::list_of_arguments_t &listargs,
+    const ParticleTypes_t &_types
+    )
+{
+  FunctionModel::list_of_arguments_t returnargs;
+  for (FunctionModel::list_of_arguments_t::const_iterator iter = listargs.begin();
+      iter != listargs.end(); ++iter) {
+    const FunctionModel::arguments_t &args = *iter;
+    /// We  place all arguments into multimap according to particle type pair.
+    // here, we need a special comparator such that types in key pair are always
+    // properly ordered.
+    typedef std::multimap<
+        argument_t::types_t,
+        argument_t,
+        ParticleTypesComparator> TypePair_Argument_Map_t;
+    TypePair_Argument_Map_t argument_map;
+    for(FunctionModel::arguments_t::const_iterator iter = args.begin();
+        iter != args.end(); ++iter) {
+      argument_map.insert( std::make_pair(iter->types, *iter) );
+    }
+    LOG(4, "DEBUG: particle_type map is " << argument_map << ".");
+
+    /// Then, we create the desired unique keys
+    typedef std::vector<argument_t::types_t> UniqueTypes_t;
+    UniqueTypes_t UniqueTypes;
+    for (ParticleTypes_t::const_iterator firstiter = _types.begin();
+        firstiter != _types.end();
+        ++firstiter) {
+      for (ParticleTypes_t::const_iterator seconditer = firstiter;
+          seconditer != _types.end();
+          ++seconditer) {
+        if (seconditer == firstiter)
+          continue;
+        UniqueTypes.push_back( std::make_pair(*firstiter, *seconditer) );
+      }
+    }
+    LOG(4, "DEBUG: Created unique types as keys " << UniqueTypes << ".");
+
+    /// Finally, we use the unique key list to pick corresponding arguments from the map
+    FunctionModel::arguments_t sortedargs;
+    sortedargs.reserve(args.size());
+    while (!argument_map.empty()) {
+      // note that particle_types_t may be flipped, i.e. 1,8 is equal to 8,1, but we
+      // must maintain the correct order in indices in accordance with the order
+      // in _types, i.e. 1,8,1 must match with e.g. ids 1,0,2 where 1 has type 1,
+      // 0 has type 8, and 2 has type 2.
+      // In other words: We do not want to flip/modify arguments such that they match
+      // with the specific type pair we seek but then this comes at the price that we
+      // have flip indices when the types in a pair are flipped.
+
+      typedef std::vector<size_t> indices_t;
+      //!> here, we gather the indices as we discover them
+      indices_t indices;
+      indices.resize(_types.size(), (size_t)-1);
+
+      // these are two iterators that create index pairs in the same way as we have
+      // created type pairs. If a -1 is still present in indices, then the index is
+      // still arbitrary but is then set by the next found index
+      indices_t::iterator firstindex = indices.begin();
+      indices_t::iterator secondindex = firstindex+1;
+
+      //!> here, we gather the current bunch of arguments as we find them
+      FunctionModel::arguments_t argumentbunch;
+      argumentbunch.reserve(UniqueTypes.size());
+
+      for (UniqueTypes_t::const_iterator typeiter = UniqueTypes.begin();
+          typeiter != UniqueTypes.end(); ++typeiter) {
+        // have all arguments to same type pair as list within the found range
+        std::pair<
+            TypePair_Argument_Map_t::iterator,
+            TypePair_Argument_Map_t::iterator> range_t =
+                argument_map.equal_range(*typeiter);
+        LOG(4, "DEBUG: Set of arguments to current key [" << typeiter->first << ","
+            << typeiter->second << "] is " << std::list<argument_t>(
+                MapValueIterator<TypePair_Argument_Map_t::iterator>(range_t.first),
+                MapValueIterator<TypePair_Argument_Map_t::iterator>(range_t.second)
+                ) << ".");
+        // the first key is always easy and is pivot which the rest has to be associated to
+        if (typeiter == UniqueTypes.begin()) {
+          const argument_t & arg = range_t.first->second;
+          if ((typeiter->first == arg.types.first) && (typeiter->second == arg.types.second)) {
+            // store in correct order
+            *firstindex = arg.indices.first;
+            *secondindex = arg.indices.second;
+          } else {
+            // store in flipped order
+            *firstindex = arg.indices.second;
+            *secondindex = arg.indices.first;
+          }
+          argumentbunch.push_back(arg);
+          argument_map.erase(range_t.first);
+          LOG(4, "DEBUG: Gathered first argument " << arg << ".");
+        } else {
+          // go through the range and pick the first argument matching the index constraints
+          for (TypePair_Argument_Map_t::iterator argiter = range_t.first;
+              argiter != range_t.second; ++argiter) {
+            // seconditer may be -1 still
+            const argument_t &arg = argiter->second;
+            if (arg.indices.first == *firstindex) {
+              if ((arg.indices.second == *secondindex) || (*secondindex == (size_t)-1)) {
+                if (*secondindex == (size_t)-1)
+                  *secondindex = arg.indices.second;
+                argumentbunch.push_back(arg);
+                argument_map.erase(argiter);
+                LOG(4, "DEBUG: Gathered another argument " << arg << ".");
+                break;
+              }
+            } else if ((arg.indices.first == *secondindex) || (*secondindex == (size_t)-1)) {
+              if (arg.indices.second == *firstindex) {
+                if (*secondindex == (size_t)-1)
+                  *secondindex = arg.indices.first;
+                argumentbunch.push_back(arg);
+                argument_map.erase(argiter);
+                LOG(4, "DEBUG: Gathered another (flipped) argument " << arg << ".");
+                break;
+              }
+            }
+          }
+        }
+        // move along in indices and check bounds
+        ++secondindex;
+        if (secondindex == indices.end()) {
+          ++firstindex;
+          if (firstindex != indices.end()-1)
+            secondindex = firstindex+1;
+        }
+      }
+      ASSERT( (firstindex == indices.end()-1) && (secondindex == indices.end()),
+          "Extractors::reorderArgumentsByParticleTypes() - we have not gathered enough arguments.");
+      ASSERT( argumentbunch.size() == UniqueTypes.size(),
+          "Extractors::reorderArgumentsByParticleTypes() - we have not gathered enough arguments.");
+      // place bunch of arguments in return args
+      LOG(3, "DEBUG: Given types " << _types << " and found indices " << indices << ".");
+      LOG(3, "DEBUG: Final bunch of arguments is " << argumentbunch << ".");
+      sortedargs.insert(sortedargs.end(), argumentbunch.begin(), argumentbunch.end());
+    }
+    returnargs.push_back(sortedargs);
+  }
+
+  return returnargs;
+}
+
+FunctionModel::list_of_arguments_t Extractors::filterArgumentsByParticleTypes(
     const FunctionModel::arguments_t &args,
     const ParticleTypes_t &_types
     )
 {
-  /// We  place all arguments into multimap according to particle type pair.
-  // here, we need a special comparator such that types in key pair are always
-  // properly ordered.
-  typedef std::multimap<
-      argument_t::types_t,
-      argument_t,
-      ParticleTypesComparator> TypePair_Argument_Map_t;
-  TypePair_Argument_Map_t argument_map;
-  for(FunctionModel::arguments_t::const_iterator iter = args.begin();
-      iter != args.end(); ++iter) {
-    argument_map.insert( std::make_pair(iter->types, *iter) );
-  }
-  LOG(4, "DEBUG: particle_type map is " << argument_map << ".");
-
-  /// Then, we create the desired unique keys
-  typedef std::vector<argument_t::types_t> UniqueTypes_t;
-  UniqueTypes_t UniqueTypes;
+  typedef std::list< argument_t > ListArguments_t;
+  ListArguments_t availableList(args.begin(), args.end());
+  LOG(2, "DEBUG: Initial list of args is " << args << ".");
+
+
+  // TODO: fill a lookup map such that we don't have O(M^3) scaling, if M is number
+  // of types (and we always must have M(M-1)/2 args) but O(M^2 log(M)). However, as
+  // M is very small (<=3), this is not necessary fruitful now.
+//  typedef ParticleTypes_t firsttype;
+//  typedef ParticleTypes_t secondtype;
+//  typedef std::map< firsttype, std::map< secondtype, boost::ref(args) > > ArgsLookup_t;
+//  ArgsLookup_t ArgsLookup;
+
+  // basically, we have two choose any two pairs out of types but only those
+  // where the first is less than the latter. Hence, we start the second
+  // iterator at the current position of the first one and skip the equal case.
+  FunctionModel::arguments_t allargs;
+  allargs.reserve(args.size());
   for (ParticleTypes_t::const_iterator firstiter = _types.begin();
       firstiter != _types.end();
@@ -617 +767 @@
       if (seconditer == firstiter)
         continue;
-      UniqueTypes.push_back( std::make_pair(*firstiter, *seconditer) );
-    }
-  }
-  LOG(4, "DEBUG: Created unique types as keys " << UniqueTypes << ".");
-
-  /// Finally, we use the unique key list to pick corresponding arguments from the map
-  FunctionModel::arguments_t returnargs;
-  returnargs.reserve(args.size());
-  while (!argument_map.empty()) {
-    // note that particle_types_t may be flipped, i.e. 1,8 is equal to 8,1, but we
-    // must maintain the correct order in indices in accordance with the order
-    // in _types, i.e. 1,8,1 must match with e.g. ids 1,0,2 where 1 has type 1,
-    // 0 has type 8, and 2 has type 2.
-    // In other words: We do not want to flip/modify arguments such that they match
-    // with the specific type pair we seek but then this comes at the price that we
-    // have flip indices when the types in a pair are flipped.
-
-    typedef std::vector<size_t> indices_t;
-    //!> here, we gather the indices as we discover them
-    indices_t indices;
-    indices.resize(_types.size(), (size_t)-1);
-
-    // these are two iterators that create index pairs in the same way as we have
-    // created type pairs. If a -1 is still present in indices, then the index is
-    // still arbitrary but is then set by the next found index
-    indices_t::iterator firstindex = indices.begin();
-    indices_t::iterator secondindex = firstindex+1;
-
-    //!> here, we gather the current bunch of arguments as we find them
-    FunctionModel::arguments_t argumentbunch;
-    argumentbunch.reserve(UniqueTypes.size());
-
-    for (UniqueTypes_t::const_iterator typeiter = UniqueTypes.begin();
-        typeiter != UniqueTypes.end(); ++typeiter) {
-      // have all arguments to same type pair as list within the found range
-      std::pair<
-          TypePair_Argument_Map_t::iterator,
-          TypePair_Argument_Map_t::iterator> range_t =
-              argument_map.equal_range(*typeiter);
-      LOG(4, "DEBUG: Set of arguments to current key [" << typeiter->first << ","
-          << typeiter->second << "] is " << std::list<argument_t>(
-              MapValueIterator<TypePair_Argument_Map_t::iterator>(range_t.first),
-              MapValueIterator<TypePair_Argument_Map_t::iterator>(range_t.second)
-              ) << ".");
-      // the first key is always easy and is pivot which the rest has to be associated to
-      if (typeiter == UniqueTypes.begin()) {
-        const argument_t & arg = range_t.first->second;
-        if ((typeiter->first == arg.types.first) && (typeiter->second == arg.types.second)) {
-          // store in correct order
-          *firstindex = arg.indices.first;
-          *secondindex = arg.indices.second;
-        } else {
-          // store in flipped order
-          *firstindex = arg.indices.second;
-          *secondindex = arg.indices.first;
-        }
-        argumentbunch.push_back(arg);
-        argument_map.erase(range_t.first);
-        LOG(4, "DEBUG: Gathered first argument " << arg << ".");
-      } else {
-        // go through the range and pick the first argument matching the index constraints
-        for (TypePair_Argument_Map_t::iterator argiter = range_t.first;
-            argiter != range_t.second; ++argiter) {
-          // seconditer may be -1 still
-          const argument_t &arg = argiter->second;
-          if (arg.indices.first == *firstindex) {
-            if ((arg.indices.second == *secondindex) || (*secondindex == (size_t)-1)) {
-              if (*secondindex == (size_t)-1)
-                *secondindex = arg.indices.second;
-              argumentbunch.push_back(arg);
-              argument_map.erase(argiter);
-              LOG(4, "DEBUG: Gathered another argument " << arg << ".");
-              break;
-            }
-          } else if ((arg.indices.first == *secondindex) || (*secondindex == (size_t)-1)) {
-            if (arg.indices.second == *firstindex) {
-              if (*secondindex == (size_t)-1)
-                *secondindex = arg.indices.first;
-              argumentbunch.push_back(arg);
-              argument_map.erase(argiter);
-              LOG(4, "DEBUG: Gathered another (flipped) argument " << arg << ".");
-              break;
-            }
-          }
-        }
-      }
-      // move along in indices and check bounds
-      ++secondindex;
-      if (secondindex == indices.end()) {
-        ++firstindex;
-        if (firstindex != indices.end()-1)
-          secondindex = firstindex+1;
-      }
-    }
-    ASSERT( (firstindex == indices.end()-1) && (secondindex == indices.end()),
-        "Extractors::reorderArgumentsByParticleTypes() - we have not gathered enough arguments.");
-    ASSERT( argumentbunch.size() == UniqueTypes.size(),
-        "Extractors::reorderArgumentsByParticleTypes() - we have not gathered enough arguments.");
-    // place bunch of arguments in return args
-    LOG(3, "DEBUG: Given types " << _types << " and found indices " << indices << ".");
-    LOG(3, "DEBUG: Final bunch of arguments is " << argumentbunch << ".");
-    returnargs.insert(returnargs.end(), argumentbunch.begin(), argumentbunch.end());
-  }
-
-  return returnargs;
-}
-
-FunctionModel::arguments_t Extractors::filterArgumentsByParticleTypes(
-    const FunctionModel::arguments_t &args,
-    const ParticleTypes_t &_types
-    )
-{
-  typedef std::list< argument_t > ListArguments_t;
-  ListArguments_t availableList(args.begin(), args.end());
-  LOG(2, "DEBUG: Initial list of args is " << args << ".");
-
-
-  // TODO: fill a lookup map such that we don't have O(M^3) scaling, if M is number
-  // of types (and we always must have M(M-1)/2 args) but O(M^2 log(M)). However, as
-  // M is very small (<=3), this is not necessary fruitful now.
-//  typedef ParticleTypes_t firsttype;
-//  typedef ParticleTypes_t secondtype;
-//  typedef std::map< firsttype, std::map< secondtype, boost::ref(args) > > ArgsLookup_t;
-//  ArgsLookup_t ArgsLookup;
-
-  // basically, we have two choose any two pairs out of types but only those
-  // where the first is less than the latter. Hence, we start the second
-  // iterator at the current position of the first one and skip the equal case.
-  FunctionModel::arguments_t returnargs;
-  returnargs.reserve(args.size());
-  for (ParticleTypes_t::const_iterator firstiter = _types.begin();
-      firstiter != _types.end();
-      ++firstiter) {
-    for (ParticleTypes_t::const_iterator seconditer = firstiter;
-        seconditer != _types.end();
-        ++seconditer) {
-      if (seconditer == firstiter)
-        continue;
+      LOG(3, "DEBUG: Looking for (" << *firstiter << "," << *seconditer << ") in all args.");
 
       // search the right one in _args (we might allow switching places of
@@ -760 +773 @@
       ListArguments_t::iterator iter = availableList.begin();
       while (iter != availableList.end()) {
-        LOG(3, "DEBUG: Current args is " << *iter << ".");
+        LOG(4, "DEBUG: Current args is " << *iter << ".");
         if ((iter->types.first == *firstiter)
               && (iter->types.second == *seconditer)) {
-          returnargs.push_back( *iter );
+          allargs.push_back( *iter );
           iter = availableList.erase(iter);
           LOG(4, "DEBUG: Accepted argument.");
         } else if ((iter->types.first == *seconditer)
               && (iter->types.second == *firstiter)) {
-          returnargs.push_back( *iter );
+          allargs.push_back( *iter );
           iter = availableList.erase(iter);
           LOG(4, "DEBUG: Accepted (flipped) argument.");
@@ -778 +791 @@
     }
   }
-  LOG(2, "DEBUG: Final list of args is " << returnargs << ".");
+  LOG(2, "DEBUG: Final list of args is " << allargs << ".");
+
+  // first, we bring together tuples of distances that belong together
+  FunctionModel::list_of_arguments_t singlelist_allargs;
+  singlelist_allargs.push_back(allargs);
+  FunctionModel::list_of_arguments_t sortedargs =
+      reorderArgumentsByParticleTypes(singlelist_allargs, _types);
+  ASSERT( sortedargs.size() == (size_t)1,
+      "Extractors::filterArgumentsByParticleTypes() - reordering did not generate a single list.");
+  // then we split up the tuples of arguments and place each into single list
+  FunctionModel::list_of_arguments_t returnargs;
+  FunctionModel::arguments_t::const_iterator argiter = sortedargs.begin()->begin();
+  const size_t num_types = _types.size();
+  const size_t args_per_tuple = num_types * (num_types-1) / 2;
+  while (argiter != sortedargs.begin()->end()) {
+    FunctionModel::arguments_t currenttuple(args_per_tuple);
+    const FunctionModel::arguments_t::const_iterator startiter = argiter;
+    std::advance(argiter, args_per_tuple);
+#ifndef NDEBUG
+    FunctionModel::arguments_t::const_iterator endoutiter =
+#endif
+        std::copy(startiter, argiter, currenttuple.begin());
+    ASSERT( endoutiter == currenttuple.end(),
+        "Extractors::filterArgumentsByParticleTypes() - currenttuple not initialized to right size.");
+    returnargs.push_back(currenttuple);
+  }
+
+  LOG(2, "DEBUG: We have generated " << returnargs.size() << " tuples of distances.");
 
   return returnargs;
@@ -807 +847 @@
 }
 
+FunctionModel::list_of_arguments_t Extractors::concatenateListOfArguments(
+    const FunctionModel::list_of_arguments_t &firstlistargs,
+    const FunctionModel::list_of_arguments_t &secondlistargs)
+{
+  FunctionModel::list_of_arguments_t listargs(firstlistargs);
+  listargs.insert(listargs.end(), secondlistargs.begin(), secondlistargs.end());
+  return listargs;
+}

src/FunctionApproximation/Extractors.hpp

@@ -304 +304 @@
   /** Reorder arguments by increasing distance.
    *
-   * \param args arguments to reorder
+   * \param listargs list of arguments to reorder each
    * \return reordered args
    */
-  FunctionModel::arguments_t reorderArgumentsByIncreasingDistance(
-      const FunctionModel::arguments_t &args
+  FunctionModel::list_of_arguments_t reorderArgumentsByIncreasingDistance(
+      const FunctionModel::list_of_arguments_t &listargs
       );
 
@@ -318 +318 @@
    * \sa filterArgumentsByParticleTypes()
    *
+   * \param listargs list of arguments to reorder each
+   * \param _types particle type vector
+   * \return reordered args
+   */
+  FunctionModel::list_of_arguments_t reorderArgumentsByParticleTypes(
+      const FunctionModel::list_of_arguments_t &eachargs,
+      const ParticleTypes_t &_types
+      );
+
+  /** Filter arguments according to types, allowing multiples.
+   *
+   * If particle types is (0,1,2) and three arguments, each with a pair of types,
+   * are given, then the alignment will be: (0,1), (0,2), and (1,2).
+   *
    * \param args arguments to reorder
    * \param _types particle type vector
-   * \return reordered args
-   */
-  FunctionModel::arguments_t reorderArgumentsByParticleTypes(
-      const FunctionModel::arguments_t &args,
-      const ParticleTypes_t &_types
-      );
-
-  /** Filter arguments according to types.
-   *
-   * If particle types is (0,1,2) and three arguments, each with a pair of types,
-   * are given, then the alignment will be: (0,1), (0,2), and (1,2).
-   *
-   * \param args arguments to reorder
-   * \param _types particle type vector
-   * \return filtered args
-   */
-  FunctionModel::arguments_t filterArgumentsByParticleTypes(
+   * \return filtered list of args
+   */
+  FunctionModel::list_of_arguments_t filterArgumentsByParticleTypes(
       const FunctionModel::arguments_t &args,
       const ParticleTypes_t &_types
@@ -361 +361 @@
       const FunctionModel::arguments_t &secondargs);
 
+  /** Combines two argument lists by concatenation.
+   *
+   * @param firstlistargs first list of argument tuples
+   * @param secondlistargs second list of argument tuples
+   * @return concatenated lists
+   */
+  FunctionModel::list_of_arguments_t concatenateListOfArguments(
+      const FunctionModel::list_of_arguments_t &firstlistargs,
+      const FunctionModel::list_of_arguments_t &secondlistargs);
+
 }; /* namespace Extractors */
 

src/FunctionApproximation/FunctionApproximation.cpp

@@ -64 +64 @@
 {}
 
-void FunctionApproximation::setTrainingData(const inputs_t &input, const outputs_t &output)
+void FunctionApproximation::setTrainingData(const filtered_inputs_t &input, const outputs_t &output)
 {
   ASSERT( input.size() == output.size(),
@@ -334 +334 @@
       +" outputs but we provide "+toString(output_data.size())+".");
   if (!output_data.empty()) {
-    inputs_t::const_iterator initer = input_data.begin();
+    filtered_inputs_t::const_iterator initer = input_data.begin();
     outputs_t::const_iterator outiter = output_data.begin();
     size_t index = 0;
@@ -362 +362 @@
       +" outputs but we provide "+toString(output_data.size())+".");
   if (!output_data.empty()) {
-    inputs_t::const_iterator initer = input_data.begin();
+    filtered_inputs_t::const_iterator initer = input_data.begin();
     outputs_t::const_iterator outiter = output_data.begin();
     size_t index = 0;

src/FunctionApproximation/FunctionApproximation.hpp

@@ -71 +71 @@
   //!> typedef for a vector of input arguments
   typedef std::vector<FunctionModel::arguments_t> inputs_t;
+  //!> typedef for a vector of input arguments
+  typedef std::vector<FunctionModel::list_of_arguments_t> filtered_inputs_t;
   //!> typedef for a vector of output values
   typedef std::vector<FunctionModel::results_t> outputs_t;
@@ -110 +112 @@
    *        FunctionApproximation::output_dimension size
    */
-  void setTrainingData(const inputs_t &input, const outputs_t &output);
+  void setTrainingData(const filtered_inputs_t &input, const outputs_t &output);
 
   /** Setter for the model function to be used in the approximation.
@@ -191 +193 @@
 
   //!> current input set of training data
-  inputs_t input_data;
+  filtered_inputs_t input_data;
   //!> current output set of training data
   outputs_t output_data;

src/FunctionApproximation/FunctionModel.hpp

@@ -15 +15 @@
 
 #include <boost/function.hpp>
+#include <list>
 #include <vector>
 
@@ -58 +59 @@
   //!> typedef for the whole set of parameters of the function
   typedef std::vector<parameter_t> parameters_t;
-  //!> typedef for the argument vector as input to the function
+  //!> typedef for the argument vector as input to the function (subset of distances)
   typedef std::vector<argument_t> arguments_t;
+  //!> typedef for a list of argument vectors as input to the function (list of subsets)
+  typedef std::list<arguments_t> list_of_arguments_t;
   //!> typedef for a single result degree of freedom
   typedef double result_t;
@@ -65 +68 @@
   typedef std::vector<result_t> results_t;
   //!> typedef for a function containing how to extract required information from a Fragment.
-  typedef boost::function< arguments_t (const Fragment &, const size_t)> extractor_t;
+  typedef boost::function< list_of_arguments_t (const Fragment &, const size_t)> extractor_t;
   //!> typedef for a function containing how to filter required distances from a full argument list.
-  typedef boost::function< arguments_t (const arguments_t &)> filter_t;
+  typedef boost::function< list_of_arguments_t (const arguments_t &)> filter_t;
   //!> typedef for the magic triple function that gets the other two distances for a given argument
   typedef boost::function< std::vector<arguments_t>(const argument_t &, const double)> triplefunction_t;
@@ -114 +117 @@
    * \return result of the function
    */
-  virtual results_t operator()(const arguments_t &arguments) const=0;
+  virtual results_t operator()(const list_of_arguments_t &arguments) const=0;
 
   /** Evaluates the derivative of the function with the given \a arguments
@@ -124 +127 @@
    *         input
    */
-  virtual results_t parameter_derivative(const arguments_t &arguments, const size_t index) const=0;
+  virtual results_t parameter_derivative(const list_of_arguments_t &arguments, const size_t index) const=0;
 
   /** States whether lower and upper boundaries should be used to constraint

src/FunctionApproximation/TrainingData.cpp

@@ -68 +68 @@
     EnergyVector.push_back( FunctionModel::results_t(1, energy) );
     // filter distances out of list of all arguments
-    FunctionModel::arguments_t args = filter(all_args);
+    FunctionModel::list_of_arguments_t args = filter(all_args);
     LOG(3, "DEBUG: Filtered arguments are " << args << ".");
     ArgumentVector.push_back( args );
@@ -78 +78 @@
   double L2sum = 0.;
 
-  FunctionApproximation::inputs_t::const_iterator initer = ArgumentVector.begin();
-  FunctionApproximation::outputs_t::const_iterator outiter = EnergyVector.begin();
+  FilteredInputVector_t::const_iterator initer = ArgumentVector.begin();
+  OutputVector_t::const_iterator outiter = EnergyVector.begin();
   for (; initer != ArgumentVector.end(); ++initer, ++outiter) {
     const FunctionModel::results_t result = model((*initer));
@@ -92 +92 @@
   double Lmax = 0.;
 //  size_t maxindex = -1;
-  FunctionApproximation::inputs_t::const_iterator initer = ArgumentVector.begin();
-  FunctionApproximation::outputs_t::const_iterator outiter = EnergyVector.begin();
+  FilteredInputVector_t::const_iterator initer = ArgumentVector.begin();
+  OutputVector_t::const_iterator outiter = EnergyVector.begin();
   for (; initer != ArgumentVector.end(); ++initer, ++outiter) {
     const FunctionModel::results_t result = model((*initer));
@@ -113 +113 @@
       const range_t &range) const
 {
-  TrainingData::L2ErrorConfigurationIndexMap_t WorseFragmentMap;
+  L2ErrorConfigurationIndexMap_t WorseFragmentMap;
   // fragments make it into the container in reversed order, hence count from top down
   size_t index= std::distance(range.first, range.second)-1;
-  InputVector_t::const_iterator initer = ArgumentVector.begin();
+  InputVector_t::const_iterator distanceiter = DistanceVector.begin();
+  FilteredInputVector_t::const_iterator initer = ArgumentVector.begin();
   OutputVector_t::const_iterator outiter = EnergyVector.begin();
-  for (; initer != ArgumentVector.end(); ++initer, ++outiter) {
+  for (; initer != ArgumentVector.end(); ++initer, ++outiter, ++distanceiter) {
     // calculate value from potential
-    const FunctionModel::arguments_t &args = *initer;
+    const FunctionModel::list_of_arguments_t &args = *initer;
     const FunctionModel::results_t result = model(args);
     const double energy = (*outiter)[0];
@@ -131 +132 @@
       // give only the distances in the debugging text
       std::stringstream streamargs;
-      BOOST_FOREACH (argument_t arg, args) {
+      BOOST_FOREACH (argument_t arg, *distanceiter) {
         streamargs << " " << arg.distance;
       }
@@ -148 +149 @@
   /// extract distance member variable from argument_t and first value from results_t
   OutputVector_t::const_iterator ergiter = EnergyVector.begin();
-  for (InputVector_t::const_iterator iter = ArgumentVector.begin();
-      iter != ArgumentVector.end(); ++iter, ++ergiter) {
+  for (InputVector_t::const_iterator iter = DistanceVector.begin();
+      iter != DistanceVector.end(); ++iter, ++ergiter) {
     ASSERT( ergiter != EnergyVector.end(),
         "TrainingData::getDistanceEnergyTable() - less output than input values.");

src/FunctionApproximation/TrainingData.hpp

@@ -27 +27 @@
  * Fragment.
  *
- * In TrainingData::operator() we construct first all pair-wise distances as
- * list of all arguments. Then, these are filtered depending on the specific
- * FunctionModel's Filter and only these are handed to down to evaluate it.
+ * TrainingData::operator() takes the set of all possible pair-wise  distances
+ * (InputVector_t) and transforms it via the given filter into a list of subsets
+ * of distances (FilteredInputVector_t) that is feedable to the model.
  *
  */
@@ -41 +41 @@
   //!> Training tuple input vector pair
   typedef FunctionApproximation::inputs_t InputVector_t;
+  //!> Training tuple modified input vector pair
+  typedef FunctionApproximation::filtered_inputs_t FilteredInputVector_t;
   //!> Training tuple output vector pair
   typedef FunctionApproximation::outputs_t OutputVector_t;
@@ -47 +49 @@
   //!> Typedef for a map of each fragment with error.
   typedef std::multimap< double, size_t > L2ErrorConfigurationIndexMap_t;
-
 
 public:
@@ -75 +76 @@
    * \return const ref to training tuple of input vector
    */
-  const InputVector_t& getTrainingInputs() const {
+  const FilteredInputVector_t& getTrainingInputs() const {
     return ArgumentVector;
   }
@@ -142 +143 @@
   OutputVector_t EnergyVector;
   //!> list of all filtered arguments over all tuples
-  InputVector_t ArgumentVector;
+  FilteredInputVector_t ArgumentVector;
   //!> function to be used for training input data extraction from a fragment
   const FunctionModel::filter_t filter;

src/FunctionApproximation/unittests/ExtractorsUnitTest.cpp

@@ -182 +182 @@
   args.push_back(arg);
   CPPUNIT_ASSERT_EQUAL( (size_t)3, args.size() );
+  FunctionModel::list_of_arguments_t listargs(1, args);
 
   // reorder
-  FunctionModel::arguments_t args_sorted =
-      Extractors::reorderArgumentsByIncreasingDistance(args);
+  FunctionModel::list_of_arguments_t listargs_sorted =
+      Extractors::reorderArgumentsByIncreasingDistance(listargs);
+  CPPUNIT_ASSERT_EQUAL( (size_t)1, listargs_sorted.size() );
+  FunctionModel::arguments_t args_sorted = *(listargs_sorted.begin());
   CPPUNIT_ASSERT_EQUAL( (size_t)3, args_sorted.size() );
   CPPUNIT_ASSERT_EQUAL( args[0].distance, args_sorted[0].distance );

src/Potentials/CompoundPotential.cpp

@@ -228 +228 @@
 {
   arguments_by_model_t partial_args;
-  // go through each model and have it filter out its arguments
+  // go through each model and have it filter out its arguments, this already
+  // returns a list of tuples associated with the specific model
   for(models_t::const_iterator modeliter = models.begin();
       modeliter != models.end(); ++modeliter) {
     FunctionModel::filter_t filterfunction = (*modeliter)->getSpecificFilter();
-    arguments_t tempargs = filterfunction(arguments);
+    list_of_arguments_t tempargs = filterfunction(arguments);
     // then split up all the bunches, too.
-    arguments_t::const_iterator advanceiter = tempargs.begin();
-    for (arguments_t::const_iterator argiter = tempargs.begin();
-        argiter != tempargs.end(); argiter = advanceiter) {
-      advanceiter += (*modeliter)->getSpecificArgumentCount();
+    for (list_of_arguments_t::const_iterator argiter = tempargs.begin();
+        argiter != tempargs.end(); ++argiter) {
+      const arguments_t &args = *argiter;
       partial_args.push_back(
           std::make_pair(
               *modeliter,
-              arguments_t(argiter, advanceiter)
+              args
             )
           );
@@ -251 +251 @@
 
 CompoundPotential::arguments_by_model_t CompoundPotential::splitUpArgumentsByModels(
-    const arguments_t &arguments) const
+    const list_of_arguments_t &listarguments) const
 {
   arguments_by_model_t partial_args;
-  arguments_t::const_iterator argiter = arguments.begin();
   particletypes_per_model_t::const_iterator typesiter = particletypes_per_model.begin();
   models_t::const_iterator modeliter = models.begin();
 
-  // add constant model (which is always first model) with empty args if present
+  /// add constant model (which is always first model) with empty args if present
   if (typesiter->empty()) {
     partial_args.push_back(
@@ -266 +265 @@
     ++typesiter;
   }
+
   // then check other models
-  while (argiter != arguments.end()) {
+  /// we only have to check whether the current model still matches or whether
+  /// have to use the next model.
+  for (list_of_arguments_t::const_iterator argiter = listarguments.begin();
+      argiter != listarguments.end(); ++argiter) {
+    const arguments_t &arguments = *argiter;
     if (typesiter+1 != particletypes_per_model.end()) {
       // check whether next argument bunch is for same model or different one
@@ -275 +279 @@
 
       // we always expect N(N-1)/2 distances for N particle types
-      arguments_t::const_iterator enditer = argiter+(types.size()*(types.size()-1)/2);
-      arguments_t::const_iterator nextenditer = argiter+(nexttypes.size()*(nexttypes.size()-1)/2);
-      arguments_t args(argiter, enditer);
-      arguments_t nextargs(argiter, nextenditer);
-      if (types.size() < nexttypes.size()) {
-        if (areValidArguments(nexttypes, nextargs)) {
+      // check first from sizes alone
+      const size_t tuplesize = types.size()*(types.size()-1)/2;
+      const size_t nexttuplesize = nexttypes.size()*(nexttypes.size()-1)/2;
+      if ((tuplesize != nexttuplesize)) {
+        if ((arguments.size() == tuplesize) &&  areValidArguments(types, arguments)) {
+          // only former still matches, don't increment
+          partial_args.push_back(
+              std::make_pair(*modeliter, arguments)
+              );
+        } else if ((arguments.size() == nexttuplesize) &&  areValidArguments(nexttypes, arguments)) {
           // latter matches, increment
           ++typesiter;
           partial_args.push_back(
-              std::make_pair(*(++modeliter), arguments_t(argiter, nextenditer))
+              std::make_pair(*(++modeliter), arguments)
               );
-          argiter = nextenditer;
-        } else if (areValidArguments(types, args)) {
-          // only former matches, don't increment
-          partial_args.push_back(
-              std::make_pair(*modeliter, arguments_t(argiter, enditer))
-              );
-          argiter = enditer;
-        } else
+        } else {
           ASSERT(0,
-              "CompoundPotential::splitUpArgumentsByModels() - neither type matches its argument bunch.");
-      } else {
-        if (areValidArguments(types, args)) {
-          // only former matches, don't increment
-          partial_args.push_back(
-              std::make_pair(*modeliter, arguments_t(argiter, enditer))
-              );
-          argiter = enditer;
-        } else if (areValidArguments(nexttypes, nextargs)) {
-          // latter matches, increment
-          ++typesiter;
-          partial_args.push_back(
-              std::make_pair(*(++modeliter), arguments_t(argiter, nextenditer))
-              );
-          argiter = nextenditer;
+              "CompoundPotential::splitUpArgumentsByModels() - neither this model nor next model match (size) with current tuple.");
+        }
+      } else { // same size, now we have to check the types individually
+        size_t encodeValidity = 0;
+        encodeValidity += 1*areValidArguments(types, arguments);
+        encodeValidity += 2*areValidArguments(nexttypes, arguments);
+
+        switch (encodeValidity) {
+          case 1:
+            // only former still matches, don't increment
+            partial_args.push_back(
+                std::make_pair(*modeliter, arguments)
+                );
+            break;
+          case 2:
+            ++typesiter;
+            partial_args.push_back(
+                std::make_pair(*(++modeliter), arguments)
+                );
+            break;
+          case 0:
+          case 3:
+          default:
+            ASSERT(0,
+                "CompoundPotential::splitUpArgumentsByModels() - neither this model nor next model match (type) with current tuple.");
+            break;
         }
       }
     } else {
       const SerializablePotential::ParticleTypes_t &types = *typesiter;
-      // we always expect N(N-1)/2 distances for N particle types
-      arguments_t::const_iterator enditer = argiter+(types.size()*(types.size()-1)/2);
-      partial_args.push_back(
-          std::make_pair(*modeliter, arguments_t(argiter, enditer))
-          );
-      argiter = enditer;
+      if (areValidArguments(types, arguments)) {
+        // only former matches, don't increment
+        partial_args.push_back(
+            std::make_pair(*modeliter, arguments)
+            );
+      } else {
+        ASSERT(0,
+            "CompoundPotential::splitUpArgumentsByModels() - last model does not match with current tuple.");
+      }
     }
   }
@@ -326 +341 @@
 }
 
-CompoundPotential::results_t CompoundPotential::operator()(const arguments_t &arguments) const
+CompoundPotential::results_t CompoundPotential::operator()(
+    const list_of_arguments_t &listarguments) const
 {
   /// first, we have to split up the given arguments
   arguments_by_model_t partial_args =
-      splitUpArgumentsByModels(arguments);
+      splitUpArgumentsByModels(listarguments);
   // print split up argument list for debugging
   if (DoLog(4)) {
@@ -348 +364 @@
       iter != partial_args.end(); ++iter) {
     partial_results.push_back(
-        (*iter->first)(iter->second)
+        (*iter->first)(
+            FunctionModel::list_of_arguments_t(1, iter->second))
     );
   }
@@ -366 +383 @@
 }
 
-CompoundPotential::results_t CompoundPotential::parameter_derivative(const arguments_t &arguments, const size_t index) const
+CompoundPotential::results_t CompoundPotential::parameter_derivative(
+    const list_of_arguments_t &listarguments,
+    const size_t index) const
 {
   // first, we have to split up the given arguments
   arguments_by_model_t partial_args =
-      splitUpArgumentsByModels(arguments);
+      splitUpArgumentsByModels(listarguments);
   // then, with each bunch of arguments, we call the specific model
   // get parameter dimensions per model
@@ -399 +418 @@
       const size_t indexbase = (iter == dimensions.begin()) ? 0 : *(iter-1);
       CompoundPotential::results_t results =
-          model->parameter_derivative(argiter->second, index-indexbase);
+          model->parameter_derivative(
+              FunctionModel::list_of_arguments_t(1, argiter->second), index-indexbase);
 
       // either set results or add
@@ -462 +482 @@
   // create initial returnfunction
   FunctionModel::filter_t returnfunction =
-      boost::bind(&Helpers::returnEmptyArguments);
+      boost::bind(&Helpers::returnEmptyListArguments);
 
   // every following fragments combines its arguments with the initial function
@@ -468 +488 @@
       modeliter != models.end(); ++modeliter) {
     returnfunction =
-          boost::bind(&Extractors::concatenateArguments,
+          boost::bind(&Extractors::concatenateListOfArguments,
               boost::bind(returnfunction, _1),
               boost::bind((*modeliter)->getSpecificFilter(), _1)

src/Potentials/CompoundPotential.hpp

@@ -93 +93 @@
   /** Evaluates the harmonic potential function for the given arguments.
    *
-   * @param arguments single distance
+   * @param listarguments list of tuples of distances
    * @return value of the potential function
    */
-  results_t operator()(const arguments_t &arguments) const;
+  results_t operator()(const list_of_arguments_t &listarguments) const;
 
   /** Evaluates the derivative of the function with the given \a arguments
    * with respect to a specific parameter indicated by \a index.
    *
-   * \param arguments set of arguments as input variables to the function
+   * \param arguments list of sets of arguments as input variables to the function
    * \param index derivative of which parameter
    * \return result vector containing the derivative with respect to the given
    *         input
    */
-  results_t parameter_derivative(const arguments_t &arguments, const size_t index) const;
+  results_t parameter_derivative(const list_of_arguments_t &listarguments, const size_t index) const;
 
   /** States whether lower and upper boundaries should be used to constraint
@@ -153 +153 @@
   /** Helper function to split up concatenated arguments for operator() calls.
    *
-   * \param arguments arguments to split up
+   * \param listarguments list of tuples of distances to assign to a model each
    * \return vector of partial arguments with associated model
    */
-  arguments_by_model_t splitUpArgumentsByModels(const arguments_t &arguments) const;
+  arguments_by_model_t splitUpArgumentsByModels(const list_of_arguments_t &listarguments) const;
 
   /** Helper function to split up total list of arguments for operator() calls.

src/Potentials/EmpiricalPotential.hpp

@@ -60 +60 @@
    * parameters.
    *
-   * \param arguments set of arguments as input variables to the function
+   * \param listarguments list of sets of arguments as input variables to the function
    * \return result of the function
    */
-  virtual results_t operator()(const arguments_t &arguments) const=0;
+  virtual results_t operator()(const list_of_arguments_t &listarguments) const=0;
 
   /** Evaluates the derivative of the function with the given \a arguments
    * for each component.
    *
-   * \param arguments set of arguments as input variables to the function
+   * \param listarguments list of sets of arguments as input variables to the function
    * \return result vector containing the derivative with respect to each
    *         input comonent of the function
    */
-  virtual derivative_components_t derivative(const arguments_t &arguments) const=0;
+  virtual derivative_components_t derivative(const list_of_arguments_t &listarguments) const=0;
 
   /** Returns the functor that converts argument_s into the

src/Potentials/Specifics/ConstantPotential.cpp

@@ -112 +112 @@
 ConstantPotential::results_t
 ConstantPotential::operator()(
-    const arguments_t &arguments
+    const list_of_arguments_t &listarguments
     ) const
 {
-  ASSERT( arguments.size() == 0,
-      "ConstantPotential::operator() - requires no argument.");
-  ASSERT( ParticleTypeChecker::checkArgumentsAgainstParticleTypes(
-      arguments, getParticleTypes()),
-      "ConstantPotential::operator() - types don't match with ones in arguments.");
-  const result_t result = params[energy_offset];
-  return std::vector<result_t>(1, result);
+  // directly set result as energy constant as independent of arg list
+  result_t result = params[energy_offset];
+  for(list_of_arguments_t::const_iterator iter = listarguments.begin();
+      iter != listarguments.end(); ++iter) {
+    const arguments_t &arguments = *iter;
+    ASSERT( arguments.size() == 0,
+        "ConstantPotential::operator() - requires no argument.");
+    ASSERT( ParticleTypeChecker::checkArgumentsAgainstParticleTypes(
+        arguments, getParticleTypes()),
+        "ConstantPotential::operator() - types don't match with ones in arguments.");
+    result += 0.;
+  }
+  return results_t(1, result);
 }
 
 ConstantPotential::derivative_components_t
 ConstantPotential::derivative(
-    const arguments_t &arguments
+    const list_of_arguments_t &listarguments
     ) const
 {
-  ASSERT( arguments.size() == 0,
-      "ConstantPotential::operator() - requires no argument.");
-  ASSERT( ParticleTypeChecker::checkArgumentsAgainstParticleTypes(
-      arguments, getParticleTypes()),
-      "ConstantPotential::operator() - types don't match with ones in arguments.");
-  derivative_components_t result(1, 0.);
-  return result;
+  result_t result = 0.;
+  for(list_of_arguments_t::const_iterator iter = listarguments.begin();
+      iter != listarguments.end(); ++iter) {
+    const arguments_t &arguments = *iter;
+    ASSERT( arguments.size() == 0,
+        "ConstantPotential::operator() - requires no argument.");
+    ASSERT( ParticleTypeChecker::checkArgumentsAgainstParticleTypes(
+        arguments, getParticleTypes()),
+        "ConstantPotential::operator() - types don't match with ones in arguments.");
+    result += 0.;
+  }
+  return derivative_components_t(1, result);
 }
 
 ConstantPotential::results_t
 ConstantPotential::parameter_derivative(
-    const arguments_t &arguments,
+    const list_of_arguments_t &listarguments,
     const size_t index
     ) const
 {
-  ASSERT( arguments.size() == 0,
-      "ConstantPotential::parameter_derivative() - requires no argument.");
-  ASSERT( ParticleTypeChecker::checkArgumentsAgainstParticleTypes(
-      arguments, getParticleTypes()),
-      "ConstantPotential::operator() - types don't match with ones in arguments.");
-  switch (index) {
-    case energy_offset:
-    {
-      // Maple result: 1
-      const result_t result = +1.;
-      return std::vector<result_t>(1, result);
-      break;
-    }
-    default:
-      break;
+  // Maple result: 1
+  result_t result = 1.;   // energy_offset
+  for(list_of_arguments_t::const_iterator iter = listarguments.begin();
+      iter != listarguments.end(); ++iter) {
+    const arguments_t &arguments = *iter;
+    ASSERT( arguments.size() == 0,
+        "ConstantPotential::parameter_derivative() - requires no argument.");
+    ASSERT( ParticleTypeChecker::checkArgumentsAgainstParticleTypes(
+        arguments, getParticleTypes()),
+        "ConstantPotential::operator() - types don't match with ones in arguments.");
+//    switch (index) {
+//      case energy_offset:
+//      {
+//        // Maple result: 1
+//        result = +1.;
+//        break;
+//      }
+//      default:
+//        break;
+//    }
   }
-  return std::vector<result_t>(1, 0.);
+  return results_t(1, result);
 }
 

src/Potentials/Specifics/ConstantPotential.hpp

@@ -36 +36 @@
   friend class PotentialFactory;
   // some repeated typedefs to avoid ambiguities
+  typedef FunctionModel::list_of_arguments_t list_of_arguments_t;
   typedef FunctionModel::arguments_t arguments_t;
   typedef FunctionModel::result_t result_t;
@@ -90 +91 @@
   /** Evaluates the harmonic potential function for the given arguments.
    *
-   * @param arguments single distance
+   * @param listarguments empty list
    * @return value of the potential function
    */
-  results_t operator()(const arguments_t &arguments) const;
+  results_t operator()(const list_of_arguments_t &listarguments) const;
 
   /** Evaluates the derivative of the potential function.
    *
-   * @param arguments single distance
+   * @param listarguments empty list
    * @return vector with derivative with respect to the input degrees of freedom
    */
-  derivative_components_t derivative(const arguments_t &arguments) const;
+  derivative_components_t derivative(const list_of_arguments_t &listarguments) const;
 
   /** Evaluates the derivative of the function with the given \a arguments
    * with respect to a specific parameter indicated by \a index.
    *
-   * \param arguments set of arguments as input variables to the function
+   * \param listarguments empty list
    * \param index derivative of which parameter
    * \return result vector containing the derivative with respect to the given
    *         input
    */
-  results_t parameter_derivative(const arguments_t &arguments, const size_t index) const;
+  results_t parameter_derivative(const list_of_arguments_t &listarguments, const size_t index) const;
 
   /** Returns the functor that converts argument_s into the

src/Potentials/Specifics/FourBodyPotential_Torsion.cpp

@@ -140 +140 @@
 FourBodyPotential_Torsion::results_t
 FourBodyPotential_Torsion::operator()(
-    const arguments_t &arguments
+    const list_of_arguments_t &listarguments
     ) const
 {
-  ASSERT( arguments.size() == getSpecificArgumentCount(),
-      "FourBodyPotential_Torsion::operator() - requires exactly three arguments.");
-  ASSERT( ParticleTypeChecker::checkArgumentsAgainstParticleTypes(
-      arguments, getParticleTypes()),
-      "FourBodyPotential_Torsion::operator() - types don't match with ones in arguments.");
-  const argument_t &r_ij = arguments[0]; // 01
-  const argument_t &r_ik = arguments[1]; // 02
-  const argument_t &r_il = arguments[2]; // 03
-  const argument_t &r_jk = arguments[3]; // 12
-  const argument_t &r_jl = arguments[4]; // 13
-  const argument_t &r_kl = arguments[5]; // 23
-  const result_t result =
-      params[spring_constant]
-             * Helpers::pow( function_theta(r_ij.distance, r_ik.distance, r_il.distance, r_jk.distance, r_jl.distance, r_kl.distance) - params[equilibrium_distance], 2 );
-  return std::vector<result_t>(1, result);
+  result_t result = 0.;
+  for(list_of_arguments_t::const_iterator iter = listarguments.begin();
+      iter != listarguments.end(); ++iter) {
+    const arguments_t &arguments = *iter;
+    ASSERT( arguments.size() == getSpecificArgumentCount(),
+        "FourBodyPotential_Torsion::operator() - requires exactly three arguments.");
+    ASSERT( ParticleTypeChecker::checkArgumentsAgainstParticleTypes(
+        arguments, getParticleTypes()),
+        "FourBodyPotential_Torsion::operator() - types don't match with ones in arguments.");
+    const argument_t &r_ij = arguments[0]; // 01
+    const argument_t &r_ik = arguments[1]; // 02
+    const argument_t &r_il = arguments[2]; // 03
+    const argument_t &r_jk = arguments[3]; // 12
+    const argument_t &r_jl = arguments[4]; // 13
+    const argument_t &r_kl = arguments[5]; // 23
+    result +=
+        params[spring_constant]
+               * Helpers::pow( function_theta(r_ij.distance, r_ik.distance, r_il.distance, r_jk.distance, r_jl.distance, r_kl.distance)
+                   - params[equilibrium_distance], 2 );
+  }
+  return results_t(1, result);
 }
 
 FourBodyPotential_Torsion::derivative_components_t
 FourBodyPotential_Torsion::derivative(
-    const arguments_t &arguments
+    const list_of_arguments_t &listarguments
     ) const
 {
-  ASSERT( arguments.size() == getSpecificArgumentCount(),
-      "FourBodyPotential_Torsion::operator() - requires exactly three arguments.");
-  ASSERT( ParticleTypeChecker::checkArgumentsAgainstParticleTypes(
-      arguments, getParticleTypes()),
-      "FourBodyPotential_Torsion::operator() - types don't match with ones in arguments.");
-  derivative_components_t result;
-  const argument_t &r_ij = arguments[0]; // 01
-  const argument_t &r_ik = arguments[1]; // 02
-  const argument_t &r_il = arguments[2]; // 03
-  const argument_t &r_jk = arguments[3]; // 12
-  const argument_t &r_jl = arguments[4]; // 13
-  const argument_t &r_kl = arguments[5]; // 23
-  result.push_back( 2. * params[spring_constant] * ( function_theta(r_ij.distance, r_ik.distance, r_il.distance, r_jk.distance, r_jl.distance, r_kl.distance) - params[equilibrium_distance]) );
-  ASSERT( result.size() == 1,
-      "FourBodyPotential_Torsion::operator() - we did not create exactly one component.");
-  return result;
+  result_t result = 0.;
+  for(list_of_arguments_t::const_iterator iter = listarguments.begin();
+      iter != listarguments.end(); ++iter) {
+    const arguments_t &arguments = *iter;
+    ASSERT( arguments.size() == getSpecificArgumentCount(),
+        "FourBodyPotential_Torsion::operator() - requires exactly three arguments.");
+    ASSERT( ParticleTypeChecker::checkArgumentsAgainstParticleTypes(
+        arguments, getParticleTypes()),
+        "FourBodyPotential_Torsion::operator() - types don't match with ones in arguments.");
+    const argument_t &r_ij = arguments[0]; // 01
+    const argument_t &r_ik = arguments[1]; // 02
+    const argument_t &r_il = arguments[2]; // 03
+    const argument_t &r_jk = arguments[3]; // 12
+    const argument_t &r_jl = arguments[4]; // 13
+    const argument_t &r_kl = arguments[5]; // 23
+    result +=
+        2. * params[spring_constant] *
+        ( function_theta(r_ij.distance, r_ik.distance, r_il.distance, r_jk.distance, r_jl.distance, r_kl.distance)
+            - params[equilibrium_distance]);
+  }
+  return derivative_components_t(1, result);
 }
 
 FourBodyPotential_Torsion::results_t
 FourBodyPotential_Torsion::parameter_derivative(
-    const arguments_t &arguments,
+    const list_of_arguments_t &listarguments,
     const size_t index
     ) const
 {
-  ASSERT( arguments.size() == getSpecificArgumentCount(),
-      "FourBodyPotential_Torsion::parameter_derivative() - requires exactly three arguments.");
-  ASSERT( ParticleTypeChecker::checkArgumentsAgainstParticleTypes(
-      arguments, getParticleTypes()),
-      "FourBodyPotential_Torsion::operator() - types don't match with ones in arguments.");
-  const argument_t &r_ij = arguments[0]; // 01
-  const argument_t &r_ik = arguments[1]; // 02
-  const argument_t &r_il = arguments[2]; // 03
-  const argument_t &r_jk = arguments[3]; // 12
-  const argument_t &r_jl = arguments[4]; // 13
-  const argument_t &r_kl = arguments[5]; // 23
-  switch (index) {
-    case spring_constant:
-    {
-      const result_t result =
-                 Helpers::pow( function_theta(r_ij.distance, r_ik.distance, r_il.distance, r_jk.distance, r_jl.distance, r_kl.distance) - params[equilibrium_distance], 2 );
-      return std::vector<result_t>(1, result);
-      break;
+  result_t result = 0.;
+  for(list_of_arguments_t::const_iterator iter = listarguments.begin();
+      iter != listarguments.end(); ++iter) {
+    const arguments_t &arguments = *iter;
+    ASSERT( arguments.size() == getSpecificArgumentCount(),
+        "FourBodyPotential_Torsion::parameter_derivative() - requires exactly three arguments.");
+    ASSERT( ParticleTypeChecker::checkArgumentsAgainstParticleTypes(
+        arguments, getParticleTypes()),
+        "FourBodyPotential_Torsion::operator() - types don't match with ones in arguments.");
+    const argument_t &r_ij = arguments[0]; // 01
+    const argument_t &r_ik = arguments[1]; // 02
+    const argument_t &r_il = arguments[2]; // 03
+    const argument_t &r_jk = arguments[3]; // 12
+    const argument_t &r_jl = arguments[4]; // 13
+    const argument_t &r_kl = arguments[5]; // 23
+    switch (index) {
+      case spring_constant:
+      {
+        result +=
+            Helpers::pow( function_theta(r_ij.distance, r_ik.distance, r_il.distance, r_jk.distance, r_jl.distance, r_kl.distance) - params[equilibrium_distance], 2 );
+        break;
+      }
+      case equilibrium_distance:
+      {
+        result +=
+            -2. * params[spring_constant]
+                   * ( function_theta(r_ij.distance, r_ik.distance, r_il.distance, r_jk.distance, r_jl.distance, r_kl.distance) - params[equilibrium_distance]);
+        break;
+      }
+      default:
+        ASSERT(0, "FourBodyPotential_Torsion::parameter_derivative() - derivative to unknown parameter desired.");
+        break;
     }
-    case equilibrium_distance:
-    {
-      const result_t result =
-          -2. * params[spring_constant]
-                 * ( function_theta(r_ij.distance, r_ik.distance, r_il.distance, r_jk.distance, r_jl.distance, r_kl.distance) - params[equilibrium_distance]);
-      return std::vector<result_t>(1, result);
-      break;
-    }
-    default:
-      ASSERT(0, "FourBodyPotential_Torsion::parameter_derivative() - derivative to unknown parameter desired.");
-      break;
   }
-  return std::vector<result_t>(1);
+  return results_t(1, result);
 }
 

src/Potentials/Specifics/FourBodyPotential_Torsion.hpp

@@ -37 +37 @@
   friend class PotentialFactory;
   // some repeated typedefs to avoid ambiguities
+  typedef FunctionModel::list_of_arguments_t list_of_arguments_t;
   typedef FunctionModel::arguments_t arguments_t;
   typedef FunctionModel::result_t result_t;
@@ -92 +93 @@
   /** Evaluates the harmonic potential function for the given arguments.
    *
-   * @param arguments single distance
+   * @param listarguments list of six distances
    * @return value of the potential function
    */
-  results_t operator()(const arguments_t &arguments) const;
+  results_t operator()(const list_of_arguments_t &listarguments) const;
 
   /** Evaluates the derivative of the potential function.
    *
-   * @param arguments single distance
+   * @param listarguments list of six distances
    * @return vector with derivative with respect to the input degrees of freedom
    */
-  derivative_components_t derivative(const arguments_t &arguments) const;
+  derivative_components_t derivative(const list_of_arguments_t &listarguments) const;
 
   /** Evaluates the derivative of the function with the given \a arguments
    * with respect to a specific parameter indicated by \a index.
    *
-   * \param arguments set of arguments as input variables to the function
+   * \param listarguments list of six distances
    * \param index derivative of which parameter
    * \return result vector containing the derivative with respect to the given
    *         input
    */
-  results_t parameter_derivative(const arguments_t &arguments, const size_t index) const;
+  results_t parameter_derivative(const list_of_arguments_t &listarguments, const size_t index) const;
 
   /** Returns the functor that converts argument_s into the

src/Potentials/Specifics/ManyBodyPotential_Tersoff.cpp

@@ -184 +184 @@
 ManyBodyPotential_Tersoff::results_t
 ManyBodyPotential_Tersoff::operator()(
-    const arguments_t &arguments
+    const list_of_arguments_t &listarguments
     ) const
 {
 //  Info info(__func__);
-  double result = 0.;
-  for(arguments_t::const_iterator argiter = arguments.begin();
-      argiter != arguments.end();
-      ++argiter) {
-    const argument_t &r_ij = *argiter;
-    ASSERT( ParticleTypeChecker::checkArgumentsAgainstParticleTypes(
-        arguments_t(1, r_ij), getParticleTypes()),
-        "ManyBodyPotential_Tersoff::operator() - types don't match with ones in arguments.");
- 
-    const double cutoff = function_cutoff(r_ij.distance);
-    const double temp = (cutoff == 0.) ?
-        0. :
-        cutoff * (
-            function_prefactor(
-                alpha,
-                function_eta(r_ij))
+  result_t result = 0.;
+  for(list_of_arguments_t::const_iterator iter = listarguments.begin();
+      iter != listarguments.end(); ++iter) {
+    const arguments_t &arguments = *iter;
+    for(arguments_t::const_iterator argiter = arguments.begin();
+        argiter != arguments.end();
+        ++argiter) {
+      const argument_t &r_ij = *argiter;
+      ASSERT( ParticleTypeChecker::checkArgumentsAgainstParticleTypes(
+          arguments_t(1, r_ij), getParticleTypes()),
+          "ManyBodyPotential_Tersoff::operator() - types don't match with ones in arguments.");
+
+      const double cutoff = function_cutoff(r_ij.distance);
+      const double temp = (cutoff == 0.) ?
+          0. :
+          cutoff * (
+              function_prefactor(
+                  alpha,
+                  function_eta(r_ij))
+              * function_smoother(
+                  params[A],
+                  params[lambda],
+                  r_ij.distance)
+              +
+              function_prefactor(
+                  params[beta],
+                  function_zeta(r_ij))
+              * function_smoother(
+                  -params[B],
+                  params[mu],
+                  r_ij.distance)
+          );
+      result += temp;
+    }
+  }
+//  LOG(2, "DEBUG: operator()(" << r_ij.distance << ") = " << result);
+  return results_t(1, result);
+}
+
+ManyBodyPotential_Tersoff::derivative_components_t
+ManyBodyPotential_Tersoff::derivative(
+    const list_of_arguments_t &listarguments
+    ) const
+{
+//  Info info(__func__);
+  return derivative_components_t();
+}
+
+ManyBodyPotential_Tersoff::results_t
+ManyBodyPotential_Tersoff::parameter_derivative(
+    const list_of_arguments_t &listarguments,
+    const size_t index
+    ) const
+{
+//  Info info(__func__);
+//  ASSERT( arguments.size() == 1,
+//      "ManyBodyPotential_Tersoff::parameter_derivative() - requires exactly one argument.");
+
+  result_t result = 0.;
+  for(list_of_arguments_t::const_iterator iter = listarguments.begin();
+      iter != listarguments.end(); ++iter) {
+    const arguments_t &arguments = *iter;
+    for(arguments_t::const_iterator argiter = arguments.begin();
+        argiter != arguments.end();
+        ++argiter) {
+      const argument_t &r_ij = *argiter;
+      ASSERT( ParticleTypeChecker::checkArgumentsAgainstParticleTypes(
+          arguments_t(1, r_ij), getParticleTypes()),
+          "ManyBodyPotential_Tersoff::operator() - types don't match with ones in arguments.");
+
+    switch (index) {
+//      case R:
+//      {
+//        result += 0.;
+//        break;
+//      }
+//      case S:
+//      {
+//        result += 0.;
+//        break;
+//      }
+      case A:
+      {
+        const double cutoff = function_cutoff(r_ij.distance);
+        result += (cutoff == 0.) ?
+            0. :
+            cutoff *
+                function_prefactor(
+                    alpha,
+                    function_eta(r_ij))
+                * function_smoother(
+                    1.,
+                    params[lambda],
+                    r_ij.distance);
+//            cutoff * function_prefactor(
+//                alpha,
+//                function_eta(r_ij))
+//            * function_smoother(
+//                1.,
+//                params[mu],
+//                r_ij.distance);
+        break;
+      }
+      case B:
+      {
+        const double cutoff = function_cutoff(r_ij.distance);
+        result += (cutoff == 0.) ?
+            0. :
+            cutoff * function_prefactor(
+                params[beta],
+                function_zeta(r_ij))
             * function_smoother(
-                params[A],
-                params[lambda],
-                r_ij.distance)
-            +
+                -1.,
+                params[mu],
+                r_ij.distance);
+//            cutoff * function_prefactor(
+//                beta,
+//                function_zeta(r_ij))
+//            * function_smoother(
+//                -params[B],
+//                params[mu],
+//                r_ij.distance)/params[B];
+        break;
+      }
+      case lambda:
+      {
+        const double cutoff = function_cutoff(r_ij.distance);
+        result += (cutoff == 0.) ?
+            0. :
+            -r_ij.distance * cutoff *
+                function_prefactor(
+                    alpha,
+                    function_eta(r_ij))
+                * function_smoother(
+                    params[A],
+                    params[lambda],
+                    r_ij.distance);
+        break;
+      }
+      case mu:
+      {
+        const double cutoff = function_cutoff(r_ij.distance);
+        result += (cutoff == 0.) ?
+            0. :
+            -r_ij.distance * cutoff *(
             function_prefactor(
                 params[beta],
@@ -217 +341 @@
                 r_ij.distance)
         );
-    result += temp;
-  }
-//  LOG(2, "DEBUG: operator()(" << r_ij.distance << ") = " << result);
-  return std::vector<result_t>(1, result);
-}
-
-ManyBodyPotential_Tersoff::derivative_components_t
-ManyBodyPotential_Tersoff::derivative(
-    const arguments_t &arguments
-    ) const
-{
-//  Info info(__func__);
-  return ManyBodyPotential_Tersoff::derivative_components_t();
-}
-
-ManyBodyPotential_Tersoff::results_t
-ManyBodyPotential_Tersoff::parameter_derivative(
-    const arguments_t &arguments,
-    const size_t index
-    ) const
-{
-//  Info info(__func__);
-//  ASSERT( arguments.size() == 1,
-//      "ManyBodyPotential_Tersoff::parameter_derivative() - requires exactly one argument.");
-
-  double result = 0.;
-  for(arguments_t::const_iterator argiter = arguments.begin();
-      argiter != arguments.end();
-      ++argiter) {
-    const argument_t &r_ij = *argiter;
-    ASSERT( ParticleTypeChecker::checkArgumentsAgainstParticleTypes(
-        arguments_t(1, r_ij), getParticleTypes()),
-        "ManyBodyPotential_Tersoff::operator() - types don't match with ones in arguments.");
-
-  switch (index) {
-//    case R:
-//    {
-//      result += 0.;
-//      break;
-//    }
-//    case S:
-//    {
-//      result += 0.;
-//      break;
-//    }
-    case A:
-    {
-      const double cutoff = function_cutoff(r_ij.distance);
-      result += (cutoff == 0.) ?
-          0. :
-          cutoff *
-              function_prefactor(
-                  alpha,
-                  function_eta(r_ij))
-              * function_smoother(
-                  1.,
-                  params[lambda],
-                  r_ij.distance);
-//          cutoff * function_prefactor(
-//              alpha,
-//              function_eta(r_ij))
-//          * function_smoother(
-//              1.,
-//              params[mu],
-//              r_ij.distance);
-      break;
+        break;
+      }
+//      case lambda3:
+//      {
+//        result += 0.;
+//        break;
+//      }
+//      case alpha:
+//      {
+//        const double temp =
+//            pow(alpha*function_eta(r_ij), params[n]);
+//        const double cutoff = function_cutoff(r_ij.distance);
+//        result += (cutoff == 0.) || (alpha == 0. )?
+//            0. :
+//            function_smoother(
+//                params[A],
+//                params[lambda],
+//                r_ij.distance)
+//            * (-.5) * alpha * (temp/alpha)
+//            / (1. + temp)
+//            ;
+//        break;
+//      }
+//      case chi:
+//      {
+//        result += 0.;
+//        break;
+//      }
+//      case omega:
+//      {
+//        result += 0.;
+//        break;
+//      }
+      case beta:
+      {
+        const double temp =
+            pow(params[beta]*function_zeta(r_ij), params[n]);
+        const double cutoff = function_cutoff(r_ij.distance);
+        result += (cutoff == 0.) || (params[beta] == 0. )?
+            0. : cutoff *
+            function_smoother(
+                -params[B],
+                params[mu],
+                r_ij.distance)
+            * (-.5)
+            * function_prefactor(
+                params[beta],
+                function_zeta(r_ij))
+            * (temp/params[beta])
+            / (1. + temp)
+            ;
+        break;
+      }
+      case n:
+      {
+        const double zeta = function_zeta(r_ij);
+        const double temp = pow( params[beta]*zeta , params[n]);
+        const double cutoff = function_cutoff(r_ij.distance);
+        const double tempres = ((cutoff == 0.) || (zeta == 0.)) ? // zeta must be caught if zero due to log
+            0. : .5 * cutoff *
+            function_smoother(
+                -params[B],
+                params[mu],
+                r_ij.distance)
+            * function_prefactor(
+                params[beta],
+                function_zeta(r_ij))
+            * ( log(1.+temp)/(params[n]*params[n]) - temp
+                * (log(function_zeta(r_ij)) + log(params[beta]))
+                /(params[n]*(1.+temp)))
+            ;
+//        if (tempres != tempres)
+//    LOG(2, "DEBUG: tempres is NaN.");
+//        LOG(2, "DEBUG: Adding " << tempres << " for p.d. w.r.t n, temp=" << temp << ", cutoff=" << cutoff);
+        result += tempres;
+        break;
+      }
+      case c:
+      {
+        const double zeta = function_zeta(r_ij);
+        if (zeta == 0.)
+          break;
+        const double temp =
+            pow(zeta, params[n]-1.) * pow(params[beta],params[n]);
+        const double cutoff = function_cutoff(r_ij.distance);
+        const double tempres = (cutoff == 0.) ?
+            0. : cutoff *
+            function_smoother(
+                -params[B],
+                params[mu],
+                r_ij.distance)
+            * function_prefactor(
+                params[beta],
+                zeta)
+             * (-1.) * temp / (1.+temp*zeta);
+        double factor = function_derivative_c(r_ij);
+        result += tempres*factor;
+        if (result != result)
+          ELOG(1, "result is NaN, zeta=" << zeta << ", temp=" << temp << ", cutoff=" << cutoff << ", tempres=" << tempres << ", factor=" << factor);
+        break;
+      }
+      case d:
+      {
+        const double zeta = function_zeta(r_ij);
+        const double temp =
+            pow(zeta, params[n]-1.) * pow(params[beta],params[n]);
+        const double cutoff = function_cutoff(r_ij.distance);
+        const double tempres = (cutoff == 0.) ?
+            0. : cutoff *
+            function_smoother(
+                -params[B],
+                params[mu],
+                r_ij.distance)
+            * function_prefactor(
+                params[beta],
+                zeta)
+             * (-1.) * temp / (1.+temp*zeta);
+        double factor = function_derivative_d(r_ij);
+        result += tempres*factor;
+        if (result != result)
+          ELOG(1, "result is NaN, zeta=" << zeta << ", temp=" << temp << ", cutoff=" << cutoff << ", tempres=" << tempres << ", factor=" << factor);
+        break;
+      }
+      case h:
+      {
+        const double zeta = function_zeta(r_ij);
+        const double temp =
+            pow(zeta, params[n]-1.) * pow(params[beta],params[n]);
+        const double cutoff = function_cutoff(r_ij.distance);
+        const double tempres = (cutoff == 0.) ?
+            0. : cutoff *
+            function_smoother(
+                -params[B],
+                params[mu],
+                r_ij.distance)
+            * function_prefactor(
+                params[beta],
+                zeta)
+             * (-1.) * temp / (1.+temp*zeta);
+        double factor = function_derivative_h(r_ij);
+        result += tempres*factor;
+        if (result != result)
+          ELOG(1, "result is NaN, zeta=" << zeta << ", temp=" << temp << ", cutoff=" << cutoff << ", tempres=" << tempres << ", factor=" << factor);
+        break;
+      }
+      default:
+        ASSERT(0, "ManyBodyPotential_Tersoff::parameter_derivative() - derivative to unknown parameter desired.");
+        break;
     }
-    case B:
-    {
-      const double cutoff = function_cutoff(r_ij.distance);
-      result += (cutoff == 0.) ?
-          0. :
-          cutoff * function_prefactor(
-              params[beta],
-              function_zeta(r_ij))
-          * function_smoother(
-              -1.,
-              params[mu],
-              r_ij.distance);
-//          cutoff * function_prefactor(
-//              beta,
-//              function_zeta(r_ij))
-//          * function_smoother(
-//              -params[B],
-//              params[mu],
-//              r_ij.distance)/params[B];
-      break;
+    if (result != result)
+      ELOG(1, "result is NaN.");
     }
-    case lambda:
-    {
-      const double cutoff = function_cutoff(r_ij.distance);
-      result += (cutoff == 0.) ?
-          0. :
-          -r_ij.distance * cutoff *
-              function_prefactor(
-                  alpha,
-                  function_eta(r_ij))
-              * function_smoother(
-                  params[A],
-                  params[lambda],
-                  r_ij.distance);
-      break;
-    }
-    case mu:
-    {
-      const double cutoff = function_cutoff(r_ij.distance);
-      result += (cutoff == 0.) ?
-          0. :
-          -r_ij.distance * cutoff *(
-          function_prefactor(
-              params[beta],
-              function_zeta(r_ij))
-          * function_smoother(
-              -params[B],
-              params[mu],
-              r_ij.distance)
-      );
-      break;
-    }
-//    case lambda3:
-//    {
-//      result += 0.;
-//      break;
-//    }
-//    case alpha:
-//    {
-//      const double temp =
-//          pow(alpha*function_eta(r_ij), params[n]);
-//      const double cutoff = function_cutoff(r_ij.distance);
-//      result += (cutoff == 0.) || (alpha == 0. )?
-//          0. :
-//          function_smoother(
-//              params[A],
-//              params[lambda],
-//              r_ij.distance)
-//          * (-.5) * alpha * (temp/alpha)
-//          / (1. + temp)
-//          ;
-//      break;
-//    }
-//    case chi:
-//    {
-//      result += 0.;
-//      break;
-//    }
-//    case omega:
-//    {
-//      result += 0.;
-//      break;
-//    }
-    case beta:
-    {
-      const double temp =
-          pow(params[beta]*function_zeta(r_ij), params[n]);
-      const double cutoff = function_cutoff(r_ij.distance);
-      result += (cutoff == 0.) || (params[beta] == 0. )?
-          0. : cutoff *
-          function_smoother(
-              -params[B],
-              params[mu],
-              r_ij.distance)
-          * (-.5)
-          * function_prefactor(
-              params[beta],
-              function_zeta(r_ij))
-          * (temp/params[beta])
-          / (1. + temp)
-          ;
-      break;
-    }
-    case n:
-    {
-      const double zeta = function_zeta(r_ij);
-      const double temp = pow( params[beta]*zeta , params[n]);
-      const double cutoff = function_cutoff(r_ij.distance);
-      const double tempres = ((cutoff == 0.) || (zeta == 0.)) ? // zeta must be caught if zero due to log
-          0. : .5 * cutoff *
-          function_smoother(
-              -params[B],
-              params[mu],
-              r_ij.distance)
-          * function_prefactor(
-              params[beta],
-              function_zeta(r_ij))
-          * ( log(1.+temp)/(params[n]*params[n]) - temp
-              * (log(function_zeta(r_ij)) + log(params[beta]))
-              /(params[n]*(1.+temp)))
-          ;
-//      if (tempres != tempres)
-//      LOG(2, "DEBUG: tempres is NaN."); 
-//      LOG(2, "DEBUG: Adding " << tempres << " for p.d. w.r.t n, temp=" << temp << ", cutoff=" << cutoff);
-      result += tempres;
-      break;
-    }
-    case c:
-    {
-      const double zeta = function_zeta(r_ij);
-      if (zeta == 0.)
-        break;
-      const double temp =
-          pow(zeta, params[n]-1.) * pow(params[beta],params[n]);
-      const double cutoff = function_cutoff(r_ij.distance);
-      const double tempres = (cutoff == 0.) ?
-          0. : cutoff *
-          function_smoother(
-              -params[B],
-              params[mu],
-              r_ij.distance)
-          * function_prefactor(
-              params[beta],
-              zeta)
-           * (-1.) * temp / (1.+temp*zeta);
-      double factor = function_derivative_c(r_ij);
-      result += tempres*factor;
-      if (result != result)
-        ELOG(1, "result is NaN, zeta=" << zeta << ", temp=" << temp << ", cutoff=" << cutoff << ", tempres=" << tempres << ", factor=" << factor);
-      break;
-    }
-    case d:
-    {
-      const double zeta = function_zeta(r_ij);
-      const double temp =
-          pow(zeta, params[n]-1.) * pow(params[beta],params[n]);
-      const double cutoff = function_cutoff(r_ij.distance);
-      const double tempres = (cutoff == 0.) ?
-          0. : cutoff *
-          function_smoother(
-              -params[B],
-              params[mu],
-              r_ij.distance)
-          * function_prefactor(
-              params[beta],
-              zeta)
-           * (-1.) * temp / (1.+temp*zeta);
-      double factor = function_derivative_d(r_ij);
-      result += tempres*factor;
-      if (result != result)
-        ELOG(1, "result is NaN, zeta=" << zeta << ", temp=" << temp << ", cutoff=" << cutoff << ", tempres=" << tempres << ", factor=" << factor);
-      break;
-    }
-    case h:
-    {
-      const double zeta = function_zeta(r_ij);
-      const double temp =
-          pow(zeta, params[n]-1.) * pow(params[beta],params[n]);
-      const double cutoff = function_cutoff(r_ij.distance);
-      const double tempres = (cutoff == 0.) ?
-          0. : cutoff *
-          function_smoother(
-              -params[B],
-              params[mu],
-              r_ij.distance)
-          * function_prefactor(
-              params[beta],
-              zeta)
-           * (-1.) * temp / (1.+temp*zeta);
-      double factor = function_derivative_h(r_ij);
-      result += tempres*factor;
-      if (result != result)
-        ELOG(1, "result is NaN, zeta=" << zeta << ", temp=" << temp << ", cutoff=" << cutoff << ", tempres=" << tempres << ", factor=" << factor);
-      break;
-    }
-    default:
-      ASSERT(0, "ManyBodyPotential_Tersoff::parameter_derivative() - derivative to unknown parameter desired.");
-      break;
-  }
-  if (result != result)
-    ELOG(1, "result is NaN.");
   }
   return results_t(1,-result);

src/Potentials/Specifics/ManyBodyPotential_Tersoff.hpp

@@ -38 +38 @@
   friend class PotentialFactory;
   // some repeated typedefs to avoid ambiguities
+  typedef FunctionModel::list_of_arguments_t list_of_arguments_t;
   typedef FunctionModel::arguments_t arguments_t;
   typedef FunctionModel::result_t result_t;
@@ -106 +107 @@
   /** Evaluates the Tersoff potential for the given arguments.
    *
-   * @param arguments single distance
+   * @param listarguments list of distances
    * @return value of the potential function
    */
-  results_t operator()(const arguments_t &arguments) const;
+  results_t operator()(const list_of_arguments_t &listarguments) const;
 
   /** Evaluates the derivative of the Tersoff potential with respect to the
    * input variables.
    *
-   * @param arguments single distance
+   * @param listarguments list of distances
    * @return vector with components of the derivative
    */
-  derivative_components_t derivative(const arguments_t &arguments) const;
+  derivative_components_t derivative(const list_of_arguments_t &listarguments) const;
 
   /** Evaluates the derivative of the function with the given \a arguments
    * with respect to a specific parameter indicated by \a index.
    *
-   * \param arguments set of arguments as input variables to the function
+   * \param listarguments list of distances
    * \param index derivative of which parameter
    * \return result vector containing the derivative with respect to the given
    *         input
    */
-  results_t parameter_derivative(const arguments_t &arguments, const size_t index) const;
+  results_t parameter_derivative(const list_of_arguments_t &listarguments, const size_t index) const;
 
   /** Returns the functor that converts argument_s into the

src/Potentials/Specifics/PairPotential_Harmonic.cpp

@@ -117 +117 @@
 PairPotential_Harmonic::results_t
 PairPotential_Harmonic::operator()(
-    const arguments_t &arguments
+    const list_of_arguments_t &listarguments
     ) const
 {
-  ASSERT( arguments.size() == 1,
-      "PairPotential_Harmonic::operator() - requires exactly one argument.");
-  ASSERT( ParticleTypeChecker::checkArgumentsAgainstParticleTypes(
-      arguments, getParticleTypes()),
-      "PairPotential_Harmonic::operator() - types don't match with ones in arguments.");
-  const argument_t &r_ij = arguments[0];
-  const result_t result =
-      params[spring_constant]
-             * Helpers::pow( r_ij.distance - params[equilibrium_distance], 2 );
-  return std::vector<result_t>(1, result);
+  result_t result = 0.;
+  for(list_of_arguments_t::const_iterator iter = listarguments.begin();
+      iter != listarguments.end(); ++iter) {
+    const arguments_t &arguments = *iter;
+    ASSERT( arguments.size() == 1,
+        "PairPotential_Harmonic::operator() - requires exactly one argument.");
+    ASSERT( ParticleTypeChecker::checkArgumentsAgainstParticleTypes(
+        arguments, getParticleTypes()),
+        "PairPotential_Harmonic::operator() - types don't match with ones in arguments.");
+    const argument_t &r_ij = arguments[0];
+    result +=
+        params[spring_constant]
+               * Helpers::pow( r_ij.distance - params[equilibrium_distance], 2 );
+  }
+  return results_t(1, result);
 }
 
 PairPotential_Harmonic::derivative_components_t
 PairPotential_Harmonic::derivative(
-    const arguments_t &arguments
+    const list_of_arguments_t &listarguments
     ) const
 {
-  ASSERT( arguments.size() == 1,
-      "PairPotential_Harmonic::operator() - requires exactly one argument.");
-  ASSERT( ParticleTypeChecker::checkArgumentsAgainstParticleTypes(
-      arguments, getParticleTypes()),
-      "PairPotential_Harmonic::operator() - types don't match with ones in arguments.");
-  derivative_components_t result;
-  const argument_t &r_ij = arguments[0];
-  result.push_back( 2. * params[spring_constant] * ( r_ij.distance - params[equilibrium_distance]) );
-  ASSERT( result.size() == 1,
-      "PairPotential_Harmonic::operator() - we did not create exactly one component.");
-  return result;
+  result_t result = 0.;
+  for(list_of_arguments_t::const_iterator iter = listarguments.begin();
+      iter != listarguments.end(); ++iter) {
+    const arguments_t &arguments = *iter;
+      ASSERT( arguments.size() == 1,
+          "PairPotential_Harmonic::operator() - requires exactly one argument.");
+      ASSERT( ParticleTypeChecker::checkArgumentsAgainstParticleTypes(
+          arguments, getParticleTypes()),
+          "PairPotential_Harmonic::operator() - types don't match with ones in arguments.");
+      const argument_t &r_ij = arguments[0];
+      result +=
+          2. * params[spring_constant] *
+          ( r_ij.distance - params[equilibrium_distance]);
+  }
+  return derivative_components_t(1, result);
 }
 
 PairPotential_Harmonic::results_t
 PairPotential_Harmonic::parameter_derivative(
-    const arguments_t &arguments,
+    const list_of_arguments_t &listarguments,
     const size_t index
     ) const
 {
-  ASSERT( arguments.size() == 1,
-      "PairPotential_Harmonic::parameter_derivative() - requires exactly one argument.");
-  ASSERT( ParticleTypeChecker::checkArgumentsAgainstParticleTypes(
-      arguments, getParticleTypes()),
-      "PairPotential_Harmonic::operator() - types don't match with ones in arguments.");
-  const argument_t &r_ij = arguments[0];
-  switch (index) {
-    case spring_constant:
-    {
-      const result_t result =
-                 Helpers::pow( r_ij.distance - params[equilibrium_distance], 2 );
-      return std::vector<result_t>(1, result);
-      break;
+  result_t result = 0.;
+  for(list_of_arguments_t::const_iterator iter = listarguments.begin();
+      iter != listarguments.end(); ++iter) {
+    const arguments_t &arguments = *iter;
+    ASSERT( arguments.size() == 1,
+        "PairPotential_Harmonic::parameter_derivative() - requires exactly one argument.");
+    ASSERT( ParticleTypeChecker::checkArgumentsAgainstParticleTypes(
+        arguments, getParticleTypes()),
+        "PairPotential_Harmonic::operator() - types don't match with ones in arguments.");
+    const argument_t &r_ij = arguments[0];
+    switch (index) {
+      case spring_constant:
+      {
+        result +=
+            Helpers::pow( r_ij.distance - params[equilibrium_distance], 2 );
+        break;
+      }
+      case equilibrium_distance:
+      {
+        result +=
+            -2. * params[spring_constant]
+                   * ( r_ij.distance - params[equilibrium_distance]);
+        break;
+      }
+      default:
+        ASSERT(0, "PairPotential_Harmonic::parameter_derivative() - derivative to unknown parameter desired.");
+        break;
     }
-    case equilibrium_distance:
-    {
-      const result_t result =
-          -2. * params[spring_constant]
-                 * ( r_ij.distance - params[equilibrium_distance]);
-      return std::vector<result_t>(1, result);
-      break;
-    }
-    default:
-      ASSERT(0, "PairPotential_Harmonic::parameter_derivative() - derivative to unknown parameter desired.");
-      break;
   }
-
-  return PairPotential_Harmonic::results_t(1, 0.);
+  return results_t(1, result);
 }
 

src/Potentials/Specifics/PairPotential_Harmonic.hpp

@@ -35 +35 @@
   friend class PotentialFactory;
   // some repeated typedefs to avoid ambiguities
+  typedef FunctionModel::list_of_arguments_t list_of_arguments_t;
   typedef FunctionModel::arguments_t arguments_t;
   typedef FunctionModel::result_t result_t;
@@ -90 +91 @@
   /** Evaluates the harmonic potential function for the given arguments.
    *
-   * @param arguments single distance
+   * @param listarguments list of single distances
    * @return value of the potential function
    */
-  results_t operator()(const arguments_t &arguments) const;
+  results_t operator()(const list_of_arguments_t &listarguments) const;
 
   /** Evaluates the derivative of the potential function.
    *
-   * @param arguments single distance
+   * @param listarguments list of single distances
    * @return vector with derivative with respect to the input degrees of freedom
    */
-  derivative_components_t derivative(const arguments_t &arguments) const;
+  derivative_components_t derivative(const list_of_arguments_t &listarguments) const;
 
   /** Evaluates the derivative of the function with the given \a arguments
    * with respect to a specific parameter indicated by \a index.
    *
-   * \param arguments set of arguments as input variables to the function
+   * \param listarguments list of single distances
    * \param index derivative of which parameter
    * \return result vector containing the derivative with respect to the given
    *         input
    */
-  results_t parameter_derivative(const arguments_t &arguments, const size_t index) const;
+  results_t parameter_derivative(const list_of_arguments_t &listarguments, const size_t index) const;
 
   /** Returns the functor that converts argument_s into the

src/Potentials/Specifics/PairPotential_LennardJones.cpp

@@ -123 +123 @@
 PairPotential_LennardJones::results_t
 PairPotential_LennardJones::operator()(
-    const arguments_t &arguments
+    const list_of_arguments_t &listarguments
     ) const
 {
-  ASSERT( arguments.size() == 1,
-      "PairPotential_LennardJones::operator() - requires one argument.");
-  ASSERT( ParticleTypeChecker::checkArgumentsAgainstParticleTypes(
-      arguments, getParticleTypes()),
-      "PairPotential_LennardJones::operator() - types don't match with ones in arguments.");
-  const double &r = arguments[0].distance;
-  const double temp = Helpers::pow(params[sigma]/r, 6);
-  const result_t result = 4.*params[epsilon] * (temp*temp - temp);
-  return std::vector<result_t>(1, result);
+  result_t result = 0.;
+  for(list_of_arguments_t::const_iterator iter = listarguments.begin();
+      iter != listarguments.end(); ++iter) {
+    const arguments_t &arguments = *iter;
+    ASSERT( arguments.size() == 1,
+        "PairPotential_LennardJones::operator() - requires one argument.");
+    ASSERT( ParticleTypeChecker::checkArgumentsAgainstParticleTypes(
+        arguments, getParticleTypes()),
+        "PairPotential_LennardJones::operator() - types don't match with ones in arguments.");
+    const double &r = arguments[0].distance;
+    const double temp = Helpers::pow(params[sigma]/r, 6);
+    result += 4.*params[epsilon] * (temp*temp - temp);
+  }
+  return results_t(1, result);
 }
 
 PairPotential_LennardJones::derivative_components_t
 PairPotential_LennardJones::derivative(
-    const arguments_t &arguments
+    const list_of_arguments_t &listarguments
     ) const
 {
-  ASSERT( arguments.size() == 1,
-      "PairPotential_LennardJones::operator() - requires no argument.");
-  ASSERT( ParticleTypeChecker::checkArgumentsAgainstParticleTypes(
-      arguments, getParticleTypes()),
-      "PairPotential_LennardJones::operator() - types don't match with ones in arguments.");
-  const double &r = arguments[0].distance;
   const double sigma6 = Helpers::pow(params[sigma], 6);
-  const result_t result =
-      4.*params[epsilon] * (
-          sigma6*sigma6*(-12.) / Helpers::pow(r,13)
-          - sigma6*(-6.) /Helpers::pow(r,7)
-      );
-  derivative_components_t results(1, result);
-  return results;
+  result_t result = 0.;
+  for(list_of_arguments_t::const_iterator iter = listarguments.begin();
+      iter != listarguments.end(); ++iter) {
+    const arguments_t &arguments = *iter;
+    ASSERT( arguments.size() == 1,
+        "PairPotential_LennardJones::operator() - requires no argument.");
+    ASSERT( ParticleTypeChecker::checkArgumentsAgainstParticleTypes(
+        arguments, getParticleTypes()),
+        "PairPotential_LennardJones::operator() - types don't match with ones in arguments.");
+    const double &r = arguments[0].distance;
+    result +=
+        4.*params[epsilon] * (
+            sigma6*sigma6*(-12.) / Helpers::pow(r,13)
+            - sigma6*(-6.) /Helpers::pow(r,7)
+        );
+  }
+  return derivative_components_t(1, result);
 }
 
 PairPotential_LennardJones::results_t
 PairPotential_LennardJones::parameter_derivative(
-    const arguments_t &arguments,
+    const list_of_arguments_t &listarguments,
     const size_t index
     ) const
 {
-  ASSERT( arguments.size() == 1,
-      "PairPotential_LennardJones::parameter_derivative() - requires no argument.");
-  ASSERT( ParticleTypeChecker::checkArgumentsAgainstParticleTypes(
-      arguments, getParticleTypes()),
-      "PairPotential_LennardJones::operator() - types don't match with ones in arguments.");
-  const double &r = arguments[0].distance;
-  switch (index) {
-    case epsilon:
-    {
-      const double temp = Helpers::pow(params[sigma]/r, 6);
-      const result_t result = 4. * (temp*temp - temp);
-      return std::vector<result_t>(1, result);
-      break;
+  result_t result = 0.;
+  for(list_of_arguments_t::const_iterator iter = listarguments.begin();
+      iter != listarguments.end(); ++iter) {
+    const arguments_t &arguments = *iter;
+    ASSERT( arguments.size() == 1,
+        "PairPotential_LennardJones::parameter_derivative() - requires no argument.");
+    ASSERT( ParticleTypeChecker::checkArgumentsAgainstParticleTypes(
+        arguments, getParticleTypes()),
+        "PairPotential_LennardJones::operator() - types don't match with ones in arguments.");
+    const double &r = arguments[0].distance;
+    switch (index) {
+      case epsilon:
+      {
+        const double temp = Helpers::pow(params[sigma]/r, 6);
+        result += 4. * (temp*temp - temp);
+        break;
+      }
+      case sigma:
+      {
+        const double r6 = Helpers::pow(r, 6);
+        result +=
+            4.*params[epsilon] * (
+                12. * Helpers::pow(params[sigma],11)/(r6*r6)
+                - 6. * Helpers::pow(params[sigma],5)/r6
+            );
+        break;
+      }
+      default:
+        break;
     }
-    case sigma:
-    {
-      const double r6 = Helpers::pow(r, 6);
-      const result_t result =
-          4.*params[epsilon] * (
-              12. * Helpers::pow(params[sigma],11)/(r6*r6)
-              - 6. * Helpers::pow(params[sigma],5)/r6
-          );
-      return std::vector<result_t>(1, result);
-      break;
-    }
-    default:
-      break;
   }
-  return std::vector<result_t>(1, 0.);
+  return results_t(1, result);
 }
 

src/Potentials/Specifics/PairPotential_LennardJones.hpp

@@ -36 +36 @@
   friend class PotentialFactory;
   // some repeated typedefs to avoid ambiguities
+  typedef FunctionModel::list_of_arguments_t list_of_arguments_t;
   typedef FunctionModel::arguments_t arguments_t;
   typedef FunctionModel::result_t result_t;
@@ -92 +93 @@
   /** Evaluates the harmonic potential function for the given arguments.
    *
-   * @param arguments single distance
+   * @param listarguments list of single distances
    * @return value of the potential function
    */
-  results_t operator()(const arguments_t &arguments) const;
+  results_t operator()(const list_of_arguments_t &listarguments) const;
 
   /** Evaluates the derivative of the potential function.
    *
-   * @param arguments single distance
+   * @param listarguments list of single distances
    * @return vector with derivative with respect to the input degrees of freedom
    */
-  derivative_components_t derivative(const arguments_t &arguments) const;
+  derivative_components_t derivative(const list_of_arguments_t &listarguments) const;
 
   /** Evaluates the derivative of the function with the given \a arguments
    * with respect to a specific parameter indicated by \a index.
    *
-   * \param arguments set of arguments as input variables to the function
+   * \param listarguments list of single distances
    * \param index derivative of which parameter
    * \return result vector containing the derivative with respect to the given
    *         input
    */
-  results_t parameter_derivative(const arguments_t &arguments, const size_t index) const;
+  results_t parameter_derivative(const list_of_arguments_t &listarguments, const size_t index) const;
 
   /** Returns the functor that converts argument_s into the

src/Potentials/Specifics/PairPotential_Morse.cpp

@@ -124 +124 @@
 PairPotential_Morse::results_t
 PairPotential_Morse::operator()(
-    const arguments_t &arguments
+    const list_of_arguments_t &listarguments
     ) const
 {
-  ASSERT( arguments.size() == 1,
-      "PairPotential_Morse::operator() - requires exactly one argument.");
-  ASSERT( ParticleTypeChecker::checkArgumentsAgainstParticleTypes(
-      arguments, getParticleTypes()),
-      "PairPotential_Morse::operator() - types don't match with ones in arguments.");
-  const argument_t &r_ij = arguments[0];
-  // Maple: f(r,D,k,R,c) := D * (1 - exp(-k*(r-R)))^(2)+c
-  const result_t result =
-      params[dissociation_energy] * Helpers::pow( 1.
-          - exp( - params[spring_constant] * ( r_ij.distance - params[equilibrium_distance])),2);
+  result_t result = 0.;
+  for(list_of_arguments_t::const_iterator iter = listarguments.begin();
+      iter != listarguments.end(); ++iter) {
+    const arguments_t &arguments = *iter;
+    ASSERT( arguments.size() == 1,
+        "PairPotential_Morse::operator() - requires exactly one argument.");
+    ASSERT( ParticleTypeChecker::checkArgumentsAgainstParticleTypes(
+        arguments, getParticleTypes()),
+        "PairPotential_Morse::operator() - types don't match with ones in arguments.");
+    const argument_t &r_ij = arguments[0];
+    // Maple: f(r,D,k,R,c) := D * (1 - exp(-k*(r-R)))^(2)+c
+    result +=
+        params[dissociation_energy] * Helpers::pow( 1.
+            - exp( - params[spring_constant] * ( r_ij.distance - params[equilibrium_distance])),2);
+  }
   return std::vector<result_t>(1, result);
 }
@@ -142 +147 @@
 PairPotential_Morse::derivative_components_t
 PairPotential_Morse::derivative(
-    const arguments_t &arguments
+    const list_of_arguments_t &listarguments
     ) const
 {
-  ASSERT( arguments.size() == 1,
-      "PairPotential_Morse::operator() - requires exactly one argument.");
-  ASSERT( ParticleTypeChecker::checkArgumentsAgainstParticleTypes(
-      arguments, getParticleTypes()),
-      "PairPotential_Morse::operator() - types don't match with ones in arguments.");
-  derivative_components_t result;
-  const argument_t &r_ij = arguments[0];
-  // Maple result: 2*D*(1-exp(-k*(r-R)))*k*exp(-k*(r-R))
-  result.push_back(
-      2. * params[dissociation_energy]
-      * ( 1. - exp( - params[spring_constant] * ( r_ij.distance - params[equilibrium_distance])))
-      * (- params[spring_constant]) * exp( - params[spring_constant] * ( r_ij.distance - params[equilibrium_distance]))
-  );
-  ASSERT( result.size() == 1,
-      "PairPotential_Morse::operator() - we did not create exactly one component.");
-  return result;
+  result_t result = 0.;
+  for(list_of_arguments_t::const_iterator iter = listarguments.begin();
+      iter != listarguments.end(); ++iter) {
+    const arguments_t &arguments = *iter;
+    ASSERT( arguments.size() == 1,
+        "PairPotential_Morse::operator() - requires exactly one argument.");
+    ASSERT( ParticleTypeChecker::checkArgumentsAgainstParticleTypes(
+        arguments, getParticleTypes()),
+        "PairPotential_Morse::operator() - types don't match with ones in arguments.");
+    const argument_t &r_ij = arguments[0];
+    // Maple result: 2*D*(1-exp(-k*(r-R)))*k*exp(-k*(r-R))
+    result +=
+        2. * params[dissociation_energy]
+        * ( 1. - exp( - params[spring_constant] * ( r_ij.distance - params[equilibrium_distance])))
+        * (- params[spring_constant]) * exp( - params[spring_constant] * ( r_ij.distance - params[equilibrium_distance]));
+  }
+  return derivative_components_t(1, result);
 }
 
 PairPotential_Morse::results_t
 PairPotential_Morse::parameter_derivative(
-    const arguments_t &arguments,
+    const list_of_arguments_t &listarguments,
     const size_t index
     ) const
 {
-  ASSERT( arguments.size() == 1,
-      "PairPotential_Morse::parameter_derivative() - requires exactly one argument.");
-  ASSERT( ParticleTypeChecker::checkArgumentsAgainstParticleTypes(
-      arguments, getParticleTypes()),
-      "PairPotential_Morse::operator() - types don't match with ones in arguments.");
-  const argument_t &r_ij = arguments[0];
-  switch (index) {
-    case spring_constant:
-    {
-      // Maple result: -2*D*(1-exp(-k*(r-R)))*(-r+R)*exp(-k*(r-R))
-      const result_t result =
-          - 2. * params[dissociation_energy]
-          * ( 1. - exp( - params[spring_constant] * ( r_ij.distance - params[equilibrium_distance])))
-          * (- r_ij.distance + params[equilibrium_distance])
-          * exp( - params[spring_constant] * ( r_ij.distance - params[equilibrium_distance]))
-          ;
-      return std::vector<result_t>(1, result);
-      break;
+  result_t result = 0.;
+  for(list_of_arguments_t::const_iterator iter = listarguments.begin();
+      iter != listarguments.end(); ++iter) {
+    const arguments_t &arguments = *iter;
+    ASSERT( arguments.size() == 1,
+        "PairPotential_Morse::parameter_derivative() - requires exactly one argument.");
+    ASSERT( ParticleTypeChecker::checkArgumentsAgainstParticleTypes(
+        arguments, getParticleTypes()),
+        "PairPotential_Morse::operator() - types don't match with ones in arguments.");
+    const argument_t &r_ij = arguments[0];
+    switch (index) {
+      case spring_constant:
+      {
+        // Maple result: -2*D*(1-exp(-k*(r-R)))*(-r+R)*exp(-k*(r-R))
+        result +=
+            - 2. * params[dissociation_energy]
+            * ( 1. - exp( - params[spring_constant] * ( r_ij.distance - params[equilibrium_distance])))
+            * (- r_ij.distance + params[equilibrium_distance])
+            * exp( - params[spring_constant] * ( r_ij.distance - params[equilibrium_distance]))
+            ;
+        break;
+      }
+      case equilibrium_distance:
+      {
+        // Maple result: -2*D*(1-exp(-k*(r-R)))*k*exp(-k*(r-R))
+        result +=
+            - 2. * params[dissociation_energy]
+            * ( 1. - exp( - params[spring_constant] * ( r_ij.distance - params[equilibrium_distance])))
+            * params[spring_constant] * exp( - params[spring_constant] * ( r_ij.distance - params[equilibrium_distance]))
+            ;
+        break;
+      }
+      case dissociation_energy:
+      {
+        // Maple result: (1-exp(-k*(r-R)))^2
+        result +=
+            Helpers::pow(1.
+                - exp( - params[spring_constant] * ( r_ij.distance - params[equilibrium_distance])),2);
+        break;
+      }
+      default:
+        ASSERT(0, "PairPotential_Morse::parameter_derivative() - derivative to unknown parameter desired.");
+        break;
     }
-    case equilibrium_distance:
-    {
-      // Maple result: -2*D*(1-exp(-k*(r-R)))*k*exp(-k*(r-R))
-      const result_t result =
-          - 2. * params[dissociation_energy]
-          * ( 1. - exp( - params[spring_constant] * ( r_ij.distance - params[equilibrium_distance])))
-          * params[spring_constant] * exp( - params[spring_constant] * ( r_ij.distance - params[equilibrium_distance]))
-          ;
-      return std::vector<result_t>(1, result);
-      break;
-    }
-    case dissociation_energy:
-    {
-      // Maple result: (1-exp(-k*(r-R)))^2
-      const result_t result =
-          Helpers::pow(1.
-              - exp( - params[spring_constant] * ( r_ij.distance - params[equilibrium_distance])),2);
-      return std::vector<result_t>(1, result);
-      break;
-    }
-    default:
-      ASSERT(0, "PairPotential_Morse::parameter_derivative() - derivative to unknown parameter desired.");
-      break;
   }
-  return std::vector<result_t>(1, 0.);
+  return results_t(1, result);
 }
 

src/Potentials/Specifics/PairPotential_Morse.hpp

@@ -35 +35 @@
   friend class PotentialFactory;
   // some repeated typedefs to avoid ambiguities
+  typedef FunctionModel::list_of_arguments_t list_of_arguments_t;
   typedef FunctionModel::arguments_t arguments_t;
   typedef FunctionModel::result_t result_t;
@@ -91 +92 @@
   /** Evaluates the harmonic potential function for the given arguments.
    *
-   * @param arguments single distance
+   * @param listarguments list of single distances
    * @return value of the potential function
    */
-  results_t operator()(const arguments_t &arguments) const;
+  results_t operator()(const list_of_arguments_t &listarguments) const;
 
   /** Evaluates the derivative of the potential function.
    *
-   * @param arguments single distance
+   * @param listarguments list of single distances
    * @return vector with derivative with respect to the input degrees of freedom
    */
-  derivative_components_t derivative(const arguments_t &arguments) const;
+  derivative_components_t derivative(const list_of_arguments_t &listarguments) const;
 
   /** Evaluates the derivative of the function with the given \a arguments
    * with respect to a specific parameter indicated by \a index.
    *
-   * \param arguments set of arguments as input variables to the function
+   * \param listarguments list of single distances
    * \param index derivative of which parameter
    * \return result vector containing the derivative with respect to the given
    *         input
    */
-  results_t parameter_derivative(const arguments_t &arguments, const size_t index) const;
+  results_t parameter_derivative(const list_of_arguments_t &listarguments, const size_t index) const;
 
   /** Returns the functor that converts argument_s into the

src/Potentials/Specifics/ThreeBodyPotential_Angle.cpp

@@ -136 +136 @@
 ThreeBodyPotential_Angle::results_t
 ThreeBodyPotential_Angle::operator()(
-    const arguments_t &arguments
+    const list_of_arguments_t &listarguments
     ) const
 {
-  ASSERT( arguments.size() == 3,
-      "ThreeBodyPotential_Angle::operator() - requires exactly three arguments.");
-  ASSERT( ParticleTypeChecker::checkArgumentsAgainstParticleTypes(
-      arguments, getParticleTypes()),
-      "ThreeBodyPotential_Angle::operator() - types don't match with ones in arguments.");
-  const argument_t &r_ij = arguments[0]; // 01
-  const argument_t &r_jk = arguments[2]; // 12
-  const argument_t &r_ik = arguments[1]; // 02
-  const result_t result =
-      params[spring_constant]
-             * Helpers::pow( function_theta(r_ij.distance, r_jk.distance, r_ik.distance) - params[equilibrium_distance], 2 );
-  return std::vector<result_t>(1, result);
+  result_t result = 0.;
+  for(list_of_arguments_t::const_iterator iter = listarguments.begin();
+      iter != listarguments.end(); ++iter) {
+    const arguments_t &arguments = *iter;
+    ASSERT( arguments.size() == 3,
+        "ThreeBodyPotential_Angle::operator() - requires exactly three arguments.");
+    ASSERT( ParticleTypeChecker::checkArgumentsAgainstParticleTypes(
+        arguments, getParticleTypes()),
+        "ThreeBodyPotential_Angle::operator() - types don't match with ones in arguments.");
+    const argument_t &r_ij = arguments[0]; // 01
+    const argument_t &r_jk = arguments[2]; // 12
+    const argument_t &r_ik = arguments[1]; // 02
+    result +=
+        params[spring_constant]
+               * Helpers::pow( function_theta(r_ij.distance, r_jk.distance, r_ik.distance)
+                   - params[equilibrium_distance], 2 );
+  }
+  return results_t(1, result);
 }
 
 ThreeBodyPotential_Angle::derivative_components_t
 ThreeBodyPotential_Angle::derivative(
-    const arguments_t &arguments
+    const list_of_arguments_t &listarguments
     ) const
 {
-  ASSERT( arguments.size() == 3,
-      "ThreeBodyPotential_Angle::operator() - requires exactly three arguments.");
-  ASSERT( ParticleTypeChecker::checkArgumentsAgainstParticleTypes(
-      arguments, getParticleTypes()),
-      "ThreeBodyPotential_Angle::operator() - types don't match with ones in arguments.");
-  derivative_components_t result;
-  const argument_t &r_ij = arguments[0]; //01
-  const argument_t &r_jk = arguments[2]; //12
-  const argument_t &r_ik = arguments[1]; //02
-  result.push_back( 2. * params[spring_constant] * ( function_theta(r_ij.distance, r_jk.distance, r_ik.distance) - params[equilibrium_distance]) );
-  ASSERT( result.size() == 1,
-      "ThreeBodyPotential_Angle::operator() - we did not create exactly one component.");
-  return result;
+  result_t result = 0.;
+  for(list_of_arguments_t::const_iterator iter = listarguments.begin();
+      iter != listarguments.end(); ++iter) {
+    const arguments_t &arguments = *iter;
+    ASSERT( arguments.size() == 3,
+        "ThreeBodyPotential_Angle::operator() - requires exactly three arguments.");
+    ASSERT( ParticleTypeChecker::checkArgumentsAgainstParticleTypes(
+        arguments, getParticleTypes()),
+        "ThreeBodyPotential_Angle::operator() - types don't match with ones in arguments.");
+    const argument_t &r_ij = arguments[0]; //01
+    const argument_t &r_jk = arguments[2]; //12
+    const argument_t &r_ik = arguments[1]; //02
+    result +=
+        2. * params[spring_constant] *
+        ( function_theta(r_ij.distance, r_jk.distance, r_ik.distance)
+            - params[equilibrium_distance]);
+  }
+  return derivative_components_t(1, result);
 }
 
 ThreeBodyPotential_Angle::results_t
 ThreeBodyPotential_Angle::parameter_derivative(
-    const arguments_t &arguments,
+    const list_of_arguments_t &listarguments,
     const size_t index
     ) const
 {
-  ASSERT( arguments.size() == 3,
-      "ThreeBodyPotential_Angle::parameter_derivative() - requires exactly three arguments.");
-  ASSERT( ParticleTypeChecker::checkArgumentsAgainstParticleTypes(
-      arguments, getParticleTypes()),
-      "ThreeBodyPotential_Angle::operator() - types don't match with ones in arguments.");
-  const argument_t &r_ij = arguments[0]; //01
-  const argument_t &r_jk = arguments[2]; //12
-  const argument_t &r_ik = arguments[1]; //02
-  switch (index) {
-    case spring_constant:
-    {
-      const result_t result =
-                 Helpers::pow( function_theta(r_ij.distance, r_jk.distance, r_ik.distance) - params[equilibrium_distance], 2 );
-      return std::vector<result_t>(1, result);
-      break;
+  result_t result = 0.;
+  for(list_of_arguments_t::const_iterator iter = listarguments.begin();
+      iter != listarguments.end(); ++iter) {
+    const arguments_t &arguments = *iter;
+    ASSERT( arguments.size() == 3,
+        "ThreeBodyPotential_Angle::parameter_derivative() - requires exactly three arguments.");
+    ASSERT( ParticleTypeChecker::checkArgumentsAgainstParticleTypes(
+        arguments, getParticleTypes()),
+        "ThreeBodyPotential_Angle::operator() - types don't match with ones in arguments.");
+    const argument_t &r_ij = arguments[0]; //01
+    const argument_t &r_jk = arguments[2]; //12
+    const argument_t &r_ik = arguments[1]; //02
+    switch (index) {
+      case spring_constant:
+      {
+        result +=
+            Helpers::pow( function_theta(r_ij.distance, r_jk.distance, r_ik.distance) - params[equilibrium_distance], 2 );
+        break;
+      }
+      case equilibrium_distance:
+      {
+        result +=
+            -2. * params[spring_constant]
+                   * ( function_theta(r_ij.distance, r_jk.distance, r_ik.distance) - params[equilibrium_distance]);
+        break;
+      }
+      default:
+        ASSERT(0, "ThreeBodyPotential_Angle::parameter_derivative() - derivative to unknown parameter desired.");
+        break;
     }
-    case equilibrium_distance:
-    {
-      const result_t result =
-          -2. * params[spring_constant]
-                 * ( function_theta(r_ij.distance, r_jk.distance, r_ik.distance) - params[equilibrium_distance]);
-      return std::vector<result_t>(1, result);
-      break;
-    }
-    default:
-      ASSERT(0, "ThreeBodyPotential_Angle::parameter_derivative() - derivative to unknown parameter desired.");
-      break;
   }
-  return std::vector<result_t>(1);
+  return results_t(1, result);
 }
 

src/Potentials/Specifics/ThreeBodyPotential_Angle.hpp

@@ -35 +35 @@
   friend class PotentialFactory;
   // some repeated typedefs to avoid ambiguities
+  typedef FunctionModel::list_of_arguments_t list_of_arguments_t;
   typedef FunctionModel::arguments_t arguments_t;
   typedef FunctionModel::result_t result_t;
@@ -90 +91 @@
   /** Evaluates the harmonic potential function for the given arguments.
    *
-   * @param arguments single distance
+   * @param listarguments list of three distances
    * @return value of the potential function
    */
-  results_t operator()(const arguments_t &arguments) const;
+  results_t operator()(const list_of_arguments_t &listarguments) const;
 
   /** Evaluates the derivative of the potential function.
    *
-   * @param arguments single distance
+   * @param listarguments list of three distances
    * @return vector with derivative with respect to the input degrees of freedom
    */
-  derivative_components_t derivative(const arguments_t &arguments) const;
+  derivative_components_t derivative(const list_of_arguments_t &listarguments) const;
 
   /** Evaluates the derivative of the function with the given \a arguments
    * with respect to a specific parameter indicated by \a index.
    *
-   * \param arguments set of arguments as input variables to the function
+   * \param listarguments list of three distances
    * \param index derivative of which parameter
    * \return result vector containing the derivative with respect to the given
    *         input
    */
-  results_t parameter_derivative(const arguments_t &arguments, const size_t index) const;
+  results_t parameter_derivative(const list_of_arguments_t &listarguments, const size_t index) const;
 
   /** Returns the functor that converts argument_s into the

src/Potentials/Specifics/unittests/ConstantPotentialUnitTest.cpp

@@ -82 +82 @@
       Helpers::isEqual(
           offset,
-          constant( FunctionModel::arguments_t() )[0]
+          constant( FunctionModel::list_of_arguments_t() )[0]
       )
   );
@@ -97 +97 @@
           0.,
           constant.derivative(
-              FunctionModel::arguments_t()
+              FunctionModel::list_of_arguments_t()
           )[0]
       )
@@ -114 +114 @@
           1.,
           constant.parameter_derivative(
-              FunctionModel::arguments_t(),
+              FunctionModel::list_of_arguments_t(),
               0
           )[0]

src/Potentials/Specifics/unittests/FourBodyPotential_ImproperUnitTest.cpp

@@ -121 +121 @@
   for (size_t index = 0; index < input.size(); ++index) {
     const FourBodyPotential_Improper::results_t result =
-        angle( input[index] );
+        angle( FunctionModel::list_of_arguments_t(1, input[index]) );
     CPPUNIT_ASSERT(
         Helpers::isEqual(
@@ -144 +144 @@
           0.,
           angle.derivative(
-              input[5]
+              FunctionModel::list_of_arguments_t(1, input[5])
           )[0],
           10.
@@ -165 +165 @@
           0.,
           angle.parameter_derivative(
-              input[5],
+              FunctionModel::list_of_arguments_t(1, input[5]),
               0
           )[0],
@@ -175 +175 @@
           0.,
           angle.parameter_derivative(
-              input[5],
+              FunctionModel::list_of_arguments_t(1, input[5]),
               1
           )[0],

src/Potentials/Specifics/unittests/FourBodyPotential_TorsionUnitTest.cpp

@@ -121 +121 @@
   for (size_t index = 0; index < input.size(); ++index) {
     const FourBodyPotential_Torsion::results_t result =
-        angle( input[index] );
+        angle( FunctionModel::list_of_arguments_t(1, input[index]) );
     CPPUNIT_ASSERT(
         Helpers::isEqual(
@@ -144 +144 @@
           0.,
           angle.derivative(
-              input[5]
+              FunctionModel::list_of_arguments_t(1, input[5])
           )[0],
           10.
@@ -165 +165 @@
           0.,
           angle.parameter_derivative(
-              input[5],
+              FunctionModel::list_of_arguments_t(1, input[5]),
               0
           )[0],
@@ -175 +175 @@
           0.,
           angle.parameter_derivative(
-              input[5],
+              FunctionModel::list_of_arguments_t(1, input[5]),
               1
           )[0],

src/Potentials/Specifics/unittests/ManyBodyPotential_TersoffUnitTest.cpp

@@ -299 +299 @@
         arg.globalid = index; // this is needed for the triplefunction to the configuration
         FunctionModel::arguments_t args(1,arg);
-        const ManyBodyPotential_Tersoff::results_t res = tersoff(args);
+        const ManyBodyPotential_Tersoff::results_t res =
+            tersoff( FunctionModel::list_of_arguments_t(1, args) );
         temp += res[0];
       }
@@ -336 +337 @@
 //          0.,
 //          tersoff.derivative(
-//              FunctionModel::arguments_t(1,argument_t(1.))
+//              FunctionModel::list_of_arguments_t(1, FunctionModel::arguments_t(1,argument_t(1.)))
 //          )[0]
 //      )
@@ -361 +362 @@
 //          0.,
 //          tersoff.parameter_derivative(
-//              FunctionModel::arguments_t(1,argument_t(1.)),
+//              FunctionModel::list_of_arguments_t(1, FunctionModel::arguments_t(1,argument_t(1.))),
 //              0
 //          )[0]
@@ -370 +371 @@
 //          0.,
 //          tersoff.parameter_derivative(
-//              FunctionModel::arguments_t(1,argument_t(1.)),
+//              FunctionModel::list_of_arguments_t(1, FunctionModel::arguments_t(1,argument_t(1.))),
 //              1
 //          )[0]
@@ -379 +380 @@
 //          1.,
 //          tersoff.parameter_derivative(
-//              FunctionModel::arguments_t(1,argument_t(1.)),
+//              FunctionModel::list_of_arguments_t(1, FunctionModel::arguments_t(1,argument_t(1.))),
 //              2
 //          )[0]

src/Potentials/Specifics/unittests/PairPotential_HarmonicUnitTest.cpp

@@ -102 +102 @@
         Helpers::isEqual(
             output[index],
-            harmonic( FunctionModel::arguments_t(1,arg) )[0]
+            harmonic( FunctionModel::list_of_arguments_t(1, FunctionModel::arguments_t(1,arg)) )[0]
         )
     );
@@ -122 +122 @@
           0.,
           harmonic.derivative(
-              FunctionModel::arguments_t(1,arg)
+              FunctionModel::list_of_arguments_t(1, FunctionModel::arguments_t(1,arg))
           )[0]
       )
@@ -143 +143 @@
           0.,
           harmonic.parameter_derivative(
-              FunctionModel::arguments_t(1,arg),
+              FunctionModel::list_of_arguments_t(1, FunctionModel::arguments_t(1,arg)),
               0
           )[0]
@@ -152 +152 @@
           0.,
           harmonic.parameter_derivative(
-              FunctionModel::arguments_t(1,arg),
+              FunctionModel::list_of_arguments_t(1, FunctionModel::arguments_t(1,arg)),
               1
           )[0]

src/Potentials/Specifics/unittests/PairPotential_LennardJonesUnitTest.cpp

@@ -118 +118 @@
         Helpers::isEqual(
             output[index],
-            lj( FunctionModel::arguments_t(1,arg) )[0],
+            lj( FunctionModel::list_of_arguments_t(1, FunctionModel::arguments_t(1,arg)) )[0],
             1.e-4/std::numeric_limits<double>::epsilon() // only compare four digits
         )
@@ -140 +140 @@
           0.,
           lj.derivative(
-              FunctionModel::arguments_t(1,arg)
+              FunctionModel::list_of_arguments_t(1, FunctionModel::arguments_t(1,arg))
           )[0],
           1.e+6
@@ -162 +162 @@
           -1.,
           lj.parameter_derivative(
-              FunctionModel::arguments_t(1,arg),
+              FunctionModel::list_of_arguments_t(1, FunctionModel::arguments_t(1,arg)),
               0
           )[0],
@@ -172 +172 @@
           0.,
           lj.parameter_derivative(
-              FunctionModel::arguments_t(1,arg),
+              FunctionModel::list_of_arguments_t(1, FunctionModel::arguments_t(1,arg)),
               1
           )[0],

src/Potentials/Specifics/unittests/PairPotential_MorseUnitTest.cpp

@@ -120 +120 @@
         Helpers::isEqual(
             output[index],
-            Morse( FunctionModel::arguments_t(1,arg) )[0],
+            Morse( FunctionModel::list_of_arguments_t(1, FunctionModel::arguments_t(1,arg)) )[0],
             1.e-4/std::numeric_limits<double>::epsilon() // only compare four digits
         )
@@ -141 +141 @@
           0.,
           Morse.derivative(
-              FunctionModel::arguments_t(1,arg)
+              FunctionModel::list_of_arguments_t(1, FunctionModel::arguments_t(1,arg))
           )[0],
           1.e+6
@@ -163 +163 @@
           0.,
           Morse.parameter_derivative(
-              FunctionModel::arguments_t(1,arg),
+              FunctionModel::list_of_arguments_t(1, FunctionModel::arguments_t(1,arg)),
               0
           )[0],
@@ -173 +173 @@
           0.,
           Morse.parameter_derivative(
-              FunctionModel::arguments_t(1,arg),
+              FunctionModel::list_of_arguments_t(1, FunctionModel::arguments_t(1,arg)),
               1
           )[0],
@@ -183 +183 @@
           0.,
           Morse.parameter_derivative(
-              FunctionModel::arguments_t(1,arg),
+              FunctionModel::list_of_arguments_t(1, FunctionModel::arguments_t(1,arg)),
               2
           )[0],

src/Potentials/Specifics/unittests/ThreeBodyPotential_AngleUnitTest.cpp

@@ -112 +112 @@
   for (size_t index = 0; index < input.size(); ++index) {
     const ThreeBodyPotential_Angle::results_t result =
-        angle( input[index] );
+        angle( FunctionModel::list_of_arguments_t(1, input[index]) );
     CPPUNIT_ASSERT(
         Helpers::isEqual(
@@ -135 +135 @@
           0.,
           angle.derivative(
-              input[5]
+              FunctionModel::list_of_arguments_t(1, input[5])
           )[0],
           10.
@@ -156 +156 @@
           0.,
           angle.parameter_derivative(
-              input[5],
+              FunctionModel::list_of_arguments_t(1, input[5]),
               0
           )[0],
@@ -166 +166 @@
           0.,
           angle.parameter_derivative(
-              input[5],
+              FunctionModel::list_of_arguments_t(1, input[5]),
               1
           )[0],

src/Potentials/helpers.hpp

@@ -108 +108 @@
   }
 
+  inline FunctionModel::list_of_arguments_t
+  returnEmptyListArguments()
+  {
+    return FunctionModel::list_of_arguments_t();
+  }
+
 }; /* namespace Helpers */
 

src/Potentials/unittests/CompoundPotentialUnitTest.cpp

@@ -159 +159 @@
     argument_t firstarg(argument_t::indices_t(0,1), argument_t::types_t(0,1), input[index]);
     argument_t secondarg(argument_t::indices_t(0,2), argument_t::types_t(0,1), input[index]);
-    FunctionModel::arguments_t args;
-    args += firstarg,secondarg;
-    const double result = compound( args )[0];
+    FunctionModel::list_of_arguments_t listargs;
+    listargs += FunctionModel::arguments_t(1,firstarg),FunctionModel::arguments_t(1,secondarg);
+    const double result = compound( listargs )[0];
     CPPUNIT_ASSERT(
         Helpers::isEqual(
@@ -205 +205 @@
   argument_t firstarg(argument_t::indices_t(0,1), argument_t::types_t(0,1), c);
   argument_t secondarg(argument_t::indices_t(0,2), argument_t::types_t(0,1), c);
-  FunctionModel::arguments_t args;
-  args += firstarg,secondarg;
-  {
-    const double result =
-        compound.parameter_derivative(
-            args,
+  FunctionModel::list_of_arguments_t listargs;
+  listargs += FunctionModel::arguments_t(1,firstarg),FunctionModel::arguments_t(1,secondarg);
+  {
+    const double result =
+        compound.parameter_derivative(
+            listargs,
             0)[0];
     CPPUNIT_ASSERT(
@@ -223 +223 @@
     const double result =
         compound.parameter_derivative(
-            args,
+            listargs,
             1)[0];
     CPPUNIT_ASSERT(
@@ -236 +236 @@
     const double result =
         compound.parameter_derivative(
-            args,
+            listargs,
             2)[0];
     CPPUNIT_ASSERT(
@@ -249 +249 @@
     const double result =
         compound.parameter_derivative(
-            args,
+            listargs,
             3)[0];
     CPPUNIT_ASSERT(

src/UIElements/Views/Qt4/QtHomologyList.cpp

@@ -184 +184 @@
     if (!data.getTrainingInputs().empty()) {
       // generate QSeisData
-      const TrainingData::InputVector_t &inputs = data.getTrainingInputs();
+      const TrainingData::InputVector_t &inputs = data.getAllArguments();
       const TrainingData::OutputVector_t &outputs = data.getTrainingOutputs();
       std::vector<double> xvalues;