diff --git a/Core/PythonAPI/inc/__call_policies.pypp.hpp b/Core/PythonAPI/inc/__call_policies.pypp.hpp
index b31e20b5413618a6720f6151c07ec0cfd0729a62..e5f8bb6a1bf0725c4072ca511a85c0b091532890 100644
--- a/Core/PythonAPI/inc/__call_policies.pypp.hpp
+++ b/Core/PythonAPI/inc/__call_policies.pypp.hpp
@@ -73,7 +73,7 @@ struct make_addressof_holder{
             return bpl::detail::none();
         }
         else{
-            size_t addressof_p = size_t( p );
+            boost::uint32_t addressof_p = reinterpret_cast< boost::uint32_t >( p );
             bpl::object p_address( addressof_p );
             return bpl::incref( p_address.ptr() );
         }
@@ -152,11 +152,6 @@ struct as_tuple_impl{
         MemoryManager::deallocate_array( arr );
         return bpl::incref( bpl::tuple( list_ ).ptr() );
     }
-
-    static PyTypeObject const *get_pytype(){
-        return &PyTuple_Type;
-    }
-
 };
 
 }
diff --git a/Core/PythonAPI/src/AxisBin.pypp.cpp b/Core/PythonAPI/src/AxisBin.pypp.cpp
index 669c312a4c85bf07f086a7f26075a4cc0df870dc..d7803664b4fcd249729648094d50df19b3e8ecb4 100644
--- a/Core/PythonAPI/src/AxisBin.pypp.cpp
+++ b/Core/PythonAPI/src/AxisBin.pypp.cpp
@@ -30,7 +30,7 @@ struct AxisBin_wrapper : AxisBin, bp::wrapper< AxisBin > {
     
     }
 
