Index: src/Potentials/Specifics/ManyBodyPotential_Tersoff.cpp
===================================================================
--- src/Potentials/Specifics/ManyBodyPotential_Tersoff.cpp	(revision 76cbd082753cf16eee92e72dd98df9644cb2bd3f)
+++ src/Potentials/Specifics/ManyBodyPotential_Tersoff.cpp	(revision e7579ed03a2594b79fb214806a5efc0a927b5480)
@@ -46,4 +46,44 @@
 #include "Potentials/helpers.hpp"
 
+ManyBodyPotential_Tersoff::ManyBodyPotential_Tersoff(
+    boost::function< std::vector<arguments_t>(const argument_t &, const double)> &_triplefunction
+    ) :
+    params(parameters_t(MAXPARAMS, 0.)),
+    triplefunction(_triplefunction)
+{}
+
+ManyBodyPotential_Tersoff::ManyBodyPotential_Tersoff(
+    const double &_cutoff_offset,
+    const double &_cutoff_halfwidth,
+    const double &_A,
+    const double &_B,
+    const double &_lambda1,
+    const double &_lambda2,
+    const double &_lambda3,
+    const double &_alpha,
+    const double &_beta,
+    const double &_n,
+    const double &_c,
+    const double &_d,
+    const double &_h,
+    boost::function< std::vector<arguments_t>(const argument_t &, const double)> &_triplefunction) :
+  params(parameters_t(MAXPARAMS, 0.)),
+  triplefunction(_triplefunction)
+{
+  params[cutoff_offset] = _cutoff_offset;
+  params[cutoff_halfwidth] = _cutoff_halfwidth;
+  params[A] = _A;
+  params[B] = _B;
+  params[lambda1] = _lambda1;
+  params[lambda2] = _lambda2;
+  params[lambda3] = _lambda3;
+  params[alpha] = _alpha;
+  params[beta] = _beta;
+  params[n] = _n;
+  params[c] = _c;
+  params[d] = _d;
+  params[h] = _h;
+}
+
 ManyBodyPotential_Tersoff::results_t
 ManyBodyPotential_Tersoff::operator()(
@@ -55,5 +95,5 @@
   const double result = (cutoff == 0.) ? 0. : cutoff * (
       function_prefactor(
-          manybodyparameter_alpha,
+          alpha,
           boost::bind(&ManyBodyPotential_Tersoff::function_eta,
               boost::cref(*this),
@@ -61,9 +101,9 @@
       * function_smoother(
           distance,
-          manybodyparameter_A,
-          manybodyparameter_lambda1)
+          A,
+          lambda1)
       +
       function_prefactor(
-          manybodyparameter_beta,
+          beta,
           boost::bind(&ManyBodyPotential_Tersoff::function_zeta,
               boost::cref(*this),
@@ -71,6 +111,6 @@
       * function_smoother(
           distance,
-          -manybodyparameter_B,
-          manybodyparameter_lambda2)
+          -B,
+          lambda2)
   );
   return std::vector<result_t>(1, result);
@@ -99,6 +139,6 @@
 {
   return pow(
-      (1. + Helpers::pow(alpha * etafunction(), manybodyparameter_n)),
-      -1./(2.*manybodyparameter_n));
+      (1. + Helpers::pow(alpha * etafunction(), n)),
+      -1./(2.*n));
 }
 
@@ -118,5 +158,5 @@
     const argument_t &r_ik = (*iter)[0];
     result += function_cutoff(r_ik.distance)
-        * exp( Helpers::pow(manybodyparameter_lambda3 * (r_ij.distance - r_ik.distance) ,3));
+        * exp( Helpers::pow(lambda3 * (r_ij.distance - r_ik.distance) ,3));
   }
 
@@ -142,5 +182,5 @@
         function_cutoff(r_ik.distance)
         * function_angle(r_ij.distance, r_ik.distance, r_jk.distance)
-        * exp( Helpers::pow(manybodyparameter_lambda3 * (r_ij.distance - r_ik.distance) ,3));
+        * exp( Helpers::pow(lambda3 * (r_ij.distance - r_ik.distance) ,3));
   }
 
@@ -159,7 +199,7 @@
   const double result =
       1.
-      + (Helpers::pow(manybodyparameter_c, 2)/Helpers::pow(manybodyparameter_d, 2))
-      - Helpers::pow(manybodyparameter_c, 2)/(Helpers::pow(manybodyparameter_d, 2) +
-          Helpers::pow(manybodyparameter_h - cos(angle/divisor),2));
+      + (Helpers::pow(c, 2)/Helpers::pow(d, 2))
+      - Helpers::pow(c, 2)/(Helpers::pow(d, 2) +
+          Helpers::pow(h - cos(angle/divisor),2));
   return result;
 }
Index: src/Potentials/Specifics/ManyBodyPotential_Tersoff.hpp
===================================================================
--- src/Potentials/Specifics/ManyBodyPotential_Tersoff.hpp	(revision 76cbd082753cf16eee92e72dd98df9644cb2bd3f)
+++ src/Potentials/Specifics/ManyBodyPotential_Tersoff.hpp	(revision e7579ed03a2594b79fb214806a5efc0a927b5480)
@@ -19,4 +19,6 @@
 #include "Potentials/EmpiricalPotential.hpp"
 #include "FunctionApproximation/FunctionModel.hpp"
