From d705ffb906dc360f60a5636295113faaa424548b Mon Sep 17 00:00:00 2001
From: Gennady Pospelov <g.pospelov@fz-juelich.de>
Date: Tue, 8 Oct 2013 15:45:20 +0200
Subject: [PATCH] Restructured example directory, setMatchedParameterValue
added to ISample
---
CMakeLists.txt | 2 +-
Core/PythonAPI/src/Beam.pypp.cpp | 24 +++++
Core/PythonAPI/src/Crystal.pypp.cpp | 24 +++++
Core/PythonAPI/src/Detector.pypp.cpp | 24 +++++
.../src/FTDistribution2DCauchy.pypp.cpp | 24 +++++
Core/PythonAPI/src/FormFactorBox.pypp.cpp | 24 +++++
Core/PythonAPI/src/FormFactorCone.pypp.cpp | 24 +++++
Core/PythonAPI/src/FormFactorCrystal.pypp.cpp | 24 +++++
.../PythonAPI/src/FormFactorCylinder.pypp.cpp | 24 +++++
.../FormFactorDecoratorDebyeWaller.pypp.cpp | 24 +++++
.../src/FormFactorEllipsoid.pypp.cpp | 24 +++++
.../src/FormFactorFullSphere.pypp.cpp | 24 +++++
.../src/FormFactorFullSpheroid.pypp.cpp | 24 +++++
Core/PythonAPI/src/FormFactorGauss.pypp.cpp | 24 +++++
.../src/FormFactorHemiSpheroid.pypp.cpp | 24 +++++
Core/PythonAPI/src/FormFactorLorentz.pypp.cpp | 24 +++++
.../src/FormFactorParallelepiped.pypp.cpp | 24 +++++
Core/PythonAPI/src/FormFactorPrism3.pypp.cpp | 24 +++++
Core/PythonAPI/src/FormFactorPrism6.pypp.cpp | 24 +++++
Core/PythonAPI/src/FormFactorPyramid.pypp.cpp | 24 +++++
Core/PythonAPI/src/FormFactorSphere.pypp.cpp | 24 +++++
.../FormFactorSphereGaussianRadius.pypp.cpp | 24 +++++
.../src/IClusteredParticles.pypp.cpp | 24 +++++
Core/PythonAPI/src/ICompositeSample.pypp.cpp | 24 +++++
Core/PythonAPI/src/IDecoration.pypp.cpp | 24 +++++
.../src/IDetectorResolution.pypp.cpp | 24 +++++
Core/PythonAPI/src/IFTDistribution2D.pypp.cpp | 24 +++++
Core/PythonAPI/src/IFormFactor.pypp.cpp | 24 +++++
Core/PythonAPI/src/IFormFactorBorn.pypp.cpp | 24 +++++
.../src/IFormFactorDecorator.pypp.cpp | 24 +++++
.../src/IInterferenceFunction.pypp.cpp | 24 +++++
Core/PythonAPI/src/IParameterized.pypp.cpp | 24 +++++
.../src/IResolutionFunction2D.pypp.cpp | 24 +++++
Core/PythonAPI/src/ISample.pypp.cpp | 24 +++++
Core/PythonAPI/src/ISampleBuilder.pypp.cpp | 24 +++++
Core/PythonAPI/src/Instrument.pypp.cpp | 24 +++++
...InterferenceFunction1DParaCrystal.pypp.cpp | 24 +++++
.../InterferenceFunction2DLattice.pypp.cpp | 24 +++++
...InterferenceFunction2DParaCrystal.pypp.cpp | 24 +++++
.../src/InterferenceFunctionNone.pypp.cpp | 24 +++++
Core/PythonAPI/src/LatticeBasis.pypp.cpp | 24 +++++
Core/PythonAPI/src/Layer.pypp.cpp | 24 +++++
Core/PythonAPI/src/LayerInterface.pypp.cpp | 24 +++++
Core/PythonAPI/src/LayerRoughness.pypp.cpp | 24 +++++
Core/PythonAPI/src/MesoCrystal.pypp.cpp | 24 +++++
Core/PythonAPI/src/MultiLayer.pypp.cpp | 24 +++++
Core/PythonAPI/src/Particle.pypp.cpp | 24 +++++
Core/PythonAPI/src/ParticleCoreShell.pypp.cpp | 24 +++++
.../PythonAPI/src/ParticleDecoration.pypp.cpp | 24 +++++
Core/PythonAPI/src/ParticleInfo.pypp.cpp | 24 +++++
.../src/PositionParticleInfo.pypp.cpp | 24 +++++
Core/PythonAPI/src/PythonModule.cpp | 20 ++--
.../src/ResolutionFunction2DSimple.pypp.cpp | 24 +++++
Core/PythonAPI/src/Simulation.pypp.cpp | 24 +++++
Core/Tools/inc/IParameterized.h | 6 ++
Core/python_module.pri | 40 ++++----
Doc/UserManual/UserManual.pdf | Bin 821235 -> 821232 bytes
Doc/UserManual/UserManual.tex | 2 +-
Examples/python/README | 13 ++-
Examples/python/fitting/README | 15 +++
.../SampleParametersIntro.py | 96 ++++++++++++++++++
.../FitCylindersPrisms.py | 0
.../Refdata_fitcylinderprisms.txt | 0
Examples/python/simulation/README | 29 ++++++
.../CylindersAndPrisms.py | 0
.../CylindersWithSizeDistribution.py | 0
.../CylinderFormfactorInBA.py | 0
.../CylinderFormfactorInBASize.py | 0
.../CylinderFormfactorInDWBA.py | 0
.../CylindersParaCrystal_1DDL.py | 0
.../CylindersParaCrystal_2DDL.py | 0
.../LatticeWithDisorder1.py | 0
.../LatticeWithDisorder2.py | 0
.../LatticeWithDisorder3.py | 0
.../LatticeWithDisorder4.py | 0
.../ex006_RotatedPyramids}/Pyramids.py | 0
.../ex006_RotatedPyramids}/RotatedPyramids.py | 0
Tests/FunctionalTests/TestCore/README | 10 +-
Tests/FunctionalTests/TestPyCore/README | 11 +-
79 files changed, 1442 insertions(+), 50 deletions(-)
create mode 100644 Examples/python/fitting/README
create mode 100644 Examples/python/fitting/ex001_SampleParametersIntro/SampleParametersIntro.py
rename Examples/python/{ex021_FitCylindersAndPrisms => fitting/ex002_FitCylindersAndPrisms}/FitCylindersPrisms.py (100%)
rename Examples/python/{ex021_FitCylindersAndPrisms => fitting/ex002_FitCylindersAndPrisms}/Refdata_fitcylinderprisms.txt (100%)
create mode 100644 Examples/python/simulation/README
rename Examples/python/{ => simulation}/ex001_CylindersAndPrisms/CylindersAndPrisms.py (100%)
rename Examples/python/{ => simulation}/ex002_CylindersWithSizeDistribution/CylindersWithSizeDistribution.py (100%)
rename Examples/python/{ => simulation}/ex003_CylinderFormfactor/CylinderFormfactorInBA.py (100%)
rename Examples/python/{ => simulation}/ex003_CylinderFormfactor/CylinderFormfactorInBASize.py (100%)
rename Examples/python/{ => simulation}/ex003_CylinderFormfactor/CylinderFormfactorInDWBA.py (100%)
rename Examples/python/{ => simulation}/ex004_CylindersParaCrystal/CylindersParaCrystal_1DDL.py (100%)
rename Examples/python/{ => simulation}/ex004_CylindersParaCrystal/CylindersParaCrystal_2DDL.py (100%)
rename Examples/python/{ex006_LatticeWithDisorder => simulation/ex005_LatticeWithDisorder}/LatticeWithDisorder1.py (100%)
rename Examples/python/{ex006_LatticeWithDisorder => simulation/ex005_LatticeWithDisorder}/LatticeWithDisorder2.py (100%)
rename Examples/python/{ex006_LatticeWithDisorder => simulation/ex005_LatticeWithDisorder}/LatticeWithDisorder3.py (100%)
rename Examples/python/{ex006_LatticeWithDisorder => simulation/ex005_LatticeWithDisorder}/LatticeWithDisorder4.py (100%)
rename Examples/python/{ex009_RotatedPyramids => simulation/ex006_RotatedPyramids}/Pyramids.py (100%)
rename Examples/python/{ex009_RotatedPyramids => simulation/ex006_RotatedPyramids}/RotatedPyramids.py (100%)
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 9cc4f95bccb..f9497dcf445 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -9,7 +9,7 @@ project(BornAgain)
# --- General project settings ---
option(BORNAGAIN_PYTHON "Build with python support" ON)
option(BORNAGAIN_APP "Build test application" ON)
-option(BORNAGAIN_GUI "Build a graphical user interface" ON)
+option(BORNAGAIN_GUI "Build a graphical user interface" OFF)
#--- Path for additional cmake modules ---
set(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/modules)
diff --git a/Core/PythonAPI/src/Beam.pypp.cpp b/Core/PythonAPI/src/Beam.pypp.cpp
index 99d3cc39bd7..e2c8d55743e 100644
--- a/Core/PythonAPI/src/Beam.pypp.cpp
+++ b/Core/PythonAPI/src/Beam.pypp.cpp
@@ -99,6 +99,18 @@ struct Beam_wrapper : Beam, bp::wrapper< Beam > {
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -255,6 +267,18 @@ void register_Beam_class(){
, default_registerParameter_function_type( &Beam_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( Beam_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ Beam_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&Beam_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/Crystal.pypp.cpp b/Core/PythonAPI/src/Crystal.pypp.cpp
index 17ad3d29da3..980f50fcce0 100644
--- a/Core/PythonAPI/src/Crystal.pypp.cpp
+++ b/Core/PythonAPI/src/Crystal.pypp.cpp
@@ -116,6 +116,18 @@ struct Crystal_wrapper : Crystal, bp::wrapper< Crystal > {
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -265,6 +277,18 @@ void register_Crystal_class(){
, default_registerParameter_function_type( &Crystal_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( Crystal_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ Crystal_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&Crystal_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/Detector.pypp.cpp b/Core/PythonAPI/src/Detector.pypp.cpp
index 17c52c99368..286cff5b79d 100644
--- a/Core/PythonAPI/src/Detector.pypp.cpp
+++ b/Core/PythonAPI/src/Detector.pypp.cpp
@@ -99,6 +99,18 @@ struct Detector_wrapper : Detector, bp::wrapper< Detector > {
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -236,6 +248,18 @@ void register_Detector_class(){
, default_registerParameter_function_type( &Detector_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( Detector_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ Detector_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&Detector_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/FTDistribution2DCauchy.pypp.cpp b/Core/PythonAPI/src/FTDistribution2DCauchy.pypp.cpp
index ca3f64b3515..7178ab3ede9 100644
--- a/Core/PythonAPI/src/FTDistribution2DCauchy.pypp.cpp
+++ b/Core/PythonAPI/src/FTDistribution2DCauchy.pypp.cpp
@@ -135,6 +135,18 @@ struct FTDistribution2DCauchy_wrapper : FTDistribution2DCauchy, bp::wrapper< FTD
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -257,6 +269,18 @@ void register_FTDistribution2DCauchy_class(){
, default_registerParameter_function_type( &FTDistribution2DCauchy_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( FTDistribution2DCauchy_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ FTDistribution2DCauchy_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&FTDistribution2DCauchy_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/FormFactorBox.pypp.cpp b/Core/PythonAPI/src/FormFactorBox.pypp.cpp
index a32713bd649..6f8c69dc6de 100644
--- a/Core/PythonAPI/src/FormFactorBox.pypp.cpp
+++ b/Core/PythonAPI/src/FormFactorBox.pypp.cpp
@@ -224,6 +224,18 @@ struct FormFactorBox_wrapper : FormFactorBox, bp::wrapper< FormFactorBox > {
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -447,6 +459,18 @@ void register_FormFactorBox_class(){
, default_registerParameter_function_type( &FormFactorBox_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( FormFactorBox_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ FormFactorBox_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&FormFactorBox_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/FormFactorCone.pypp.cpp b/Core/PythonAPI/src/FormFactorCone.pypp.cpp
index b4c262a46c4..89d0f205559 100644
--- a/Core/PythonAPI/src/FormFactorCone.pypp.cpp
+++ b/Core/PythonAPI/src/FormFactorCone.pypp.cpp
@@ -212,6 +212,18 @@ struct FormFactorCone_wrapper : FormFactorCone, bp::wrapper< FormFactorCone > {
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -414,6 +426,18 @@ void register_FormFactorCone_class(){
, default_registerParameter_function_type( &FormFactorCone_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( FormFactorCone_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ FormFactorCone_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&FormFactorCone_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/FormFactorCrystal.pypp.cpp b/Core/PythonAPI/src/FormFactorCrystal.pypp.cpp
index d33b80f25ab..ceabdbe2db0 100644
--- a/Core/PythonAPI/src/FormFactorCrystal.pypp.cpp
+++ b/Core/PythonAPI/src/FormFactorCrystal.pypp.cpp
@@ -217,6 +217,18 @@ struct FormFactorCrystal_wrapper : FormFactorCrystal, bp::wrapper< FormFactorCry
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -431,6 +443,18 @@ void register_FormFactorCrystal_class(){
, default_registerParameter_function_type( &FormFactorCrystal_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( FormFactorCrystal_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ FormFactorCrystal_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&FormFactorCrystal_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/FormFactorCylinder.pypp.cpp b/Core/PythonAPI/src/FormFactorCylinder.pypp.cpp
index 240dd84db9f..ee19b55f3f5 100644
--- a/Core/PythonAPI/src/FormFactorCylinder.pypp.cpp
+++ b/Core/PythonAPI/src/FormFactorCylinder.pypp.cpp
@@ -248,6 +248,18 @@ struct FormFactorCylinder_wrapper : FormFactorCylinder, bp::wrapper< FormFactorC
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -486,6 +498,18 @@ void register_FormFactorCylinder_class(){
, default_registerParameter_function_type( &FormFactorCylinder_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( FormFactorCylinder_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ FormFactorCylinder_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&FormFactorCylinder_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/FormFactorDecoratorDebyeWaller.pypp.cpp b/Core/PythonAPI/src/FormFactorDecoratorDebyeWaller.pypp.cpp
index 8a9e360a7a9..3e1e77bef05 100644
--- a/Core/PythonAPI/src/FormFactorDecoratorDebyeWaller.pypp.cpp
+++ b/Core/PythonAPI/src/FormFactorDecoratorDebyeWaller.pypp.cpp
@@ -212,6 +212,18 @@ struct FormFactorDecoratorDebyeWaller_wrapper : FormFactorDecoratorDebyeWaller,
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -414,6 +426,18 @@ void register_FormFactorDecoratorDebyeWaller_class(){
, default_registerParameter_function_type( &FormFactorDecoratorDebyeWaller_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( FormFactorDecoratorDebyeWaller_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ FormFactorDecoratorDebyeWaller_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&FormFactorDecoratorDebyeWaller_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/FormFactorEllipsoid.pypp.cpp b/Core/PythonAPI/src/FormFactorEllipsoid.pypp.cpp
index 70b76893745..2445e215a90 100644
--- a/Core/PythonAPI/src/FormFactorEllipsoid.pypp.cpp
+++ b/Core/PythonAPI/src/FormFactorEllipsoid.pypp.cpp
@@ -224,6 +224,18 @@ struct FormFactorEllipsoid_wrapper : FormFactorEllipsoid, bp::wrapper< FormFacto
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -447,6 +459,18 @@ void register_FormFactorEllipsoid_class(){
, default_registerParameter_function_type( &FormFactorEllipsoid_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( FormFactorEllipsoid_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ FormFactorEllipsoid_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&FormFactorEllipsoid_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/FormFactorFullSphere.pypp.cpp b/Core/PythonAPI/src/FormFactorFullSphere.pypp.cpp
index af6e979baec..bb3d482d9ce 100644
--- a/Core/PythonAPI/src/FormFactorFullSphere.pypp.cpp
+++ b/Core/PythonAPI/src/FormFactorFullSphere.pypp.cpp
@@ -236,6 +236,18 @@ struct FormFactorFullSphere_wrapper : FormFactorFullSphere, bp::wrapper< FormFac
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -462,6 +474,18 @@ void register_FormFactorFullSphere_class(){
, default_registerParameter_function_type( &FormFactorFullSphere_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( FormFactorFullSphere_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ FormFactorFullSphere_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&FormFactorFullSphere_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/FormFactorFullSpheroid.pypp.cpp b/Core/PythonAPI/src/FormFactorFullSpheroid.pypp.cpp
index 42b5a282887..18a4a31895f 100644
--- a/Core/PythonAPI/src/FormFactorFullSpheroid.pypp.cpp
+++ b/Core/PythonAPI/src/FormFactorFullSpheroid.pypp.cpp
@@ -212,6 +212,18 @@ struct FormFactorFullSpheroid_wrapper : FormFactorFullSpheroid, bp::wrapper< For
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -414,6 +426,18 @@ void register_FormFactorFullSpheroid_class(){
, default_registerParameter_function_type( &FormFactorFullSpheroid_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( FormFactorFullSpheroid_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ FormFactorFullSpheroid_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&FormFactorFullSpheroid_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/FormFactorGauss.pypp.cpp b/Core/PythonAPI/src/FormFactorGauss.pypp.cpp
index a15262b4836..c8cf6fa7443 100644
--- a/Core/PythonAPI/src/FormFactorGauss.pypp.cpp
+++ b/Core/PythonAPI/src/FormFactorGauss.pypp.cpp
@@ -231,6 +231,18 @@ struct FormFactorGauss_wrapper : FormFactorGauss, bp::wrapper< FormFactorGauss >
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -446,6 +458,18 @@ void register_FormFactorGauss_class(){
, default_registerParameter_function_type( &FormFactorGauss_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( FormFactorGauss_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ FormFactorGauss_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&FormFactorGauss_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/FormFactorHemiSpheroid.pypp.cpp b/Core/PythonAPI/src/FormFactorHemiSpheroid.pypp.cpp
index 43f766aaa92..8a8e806768b 100644
--- a/Core/PythonAPI/src/FormFactorHemiSpheroid.pypp.cpp
+++ b/Core/PythonAPI/src/FormFactorHemiSpheroid.pypp.cpp
@@ -212,6 +212,18 @@ struct FormFactorHemiSpheroid_wrapper : FormFactorHemiSpheroid, bp::wrapper< For
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -414,6 +426,18 @@ void register_FormFactorHemiSpheroid_class(){
, default_registerParameter_function_type( &FormFactorHemiSpheroid_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( FormFactorHemiSpheroid_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ FormFactorHemiSpheroid_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&FormFactorHemiSpheroid_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/FormFactorLorentz.pypp.cpp b/Core/PythonAPI/src/FormFactorLorentz.pypp.cpp
index 90327dd6a6e..500f7ff1def 100644
--- a/Core/PythonAPI/src/FormFactorLorentz.pypp.cpp
+++ b/Core/PythonAPI/src/FormFactorLorentz.pypp.cpp
@@ -231,6 +231,18 @@ struct FormFactorLorentz_wrapper : FormFactorLorentz, bp::wrapper< FormFactorLor
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -446,6 +458,18 @@ void register_FormFactorLorentz_class(){
, default_registerParameter_function_type( &FormFactorLorentz_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( FormFactorLorentz_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ FormFactorLorentz_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&FormFactorLorentz_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/FormFactorParallelepiped.pypp.cpp b/Core/PythonAPI/src/FormFactorParallelepiped.pypp.cpp
index 9cc5960eefe..9e678b35a8b 100644
--- a/Core/PythonAPI/src/FormFactorParallelepiped.pypp.cpp
+++ b/Core/PythonAPI/src/FormFactorParallelepiped.pypp.cpp
@@ -224,6 +224,18 @@ struct FormFactorParallelepiped_wrapper : FormFactorParallelepiped, bp::wrapper<
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -438,6 +450,18 @@ void register_FormFactorParallelepiped_class(){
, default_registerParameter_function_type( &FormFactorParallelepiped_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( FormFactorParallelepiped_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ FormFactorParallelepiped_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&FormFactorParallelepiped_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/FormFactorPrism3.pypp.cpp b/Core/PythonAPI/src/FormFactorPrism3.pypp.cpp
index 91ebcc9ecfe..55f9c6566bd 100644
--- a/Core/PythonAPI/src/FormFactorPrism3.pypp.cpp
+++ b/Core/PythonAPI/src/FormFactorPrism3.pypp.cpp
@@ -260,6 +260,18 @@ struct FormFactorPrism3_wrapper : FormFactorPrism3, bp::wrapper< FormFactorPrism
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -509,6 +521,18 @@ void register_FormFactorPrism3_class(){
, default_registerParameter_function_type( &FormFactorPrism3_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( FormFactorPrism3_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ FormFactorPrism3_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&FormFactorPrism3_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/FormFactorPrism6.pypp.cpp b/Core/PythonAPI/src/FormFactorPrism6.pypp.cpp
index 8442d80023d..d1aa6cc0142 100644
--- a/Core/PythonAPI/src/FormFactorPrism6.pypp.cpp
+++ b/Core/PythonAPI/src/FormFactorPrism6.pypp.cpp
@@ -224,6 +224,18 @@ struct FormFactorPrism6_wrapper : FormFactorPrism6, bp::wrapper< FormFactorPrism
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -438,6 +450,18 @@ void register_FormFactorPrism6_class(){
, default_registerParameter_function_type( &FormFactorPrism6_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( FormFactorPrism6_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ FormFactorPrism6_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&FormFactorPrism6_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/FormFactorPyramid.pypp.cpp b/Core/PythonAPI/src/FormFactorPyramid.pypp.cpp
index 2146af388f5..b133da68bf2 100644
--- a/Core/PythonAPI/src/FormFactorPyramid.pypp.cpp
+++ b/Core/PythonAPI/src/FormFactorPyramid.pypp.cpp
@@ -284,6 +284,18 @@ struct FormFactorPyramid_wrapper : FormFactorPyramid, bp::wrapper< FormFactorPyr
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -556,6 +568,18 @@ void register_FormFactorPyramid_class(){
, default_registerParameter_function_type( &FormFactorPyramid_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( FormFactorPyramid_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ FormFactorPyramid_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&FormFactorPyramid_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/FormFactorSphere.pypp.cpp b/Core/PythonAPI/src/FormFactorSphere.pypp.cpp
index 3bdf99073ef..a20a1890e5f 100644
--- a/Core/PythonAPI/src/FormFactorSphere.pypp.cpp
+++ b/Core/PythonAPI/src/FormFactorSphere.pypp.cpp
@@ -212,6 +212,18 @@ struct FormFactorSphere_wrapper : FormFactorSphere, bp::wrapper< FormFactorSpher
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -414,6 +426,18 @@ void register_FormFactorSphere_class(){
, default_registerParameter_function_type( &FormFactorSphere_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( FormFactorSphere_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ FormFactorSphere_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&FormFactorSphere_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/FormFactorSphereGaussianRadius.pypp.cpp b/Core/PythonAPI/src/FormFactorSphereGaussianRadius.pypp.cpp
index 557fc18c9a9..5aadd719763 100644
--- a/Core/PythonAPI/src/FormFactorSphereGaussianRadius.pypp.cpp
+++ b/Core/PythonAPI/src/FormFactorSphereGaussianRadius.pypp.cpp
@@ -224,6 +224,18 @@ struct FormFactorSphereGaussianRadius_wrapper : FormFactorSphereGaussianRadius,
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -438,6 +450,18 @@ void register_FormFactorSphereGaussianRadius_class(){
, default_registerParameter_function_type( &FormFactorSphereGaussianRadius_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( FormFactorSphereGaussianRadius_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ FormFactorSphereGaussianRadius_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&FormFactorSphereGaussianRadius_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/IClusteredParticles.pypp.cpp b/Core/PythonAPI/src/IClusteredParticles.pypp.cpp
index 8888b5eb8b0..b2dc3bec03d 100644
--- a/Core/PythonAPI/src/IClusteredParticles.pypp.cpp
+++ b/Core/PythonAPI/src/IClusteredParticles.pypp.cpp
@@ -121,6 +121,18 @@ struct IClusteredParticles_wrapper : IClusteredParticles, bp::wrapper< IClustere
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -241,6 +253,18 @@ void register_IClusteredParticles_class(){
, default_registerParameter_function_type( &IClusteredParticles_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( IClusteredParticles_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ IClusteredParticles_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&IClusteredParticles_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/ICompositeSample.pypp.cpp b/Core/PythonAPI/src/ICompositeSample.pypp.cpp
index 352fb40c1be..ca169d66b11 100644
--- a/Core/PythonAPI/src/ICompositeSample.pypp.cpp
+++ b/Core/PythonAPI/src/ICompositeSample.pypp.cpp
@@ -109,6 +109,18 @@ struct ICompositeSample_wrapper : ICompositeSample, bp::wrapper< ICompositeSampl
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -217,6 +229,18 @@ void register_ICompositeSample_class(){
, default_registerParameter_function_type( &ICompositeSample_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( ICompositeSample_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ ICompositeSample_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&ICompositeSample_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/IDecoration.pypp.cpp b/Core/PythonAPI/src/IDecoration.pypp.cpp
index eb647e1e0a7..3e897b053a9 100644
--- a/Core/PythonAPI/src/IDecoration.pypp.cpp
+++ b/Core/PythonAPI/src/IDecoration.pypp.cpp
@@ -139,6 +139,18 @@ struct IDecoration_wrapper : IDecoration, bp::wrapper< IDecoration > {
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -324,6 +336,18 @@ void register_IDecoration_class(){
, default_registerParameter_function_type( &IDecoration_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( IDecoration_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ IDecoration_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&IDecoration_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/IDetectorResolution.pypp.cpp b/Core/PythonAPI/src/IDetectorResolution.pypp.cpp
index 791afdbbb89..2ac71b82b8d 100644
--- a/Core/PythonAPI/src/IDetectorResolution.pypp.cpp
+++ b/Core/PythonAPI/src/IDetectorResolution.pypp.cpp
@@ -102,6 +102,18 @@ struct IDetectorResolution_wrapper : IDetectorResolution, bp::wrapper< IDetector
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -208,6 +220,18 @@ void register_IDetectorResolution_class(){
, default_registerParameter_function_type( &IDetectorResolution_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( IDetectorResolution_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ IDetectorResolution_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&IDetectorResolution_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/IFTDistribution2D.pypp.cpp b/Core/PythonAPI/src/IFTDistribution2D.pypp.cpp
index 3e0819da07d..bcd19d0838a 100644
--- a/Core/PythonAPI/src/IFTDistribution2D.pypp.cpp
+++ b/Core/PythonAPI/src/IFTDistribution2D.pypp.cpp
@@ -107,6 +107,18 @@ struct IFTDistribution2D_wrapper : IFTDistribution2D, bp::wrapper< IFTDistributi
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -251,6 +263,18 @@ void register_IFTDistribution2D_class(){
, default_registerParameter_function_type( &IFTDistribution2D_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( IFTDistribution2D_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ IFTDistribution2D_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&IFTDistribution2D_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/IFormFactor.pypp.cpp b/Core/PythonAPI/src/IFormFactor.pypp.cpp
index a4604b0dc84..481829c6007 100644
--- a/Core/PythonAPI/src/IFormFactor.pypp.cpp
+++ b/Core/PythonAPI/src/IFormFactor.pypp.cpp
@@ -198,6 +198,18 @@ struct IFormFactor_wrapper : IFormFactor, bp::wrapper< IFormFactor > {
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -396,6 +408,18 @@ void register_IFormFactor_class(){
, default_registerParameter_function_type( &IFormFactor_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( IFormFactor_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ IFormFactor_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&IFormFactor_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/IFormFactorBorn.pypp.cpp b/Core/PythonAPI/src/IFormFactorBorn.pypp.cpp
index 58832bef87c..dbcc13be33e 100644
--- a/Core/PythonAPI/src/IFormFactorBorn.pypp.cpp
+++ b/Core/PythonAPI/src/IFormFactorBorn.pypp.cpp
@@ -210,6 +210,18 @@ struct IFormFactorBorn_wrapper : IFormFactorBorn, bp::wrapper< IFormFactorBorn >
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -420,6 +432,18 @@ void register_IFormFactorBorn_class(){
, default_registerParameter_function_type( &IFormFactorBorn_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( IFormFactorBorn_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ IFormFactorBorn_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&IFormFactorBorn_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/IFormFactorDecorator.pypp.cpp b/Core/PythonAPI/src/IFormFactorDecorator.pypp.cpp
index 4e17d6fbeb1..13c4b0d1073 100644
--- a/Core/PythonAPI/src/IFormFactorDecorator.pypp.cpp
+++ b/Core/PythonAPI/src/IFormFactorDecorator.pypp.cpp
@@ -191,6 +191,18 @@ struct IFormFactorDecorator_wrapper : IFormFactorDecorator, bp::wrapper< IFormFa
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -389,6 +401,18 @@ void register_IFormFactorDecorator_class(){
, default_registerParameter_function_type( &IFormFactorDecorator_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( IFormFactorDecorator_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ IFormFactorDecorator_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&IFormFactorDecorator_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/IInterferenceFunction.pypp.cpp b/Core/PythonAPI/src/IInterferenceFunction.pypp.cpp
index 9cf760032b6..225595bd6f1 100644
--- a/Core/PythonAPI/src/IInterferenceFunction.pypp.cpp
+++ b/Core/PythonAPI/src/IInterferenceFunction.pypp.cpp
@@ -138,6 +138,18 @@ struct IInterferenceFunction_wrapper : IInterferenceFunction, bp::wrapper< IInte
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -279,6 +291,18 @@ void register_IInterferenceFunction_class(){
, default_registerParameter_function_type( &IInterferenceFunction_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( IInterferenceFunction_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ IInterferenceFunction_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&IInterferenceFunction_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/IParameterized.pypp.cpp b/Core/PythonAPI/src/IParameterized.pypp.cpp
index 5c6ebffeeed..a877d62ddc8 100644
--- a/Core/PythonAPI/src/IParameterized.pypp.cpp
+++ b/Core/PythonAPI/src/IParameterized.pypp.cpp
@@ -106,6 +106,18 @@ struct IParameterized_wrapper : IParameterized, bp::wrapper< IParameterized > {
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -215,6 +227,18 @@ void register_IParameterized_class(){
, default_registerParameter_function_type( &IParameterized_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( IParameterized_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ IParameterized_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&IParameterized_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/IResolutionFunction2D.pypp.cpp b/Core/PythonAPI/src/IResolutionFunction2D.pypp.cpp
index 41b775dc630..6fb03f15fa9 100644
--- a/Core/PythonAPI/src/IResolutionFunction2D.pypp.cpp
+++ b/Core/PythonAPI/src/IResolutionFunction2D.pypp.cpp
@@ -102,6 +102,18 @@ struct IResolutionFunction2D_wrapper : IResolutionFunction2D, bp::wrapper< IReso
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -208,6 +220,18 @@ void register_IResolutionFunction2D_class(){
, default_registerParameter_function_type( &IResolutionFunction2D_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( IResolutionFunction2D_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ IResolutionFunction2D_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&IResolutionFunction2D_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/ISample.pypp.cpp b/Core/PythonAPI/src/ISample.pypp.cpp
index a8ed7288c4a..1cd53ce9754 100644
--- a/Core/PythonAPI/src/ISample.pypp.cpp
+++ b/Core/PythonAPI/src/ISample.pypp.cpp
@@ -133,6 +133,18 @@ struct ISample_wrapper : ISample, bp::wrapper< ISample > {
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -283,6 +295,18 @@ void register_ISample_class(){
, default_registerParameter_function_type( &ISample_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( ISample_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ ISample_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&ISample_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/ISampleBuilder.pypp.cpp b/Core/PythonAPI/src/ISampleBuilder.pypp.cpp
index 48973a8d6ae..324cda2a65e 100644
--- a/Core/PythonAPI/src/ISampleBuilder.pypp.cpp
+++ b/Core/PythonAPI/src/ISampleBuilder.pypp.cpp
@@ -111,6 +111,18 @@ struct ISampleBuilder_wrapper : ISampleBuilder, bp::wrapper< ISampleBuilder > {
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -209,6 +221,18 @@ void register_ISampleBuilder_class(){
, default_registerParameter_function_type( &ISampleBuilder_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( ISampleBuilder_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ ISampleBuilder_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&ISampleBuilder_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/Instrument.pypp.cpp b/Core/PythonAPI/src/Instrument.pypp.cpp
index 7e2dc045bda..f3980235854 100644
--- a/Core/PythonAPI/src/Instrument.pypp.cpp
+++ b/Core/PythonAPI/src/Instrument.pypp.cpp
@@ -99,6 +99,18 @@ struct Instrument_wrapper : Instrument, bp::wrapper< Instrument > {
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -303,6 +315,18 @@ void register_Instrument_class(){
, default_registerParameter_function_type( &Instrument_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( Instrument_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ Instrument_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&Instrument_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/InterferenceFunction1DParaCrystal.pypp.cpp b/Core/PythonAPI/src/InterferenceFunction1DParaCrystal.pypp.cpp
index f5d3ee564de..faa78986054 100644
--- a/Core/PythonAPI/src/InterferenceFunction1DParaCrystal.pypp.cpp
+++ b/Core/PythonAPI/src/InterferenceFunction1DParaCrystal.pypp.cpp
@@ -152,6 +152,18 @@ struct InterferenceFunction1DParaCrystal_wrapper : InterferenceFunction1DParaCry
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -317,6 +329,18 @@ void register_InterferenceFunction1DParaCrystal_class(){
, default_registerParameter_function_type( &InterferenceFunction1DParaCrystal_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( InterferenceFunction1DParaCrystal_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ InterferenceFunction1DParaCrystal_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&InterferenceFunction1DParaCrystal_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/InterferenceFunction2DLattice.pypp.cpp b/Core/PythonAPI/src/InterferenceFunction2DLattice.pypp.cpp
index bb05e39b1b5..16dc31d0603 100644
--- a/Core/PythonAPI/src/InterferenceFunction2DLattice.pypp.cpp
+++ b/Core/PythonAPI/src/InterferenceFunction2DLattice.pypp.cpp
@@ -152,6 +152,18 @@ struct InterferenceFunction2DLattice_wrapper : InterferenceFunction2DLattice, bp
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -307,6 +319,18 @@ void register_InterferenceFunction2DLattice_class(){
, default_registerParameter_function_type( &InterferenceFunction2DLattice_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( InterferenceFunction2DLattice_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ InterferenceFunction2DLattice_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&InterferenceFunction2DLattice_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/InterferenceFunction2DParaCrystal.pypp.cpp b/Core/PythonAPI/src/InterferenceFunction2DParaCrystal.pypp.cpp
index 156d1e720c6..0d7dc9a550c 100644
--- a/Core/PythonAPI/src/InterferenceFunction2DParaCrystal.pypp.cpp
+++ b/Core/PythonAPI/src/InterferenceFunction2DParaCrystal.pypp.cpp
@@ -152,6 +152,18 @@ struct InterferenceFunction2DParaCrystal_wrapper : InterferenceFunction2DParaCry
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -349,6 +361,18 @@ void register_InterferenceFunction2DParaCrystal_class(){
, default_registerParameter_function_type( &InterferenceFunction2DParaCrystal_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( InterferenceFunction2DParaCrystal_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ InterferenceFunction2DParaCrystal_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&InterferenceFunction2DParaCrystal_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/InterferenceFunctionNone.pypp.cpp b/Core/PythonAPI/src/InterferenceFunctionNone.pypp.cpp
index 9e36ca1e3c4..3215e69713e 100644
--- a/Core/PythonAPI/src/InterferenceFunctionNone.pypp.cpp
+++ b/Core/PythonAPI/src/InterferenceFunctionNone.pypp.cpp
@@ -152,6 +152,18 @@ struct InterferenceFunctionNone_wrapper : InterferenceFunctionNone, bp::wrapper<
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -297,6 +309,18 @@ void register_InterferenceFunctionNone_class(){
, default_registerParameter_function_type( &InterferenceFunctionNone_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( InterferenceFunctionNone_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ InterferenceFunctionNone_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&InterferenceFunctionNone_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/LatticeBasis.pypp.cpp b/Core/PythonAPI/src/LatticeBasis.pypp.cpp
index e144b5a5d95..d2e62372b8e 100644
--- a/Core/PythonAPI/src/LatticeBasis.pypp.cpp
+++ b/Core/PythonAPI/src/LatticeBasis.pypp.cpp
@@ -140,6 +140,18 @@ struct LatticeBasis_wrapper : LatticeBasis, bp::wrapper< LatticeBasis > {
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -294,6 +306,18 @@ void register_LatticeBasis_class(){
, default_registerParameter_function_type( &LatticeBasis_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( LatticeBasis_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ LatticeBasis_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&LatticeBasis_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/Layer.pypp.cpp b/Core/PythonAPI/src/Layer.pypp.cpp
index 3c6ce6f8a7a..b33f0a0225e 100644
--- a/Core/PythonAPI/src/Layer.pypp.cpp
+++ b/Core/PythonAPI/src/Layer.pypp.cpp
@@ -245,6 +245,18 @@ struct Layer_wrapper : Layer, bp::wrapper< Layer > {
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -463,6 +475,18 @@ void register_Layer_class(){
, default_registerParameter_function_type( &Layer_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( Layer_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ Layer_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&Layer_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/LayerInterface.pypp.cpp b/Core/PythonAPI/src/LayerInterface.pypp.cpp
index 09e91c515a3..b600ce47ceb 100644
--- a/Core/PythonAPI/src/LayerInterface.pypp.cpp
+++ b/Core/PythonAPI/src/LayerInterface.pypp.cpp
@@ -97,6 +97,18 @@ struct LayerInterface_wrapper : LayerInterface, bp::wrapper< LayerInterface > {
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -235,6 +247,18 @@ void register_LayerInterface_class(){
, default_registerParameter_function_type( &LayerInterface_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( LayerInterface_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ LayerInterface_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&LayerInterface_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/LayerRoughness.pypp.cpp b/Core/PythonAPI/src/LayerRoughness.pypp.cpp
index 1cbdaaaca9f..f8a0c6491c4 100644
--- a/Core/PythonAPI/src/LayerRoughness.pypp.cpp
+++ b/Core/PythonAPI/src/LayerRoughness.pypp.cpp
@@ -135,6 +135,18 @@ struct LayerRoughness_wrapper : LayerRoughness, bp::wrapper< LayerRoughness > {
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -335,6 +347,18 @@ void register_LayerRoughness_class(){
, default_registerParameter_function_type( &LayerRoughness_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( LayerRoughness_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ LayerRoughness_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&LayerRoughness_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/MesoCrystal.pypp.cpp b/Core/PythonAPI/src/MesoCrystal.pypp.cpp
index ec1cffea82e..6a2f367506a 100644
--- a/Core/PythonAPI/src/MesoCrystal.pypp.cpp
+++ b/Core/PythonAPI/src/MesoCrystal.pypp.cpp
@@ -128,6 +128,18 @@ struct MesoCrystal_wrapper : MesoCrystal, bp::wrapper< MesoCrystal > {
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -260,6 +272,18 @@ void register_MesoCrystal_class(){
, default_registerParameter_function_type( &MesoCrystal_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( MesoCrystal_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ MesoCrystal_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&MesoCrystal_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/MultiLayer.pypp.cpp b/Core/PythonAPI/src/MultiLayer.pypp.cpp
index ed9e2da5b15..dde8ee8de51 100644
--- a/Core/PythonAPI/src/MultiLayer.pypp.cpp
+++ b/Core/PythonAPI/src/MultiLayer.pypp.cpp
@@ -116,6 +116,18 @@ struct MultiLayer_wrapper : MultiLayer, bp::wrapper< MultiLayer > {
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -376,6 +388,18 @@ void register_MultiLayer_class(){
, default_registerParameter_function_type( &MultiLayer_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( MultiLayer_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ MultiLayer_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&MultiLayer_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/Particle.pypp.cpp b/Core/PythonAPI/src/Particle.pypp.cpp
index 2cc0985e8ee..14998ed4fb0 100644
--- a/Core/PythonAPI/src/Particle.pypp.cpp
+++ b/Core/PythonAPI/src/Particle.pypp.cpp
@@ -202,6 +202,18 @@ struct Particle_wrapper : Particle, bp::wrapper< Particle > {
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -394,6 +406,18 @@ void register_Particle_class(){
, default_registerParameter_function_type( &Particle_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( Particle_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ Particle_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&Particle_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/ParticleCoreShell.pypp.cpp b/Core/PythonAPI/src/ParticleCoreShell.pypp.cpp
index 6482b19436a..9bf73f518ba 100644
--- a/Core/PythonAPI/src/ParticleCoreShell.pypp.cpp
+++ b/Core/PythonAPI/src/ParticleCoreShell.pypp.cpp
@@ -128,6 +128,18 @@ struct ParticleCoreShell_wrapper : ParticleCoreShell, bp::wrapper< ParticleCoreS
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -260,6 +272,18 @@ void register_ParticleCoreShell_class(){
, default_registerParameter_function_type( &ParticleCoreShell_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( ParticleCoreShell_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ ParticleCoreShell_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&ParticleCoreShell_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/ParticleDecoration.pypp.cpp b/Core/PythonAPI/src/ParticleDecoration.pypp.cpp
index 78b6fdc9858..43ff146e939 100644
--- a/Core/PythonAPI/src/ParticleDecoration.pypp.cpp
+++ b/Core/PythonAPI/src/ParticleDecoration.pypp.cpp
@@ -176,6 +176,18 @@ struct ParticleDecoration_wrapper : ParticleDecoration, bp::wrapper< ParticleDec
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -395,6 +407,18 @@ void register_ParticleDecoration_class(){
, default_registerParameter_function_type( &ParticleDecoration_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( ParticleDecoration_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ ParticleDecoration_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&ParticleDecoration_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/ParticleInfo.pypp.cpp b/Core/PythonAPI/src/ParticleInfo.pypp.cpp
index 39d64862895..a5cb7be1f6c 100644
--- a/Core/PythonAPI/src/ParticleInfo.pypp.cpp
+++ b/Core/PythonAPI/src/ParticleInfo.pypp.cpp
@@ -116,6 +116,18 @@ struct ParticleInfo_wrapper : ParticleInfo, bp::wrapper< ParticleInfo > {
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -274,6 +286,18 @@ void register_ParticleInfo_class(){
, default_registerParameter_function_type( &ParticleInfo_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( ParticleInfo_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ ParticleInfo_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&ParticleInfo_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/PositionParticleInfo.pypp.cpp b/Core/PythonAPI/src/PositionParticleInfo.pypp.cpp
index dfbc61d5090..3e94fdb5370 100644
--- a/Core/PythonAPI/src/PositionParticleInfo.pypp.cpp
+++ b/Core/PythonAPI/src/PositionParticleInfo.pypp.cpp
@@ -116,6 +116,18 @@ struct PositionParticleInfo_wrapper : PositionParticleInfo, bp::wrapper< Positio
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -255,6 +267,18 @@ void register_PositionParticleInfo_class(){
, default_registerParameter_function_type( &PositionParticleInfo_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( PositionParticleInfo_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ PositionParticleInfo_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&PositionParticleInfo_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/PythonModule.cpp b/Core/PythonAPI/src/PythonModule.cpp
index eae618f07d3..8b364db0c18 100644
--- a/Core/PythonAPI/src/PythonModule.cpp
+++ b/Core/PythonAPI/src/PythonModule.cpp
@@ -7,8 +7,8 @@
#include "Bin1D.pypp.h"
#include "Bin1DCVector.pypp.h"
#include "Crystal.pypp.h"
+#include "cvector_t.pypp.h"
#include "Detector.pypp.h"
-#include "FTDistribution2DCauchy.pypp.h"
#include "FormFactorBox.pypp.h"
#include "FormFactorCone.pypp.h"
#include "FormFactorCrystal.pypp.h"
@@ -26,6 +26,7 @@
#include "FormFactorPyramid.pypp.h"
#include "FormFactorSphere.pypp.h"
#include "FormFactorSphereGaussianRadius.pypp.h"
+#include "FTDistribution2DCauchy.pypp.h"
#include "HomogeneousMaterial.pypp.h"
#include "IAxis.pypp.h"
#include "ICloneable.pypp.h"
@@ -33,23 +34,24 @@
#include "ICompositeSample.pypp.h"
#include "IDecoration.pypp.h"
#include "IDetectorResolution.pypp.h"
-#include "IFTDistribution2D.pypp.h"
#include "IFormFactor.pypp.h"
#include "IFormFactorBorn.pypp.h"
#include "IFormFactorDecorator.pypp.h"
+#include "IFTDistribution2D.pypp.h"
#include "IInterferenceFunction.pypp.h"
#include "IMaterial.pypp.h"
+#include "Instrument.pypp.h"
+#include "InterferenceFunction1DParaCrystal.pypp.h"
+#include "InterferenceFunction2DLattice.pypp.h"
+#include "InterferenceFunction2DParaCrystal.pypp.h"
+#include "InterferenceFunctionNone.pypp.h"
#include "IParameterized.pypp.h"
#include "IResolutionFunction2D.pypp.h"
#include "ISample.pypp.h"
#include "ISampleBuilder.pypp.h"
#include "ISelectionRule.pypp.h"
#include "ITransform3D.pypp.h"
-#include "Instrument.pypp.h"
-#include "InterferenceFunction1DParaCrystal.pypp.h"
-#include "InterferenceFunction2DLattice.pypp.h"
-#include "InterferenceFunction2DParaCrystal.pypp.h"
-#include "InterferenceFunctionNone.pypp.h"
+#include "kvector_t.pypp.h"
#include "Lattice.pypp.h"
#include "Lattice2DIFParameters.pypp.h"
#include "LatticeBasis.pypp.h"
@@ -59,6 +61,7 @@
#include "MaterialManager.pypp.h"
#include "MesoCrystal.pypp.h"
#include "MultiLayer.pypp.h"
+#include "ndimdata_t.pypp.h"
#include "OutputDataIOFactory.pypp.h"
#include "ParameterPool.pypp.h"
#include "Particle.pypp.h"
@@ -80,9 +83,6 @@
#include "StochasticDoubleGaussian.pypp.h"
#include "StochasticParameter_t.pypp.h"
#include "StochasticSampledParameter.pypp.h"
-#include "cvector_t.pypp.h"
-#include "kvector_t.pypp.h"
-#include "ndimdata_t.pypp.h"
#include "vdouble1d_t.pypp.h"
#include "vector_IFormFactorPtr_t.pypp.h"
#include "vector_integer_t.pypp.h"
diff --git a/Core/PythonAPI/src/ResolutionFunction2DSimple.pypp.cpp b/Core/PythonAPI/src/ResolutionFunction2DSimple.pypp.cpp
index c607587eab0..2b60275edbe 100644
--- a/Core/PythonAPI/src/ResolutionFunction2DSimple.pypp.cpp
+++ b/Core/PythonAPI/src/ResolutionFunction2DSimple.pypp.cpp
@@ -116,6 +116,18 @@ struct ResolutionFunction2DSimple_wrapper : ResolutionFunction2DSimple, bp::wrap
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -226,6 +238,18 @@ void register_ResolutionFunction2DSimple_class(){
, default_registerParameter_function_type( &ResolutionFunction2DSimple_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( ResolutionFunction2DSimple_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ ResolutionFunction2DSimple_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&ResolutionFunction2DSimple_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/PythonAPI/src/Simulation.pypp.cpp b/Core/PythonAPI/src/Simulation.pypp.cpp
index 75059f6d4bf..b91ac645550 100644
--- a/Core/PythonAPI/src/Simulation.pypp.cpp
+++ b/Core/PythonAPI/src/Simulation.pypp.cpp
@@ -104,6 +104,18 @@ struct Simulation_wrapper : Simulation, bp::wrapper< Simulation > {
}
}
+ virtual int setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ if( bp::override func_setMatchedParametersValue = this->get_override( "setMatchedParametersValue" ) )
+ return func_setMatchedParametersValue( wildcards, value );
+ else{
+ return this->IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+ }
+
+ int default_setMatchedParametersValue( ::std::string const & wildcards, double value ) {
+ return IParameterized::setMatchedParametersValue( wildcards, value );
+ }
+
virtual bool setParameterValue( ::std::string const & name, double value ) {
if( bp::override func_setParameterValue = this->get_override( "setParameterValue" ) )
return func_setParameterValue( name, value );
@@ -407,6 +419,18 @@ void register_Simulation_class(){
, default_registerParameter_function_type( &Simulation_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
+ }
+ { //::IParameterized::setMatchedParametersValue
+
+ typedef int ( ::IParameterized::*setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+ typedef int ( Simulation_wrapper::*default_setMatchedParametersValue_function_type )( ::std::string const &,double ) ;
+
+ Simulation_exposer.def(
+ "setMatchedParametersValue"
+ , setMatchedParametersValue_function_type(&::IParameterized::setMatchedParametersValue)
+ , default_setMatchedParametersValue_function_type(&Simulation_wrapper::default_setMatchedParametersValue)
+ , ( bp::arg("wildcards"), bp::arg("value") ) );
+
}
{ //::IParameterized::setParameterValue
diff --git a/Core/Tools/inc/IParameterized.h b/Core/Tools/inc/IParameterized.h
index 66404d115f6..3b28cc2b637 100644
--- a/Core/Tools/inc/IParameterized.h
+++ b/Core/Tools/inc/IParameterized.h
@@ -61,6 +61,12 @@ public:
virtual bool setParameterValue(const std::string &name, double value)
{ return m_parameters.setParameterValue(name, value); }
+ //! Sets parameter value, return number of changed parameters
+ virtual int setMatchedParametersValue(const std::string& wildcards, double value)
+ {
+ return m_parameters.setMatchedParametersValue(wildcards, value);
+ }
+
//! clear parameter pool
virtual void clearParameterPool() { m_parameters.clear(); }
diff --git a/Core/python_module.pri b/Core/python_module.pri
index ffb6a52a612..b4609993998 100644
--- a/Core/python_module.pri
+++ b/Core/python_module.pri
@@ -8,8 +8,8 @@ HEADERS += \
PythonAPI/inc/Bin1D.pypp.h \
PythonAPI/inc/Bin1DCVector.pypp.h \
PythonAPI/inc/Crystal.pypp.h \
+ PythonAPI/inc/cvector_t.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 \
@@ -27,6 +27,7 @@ HEADERS += \
PythonAPI/inc/FormFactorPyramid.pypp.h \
PythonAPI/inc/FormFactorSphere.pypp.h \
PythonAPI/inc/FormFactorSphereGaussianRadius.pypp.h \
+ PythonAPI/inc/FTDistribution2DCauchy.pypp.h \
PythonAPI/inc/HomogeneousMaterial.pypp.h \
PythonAPI/inc/IAxis.pypp.h \
PythonAPI/inc/ICloneable.pypp.h \
@@ -34,23 +35,24 @@ HEADERS += \
PythonAPI/inc/ICompositeSample.pypp.h \
PythonAPI/inc/IDecoration.pypp.h \
PythonAPI/inc/IDetectorResolution.pypp.h \
- PythonAPI/inc/IFTDistribution2D.pypp.h \
PythonAPI/inc/IFormFactor.pypp.h \
PythonAPI/inc/IFormFactorBorn.pypp.h \
PythonAPI/inc/IFormFactorDecorator.pypp.h \
+ PythonAPI/inc/IFTDistribution2D.pypp.h \
PythonAPI/inc/IInterferenceFunction.pypp.h \
PythonAPI/inc/IMaterial.pypp.h \
+ PythonAPI/inc/Instrument.pypp.h \
+ PythonAPI/inc/InterferenceFunction1DParaCrystal.pypp.h \
+ PythonAPI/inc/InterferenceFunction2DLattice.pypp.h \
+ PythonAPI/inc/InterferenceFunction2DParaCrystal.pypp.h \
+ PythonAPI/inc/InterferenceFunctionNone.pypp.h \
PythonAPI/inc/IParameterized.pypp.h \
PythonAPI/inc/IResolutionFunction2D.pypp.h \
PythonAPI/inc/ISample.pypp.h \
PythonAPI/inc/ISampleBuilder.pypp.h \
PythonAPI/inc/ISelectionRule.pypp.h \
PythonAPI/inc/ITransform3D.pypp.h \
- PythonAPI/inc/Instrument.pypp.h \
- PythonAPI/inc/InterferenceFunction1DParaCrystal.pypp.h \
- PythonAPI/inc/InterferenceFunction2DLattice.pypp.h \
- PythonAPI/inc/InterferenceFunction2DParaCrystal.pypp.h \
- PythonAPI/inc/InterferenceFunctionNone.pypp.h \
+ PythonAPI/inc/kvector_t.pypp.h \
PythonAPI/inc/Lattice.pypp.h \
PythonAPI/inc/Lattice2DIFParameters.pypp.h \
PythonAPI/inc/LatticeBasis.pypp.h \
@@ -60,6 +62,7 @@ HEADERS += \
PythonAPI/inc/MaterialManager.pypp.h \
PythonAPI/inc/MesoCrystal.pypp.h \
PythonAPI/inc/MultiLayer.pypp.h \
+ PythonAPI/inc/ndimdata_t.pypp.h \
PythonAPI/inc/OutputDataIOFactory.pypp.h \
PythonAPI/inc/ParameterPool.pypp.h \
PythonAPI/inc/Particle.pypp.h \
@@ -81,9 +84,6 @@ HEADERS += \
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/ndimdata_t.pypp.h \
PythonAPI/inc/vdouble1d_t.pypp.h \
PythonAPI/inc/vector_IFormFactorPtr_t.pypp.h \
PythonAPI/inc/vector_integer_t.pypp.h \
@@ -100,8 +100,8 @@ SOURCES += \
PythonAPI/src/Bin1D.pypp.cpp \
PythonAPI/src/Bin1DCVector.pypp.cpp \
PythonAPI/src/Crystal.pypp.cpp \
+ PythonAPI/src/cvector_t.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 \
@@ -119,6 +119,7 @@ SOURCES += \
PythonAPI/src/FormFactorPyramid.pypp.cpp \
PythonAPI/src/FormFactorSphere.pypp.cpp \
PythonAPI/src/FormFactorSphereGaussianRadius.pypp.cpp \
+ PythonAPI/src/FTDistribution2DCauchy.pypp.cpp \
PythonAPI/src/HomogeneousMaterial.pypp.cpp \
PythonAPI/src/IAxis.pypp.cpp \
PythonAPI/src/ICloneable.pypp.cpp \
@@ -126,23 +127,24 @@ SOURCES += \
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/IFormFactorDecorator.pypp.cpp \
+ PythonAPI/src/IFTDistribution2D.pypp.cpp \
PythonAPI/src/IInterferenceFunction.pypp.cpp \
PythonAPI/src/IMaterial.pypp.cpp \
+ PythonAPI/src/Instrument.pypp.cpp \
+ PythonAPI/src/InterferenceFunction1DParaCrystal.pypp.cpp \
+ PythonAPI/src/InterferenceFunction2DLattice.pypp.cpp \
+ PythonAPI/src/InterferenceFunction2DParaCrystal.pypp.cpp \
+ PythonAPI/src/InterferenceFunctionNone.pypp.cpp \
PythonAPI/src/IParameterized.pypp.cpp \
PythonAPI/src/IResolutionFunction2D.pypp.cpp \
PythonAPI/src/ISample.pypp.cpp \
PythonAPI/src/ISampleBuilder.pypp.cpp \
PythonAPI/src/ISelectionRule.pypp.cpp \
PythonAPI/src/ITransform3D.pypp.cpp \
- PythonAPI/src/Instrument.pypp.cpp \
- PythonAPI/src/InterferenceFunction1DParaCrystal.pypp.cpp \
- PythonAPI/src/InterferenceFunction2DLattice.pypp.cpp \
- PythonAPI/src/InterferenceFunction2DParaCrystal.pypp.cpp \
- PythonAPI/src/InterferenceFunctionNone.pypp.cpp \
+ PythonAPI/src/kvector_t.pypp.cpp \
PythonAPI/src/Lattice.pypp.cpp \
PythonAPI/src/Lattice2DIFParameters.pypp.cpp \
PythonAPI/src/LatticeBasis.pypp.cpp \
@@ -152,6 +154,7 @@ SOURCES += \
PythonAPI/src/MaterialManager.pypp.cpp \
PythonAPI/src/MesoCrystal.pypp.cpp \
PythonAPI/src/MultiLayer.pypp.cpp \
+ PythonAPI/src/ndimdata_t.pypp.cpp \
PythonAPI/src/OutputDataIOFactory.pypp.cpp \
PythonAPI/src/ParameterPool.pypp.cpp \
PythonAPI/src/Particle.pypp.cpp \
@@ -173,9 +176,6 @@ SOURCES += \
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/ndimdata_t.pypp.cpp \
PythonAPI/src/vdouble1d_t.pypp.cpp \
PythonAPI/src/vector_IFormFactorPtr_t.pypp.cpp \
PythonAPI/src/vector_integer_t.pypp.cpp \
diff --git a/Doc/UserManual/UserManual.pdf b/Doc/UserManual/UserManual.pdf
index db1e10586fe54b1adab3e442b53895e59fdaf310..01d344b44e670ad1e6dfeca8dadac47bbce4cd45 100644
GIT binary patch
delta 2144
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
delta 2147
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
diff --git a/Doc/UserManual/UserManual.tex b/Doc/UserManual/UserManual.tex
index d6dc3b3b611..ad167de1554 100644
--- a/Doc/UserManual/UserManual.tex
+++ b/Doc/UserManual/UserManual.tex
@@ -183,7 +183,7 @@ Forschungszentrum J\"ulich GmbH
\input{QuickStart}
\input{Installation}
\input{SimulationExamples}
-%\input{FittingExamples}
+\input{FittingExamples}
\input{SoftwareArchitecture}
%\input{SoftwareDesignOverview}
%\appendix
diff --git a/Examples/python/README b/Examples/python/README
index 3569f436520..298793d8ca5 100644
--- a/Examples/python/README
+++ b/Examples/python/README
@@ -1,16 +1,15 @@
BornAgain usage examples.
+This directory contains three sets of examples aimed to demonstrate
+to the user how to simulate and fit with BornAgain.
+
Content:
+./simulation - simulation examples
+./fitting - fitting examples
+./demos - collection of scripts used in different demonstrations
-ex001_CylindersAndPrisms - Mixture of cylinders and prisms without interference (IsGISAXS example #1)
-ex002_CylindersWithSizeDistribution - Mixture cylinder particles with different size distribution (IsGISAXS example #2)
-ex003_CylinderFormfactor - Cylinder formfactor in BA and DWBA (IsGISAXS example #3)
-ex004_CylindersParaCrystal - 1D and 2D paracrystal (IsGISAXS example #4)
-ex006_LatticeWithDisorder - 2D lattice with different disorder (IsGISAXS example #6)
-ex009_RotatedPyramids - Pyramids, rotated pyramids on top of substrate (IsGISAXS example #9)
-More examples in ./Tests/FunctionalTests
diff --git a/Examples/python/fitting/README b/Examples/python/fitting/README
new file mode 100644
index 00000000000..e2e9469fc18
--- /dev/null
+++ b/Examples/python/fitting/README
@@ -0,0 +1,15 @@
+BornAgain fitting examples.
+
+In this directory one can find examples of complete applications
+used for fitting.
+
+--- ex001_SampleParametersIntro ---
+ This example shows how to create a sample with fixed parameters and then
+ change this parameters on the fly during runtime.
+ The example doesn't contain any fitting and serve as a gentle introduction
+ to other fitting examples.
+
+--- ex002_FitCylindersAndPrisms ---
+ The model "mixture of cylinders and prisms without interference"
+ will be used to fit real data.
+
diff --git a/Examples/python/fitting/ex001_SampleParametersIntro/SampleParametersIntro.py b/Examples/python/fitting/ex001_SampleParametersIntro/SampleParametersIntro.py
new file mode 100644
index 00000000000..4bf11c00529
--- /dev/null
+++ b/Examples/python/fitting/ex001_SampleParametersIntro/SampleParametersIntro.py
@@ -0,0 +1,96 @@
+# This example shows how to create a sample with fixed parameters and then
+# change this parameters on the fly during runtime.
+# The example doesn't contain any fitting and serve as a gentle introduction
+# to other fitting examples.
+
+import sys, os, numpy, pylab, matplotlib
+from libBornAgainCore import *
+
+
+def get_sample():
+ """
+ Build and return the sample representing cylinders and pyramids on top of
+ substrate without interference. Sample is made for fixed set of parameters.
+ """
+ # defining materials
+ m_air = MaterialManager.getHomogeneousMaterial("Air", 0.0, 0.0 )
+ m_substrate = MaterialManager.getHomogeneousMaterial("Substrate", 6e-6, 2e-8 )
+ m_particle = MaterialManager.getHomogeneousMaterial("Particle", 6e-4, 2e-8 )
+
+ # collection of particles
+ cylinder_ff = FormFactorCylinder(5*nanometer, 5*nanometer)
+ cylinder = Particle(m_particle, cylinder_ff)
+ prism_ff = FormFactorPrism3(5*nanometer, 5*nanometer)
+ prism = Particle(m_particle, prism_ff)
+ particle_decoration = ParticleDecoration()
+ particle_decoration.addParticle(cylinder, 0.0, 0.5)
+ particle_decoration.addParticle(prism, 0.0, 0.5)
+ interference = InterferenceFunctionNone()
+ particle_decoration.addInterferenceFunction(interference)
+
+ # air layer with particles and substrate form multi layer
+ air_layer = Layer(m_air)
+ air_layer.setDecoration(particle_decoration)
+ substrate_layer = Layer(m_substrate, 0)
+ multi_layer = MultiLayer()
+ multi_layer.addLayer(air_layer)
+ multi_layer.addLayer(substrate_layer)
+ return multi_layer
+
+
+def get_simulation():
+ """
+ Create and return GISAXS simulation with beam and detector defined
+ """
+ simulation = Simulation()
+ simulation.setDetectorParameters(100, -1.0*degree, 1.0*degree
+ , 100, 0.0*degree, 2.0*degree, True)
+ simulation.setBeamParameters(1.0*angstrom, 0.2*degree, 0.0*degree)
+ return simulation
+
+
+def run_simulations():
+ """
+ Runs simulations for the sample with different sample parameters.
+ """
+
+ sample = get_sample()
+ print "The sample contains following parameters ('name':value)"
+ sample.printParameters()
+
+ simulation = get_simulation()
+ simulation.setSample(sample)
+
+ results = []
+
+ # simulation #1
+ # # initial sample is used
+ simulation.runSimulation()
+ results.append( GetOutputData(simulation) )
+
+ # simulation #2
+ # one sample parameter (height of the cylinder) is changed using exact parameter name
+ sample.setParameterValue('/MultiLayer/Layer0/ParticleDecoration/ParticleInfo0/Particle/FormFactorCylinder/height'
+ , 1.0*nanometer)
+ simulation.runSimulation()
+ results.append( GetOutputData(simulation) )
+
+ # simulation #3
+ # all parameters which are matching criteria will be changed
+
+
+ return results
+
+
+#-------------------------------------------------------------
+# main()
+#-------------------------------------------------------------
+if __name__ == '__main__':
+ results = run_simulations()
+# result = run_simulation() + 1 # for log scale
+# pylab.imshow(numpy.rot90(result, 1),
+# norm=matplotlib.colors.LogNorm(),
+# extent=[-1.0, 1.0, 0, 2.0])
+# pylab.show()
+
+
diff --git a/Examples/python/ex021_FitCylindersAndPrisms/FitCylindersPrisms.py b/Examples/python/fitting/ex002_FitCylindersAndPrisms/FitCylindersPrisms.py
similarity index 100%
rename from Examples/python/ex021_FitCylindersAndPrisms/FitCylindersPrisms.py
rename to Examples/python/fitting/ex002_FitCylindersAndPrisms/FitCylindersPrisms.py
diff --git a/Examples/python/ex021_FitCylindersAndPrisms/Refdata_fitcylinderprisms.txt b/Examples/python/fitting/ex002_FitCylindersAndPrisms/Refdata_fitcylinderprisms.txt
similarity index 100%
rename from Examples/python/ex021_FitCylindersAndPrisms/Refdata_fitcylinderprisms.txt
rename to Examples/python/fitting/ex002_FitCylindersAndPrisms/Refdata_fitcylinderprisms.txt
diff --git a/Examples/python/simulation/README b/Examples/python/simulation/README
new file mode 100644
index 00000000000..70bc37a8b43
--- /dev/null
+++ b/Examples/python/simulation/README
@@ -0,0 +1,29 @@
+BornAgain simulation examples.
+
+In this directory one can find examples of complete applications
+used for different simulation studies.
+
+--- ex001_CylindersAndPrisms ---
+ Mixture of cylinders and prisms without interference.
+ Corresponds to IsGISAXS example #1.
+
+--- ex002_CylindersWithSizeDistribution ---
+ Mixture cylinder particles with different size distribution.
+ Corresponds to IsGISAXS example #2.
+
+--- ex003_CylinderFormfactor ---
+ Cylinder formfactor in BA and DWBA.
+ Corresponds to IsGISAXS example #3.
+
+--- ex004_CylindersParaCrystal ---
+ 1D and 2D paracrystal.
+ Corresponds to IsGISAXS example #4.
+
+--- ex005_LatticeWithDisorder ---
+ 2D lattice with different disorder.
+ Corresponds to IsGISAXS example #6.
+
+--- ex006_RotatedPyramids ---
+ Pyramids, rotated pyramids on top of substrate.
+ Corresponds to IsGISAXS example #9.
+
diff --git a/Examples/python/ex001_CylindersAndPrisms/CylindersAndPrisms.py b/Examples/python/simulation/ex001_CylindersAndPrisms/CylindersAndPrisms.py
similarity index 100%
rename from Examples/python/ex001_CylindersAndPrisms/CylindersAndPrisms.py
rename to Examples/python/simulation/ex001_CylindersAndPrisms/CylindersAndPrisms.py
diff --git a/Examples/python/ex002_CylindersWithSizeDistribution/CylindersWithSizeDistribution.py b/Examples/python/simulation/ex002_CylindersWithSizeDistribution/CylindersWithSizeDistribution.py
similarity index 100%
rename from Examples/python/ex002_CylindersWithSizeDistribution/CylindersWithSizeDistribution.py
rename to Examples/python/simulation/ex002_CylindersWithSizeDistribution/CylindersWithSizeDistribution.py
diff --git a/Examples/python/ex003_CylinderFormfactor/CylinderFormfactorInBA.py b/Examples/python/simulation/ex003_CylinderFormfactor/CylinderFormfactorInBA.py
similarity index 100%
rename from Examples/python/ex003_CylinderFormfactor/CylinderFormfactorInBA.py
rename to Examples/python/simulation/ex003_CylinderFormfactor/CylinderFormfactorInBA.py
diff --git a/Examples/python/ex003_CylinderFormfactor/CylinderFormfactorInBASize.py b/Examples/python/simulation/ex003_CylinderFormfactor/CylinderFormfactorInBASize.py
similarity index 100%
rename from Examples/python/ex003_CylinderFormfactor/CylinderFormfactorInBASize.py
rename to Examples/python/simulation/ex003_CylinderFormfactor/CylinderFormfactorInBASize.py
diff --git a/Examples/python/ex003_CylinderFormfactor/CylinderFormfactorInDWBA.py b/Examples/python/simulation/ex003_CylinderFormfactor/CylinderFormfactorInDWBA.py
similarity index 100%
rename from Examples/python/ex003_CylinderFormfactor/CylinderFormfactorInDWBA.py
rename to Examples/python/simulation/ex003_CylinderFormfactor/CylinderFormfactorInDWBA.py
diff --git a/Examples/python/ex004_CylindersParaCrystal/CylindersParaCrystal_1DDL.py b/Examples/python/simulation/ex004_CylindersParaCrystal/CylindersParaCrystal_1DDL.py
similarity index 100%
rename from Examples/python/ex004_CylindersParaCrystal/CylindersParaCrystal_1DDL.py
rename to Examples/python/simulation/ex004_CylindersParaCrystal/CylindersParaCrystal_1DDL.py
diff --git a/Examples/python/ex004_CylindersParaCrystal/CylindersParaCrystal_2DDL.py b/Examples/python/simulation/ex004_CylindersParaCrystal/CylindersParaCrystal_2DDL.py
similarity index 100%
rename from Examples/python/ex004_CylindersParaCrystal/CylindersParaCrystal_2DDL.py
rename to Examples/python/simulation/ex004_CylindersParaCrystal/CylindersParaCrystal_2DDL.py
diff --git a/Examples/python/ex006_LatticeWithDisorder/LatticeWithDisorder1.py b/Examples/python/simulation/ex005_LatticeWithDisorder/LatticeWithDisorder1.py
similarity index 100%
rename from Examples/python/ex006_LatticeWithDisorder/LatticeWithDisorder1.py
rename to Examples/python/simulation/ex005_LatticeWithDisorder/LatticeWithDisorder1.py
diff --git a/Examples/python/ex006_LatticeWithDisorder/LatticeWithDisorder2.py b/Examples/python/simulation/ex005_LatticeWithDisorder/LatticeWithDisorder2.py
similarity index 100%
rename from Examples/python/ex006_LatticeWithDisorder/LatticeWithDisorder2.py
rename to Examples/python/simulation/ex005_LatticeWithDisorder/LatticeWithDisorder2.py
diff --git a/Examples/python/ex006_LatticeWithDisorder/LatticeWithDisorder3.py b/Examples/python/simulation/ex005_LatticeWithDisorder/LatticeWithDisorder3.py
similarity index 100%
rename from Examples/python/ex006_LatticeWithDisorder/LatticeWithDisorder3.py
rename to Examples/python/simulation/ex005_LatticeWithDisorder/LatticeWithDisorder3.py
diff --git a/Examples/python/ex006_LatticeWithDisorder/LatticeWithDisorder4.py b/Examples/python/simulation/ex005_LatticeWithDisorder/LatticeWithDisorder4.py
similarity index 100%
rename from Examples/python/ex006_LatticeWithDisorder/LatticeWithDisorder4.py
rename to Examples/python/simulation/ex005_LatticeWithDisorder/LatticeWithDisorder4.py
diff --git a/Examples/python/ex009_RotatedPyramids/Pyramids.py b/Examples/python/simulation/ex006_RotatedPyramids/Pyramids.py
similarity index 100%
rename from Examples/python/ex009_RotatedPyramids/Pyramids.py
rename to Examples/python/simulation/ex006_RotatedPyramids/Pyramids.py
diff --git a/Examples/python/ex009_RotatedPyramids/RotatedPyramids.py b/Examples/python/simulation/ex006_RotatedPyramids/RotatedPyramids.py
similarity index 100%
rename from Examples/python/ex009_RotatedPyramids/RotatedPyramids.py
rename to Examples/python/simulation/ex006_RotatedPyramids/RotatedPyramids.py
diff --git a/Tests/FunctionalTests/TestCore/README b/Tests/FunctionalTests/TestCore/README
index 420684d5f89..32be47bdb75 100644
--- a/Tests/FunctionalTests/TestCore/README
+++ b/Tests/FunctionalTests/TestCore/README
@@ -3,13 +3,12 @@ Collection of functional tests (C++)
Collection contains functional tests for BornAgainCore library.
Each test defines simple geometry, runs simulation and then compare results of the simulation with reference data.
-To build all tests
-qmake; make
+Tests are compiled and executed automatically when user builds the whole project with 'check' target
+cmake; make check
-To run tests
-python TestCore.py
+--- List of tests ---
-Tests taken from IsGISAXS:
+Tests reproducing IsGISAXS functionality:
IsGISAXS01 - Mixture of cylinders and prisms without interference (IsGISAXS example #1)
IsGISAXS02 - Mixture cylinder particles with different size distribution (IsGISAXS example #2)
IsGISAXS03 - Cylinder formfactor in BA and DWBA (IsGISAXS example #3)
@@ -22,7 +21,6 @@ IsGISAXS10 - Cylinders with interference on top of substrate (IsGISAXS example
IsGISAXS11 - Core shell nanoparticles (IsGISAXS example #11)
IsGISAXS15 - Size spacing correlation approximation (IsGISAXS example #15)
-
Other tests:
MesoCrystal1 - Meso crystal simulation
diff --git a/Tests/FunctionalTests/TestPyCore/README b/Tests/FunctionalTests/TestPyCore/README
index ef59d5e0a8a..acbb83aa903 100644
--- a/Tests/FunctionalTests/TestPyCore/README
+++ b/Tests/FunctionalTests/TestPyCore/README
@@ -3,13 +3,12 @@ Collection of functional tests (Python)
Collection contains functional tests for BornAgainCore library.
Each test defines simple geometry, runs simulation and then compare results of the simulation with reference data.
-To build all tests
-qmake; make
+Tests are executed automatically when user builds the whole project with 'check' target:
+cmake; make check
-To run tests
-python TestPyCore.py
+--- List of tests ---
-List of tests
+Tests reproducing IsGISAXS functionality:
IsGISAXS01 - Mixture of cylinders and prisms without interference (IsGISAXS example #1)
IsGISAXS02 - Mixture cylinder particles with different size distribution (IsGISAXS example #2)
IsGISAXS03 - Cylinder formfactor in BA and DWBA (IsGISAXS example #3)
@@ -21,4 +20,6 @@ IsGISAXS09 - Pyramids on top of substrate - Rotated pyramids on top of substra
IsGISAXS10 - Cylinders with interference on top of substrate (IsGISAXS example #10)
IsGISAXS11 - Core shell nanoparticles (IsGISAXS example #11)
IsGISAXS15 - Size spacing correlation approximation (IsGISAXS example #15)
+
+Other tests:
MesoCrystal1 - Meso crystal simulation
--
GitLab