-    AxisBin_wrapper(::std::string name, ::size_t nbr_bins, double start, double end )
+    AxisBin_wrapper(::std::string name, ::std::size_t nbr_bins, double start, double end )
     : AxisBin( name, nbr_bins, start, end )
       , bp::wrapper< AxisBin >(){
         // constructor
@@ -40,11 +40,11 @@ struct AxisBin_wrapper : AxisBin, bp::wrapper< AxisBin > {
     virtual ::AxisBin * clone(  ) const  {
         if( bp::override func_clone = this->get_override( "clone" ) )
             return func_clone(  );
-        else{
+        else
             return this->AxisBin::clone(  );
-        }
     }
     
+    
     ::AxisBin * default_clone(  ) const  {
         return AxisBin::clone( );
     }
@@ -52,47 +52,47 @@ struct AxisBin_wrapper : AxisBin, bp::wrapper< AxisBin > {
     virtual ::AxisBin * createDoubleBinSize(  ) const  {
         if( bp::override func_createDoubleBinSize = this->get_override( "createDoubleBinSize" ) )
             return func_createDoubleBinSize(  );
-        else{
+        else
             return this->AxisBin::createDoubleBinSize(  );
-        }
     }
     
+    
     ::AxisBin * default_createDoubleBinSize(  ) const  {
         return AxisBin::createDoubleBinSize( );
     }
 
-    virtual ::size_t findClosestIndex( double value ) const  {
+    virtual ::std::size_t findClosestIndex( double value ) const  {
         if( bp::override func_findClosestIndex = this->get_override( "findClosestIndex" ) )
             return func_findClosestIndex( value );
-        else{
+        else
             return this->AxisBin::findClosestIndex( value );
-        }
     }
     
-    ::size_t default_findClosestIndex( double value ) const  {
+    
+    ::std::size_t default_findClosestIndex( double value ) const  {
         return AxisBin::findClosestIndex( value );
     }
 
-    virtual ::Bin1D getBin( ::size_t index ) const  {
+    virtual ::Bin1D getBin( ::std::size_t index ) const  {
         if( bp::override func_getBin = this->get_override( "getBin" ) )
             return func_getBin( index );
-        else{
+        else
             return this->AxisBin::getBin( index );
-        }
     }
     
-    ::Bin1D default_getBin( ::size_t index ) const  {
+    
+    ::Bin1D default_getBin( ::std::size_t index ) const  {
         return AxisBin::getBin( index );
     }
 
     virtual double getMax(  ) const  {
         if( bp::override func_getMax = this->get_override( "getMax" ) )
             return func_getMax(  );
-        else{
+        else
             return this->AxisBin::getMax(  );
-        }
     }
     
+    
     double default_getMax(  ) const  {
         return AxisBin::getMax( );
     }
@@ -100,36 +100,36 @@ struct AxisBin_wrapper : AxisBin, bp::wrapper< AxisBin > {
     virtual double getMin(  ) const  {
         if( bp::override func_getMin = this->get_override( "getMin" ) )
             return func_getMin(  );
-        else{
+        else
             return this->AxisBin::getMin(  );
-        }
     }
     
+    
     double default_getMin(  ) const  {
         return AxisBin::getMin( );
     }
 
-    virtual ::size_t getSize(  ) const  {
+    virtual ::std::size_t getSize(  ) const  {
         if( bp::override func_getSize = this->get_override( "getSize" ) )
             return func_getSize(  );
-        else{
+        else
             return this->AxisBin::getSize(  );
-        }
     }
     
-    ::size_t default_getSize(  ) const  {
+    
+    ::std::size_t default_getSize(  ) const  {
         return AxisBin::getSize( );
     }
 
-    virtual double operator[]( ::size_t index ) const  {
+    virtual double operator[]( ::std::size_t index ) const  {
         if( bp::override func___getitem__ = this->get_override( "__getitem__" ) )
             return func___getitem__( index );
-        else{
+        else
             return this->AxisBin::operator[]( index );
-        }
     }
     
-    double default___getitem__( ::size_t index ) const  {
+    
+    double default___getitem__( ::std::size_t index ) const  {
         return AxisBin::operator[]( index );
     }
 
@@ -141,7 +141,7 @@ void register_AxisBin_class(){
         typedef bp::class_< AxisBin_wrapper, bp::bases< IAxis > > AxisBin_exposer_t;
         AxisBin_exposer_t AxisBin_exposer = AxisBin_exposer_t( "AxisBin", bp::init< std::string >(( bp::arg("name") )) );
         bp::scope AxisBin_scope( AxisBin_exposer );
-        AxisBin_exposer.def( bp::init< std::string, size_t, double, double >(( bp::arg("name"), bp::arg("nbr_bins"), bp::arg("start"), bp::arg("end") )) );
+        AxisBin_exposer.def( bp::init< std::string, std::size_t, double, double >(( bp::arg("name"), bp::arg("nbr_bins"), bp::arg("start"), bp::arg("end") )) );
         { //::AxisBin::clone
         
             typedef ::AxisBin * ( ::AxisBin::*clone_function_type )(  ) const;
@@ -168,8 +168,8 @@ void register_AxisBin_class(){
         }
         { //::AxisBin::findClosestIndex
         
-            typedef ::size_t ( ::AxisBin::*findClosestIndex_function_type )( double ) const;
-            typedef ::size_t ( AxisBin_wrapper::*default_findClosestIndex_function_type )( double ) const;
+            typedef ::std::size_t ( ::AxisBin::*findClosestIndex_function_type )( double ) const;
+            typedef ::std::size_t ( AxisBin_wrapper::*default_findClosestIndex_function_type )( double ) const;
             
             AxisBin_exposer.def( 
                 "findClosestIndex"
@@ -180,8 +180,8 @@ void register_AxisBin_class(){
         }
         { //::AxisBin::getBin
         
-            typedef ::Bin1D ( ::AxisBin::*getBin_function_type )( ::size_t ) const;
-            typedef ::Bin1D ( AxisBin_wrapper::*default_getBin_function_type )( ::size_t ) const;
+            typedef ::Bin1D ( ::AxisBin::*getBin_function_type )( ::std::size_t ) const;
+            typedef ::Bin1D ( AxisBin_wrapper::*default_getBin_function_type )( ::std::size_t ) const;
             
             AxisBin_exposer.def( 
                 "getBin"
@@ -214,8 +214,8 @@ void register_AxisBin_class(){
         }
         { //::AxisBin::getSize
         
-            typedef ::size_t ( ::AxisBin::*getSize_function_type )(  ) const;
-            typedef ::size_t ( AxisBin_wrapper::*default_getSize_function_type )(  ) const;
+            typedef ::std::size_t ( ::AxisBin::*getSize_function_type )(  ) const;
+            typedef ::std::size_t ( AxisBin_wrapper::*default_getSize_function_type )(  ) const;
             
             AxisBin_exposer.def( 
                 "getSize"
@@ -234,7 +234,7 @@ void register_AxisBin_class(){
         }
         { //::AxisBin::initBins
         
-            typedef void ( ::AxisBin::*initBins_function_type )( ::size_t,double,double ) ;
+            typedef void ( ::AxisBin::*initBins_function_type )( ::std::size_t,double,double ) ;
             
             AxisBin_exposer.def( 
                 "initBins"
@@ -244,8 +244,8 @@ void register_AxisBin_class(){
         }
         { //::AxisBin::operator[]
         
-            typedef double ( ::AxisBin::*__getitem___function_type )( ::size_t ) const;
-            typedef double ( AxisBin_wrapper::*default___getitem___function_type )( ::size_t ) const;
+            typedef double ( ::AxisBin::*__getitem___function_type )( ::std::size_t ) const;
+            typedef double ( AxisBin_wrapper::*default___getitem___function_type )( ::std::size_t ) const;
             
             AxisBin_exposer.def( 
                 "__getitem__"
diff --git a/Core/PythonAPI/src/AxisDouble.pypp.cpp b/Core/PythonAPI/src/AxisDouble.pypp.cpp
index b8f339934ce794cec37fda805faa559fd1cde158..300be999fae50e538a44392edbd3c49a5667437c 100644
--- a/Core/PythonAPI/src/AxisDouble.pypp.cpp
+++ b/Core/PythonAPI/src/AxisDouble.pypp.cpp
@@ -30,7 +30,7 @@ struct AxisDouble_wrapper : AxisDouble, bp::wrapper< AxisDouble > {
     
     }
 
-    AxisDouble_wrapper(::std::string name, ::size_t size, double start, double end )
+    AxisDouble_wrapper(::std::string name, ::std::size_t size, double start, double end )
     : AxisDouble( name, size, start, end )
       , bp::wrapper< AxisDouble >(){
         // constructor
@@ -44,38 +44,38 @@ struct AxisDouble_wrapper : AxisDouble, bp::wrapper< AxisDouble > {
     
     }
 
-    virtual ::size_t findClosestIndex( double value ) const  {
+    virtual ::std::size_t findClosestIndex( double value ) const  {
         if( bp::override func_findClosestIndex = this->get_override( "findClosestIndex" ) )
             return func_findClosestIndex( value );
-        else{
+        else
             return this->AxisDouble::findClosestIndex( value );
-        }
     }
     
-    ::size_t default_findClosestIndex( double value ) const  {
+    
+    ::std::size_t default_findClosestIndex( double value ) const  {
         return AxisDouble::findClosestIndex( value );
     }
 
-    virtual ::Bin1D getBin( ::size_t index ) const  {
+    virtual ::Bin1D getBin( ::std::size_t index ) const  {
         if( bp::override func_getBin = this->get_override( "getBin" ) )
             return func_getBin( index );
-        else{
+        else
             return this->AxisDouble::getBin( index );
-        }
     }
     
-    ::Bin1D default_getBin( ::size_t index ) const  {
+    
+    ::Bin1D default_getBin( ::std::size_t index ) const  {
         return AxisDouble::getBin( index );
     }
 
     virtual double getMax(  ) const  {
         if( bp::override func_getMax = this->get_override( "getMax" ) )
             return func_getMax(  );
-        else{
+        else
             return this->AxisDouble::getMax(  );
-        }
     }
     
+    
     double default_getMax(  ) const  {
         return AxisDouble::getMax( );
     }
@@ -83,36 +83,36 @@ struct AxisDouble_wrapper : AxisDouble, bp::wrapper< AxisDouble > {
     virtual double getMin(  ) const  {
         if( bp::override func_getMin = this->get_override( "getMin" ) )
             return func_getMin(  );
-        else{
+        else
             return this->AxisDouble::getMin(  );
-        }
     }
     
+    
     double default_getMin(  ) const  {
         return AxisDouble::getMin( );
     }
 
-    virtual ::size_t getSize(  ) const  {
+    virtual ::std::size_t getSize(  ) const  {
         if( bp::override func_getSize = this->get_override( "getSize" ) )
             return func_getSize(  );
-        else{
+        else
             return this->AxisDouble::getSize(  );
-        }
     }
     
-    ::size_t default_getSize(  ) const  {
+    
+    ::std::size_t default_getSize(  ) const  {
         return AxisDouble::getSize( );
     }
 
-    virtual double operator[]( ::size_t index ) const  {
+    virtual double operator[]( ::std::size_t index ) const  {
         if( bp::override func___getitem__ = this->get_override( "__getitem__" ) )
             return func___getitem__( index );
-        else{
+        else
             return this->AxisDouble::operator[]( index );
-        }
     }
     
-    double default___getitem__( ::size_t index ) const  {
+    
+    double default___getitem__( ::std::size_t index ) const  {
         return AxisDouble::operator[]( index );
     }
 
@@ -124,12 +124,12 @@ void register_AxisDouble_class(){
         typedef bp::class_< AxisDouble_wrapper, bp::bases< IAxis > > AxisDouble_exposer_t;
         AxisDouble_exposer_t AxisDouble_exposer = AxisDouble_exposer_t( "AxisDouble", bp::init< std::string >(( bp::arg("name") )) );
         bp::scope AxisDouble_scope( AxisDouble_exposer );
-        AxisDouble_exposer.def( bp::init< std::string, size_t, double, double >(( bp::arg("name"), bp::arg("size"), bp::arg("start"), bp::arg("end") )) );
+        AxisDouble_exposer.def( bp::init< std::string, std::size_t, double, double >(( bp::arg("name"), bp::arg("size"), bp::arg("start"), bp::arg("end") )) );
         AxisDouble_exposer.def( bp::init< AxisBin const & >(( bp::arg("source") )) );
         { //::AxisDouble::findClosestIndex
         
-            typedef ::size_t ( ::AxisDouble::*findClosestIndex_function_type )( double ) const;
-            typedef ::size_t ( AxisDouble_wrapper::*default_findClosestIndex_function_type )( double ) const;
+            typedef ::std::size_t ( ::AxisDouble::*findClosestIndex_function_type )( double ) const;
+            typedef ::std::size_t ( AxisDouble_wrapper::*default_findClosestIndex_function_type )( double ) const;
             
             AxisDouble_exposer.def( 
                 "findClosestIndex"
@@ -140,8 +140,8 @@ void register_AxisDouble_class(){
         }
         { //::AxisDouble::getBin
         
-            typedef ::Bin1D ( ::AxisDouble::*getBin_function_type )( ::size_t ) const;
-            typedef ::Bin1D ( AxisDouble_wrapper::*default_getBin_function_type )( ::size_t ) const;
+            typedef ::Bin1D ( ::AxisDouble::*getBin_function_type )( ::std::size_t ) const;
+            typedef ::Bin1D ( AxisDouble_wrapper::*default_getBin_function_type )( ::std::size_t ) const;
             
             AxisDouble_exposer.def( 
                 "getBin"
@@ -152,7 +152,7 @@ void register_AxisDouble_class(){
         }
         { //::AxisDouble::getLowerBoundIndex
         
-            typedef ::size_t ( ::AxisDouble::*getLowerBoundIndex_function_type )( double ) const;
+            typedef ::std::size_t ( ::AxisDouble::*getLowerBoundIndex_function_type )( double ) const;
             
             AxisDouble_exposer.def( 
                 "getLowerBoundIndex"
@@ -184,8 +184,8 @@ void register_AxisDouble_class(){
         }
         { //::AxisDouble::getSize
         
-            typedef ::size_t ( ::AxisDouble::*getSize_function_type )(  ) const;
-            typedef ::size_t ( AxisDouble_wrapper::*default_getSize_function_type )(  ) const;
+            typedef ::std::size_t ( ::AxisDouble::*getSize_function_type )(  ) const;
+            typedef ::std::size_t ( AxisDouble_wrapper::*default_getSize_function_type )(  ) const;
             
             AxisDouble_exposer.def( 
                 "getSize"
@@ -195,7 +195,7 @@ void register_AxisDouble_class(){
         }
         { //::AxisDouble::getUpperBoundIndex
         
-            typedef ::size_t ( ::AxisDouble::*getUpperBoundIndex_function_type )( double ) const;
+            typedef ::std::size_t ( ::AxisDouble::*getUpperBoundIndex_function_type )( double ) const;
             
             AxisDouble_exposer.def( 
                 "getUpperBoundIndex"
@@ -214,7 +214,7 @@ void register_AxisDouble_class(){
         }
         { //::AxisDouble::initElements
         
-            typedef void ( ::AxisDouble::*initElements_function_type )( ::size_t,double,double ) ;
+            typedef void ( ::AxisDouble::*initElements_function_type )( ::std::size_t,double,double ) ;
             
             AxisDouble_exposer.def( 
                 "initElements"
@@ -224,8 +224,8 @@ void register_AxisDouble_class(){
         }
         { //::AxisDouble::operator[]
         
-            typedef double ( ::AxisDouble::*__getitem___function_type )( ::size_t ) const;
-            typedef double ( AxisDouble_wrapper::*default___getitem___function_type )( ::size_t ) const;
+            typedef double ( ::AxisDouble::*__getitem___function_type )( ::std::size_t ) const;
+            typedef double ( AxisDouble_wrapper::*default___getitem___function_type )( ::std::size_t ) const;
             
             AxisDouble_exposer.def( 
                 "__getitem__"
diff --git a/Core/PythonAPI/src/FTDistribution2DCauchy.pypp.cpp b/Core/PythonAPI/src/FTDistribution2DCauchy.pypp.cpp
index be52bad15dfe4a43e31d27390ef89a33328bd77b..3a354bc71f8a65c1427a4a4bbd0c18f44d024468 100644
--- a/Core/PythonAPI/src/FTDistribution2DCauchy.pypp.cpp
+++ b/Core/PythonAPI/src/FTDistribution2DCauchy.pypp.cpp
@@ -25,8 +25,8 @@ struct FTDistribution2DCauchy_wrapper : FTDistribution2DCauchy, bp::wrapper< FTD
         
     }
 
-    FTDistribution2DCauchy_wrapper(double omega_x, double omega_y )
-    : FTDistribution2DCauchy( omega_x, omega_y )
+    FTDistribution2DCauchy_wrapper(double coherence_length_x, double coherence_length_y )
+    : FTDistribution2DCauchy( coherence_length_x, coherence_length_y )
       , bp::wrapper< FTDistribution2DCauchy >(){
         // constructor
     
@@ -56,18 +56,6 @@ struct FTDistribution2DCauchy_wrapper : FTDistribution2DCauchy, bp::wrapper< FTD
         return FTDistribution2DCauchy::evaluate( qx, qy );
     }
 
-    virtual void transformToStarBasis( double qX, double qY, double alpha, double a, double b, double & qa, double & qb ) const  {
-        if( bp::override func_transformToStarBasis = this->get_override( "transformToStarBasis" ) )
-            func_transformToStarBasis( qX, qY, alpha, a, b, qa, qb );
-        else
-            this->FTDistribution2DCauchy::transformToStarBasis( qX, qY, alpha, a, b, qa, qb );
-    }
-    
-    
-    void default_transformToStarBasis( double qX, double qY, double alpha, double a, double b, double & qa, double & qb ) const  {
-        FTDistribution2DCauchy::transformToStarBasis( qX, qY, alpha, a, b, qa, qb );
-    }
-
     virtual bool areParametersChanged(  ) {
         if( bp::override func_areParametersChanged = this->get_override( "areParametersChanged" ) )
             return func_areParametersChanged(  );
@@ -165,7 +153,7 @@ void register_FTDistribution2DCauchy_class(){
 
     { //::FTDistribution2DCauchy
         typedef bp::class_< FTDistribution2DCauchy_wrapper, bp::bases< IFTDistribution2D > > FTDistribution2DCauchy_exposer_t;
-        FTDistribution2DCauchy_exposer_t FTDistribution2DCauchy_exposer = FTDistribution2DCauchy_exposer_t( "FTDistribution2DCauchy", bp::init< double, double >(( bp::arg("omega_x"), bp::arg("omega_y") )) );
+        FTDistribution2DCauchy_exposer_t FTDistribution2DCauchy_exposer = FTDistribution2DCauchy_exposer_t( "FTDistribution2DCauchy", bp::init< double, double >(( bp::arg("coherence_length_x"), bp::arg("coherence_length_y") )) );
         bp::scope FTDistribution2DCauchy_scope( FTDistribution2DCauchy_exposer );
         { //::FTDistribution2DCauchy::clone
         
@@ -190,18 +178,6 @@ void register_FTDistribution2DCauchy_class(){
                 , default_evaluate_function_type(&FTDistribution2DCauchy_wrapper::default_evaluate)
                 , ( bp::arg("qx"), bp::arg("qy") ) );
         
-        }
-        { //::FTDistribution2DCauchy::transformToStarBasis
-        
-            typedef void ( ::FTDistribution2DCauchy::*transformToStarBasis_function_type )( double,double,double,double,double,double &,double & ) const;
-            typedef void ( FTDistribution2DCauchy_wrapper::*default_transformToStarBasis_function_type )( double,double,double,double,double,double &,double & ) const;
-            
-            FTDistribution2DCauchy_exposer.def( 
-                "transformToStarBasis"
-                , transformToStarBasis_function_type(&::FTDistribution2DCauchy::transformToStarBasis)
-                , default_transformToStarBasis_function_type(&FTDistribution2DCauchy_wrapper::default_transformToStarBasis)
-                , ( bp::arg("qX"), bp::arg("qY"), bp::arg("alpha"), bp::arg("a"), bp::arg("b"), bp::arg("qa"), bp::arg("qb") ) );
-        
         }
         { //::IParameterized::areParametersChanged
         
diff --git a/Core/PythonAPI/src/HomogeneousMaterial.pypp.cpp b/Core/PythonAPI/src/HomogeneousMaterial.pypp.cpp
index 54f03ec9383a707ab1c91d44dee1d4cf8fb73d45..cb298c17261071e1fc6ba80361e9d491935e34b6 100644
--- a/Core/PythonAPI/src/HomogeneousMaterial.pypp.cpp
+++ b/Core/PythonAPI/src/HomogeneousMaterial.pypp.cpp
@@ -40,11 +40,11 @@ struct HomogeneousMaterial_wrapper : HomogeneousMaterial, bp::wrapper< Homogeneo
     virtual ::HomogeneousMaterial * clone(  ) const  {
         if( bp::override func_clone = this->get_override( "clone" ) )
             return func_clone(  );
-        else{
+        else
             return this->HomogeneousMaterial::clone(  );
-        }
     }
     
+    
     ::HomogeneousMaterial * default_clone(  ) const  {
         return HomogeneousMaterial::clone( );
     }
@@ -52,11 +52,11 @@ struct HomogeneousMaterial_wrapper : HomogeneousMaterial, bp::wrapper< Homogeneo
     virtual ::IMaterial const * createTransformedMaterial( ::Geometry::ITransform3D const & transform ) const  {
         if( bp::override func_createTransformedMaterial = this->get_override( "createTransformedMaterial" ) )
             return func_createTransformedMaterial( boost::ref(transform) );
-        else{
+        else
             return this->HomogeneousMaterial::createTransformedMaterial( boost::ref(transform) );
-        }
     }
     
+    
     ::IMaterial const * default_createTransformedMaterial( ::Geometry::ITransform3D const & transform ) const  {
         return HomogeneousMaterial::createTransformedMaterial( boost::ref(transform) );
     }
@@ -64,11 +64,11 @@ struct HomogeneousMaterial_wrapper : HomogeneousMaterial, bp::wrapper< Homogeneo
     virtual ::complex_t getRefractiveIndex(  ) const  {
         if( bp::override func_getRefractiveIndex = this->get_override( "getRefractiveIndex" ) )
             return func_getRefractiveIndex(  );
-        else{
+        else
             return this->HomogeneousMaterial::getRefractiveIndex(  );
-        }
     }
     
+    
     ::complex_t default_getRefractiveIndex(  ) const  {
         return HomogeneousMaterial::getRefractiveIndex( );
     }
@@ -76,11 +76,11 @@ struct HomogeneousMaterial_wrapper : HomogeneousMaterial, bp::wrapper< Homogeneo
     virtual bool isScalarMaterial(  ) const  {
         if( bp::override func_isScalarMaterial = this->get_override( "isScalarMaterial" ) )
             return func_isScalarMaterial(  );
-        else{
+        else
             return this->IMaterial::isScalarMaterial(  );
-        }
     }
     
+    
     bool default_isScalarMaterial(  ) const  {
         return IMaterial::isScalarMaterial( );
     }
diff --git a/Core/PythonAPI/src/IAxis.pypp.cpp b/Core/PythonAPI/src/IAxis.pypp.cpp
index a6c9c35dcd98aa69f39a992fe63304b54e7adf7c..9c689bebe60a4d93f9e856aaab898a9a45e5c2d3 100644
--- a/Core/PythonAPI/src/IAxis.pypp.cpp
+++ b/Core/PythonAPI/src/IAxis.pypp.cpp
@@ -33,12 +33,12 @@ struct IAxis_wrapper : IAxis, bp::wrapper< IAxis > {
         return func_createDoubleBinSize(  );
     }
 
-    virtual ::size_t findClosestIndex( double value ) const {
+    virtual ::std::size_t findClosestIndex( double value ) const {
         bp::override func_findClosestIndex = this->get_override( "findClosestIndex" );
         return func_findClosestIndex( value );
     }
 
-    virtual ::Bin1D getBin( ::size_t index ) const {
+    virtual ::Bin1D getBin( ::std::size_t index ) const {
         bp::override func_getBin = this->get_override( "getBin" );
         return func_getBin( index );
     }
@@ -53,12 +53,12 @@ struct IAxis_wrapper : IAxis, bp::wrapper< IAxis > {
         return func_getMin(  );
     }
 
-    virtual ::size_t getSize(  ) const {
+    virtual ::std::size_t getSize(  ) const {
         bp::override func_getSize = this->get_override( "getSize" );
         return func_getSize(  );
     }
 
-    virtual double operator[]( ::size_t index ) const {
+    virtual double operator[]( ::std::size_t index ) const {
         bp::override func___getitem__ = this->get_override( "__getitem__" );
         return func___getitem__( index );
     }
@@ -93,7 +93,7 @@ void register_IAxis_class(){
         }
         { //::IAxis::findClosestIndex
         
-            typedef ::size_t ( ::IAxis::*findClosestIndex_function_type )( double ) const;
+            typedef ::std::size_t ( ::IAxis::*findClosestIndex_function_type )( double ) const;
             
             IAxis_exposer.def( 
                 "findClosestIndex"
@@ -103,7 +103,7 @@ void register_IAxis_class(){
         }
         { //::IAxis::getBin
         
-            typedef ::Bin1D ( ::IAxis::*getBin_function_type )( ::size_t ) const;
+            typedef ::Bin1D ( ::IAxis::*getBin_function_type )( ::std::size_t ) const;
             
             IAxis_exposer.def( 
                 "getBin"
@@ -140,7 +140,7 @@ void register_IAxis_class(){
         }
         { //::IAxis::getSize
         
-            typedef ::size_t ( ::IAxis::*getSize_function_type )(  ) const;
+            typedef ::std::size_t ( ::IAxis::*getSize_function_type )(  ) const;
             
             IAxis_exposer.def( 
                 "getSize"
@@ -149,7 +149,7 @@ void register_IAxis_class(){
         }
         { //::IAxis::operator[]
         
-            typedef double ( ::IAxis::*__getitem___function_type )( ::size_t ) const;
+            typedef double ( ::IAxis::*__getitem___function_type )( ::std::size_t ) const;
             
             IAxis_exposer.def( 
                 "__getitem__"
diff --git a/Core/PythonAPI/src/IFTDistribution2D.pypp.cpp b/Core/PythonAPI/src/IFTDistribution2D.pypp.cpp
index 8fbe7b360e91d804e8752bde9e71e80da7b9377c..301a0f8f4880c9445135c8d67b2bd8c8581dda3d 100644
--- a/Core/PythonAPI/src/IFTDistribution2D.pypp.cpp
+++ b/Core/PythonAPI/src/IFTDistribution2D.pypp.cpp
@@ -18,8 +18,8 @@ namespace bp = boost::python;
 
 struct IFTDistribution2D_wrapper : IFTDistribution2D, bp::wrapper< IFTDistribution2D > {
 
-    IFTDistribution2D_wrapper(double omega_x, double omega_y )
-    : IFTDistribution2D( omega_x, omega_y )
+    IFTDistribution2D_wrapper(double coherence_length_x, double coherence_length_y )
+    : IFTDistribution2D( coherence_length_x, coherence_length_y )
       , bp::wrapper< IFTDistribution2D >(){
         // constructor
     
@@ -35,11 +35,6 @@ struct IFTDistribution2D_wrapper : IFTDistribution2D, bp::wrapper< IFTDistributi
         return func_evaluate( qx, qy );
     }
 
-    virtual void transformToStarBasis( double qX, double qY, double alpha, double a, double b, double & qa, double & qb ) const {
-        bp::override func_transformToStarBasis = this->get_override( "transformToStarBasis" );
-        func_transformToStarBasis( qX, qY, alpha, a, b, qa, qb );
-    }
-
     virtual bool areParametersChanged(  ) {
         if( bp::override func_areParametersChanged = this->get_override( "areParametersChanged" ) )
             return func_areParametersChanged(  );
@@ -137,7 +132,7 @@ void register_IFTDistribution2D_class(){
 
     { //::IFTDistribution2D
         typedef bp::class_< IFTDistribution2D_wrapper, bp::bases< IParameterized >, boost::noncopyable > IFTDistribution2D_exposer_t;
-        IFTDistribution2D_exposer_t IFTDistribution2D_exposer = IFTDistribution2D_exposer_t( "IFTDistribution2D", bp::init< double, double >(( bp::arg("omega_x"), bp::arg("omega_y") )) );
+        IFTDistribution2D_exposer_t IFTDistribution2D_exposer = IFTDistribution2D_exposer_t( "IFTDistribution2D", bp::init< double, double >(( bp::arg("coherence_length_x"), bp::arg("coherence_length_y") )) );
         bp::scope IFTDistribution2D_scope( IFTDistribution2D_exposer );
         { //::IFTDistribution2D::clone
         
@@ -193,7 +188,7 @@ void register_IFTDistribution2D_class(){
             
             IFTDistribution2D_exposer.def( 
                 "transformToStarBasis"
-                , bp::pure_virtual( transformToStarBasis_function_type(&::IFTDistribution2D::transformToStarBasis) )
+                , transformToStarBasis_function_type( &::IFTDistribution2D::transformToStarBasis )
                 , ( bp::arg("qX"), bp::arg("qY"), bp::arg("alpha"), bp::arg("a"), bp::arg("b"), bp::arg("qa"), bp::arg("qb") ) );
         
         }
diff --git a/Core/PythonAPI/src/IMaterial.pypp.cpp b/Core/PythonAPI/src/IMaterial.pypp.cpp
index 06ef528bf18110412ed581e97ba85e52d2a18d50..3585f441333c7a69c5e0b8582480abb706347554 100644
--- a/Core/PythonAPI/src/IMaterial.pypp.cpp
+++ b/Core/PythonAPI/src/IMaterial.pypp.cpp
@@ -33,11 +33,11 @@ struct IMaterial_wrapper : IMaterial, bp::wrapper< IMaterial > {
     virtual ::IMaterial * clone(  ) const  {
         if( bp::override func_clone = this->get_override( "clone" ) )
             return func_clone(  );
-        else{
+        else
             return this->IMaterial::clone(  );
-        }
     }
     
+    
     ::IMaterial * default_clone(  ) const  {
         return IMaterial::clone( );
     }
@@ -45,11 +45,11 @@ struct IMaterial_wrapper : IMaterial, bp::wrapper< IMaterial > {
     virtual ::IMaterial const * createTransformedMaterial( ::Geometry::ITransform3D const & transform ) const  {
         if( bp::override func_createTransformedMaterial = this->get_override( "createTransformedMaterial" ) )
             return func_createTransformedMaterial( boost::ref(transform) );
-        else{
+        else
             return this->IMaterial::createTransformedMaterial( boost::ref(transform) );
-        }
     }
     
+    
     ::IMaterial const * default_createTransformedMaterial( ::Geometry::ITransform3D const & transform ) const  {
         return IMaterial::createTransformedMaterial( boost::ref(transform) );
     }
@@ -57,11 +57,11 @@ struct IMaterial_wrapper : IMaterial, bp::wrapper< IMaterial > {
     virtual ::complex_t getRefractiveIndex(  ) const  {
         if( bp::override func_getRefractiveIndex = this->get_override( "getRefractiveIndex" ) )
             return func_getRefractiveIndex(  );
-        else{
+        else
             return this->IMaterial::getRefractiveIndex(  );
-        }
     }
     
+    
     ::complex_t default_getRefractiveIndex(  ) const  {
         return IMaterial::getRefractiveIndex( );
     }
@@ -69,11 +69,11 @@ struct IMaterial_wrapper : IMaterial, bp::wrapper< IMaterial > {
     virtual bool isScalarMaterial(  ) const  {
         if( bp::override func_isScalarMaterial = this->get_override( "isScalarMaterial" ) )
             return func_isScalarMaterial(  );
-        else{
+        else
             return this->IMaterial::isScalarMaterial(  );
-        }
     }
     
+    
     bool default_isScalarMaterial(  ) const  {
         return IMaterial::isScalarMaterial( );
     }
diff --git a/Core/PythonAPI/src/IObservable.pypp.cpp b/Core/PythonAPI/src/IObservable.pypp.cpp
index 6e3f06ed514410bbb627cc7662aae9e981e84ec4..c73a23d0bf6708f67b04bfc30d66b984ecb5fd0c 100644
--- a/Core/PythonAPI/src/IObservable.pypp.cpp
+++ b/Core/PythonAPI/src/IObservable.pypp.cpp
@@ -33,11 +33,11 @@ struct IObservable_wrapper : IObservable, bp::wrapper< IObservable > {
     virtual void attachObserver( ::boost::shared_ptr< IObserver > obj ) {
         if( bp::override func_attachObserver = this->get_override( "attachObserver" ) )
             func_attachObserver( obj );
-        else{
+        else
             this->IObservable::attachObserver( obj );
-        }
     }
     
+    
     void default_attachObserver( ::boost::shared_ptr< IObserver > obj ) {
         IObservable::attachObserver( obj );
     }
@@ -45,11 +45,11 @@ struct IObservable_wrapper : IObservable, bp::wrapper< IObservable > {
     virtual void notifyObservers(  ) {
         if( bp::override func_notifyObservers = this->get_override( "notifyObservers" ) )
             func_notifyObservers(  );
-        else{
+        else
             this->IObservable::notifyObservers(  );
-        }
     }
     
+    
     void default_notifyObservers(  ) {
         IObservable::notifyObservers( );
     }
diff --git a/Core/PythonAPI/src/IObserver.pypp.cpp b/Core/PythonAPI/src/IObserver.pypp.cpp
index 04ac2919e58459d79daaa149dec2b099ee23ac18..9d93fda86f32c812006aa5454c63b36241843e57 100644
--- a/Core/PythonAPI/src/IObserver.pypp.cpp
+++ b/Core/PythonAPI/src/IObserver.pypp.cpp
@@ -33,11 +33,11 @@ struct IObserver_wrapper : IObserver, bp::wrapper< IObserver > {
     virtual void update( ::IObservable * arg0 ) {
         if( bp::override func_update = this->get_override( "update" ) )
             func_update( boost::python::ptr(arg0) );
-        else{
+        else
             this->IObserver::update( boost::python::ptr(arg0) );
-        }
     }
     
+    
     void default_update( ::IObservable * arg0 ) {
         IObserver::update( boost::python::ptr(arg0) );
     }
diff --git a/Core/PythonAPI/src/ITransform3D.pypp.cpp b/Core/PythonAPI/src/ITransform3D.pypp.cpp
index f500e0d020698ebca3098edb5465eb690e8cd7ef..facf344322d8c1d3cecdc6458b54e4785564c39a 100644
--- a/Core/PythonAPI/src/ITransform3D.pypp.cpp
+++ b/Core/PythonAPI/src/ITransform3D.pypp.cpp
@@ -33,11 +33,11 @@ struct ITransform3D_wrapper : Geometry::ITransform3D, bp::wrapper< Geometry::ITr
     virtual ::Geometry::ITransform3D * clone(  ) const  {
         if( bp::override func_clone = this->get_override( "clone" ) )
             return func_clone(  );
-        else{
+        else
             return this->Geometry::ITransform3D::clone(  );
-        }
     }
     
+    
     ::Geometry::ITransform3D * default_clone(  ) const  {
         return Geometry::ITransform3D::clone( );
     }
@@ -45,11 +45,11 @@ struct ITransform3D_wrapper : Geometry::ITransform3D, bp::wrapper< Geometry::ITr
     virtual void print( ::std::ostream & ostr ) const  {
         if( bp::override func_print = this->get_override( "print" ) )
             func_print( boost::ref(ostr) );
-        else{
+        else
             this->Geometry::ITransform3D::print( boost::ref(ostr) );
-        }
     }
     
+    
     void default_print( ::std::ostream & ostr ) const  {
         Geometry::ITransform3D::print( boost::ref(ostr) );
     }
diff --git a/Core/PythonAPI/src/IntensityData.pypp.cpp b/Core/PythonAPI/src/IntensityData.pypp.cpp
index a4764e19baa7e85e942818834665a55839a3b2bd..55ba4ac878ef958f57f97341661d4e9ac8ef5717 100644
--- a/Core/PythonAPI/src/IntensityData.pypp.cpp
+++ b/Core/PythonAPI/src/IntensityData.pypp.cpp
@@ -34,7 +34,7 @@ void register_IntensityData_class(){
         { //::OutputData< double >::addAxis
         
             typedef OutputData< double > exported_class_t;
-            typedef void ( exported_class_t::*addAxis_function_type )( ::std::string const &,::size_t,double,double ) ;
+            typedef void ( exported_class_t::*addAxis_function_type )( ::std::string const &,::std::size_t,double,double ) ;
             
             IntensityData_exposer.def( 
                 "addAxis"
@@ -87,7 +87,7 @@ void register_IntensityData_class(){
         { //::OutputData< double >::getAllocatedSize
         
             typedef OutputData< double > exported_class_t;
-            typedef ::size_t ( exported_class_t::*getAllocatedSize_function_type )(  ) const;
+            typedef ::std::size_t ( exported_class_t::*getAllocatedSize_function_type )(  ) const;
             
             IntensityData_exposer.def( 
                 "getAllocatedSize"
@@ -107,7 +107,7 @@ void register_IntensityData_class(){
         { //::OutputData< double >::getAxis
         
             typedef OutputData< double > exported_class_t;
-            typedef ::IAxis const * ( exported_class_t::*getAxis_function_type )( ::size_t ) const;
+            typedef ::IAxis const * ( exported_class_t::*getAxis_function_type )( ::std::size_t ) const;
             
             IntensityData_exposer.def( 
                 "getAxis"
@@ -131,7 +131,7 @@ void register_IntensityData_class(){
         { //::OutputData< double >::getAxisIndex
         
             typedef OutputData< double > exported_class_t;
-            typedef ::size_t ( exported_class_t::*getAxisIndex_function_type )( ::std::string const & ) const;
+            typedef ::std::size_t ( exported_class_t::*getAxisIndex_function_type )( ::std::string const & ) const;
             
             IntensityData_exposer.def( 
                 "getAxisIndex"
@@ -142,7 +142,7 @@ void register_IntensityData_class(){
         { //::OutputData< double >::getIndexOfAxis
         
             typedef OutputData< double > exported_class_t;
-            typedef ::size_t ( exported_class_t::*getIndexOfAxis_function_type )( ::std::string const &,::size_t ) const;
+            typedef ::std::size_t ( exported_class_t::*getIndexOfAxis_function_type )( ::std::string const &,::std::size_t ) const;
             
             IntensityData_exposer.def( 
                 "getIndexOfAxis"
@@ -153,7 +153,7 @@ void register_IntensityData_class(){
         { //::OutputData< double >::getRank
         
             typedef OutputData< double > exported_class_t;
-            typedef ::size_t ( exported_class_t::*getRank_function_type )(  ) const;
+            typedef ::std::size_t ( exported_class_t::*getRank_function_type )(  ) const;
             
             IntensityData_exposer.def( 
                 "getRank"
@@ -173,7 +173,7 @@ void register_IntensityData_class(){
         { //::OutputData< double >::getValueOfAxis
         
             typedef OutputData< double > exported_class_t;
-            typedef double ( exported_class_t::*getValueOfAxis_function_type )( ::std::string const &,::size_t ) const;
+            typedef double ( exported_class_t::*getValueOfAxis_function_type )( ::std::string const &,::std::size_t ) const;
             
             IntensityData_exposer.def( 
                 "getValueOfAxis"
@@ -210,7 +210,7 @@ void register_IntensityData_class(){
         { //::OutputData< double >::operator[]
         
             typedef OutputData< double > exported_class_t;
-            typedef double & ( exported_class_t::*__getitem___function_type )( ::size_t ) ;
+            typedef double & ( exported_class_t::*__getitem___function_type )( ::std::size_t ) ;
             
             IntensityData_exposer.def( 
                 "__getitem__"
@@ -222,7 +222,7 @@ void register_IntensityData_class(){
         { //::OutputData< double >::operator[]
         
             typedef OutputData< double > exported_class_t;
-            typedef double const & ( exported_class_t::*__getitem___function_type )( ::size_t ) const;
+            typedef double const & ( exported_class_t::*__getitem___function_type )( ::std::size_t ) const;
             
             IntensityData_exposer.def( 
                 "__getitem__"
@@ -277,7 +277,7 @@ void register_IntensityData_class(){
         { //::OutputData< double >::toCoordinate
         
             typedef OutputData< double > exported_class_t;
-            typedef int ( exported_class_t::*toCoordinate_function_type )( ::size_t,::size_t ) const;
+            typedef int ( exported_class_t::*toCoordinate_function_type )( ::std::size_t,::std::size_t ) const;
             
             IntensityData_exposer.def( 
                 "toCoordinate"
@@ -288,7 +288,7 @@ void register_IntensityData_class(){
         { //::OutputData< double >::toCoordinates
         
             typedef OutputData< double > exported_class_t;
-            typedef ::std::vector< int > ( exported_class_t::*toCoordinates_function_type )( ::size_t ) const;
+            typedef ::std::vector< int > ( exported_class_t::*toCoordinates_function_type )( ::std::size_t ) const;
             
             IntensityData_exposer.def( 
                 "toCoordinates"
@@ -299,7 +299,7 @@ void register_IntensityData_class(){
         { //::OutputData< double >::toIndex
         
             typedef OutputData< double > exported_class_t;
-            typedef ::size_t ( exported_class_t::*toIndex_function_type )( ::std::vector< int > ) const;
+            typedef ::std::size_t ( exported_class_t::*toIndex_function_type )( ::std::vector< int > ) const;
             
             IntensityData_exposer.def( 
                 "toIndex"
diff --git a/Core/PythonAPI/src/ParameterPool.pypp.cpp b/Core/PythonAPI/src/ParameterPool.pypp.cpp
index 914cffcceb87c743ab97a780af190e5900711dce..88a890adef42f8d7457b59117ee8e8606bba2a3c 100644
--- a/Core/PythonAPI/src/ParameterPool.pypp.cpp
+++ b/Core/PythonAPI/src/ParameterPool.pypp.cpp
@@ -26,11 +26,11 @@ struct ParameterPool_wrapper : ParameterPool, bp::wrapper< ParameterPool > {
     virtual ::ParameterPool * clone(  ) const  {
         if( bp::override func_clone = this->get_override( "clone" ) )
             return func_clone(  );
-        else{
+        else
             return this->ParameterPool::clone(  );
-        }
     }
     
+    
     ::ParameterPool * default_clone(  ) const  {
         return ParameterPool::clone( );
     }
@@ -127,7 +127,7 @@ void register_ParameterPool_class(){
         }
         { //::ParameterPool::size
         
-            typedef ::size_t ( ::ParameterPool::*size_function_type )(  ) const;
+            typedef ::std::size_t ( ::ParameterPool::*size_function_type )(  ) const;
             
             ParameterPool_exposer.def( 
                 "size"
diff --git a/Core/PythonAPI/src/PythonModule.cpp b/Core/PythonAPI/src/PythonModule.cpp
index a398f4bb3f6acf338851e974ca1bb214fc3a3c05..08a156af7a1a338f156211529150fdf6c3a967c8 100644
--- a/Core/PythonAPI/src/PythonModule.cpp
+++ b/Core/PythonAPI/src/PythonModule.cpp
@@ -4,95 +4,95 @@
 #include "numpy/arrayobject.h"
 // the order of 3 guys above is important
 
-#include "AxisBin.pypp.h" 
-#include "AxisDouble.pypp.h" 
-#include "Beam.pypp.h" 
-#include "Bin1D.pypp.h" 
-#include "Bin1DCVector.pypp.h" 
-#include "Crystal.pypp.h" 
+#include "RotateZ_3D.pypp.h" 
+#include "IFTDistribution2D.pypp.h" 
 #include "Detector.pypp.h" 
-#include "FTDistribution2DCauchy.pypp.h" 
-#include "FormFactorBox.pypp.h" 
-#include "FormFactorCone.pypp.h" 
-#include "FormFactorCrystal.pypp.h" 
+#include "LatticeBasis.pypp.h" 
+#include "ParticleCoreShell.pypp.h" 
+#include "Beam.pypp.h" 
+#include "Lattice.pypp.h" 
 #include "FormFactorCylinder.pypp.h" 
-#include "FormFactorDecoratorDebyeWaller.pypp.h" 
-#include "FormFactorEllipsoid.pypp.h" 
-#include "FormFactorFullSphere.pypp.h" 
-#include "FormFactorFullSpheroid.pypp.h" 
-#include "FormFactorGauss.pypp.h" 
-#include "FormFactorHemiSpheroid.pypp.h" 
-#include "FormFactorLorentz.pypp.h" 
-#include "FormFactorParallelepiped.pypp.h" 
-#include "FormFactorPrism3.pypp.h" 
-#include "FormFactorPrism6.pypp.h" 
-#include "FormFactorPyramid.pypp.h" 
-#include "FormFactorSphere.pypp.h" 
-#include "FormFactorSphereGaussianRadius.pypp.h" 
+#include "ICloneable.pypp.h" 
+#include "StochasticSampledParameter.pypp.h" 
 #include "HomogeneousMaterial.pypp.h" 
+#include "vector_integer_t.pypp.h" 
+#include "AxisDouble.pypp.h" 
 #include "IAxis.pypp.h" 
-#include "ICloneable.pypp.h" 
-#include "IClusteredParticles.pypp.h" 
-#include "ICompositeSample.pypp.h" 
-#include "IDecoration.pypp.h" 
-#include "IDetectorResolution.pypp.h" 
-#include "IFTDistribution2D.pypp.h" 
+#include "Layer.pypp.h" 
 #include "IFormFactor.pypp.h" 
-#include "IFormFactorBorn.pypp.h" 
-#include "IFormFactorDecorator.pypp.h" 
-#include "IInterferenceFunction.pypp.h" 
-#include "IMaterial.pypp.h" 
 #include "IObservable.pypp.h" 
-#include "IObserver.pypp.h" 
-#include "IParameterized.pypp.h" 
-#include "IResolutionFunction2D.pypp.h" 
-#include "ISample.pypp.h" 
+#include "FormFactorParallelepiped.pypp.h" 
+#include "RealParameterWrapper.pypp.h" 
+#include "MaterialManager.pypp.h" 
+#include "ResolutionFunction2DSimple.pypp.h" 
+#include "SimulationParameters.pypp.h" 
+#include "AxisBin.pypp.h" 
+#include "FormFactorGauss.pypp.h" 
+#include "FormFactorFullSpheroid.pypp.h" 
+#include "PythonInterface_global_variables.pypp.h" 
 #include "ISampleBuilder.pypp.h" 
-#include "ISelectionRule.pypp.h" 
-#include "ITransform3D.pypp.h" 
-#include "Instrument.pypp.h" 
-#include "IntensityData.pypp.h" 
-#include "InterferenceFunction1DParaCrystal.pypp.h" 
+#include "StochasticParameter_t.pypp.h" 
+#include "StochasticDoubleGaussian.pypp.h" 
+#include "FormFactorPrism6.pypp.h" 
 #include "InterferenceFunction2DLattice.pypp.h" 
-#include "InterferenceFunction2DParaCrystal.pypp.h" 
-#include "InterferenceFunctionNone.pypp.h" 
-#include "Lattice.pypp.h" 
-#include "Lattice2DIFParameters.pypp.h" 
-#include "LatticeBasis.pypp.h" 
-#include "Layer.pypp.h" 
-#include "LayerInterface.pypp.h" 
-#include "LayerRoughness.pypp.h" 
-#include "MaterialManager.pypp.h" 
-#include "MesoCrystal.pypp.h" 
+#include "FormFactorPyramid.pypp.h" 
+#include "FormFactorBox.pypp.h" 
+#include "IResolutionFunction2D.pypp.h" 
+#include "IFormFactorBorn.pypp.h" 
 #include "MultiLayer.pypp.h" 
-#include "OutputDataIOFactory.pypp.h" 
+#include "ITransform3D.pypp.h" 
+#include "ParticleDecoration.pypp.h" 
+#include "IDecoration.pypp.h" 
+#include "FTDistribution2DCauchy.pypp.h" 
+#include "ICompositeSample.pypp.h" 
+#include "cvector_t.pypp.h" 
 #include "ParameterPool.pypp.h" 
 #include "Particle.pypp.h" 
-#include "ParticleBuilder.pypp.h" 
-#include "ParticleCoreShell.pypp.h" 
-#include "ParticleDecoration.pypp.h" 
+#include "FormFactorCone.pypp.h" 
+#include "FormFactorPrism3.pypp.h" 
+#include "InterferenceFunction2DParaCrystal.pypp.h" 
+#include "vdouble1d_t.pypp.h" 
+#include "MesoCrystal.pypp.h" 
+#include "RotateY_3D.pypp.h" 
+#include "FormFactorDecoratorDebyeWaller.pypp.h" 
+#include "vector_IFormFactorPtr_t.pypp.h" 
+#include "IMaterial.pypp.h" 
+#include "IFormFactorDecorator.pypp.h" 
+#include "Instrument.pypp.h" 
+#include "IDetectorResolution.pypp.h" 
+#include "ISelectionRule.pypp.h" 
+#include "Bin1D.pypp.h" 
 #include "ParticleInfo.pypp.h" 
+#include "vector_longinteger_t.pypp.h" 
+#include "FormFactorHemiSpheroid.pypp.h" 
+#include "LayerInterface.pypp.h" 
+#include "FormFactorFullSphere.pypp.h" 
 #include "PositionParticleInfo.pypp.h" 
-#include "PythonInterface_free_functions.pypp.h" 
-#include "PythonInterface_global_variables.pypp.h" 
-#include "RealParameterWrapper.pypp.h" 
-#include "ResolutionFunction2DSimple.pypp.h" 
-#include "RotateY_3D.pypp.h" 
-#include "RotateZ_3D.pypp.h" 
-#include "SimpleSelectionRule.pypp.h" 
-#include "Simulation.pypp.h" 
-#include "SimulationParameters.pypp.h" 
+#include "LayerRoughness.pypp.h" 
+#include "FormFactorCrystal.pypp.h" 
+#include "IntensityData.pypp.h" 
+#include "IParameterized.pypp.h" 
+#include "Bin1DCVector.pypp.h" 
 #include "StochasticDoubleGate.pypp.h" 
-#include "StochasticDoubleGaussian.pypp.h" 
-#include "StochasticParameter_t.pypp.h" 
-#include "StochasticSampledParameter.pypp.h" 
-#include "cvector_t.pypp.h" 
-#include "kvector_t.pypp.h" 
-#include "vdouble1d_t.pypp.h" 
-#include "vector_IFormFactorPtr_t.pypp.h" 
-#include "vector_integer_t.pypp.h" 
+#include "IClusteredParticles.pypp.h" 
+#include "IInterferenceFunction.pypp.h" 
+#include "SimpleSelectionRule.pypp.h" 
+#include "FormFactorLorentz.pypp.h" 
+#include "OutputDataIOFactory.pypp.h" 
 #include "vector_kvector_t.pypp.h" 
-#include "vector_longinteger_t.pypp.h" 
+#include "InterferenceFunction1DParaCrystal.pypp.h" 
+#include "InterferenceFunctionNone.pypp.h" 
+#include "Crystal.pypp.h" 
+#include "PythonInterface_free_functions.pypp.h" 
+#include "kvector_t.pypp.h" 
+#include "FormFactorEllipsoid.pypp.h" 
+#include "Simulation.pypp.h" 
+#include "ISample.pypp.h" 
+#include "IObserver.pypp.h" 
+#include "ParticleBuilder.pypp.h" 
+#include "FormFactorSphereGaussianRadius.pypp.h" 
+#include "Lattice2DIFParameters.pypp.h" 
+#include "FormFactorSphere.pypp.h" 
 #include "__call_policies.pypp.hpp" 
 #include "__convenience.pypp.hpp" 
 
diff --git a/Core/PythonAPI/src/RotateY_3D.pypp.cpp b/Core/PythonAPI/src/RotateY_3D.pypp.cpp
index aa59091d230fad26d5946f570fbe1e9c967a4585..97710288431fce6ba71b8760dfdb48c005e68652 100644
--- a/Core/PythonAPI/src/RotateY_3D.pypp.cpp
+++ b/Core/PythonAPI/src/RotateY_3D.pypp.cpp
@@ -33,11 +33,11 @@ struct RotateY_3D_wrapper : Geometry::RotateY_3D, bp::wrapper< Geometry::RotateY
     virtual ::Geometry::RotateY_3D * clone(  ) const  {
         if( bp::override func_clone = this->get_override( "clone" ) )
             return func_clone(  );
-        else{
+        else
             return this->Geometry::RotateY_3D::clone(  );
-        }
     }
     
+    
     ::Geometry::RotateY_3D * default_clone(  ) const  {
         return Geometry::RotateY_3D::clone( );
     }
@@ -45,11 +45,11 @@ struct RotateY_3D_wrapper : Geometry::RotateY_3D, bp::wrapper< Geometry::RotateY
     virtual void print( ::std::ostream & ostr ) const  {
         if( bp::override func_print = this->get_override( "print" ) )
             func_print( boost::ref(ostr) );
-        else{
+        else
             this->Geometry::RotateY_3D::print( boost::ref(ostr) );
-        }
     }
     
+    
     void default_print( ::std::ostream & ostr ) const  {
         Geometry::RotateY_3D::print( boost::ref(ostr) );
     }
diff --git a/Core/PythonAPI/src/RotateZ_3D.pypp.cpp b/Core/PythonAPI/src/RotateZ_3D.pypp.cpp
index 6fa2018db5c7ea988de5acc358e3bf8e7e4e786a..e2cbeda26e50a2dfe449fd6a76a10beecd83cbdc 100644
--- a/Core/PythonAPI/src/RotateZ_3D.pypp.cpp
+++ b/Core/PythonAPI/src/RotateZ_3D.pypp.cpp
@@ -33,11 +33,11 @@ struct RotateZ_3D_wrapper : Geometry::RotateZ_3D, bp::wrapper< Geometry::RotateZ
     virtual ::Geometry::RotateZ_3D * clone(  ) const  {
         if( bp::override func_clone = this->get_override( "clone" ) )
             return func_clone(  );
-        else{
+        else
             return this->Geometry::RotateZ_3D::clone(  );
-        }
     }
     
+    
     ::Geometry::RotateZ_3D * default_clone(  ) const  {
         return Geometry::RotateZ_3D::clone( );
     }
@@ -45,11 +45,11 @@ struct RotateZ_3D_wrapper : Geometry::RotateZ_3D, bp::wrapper< Geometry::RotateZ
     virtual void print( ::std::ostream & ostr ) const  {
         if( bp::override func_print = this->get_override( "print" ) )
             func_print( boost::ref(ostr) );
-        else{
+        else
             this->Geometry::RotateZ_3D::print( boost::ref(ostr) );
-        }
     }
     
+    
     void default_print( ::std::ostream & ostr ) const  {
         Geometry::RotateZ_3D::print( boost::ref(ostr) );
     }
diff --git a/Core/PythonAPI/src/SimpleSelectionRule.pypp.cpp b/Core/PythonAPI/src/SimpleSelectionRule.pypp.cpp
index cb07c7da7f228d0ed0627c2ad86dc6ba479e1229..b66737013bbb60b02e5b57ca8a9ffcc1cd795f14 100644
--- a/Core/PythonAPI/src/SimpleSelectionRule.pypp.cpp
+++ b/Core/PythonAPI/src/SimpleSelectionRule.pypp.cpp
@@ -33,11 +33,11 @@ struct SimpleSelectionRule_wrapper : SimpleSelectionRule, bp::wrapper< SimpleSel
     virtual ::SimpleSelectionRule * clone(  ) const  {
         if( bp::override func_clone = this->get_override( "clone" ) )
             return func_clone(  );
-        else{
+        else
             return this->SimpleSelectionRule::clone(  );
-        }
     }
     
+    
     ::SimpleSelectionRule * default_clone(  ) const  {
         return SimpleSelectionRule::clone( );
     }
@@ -45,11 +45,11 @@ struct SimpleSelectionRule_wrapper : SimpleSelectionRule, bp::wrapper< SimpleSel
     virtual bool coordinateSelected( ::IndexVector3D const & coordinate ) const  {
         if( bp::override func_coordinateSelected = this->get_override( "coordinateSelected" ) )
             return func_coordinateSelected( boost::ref(coordinate) );
-        else{
+        else
             return this->SimpleSelectionRule::coordinateSelected( boost::ref(coordinate) );
-        }
     }
     
+    
     bool default_coordinateSelected( ::IndexVector3D const & coordinate ) const  {
         return SimpleSelectionRule::coordinateSelected( boost::ref(coordinate) );
     }
diff --git a/Core/PythonAPI/src/StochasticDoubleGate.pypp.cpp b/Core/PythonAPI/src/StochasticDoubleGate.pypp.cpp
index ea0d2bcc00b58e26f953ab1f8c5b8d497e51565b..a2c2e6ca95bf639e8c92a7e2947e72283af1c1eb 100644
--- a/Core/PythonAPI/src/StochasticDoubleGate.pypp.cpp
+++ b/Core/PythonAPI/src/StochasticDoubleGate.pypp.cpp
@@ -26,11 +26,11 @@ struct StochasticDoubleGate_wrapper : StochasticDoubleGate, bp::wrapper< Stochas
     virtual ::StochasticDoubleGate * clone(  ) const  {
         if( bp::override func_clone = this->get_override( "clone" ) )
             return func_clone(  );
-        else{
+        else
             return this->StochasticDoubleGate::clone(  );
-        }
     }
     
+    
     ::StochasticDoubleGate * default_clone(  ) const  {
         return StochasticDoubleGate::clone( );
     }
@@ -38,11 +38,11 @@ struct StochasticDoubleGate_wrapper : StochasticDoubleGate, bp::wrapper< Stochas
     virtual double getFWHM(  ) const  {
         if( bp::override func_getFWHM = this->get_override( "getFWHM" ) )
             return func_getFWHM(  );
-        else{
+        else
             return this->StochasticDoubleGate::getFWHM(  );
-        }
     }
     
+    
     double default_getFWHM(  ) const  {
         return StochasticDoubleGate::getFWHM( );
     }
@@ -50,11 +50,11 @@ struct StochasticDoubleGate_wrapper : StochasticDoubleGate, bp::wrapper< Stochas
     virtual double probabilityDensity( double value ) const  {
         if( bp::override func_probabilityDensity = this->get_override( "probabilityDensity" ) )
             return func_probabilityDensity( value );
-        else{
+        else
             return this->StochasticDoubleGate::probabilityDensity( value );
-        }
     }
     
+    
     double default_probabilityDensity( double value ) const  {
         return StochasticDoubleGate::probabilityDensity( value );
     }
@@ -62,11 +62,11 @@ struct StochasticDoubleGate_wrapper : StochasticDoubleGate, bp::wrapper< Stochas
     virtual void setToRandom(  ) {
         if( bp::override func_setToRandom = this->get_override( "setToRandom" ) )
             func_setToRandom(  );
-        else{
+        else
             this->StochasticDoubleGate::setToRandom(  );
-        }
     }
     
+    
     void default_setToRandom(  ) {
         StochasticDoubleGate::setToRandom( );
     }
@@ -74,11 +74,11 @@ struct StochasticDoubleGate_wrapper : StochasticDoubleGate, bp::wrapper< Stochas
     virtual double getRandom(  ) {
         if( bp::override func_getRandom = this->get_override( "getRandom" ) )
             return func_getRandom(  );
-        else{
+        else
             return this->StochasticParameter< double >::getRandom(  );
-        }
     }
     
+    
     double default_getRandom(  ) {
         return StochasticParameter< double >::getRandom( );
     }
@@ -86,11 +86,11 @@ struct StochasticDoubleGate_wrapper : StochasticDoubleGate, bp::wrapper< Stochas
     virtual void setToAverage(  ) {
         if( bp::override func_setToAverage = this->get_override( "setToAverage" ) )
             func_setToAverage(  );
-        else{
+        else
             this->StochasticParameter< double >::setToAverage(  );
-        }
     }
     
+    
     void default_setToAverage(  ) {
         StochasticParameter< double >::setToAverage( );
     }
diff --git a/Core/PythonAPI/src/StochasticDoubleGaussian.pypp.cpp b/Core/PythonAPI/src/StochasticDoubleGaussian.pypp.cpp
index 820e29c3e451eda7af03306e5dd63852ca7c9913..ec0bb290500ff2041944e8335e9be278491390af 100644
--- a/Core/PythonAPI/src/StochasticDoubleGaussian.pypp.cpp
+++ b/Core/PythonAPI/src/StochasticDoubleGaussian.pypp.cpp
@@ -26,11 +26,11 @@ struct StochasticDoubleGaussian_wrapper : StochasticDoubleGaussian, bp::wrapper<
     virtual ::StochasticDoubleGaussian * clone(  ) const  {
         if( bp::override func_clone = this->get_override( "clone" ) )
             return func_clone(  );
-        else{
+        else
             return this->StochasticDoubleGaussian::clone(  );
-        }
     }
     
+    
     ::StochasticDoubleGaussian * default_clone(  ) const  {
         return StochasticDoubleGaussian::clone( );
     }
@@ -38,11 +38,11 @@ struct StochasticDoubleGaussian_wrapper : StochasticDoubleGaussian, bp::wrapper<
     virtual double getFWHM(  ) const  {
         if( bp::override func_getFWHM = this->get_override( "getFWHM" ) )
             return func_getFWHM(  );
-        else{
+        else
             return this->StochasticDoubleGaussian::getFWHM(  );
-        }
     }
     
+    
     double default_getFWHM(  ) const  {
         return StochasticDoubleGaussian::getFWHM( );
     }
@@ -50,11 +50,11 @@ struct StochasticDoubleGaussian_wrapper : StochasticDoubleGaussian, bp::wrapper<
     virtual double probabilityDensity( double value ) const  {
         if( bp::override func_probabilityDensity = this->get_override( "probabilityDensity" ) )
             return func_probabilityDensity( value );
-        else{
+        else
             return this->StochasticDoubleGaussian::probabilityDensity( value );
-        }
     }
     
+    
     double default_probabilityDensity( double value ) const  {
         return StochasticDoubleGaussian::probabilityDensity( value );
     }
@@ -62,11 +62,11 @@ struct StochasticDoubleGaussian_wrapper : StochasticDoubleGaussian, bp::wrapper<
     virtual void setToRandom(  ) {
         if( bp::override func_setToRandom = this->get_override( "setToRandom" ) )
             func_setToRandom(  );
-        else{
+        else
             this->StochasticDoubleGaussian::setToRandom(  );
-        }
     }
     
+    
     void default_setToRandom(  ) {
         StochasticDoubleGaussian::setToRandom( );
     }
@@ -74,11 +74,11 @@ struct StochasticDoubleGaussian_wrapper : StochasticDoubleGaussian, bp::wrapper<
     virtual double getRandom(  ) {
         if( bp::override func_getRandom = this->get_override( "getRandom" ) )
             return func_getRandom(  );
-        else{
+        else
             return this->StochasticParameter< double >::getRandom(  );
-        }
     }
     
+    
     double default_getRandom(  ) {
         return StochasticParameter< double >::getRandom( );
     }
@@ -86,11 +86,11 @@ struct StochasticDoubleGaussian_wrapper : StochasticDoubleGaussian, bp::wrapper<
     virtual void setToAverage(  ) {
         if( bp::override func_setToAverage = this->get_override( "setToAverage" ) )
             func_setToAverage(  );
-        else{
+        else
             this->StochasticParameter< double >::setToAverage(  );
-        }
     }
     
+    
     void default_setToAverage(  ) {
         StochasticParameter< double >::setToAverage( );
     }
diff --git a/Core/PythonAPI/src/StochasticParameter_t.pypp.cpp b/Core/PythonAPI/src/StochasticParameter_t.pypp.cpp
index 1c7f4060708c9de5ed217052a0046dc0d45ae2ba..e6cd435ac44605b2a56bb0a5ef8f60d430c7f15d 100644
--- a/Core/PythonAPI/src/StochasticParameter_t.pypp.cpp
+++ b/Core/PythonAPI/src/StochasticParameter_t.pypp.cpp
@@ -31,11 +31,11 @@ struct StochasticParameter_less__double__greater__wrapper : StochasticParameter<
     virtual double getFWHM(  ) const  {
         if( bp::override func_getFWHM = this->get_override( "getFWHM" ) )
             return func_getFWHM(  );
-        else{
+        else
             return this->StochasticParameter< double >::getFWHM(  );
-        }
     }
     
+    
     double default_getFWHM(  ) const  {
         return StochasticParameter< double >::getFWHM( );
     }
@@ -43,11 +43,11 @@ struct StochasticParameter_less__double__greater__wrapper : StochasticParameter<
     virtual double getRandom(  ) {
         if( bp::override func_getRandom = this->get_override( "getRandom" ) )
             return func_getRandom(  );
-        else{
+        else
             return this->StochasticParameter< double >::getRandom(  );
-        }
     }
     
+    
     double default_getRandom(  ) {
         return StochasticParameter< double >::getRandom( );
     }
@@ -60,11 +60,11 @@ struct StochasticParameter_less__double__greater__wrapper : StochasticParameter<
     virtual void setToAverage(  ) {
         if( bp::override func_setToAverage = this->get_override( "setToAverage" ) )
             func_setToAverage(  );
-        else{
+        else
             this->StochasticParameter< double >::setToAverage(  );
-        }
     }
     
+    
     void default_setToAverage(  ) {
         StochasticParameter< double >::setToAverage( );
     }
diff --git a/Core/PythonAPI/src/StochasticSampledParameter.pypp.cpp b/Core/PythonAPI/src/StochasticSampledParameter.pypp.cpp
index 26fc062960c37ebca48c2c814e930d4a27534734..6868e315885f63e6e03aec579237a42e2dde5cfc 100644
--- a/Core/PythonAPI/src/StochasticSampledParameter.pypp.cpp
+++ b/Core/PythonAPI/src/StochasticSampledParameter.pypp.cpp
@@ -16,14 +16,14 @@ namespace bp = boost::python;
 
 struct StochasticSampledParameter_wrapper : StochasticSampledParameter, bp::wrapper< StochasticSampledParameter > {
 
-    StochasticSampledParameter_wrapper(::StochasticParameter< double > const & par, ::size_t nbins, double xmin, double xmax )
+    StochasticSampledParameter_wrapper(::StochasticParameter< double > const & par, ::std::size_t nbins, double xmin, double xmax )
     : StochasticSampledParameter( boost::ref(par), nbins, xmin, xmax )
       , bp::wrapper< StochasticSampledParameter >(){
         // constructor
     
     }
 
-    StochasticSampledParameter_wrapper(::StochasticParameter< double > const & par, ::size_t nbins, int nfwhm=3 )
+    StochasticSampledParameter_wrapper(::StochasticParameter< double > const & par, ::std::size_t nbins, int nfwhm=3 )
     : StochasticSampledParameter( boost::ref(par), nbins, nfwhm )
       , bp::wrapper< StochasticSampledParameter >(){
         // constructor
@@ -33,11 +33,11 @@ struct StochasticSampledParameter_wrapper : StochasticSampledParameter, bp::wrap
     virtual ::StochasticSampledParameter * clone(  ) const  {
         if( bp::override func_clone = this->get_override( "clone" ) )
             return func_clone(  );
-        else{
+        else
             return this->StochasticSampledParameter::clone(  );
-        }
     }
     
+    
     ::StochasticSampledParameter * default_clone(  ) const  {
         return StochasticSampledParameter::clone( );
     }
@@ -45,11 +45,11 @@ struct StochasticSampledParameter_wrapper : StochasticSampledParameter, bp::wrap
     virtual double probabilityDensity( double value ) const  {
         if( bp::override func_probabilityDensity = this->get_override( "probabilityDensity" ) )
             return func_probabilityDensity( value );
-        else{
+        else
             return this->StochasticSampledParameter::probabilityDensity( value );
-        }
     }
     
+    
     double default_probabilityDensity( double value ) const  {
         return StochasticSampledParameter::probabilityDensity( value );
     }
@@ -57,11 +57,11 @@ struct StochasticSampledParameter_wrapper : StochasticSampledParameter, bp::wrap
     virtual void setToRandom(  ) {
         if( bp::override func_setToRandom = this->get_override( "setToRandom" ) )
             func_setToRandom(  );
-        else{
+        else
             this->StochasticSampledParameter::setToRandom(  );
-        }
     }
     
+    
     void default_setToRandom(  ) {
         StochasticSampledParameter::setToRandom( );
     }
@@ -69,11 +69,11 @@ struct StochasticSampledParameter_wrapper : StochasticSampledParameter, bp::wrap
     virtual double getFWHM(  ) const  {
         if( bp::override func_getFWHM = this->get_override( "getFWHM" ) )
             return func_getFWHM(  );
-        else{
+        else
             return this->StochasticParameter< double >::getFWHM(  );
-        }
     }
     
+    
     double default_getFWHM(  ) const  {
         return StochasticParameter< double >::getFWHM( );
     }
@@ -81,11 +81,11 @@ struct StochasticSampledParameter_wrapper : StochasticSampledParameter, bp::wrap
     virtual double getRandom(  ) {
         if( bp::override func_getRandom = this->get_override( "getRandom" ) )
             return func_getRandom(  );
-        else{
+        else
             return this->StochasticParameter< double >::getRandom(  );
-        }
     }
     
+    
     double default_getRandom(  ) {
         return StochasticParameter< double >::getRandom( );
     }
@@ -93,11 +93,11 @@ struct StochasticSampledParameter_wrapper : StochasticSampledParameter, bp::wrap
     virtual void setToAverage(  ) {
         if( bp::override func_setToAverage = this->get_override( "setToAverage" ) )
             func_setToAverage(  );
-        else{
+        else
             this->StochasticParameter< double >::setToAverage(  );
-        }
     }
     
+    
     void default_setToAverage(  ) {
         StochasticParameter< double >::setToAverage( );
     }
@@ -108,9 +108,9 @@ void register_StochasticSampledParameter_class(){
 
     { //::StochasticSampledParameter
         typedef bp::class_< StochasticSampledParameter_wrapper, bp::bases< StochasticParameter< double > >, boost::noncopyable > StochasticSampledParameter_exposer_t;
-        StochasticSampledParameter_exposer_t StochasticSampledParameter_exposer = StochasticSampledParameter_exposer_t( "StochasticSampledParameter", bp::init< StochasticParameter< double > const &, size_t, double, double >(( bp::arg("par"), bp::arg("nbins"), bp::arg("xmin"), bp::arg("xmax") )) );
+        StochasticSampledParameter_exposer_t StochasticSampledParameter_exposer = StochasticSampledParameter_exposer_t( "StochasticSampledParameter", bp::init< StochasticParameter< double > const &, std::size_t, double, double >(( bp::arg("par"), bp::arg("nbins"), bp::arg("xmin"), bp::arg("xmax") )) );
         bp::scope StochasticSampledParameter_scope( StochasticSampledParameter_exposer );
-        StochasticSampledParameter_exposer.def( bp::init< StochasticParameter< double > const &, size_t, bp::optional< int > >(( bp::arg("par"), bp::arg("nbins"), bp::arg("nfwhm")=(int)(3) )) );
+        StochasticSampledParameter_exposer.def( bp::init< StochasticParameter< double > const &, std::size_t, bp::optional< int > >(( bp::arg("par"), bp::arg("nbins"), bp::arg("nfwhm")=(int)(3) )) );
         { //::StochasticSampledParameter::clone
         
             typedef ::StochasticSampledParameter * ( ::StochasticSampledParameter::*clone_function_type )(  ) const;
@@ -125,7 +125,7 @@ void register_StochasticSampledParameter_class(){
         }
         { //::StochasticSampledParameter::getBinValue
         
-            typedef double ( ::StochasticSampledParameter::*getBinValue_function_type )( ::size_t ) const;
+            typedef double ( ::StochasticSampledParameter::*getBinValue_function_type )( ::std::size_t ) const;
             
             StochasticSampledParameter_exposer.def( 
                 "getBinValue"
@@ -135,7 +135,7 @@ void register_StochasticSampledParameter_class(){
         }
         { //::StochasticSampledParameter::getNbins
         
-            typedef ::size_t ( ::StochasticSampledParameter::*getNbins_function_type )(  ) const;
+            typedef ::std::size_t ( ::StochasticSampledParameter::*getNbins_function_type )(  ) const;
             
             StochasticSampledParameter_exposer.def( 
                 "getNbins"
@@ -144,7 +144,7 @@ void register_StochasticSampledParameter_class(){
         }
         { //::StochasticSampledParameter::getNormalizedProbability
         
-            typedef double ( ::StochasticSampledParameter::*getNormalizedProbability_function_type )( ::size_t ) const;
+            typedef double ( ::StochasticSampledParameter::*getNormalizedProbability_function_type )( ::std::size_t ) const;
             
             StochasticSampledParameter_exposer.def( 
                 "getNormalizedProbability"
@@ -154,7 +154,7 @@ void register_StochasticSampledParameter_class(){
         }
         { //::StochasticSampledParameter::probabilityBinDensity
         
-            typedef double ( ::StochasticSampledParameter::*probabilityBinDensity_function_type )( ::size_t ) const;
+            typedef double ( ::StochasticSampledParameter::*probabilityBinDensity_function_type )( ::std::size_t ) const;
             
             StochasticSampledParameter_exposer.def( 
                 "probabilityBinDensity"
diff --git a/Core/python_module.pri b/Core/python_module.pri
index 6546e3ba35a630a6614ba116c853f8c73b4f51fe..ad5fb6536af69ef782ab7839ea80369e6fcf1c80 100644
--- a/Core/python_module.pri
+++ b/Core/python_module.pri
@@ -4,95 +4,95 @@ HEADERS +=  \
     PythonAPI/inc/PythonOutputData.h \ 
     PythonAPI/inc/PythonCoreExposer.h \ 
     PythonAPI/inc/PythonCoreList.h \ 
-    PythonAPI/inc/AxisBin.pypp.h \
-    PythonAPI/inc/AxisDouble.pypp.h \
-    PythonAPI/inc/Beam.pypp.h \
-    PythonAPI/inc/Bin1D.pypp.h \
-    PythonAPI/inc/Bin1DCVector.pypp.h \
-    PythonAPI/inc/Crystal.pypp.h \
+    PythonAPI/inc/RotateZ_3D.pypp.h \
+    PythonAPI/inc/IFTDistribution2D.pypp.h \
     PythonAPI/inc/Detector.pypp.h \
-    PythonAPI/inc/FTDistribution2DCauchy.pypp.h \
-    PythonAPI/inc/FormFactorBox.pypp.h \
-    PythonAPI/inc/FormFactorCone.pypp.h \
-    PythonAPI/inc/FormFactorCrystal.pypp.h \
+    PythonAPI/inc/LatticeBasis.pypp.h \
+    PythonAPI/inc/ParticleCoreShell.pypp.h \
+    PythonAPI/inc/Beam.pypp.h \
+    PythonAPI/inc/Lattice.pypp.h \
     PythonAPI/inc/FormFactorCylinder.pypp.h \
-    PythonAPI/inc/FormFactorDecoratorDebyeWaller.pypp.h \
-    PythonAPI/inc/FormFactorEllipsoid.pypp.h \
-    PythonAPI/inc/FormFactorFullSphere.pypp.h \
-    PythonAPI/inc/FormFactorFullSpheroid.pypp.h \
-    PythonAPI/inc/FormFactorGauss.pypp.h \
-    PythonAPI/inc/FormFactorHemiSpheroid.pypp.h \
-    PythonAPI/inc/FormFactorLorentz.pypp.h \
-    PythonAPI/inc/FormFactorParallelepiped.pypp.h \
-    PythonAPI/inc/FormFactorPrism3.pypp.h \
-    PythonAPI/inc/FormFactorPrism6.pypp.h \
-    PythonAPI/inc/FormFactorPyramid.pypp.h \
-    PythonAPI/inc/FormFactorSphere.pypp.h \
-    PythonAPI/inc/FormFactorSphereGaussianRadius.pypp.h \
+    PythonAPI/inc/ICloneable.pypp.h \
+    PythonAPI/inc/StochasticSampledParameter.pypp.h \
     PythonAPI/inc/HomogeneousMaterial.pypp.h \
+    PythonAPI/inc/vector_integer_t.pypp.h \
+    PythonAPI/inc/AxisDouble.pypp.h \
     PythonAPI/inc/IAxis.pypp.h \
-    PythonAPI/inc/ICloneable.pypp.h \
-    PythonAPI/inc/IClusteredParticles.pypp.h \
-    PythonAPI/inc/ICompositeSample.pypp.h \
-    PythonAPI/inc/IDecoration.pypp.h \
-    PythonAPI/inc/IDetectorResolution.pypp.h \
-    PythonAPI/inc/IFTDistribution2D.pypp.h \
+    PythonAPI/inc/Layer.pypp.h \
     PythonAPI/inc/IFormFactor.pypp.h \
-    PythonAPI/inc/IFormFactorBorn.pypp.h \
-    PythonAPI/inc/IFormFactorDecorator.pypp.h \
-    PythonAPI/inc/IInterferenceFunction.pypp.h \
-    PythonAPI/inc/IMaterial.pypp.h \
     PythonAPI/inc/IObservable.pypp.h \
-    PythonAPI/inc/IObserver.pypp.h \
-    PythonAPI/inc/IParameterized.pypp.h \
-    PythonAPI/inc/IResolutionFunction2D.pypp.h \
-    PythonAPI/inc/ISample.pypp.h \
+    PythonAPI/inc/FormFactorParallelepiped.pypp.h \
+    PythonAPI/inc/RealParameterWrapper.pypp.h \
+    PythonAPI/inc/MaterialManager.pypp.h \
+    PythonAPI/inc/ResolutionFunction2DSimple.pypp.h \
+    PythonAPI/inc/SimulationParameters.pypp.h \
+    PythonAPI/inc/AxisBin.pypp.h \
+    PythonAPI/inc/FormFactorGauss.pypp.h \
+    PythonAPI/inc/FormFactorFullSpheroid.pypp.h \
+    PythonAPI/inc/PythonInterface_global_variables.pypp.h \
     PythonAPI/inc/ISampleBuilder.pypp.h \
-    PythonAPI/inc/ISelectionRule.pypp.h \
-    PythonAPI/inc/ITransform3D.pypp.h \
-    PythonAPI/inc/Instrument.pypp.h \
-    PythonAPI/inc/IntensityData.pypp.h \
-    PythonAPI/inc/InterferenceFunction1DParaCrystal.pypp.h \
+    PythonAPI/inc/StochasticParameter_t.pypp.h \
+    PythonAPI/inc/StochasticDoubleGaussian.pypp.h \
+    PythonAPI/inc/FormFactorPrism6.pypp.h \
     PythonAPI/inc/InterferenceFunction2DLattice.pypp.h \
-    PythonAPI/inc/InterferenceFunction2DParaCrystal.pypp.h \
-    PythonAPI/inc/InterferenceFunctionNone.pypp.h \
-    PythonAPI/inc/Lattice.pypp.h \
-    PythonAPI/inc/Lattice2DIFParameters.pypp.h \
-    PythonAPI/inc/LatticeBasis.pypp.h \
-    PythonAPI/inc/Layer.pypp.h \
-    PythonAPI/inc/LayerInterface.pypp.h \
-    PythonAPI/inc/LayerRoughness.pypp.h \
-    PythonAPI/inc/MaterialManager.pypp.h \
-    PythonAPI/inc/MesoCrystal.pypp.h \
+    PythonAPI/inc/FormFactorPyramid.pypp.h \
+    PythonAPI/inc/FormFactorBox.pypp.h \
+    PythonAPI/inc/IResolutionFunction2D.pypp.h \
+    PythonAPI/inc/IFormFactorBorn.pypp.h \
     PythonAPI/inc/MultiLayer.pypp.h \
-    PythonAPI/inc/OutputDataIOFactory.pypp.h \
+    PythonAPI/inc/ITransform3D.pypp.h \
+    PythonAPI/inc/ParticleDecoration.pypp.h \
+    PythonAPI/inc/IDecoration.pypp.h \
+    PythonAPI/inc/FTDistribution2DCauchy.pypp.h \
+    PythonAPI/inc/ICompositeSample.pypp.h \
+    PythonAPI/inc/cvector_t.pypp.h \
     PythonAPI/inc/ParameterPool.pypp.h \
     PythonAPI/inc/Particle.pypp.h \
-    PythonAPI/inc/ParticleBuilder.pypp.h \
-    PythonAPI/inc/ParticleCoreShell.pypp.h \
-    PythonAPI/inc/ParticleDecoration.pypp.h \
+    PythonAPI/inc/FormFactorCone.pypp.h \
+    PythonAPI/inc/FormFactorPrism3.pypp.h \
+    PythonAPI/inc/InterferenceFunction2DParaCrystal.pypp.h \
+    PythonAPI/inc/vdouble1d_t.pypp.h \
+    PythonAPI/inc/MesoCrystal.pypp.h \
+    PythonAPI/inc/RotateY_3D.pypp.h \
+    PythonAPI/inc/FormFactorDecoratorDebyeWaller.pypp.h \
+    PythonAPI/inc/vector_IFormFactorPtr_t.pypp.h \
+    PythonAPI/inc/IMaterial.pypp.h \
+    PythonAPI/inc/IFormFactorDecorator.pypp.h \
+    PythonAPI/inc/Instrument.pypp.h \
+    PythonAPI/inc/IDetectorResolution.pypp.h \
+    PythonAPI/inc/ISelectionRule.pypp.h \
+    PythonAPI/inc/Bin1D.pypp.h \
     PythonAPI/inc/ParticleInfo.pypp.h \
+    PythonAPI/inc/vector_longinteger_t.pypp.h \
+    PythonAPI/inc/FormFactorHemiSpheroid.pypp.h \
+    PythonAPI/inc/LayerInterface.pypp.h \
+    PythonAPI/inc/FormFactorFullSphere.pypp.h \
     PythonAPI/inc/PositionParticleInfo.pypp.h \
-    PythonAPI/inc/PythonInterface_free_functions.pypp.h \
-    PythonAPI/inc/PythonInterface_global_variables.pypp.h \
-    PythonAPI/inc/RealParameterWrapper.pypp.h \
-    PythonAPI/inc/ResolutionFunction2DSimple.pypp.h \
-    PythonAPI/inc/RotateY_3D.pypp.h \
-    PythonAPI/inc/RotateZ_3D.pypp.h \
-    PythonAPI/inc/SimpleSelectionRule.pypp.h \
-    PythonAPI/inc/Simulation.pypp.h \
-    PythonAPI/inc/SimulationParameters.pypp.h \
+    PythonAPI/inc/LayerRoughness.pypp.h \
+    PythonAPI/inc/FormFactorCrystal.pypp.h \
+    PythonAPI/inc/IntensityData.pypp.h \
+    PythonAPI/inc/IParameterized.pypp.h \
+    PythonAPI/inc/Bin1DCVector.pypp.h \
     PythonAPI/inc/StochasticDoubleGate.pypp.h \
-    PythonAPI/inc/StochasticDoubleGaussian.pypp.h \
-    PythonAPI/inc/StochasticParameter_t.pypp.h \
-    PythonAPI/inc/StochasticSampledParameter.pypp.h \
-    PythonAPI/inc/cvector_t.pypp.h \
-    PythonAPI/inc/kvector_t.pypp.h \
-    PythonAPI/inc/vdouble1d_t.pypp.h \
-    PythonAPI/inc/vector_IFormFactorPtr_t.pypp.h \
-    PythonAPI/inc/vector_integer_t.pypp.h \
+    PythonAPI/inc/IClusteredParticles.pypp.h \
+    PythonAPI/inc/IInterferenceFunction.pypp.h \
+    PythonAPI/inc/SimpleSelectionRule.pypp.h \
+    PythonAPI/inc/FormFactorLorentz.pypp.h \
+    PythonAPI/inc/OutputDataIOFactory.pypp.h \
     PythonAPI/inc/vector_kvector_t.pypp.h \
-    PythonAPI/inc/vector_longinteger_t.pypp.h \
+    PythonAPI/inc/InterferenceFunction1DParaCrystal.pypp.h \
+    PythonAPI/inc/InterferenceFunctionNone.pypp.h \
+    PythonAPI/inc/Crystal.pypp.h \
+    PythonAPI/inc/PythonInterface_free_functions.pypp.h \
+    PythonAPI/inc/kvector_t.pypp.h \
+    PythonAPI/inc/FormFactorEllipsoid.pypp.h \
+    PythonAPI/inc/Simulation.pypp.h \
+    PythonAPI/inc/ISample.pypp.h \
+    PythonAPI/inc/IObserver.pypp.h \
+    PythonAPI/inc/ParticleBuilder.pypp.h \
+    PythonAPI/inc/FormFactorSphereGaussianRadius.pypp.h \
+    PythonAPI/inc/Lattice2DIFParameters.pypp.h \
+    PythonAPI/inc/FormFactorSphere.pypp.h \
     PythonAPI/inc/__call_policies.pypp.hpp \
     PythonAPI/inc/__convenience.pypp.hpp 
 
@@ -100,95 +100,95 @@ SOURCES +=  \
     PythonAPI/src/PythonModule.cpp \ 
     PythonAPI/src/PythonListConverter.cpp \ 
     PythonAPI/src/PythonOutputData.cpp \ 
-    PythonAPI/src/AxisBin.pypp.cpp \
-    PythonAPI/src/AxisDouble.pypp.cpp \
-    PythonAPI/src/Beam.pypp.cpp \
-    PythonAPI/src/Bin1D.pypp.cpp \
-    PythonAPI/src/Bin1DCVector.pypp.cpp \
-    PythonAPI/src/Crystal.pypp.cpp \
-    PythonAPI/src/Detector.pypp.cpp \
-    PythonAPI/src/FTDistribution2DCauchy.pypp.cpp \
-    PythonAPI/src/FormFactorBox.pypp.cpp \
-    PythonAPI/src/FormFactorCone.pypp.cpp \
-    PythonAPI/src/FormFactorCrystal.pypp.cpp \
-    PythonAPI/src/FormFactorCylinder.pypp.cpp \
-    PythonAPI/src/FormFactorDecoratorDebyeWaller.pypp.cpp \
-    PythonAPI/src/FormFactorEllipsoid.pypp.cpp \
-    PythonAPI/src/FormFactorFullSphere.pypp.cpp \
-    PythonAPI/src/FormFactorFullSpheroid.pypp.cpp \
-    PythonAPI/src/FormFactorGauss.pypp.cpp \
-    PythonAPI/src/FormFactorHemiSpheroid.pypp.cpp \
+    PythonAPI/src/ParticleCoreShell.pypp.cpp \
+    PythonAPI/src/kvector_t.pypp.cpp \
+    PythonAPI/src/vector_IFormFactorPtr_t.pypp.cpp \
+    PythonAPI/src/FormFactorSphere.pypp.cpp \
     PythonAPI/src/FormFactorLorentz.pypp.cpp \
+    PythonAPI/src/FormFactorCylinder.pypp.cpp \
+    PythonAPI/src/ISelectionRule.pypp.cpp \
+    PythonAPI/src/InterferenceFunctionNone.pypp.cpp \
+    PythonAPI/src/IResolutionFunction2D.pypp.cpp \
+    PythonAPI/src/ITransform3D.pypp.cpp \
+    PythonAPI/src/Layer.pypp.cpp \
+    PythonAPI/src/Lattice2DIFParameters.pypp.cpp \
     PythonAPI/src/FormFactorParallelepiped.pypp.cpp \
-    PythonAPI/src/FormFactorPrism3.pypp.cpp \
+    PythonAPI/src/ISample.pypp.cpp \
+    PythonAPI/src/MultiLayer.pypp.cpp \
     PythonAPI/src/FormFactorPrism6.pypp.cpp \
     PythonAPI/src/FormFactorPyramid.pypp.cpp \
-    PythonAPI/src/FormFactorSphere.pypp.cpp \
-    PythonAPI/src/FormFactorSphereGaussianRadius.pypp.cpp \
-    PythonAPI/src/HomogeneousMaterial.pypp.cpp \
     PythonAPI/src/IAxis.pypp.cpp \
-    PythonAPI/src/ICloneable.pypp.cpp \
-    PythonAPI/src/IClusteredParticles.pypp.cpp \
-    PythonAPI/src/ICompositeSample.pypp.cpp \
-    PythonAPI/src/IDecoration.pypp.cpp \
-    PythonAPI/src/IDetectorResolution.pypp.cpp \
-    PythonAPI/src/IFTDistribution2D.pypp.cpp \
-    PythonAPI/src/IFormFactor.pypp.cpp \
-    PythonAPI/src/IFormFactorBorn.pypp.cpp \
+    PythonAPI/src/vdouble1d_t.pypp.cpp \
     PythonAPI/src/IFormFactorDecorator.pypp.cpp \
-    PythonAPI/src/IInterferenceFunction.pypp.cpp \
-    PythonAPI/src/IMaterial.pypp.cpp \
-    PythonAPI/src/IObservable.pypp.cpp \
-    PythonAPI/src/IObserver.pypp.cpp \
+    PythonAPI/src/Bin1D.pypp.cpp \
     PythonAPI/src/IParameterized.pypp.cpp \
-    PythonAPI/src/IResolutionFunction2D.pypp.cpp \
-    PythonAPI/src/ISample.pypp.cpp \
+    PythonAPI/src/PythonInterface_global_variables.pypp.cpp \
+    PythonAPI/src/IInterferenceFunction.pypp.cpp \
+    PythonAPI/src/RealParameterWrapper.pypp.cpp \
+    PythonAPI/src/PythonInterface_free_functions.pypp.cpp \
+    PythonAPI/src/MesoCrystal.pypp.cpp \
+    PythonAPI/src/FormFactorCrystal.pypp.cpp \
     PythonAPI/src/ISampleBuilder.pypp.cpp \
-    PythonAPI/src/ISelectionRule.pypp.cpp \
-    PythonAPI/src/ITransform3D.pypp.cpp \
-    PythonAPI/src/Instrument.pypp.cpp \
-    PythonAPI/src/IntensityData.pypp.cpp \
-    PythonAPI/src/InterferenceFunction1DParaCrystal.pypp.cpp \
-    PythonAPI/src/InterferenceFunction2DLattice.pypp.cpp \
-    PythonAPI/src/InterferenceFunction2DParaCrystal.pypp.cpp \
-    PythonAPI/src/InterferenceFunctionNone.pypp.cpp \
+    PythonAPI/src/StochasticSampledParameter.pypp.cpp \
+    PythonAPI/src/FormFactorFullSphere.pypp.cpp \
+    PythonAPI/src/StochasticParameter_t.pypp.cpp \
+    PythonAPI/src/AxisBin.pypp.cpp \
+    PythonAPI/src/SimpleSelectionRule.pypp.cpp \
+    PythonAPI/src/IDecoration.pypp.cpp \
+    PythonAPI/src/FTDistribution2DCauchy.pypp.cpp \
+    PythonAPI/src/IFTDistribution2D.pypp.cpp \
+    PythonAPI/src/ICloneable.pypp.cpp \
+    PythonAPI/src/ParticleInfo.pypp.cpp \
+    PythonAPI/src/ParticleDecoration.pypp.cpp \
+    PythonAPI/src/FormFactorSphereGaussianRadius.pypp.cpp \
+    PythonAPI/src/IClusteredParticles.pypp.cpp \
+    PythonAPI/src/Particle.pypp.cpp \
+    PythonAPI/src/IObserver.pypp.cpp \
     PythonAPI/src/Lattice.pypp.cpp \
-    PythonAPI/src/Lattice2DIFParameters.pypp.cpp \
-    PythonAPI/src/LatticeBasis.pypp.cpp \
-    PythonAPI/src/Layer.pypp.cpp \
-    PythonAPI/src/LayerInterface.pypp.cpp \
-    PythonAPI/src/LayerRoughness.pypp.cpp \
-    PythonAPI/src/MaterialManager.pypp.cpp \
-    PythonAPI/src/MesoCrystal.pypp.cpp \
-    PythonAPI/src/MultiLayer.pypp.cpp \
+    PythonAPI/src/vector_longinteger_t.pypp.cpp \
+    PythonAPI/src/IMaterial.pypp.cpp \
+    PythonAPI/src/InterferenceFunction2DLattice.pypp.cpp \
+    PythonAPI/src/ResolutionFunction2DSimple.pypp.cpp \
+    PythonAPI/src/Detector.pypp.cpp \
+    PythonAPI/src/Bin1DCVector.pypp.cpp \
+    PythonAPI/src/HomogeneousMaterial.pypp.cpp \
+    PythonAPI/src/FormFactorHemiSpheroid.pypp.cpp \
+    PythonAPI/src/vector_integer_t.pypp.cpp \
     PythonAPI/src/OutputDataIOFactory.pypp.cpp \
     PythonAPI/src/ParameterPool.pypp.cpp \
-    PythonAPI/src/Particle.pypp.cpp \
+    PythonAPI/src/InterferenceFunction2DParaCrystal.pypp.cpp \
+    PythonAPI/src/FormFactorCone.pypp.cpp \
+    PythonAPI/src/Simulation.pypp.cpp \
+    PythonAPI/src/IntensityData.pypp.cpp \
+    PythonAPI/src/AxisDouble.pypp.cpp \
+    PythonAPI/src/FormFactorFullSpheroid.pypp.cpp \
+    PythonAPI/src/MaterialManager.pypp.cpp \
+    PythonAPI/src/IObservable.pypp.cpp \
     PythonAPI/src/ParticleBuilder.pypp.cpp \
-    PythonAPI/src/ParticleCoreShell.pypp.cpp \
-    PythonAPI/src/ParticleDecoration.pypp.cpp \
-    PythonAPI/src/ParticleInfo.pypp.cpp \
+    PythonAPI/src/Instrument.pypp.cpp \
+    PythonAPI/src/FormFactorGauss.pypp.cpp \
+    PythonAPI/src/FormFactorPrism3.pypp.cpp \
     PythonAPI/src/PositionParticleInfo.pypp.cpp \
-    PythonAPI/src/PythonInterface_free_functions.pypp.cpp \
-    PythonAPI/src/PythonInterface_global_variables.pypp.cpp \
-    PythonAPI/src/RealParameterWrapper.pypp.cpp \
-    PythonAPI/src/ResolutionFunction2DSimple.pypp.cpp \
-    PythonAPI/src/RotateY_3D.pypp.cpp \
+    PythonAPI/src/ICompositeSample.pypp.cpp \
+    PythonAPI/src/Beam.pypp.cpp \
+    PythonAPI/src/FormFactorDecoratorDebyeWaller.pypp.cpp \
+    PythonAPI/src/IFormFactor.pypp.cpp \
+    PythonAPI/src/FormFactorBox.pypp.cpp \
+    PythonAPI/src/IDetectorResolution.pypp.cpp \
     PythonAPI/src/RotateZ_3D.pypp.cpp \
-    PythonAPI/src/SimpleSelectionRule.pypp.cpp \
-    PythonAPI/src/Simulation.pypp.cpp \
-    PythonAPI/src/SimulationParameters.pypp.cpp \
+    PythonAPI/src/LayerInterface.pypp.cpp \
+    PythonAPI/src/InterferenceFunction1DParaCrystal.pypp.cpp \
+    PythonAPI/src/RotateY_3D.pypp.cpp \
     PythonAPI/src/StochasticDoubleGate.pypp.cpp \
-    PythonAPI/src/StochasticDoubleGaussian.pypp.cpp \
-    PythonAPI/src/StochasticParameter_t.pypp.cpp \
-    PythonAPI/src/StochasticSampledParameter.pypp.cpp \
     PythonAPI/src/cvector_t.pypp.cpp \
-    PythonAPI/src/kvector_t.pypp.cpp \
-    PythonAPI/src/vdouble1d_t.pypp.cpp \
-    PythonAPI/src/vector_IFormFactorPtr_t.pypp.cpp \
-    PythonAPI/src/vector_integer_t.pypp.cpp \
+    PythonAPI/src/SimulationParameters.pypp.cpp \
+    PythonAPI/src/IFormFactorBorn.pypp.cpp \
     PythonAPI/src/vector_kvector_t.pypp.cpp \
-    PythonAPI/src/vector_longinteger_t.pypp.cpp 
+    PythonAPI/src/FormFactorEllipsoid.pypp.cpp \
+    PythonAPI/src/LayerRoughness.pypp.cpp \
+    PythonAPI/src/LatticeBasis.pypp.cpp \
+    PythonAPI/src/StochasticDoubleGaussian.pypp.cpp \
+    PythonAPI/src/Crystal.pypp.cpp 
 
 INCLUDEPATH += ./PythonAPI/inc 
 DEPENDPATH  += ./PythonAPI/inc 
diff --git a/Fit/PythonAPI/src/AttLimits.pypp.cpp b/Fit/PythonAPI/src/AttLimits.pypp.cpp
index e9ebeee424eb2c646fdbec7c49aea06ddc19540b..9faa92236e7264e872e5aa990419aca05dc8b399 100644
--- a/Fit/PythonAPI/src/AttLimits.pypp.cpp
+++ b/Fit/PythonAPI/src/AttLimits.pypp.cpp
@@ -33,11 +33,11 @@ struct AttLimits_wrapper : AttLimits, bp::wrapper< AttLimits > {
     virtual double getLowerLimit(  ) const  {
         if( bp::override func_getLowerLimit = this->get_override( "getLowerLimit" ) )
             return func_getLowerLimit(  );
-        else{
+        else
             return this->AttLimits::getLowerLimit(  );
-        }
     }
     
+    
     double default_getLowerLimit(  ) const  {
         return AttLimits::getLowerLimit( );
     }
@@ -45,11 +45,11 @@ struct AttLimits_wrapper : AttLimits, bp::wrapper< AttLimits > {
     virtual double getUpperLimit(  ) const  {
         if( bp::override func_getUpperLimit = this->get_override( "getUpperLimit" ) )
             return func_getUpperLimit(  );
-        else{
+        else
             return this->AttLimits::getUpperLimit(  );
-        }
     }
     
+    
     double default_getUpperLimit(  ) const  {
         return AttLimits::getUpperLimit( );
     }
@@ -57,11 +57,11 @@ struct AttLimits_wrapper : AttLimits, bp::wrapper< AttLimits > {
     virtual bool hasLowerAndUpperLimits(  ) const  {
         if( bp::override func_hasLowerAndUpperLimits = this->get_override( "hasLowerAndUpperLimits" ) )
             return func_hasLowerAndUpperLimits(  );
-        else{
+        else
             return this->AttLimits::hasLowerAndUpperLimits(  );
-        }
     }
     
+    
     bool default_hasLowerAndUpperLimits(  ) const  {
         return AttLimits::hasLowerAndUpperLimits( );
     }
@@ -69,11 +69,11 @@ struct AttLimits_wrapper : AttLimits, bp::wrapper< AttLimits > {
     virtual bool hasLowerLimit(  ) const  {
         if( bp::override func_hasLowerLimit = this->get_override( "hasLowerLimit" ) )
             return func_hasLowerLimit(  );
-        else{
+        else
             return this->AttLimits::hasLowerLimit(  );
-        }
     }
     
+    
     bool default_hasLowerLimit(  ) const  {
         return AttLimits::hasLowerLimit( );
     }
@@ -81,11 +81,11 @@ struct AttLimits_wrapper : AttLimits, bp::wrapper< AttLimits > {
     virtual bool hasUpperLimit(  ) const  {
         if( bp::override func_hasUpperLimit = this->get_override( "hasUpperLimit" ) )
             return func_hasUpperLimit(  );
-        else{
+        else
             return this->AttLimits::hasUpperLimit(  );
-        }
     }
     
+    
     bool default_hasUpperLimit(  ) const  {
         return AttLimits::hasUpperLimit( );
     }
@@ -93,11 +93,11 @@ struct AttLimits_wrapper : AttLimits, bp::wrapper< AttLimits > {
     virtual bool isFixed(  ) const  {
         if( bp::override func_isFixed = this->get_override( "isFixed" ) )
             return func_isFixed(  );
-        else{
+        else
             return this->AttLimits::isFixed(  );
-        }
     }
     
+    
     bool default_isFixed(  ) const  {
         return AttLimits::isFixed( );
     }
@@ -105,11 +105,11 @@ struct AttLimits_wrapper : AttLimits, bp::wrapper< AttLimits > {
     virtual void removeLimits(  ) {
         if( bp::override func_removeLimits = this->get_override( "removeLimits" ) )
             func_removeLimits(  );
-        else{
+        else
             this->AttLimits::removeLimits(  );
-        }
     }
     
+    
     void default_removeLimits(  ) {
         AttLimits::removeLimits( );
     }
@@ -117,11 +117,11 @@ struct AttLimits_wrapper : AttLimits, bp::wrapper< AttLimits > {
     virtual void removeLowerLimit(  ) {
         if( bp::override func_removeLowerLimit = this->get_override( "removeLowerLimit" ) )
             func_removeLowerLimit(  );
-        else{
+        else
             this->AttLimits::removeLowerLimit(  );
-        }
     }
     
+    
     void default_removeLowerLimit(  ) {
         AttLimits::removeLowerLimit( );
     }
@@ -129,11 +129,11 @@ struct AttLimits_wrapper : AttLimits, bp::wrapper< AttLimits > {
     virtual void removeUpperLimit(  ) {
         if( bp::override func_removeUpperLimit = this->get_override( "removeUpperLimit" ) )
             func_removeUpperLimit(  );
-        else{
+        else
             this->AttLimits::removeUpperLimit(  );
-        }
     }
     
+    
     void default_removeUpperLimit(  ) {
         AttLimits::removeUpperLimit( );
     }
@@ -141,11 +141,11 @@ struct AttLimits_wrapper : AttLimits, bp::wrapper< AttLimits > {
     virtual void setFixed( bool is_fixed ) {
         if( bp::override func_setFixed = this->get_override( "setFixed" ) )
             func_setFixed( is_fixed );
-        else{
+        else
             this->AttLimits::setFixed( is_fixed );
-        }
     }
     
+    
     void default_setFixed( bool is_fixed ) {
         AttLimits::setFixed( is_fixed );
     }
@@ -153,11 +153,11 @@ struct AttLimits_wrapper : AttLimits, bp::wrapper< AttLimits > {
     virtual void setLimits( double xmin, double xmax ) {
         if( bp::override func_setLimits = this->get_override( "setLimits" ) )
             func_setLimits( xmin, xmax );
-        else{
+        else
             this->AttLimits::setLimits( xmin, xmax );
-        }
     }
     
+    
     void default_setLimits( double xmin, double xmax ) {
         AttLimits::setLimits( xmin, xmax );
     }
@@ -165,11 +165,11 @@ struct AttLimits_wrapper : AttLimits, bp::wrapper< AttLimits > {
     virtual void setLowerLimit( double value ) {
         if( bp::override func_setLowerLimit = this->get_override( "setLowerLimit" ) )
             func_setLowerLimit( value );
-        else{
+        else
             this->AttLimits::setLowerLimit( value );
-        }
     }
     
+    
     void default_setLowerLimit( double value ) {
         AttLimits::setLowerLimit( value );
     }
@@ -177,11 +177,11 @@ struct AttLimits_wrapper : AttLimits, bp::wrapper< AttLimits > {
     virtual void setUpperLimit( double value ) {
         if( bp::override func_setUpperLimit = this->get_override( "setUpperLimit" ) )
             func_setUpperLimit( value );
-        else{
+        else
             this->AttLimits::setUpperLimit( value );
-        }
     }
     
+    
     void default_setUpperLimit( double value ) {
         AttLimits::setUpperLimit( value );
     }
diff --git a/Fit/PythonAPI/src/ChiSquaredModule.pypp.cpp b/Fit/PythonAPI/src/ChiSquaredModule.pypp.cpp
index 85ec4492f73bcc75250442d5e346b3def2042761..b2e416fca359015f2890a5d361248bb319b20c11 100644
--- a/Fit/PythonAPI/src/ChiSquaredModule.pypp.cpp
+++ b/Fit/PythonAPI/src/ChiSquaredModule.pypp.cpp
@@ -33,11 +33,11 @@ struct ChiSquaredModule_wrapper : ChiSquaredModule, bp::wrapper< ChiSquaredModul
     virtual double calculateChiSquared(  ) {
         if( bp::override func_calculateChiSquared = this->get_override( "calculateChiSquared" ) )
             return func_calculateChiSquared(  );
-        else{
+        else
             return this->ChiSquaredModule::calculateChiSquared(  );
-        }
     }
     
+    
     double default_calculateChiSquared(  ) {
         return ChiSquaredModule::calculateChiSquared( );
     }
@@ -45,11 +45,11 @@ struct ChiSquaredModule_wrapper : ChiSquaredModule, bp::wrapper< ChiSquaredModul
     virtual ::ChiSquaredModule * clone(  ) const  {
         if( bp::override func_clone = this->get_override( "clone" ) )
             return func_clone(  );
-        else{
+        else
             return this->ChiSquaredModule::clone(  );
-        }
     }
     
+    
     ::ChiSquaredModule * default_clone(  ) const  {
         return ChiSquaredModule::clone( );
     }
@@ -57,35 +57,35 @@ struct ChiSquaredModule_wrapper : ChiSquaredModule, bp::wrapper< ChiSquaredModul
     virtual ::OutputData< double > * createChi2DifferenceMap(  ) const  {
         if( bp::override func_createChi2DifferenceMap = this->get_override( "createChi2DifferenceMap" ) )
             return func_createChi2DifferenceMap(  );
-        else{
+        else
             return this->ChiSquaredModule::createChi2DifferenceMap(  );
-        }
     }
     
+    
     ::OutputData< double > * default_createChi2DifferenceMap(  ) const  {
         return ChiSquaredModule::createChi2DifferenceMap( );
     }
 
-    virtual double getResidualValue( ::size_t index ) const  {
+    virtual double getResidualValue( ::std::size_t index ) const  {
         if( bp::override func_getResidualValue = this->get_override( "getResidualValue" ) )
             return func_getResidualValue( index );
-        else{
+        else
             return this->ChiSquaredModule::getResidualValue( index );
-        }
     }
     
-    double default_getResidualValue( ::size_t index ) const  {
+    
+    double default_getResidualValue( ::std::size_t index ) const  {
         return ChiSquaredModule::getResidualValue( index );
     }
 
     virtual ::IFittingDataSelector const * getFittingDataSelector(  ) const  {
         if( bp::override func_getFittingDataSelector = this->get_override( "getFittingDataSelector" ) )
             return func_getFittingDataSelector(  );
-        else{
+        else
             return this->IChiSquaredModule::getFittingDataSelector(  );
-        }
     }
     
+    
     ::IFittingDataSelector const * default_getFittingDataSelector(  ) const  {
         return IChiSquaredModule::getFittingDataSelector( );
     }
@@ -93,11 +93,11 @@ struct ChiSquaredModule_wrapper : ChiSquaredModule, bp::wrapper< ChiSquaredModul
     virtual ::IIntensityFunction const * getIntensityFunction(  ) const  {
         if( bp::override func_getIntensityFunction = this->get_override( "getIntensityFunction" ) )
             return func_getIntensityFunction(  );
-        else{
+        else
             return this->IChiSquaredModule::getIntensityFunction(  );
-        }
     }
     
+    
     ::IIntensityFunction const * default_getIntensityFunction(  ) const  {
         return IChiSquaredModule::getIntensityFunction( );
     }
@@ -105,11 +105,11 @@ struct ChiSquaredModule_wrapper : ChiSquaredModule, bp::wrapper< ChiSquaredModul
     virtual ::IOutputDataNormalizer const * getOutputDataNormalizer(  ) const  {
         if( bp::override func_getOutputDataNormalizer = this->get_override( "getOutputDataNormalizer" ) )
             return func_getOutputDataNormalizer(  );
-        else{
+        else
             return this->IChiSquaredModule::getOutputDataNormalizer(  );
-        }
     }
     
+    
     ::IOutputDataNormalizer const * default_getOutputDataNormalizer(  ) const  {
         return IChiSquaredModule::getOutputDataNormalizer( );
     }
@@ -117,11 +117,11 @@ struct ChiSquaredModule_wrapper : ChiSquaredModule, bp::wrapper< ChiSquaredModul
     virtual ::IOutputDataNormalizer * getOutputDataNormalizer(  ) {
         if( bp::override func_getOutputDataNormalizer = this->get_override( "getOutputDataNormalizer" ) )
             return func_getOutputDataNormalizer(  );
-        else{
+        else
             return this->IChiSquaredModule::getOutputDataNormalizer(  );
-        }
     }
     
+    
     ::IOutputDataNormalizer * default_getOutputDataNormalizer(  ) {
         return IChiSquaredModule::getOutputDataNormalizer( );
     }
@@ -129,11 +129,11 @@ struct ChiSquaredModule_wrapper : ChiSquaredModule, bp::wrapper< ChiSquaredModul
     virtual void setFittingDataSelector( ::IFittingDataSelector const & selector ) {
         if( bp::override func_setFittingDataSelector = this->get_override( "setFittingDataSelector" ) )
             func_setFittingDataSelector( boost::ref(selector) );
-        else{
+        else
             this->IChiSquaredModule::setFittingDataSelector( boost::ref(selector) );
-        }
     }
     
+    
     void default_setFittingDataSelector( ::IFittingDataSelector const & selector ) {
         IChiSquaredModule::setFittingDataSelector( boost::ref(selector) );
     }
@@ -141,11 +141,11 @@ struct ChiSquaredModule_wrapper : ChiSquaredModule, bp::wrapper< ChiSquaredModul
     virtual void setIntensityFunction( ::IIntensityFunction const & intensity_function ) {
         if( bp::override func_setIntensityFunction = this->get_override( "setIntensityFunction" ) )
             func_setIntensityFunction( boost::ref(intensity_function) );
-        else{
+        else
             this->IChiSquaredModule::setIntensityFunction( boost::ref(intensity_function) );
-        }
     }
     
+    
     void default_setIntensityFunction( ::IIntensityFunction const & intensity_function ) {
         IChiSquaredModule::setIntensityFunction( boost::ref(intensity_function) );
     }
@@ -153,11 +153,11 @@ struct ChiSquaredModule_wrapper : ChiSquaredModule, bp::wrapper< ChiSquaredModul
     virtual void setOutputDataNormalizer( ::IOutputDataNormalizer const & data_normalizer ) {
         if( bp::override func_setOutputDataNormalizer = this->get_override( "setOutputDataNormalizer" ) )
             func_setOutputDataNormalizer( boost::ref(data_normalizer) );
-        else{
+        else
             this->IChiSquaredModule::setOutputDataNormalizer( boost::ref(data_normalizer) );
-        }
     }
     
+    
     void default_setOutputDataNormalizer( ::IOutputDataNormalizer const & data_normalizer ) {
         IChiSquaredModule::setOutputDataNormalizer( boost::ref(data_normalizer) );
     }
@@ -208,8 +208,8 @@ void register_ChiSquaredModule_class(){
         }
         { //::ChiSquaredModule::getResidualValue
         
-            typedef double ( ::ChiSquaredModule::*getResidualValue_function_type )( ::size_t ) const;
-            typedef double ( ChiSquaredModule_wrapper::*default_getResidualValue_function_type )( ::size_t ) const;
+            typedef double ( ::ChiSquaredModule::*getResidualValue_function_type )( ::std::size_t ) const;
+            typedef double ( ChiSquaredModule_wrapper::*default_getResidualValue_function_type )( ::std::size_t ) const;
             
             ChiSquaredModule_exposer.def( 
                 "getResidualValue"
diff --git a/Fit/PythonAPI/src/FitObject.pypp.cpp b/Fit/PythonAPI/src/FitObject.pypp.cpp
index c07985a9a329cf89787a1e30ff2de6343296d99a..44aaab36a69611d610f24ad1a4406eaad38762a8 100644
--- a/Fit/PythonAPI/src/FitObject.pypp.cpp
+++ b/Fit/PythonAPI/src/FitObject.pypp.cpp
@@ -91,7 +91,7 @@ void register_FitObject_class(){
         }
         { //::FitObject::getSizeOfData
         
-            typedef ::size_t ( ::FitObject::*getSizeOfData_function_type )(  ) const;
+            typedef ::std::size_t ( ::FitObject::*getSizeOfData_function_type )(  ) const;
             
             FitObject_exposer.def( 
                 "getSizeOfData"
diff --git a/Fit/PythonAPI/src/FitParameter.pypp.cpp b/Fit/PythonAPI/src/FitParameter.pypp.cpp
index 719bdf807ebbde7074da6fe83fae832c507d7bac..36fb7bcb1518619f7be884fc4c0291eed66dd9dd 100644
--- a/Fit/PythonAPI/src/FitParameter.pypp.cpp
+++ b/Fit/PythonAPI/src/FitParameter.pypp.cpp
@@ -40,11 +40,11 @@ struct FitParameter_wrapper : FitParameter, bp::wrapper< FitParameter > {
     virtual double getError(  ) const  {
         if( bp::override func_getError = this->get_override( "getError" ) )
             return func_getError(  );
-        else{
+        else
             return this->FitParameter::getError(  );
-        }
     }
     
+    
     double default_getError(  ) const  {
         return FitParameter::getError( );
     }
@@ -52,11 +52,11 @@ struct FitParameter_wrapper : FitParameter, bp::wrapper< FitParameter > {
     virtual double getStep(  ) const  {
         if( bp::override func_getStep = this->get_override( "getStep" ) )
             return func_getStep(  );
-        else{
+        else
             return this->FitParameter::getStep(  );
-        }
     }
     
+    
     double default_getStep(  ) const  {
         return FitParameter::getStep( );
     }
@@ -64,11 +64,11 @@ struct FitParameter_wrapper : FitParameter, bp::wrapper< FitParameter > {
     virtual double getValue(  ) const  {
         if( bp::override func_getValue = this->get_override( "getValue" ) )
             return func_getValue(  );
-        else{
+        else
             return this->FitParameter::getValue(  );
-        }
     }
     
+    
     double default_getValue(  ) const  {
         return FitParameter::getValue( );
     }
@@ -76,11 +76,11 @@ struct FitParameter_wrapper : FitParameter, bp::wrapper< FitParameter > {
     virtual void setError( double value ) {
         if( bp::override func_setError = this->get_override( "setError" ) )
             func_setError( value );
-        else{
+        else
             this->FitParameter::setError( value );
-        }
     }
     
+    
     void default_setError( double value ) {
         FitParameter::setError( value );
     }
@@ -88,11 +88,11 @@ struct FitParameter_wrapper : FitParameter, bp::wrapper< FitParameter > {
     virtual void setStep( double value ) {
         if( bp::override func_setStep = this->get_override( "setStep" ) )
             func_setStep( value );
-        else{
+        else
             this->FitParameter::setStep( value );
-        }
     }
     
+    
     void default_setStep( double value ) {
         FitParameter::setStep( value );
     }
@@ -100,11 +100,11 @@ struct FitParameter_wrapper : FitParameter, bp::wrapper< FitParameter > {
     virtual void setValue( double value ) {
         if( bp::override func_setValue = this->get_override( "setValue" ) )
             func_setValue( value );
-        else{
+        else
             this->FitParameter::setValue( value );
-        }
     }
     
+    
     void default_setValue( double value ) {
         FitParameter::setValue( value );
     }
@@ -112,11 +112,11 @@ struct FitParameter_wrapper : FitParameter, bp::wrapper< FitParameter > {
     virtual double getLowerLimit(  ) const  {
         if( bp::override func_getLowerLimit = this->get_override( "getLowerLimit" ) )
             return func_getLowerLimit(  );
-        else{
+        else
             return this->AttLimits::getLowerLimit(  );
-        }
     }
     
+    
     double default_getLowerLimit(  ) const  {
         return AttLimits::getLowerLimit( );
     }
@@ -124,11 +124,11 @@ struct FitParameter_wrapper : FitParameter, bp::wrapper< FitParameter > {
     virtual double getUpperLimit(  ) const  {
         if( bp::override func_getUpperLimit = this->get_override( "getUpperLimit" ) )
             return func_getUpperLimit(  );
-        else{
+        else
             return this->AttLimits::getUpperLimit(  );
-        }
     }
     
+    
     double default_getUpperLimit(  ) const  {
         return AttLimits::getUpperLimit( );
     }
@@ -136,11 +136,11 @@ struct FitParameter_wrapper : FitParameter, bp::wrapper< FitParameter > {
     virtual bool hasLowerAndUpperLimits(  ) const  {
         if( bp::override func_hasLowerAndUpperLimits = this->get_override( "hasLowerAndUpperLimits" ) )
             return func_hasLowerAndUpperLimits(  );
-        else{
+        else
             return this->AttLimits::hasLowerAndUpperLimits(  );
-        }
     }
     
+    
     bool default_hasLowerAndUpperLimits(  ) const  {
         return AttLimits::hasLowerAndUpperLimits( );
     }
@@ -148,11 +148,11 @@ struct FitParameter_wrapper : FitParameter, bp::wrapper< FitParameter > {
     virtual bool hasLowerLimit(  ) const  {
         if( bp::override func_hasLowerLimit = this->get_override( "hasLowerLimit" ) )
             return func_hasLowerLimit(  );
-        else{
+        else
             return this->AttLimits::hasLowerLimit(  );
-        }
     }
     
+    
     bool default_hasLowerLimit(  ) const  {
         return AttLimits::hasLowerLimit( );
     }
@@ -160,11 +160,11 @@ struct FitParameter_wrapper : FitParameter, bp::wrapper< FitParameter > {
     virtual bool hasUpperLimit(  ) const  {
         if( bp::override func_hasUpperLimit = this->get_override( "hasUpperLimit" ) )
             return func_hasUpperLimit(  );
-        else{
+        else
             return this->AttLimits::hasUpperLimit(  );
-        }
     }
     
+    
     bool default_hasUpperLimit(  ) const  {
         return AttLimits::hasUpperLimit( );
     }
@@ -172,11 +172,11 @@ struct FitParameter_wrapper : FitParameter, bp::wrapper< FitParameter > {
     virtual bool isFixed(  ) const  {
         if( bp::override func_isFixed = this->get_override( "isFixed" ) )
             return func_isFixed(  );
-        else{
+        else
             return this->AttLimits::isFixed(  );
-        }
     }
     
+    
     bool default_isFixed(  ) const  {
         return AttLimits::isFixed( );
     }
@@ -184,11 +184,11 @@ struct FitParameter_wrapper : FitParameter, bp::wrapper< FitParameter > {
     virtual void removeLimits(  ) {
         if( bp::override func_removeLimits = this->get_override( "removeLimits" ) )
             func_removeLimits(  );
-        else{
+        else
             this->AttLimits::removeLimits(  );
-        }
     }
     
+    
     void default_removeLimits(  ) {
         AttLimits::removeLimits( );
     }
@@ -196,11 +196,11 @@ struct FitParameter_wrapper : FitParameter, bp::wrapper< FitParameter > {
     virtual void removeLowerLimit(  ) {
         if( bp::override func_removeLowerLimit = this->get_override( "removeLowerLimit" ) )
             func_removeLowerLimit(  );
-        else{
+        else
             this->AttLimits::removeLowerLimit(  );
-        }
     }
     
+    
     void default_removeLowerLimit(  ) {
         AttLimits::removeLowerLimit( );
     }
@@ -208,11 +208,11 @@ struct FitParameter_wrapper : FitParameter, bp::wrapper< FitParameter > {
     virtual void removeUpperLimit(  ) {
         if( bp::override func_removeUpperLimit = this->get_override( "removeUpperLimit" ) )
             func_removeUpperLimit(  );
-        else{
+        else
             this->AttLimits::removeUpperLimit(  );
-        }
     }
     
+    
     void default_removeUpperLimit(  ) {
         AttLimits::removeUpperLimit( );
     }
@@ -220,11 +220,11 @@ struct FitParameter_wrapper : FitParameter, bp::wrapper< FitParameter > {
     virtual void setFixed( bool is_fixed ) {
         if( bp::override func_setFixed = this->get_override( "setFixed" ) )
             func_setFixed( is_fixed );
-        else{
+        else
             this->AttLimits::setFixed( is_fixed );
-        }
     }
     
+    
     void default_setFixed( bool is_fixed ) {
         AttLimits::setFixed( is_fixed );
     }
@@ -232,11 +232,11 @@ struct FitParameter_wrapper : FitParameter, bp::wrapper< FitParameter > {
     virtual void setLimits( double xmin, double xmax ) {
         if( bp::override func_setLimits = this->get_override( "setLimits" ) )
             func_setLimits( xmin, xmax );
-        else{
+        else
             this->AttLimits::setLimits( xmin, xmax );
-        }
     }
     
+    
     void default_setLimits( double xmin, double xmax ) {
         AttLimits::setLimits( xmin, xmax );
     }
@@ -244,11 +244,11 @@ struct FitParameter_wrapper : FitParameter, bp::wrapper< FitParameter > {
     virtual void setLowerLimit( double value ) {
         if( bp::override func_setLowerLimit = this->get_override( "setLowerLimit" ) )
             func_setLowerLimit( value );
-        else{
+        else
             this->AttLimits::setLowerLimit( value );
-        }
     }
     
+    
     void default_setLowerLimit( double value ) {
         AttLimits::setLowerLimit( value );
     }
@@ -256,11 +256,11 @@ struct FitParameter_wrapper : FitParameter, bp::wrapper< FitParameter > {
     virtual void setUpperLimit( double value ) {
         if( bp::override func_setUpperLimit = this->get_override( "setUpperLimit" ) )
             func_setUpperLimit( value );
-        else{
+        else
             this->AttLimits::setUpperLimit( value );
-        }
     }
     
+    
     void default_setUpperLimit( double value ) {
         AttLimits::setUpperLimit( value );
     }
diff --git a/Fit/PythonAPI/src/FitSuite.pypp.cpp b/Fit/PythonAPI/src/FitSuite.pypp.cpp
index 4d8276308c13a0f01f1689b630c2fcd21e7246e9..05de160f1144a90e3ceb854a4fc948bcc87b87dd 100644
--- a/Fit/PythonAPI/src/FitSuite.pypp.cpp
+++ b/Fit/PythonAPI/src/FitSuite.pypp.cpp
@@ -26,11 +26,11 @@ struct FitSuite_wrapper : FitSuite, bp::wrapper< FitSuite > {
     virtual void link_fit_parameters(  ) {
         if( bp::override func_link_fit_parameters = this->get_override( "link_fit_parameters" ) )
             func_link_fit_parameters(  );
-        else{
+        else
             this->FitSuite::link_fit_parameters(  );
-        }
     }
     
+    
     void default_link_fit_parameters(  ) {
         FitSuite::link_fit_parameters( );
     }
@@ -38,11 +38,11 @@ struct FitSuite_wrapper : FitSuite, bp::wrapper< FitSuite > {
     virtual void minimize(  ) {
         if( bp::override func_minimize = this->get_override( "minimize" ) )
             func_minimize(  );
-        else{
+        else
             this->FitSuite::minimize(  );
-        }
     }
     
+    
     void default_minimize(  ) {
         FitSuite::minimize( );
     }
@@ -50,11 +50,11 @@ struct FitSuite_wrapper : FitSuite, bp::wrapper< FitSuite > {
     virtual void runFit(  ) {
         if( bp::override func_runFit = this->get_override( "runFit" ) )
             func_runFit(  );
-        else{
+        else
             this->FitSuite::runFit(  );
-        }
     }
     
+    
     void default_runFit(  ) {
         FitSuite::runFit( );
     }
@@ -62,11 +62,11 @@ struct FitSuite_wrapper : FitSuite, bp::wrapper< FitSuite > {
     virtual void attachObserver( ::boost::shared_ptr< IObserver > obj ) {
         if( bp::override func_attachObserver = this->get_override( "attachObserver" ) )
             func_attachObserver( obj );
-        else{
+        else
             this->IObservable::attachObserver( obj );
-        }
     }
     
+    
     void default_attachObserver( ::boost::shared_ptr< IObserver > obj ) {
         IObservable::attachObserver( obj );
     }
@@ -74,11 +74,11 @@ struct FitSuite_wrapper : FitSuite, bp::wrapper< FitSuite > {
     virtual void notifyObservers(  ) {
         if( bp::override func_notifyObservers = this->get_override( "notifyObservers" ) )
             func_notifyObservers(  );
-        else{
+        else
             this->IObservable::notifyObservers(  );
-        }
     }
     
+    
     void default_notifyObservers(  ) {
         IObservable::notifyObservers( );
     }
@@ -183,7 +183,7 @@ void register_FitSuite_class(){
         }
         { //::FitSuite::getNCalls
         
-            typedef ::size_t ( ::FitSuite::*getNCalls_function_type )(  ) const;
+            typedef ::std::size_t ( ::FitSuite::*getNCalls_function_type )(  ) const;
             
             FitSuite_exposer.def( 
                 "getNCalls"
@@ -192,7 +192,7 @@ void register_FitSuite_class(){
         }
         { //::FitSuite::getNStrategy
         
-            typedef ::size_t ( ::FitSuite::*getNStrategy_function_type )(  ) const;
+            typedef ::std::size_t ( ::FitSuite::*getNStrategy_function_type )(  ) const;
             
             FitSuite_exposer.def( 
                 "getNStrategy"
diff --git a/Fit/PythonAPI/src/FitSuiteObjects.pypp.cpp b/Fit/PythonAPI/src/FitSuiteObjects.pypp.cpp
index 0aea9b4d8f46edf249fe6c90c6820b04969ce574..50e77c75aaa3c4167ad5fe1095baaef54d02855e 100644
--- a/Fit/PythonAPI/src/FitSuiteObjects.pypp.cpp
+++ b/Fit/PythonAPI/src/FitSuiteObjects.pypp.cpp
@@ -59,40 +59,40 @@ void register_FitSuiteObjects_class(){
         }
         { //::FitSuiteObjects::getObject
         
-            typedef ::FitObject const * ( ::FitSuiteObjects::*getObject_function_type )( ::size_t ) const;
+            typedef ::FitObject const * ( ::FitSuiteObjects::*getObject_function_type )( ::std::size_t ) const;
             
             FitSuiteObjects_exposer.def( 
                 "getObject"
                 , getObject_function_type( &::FitSuiteObjects::getObject )
-                , ( bp::arg("i_item")=(::size_t)(0) )
+                , ( bp::arg("i_item")=(long unsigned int)(0) )
                 , bp::return_value_policy< bp::reference_existing_object >() );
         
         }
         { //::FitSuiteObjects::getObject
         
-            typedef ::FitObject * ( ::FitSuiteObjects::*getObject_function_type )( ::size_t ) ;
+            typedef ::FitObject * ( ::FitSuiteObjects::*getObject_function_type )( ::std::size_t ) ;
             
             FitSuiteObjects_exposer.def( 
                 "getObject"
                 , getObject_function_type( &::FitSuiteObjects::getObject )
-                , ( bp::arg("i_item")=(::size_t)(0) )
+                , ( bp::arg("i_item")=(long unsigned int)(0) )
                 , bp::return_value_policy< bp::reference_existing_object >() );
         
         }
         { //::FitSuiteObjects::getRealData
         
-            typedef ::OutputData< double > const * ( ::FitSuiteObjects::*getRealData_function_type )( ::size_t ) const;
+            typedef ::OutputData< double > const * ( ::FitSuiteObjects::*getRealData_function_type )( ::std::size_t ) const;
             
             FitSuiteObjects_exposer.def( 
                 "getRealData"
                 , getRealData_function_type( &::FitSuiteObjects::getRealData )
-                , ( bp::arg("i_item")=(::size_t)(0) )
+                , ( bp::arg("i_item")=(long unsigned int)(0) )
                 , bp::return_value_policy< bp::reference_existing_object >() );
         
         }
         { //::FitSuiteObjects::getResidualValue
         
-            typedef double ( ::FitSuiteObjects::*getResidualValue_function_type )( ::size_t ) ;
+            typedef double ( ::FitSuiteObjects::*getResidualValue_function_type )( ::std::size_t ) ;
             
             FitSuiteObjects_exposer.def( 
                 "getResidualValue"
@@ -102,40 +102,40 @@ void register_FitSuiteObjects_class(){
         }
         { //::FitSuiteObjects::getSimulation
         
-            typedef ::Simulation const * ( ::FitSuiteObjects::*getSimulation_function_type )( ::size_t ) const;
+            typedef ::Simulation const * ( ::FitSuiteObjects::*getSimulation_function_type )( ::std::size_t ) const;
             
             FitSuiteObjects_exposer.def( 
                 "getSimulation"
                 , getSimulation_function_type( &::FitSuiteObjects::getSimulation )
-                , ( bp::arg("i_item")=(::size_t)(0) )
+                , ( bp::arg("i_item")=(long unsigned int)(0) )
                 , bp::return_value_policy< bp::reference_existing_object >() );
         
         }
         { //::FitSuiteObjects::getSimulation
         
-            typedef ::Simulation * ( ::FitSuiteObjects::*getSimulation_function_type )( ::size_t ) ;
+            typedef ::Simulation * ( ::FitSuiteObjects::*getSimulation_function_type )( ::std::size_t ) ;
             
             FitSuiteObjects_exposer.def( 
                 "getSimulation"
                 , getSimulation_function_type( &::FitSuiteObjects::getSimulation )
-                , ( bp::arg("i_item")=(::size_t)(0) )
+                , ( bp::arg("i_item")=(long unsigned int)(0) )
                 , bp::return_value_policy< bp::reference_existing_object >() );
         
         }
         { //::FitSuiteObjects::getSimulationData
         
-            typedef ::OutputData< double > const * ( ::FitSuiteObjects::*getSimulationData_function_type )( ::size_t ) const;
+            typedef ::OutputData< double > const * ( ::FitSuiteObjects::*getSimulationData_function_type )( ::std::size_t ) const;
             
             FitSuiteObjects_exposer.def( 
                 "getSimulationData"
                 , getSimulationData_function_type( &::FitSuiteObjects::getSimulationData )
-                , ( bp::arg("i_item")=(::size_t)(0) )
+                , ( bp::arg("i_item")=(long unsigned int)(0) )
                 , bp::return_value_policy< bp::reference_existing_object >() );
         
         }
         { //::FitSuiteObjects::getSizeOfDataSet
         
-            typedef ::size_t ( ::FitSuiteObjects::*getSizeOfDataSet_function_type )(  ) const;
+            typedef ::std::size_t ( ::FitSuiteObjects::*getSizeOfDataSet_function_type )(  ) const;
             
             FitSuiteObjects_exposer.def( 
                 "getSizeOfDataSet"
@@ -163,12 +163,12 @@ void register_FitSuiteObjects_class(){
         }
         { //::FitSuiteObjects::setRealData
         
-            typedef void ( ::FitSuiteObjects::*setRealData_function_type )( ::OutputData< double > const &,::size_t ) ;
+            typedef void ( ::FitSuiteObjects::*setRealData_function_type )( ::OutputData< double > const &,::std::size_t ) ;
             
             FitSuiteObjects_exposer.def( 
                 "setRealData"
                 , setRealData_function_type( &::FitSuiteObjects::setRealData )
-                , ( bp::arg("real_data"), bp::arg("i_item")=(::size_t)(0) ) );
+                , ( bp::arg("real_data"), bp::arg("i_item")=(long unsigned int)(0) ) );
         
         }
         { //::FitSuiteObjects::setSimulationNormalize
@@ -183,7 +183,7 @@ void register_FitSuiteObjects_class(){
         }
         { //::FitSuiteObjects::size
         
-            typedef ::size_t ( ::FitSuiteObjects::*size_function_type )(  ) const;
+            typedef ::std::size_t ( ::FitSuiteObjects::*size_function_type )(  ) const;
             
             FitSuiteObjects_exposer.def( 
                 "size"
diff --git a/Fit/PythonAPI/src/FitSuiteParameters.pypp.cpp b/Fit/PythonAPI/src/FitSuiteParameters.pypp.cpp
index 3ac893aa9913956d70bc67e842334fcc05db6650..586ccde2d6c4189dd56e6e9fca1313d4fa6dfd89 100644
--- a/Fit/PythonAPI/src/FitSuiteParameters.pypp.cpp
+++ b/Fit/PythonAPI/src/FitSuiteParameters.pypp.cpp
@@ -50,7 +50,7 @@ void register_FitSuiteParameters_class(){
         }
         { //::FitSuiteParameters::getNfreeParameters
         
-            typedef ::size_t ( ::FitSuiteParameters::*getNfreeParameters_function_type )(  ) const;
+            typedef ::std::size_t ( ::FitSuiteParameters::*getNfreeParameters_function_type )(  ) const;
             
             FitSuiteParameters_exposer.def( 
                 "getNfreeParameters"
@@ -90,7 +90,7 @@ void register_FitSuiteParameters_class(){
         }
         { //::FitSuiteParameters::operator[]
         
-            typedef ::FitParameter const * ( ::FitSuiteParameters::*__getitem___function_type )( ::size_t ) const;
+            typedef ::FitParameter const * ( ::FitSuiteParameters::*__getitem___function_type )( ::std::size_t ) const;
             
             FitSuiteParameters_exposer.def( 
                 "__getitem__"
@@ -101,7 +101,7 @@ void register_FitSuiteParameters_class(){
         }
         { //::FitSuiteParameters::operator[]
         
-            typedef ::FitParameter * ( ::FitSuiteParameters::*__getitem___function_type )( ::size_t ) ;
+            typedef ::FitParameter * ( ::FitSuiteParameters::*__getitem___function_type )( ::std::size_t ) ;
             
             FitSuiteParameters_exposer.def( 
                 "__getitem__"
@@ -163,7 +163,7 @@ void register_FitSuiteParameters_class(){
         }
         { //::FitSuiteParameters::size
         
-            typedef ::size_t ( ::FitSuiteParameters::*size_function_type )(  ) const;
+            typedef ::std::size_t ( ::FitSuiteParameters::*size_function_type )(  ) const;
             
             FitSuiteParameters_exposer.def( 
                 "size"
diff --git a/Fit/PythonAPI/src/IChiSquaredModule.pypp.cpp b/Fit/PythonAPI/src/IChiSquaredModule.pypp.cpp
index 5952056df869de4fc60756008917ad0859e6a21c..2d8c14cad8db365d3eb2da910988874caa6c3c49 100644
--- a/Fit/PythonAPI/src/IChiSquaredModule.pypp.cpp
+++ b/Fit/PythonAPI/src/IChiSquaredModule.pypp.cpp
@@ -41,11 +41,11 @@ struct IChiSquaredModule_wrapper : IChiSquaredModule, bp::wrapper< IChiSquaredMo
     virtual ::IFittingDataSelector const * getFittingDataSelector(  ) const  {
         if( bp::override func_getFittingDataSelector = this->get_override( "getFittingDataSelector" ) )
             return func_getFittingDataSelector(  );
-        else{
+        else
             return this->IChiSquaredModule::getFittingDataSelector(  );
-        }
     }
     
+    
     ::IFittingDataSelector const * default_getFittingDataSelector(  ) const  {
         return IChiSquaredModule::getFittingDataSelector( );
     }
@@ -53,11 +53,11 @@ struct IChiSquaredModule_wrapper : IChiSquaredModule, bp::wrapper< IChiSquaredMo
     virtual ::IIntensityFunction const * getIntensityFunction(  ) const  {
         if( bp::override func_getIntensityFunction = this->get_override( "getIntensityFunction" ) )
             return func_getIntensityFunction(  );
-        else{
+        else
             return this->IChiSquaredModule::getIntensityFunction(  );
-        }
     }
     
+    
     ::IIntensityFunction const * default_getIntensityFunction(  ) const  {
         return IChiSquaredModule::getIntensityFunction( );
     }
@@ -65,11 +65,11 @@ struct IChiSquaredModule_wrapper : IChiSquaredModule, bp::wrapper< IChiSquaredMo
     virtual ::IOutputDataNormalizer const * getOutputDataNormalizer(  ) const  {
         if( bp::override func_getOutputDataNormalizer = this->get_override( "getOutputDataNormalizer" ) )
             return func_getOutputDataNormalizer(  );
-        else{
+        else
             return this->IChiSquaredModule::getOutputDataNormalizer(  );
-        }
     }
     
+    
     ::IOutputDataNormalizer const * default_getOutputDataNormalizer(  ) const  {
         return IChiSquaredModule::getOutputDataNormalizer( );
     }
@@ -77,35 +77,35 @@ struct IChiSquaredModule_wrapper : IChiSquaredModule, bp::wrapper< IChiSquaredMo
     virtual ::IOutputDataNormalizer * getOutputDataNormalizer(  ) {
         if( bp::override func_getOutputDataNormalizer = this->get_override( "getOutputDataNormalizer" ) )
             return func_getOutputDataNormalizer(  );
-        else{
+        else
             return this->IChiSquaredModule::getOutputDataNormalizer(  );
-        }
     }
     
+    
     ::IOutputDataNormalizer * default_getOutputDataNormalizer(  ) {
         return IChiSquaredModule::getOutputDataNormalizer( );
     }
 
-    virtual double getResidualValue( ::size_t arg0 ) const  {
+    virtual double getResidualValue( ::std::size_t arg0 ) const  {
         if( bp::override func_getResidualValue = this->get_override( "getResidualValue" ) )
             return func_getResidualValue( arg0 );
-        else{
+        else
             return this->IChiSquaredModule::getResidualValue( arg0 );
-        }
     }
     
-    double default_getResidualValue( ::size_t arg0 ) const  {
+    
+    double default_getResidualValue( ::std::size_t arg0 ) const  {
         return IChiSquaredModule::getResidualValue( arg0 );
     }
 
     virtual void setFittingDataSelector( ::IFittingDataSelector const & selector ) {
         if( bp::override func_setFittingDataSelector = this->get_override( "setFittingDataSelector" ) )
             func_setFittingDataSelector( boost::ref(selector) );
-        else{
+        else
             this->IChiSquaredModule::setFittingDataSelector( boost::ref(selector) );
-        }
     }
     
+    
     void default_setFittingDataSelector( ::IFittingDataSelector const & selector ) {
         IChiSquaredModule::setFittingDataSelector( boost::ref(selector) );
     }
@@ -113,11 +113,11 @@ struct IChiSquaredModule_wrapper : IChiSquaredModule, bp::wrapper< IChiSquaredMo
     virtual void setIntensityFunction( ::IIntensityFunction const & intensity_function ) {
         if( bp::override func_setIntensityFunction = this->get_override( "setIntensityFunction" ) )
             func_setIntensityFunction( boost::ref(intensity_function) );
-        else{
+        else
             this->IChiSquaredModule::setIntensityFunction( boost::ref(intensity_function) );
-        }
     }
     
+    
     void default_setIntensityFunction( ::IIntensityFunction const & intensity_function ) {
         IChiSquaredModule::setIntensityFunction( boost::ref(intensity_function) );
     }
@@ -125,11 +125,11 @@ struct IChiSquaredModule_wrapper : IChiSquaredModule, bp::wrapper< IChiSquaredMo
     virtual void setOutputDataNormalizer( ::IOutputDataNormalizer const & data_normalizer ) {
         if( bp::override func_setOutputDataNormalizer = this->get_override( "setOutputDataNormalizer" ) )
             func_setOutputDataNormalizer( boost::ref(data_normalizer) );
-        else{
+        else
             this->IChiSquaredModule::setOutputDataNormalizer( boost::ref(data_normalizer) );
-        }
     }
     
+    
     void default_setOutputDataNormalizer( ::IOutputDataNormalizer const & data_normalizer ) {
         IChiSquaredModule::setOutputDataNormalizer( boost::ref(data_normalizer) );
     }
@@ -231,8 +231,8 @@ void register_IChiSquaredModule_class(){
         }
         { //::IChiSquaredModule::getResidualValue
         
-            typedef double ( ::IChiSquaredModule::*getResidualValue_function_type )( ::size_t ) const;
-            typedef double ( IChiSquaredModule_wrapper::*default_getResidualValue_function_type )( ::size_t ) const;
+            typedef double ( ::IChiSquaredModule::*getResidualValue_function_type )( ::std::size_t ) const;
+            typedef double ( IChiSquaredModule_wrapper::*default_getResidualValue_function_type )( ::std::size_t ) const;
             
             IChiSquaredModule_exposer.def( 
                 "getResidualValue"
diff --git a/Fit/PythonAPI/src/IMinimizer.pypp.cpp b/Fit/PythonAPI/src/IMinimizer.pypp.cpp
index e7d5213970a5d1c10abdb97bd231426200c4efec..692986d6c7952638bb5402f67f4ec14b20eae6da 100644
--- a/Fit/PythonAPI/src/IMinimizer.pypp.cpp
+++ b/Fit/PythonAPI/src/IMinimizer.pypp.cpp
@@ -26,35 +26,35 @@ struct IMinimizer_wrapper : IMinimizer, bp::wrapper< IMinimizer > {
     virtual void clear(  ) {
         if( bp::override func_clear = this->get_override( "clear" ) )
             func_clear(  );
-        else{
+        else
             this->IMinimizer::clear(  );
-        }
     }
     
+    
     void default_clear(  ) {
         IMinimizer::clear( );
     }
 
-    virtual double getErrorOfVariable( ::size_t arg0 ) const  {
+    virtual double getErrorOfVariable( ::std::size_t arg0 ) const  {
         if( bp::override func_getErrorOfVariable = this->get_override( "getErrorOfVariable" ) )
             return func_getErrorOfVariable( arg0 );
-        else{
+        else
             return this->IMinimizer::getErrorOfVariable( arg0 );
-        }
     }
     
-    double default_getErrorOfVariable( ::size_t arg0 ) const  {
+    
+    double default_getErrorOfVariable( ::std::size_t arg0 ) const  {
         return IMinimizer::getErrorOfVariable( arg0 );
     }
 
     virtual ::std::vector< double > getErrorOfVariables(  ) const  {
         if( bp::override func_getErrorOfVariables = this->get_override( "getErrorOfVariables" ) )
             return func_getErrorOfVariables(  );
-        else{
+        else
             return this->IMinimizer::getErrorOfVariables(  );
-        }
     }
     
+    
     ::std::vector< double > default_getErrorOfVariables(  ) const  {
         return IMinimizer::getErrorOfVariables( );
     }
@@ -62,71 +62,71 @@ struct IMinimizer_wrapper : IMinimizer, bp::wrapper< IMinimizer > {
     virtual double getMinValue(  ) const  {
         if( bp::override func_getMinValue = this->get_override( "getMinValue" ) )
             return func_getMinValue(  );
-        else{
+        else
             return this->IMinimizer::getMinValue(  );
-        }
     }
     
+    
     double default_getMinValue(  ) const  {
         return IMinimizer::getMinValue( );
     }
 
-    virtual ::size_t getNCalls(  ) const  {
+    virtual ::std::size_t getNCalls(  ) const  {
         if( bp::override func_getNCalls = this->get_override( "getNCalls" ) )
             return func_getNCalls(  );
-        else{
+        else
             return this->IMinimizer::getNCalls(  );
-        }
     }
     
-    ::size_t default_getNCalls(  ) const  {
+    
+    ::std::size_t default_getNCalls(  ) const  {
         return IMinimizer::getNCalls( );
     }
 
-    virtual ::size_t getNumberOfVariables(  ) const  {
+    virtual ::std::size_t getNumberOfVariables(  ) const  {
         if( bp::override func_getNumberOfVariables = this->get_override( "getNumberOfVariables" ) )
             return func_getNumberOfVariables(  );
-        else{
+        else
             return this->IMinimizer::getNumberOfVariables(  );
-        }
     }
     
-    ::size_t default_getNumberOfVariables(  ) const  {
+    
+    ::std::size_t default_getNumberOfVariables(  ) const  {
         return IMinimizer::getNumberOfVariables( );
     }
 
     virtual ::MinimizerOptions getOptions(  ) const  {
         if( bp::override func_getOptions = this->get_override( "getOptions" ) )
             return func_getOptions(  );
-        else{
+        else
             return this->IMinimizer::getOptions(  );
-        }
     }
     
+    
     ::MinimizerOptions default_getOptions(  ) const  {
         return IMinimizer::getOptions( );
     }
 
-    virtual double getValueOfVariableAtMinimum( ::size_t arg0 ) const  {
+    virtual double getValueOfVariableAtMinimum( ::std::size_t arg0 ) const  {
         if( bp::override func_getValueOfVariableAtMinimum = this->get_override( "getValueOfVariableAtMinimum" ) )
             return func_getValueOfVariableAtMinimum( arg0 );
-        else{
+        else
             return this->IMinimizer::getValueOfVariableAtMinimum( arg0 );
-        }
     }
     
-    double default_getValueOfVariableAtMinimum( ::size_t arg0 ) const  {
+    
+    double default_getValueOfVariableAtMinimum( ::std::size_t arg0 ) const  {
         return IMinimizer::getValueOfVariableAtMinimum( arg0 );
     }
 
     virtual ::std::vector< double > getValueOfVariablesAtMinimum(  ) const  {
         if( bp::override func_getValueOfVariablesAtMinimum = this->get_override( "getValueOfVariablesAtMinimum" ) )
             return func_getValueOfVariablesAtMinimum(  );
-        else{
+        else
             return this->IMinimizer::getValueOfVariablesAtMinimum(  );
-        }
     }
     
+    
     ::std::vector< double > default_getValueOfVariablesAtMinimum(  ) const  {
         return IMinimizer::getValueOfVariablesAtMinimum( );
     }
@@ -139,11 +139,11 @@ struct IMinimizer_wrapper : IMinimizer, bp::wrapper< IMinimizer > {
     virtual void printResults(  ) const  {
         if( bp::override func_printResults = this->get_override( "printResults" ) )
             func_printResults(  );
-        else{
+        else
             this->IMinimizer::printResults(  );
-        }
     }
     
+    
     void default_printResults(  ) const  {
         IMinimizer::printResults( );
     }
@@ -151,11 +151,11 @@ struct IMinimizer_wrapper : IMinimizer, bp::wrapper< IMinimizer > {
     virtual void setOptions( ::MinimizerOptions const & arg0 ) {
         if( bp::override func_setOptions = this->get_override( "setOptions" ) )
             func_setOptions( boost::ref(arg0) );
-        else{
+        else
             this->IMinimizer::setOptions( boost::ref(arg0) );
-        }
     }
     
+    
     void default_setOptions( ::MinimizerOptions const & arg0 ) {
         IMinimizer::setOptions( boost::ref(arg0) );
     }
@@ -163,11 +163,11 @@ struct IMinimizer_wrapper : IMinimizer, bp::wrapper< IMinimizer > {
     virtual void setOptions( ::std::string const & arg0 ) {
         if( bp::override func_setOptions = this->get_override( "setOptions" ) )
             func_setOptions( arg0 );
-        else{
+        else
             this->IMinimizer::setOptions( arg0 );
-        }
     }
     
+    
     void default_setOptions( ::std::string const & arg0 ) {
         IMinimizer::setOptions( arg0 );
     }
@@ -175,11 +175,11 @@ struct IMinimizer_wrapper : IMinimizer, bp::wrapper< IMinimizer > {
     virtual void setParameters( ::FitSuiteParameters const & arg0 ) {
         if( bp::override func_setParameters = this->get_override( "setParameters" ) )
             func_setParameters( boost::ref(arg0) );
-        else{
+        else
             this->IMinimizer::setParameters( boost::ref(arg0) );
-        }
     }
     
+    
     void default_setParameters( ::FitSuiteParameters const & arg0 ) {
         IMinimizer::setParameters( boost::ref(arg0) );
     }
@@ -205,8 +205,8 @@ void register_IMinimizer_class(){
         }
         { //::IMinimizer::getErrorOfVariable
         
-            typedef double ( ::IMinimizer::*getErrorOfVariable_function_type )( ::size_t ) const;
-            typedef double ( IMinimizer_wrapper::*default_getErrorOfVariable_function_type )( ::size_t ) const;
+            typedef double ( ::IMinimizer::*getErrorOfVariable_function_type )( ::std::size_t ) const;
+            typedef double ( IMinimizer_wrapper::*default_getErrorOfVariable_function_type )( ::std::size_t ) const;
             
             IMinimizer_exposer.def( 
                 "getErrorOfVariable"
@@ -239,8 +239,8 @@ void register_IMinimizer_class(){
         }
         { //::IMinimizer::getNCalls
         
-            typedef ::size_t ( ::IMinimizer::*getNCalls_function_type )(  ) const;
-            typedef ::size_t ( IMinimizer_wrapper::*default_getNCalls_function_type )(  ) const;
+            typedef ::std::size_t ( ::IMinimizer::*getNCalls_function_type )(  ) const;
+            typedef ::std::size_t ( IMinimizer_wrapper::*default_getNCalls_function_type )(  ) const;
             
             IMinimizer_exposer.def( 
                 "getNCalls"
@@ -250,8 +250,8 @@ void register_IMinimizer_class(){
         }
         { //::IMinimizer::getNumberOfVariables
         
-            typedef ::size_t ( ::IMinimizer::*getNumberOfVariables_function_type )(  ) const;
-            typedef ::size_t ( IMinimizer_wrapper::*default_getNumberOfVariables_function_type )(  ) const;
+            typedef ::std::size_t ( ::IMinimizer::*getNumberOfVariables_function_type )(  ) const;
+            typedef ::std::size_t ( IMinimizer_wrapper::*default_getNumberOfVariables_function_type )(  ) const;
             
             IMinimizer_exposer.def( 
                 "getNumberOfVariables"
@@ -272,8 +272,8 @@ void register_IMinimizer_class(){
         }
         { //::IMinimizer::getValueOfVariableAtMinimum
         
-            typedef double ( ::IMinimizer::*getValueOfVariableAtMinimum_function_type )( ::size_t ) const;
-            typedef double ( IMinimizer_wrapper::*default_getValueOfVariableAtMinimum_function_type )( ::size_t ) const;
+            typedef double ( ::IMinimizer::*getValueOfVariableAtMinimum_function_type )( ::std::size_t ) const;
+            typedef double ( IMinimizer_wrapper::*default_getValueOfVariableAtMinimum_function_type )( ::std::size_t ) const;
             
             IMinimizer_exposer.def( 
                 "getValueOfVariableAtMinimum"
diff --git a/Fit/PythonAPI/src/ISquaredFunction.pypp.cpp b/Fit/PythonAPI/src/ISquaredFunction.pypp.cpp
index d3102be1a4b8578ccb595113353c8de045bf2187..03961fd42f54edf9f09a3ad4ce233f78b6345e0e 100644
--- a/Fit/PythonAPI/src/ISquaredFunction.pypp.cpp
+++ b/Fit/PythonAPI/src/ISquaredFunction.pypp.cpp
@@ -31,11 +31,11 @@ struct ISquaredFunction_wrapper : ISquaredFunction, bp::wrapper< ISquaredFunctio
     virtual double calculateSquaredError( double real_value, double simulated_value=0.0 ) const  {
         if( bp::override func_calculateSquaredError = this->get_override( "calculateSquaredError" ) )
             return func_calculateSquaredError( real_value, simulated_value );
-        else{
+        else
             return this->ISquaredFunction::calculateSquaredError( real_value, simulated_value );
-        }
     }
     
+    
     double default_calculateSquaredError( double real_value, double simulated_value=0.0 ) const  {
         return ISquaredFunction::calculateSquaredError( real_value, simulated_value );
     }
diff --git a/Fit/PythonAPI/src/OutputDataNormalizer.pypp.cpp b/Fit/PythonAPI/src/OutputDataNormalizer.pypp.cpp
index 1f174b834df98ba7427c89851fdabb962ea652c5..e73f1c904aa56c1d756dddd015373eae70f6340c 100644
--- a/Fit/PythonAPI/src/OutputDataNormalizer.pypp.cpp
+++ b/Fit/PythonAPI/src/OutputDataNormalizer.pypp.cpp
@@ -33,11 +33,11 @@ struct OutputDataNormalizer_wrapper : OutputDataNormalizer, bp::wrapper< OutputD
     virtual ::OutputDataNormalizer * clone(  ) const  {
         if( bp::override func_clone = this->get_override( "clone" ) )
             return func_clone(  );
-        else{
+        else
             return this->OutputDataNormalizer::clone(  );
-        }
     }
     
+    
     ::OutputDataNormalizer * default_clone(  ) const  {
         return OutputDataNormalizer::clone( );
     }
@@ -45,11 +45,11 @@ struct OutputDataNormalizer_wrapper : OutputDataNormalizer, bp::wrapper< OutputD
     virtual ::OutputData< double > * createNormalizedData( ::OutputData< double > const & data ) const  {
         if( bp::override func_createNormalizedData = this->get_override( "createNormalizedData" ) )
             return func_createNormalizedData( boost::ref(data) );
-        else{
+        else
             return this->OutputDataNormalizer::createNormalizedData( boost::ref(data) );
-        }
     }
     
+    
     ::OutputData< double > * default_createNormalizedData( ::OutputData< double > const & data ) const  {
         return OutputDataNormalizer::createNormalizedData( boost::ref(data) );
     }
@@ -57,11 +57,11 @@ struct OutputDataNormalizer_wrapper : OutputDataNormalizer, bp::wrapper< OutputD
     virtual void setMaximumIntensity( double max_intensity ) {
         if( bp::override func_setMaximumIntensity = this->get_override( "setMaximumIntensity" ) )
             func_setMaximumIntensity( max_intensity );
-        else{
+        else
             this->OutputDataNormalizer::setMaximumIntensity( max_intensity );
-        }
     }
     
+    
     void default_setMaximumIntensity( double max_intensity ) {
         OutputDataNormalizer::setMaximumIntensity( max_intensity );
     }
diff --git a/Fit/PythonAPI/src/OutputDataSimpleNormalizer.pypp.cpp b/Fit/PythonAPI/src/OutputDataSimpleNormalizer.pypp.cpp
index 70b59588290d8d49c637096863ec5648dc3965f9..0bce6f350de766396e59c1525029ee93dd8f3714 100644
--- a/Fit/PythonAPI/src/OutputDataSimpleNormalizer.pypp.cpp
+++ b/Fit/PythonAPI/src/OutputDataSimpleNormalizer.pypp.cpp
@@ -33,11 +33,11 @@ struct OutputDataSimpleNormalizer_wrapper : OutputDataSimpleNormalizer, bp::wrap
     virtual ::OutputDataSimpleNormalizer * clone(  ) const  {
         if( bp::override func_clone = this->get_override( "clone" ) )
             return func_clone(  );
-        else{
+        else
             return this->OutputDataSimpleNormalizer::clone(  );
-        }
     }
     
+    
     ::OutputDataSimpleNormalizer * default_clone(  ) const  {
         return OutputDataSimpleNormalizer::clone( );
     }
@@ -45,11 +45,11 @@ struct OutputDataSimpleNormalizer_wrapper : OutputDataSimpleNormalizer, bp::wrap
     virtual void setMaximumIntensity( double max_intensity ) {
         if( bp::override func_setMaximumIntensity = this->get_override( "setMaximumIntensity" ) )
             func_setMaximumIntensity( max_intensity );
-        else{
+        else
             this->OutputDataSimpleNormalizer::setMaximumIntensity( max_intensity );
-        }
     }
     
+    
     void default_setMaximumIntensity( double max_intensity ) {
         OutputDataSimpleNormalizer::setMaximumIntensity( max_intensity );
     }
@@ -57,11 +57,11 @@ struct OutputDataSimpleNormalizer_wrapper : OutputDataSimpleNormalizer, bp::wrap
     virtual ::OutputData< double > * createNormalizedData( ::OutputData< double > const & data ) const  {
         if( bp::override func_createNormalizedData = this->get_override( "createNormalizedData" ) )
             return func_createNormalizedData( boost::ref(data) );
-        else{
+        else
             return this->OutputDataNormalizer::createNormalizedData( boost::ref(data) );
-        }
     }
     
+    
     ::OutputData< double > * default_createNormalizedData( ::OutputData< double > const & data ) const  {
         return OutputDataNormalizer::createNormalizedData( boost::ref(data) );
     }
diff --git a/Fit/PythonAPI/src/PythonModule.cpp b/Fit/PythonAPI/src/PythonModule.cpp
index a505ce9bb29347cfe8c4f4e4b2d5d9cbb5fac35f..52a616d52fb25673f53b35e4764df957007fc2b3 100644
--- a/Fit/PythonAPI/src/PythonModule.cpp
+++ b/Fit/PythonAPI/src/PythonModule.cpp
@@ -6,27 +6,27 @@ GCC_DIAG_OFF(missing-field-initializers);
 GCC_DIAG_ON(unused-parameter);
 GCC_DIAG_ON(missing-field-initializers);
 
+#include "SquaredFunctionWithGaussianError.pypp.h" 
+#include "OutputDataSimpleNormalizer.pypp.h" 
 #include "AttFitting.pypp.h" 
-#include "AttLimits.pypp.h" 
-#include "ChiSquaredModule.pypp.h" 
-#include "FitObject.pypp.h" 
-#include "FitParameter.pypp.h" 
-#include "FitSuite.pypp.h" 
 #include "FitSuiteObjects.pypp.h" 
-#include "FitSuiteParameters.pypp.h" 
-#include "IChiSquaredModule.pypp.h" 
-#include "IMinimizer.pypp.h" 
-#include "INamed.pypp.h" 
-#include "IOutputDataNormalizer.pypp.h" 
 #include "ISquaredFunction.pypp.h" 
 #include "MinimizerFactory.pypp.h" 
-#include "MinimizerOptions.pypp.h" 
 #include "OutputDataNormalizer.pypp.h" 
-#include "OutputDataSimpleNormalizer.pypp.h" 
-#include "SquaredFunctionDefault.pypp.h" 
-#include "SquaredFunctionWhichOnlyWorks.pypp.h" 
-#include "SquaredFunctionWithGaussianError.pypp.h" 
+#include "MinimizerOptions.pypp.h" 
 #include "SquaredFunctionWithSystematicError.pypp.h" 
+#include "IOutputDataNormalizer.pypp.h" 
+#include "SquaredFunctionWhichOnlyWorks.pypp.h" 
+#include "FitParameter.pypp.h" 
+#include "FitObject.pypp.h" 
+#include "IMinimizer.pypp.h" 
+#include "INamed.pypp.h" 
+#include "SquaredFunctionDefault.pypp.h" 
+#include "ChiSquaredModule.pypp.h" 
+#include "FitSuite.pypp.h" 
+#include "AttLimits.pypp.h" 
+#include "IChiSquaredModule.pypp.h" 
+#include "FitSuiteParameters.pypp.h" 
 
 BOOST_PYTHON_MODULE(libBornAgainFit){
 
diff --git a/Fit/PythonAPI/src/SquaredFunctionDefault.pypp.cpp b/Fit/PythonAPI/src/SquaredFunctionDefault.pypp.cpp
index 24c1031d440dfb73a3a0f7df006e34d0ea02bb61..3b0b52c824aaccf828d36061a7c0a4ba77a587a3 100644
--- a/Fit/PythonAPI/src/SquaredFunctionDefault.pypp.cpp
+++ b/Fit/PythonAPI/src/SquaredFunctionDefault.pypp.cpp
@@ -33,11 +33,11 @@ struct SquaredFunctionDefault_wrapper : SquaredFunctionDefault, bp::wrapper< Squ
     virtual double calculateSquaredDifference( double real_value, double simulated_value ) const  {
         if( bp::override func_calculateSquaredDifference = this->get_override( "calculateSquaredDifference" ) )
             return func_calculateSquaredDifference( real_value, simulated_value );
-        else{
+        else
             return this->SquaredFunctionDefault::calculateSquaredDifference( real_value, simulated_value );
-        }
     }
     
+    
     double default_calculateSquaredDifference( double real_value, double simulated_value ) const  {
         return SquaredFunctionDefault::calculateSquaredDifference( real_value, simulated_value );
     }
@@ -45,11 +45,11 @@ struct SquaredFunctionDefault_wrapper : SquaredFunctionDefault, bp::wrapper< Squ
     virtual double calculateSquaredError( double real_value, double arg1 ) const  {
         if( bp::override func_calculateSquaredError = this->get_override( "calculateSquaredError" ) )
             return func_calculateSquaredError( real_value, arg1 );
-        else{
+        else
             return this->SquaredFunctionDefault::calculateSquaredError( real_value, arg1 );
-        }
     }
     
+    
     double default_calculateSquaredError( double real_value, double arg1 ) const  {
         return SquaredFunctionDefault::calculateSquaredError( real_value, arg1 );
     }
@@ -57,11 +57,11 @@ struct SquaredFunctionDefault_wrapper : SquaredFunctionDefault, bp::wrapper< Squ
     virtual ::SquaredFunctionDefault * clone(  ) const  {
         if( bp::override func_clone = this->get_override( "clone" ) )
             return func_clone(  );
-        else{
+        else
             return this->SquaredFunctionDefault::clone(  );
-        }
     }
     
+    
     ::SquaredFunctionDefault * default_clone(  ) const  {
         return SquaredFunctionDefault::clone( );
     }
diff --git a/Fit/PythonAPI/src/SquaredFunctionWhichOnlyWorks.pypp.cpp b/Fit/PythonAPI/src/SquaredFunctionWhichOnlyWorks.pypp.cpp
index bbb302b394a39e8dbddda31cd8b59120bf12a96c..378918ee7ee2be818a1e7e61ee959902551042b7 100644
--- a/Fit/PythonAPI/src/SquaredFunctionWhichOnlyWorks.pypp.cpp
+++ b/Fit/PythonAPI/src/SquaredFunctionWhichOnlyWorks.pypp.cpp
@@ -33,11 +33,11 @@ struct SquaredFunctionWhichOnlyWorks_wrapper : SquaredFunctionWhichOnlyWorks, bp
     virtual double calculateSquaredDifference( double real_value, double simulated_value ) const  {
         if( bp::override func_calculateSquaredDifference = this->get_override( "calculateSquaredDifference" ) )
             return func_calculateSquaredDifference( real_value, simulated_value );
-        else{
+        else
             return this->SquaredFunctionWhichOnlyWorks::calculateSquaredDifference( real_value, simulated_value );
-        }
     }
     
+    
     double default_calculateSquaredDifference( double real_value, double simulated_value ) const  {
         return SquaredFunctionWhichOnlyWorks::calculateSquaredDifference( real_value, simulated_value );
     }
@@ -45,11 +45,11 @@ struct SquaredFunctionWhichOnlyWorks_wrapper : SquaredFunctionWhichOnlyWorks, bp
     virtual ::SquaredFunctionWhichOnlyWorks * clone(  ) const  {
         if( bp::override func_clone = this->get_override( "clone" ) )
             return func_clone(  );
-        else{
+        else
             return this->SquaredFunctionWhichOnlyWorks::clone(  );
-        }
     }
     
+    
     ::SquaredFunctionWhichOnlyWorks * default_clone(  ) const  {
         return SquaredFunctionWhichOnlyWorks::clone( );
     }
@@ -57,11 +57,11 @@ struct SquaredFunctionWhichOnlyWorks_wrapper : SquaredFunctionWhichOnlyWorks, bp
     virtual double calculateSquaredError( double real_value, double simulated_value=0.0 ) const  {
         if( bp::override func_calculateSquaredError = this->get_override( "calculateSquaredError" ) )
             return func_calculateSquaredError( real_value, simulated_value );
-        else{
+        else
             return this->ISquaredFunction::calculateSquaredError( real_value, simulated_value );
-        }
     }
     
+    
     double default_calculateSquaredError( double real_value, double simulated_value=0.0 ) const  {
         return ISquaredFunction::calculateSquaredError( real_value, simulated_value );
     }
diff --git a/Fit/PythonAPI/src/SquaredFunctionWithGaussianError.pypp.cpp b/Fit/PythonAPI/src/SquaredFunctionWithGaussianError.pypp.cpp
index 87abc082ddab8fe0715b108485d9918c947bae3c..6d869a72a869ab3957b46ac5c9d8a469bc25395d 100644
--- a/Fit/PythonAPI/src/SquaredFunctionWithGaussianError.pypp.cpp
+++ b/Fit/PythonAPI/src/SquaredFunctionWithGaussianError.pypp.cpp
@@ -33,11 +33,11 @@ struct SquaredFunctionWithGaussianError_wrapper : SquaredFunctionWithGaussianErr
     virtual double calculateSquaredDifference( double real_value, double simulated_value ) const  {
         if( bp::override func_calculateSquaredDifference = this->get_override( "calculateSquaredDifference" ) )
             return func_calculateSquaredDifference( real_value, simulated_value );
-        else{
+        else
             return this->SquaredFunctionWithGaussianError::calculateSquaredDifference( real_value, simulated_value );
-        }
     }
     
+    
     double default_calculateSquaredDifference( double real_value, double simulated_value ) const  {
         return SquaredFunctionWithGaussianError::calculateSquaredDifference( real_value, simulated_value );
     }
@@ -45,11 +45,11 @@ struct SquaredFunctionWithGaussianError_wrapper : SquaredFunctionWithGaussianErr
     virtual double calculateSquaredError( double arg0, double arg1 ) const  {
         if( bp::override func_calculateSquaredError = this->get_override( "calculateSquaredError" ) )
             return func_calculateSquaredError( arg0, arg1 );
-        else{
+        else
             return this->SquaredFunctionWithGaussianError::calculateSquaredError( arg0, arg1 );
-        }
     }
     
+    
     double default_calculateSquaredError( double arg0, double arg1 ) const  {
         return SquaredFunctionWithGaussianError::calculateSquaredError( arg0, arg1 );
     }
@@ -57,11 +57,11 @@ struct SquaredFunctionWithGaussianError_wrapper : SquaredFunctionWithGaussianErr
     virtual ::SquaredFunctionWithGaussianError * clone(  ) const  {
         if( bp::override func_clone = this->get_override( "clone" ) )
             return func_clone(  );
-        else{
+        else
             return this->SquaredFunctionWithGaussianError::clone(  );
-        }
     }
     
+    
     ::SquaredFunctionWithGaussianError * default_clone(  ) const  {
         return SquaredFunctionWithGaussianError::clone( );
     }
diff --git a/Fit/PythonAPI/src/SquaredFunctionWithSystematicError.pypp.cpp b/Fit/PythonAPI/src/SquaredFunctionWithSystematicError.pypp.cpp
index 1129f605a5790a1f9349c749d78ddce6dd9e3e5d..37b0378963542325d24c0bfba602a6189dff1f24 100644
--- a/Fit/PythonAPI/src/SquaredFunctionWithSystematicError.pypp.cpp
+++ b/Fit/PythonAPI/src/SquaredFunctionWithSystematicError.pypp.cpp
@@ -33,11 +33,11 @@ struct SquaredFunctionWithSystematicError_wrapper : SquaredFunctionWithSystemati
     virtual double calculateSquaredDifference( double real_value, double simulated_value ) const  {
         if( bp::override func_calculateSquaredDifference = this->get_override( "calculateSquaredDifference" ) )
             return func_calculateSquaredDifference( real_value, simulated_value );
-        else{
+        else
             return this->SquaredFunctionWithSystematicError::calculateSquaredDifference( real_value, simulated_value );
-        }
     }
     
+    
     double default_calculateSquaredDifference( double real_value, double simulated_value ) const  {
         return SquaredFunctionWithSystematicError::calculateSquaredDifference( real_value, simulated_value );
     }
@@ -45,11 +45,11 @@ struct SquaredFunctionWithSystematicError_wrapper : SquaredFunctionWithSystemati
     virtual double calculateSquaredError( double real_value, double simulated_value=0.0 ) const  {
         if( bp::override func_calculateSquaredError = this->get_override( "calculateSquaredError" ) )
             return func_calculateSquaredError( real_value, simulated_value );
-        else{
+        else
             return this->SquaredFunctionWithSystematicError::calculateSquaredError( real_value, simulated_value );
-        }
     }
     
+    
     double default_calculateSquaredError( double real_value, double simulated_value=0.0 ) const  {
         return SquaredFunctionWithSystematicError::calculateSquaredError( real_value, simulated_value );
     }
@@ -57,11 +57,11 @@ struct SquaredFunctionWithSystematicError_wrapper : SquaredFunctionWithSystemati
     virtual ::SquaredFunctionWithSystematicError * clone(  ) const  {
         if( bp::override func_clone = this->get_override( "clone" ) )
             return func_clone(  );
-        else{
+        else
             return this->SquaredFunctionWithSystematicError::clone(  );
-        }
     }
     
+    
     ::SquaredFunctionWithSystematicError * default_clone(  ) const  {
         return SquaredFunctionWithSystematicError::clone( );
     }
diff --git a/Fit/python_module.pri b/Fit/python_module.pri
index b85ff59160b2ea3247264300f639bf8bc990e16f..71eae99f6300bb9c8953e05ee6618b6dce4bd14c 100644
--- a/Fit/python_module.pri
+++ b/Fit/python_module.pri
@@ -1,51 +1,51 @@
 HEADERS +=  \ 
     PythonAPI/inc/PythonFitExposer.h \ 
     PythonAPI/inc/PythonFitList.h \ 
+    PythonAPI/inc/SquaredFunctionWithGaussianError.pypp.h \
+    PythonAPI/inc/OutputDataSimpleNormalizer.pypp.h \
     PythonAPI/inc/AttFitting.pypp.h \
-    PythonAPI/inc/AttLimits.pypp.h \
-    PythonAPI/inc/ChiSquaredModule.pypp.h \
-    PythonAPI/inc/FitObject.pypp.h \
-    PythonAPI/inc/FitParameter.pypp.h \
-    PythonAPI/inc/FitSuite.pypp.h \
     PythonAPI/inc/FitSuiteObjects.pypp.h \
-    PythonAPI/inc/FitSuiteParameters.pypp.h \
-    PythonAPI/inc/IChiSquaredModule.pypp.h \
-    PythonAPI/inc/IMinimizer.pypp.h \
-    PythonAPI/inc/INamed.pypp.h \
-    PythonAPI/inc/IOutputDataNormalizer.pypp.h \
     PythonAPI/inc/ISquaredFunction.pypp.h \
     PythonAPI/inc/MinimizerFactory.pypp.h \
-    PythonAPI/inc/MinimizerOptions.pypp.h \
     PythonAPI/inc/OutputDataNormalizer.pypp.h \
-    PythonAPI/inc/OutputDataSimpleNormalizer.pypp.h \
-    PythonAPI/inc/SquaredFunctionDefault.pypp.h \
+    PythonAPI/inc/MinimizerOptions.pypp.h \
+    PythonAPI/inc/SquaredFunctionWithSystematicError.pypp.h \
+    PythonAPI/inc/IOutputDataNormalizer.pypp.h \
     PythonAPI/inc/SquaredFunctionWhichOnlyWorks.pypp.h \
-    PythonAPI/inc/SquaredFunctionWithGaussianError.pypp.h \
-    PythonAPI/inc/SquaredFunctionWithSystematicError.pypp.h 
+    PythonAPI/inc/FitParameter.pypp.h \
+    PythonAPI/inc/FitObject.pypp.h \
+    PythonAPI/inc/IMinimizer.pypp.h \
+    PythonAPI/inc/INamed.pypp.h \
+    PythonAPI/inc/SquaredFunctionDefault.pypp.h \
+    PythonAPI/inc/ChiSquaredModule.pypp.h \
+    PythonAPI/inc/FitSuite.pypp.h \
+    PythonAPI/inc/AttLimits.pypp.h \
+    PythonAPI/inc/IChiSquaredModule.pypp.h \
+    PythonAPI/inc/FitSuiteParameters.pypp.h 
 
 SOURCES +=  \ 
     PythonAPI/src/PythonModule.cpp \ 
-    PythonAPI/src/AttFitting.pypp.cpp \
+    PythonAPI/src/OutputDataSimpleNormalizer.pypp.cpp \
+    PythonAPI/src/SquaredFunctionWithSystematicError.pypp.cpp \
+    PythonAPI/src/INamed.pypp.cpp \
+    PythonAPI/src/FitParameter.pypp.cpp \
     PythonAPI/src/AttLimits.pypp.cpp \
     PythonAPI/src/ChiSquaredModule.pypp.cpp \
-    PythonAPI/src/FitObject.pypp.cpp \
-    PythonAPI/src/FitParameter.pypp.cpp \
-    PythonAPI/src/FitSuite.pypp.cpp \
-    PythonAPI/src/FitSuiteObjects.pypp.cpp \
-    PythonAPI/src/FitSuiteParameters.pypp.cpp \
     PythonAPI/src/IChiSquaredModule.pypp.cpp \
-    PythonAPI/src/IMinimizer.pypp.cpp \
-    PythonAPI/src/INamed.pypp.cpp \
-    PythonAPI/src/IOutputDataNormalizer.pypp.cpp \
-    PythonAPI/src/ISquaredFunction.pypp.cpp \
-    PythonAPI/src/MinimizerFactory.pypp.cpp \
-    PythonAPI/src/MinimizerOptions.pypp.cpp \
-    PythonAPI/src/OutputDataNormalizer.pypp.cpp \
-    PythonAPI/src/OutputDataSimpleNormalizer.pypp.cpp \
     PythonAPI/src/SquaredFunctionDefault.pypp.cpp \
     PythonAPI/src/SquaredFunctionWhichOnlyWorks.pypp.cpp \
+    PythonAPI/src/OutputDataNormalizer.pypp.cpp \
+    PythonAPI/src/FitSuite.pypp.cpp \
+    PythonAPI/src/IMinimizer.pypp.cpp \
     PythonAPI/src/SquaredFunctionWithGaussianError.pypp.cpp \
-    PythonAPI/src/SquaredFunctionWithSystematicError.pypp.cpp 
+    PythonAPI/src/MinimizerFactory.pypp.cpp \
+    PythonAPI/src/ISquaredFunction.pypp.cpp \
+    PythonAPI/src/IOutputDataNormalizer.pypp.cpp \
+    PythonAPI/src/FitSuiteObjects.pypp.cpp \
+    PythonAPI/src/FitObject.pypp.cpp \
+    PythonAPI/src/AttFitting.pypp.cpp \
+    PythonAPI/src/FitSuiteParameters.pypp.cpp \
+    PythonAPI/src/MinimizerOptions.pypp.cpp 
 
 INCLUDEPATH += ./PythonAPI/inc 
 DEPENDPATH  += ./PythonAPI/inc 
diff --git a/Tests/FunctionalTests/TestCore/IsGISAXS06L4/IsGISAXS06L4.cpp b/Tests/FunctionalTests/TestCore/IsGISAXS06L4/IsGISAXS06L4.cpp
index cf34e6f5d4198e9795313a95a251e82ebc52dd3c..a698783b5aa80d05a899ddc43365c4515e59ca41 100644
--- a/Tests/FunctionalTests/TestCore/IsGISAXS06L4/IsGISAXS06L4.cpp
+++ b/Tests/FunctionalTests/TestCore/IsGISAXS06L4/IsGISAXS06L4.cpp
@@ -49,7 +49,7 @@ void FunctionalTests::IsGISAXS06L4::run(const std::string &path_to_data)
     for (size_t i=0; i<xi.getNbins(); ++i) {
         double xi_value = xi.getBinValue(i);
         double probability = xi.getNormalizedProbability(i);
-        builder.setMatchedParametersValue("*xi",xi_value);
+        builder.setParameterValue("xi",xi_value);
         MultiLayer *p_sample = dynamic_cast<MultiLayer *>(builder.buildSample());
         simulation->setSample(*p_sample);
         simulation->runSimulation();