+
+#include "CodePatterns/Assert.hpp"
 
 /** This class is the implementation of the Tersoff potential function.
@@ -34,31 +36,5 @@
   typedef FunctionModel::results_t results_t;
   typedef EmpiricalPotential::derivative_components_t derivative_components_t;
-private:
-  //!> cutoff_offset offset for cutoff parameter
-  const double cutoff_offset;
-  //!> cutoff_halfwidth half-width for cutoff parameter
-  const double cutoff_halfwidth;
-  //!> many body prefactor parameter for attractive part
-  const double manybodyparameter_A;
-  //!> many body prefactor parameter for attractive part
-  const double manybodyparameter_B;
-  //!> many body scale parameter for attractive part
-  const double manybodyparameter_lambda1;
-  //!> many body scale parameter for attractive part
-  const double manybodyparameter_lambda2;
-  //!> length scale for coordination influence
-  const double manybodyparameter_lambda3;
-  //!> many body parameter for attractive part
-  const double manybodyparameter_alpha;
-  //!> many body parameter for repulsive part
-  const double manybodyparameter_beta;
-  //!> many body type-dependent parameter giving the power
-  const double manybodyparameter_n;
-  //!> many-body type-dependent parameter in angular dependence
-  const double manybodyparameter_c;
-  //!> many-body type-dependent parameter in angular dependence
-  const double manybodyparameter_d;
-  //!> many-body type-dependent parameter in angular dependence
-  const double manybodyparameter_h;
+  typedef FunctionModel::parameters_t parameters_t;
 public:
   /** Constructor for class ManyBodyPotential_Tersoff.
@@ -69,33 +45,42 @@
    */
   ManyBodyPotential_Tersoff(
-      const double _cutoff_offset,
-      const double _cutoff_halfwidth,
-      const double A,
-      const double B,
-      const double lambda1,
-      const double lambda2,
-      const double lambda3,
-      const double alpha,
-      const double beta,
-      const double n,
-      const double c,
-      const double d,
-      const double h,
-      boost::function< std::vector<arguments_t>(const argument_t &, const double)> &_triplefunction) :
-    cutoff_offset(_cutoff_offset),
-    cutoff_halfwidth(_cutoff_offset),
-    manybodyparameter_A(A),
-    manybodyparameter_B(B),
-    manybodyparameter_lambda1(lambda1),
-    manybodyparameter_lambda2(lambda2),
-    manybodyparameter_lambda3(lambda3),
-    manybodyparameter_alpha(alpha),
-    manybodyparameter_beta(beta),
-    manybodyparameter_n(n),
-    manybodyparameter_c(d),
-    manybodyparameter_d(d),
-    manybodyparameter_h(h),
-    triplefunction(_triplefunction)
-  {}
+      boost::function< std::vector<arguments_t>(const argument_t &, const double)> &_triplefunction
+      );
+
+  /** Constructor for class ManyBodyPotential_Tersoff.
+   *
+   * @param _cutoff_offset offset for cutoff
+   * @param _cutoff_halfwidth halfwidth for cutoff relative to \a _cutoff_offset
+   * @param A
+   * @param B
+   * @param lambda1
+   * @param lambda2
+   * @param lambda3
+   * @param alpha
+   * @param beta
+   * @param n
+   * @param c
+   * @param d
+   * @param h
+   * @param _triplefunction function that returns a list of triples (i.e. the
+   *        two remaining distances) to a given pair of points (contained as
+   *        indices within the argument)
+   */
+  ManyBodyPotential_Tersoff(
+      const double &_cutoff_offset,
+      const double &_cutoff_halfwidth,
+      const double &A,
+      const double &B,
+      const double &lambda1,
+      const double &lambda2,
+      const double &lambda3,
+      const double &alpha,
+      const double &beta,
+      const double &n,
+      const double &c,
+      const double &d,
+      const double &h,
+      boost::function< std::vector<arguments_t>(const argument_t &, const double)> &_triplefunction);
+
   /** Destructor of class ManyBodyPotential_Tersoff.
    *
@@ -126,5 +111,13 @@
    *         input
    */
-  virtual results_t paramter_derivative(const arguments_t &arguments, const size_t index) const=0;
+  results_t parameter_derivative(const arguments_t &arguments, const size_t index) const;
+
+private:
+  /** Prohibit private default constructor.
+   *
+   * We essentially need the triplefunction, hence without this function cannot
+   * be.
+   */
+  ManyBodyPotential_Tersoff();
 
 private:
@@ -183,4 +176,56 @@
 
 private:
+  enum parameter_enum_t {
+    cutoff_offset=0,
+    equilibrium_distance=1,
+    cutoff_halfwidth=2,
+    A=3,
+    B=4,
+    lambda1=5,
+    lambda2=6,
+    lambda3=7,
+    alpha=8,
+    beta=9,
+    n=10,
+    c=11,
+    d=12,
+    h=13,
+    MAXPARAMS
+  };
+  //!> parameter vector with parameters as in enum parameter_enum_t
+  parameters_t params;
+
+public:
+  /** Setter for parameters as required by FunctionModel interface.
+   *
+   * \param _params given set of parameters
+   */
+  void setParameters(const parameters_t &_params)
+  {
+    ASSERT( _params.size() == getParameterDimension(),
+        "ManyBodyPotential_Tersoff::setParameters() - we need exactly "
+        +toString(getParameterDimension())+" parameters.");
+    params = _params;
+  }
+
+  /** Getter for parameters as required by FunctionModel interface.
+   *
+   * \return set of parameters
+   */
+  parameters_t getParameters() const
+  {
+    return params;
+  }
+
+  /** Getter for the number of parameters of this model function.
+   *
+   * \return number of parameters
+   */
+  size_t getParameterDimension() const
+  {
+    return MAXPARAMS;
+  }
+
+private:
   //!> bound function that obtains the triples for the internal coordinationb summation.
   const boost::function< std::vector< arguments_t >(const argument_t &, const double)> &triplefunction;
