diff --git a/Core/PythonAPI/src/FormFactorBox.pypp.cpp b/Core/PythonAPI/src/FormFactorBox.pypp.cpp
index 545a8c77d41cd272ae432ad6234956d3055751d3..689b2a239581aea283d87f4002dd510cac72ad6d 100644
--- a/Core/PythonAPI/src/FormFactorBox.pypp.cpp
+++ b/Core/PythonAPI/src/FormFactorBox.pypp.cpp
@@ -157,6 +157,18 @@ struct FormFactorBox_wrapper : FormFactorBox, bp::wrapper< FormFactorBox > {
         return IFormFactorBorn::evaluate( boost::ref(k_i), boost::ref(k_f_bin), alpha_f_bin );
     }
 
+    virtual ::ICompositeSample * getCompositeSample(  ) {
+        if( bp::override func_getCompositeSample = this->get_override( "getCompositeSample" ) )
+            return func_getCompositeSample(  );
+        else
+            return this->ISample::getCompositeSample(  );
+    }
+    
+    
+    ::ICompositeSample * default_getCompositeSample(  ) {
+        return ISample::getCompositeSample( );
+    }
+
     virtual ::ICompositeSample const * getCompositeSample(  ) const  {
         if( bp::override func_getCompositeSample = this->get_override( "getCompositeSample" ) )
             return func_getCompositeSample(  );
@@ -416,6 +428,18 @@ void register_FormFactorBox_class(){
                 , default_evaluate_function_type(&FormFactorBox_wrapper::default_evaluate)
                 , ( bp::arg("k_i"), bp::arg("k_f_bin"), bp::arg("alpha_f_bin") ) );
         
+        }
+        { //::ISample::getCompositeSample
+        
+            typedef ::ICompositeSample * ( ::ISample::*getCompositeSample_function_type )(  ) ;
+            typedef ::ICompositeSample * ( FormFactorBox_wrapper::*default_getCompositeSample_function_type )(  ) ;
+            
+            FormFactorBox_exposer.def( 
+                "getCompositeSample"
+                , getCompositeSample_function_type(&::ISample::getCompositeSample)
+                , default_getCompositeSample_function_type(&FormFactorBox_wrapper::default_getCompositeSample)
+                , bp::return_value_policy< bp::reference_existing_object >() );
+        
         }
         { //::ISample::getCompositeSample
         
diff --git a/Core/PythonAPI/src/FormFactorCone.pypp.cpp b/Core/PythonAPI/src/FormFactorCone.pypp.cpp
index caa337a5de9b0d7de50faf7f205f38aab20c27bc..481e680d04c09f040551beab6135f83659f9e8a7 100644
--- a/Core/PythonAPI/src/FormFactorCone.pypp.cpp
+++ b/Core/PythonAPI/src/FormFactorCone.pypp.cpp
@@ -205,6 +205,18 @@ struct FormFactorCone_wrapper : FormFactorCone, bp::wrapper< FormFactorCone > {
         return IFormFactorBorn::evaluate( boost::ref(k_i), boost::ref(k_f_bin), alpha_f_bin );
     }
 
+    virtual ::ICompositeSample * getCompositeSample(  ) {
+        if( bp::override func_getCompositeSample = this->get_override( "getCompositeSample" ) )
+            return func_getCompositeSample(  );
+        else
+            return this->ISample::getCompositeSample(  );
+    }
+    
+    
+    ::ICompositeSample * default_getCompositeSample(  ) {
+        return ISample::getCompositeSample( );
+    }
+
     virtual ::ICompositeSample const * getCompositeSample(  ) const  {
         if( bp::override func_getCompositeSample = this->get_override( "getCompositeSample" ) )
             return func_getCompositeSample(  );
@@ -502,6 +514,18 @@ void register_FormFactorCone_class(){
                 , default_evaluate_function_type(&FormFactorCone_wrapper::default_evaluate)
                 , ( bp::arg("k_i"), bp::arg("k_f_bin"), bp::arg("alpha_f_bin") ) );
         
+        }
+        { //::ISample::getCompositeSample
+        
+            typedef ::ICompositeSample * ( ::ISample::*getCompositeSample_function_type )(  ) ;
+            typedef ::ICompositeSample * ( FormFactorCone_wrapper::*default_getCompositeSample_function_type )(  ) ;
+            
+            FormFactorCone_exposer.def( 
+                "getCompositeSample"
+                , getCompositeSample_function_type(&::ISample::getCompositeSample)
+                , default_getCompositeSample_function_type(&FormFactorCone_wrapper::default_getCompositeSample)
+                , bp::return_value_policy< bp::reference_existing_object >() );
+        
         }
         { //::ISample::getCompositeSample
         
diff --git a/Core/PythonAPI/src/FormFactorCrystal.pypp.cpp b/Core/PythonAPI/src/FormFactorCrystal.pypp.cpp
index f4956ed3ec4668b672c803a3d108e96e57c0f286..7cc9ec6ebbdbde1ab68d57474603d748b37fb75d 100644
--- a/Core/PythonAPI/src/FormFactorCrystal.pypp.cpp
+++ b/Core/PythonAPI/src/FormFactorCrystal.pypp.cpp
@@ -126,6 +126,18 @@ struct FormFactorCrystal_wrapper : FormFactorCrystal, bp::wrapper< FormFactorCry
         return IParameterized::createParameterTree( );
     }
 
+    virtual ::ICompositeSample * getCompositeSample(  ) {
+        if( bp::override func_getCompositeSample = this->get_override( "getCompositeSample" ) )
+            return func_getCompositeSample(  );
+        else
+            return this->ISample::getCompositeSample(  );
+    }
+    
+    
+    ::ICompositeSample * default_getCompositeSample(  ) {
+        return ISample::getCompositeSample( );
+    }
+
     virtual ::ICompositeSample const * getCompositeSample(  ) const  {
         if( bp::override func_getCompositeSample = this->get_override( "getCompositeSample" ) )
             return func_getCompositeSample(  );
@@ -378,6 +390,18 @@ void register_FormFactorCrystal_class(){
                 , default_createParameterTree_function_type(&FormFactorCrystal_wrapper::default_createParameterTree)
                 , bp::return_value_policy< bp::manage_new_object >() );
         
+        }
+        { //::ISample::getCompositeSample
+        
+            typedef ::ICompositeSample * ( ::ISample::*getCompositeSample_function_type )(  ) ;
+            typedef ::ICompositeSample * ( FormFactorCrystal_wrapper::*default_getCompositeSample_function_type )(  ) ;
+            
+            FormFactorCrystal_exposer.def( 
+                "getCompositeSample"
+                , getCompositeSample_function_type(&::ISample::getCompositeSample)
+                , default_getCompositeSample_function_type(&FormFactorCrystal_wrapper::default_getCompositeSample)
+                , bp::return_value_policy< bp::reference_existing_object >() );
+        
         }
         { //::ISample::getCompositeSample
         
diff --git a/Core/PythonAPI/src/FormFactorCylinder.pypp.cpp b/Core/PythonAPI/src/FormFactorCylinder.pypp.cpp
index 8e6f648fb3f65bf5bb8502c554c44d4b8ece3c08..7c9b65181528b4df30810aa185ed30b289bcf464 100644
--- a/Core/PythonAPI/src/FormFactorCylinder.pypp.cpp
+++ b/Core/PythonAPI/src/FormFactorCylinder.pypp.cpp
@@ -181,6 +181,18 @@ struct FormFactorCylinder_wrapper : FormFactorCylinder, bp::wrapper< FormFactorC
         return IFormFactorBorn::evaluate( boost::ref(k_i), boost::ref(k_f_bin), alpha_f_bin );
     }
 
+    virtual ::ICompositeSample * getCompositeSample(  ) {
+        if( bp::override func_getCompositeSample = this->get_override( "getCompositeSample" ) )
+            return func_getCompositeSample(  );
+        else
+            return this->ISample::getCompositeSample(  );
+    }
+    
+    
+    ::ICompositeSample * default_getCompositeSample(  ) {
+        return ISample::getCompositeSample( );
+    }
+
     virtual ::ICompositeSample const * getCompositeSample(  ) const  {
         if( bp::override func_getCompositeSample = this->get_override( "getCompositeSample" ) )
             return func_getCompositeSample(  );
@@ -455,6 +467,18 @@ void register_FormFactorCylinder_class(){
                 , default_evaluate_function_type(&FormFactorCylinder_wrapper::default_evaluate)
                 , ( bp::arg("k_i"), bp::arg("k_f_bin"), bp::arg("alpha_f_bin") ) );
         
+        }
+        { //::ISample::getCompositeSample
+        
+            typedef ::ICompositeSample * ( ::ISample::*getCompositeSample_function_type )(  ) ;
+            typedef ::ICompositeSample * ( FormFactorCylinder_wrapper::*default_getCompositeSample_function_type )(  ) ;
+            
+            FormFactorCylinder_exposer.def( 
+                "getCompositeSample"
+                , getCompositeSample_function_type(&::ISample::getCompositeSample)
+                , default_getCompositeSample_function_type(&FormFactorCylinder_wrapper::default_getCompositeSample)
+                , bp::return_value_policy< bp::reference_existing_object >() );
+        
         }
         { //::ISample::getCompositeSample
         
diff --git a/Core/PythonAPI/src/FormFactorDecoratorDebyeWaller.pypp.cpp b/Core/PythonAPI/src/FormFactorDecoratorDebyeWaller.pypp.cpp
index b7d22d1b008955fff615cc70a634b8d99ff38c9b..5ca0c6defc80f17e528b1b936ec8d2df0e792d86 100644
--- a/Core/PythonAPI/src/FormFactorDecoratorDebyeWaller.pypp.cpp
+++ b/Core/PythonAPI/src/FormFactorDecoratorDebyeWaller.pypp.cpp
@@ -121,6 +121,18 @@ struct FormFactorDecoratorDebyeWaller_wrapper : FormFactorDecoratorDebyeWaller,
         return IParameterized::createParameterTree( );
     }
 
+    virtual ::ICompositeSample * getCompositeSample(  ) {
+        if( bp::override func_getCompositeSample = this->get_override( "getCompositeSample" ) )
+            return func_getCompositeSample(  );
+        else
+            return this->ISample::getCompositeSample(  );
+    }
+    
+    
+    ::ICompositeSample * default_getCompositeSample(  ) {
+        return ISample::getCompositeSample( );
+    }
+
     virtual ::ICompositeSample const * getCompositeSample(  ) const  {
         if( bp::override func_getCompositeSample = this->get_override( "getCompositeSample" ) )
             return func_getCompositeSample(  );
@@ -361,6 +373,18 @@ void register_FormFactorDecoratorDebyeWaller_class(){
                 , default_createParameterTree_function_type(&FormFactorDecoratorDebyeWaller_wrapper::default_createParameterTree)
                 , bp::return_value_policy< bp::manage_new_object >() );
         
+        }
+        { //::ISample::getCompositeSample
+        
+            typedef ::ICompositeSample * ( ::ISample::*getCompositeSample_function_type )(  ) ;
+            typedef ::ICompositeSample * ( FormFactorDecoratorDebyeWaller_wrapper::*default_getCompositeSample_function_type )(  ) ;
+            
+            FormFactorDecoratorDebyeWaller_exposer.def( 
+                "getCompositeSample"
+                , getCompositeSample_function_type(&::ISample::getCompositeSample)
+                , default_getCompositeSample_function_type(&FormFactorDecoratorDebyeWaller_wrapper::default_getCompositeSample)
+                , bp::return_value_policy< bp::reference_existing_object >() );
+        
         }
         { //::ISample::getCompositeSample
         
diff --git a/Core/PythonAPI/src/FormFactorEllipsoid.pypp.cpp b/Core/PythonAPI/src/FormFactorEllipsoid.pypp.cpp
index f5b8c13ec58113eb0ae4ec114a3479397b9bf0c7..570c7b1e1a3de59f28222856ad5627a74e506c99 100644
--- a/Core/PythonAPI/src/FormFactorEllipsoid.pypp.cpp
+++ b/Core/PythonAPI/src/FormFactorEllipsoid.pypp.cpp
@@ -157,6 +157,18 @@ struct FormFactorEllipsoid_wrapper : FormFactorEllipsoid, bp::wrapper< FormFacto
         return IFormFactorBorn::evaluate( boost::ref(k_i), boost::ref(k_f_bin), alpha_f_bin );
     }
 
+    virtual ::ICompositeSample * getCompositeSample(  ) {
+        if( bp::override func_getCompositeSample = this->get_override( "getCompositeSample" ) )
+            return func_getCompositeSample(  );
+        else
+            return this->ISample::getCompositeSample(  );
+    }
+    
+    
+    ::ICompositeSample * default_getCompositeSample(  ) {
+        return ISample::getCompositeSample( );
+    }
+
     virtual ::ICompositeSample const * getCompositeSample(  ) const  {
         if( bp::override func_getCompositeSample = this->get_override( "getCompositeSample" ) )
             return func_getCompositeSample(  );
@@ -416,6 +428,18 @@ void register_FormFactorEllipsoid_class(){
                 , default_evaluate_function_type(&FormFactorEllipsoid_wrapper::default_evaluate)
                 , ( bp::arg("k_i"), bp::arg("k_f_bin"), bp::arg("alpha_f_bin") ) );
         
+        }
+        { //::ISample::getCompositeSample
+        
+            typedef ::ICompositeSample * ( ::ISample::*getCompositeSample_function_type )(  ) ;
+            typedef ::ICompositeSample * ( FormFactorEllipsoid_wrapper::*default_getCompositeSample_function_type )(  ) ;
+            
+            FormFactorEllipsoid_exposer.def( 
+                "getCompositeSample"
+                , getCompositeSample_function_type(&::ISample::getCompositeSample)
+                , default_getCompositeSample_function_type(&FormFactorEllipsoid_wrapper::default_getCompositeSample)
+                , bp::return_value_policy< bp::reference_existing_object >() );
+        
         }
         { //::ISample::getCompositeSample
         
diff --git a/Core/PythonAPI/src/FormFactorFullSphere.pypp.cpp b/Core/PythonAPI/src/FormFactorFullSphere.pypp.cpp
index 3849c05432af743970fbe2db9a8a797dac9f13e1..b732c4c4b74fbde714e2b8806e8c50094bbbd023 100644
--- a/Core/PythonAPI/src/FormFactorFullSphere.pypp.cpp
+++ b/Core/PythonAPI/src/FormFactorFullSphere.pypp.cpp
@@ -169,6 +169,18 @@ struct FormFactorFullSphere_wrapper : FormFactorFullSphere, bp::wrapper< FormFac
         return IFormFactorBorn::evaluate( boost::ref(k_i), boost::ref(k_f_bin), alpha_f_bin );
     }
 
+    virtual ::ICompositeSample * getCompositeSample(  ) {
+        if( bp::override func_getCompositeSample = this->get_override( "getCompositeSample" ) )
+            return func_getCompositeSample(  );
+        else
+            return this->ISample::getCompositeSample(  );
+    }
+    
+    
+    ::ICompositeSample * default_getCompositeSample(  ) {
+        return ISample::getCompositeSample( );
+    }
+
     virtual ::ICompositeSample const * getCompositeSample(  ) const  {
         if( bp::override func_getCompositeSample = this->get_override( "getCompositeSample" ) )
             return func_getCompositeSample(  );
@@ -431,6 +443,18 @@ void register_FormFactorFullSphere_class(){
                 , default_evaluate_function_type(&FormFactorFullSphere_wrapper::default_evaluate)
                 , ( bp::arg("k_i"), bp::arg("k_f_bin"), bp::arg("alpha_f_bin") ) );
         
+        }
+        { //::ISample::getCompositeSample
+        
+            typedef ::ICompositeSample * ( ::ISample::*getCompositeSample_function_type )(  ) ;
+            typedef ::ICompositeSample * ( FormFactorFullSphere_wrapper::*default_getCompositeSample_function_type )(  ) ;
+            
+            FormFactorFullSphere_exposer.def( 
+                "getCompositeSample"
+                , getCompositeSample_function_type(&::ISample::getCompositeSample)
+                , default_getCompositeSample_function_type(&FormFactorFullSphere_wrapper::default_getCompositeSample)
+                , bp::return_value_policy< bp::reference_existing_object >() );
+        
         }
         { //::ISample::getCompositeSample
         
diff --git a/Core/PythonAPI/src/FormFactorFullSpheroid.pypp.cpp b/Core/PythonAPI/src/FormFactorFullSpheroid.pypp.cpp
index 02848d2d2afeea7cac6d890cd9231fcfc265866b..6e0df1159a83cfac78d16254cf41719190d264f1 100644
--- a/Core/PythonAPI/src/FormFactorFullSpheroid.pypp.cpp
+++ b/Core/PythonAPI/src/FormFactorFullSpheroid.pypp.cpp
@@ -157,6 +157,18 @@ struct FormFactorFullSpheroid_wrapper : FormFactorFullSpheroid, bp::wrapper< For
         return IFormFactorBorn::evaluate( boost::ref(k_i), boost::ref(k_f_bin), alpha_f_bin );
     }
 
+    virtual ::ICompositeSample * getCompositeSample(  ) {
+        if( bp::override func_getCompositeSample = this->get_override( "getCompositeSample" ) )
+            return func_getCompositeSample(  );
+        else
+            return this->ISample::getCompositeSample(  );
+    }
+    
+    
+    ::ICompositeSample * default_getCompositeSample(  ) {
+        return ISample::getCompositeSample( );
+    }
+
     virtual ::ICompositeSample const * getCompositeSample(  ) const  {
         if( bp::override func_getCompositeSample = this->get_override( "getCompositeSample" ) )
             return func_getCompositeSample(  );
@@ -407,6 +419,18 @@ void register_FormFactorFullSpheroid_class(){
                 , default_evaluate_function_type(&FormFactorFullSpheroid_wrapper::default_evaluate)
                 , ( bp::arg("k_i"), bp::arg("k_f_bin"), bp::arg("alpha_f_bin") ) );
         
+        }
+        { //::ISample::getCompositeSample
+        
+            typedef ::ICompositeSample * ( ::ISample::*getCompositeSample_function_type )(  ) ;
+            typedef ::ICompositeSample * ( FormFactorFullSpheroid_wrapper::*default_getCompositeSample_function_type )(  ) ;
+            
+            FormFactorFullSpheroid_exposer.def( 
+                "getCompositeSample"
+                , getCompositeSample_function_type(&::ISample::getCompositeSample)
+                , default_getCompositeSample_function_type(&FormFactorFullSpheroid_wrapper::default_getCompositeSample)
+                , bp::return_value_policy< bp::reference_existing_object >() );
+        
         }
         { //::ISample::getCompositeSample
         
diff --git a/Core/PythonAPI/src/FormFactorGauss.pypp.cpp b/Core/PythonAPI/src/FormFactorGauss.pypp.cpp
index c0431a98d53f87d0b56028b8e4a0d28bebd45f1f..58a86a60b6bb05dbf366ad31fc02c157f350fef1 100644
--- a/Core/PythonAPI/src/FormFactorGauss.pypp.cpp
+++ b/Core/PythonAPI/src/FormFactorGauss.pypp.cpp
@@ -176,6 +176,18 @@ struct FormFactorGauss_wrapper : FormFactorGauss, bp::wrapper< FormFactorGauss >
         return IFormFactorBorn::evaluate( boost::ref(k_i), boost::ref(k_f_bin), alpha_f_bin );
     }
 
+    virtual ::ICompositeSample * getCompositeSample(  ) {
+        if( bp::override func_getCompositeSample = this->get_override( "getCompositeSample" ) )
+            return func_getCompositeSample(  );
+        else
+            return this->ISample::getCompositeSample(  );
+    }
+    
+    
+    ::ICompositeSample * default_getCompositeSample(  ) {
+        return ISample::getCompositeSample( );
+    }
+
     virtual ::ICompositeSample const * getCompositeSample(  ) const  {
         if( bp::override func_getCompositeSample = this->get_override( "getCompositeSample" ) )
             return func_getCompositeSample(  );
@@ -426,6 +438,18 @@ void register_FormFactorGauss_class(){
                 , default_evaluate_function_type(&FormFactorGauss_wrapper::default_evaluate)
                 , ( bp::arg("k_i"), bp::arg("k_f_bin"), bp::arg("alpha_f_bin") ) );
         
+        }
+        { //::ISample::getCompositeSample
+        
+            typedef ::ICompositeSample * ( ::ISample::*getCompositeSample_function_type )(  ) ;
+            typedef ::ICompositeSample * ( FormFactorGauss_wrapper::*default_getCompositeSample_function_type )(  ) ;
+            
+            FormFactorGauss_exposer.def( 
+                "getCompositeSample"
+                , getCompositeSample_function_type(&::ISample::getCompositeSample)
+                , default_getCompositeSample_function_type(&FormFactorGauss_wrapper::default_getCompositeSample)
+                , bp::return_value_policy< bp::reference_existing_object >() );
+        
         }
         { //::ISample::getCompositeSample
         
diff --git a/Core/PythonAPI/src/FormFactorHemiSpheroid.pypp.cpp b/Core/PythonAPI/src/FormFactorHemiSpheroid.pypp.cpp
index 1a300af87c57d5d832a1b2b723e8548daf4099ba..c1d58276681263c58187d2106dc2086366252171 100644
--- a/Core/PythonAPI/src/FormFactorHemiSpheroid.pypp.cpp
+++ b/Core/PythonAPI/src/FormFactorHemiSpheroid.pypp.cpp
@@ -133,6 +133,18 @@ struct FormFactorHemiSpheroid_wrapper : FormFactorHemiSpheroid, bp::wrapper< For
         return IFormFactorBorn::evaluate( boost::ref(k_i), boost::ref(k_f_bin), alpha_f_bin );
     }
 
+    virtual ::ICompositeSample * getCompositeSample(  ) {
+        if( bp::override func_getCompositeSample = this->get_override( "getCompositeSample" ) )
+            return func_getCompositeSample(  );
+        else
+            return this->ISample::getCompositeSample(  );
+    }
+    
+    
+    ::ICompositeSample * default_getCompositeSample(  ) {
+        return ISample::getCompositeSample( );
+    }
+
     virtual ::ICompositeSample const * getCompositeSample(  ) const  {
         if( bp::override func_getCompositeSample = this->get_override( "getCompositeSample" ) )
             return func_getCompositeSample(  );
@@ -372,6 +384,18 @@ void register_FormFactorHemiSpheroid_class(){
                 , default_evaluate_function_type(&FormFactorHemiSpheroid_wrapper::default_evaluate)
                 , ( bp::arg("k_i"), bp::arg("k_f_bin"), bp::arg("alpha_f_bin") ) );
         
+        }
+        { //::ISample::getCompositeSample
+        
+            typedef ::ICompositeSample * ( ::ISample::*getCompositeSample_function_type )(  ) ;
+            typedef ::ICompositeSample * ( FormFactorHemiSpheroid_wrapper::*default_getCompositeSample_function_type )(  ) ;
+            
+            FormFactorHemiSpheroid_exposer.def( 
+                "getCompositeSample"
+                , getCompositeSample_function_type(&::ISample::getCompositeSample)
+                , default_getCompositeSample_function_type(&FormFactorHemiSpheroid_wrapper::default_getCompositeSample)
+                , bp::return_value_policy< bp::reference_existing_object >() );
+        
         }
         { //::ISample::getCompositeSample
         
diff --git a/Core/PythonAPI/src/FormFactorLorentz.pypp.cpp b/Core/PythonAPI/src/FormFactorLorentz.pypp.cpp
index 4b41e00edca20e7caa2fb92cc6d95296a2b494c7..044f59d6a75e43cd65bcadc7c5dfab7f25912e13 100644
--- a/Core/PythonAPI/src/FormFactorLorentz.pypp.cpp
+++ b/Core/PythonAPI/src/FormFactorLorentz.pypp.cpp
@@ -140,6 +140,18 @@ struct FormFactorLorentz_wrapper : FormFactorLorentz, bp::wrapper< FormFactorLor
         return IFormFactorBorn::evaluate( boost::ref(k_i), boost::ref(k_f_bin), alpha_f_bin );
     }
 
+    virtual ::ICompositeSample * getCompositeSample(  ) {
+        if( bp::override func_getCompositeSample = this->get_override( "getCompositeSample" ) )
+            return func_getCompositeSample(  );
+        else
+            return this->ISample::getCompositeSample(  );
+    }
+    
+    
+    ::ICompositeSample * default_getCompositeSample(  ) {
+        return ISample::getCompositeSample( );
+    }
+
     virtual ::ICompositeSample const * getCompositeSample(  ) const  {
         if( bp::override func_getCompositeSample = this->get_override( "getCompositeSample" ) )
             return func_getCompositeSample(  );
@@ -393,6 +405,18 @@ void register_FormFactorLorentz_class(){
                 , default_evaluate_function_type(&FormFactorLorentz_wrapper::default_evaluate)
                 , ( bp::arg("k_i"), bp::arg("k_f_bin"), bp::arg("alpha_f_bin") ) );
         
+        }
+        { //::ISample::getCompositeSample
+        
+            typedef ::ICompositeSample * ( ::ISample::*getCompositeSample_function_type )(  ) ;
+            typedef ::ICompositeSample * ( FormFactorLorentz_wrapper::*default_getCompositeSample_function_type )(  ) ;
+            
+            FormFactorLorentz_exposer.def( 
+                "getCompositeSample"
+                , getCompositeSample_function_type(&::ISample::getCompositeSample)
+                , default_getCompositeSample_function_type(&FormFactorLorentz_wrapper::default_getCompositeSample)
+                , bp::return_value_policy< bp::reference_existing_object >() );
+        
         }
         { //::ISample::getCompositeSample
         
diff --git a/Core/PythonAPI/src/FormFactorParallelepiped.pypp.cpp b/Core/PythonAPI/src/FormFactorParallelepiped.pypp.cpp
index 20268561acd1ab05bc4e0573555c27aac0b8b4b0..d9cced20d1ecae133546fec9b666b820e948b79d 100644
--- a/Core/PythonAPI/src/FormFactorParallelepiped.pypp.cpp
+++ b/Core/PythonAPI/src/FormFactorParallelepiped.pypp.cpp
@@ -157,6 +157,18 @@ struct FormFactorParallelepiped_wrapper : FormFactorParallelepiped, bp::wrapper<
         return IFormFactorBorn::evaluate( boost::ref(k_i), boost::ref(k_f_bin), alpha_f_bin );
     }
 
+    virtual ::ICompositeSample * getCompositeSample(  ) {
+        if( bp::override func_getCompositeSample = this->get_override( "getCompositeSample" ) )
+            return func_getCompositeSample(  );
+        else
+            return this->ISample::getCompositeSample(  );
+    }
+    
+    
+    ::ICompositeSample * default_getCompositeSample(  ) {
+        return ISample::getCompositeSample( );
+    }
+
     virtual ::ICompositeSample const * getCompositeSample(  ) const  {
         if( bp::override func_getCompositeSample = this->get_override( "getCompositeSample" ) )
             return func_getCompositeSample(  );
@@ -407,6 +419,18 @@ void register_FormFactorParallelepiped_class(){
                 , default_evaluate_function_type(&FormFactorParallelepiped_wrapper::default_evaluate)
                 , ( bp::arg("k_i"), bp::arg("k_f_bin"), bp::arg("alpha_f_bin") ) );
         
+        }
+        { //::ISample::getCompositeSample
+        
+            typedef ::ICompositeSample * ( ::ISample::*getCompositeSample_function_type )(  ) ;
+            typedef ::ICompositeSample * ( FormFactorParallelepiped_wrapper::*default_getCompositeSample_function_type )(  ) ;
+            
+            FormFactorParallelepiped_exposer.def( 
+                "getCompositeSample"
+                , getCompositeSample_function_type(&::ISample::getCompositeSample)
+                , default_getCompositeSample_function_type(&FormFactorParallelepiped_wrapper::default_getCompositeSample)
+                , bp::return_value_policy< bp::reference_existing_object >() );
+        
         }
         { //::ISample::getCompositeSample
         
diff --git a/Core/PythonAPI/src/FormFactorPrism3.pypp.cpp b/Core/PythonAPI/src/FormFactorPrism3.pypp.cpp
index 7344a006a550e713af3795888c6ef0ab692df703..c84469abf8bade55a52c386e08b8631e99aa2f98 100644
--- a/Core/PythonAPI/src/FormFactorPrism3.pypp.cpp
+++ b/Core/PythonAPI/src/FormFactorPrism3.pypp.cpp
@@ -181,6 +181,18 @@ struct FormFactorPrism3_wrapper : FormFactorPrism3, bp::wrapper< FormFactorPrism
         return IFormFactorBorn::evaluate( boost::ref(k_i), boost::ref(k_f_bin), alpha_f_bin );
     }
 
+    virtual ::ICompositeSample * getCompositeSample(  ) {
+        if( bp::override func_getCompositeSample = this->get_override( "getCompositeSample" ) )
+            return func_getCompositeSample(  );
+        else
+            return this->ISample::getCompositeSample(  );
+    }
+    
+    
+    ::ICompositeSample * default_getCompositeSample(  ) {
+        return ISample::getCompositeSample( );
+    }
+
     virtual ::ICompositeSample const * getCompositeSample(  ) const  {
         if( bp::override func_getCompositeSample = this->get_override( "getCompositeSample" ) )
             return func_getCompositeSample(  );
@@ -467,6 +479,18 @@ void register_FormFactorPrism3_class(){
                 , default_evaluate_function_type(&FormFactorPrism3_wrapper::default_evaluate)
                 , ( bp::arg("k_i"), bp::arg("k_f_bin"), bp::arg("alpha_f_bin") ) );
         
+        }
+        { //::ISample::getCompositeSample
+        
+            typedef ::ICompositeSample * ( ::ISample::*getCompositeSample_function_type )(  ) ;
+            typedef ::ICompositeSample * ( FormFactorPrism3_wrapper::*default_getCompositeSample_function_type )(  ) ;
+            
+            FormFactorPrism3_exposer.def( 
+                "getCompositeSample"
+                , getCompositeSample_function_type(&::ISample::getCompositeSample)
+                , default_getCompositeSample_function_type(&FormFactorPrism3_wrapper::default_getCompositeSample)
+                , bp::return_value_policy< bp::reference_existing_object >() );
+        
         }
         { //::ISample::getCompositeSample
         
diff --git a/Core/PythonAPI/src/FormFactorPrism6.pypp.cpp b/Core/PythonAPI/src/FormFactorPrism6.pypp.cpp
index 23fa49d6c4467d4e8e3a72283745f74f39258308..a4befbea095b6815b87825a29a54be696ec347ef 100644
--- a/Core/PythonAPI/src/FormFactorPrism6.pypp.cpp
+++ b/Core/PythonAPI/src/FormFactorPrism6.pypp.cpp
@@ -181,6 +181,18 @@ struct FormFactorPrism6_wrapper : FormFactorPrism6, bp::wrapper< FormFactorPrism
         return IFormFactorBorn::evaluate( boost::ref(k_i), boost::ref(k_f_bin), alpha_f_bin );
     }
 
+    virtual ::ICompositeSample * getCompositeSample(  ) {
+        if( bp::override func_getCompositeSample = this->get_override( "getCompositeSample" ) )
+            return func_getCompositeSample(  );
+        else
+            return this->ISample::getCompositeSample(  );
+    }
+    
+    
+    ::ICompositeSample * default_getCompositeSample(  ) {
+        return ISample::getCompositeSample( );
+    }
+
     virtual ::ICompositeSample const * getCompositeSample(  ) const  {
         if( bp::override func_getCompositeSample = this->get_override( "getCompositeSample" ) )
             return func_getCompositeSample(  );
@@ -455,6 +467,18 @@ void register_FormFactorPrism6_class(){
                 , default_evaluate_function_type(&FormFactorPrism6_wrapper::default_evaluate)
                 , ( bp::arg("k_i"), bp::arg("k_f_bin"), bp::arg("alpha_f_bin") ) );
         
+        }
+        { //::ISample::getCompositeSample
+        
+            typedef ::ICompositeSample * ( ::ISample::*getCompositeSample_function_type )(  ) ;
+            typedef ::ICompositeSample * ( FormFactorPrism6_wrapper::*default_getCompositeSample_function_type )(  ) ;
+            
+            FormFactorPrism6_exposer.def( 
+                "getCompositeSample"
+                , getCompositeSample_function_type(&::ISample::getCompositeSample)
+                , default_getCompositeSample_function_type(&FormFactorPrism6_wrapper::default_getCompositeSample)
+                , bp::return_value_policy< bp::reference_existing_object >() );
+        
         }
         { //::ISample::getCompositeSample
         
diff --git a/Core/PythonAPI/src/FormFactorPyramid.pypp.cpp b/Core/PythonAPI/src/FormFactorPyramid.pypp.cpp
index db82e8d663c2afc6e668ce94f5ea67552ae52b1c..895607d981bbd9f4fbb973a4aac6c3872d319d75 100644
--- a/Core/PythonAPI/src/FormFactorPyramid.pypp.cpp
+++ b/Core/PythonAPI/src/FormFactorPyramid.pypp.cpp
@@ -205,6 +205,18 @@ struct FormFactorPyramid_wrapper : FormFactorPyramid, bp::wrapper< FormFactorPyr
         return IFormFactorBorn::evaluate( boost::ref(k_i), boost::ref(k_f_bin), alpha_f_bin );
     }
 
+    virtual ::ICompositeSample * getCompositeSample(  ) {
+        if( bp::override func_getCompositeSample = this->get_override( "getCompositeSample" ) )
+            return func_getCompositeSample(  );
+        else
+            return this->ISample::getCompositeSample(  );
+    }
+    
+    
+    ::ICompositeSample * default_getCompositeSample(  ) {
+        return ISample::getCompositeSample( );
+    }
+
     virtual ::ICompositeSample const * getCompositeSample(  ) const  {
         if( bp::override func_getCompositeSample = this->get_override( "getCompositeSample" ) )
             return func_getCompositeSample(  );
@@ -514,6 +526,18 @@ void register_FormFactorPyramid_class(){
                 , default_evaluate_function_type(&FormFactorPyramid_wrapper::default_evaluate)
                 , ( bp::arg("k_i"), bp::arg("k_f_bin"), bp::arg("alpha_f_bin") ) );
         
+        }
+        { //::ISample::getCompositeSample
+        
+            typedef ::ICompositeSample * ( ::ISample::*getCompositeSample_function_type )(  ) ;
+            typedef ::ICompositeSample * ( FormFactorPyramid_wrapper::*default_getCompositeSample_function_type )(  ) ;
+            
+            FormFactorPyramid_exposer.def( 
+                "getCompositeSample"
+                , getCompositeSample_function_type(&::ISample::getCompositeSample)
+                , default_getCompositeSample_function_type(&FormFactorPyramid_wrapper::default_getCompositeSample)
+                , bp::return_value_policy< bp::reference_existing_object >() );
+        
         }
         { //::ISample::getCompositeSample