diff --git a/App/inc/TestDetectorResolution.h b/App/inc/TestDetectorResolution.h
index 061ecd490eb953b46cf1887abbfe5245cfb79cb8..ad15bb53a917c5cad962b5c4997c184172fda37b 100644
--- a/App/inc/TestDetectorResolution.h
+++ b/App/inc/TestDetectorResolution.h
@@ -20,7 +20,7 @@
#include "OutputData.h"
#include "FormFactors.h"
#include "ISample.h"
-#include "InterferenceFunction1DParaCrystal.h"
+#include "InterferenceFunctionRadialParaCrystal.h"
#include "InterferenceFunctionNone.h"
class TestDetectorResolution : public IApplicationTest
diff --git a/App/src/TestDetectorResolution.cpp b/App/src/TestDetectorResolution.cpp
index dd973566610a4b8908c3b5f5cacdd8c10d980ee9..695c6cd4570d7fd671a945e6a03f95553e494a49 100644
--- a/App/src/TestDetectorResolution.cpp
+++ b/App/src/TestDetectorResolution.cpp
@@ -63,8 +63,8 @@ void TestDetectorResolution::initializeSample()
air_layer.setMaterial(air_material);
Layer substrate_layer;
substrate_layer.setMaterial(substrate_material);
- InterferenceFunction1DParaCrystal *p_interference_function =
- new InterferenceFunction1DParaCrystal(20.0*Units::nanometer,
+ InterferenceFunctionRadialParaCrystal *p_interference_function =
+ new InterferenceFunctionRadialParaCrystal(20.0*Units::nanometer,
1e7*Units::nanometer);
FTDistribution1DGauss pdf(7*Units::nanometer);
p_interference_function->setProbabilityDistribution(pdf);
diff --git a/App/src/TestFittingModule1.cpp b/App/src/TestFittingModule1.cpp
index f7f8e6a2aa3d538055ec4d29bc6083268a388cce..93e79b9472b4e9ed93cd0488948c5673a79a4043 100644
--- a/App/src/TestFittingModule1.cpp
+++ b/App/src/TestFittingModule1.cpp
@@ -22,7 +22,7 @@
#include "FormFactors.h"
#include "Simulation.h"
#include "ISquaredFunction.h"
-#include "InterferenceFunction1DParaCrystal.h"
+#include "InterferenceFunctionRadialParaCrystal.h"
#include "InterferenceFunctionNone.h"
#include "IsGISAXSTools.h"
#include "Materials.h"
diff --git a/App/src/TestFittingModule2.cpp b/App/src/TestFittingModule2.cpp
index 786f6d62a350f9e53548131a457a318cec21e470..b05d423614d38083e777487564e8a1313029c82f 100644
--- a/App/src/TestFittingModule2.cpp
+++ b/App/src/TestFittingModule2.cpp
@@ -25,7 +25,7 @@
#include "Simulation.h"
#include "IIntensityFunction.h"
#include "IObserver.h"
-#include "InterferenceFunction1DParaCrystal.h"
+#include "InterferenceFunctionRadialParaCrystal.h"
#include "InterferenceFunctionNone.h"
#include "IsGISAXSTools.h"
#include "Materials.h"
diff --git a/App/src/TestFittingModule3.cpp b/App/src/TestFittingModule3.cpp
index 44beff258c57c47cd4b4d112cb622845ba1ce8a1..f65321b07727d60d5b846c238f91242b09a15f2e 100644
--- a/App/src/TestFittingModule3.cpp
+++ b/App/src/TestFittingModule3.cpp
@@ -22,7 +22,7 @@
#include "FitSuiteObserverFactory.h"
#include "FormFactors.h"
#include "Simulation.h"
-#include "InterferenceFunction1DParaCrystal.h"
+#include "InterferenceFunctionRadialParaCrystal.h"
#include "InterferenceFunctionNone.h"
#include "IsGISAXSTools.h"
#include "Materials.h"
diff --git a/App/src/TestIsGISAXS12.cpp b/App/src/TestIsGISAXS12.cpp
index 48ac4e1f3fe10ea132c26f822527c21f8c4c0143..0727f7dee18fa2728a3a867b0f386c78e52588df 100644
--- a/App/src/TestIsGISAXS12.cpp
+++ b/App/src/TestIsGISAXS12.cpp
@@ -19,7 +19,7 @@
#include "FitSuiteObserverFactory.h"
#include "FormFactorCylinder.h"
#include "Simulation.h"
-#include "InterferenceFunction1DParaCrystal.h"
+#include "InterferenceFunctionRadialParaCrystal.h"
#include "InterferenceFunctionNone.h"
#include "IsGISAXSData.h"
#include "IsGISAXSTools.h"
@@ -504,8 +504,8 @@ ISample *TestIsGISAXS12::TestSampleBuilder::buildSample() const
DistributionGaussian gauss2(radius2, sigma2);
ParticleLayout particle_layout;
- InterferenceFunction1DParaCrystal *p_interference_function =
- new InterferenceFunction1DParaCrystal(m_interf_distance,
+ InterferenceFunctionRadialParaCrystal *p_interference_function =
+ new InterferenceFunctionRadialParaCrystal(m_interf_distance,
1e7*Units::nanometer); // peak_distance, corr_length
FTDistribution1DGauss pdf(m_interf_width);
p_interference_function->setProbabilityDistribution(pdf);
diff --git a/App/src/TestIsGISAXS13.cpp b/App/src/TestIsGISAXS13.cpp
index c6e3b16f3684560b4c8a2b7bd09d5a9f11b351ce..24031b7b6c8396519b83d3eb5c2d3b20e7d7ff83 100644
--- a/App/src/TestIsGISAXS13.cpp
+++ b/App/src/TestIsGISAXS13.cpp
@@ -18,7 +18,7 @@
#include "FitSuite.h"
#include "FitSuiteObserverFactory.h"
#include "Simulation.h"
-#include "InterferenceFunction1DParaCrystal.h"
+#include "InterferenceFunctionRadialParaCrystal.h"
#include "InterferenceFunctionNone.h"
#include "IsGISAXSData.h"
#include "IsGISAXSTools.h"
diff --git a/App/src/TestIsGISAXS5.cpp b/App/src/TestIsGISAXS5.cpp
index 144a8fab404252fa2d7b29d77afb7c09a067915a..8ab628613c01b25d6c1c5cba156428f1da5df9df 100644
--- a/App/src/TestIsGISAXS5.cpp
+++ b/App/src/TestIsGISAXS5.cpp
@@ -19,7 +19,7 @@
#include "FitSuiteObserverFactory.h"
#include "FormFactorCylinder.h"
#include "Simulation.h"
-#include "InterferenceFunction1DParaCrystal.h"
+#include "InterferenceFunctionRadialParaCrystal.h"
#include "InterferenceFunctionNone.h"
#include "IsGISAXSData.h"
#include "IsGISAXSTools.h"
@@ -294,8 +294,8 @@ ISample *TestIsGISAXS5::SampleBuilder::buildSample() const
DistributionGaussian gauss(m_particle_radius, sigma);
ParticleLayout particle_layout;
- InterferenceFunction1DParaCrystal *p_interference_function =
- new InterferenceFunction1DParaCrystal(m_interf_distance,
+ InterferenceFunctionRadialParaCrystal *p_interference_function =
+ new InterferenceFunctionRadialParaCrystal(m_interf_distance,
1e7*Units::nanometer); // peak_distance, corr_length
FTDistribution1DGauss pdf(m_interf_width);
p_interference_function->setProbabilityDistribution(pdf);
diff --git a/App/src/TestPyGenerator.cpp b/App/src/TestPyGenerator.cpp
index c08449306fefc4efe7d4e0f573ebf582d153481c..27ae79c94f8bb86ce21732c2cf5ddf6c57d7b0ec 100644
--- a/App/src/TestPyGenerator.cpp
+++ b/App/src/TestPyGenerator.cpp
@@ -6,7 +6,7 @@
#include "ICompositeSample.h"
#include "INamed.h"
#include "ISample.h"
-#include "InterferenceFunction1DParaCrystal.h"
+#include "InterferenceFunctionRadialParaCrystal.h"
#include "IMaterial.h"
#include "InterferenceFunctionNone.h"
#include "ISample.h"
diff --git a/App/src/TestRipple1.cpp b/App/src/TestRipple1.cpp
index 32733cc67817e3b7347321b5c704a90900e71506..3c3ab28762ea44ce32e0f056729a31c90c7f3f81 100644
--- a/App/src/TestRipple1.cpp
+++ b/App/src/TestRipple1.cpp
@@ -16,7 +16,7 @@
#include "TestRipple1.h"
#include "DrawHelper.h"
#include "Simulation.h"
-#include "InterferenceFunction1DParaCrystal.h"
+#include "InterferenceFunctionRadialParaCrystal.h"
#include "InterferenceFunctionNone.h"
#include "IsGISAXSData.h"
#include "IsGISAXSTools.h"
@@ -187,8 +187,8 @@ ISample *TestRipple1::TestSampleBuilder::buildSample() const
ParticleLayout particle_layout;
particle_layout.addParticle(ripple,0.0,1.0);
- InterferenceFunction1DParaCrystal *p_interference_function =
- new InterferenceFunction1DParaCrystal(m_interf_distance,
+ InterferenceFunctionRadialParaCrystal *p_interference_function =
+ new InterferenceFunctionRadialParaCrystal(m_interf_distance,
1e7*Units::nanometer); // peak_distance, corr_length
FTDistribution1DGauss pdf(m_interf_width);
p_interference_function->setProbabilityDistribution(pdf);
diff --git a/App/src/TestRipple2.cpp b/App/src/TestRipple2.cpp
index ac7651eb6aaa883db7533f1b026784b1294aad35..16376a73fcfc6ab9f0c6cf16d466282d8b0fa954 100644
--- a/App/src/TestRipple2.cpp
+++ b/App/src/TestRipple2.cpp
@@ -16,7 +16,7 @@
#include "TestRipple2.h"
#include "DrawHelper.h"
#include "Simulation.h"
-#include "InterferenceFunction1DParaCrystal.h"
+#include "InterferenceFunctionRadialParaCrystal.h"
#include "InterferenceFunctionNone.h"
#include "IsGISAXSData.h"
#include "IsGISAXSTools.h"
@@ -189,8 +189,8 @@ ISample *TestRipple2::TestSampleBuilder::buildSample() const
ParticleLayout particle_layout;
particle_layout.addParticle(ripple,0.0,1.0);
- InterferenceFunction1DParaCrystal *p_interference_function =
- new InterferenceFunction1DParaCrystal(m_interf_distance,
+ InterferenceFunctionRadialParaCrystal *p_interference_function =
+ new InterferenceFunctionRadialParaCrystal(m_interf_distance,
1e7*Units::nanometer); // peak_distance, corr_length
FTDistribution1DGauss pdf(m_interf_width);
p_interference_function->setProbabilityDistribution(pdf);
diff --git a/Core/Algorithms/src/SizeSpacingCorrelationApproximationStrategy.cpp b/Core/Algorithms/src/SizeSpacingCorrelationApproximationStrategy.cpp
index 7ecc8672d015da44f6eeab17ed041ea12d9dcc6d..b7d4b4391495d57feb63102dc8842ae7f4d55d24 100644
--- a/Core/Algorithms/src/SizeSpacingCorrelationApproximationStrategy.cpp
+++ b/Core/Algorithms/src/SizeSpacingCorrelationApproximationStrategy.cpp
@@ -14,7 +14,7 @@
// ************************************************************************** //
#include "SizeSpacingCorrelationApproximationStrategy.h"
-#include "InterferenceFunction1DParaCrystal.h"
+#include "InterferenceFunctionRadialParaCrystal.h"
#include "MathFunctions.h"
SizeSpacingCorrelationApproximationStrategy::SizeSpacingCorrelationApproximationStrategy(
@@ -95,8 +95,8 @@ complex_t
SizeSpacingCorrelationApproximationStrategy::getCharacteristicDistribution(
double qp) const
{
- const InterferenceFunction1DParaCrystal *p_iff =
- dynamic_cast<const InterferenceFunction1DParaCrystal *>(m_ifs[0]);
+ const InterferenceFunctionRadialParaCrystal *p_iff =
+ dynamic_cast<const InterferenceFunctionRadialParaCrystal *>(m_ifs[0]);
if (p_iff==0) {
throw ClassInitializationException("Wrong interference function for SSCA");
}
diff --git a/Core/PythonAPI/inc/InterferenceFunction1DParaCrystal.pypp.h b/Core/PythonAPI/inc/InterferenceFunction1DParaCrystal.pypp.h
deleted file mode 100644
index 49b328be00de2d0286f6c7ad214601f23762845f..0000000000000000000000000000000000000000
--- a/Core/PythonAPI/inc/InterferenceFunction1DParaCrystal.pypp.h
+++ /dev/null
@@ -1,11 +0,0 @@
-// This file has been generated by Py++.
-
-// BornAgain: simulate and fit scattering at grazing incidence
-//! @brief Automatically generated boost::python code for PythonCoreAPI
-
-#ifndef InterferenceFunction1DParaCrystal_hpp__pyplusplus_wrapper
-#define InterferenceFunction1DParaCrystal_hpp__pyplusplus_wrapper
-
-void register_InterferenceFunction1DParaCrystal_class();
-
-#endif//InterferenceFunction1DParaCrystal_hpp__pyplusplus_wrapper
diff --git a/Core/PythonAPI/inc/InterferenceFunctionRadialParaCrystal.pypp.h b/Core/PythonAPI/inc/InterferenceFunctionRadialParaCrystal.pypp.h
new file mode 100644
index 0000000000000000000000000000000000000000..5061820ec8a4b19fbc75ef00b80e2cf5db07f20b
--- /dev/null
+++ b/Core/PythonAPI/inc/InterferenceFunctionRadialParaCrystal.pypp.h
@@ -0,0 +1,11 @@
+// This file has been generated by Py++.
+
+// BornAgain: simulate and fit scattering at grazing incidence
+//! @brief Automatically generated boost::python code for PythonCoreAPI
+
+#ifndef InterferenceFunctionRadialParaCrystal_hpp__pyplusplus_wrapper
+#define InterferenceFunctionRadialParaCrystal_hpp__pyplusplus_wrapper
+
+void register_InterferenceFunctionRadialParaCrystal_class();
+
+#endif//InterferenceFunctionRadialParaCrystal_hpp__pyplusplus_wrapper
diff --git a/Core/PythonAPI/inc/PythonCoreList.h b/Core/PythonAPI/inc/PythonCoreList.h
index f6eec7c0581b2270c0a41208f4aa620e9313b47c..647752e96d89962d71f583dbb66869c017cb57c4 100644
--- a/Core/PythonAPI/inc/PythonCoreList.h
+++ b/Core/PythonAPI/inc/PythonCoreList.h
@@ -66,7 +66,7 @@
#include "ISingleton.h"
#include "Instrument.h"
#include "InterferenceFunction1DLattice.h"
-#include "InterferenceFunction1DParaCrystal.h"
+#include "InterferenceFunctionRadialParaCrystal.h"
#include "InterferenceFunction2DLattice.h"
#include "InterferenceFunction2DParaCrystal.h"
#include "InterferenceFunctionNone.h"
diff --git a/Core/PythonAPI/inc/PythonModule.h b/Core/PythonAPI/inc/PythonModule.h
index de3f50ae6298455f7c244b21afdc65cccb09d68f..c1f3cf3c8c04db6bb2c9751cdfea94b58eb69344 100644
--- a/Core/PythonAPI/inc/PythonModule.h
+++ b/Core/PythonAPI/inc/PythonModule.h
@@ -36,7 +36,7 @@
//#include "IFormFactorDecorator.h"
//#include "IInterferenceFunction.h"
//#include "InterferenceFunctionNone.h"
-//#include "InterferenceFunction1DParaCrystal.h"
+//#include "InterferenceFunctionRadialParaCrystal.h"
//#include "IMaterial.h"
//#include "IParameterized.h"
//#include "ISample.h"
diff --git a/Core/PythonAPI/src/InterferenceFunction1DParaCrystal.pypp.cpp b/Core/PythonAPI/src/InterferenceFunctionRadialParaCrystal.pypp.cpp
similarity index 61%
rename from Core/PythonAPI/src/InterferenceFunction1DParaCrystal.pypp.cpp
rename to Core/PythonAPI/src/InterferenceFunctionRadialParaCrystal.pypp.cpp
index 7efc8d9e30db68d1e0ebc6aacd0cd813ddd04817..736a2332664f07e7368c36faea067c473f9cd37a 100644
--- a/Core/PythonAPI/src/InterferenceFunction1DParaCrystal.pypp.cpp
+++ b/Core/PythonAPI/src/InterferenceFunctionRadialParaCrystal.pypp.cpp
@@ -12,53 +12,53 @@ GCC_DIAG_ON(missing-field-initializers)
#include "__call_policies.pypp.hpp"
#include "__convenience.pypp.hpp"
#include "PythonCoreList.h"
-#include "InterferenceFunction1DParaCrystal.pypp.h"
+#include "InterferenceFunctionRadialParaCrystal.pypp.h"
namespace bp = boost::python;
-struct InterferenceFunction1DParaCrystal_wrapper : InterferenceFunction1DParaCrystal, bp::wrapper< InterferenceFunction1DParaCrystal > {
+struct InterferenceFunctionRadialParaCrystal_wrapper : InterferenceFunctionRadialParaCrystal, bp::wrapper< InterferenceFunctionRadialParaCrystal > {
- InterferenceFunction1DParaCrystal_wrapper(double peak_distance, double damping_length=0.0 )
- : InterferenceFunction1DParaCrystal( peak_distance, damping_length )
- , bp::wrapper< InterferenceFunction1DParaCrystal >(){
+ InterferenceFunctionRadialParaCrystal_wrapper(double peak_distance, double damping_length=0.0 )
+ : InterferenceFunctionRadialParaCrystal( peak_distance, damping_length )
+ , bp::wrapper< InterferenceFunctionRadialParaCrystal >(){
// constructor
m_pyobj = 0;
}
- virtual ::InterferenceFunction1DParaCrystal * clone( ) const {
+ virtual ::InterferenceFunctionRadialParaCrystal * clone( ) const {
if( bp::override func_clone = this->get_override( "clone" ) )
return func_clone( );
else{
- return this->InterferenceFunction1DParaCrystal::clone( );
+ return this->InterferenceFunctionRadialParaCrystal::clone( );
}
}
- ::InterferenceFunction1DParaCrystal * default_clone( ) const {
- return InterferenceFunction1DParaCrystal::clone( );
+ ::InterferenceFunctionRadialParaCrystal * default_clone( ) const {
+ return InterferenceFunctionRadialParaCrystal::clone( );
}
virtual double evaluate( ::cvector_t const & q ) const {
if( bp::override func_evaluate = this->get_override( "evaluate" ) )
return func_evaluate( boost::ref(q) );
else{
- return this->InterferenceFunction1DParaCrystal::evaluate( boost::ref(q) );
+ return this->InterferenceFunctionRadialParaCrystal::evaluate( boost::ref(q) );
}
}
double default_evaluate( ::cvector_t const & q ) const {
- return InterferenceFunction1DParaCrystal::evaluate( boost::ref(q) );
+ return InterferenceFunctionRadialParaCrystal::evaluate( boost::ref(q) );
}
virtual double getKappa( ) const {
if( bp::override func_getKappa = this->get_override( "getKappa" ) )
return func_getKappa( );
else{
- return this->InterferenceFunction1DParaCrystal::getKappa( );
+ return this->InterferenceFunctionRadialParaCrystal::getKappa( );
}
}
double default_getKappa( ) const {
- return InterferenceFunction1DParaCrystal::getKappa( );
+ return InterferenceFunctionRadialParaCrystal::getKappa( );
}
virtual bool areParametersChanged( ) {
@@ -192,7 +192,7 @@ struct InterferenceFunction1DParaCrystal_wrapper : InterferenceFunction1DParaCry
}
static void default_registerParameter( ::IParameterized & inst, ::std::string const & name, long unsigned int parpointer ){
- if( dynamic_cast< InterferenceFunction1DParaCrystal_wrapper * >( boost::addressof( inst ) ) ){
+ if( dynamic_cast< InterferenceFunctionRadialParaCrystal_wrapper * >( boost::addressof( inst ) ) ){
inst.::IParameterized::registerParameter(name, reinterpret_cast< double * >( parpointer ));
}
else{
@@ -252,280 +252,280 @@ struct InterferenceFunction1DParaCrystal_wrapper : InterferenceFunction1DParaCry
};
-void register_InterferenceFunction1DParaCrystal_class(){
+void register_InterferenceFunctionRadialParaCrystal_class(){
- { //::InterferenceFunction1DParaCrystal
- typedef bp::class_< InterferenceFunction1DParaCrystal_wrapper, bp::bases< IInterferenceFunction >, std::auto_ptr< InterferenceFunction1DParaCrystal_wrapper >, boost::noncopyable > InterferenceFunction1DParaCrystal_exposer_t;
- InterferenceFunction1DParaCrystal_exposer_t InterferenceFunction1DParaCrystal_exposer = InterferenceFunction1DParaCrystal_exposer_t( "InterferenceFunction1DParaCrystal", bp::init< double, bp::optional< double > >(( bp::arg("peak_distance"), bp::arg("damping_length")=0.0 )) );
- bp::scope InterferenceFunction1DParaCrystal_scope( InterferenceFunction1DParaCrystal_exposer );
- { //::InterferenceFunction1DParaCrystal::FTPDF
+ { //::InterferenceFunctionRadialParaCrystal
+ typedef bp::class_< InterferenceFunctionRadialParaCrystal_wrapper, bp::bases< IInterferenceFunction >, std::auto_ptr< InterferenceFunctionRadialParaCrystal_wrapper >, boost::noncopyable > InterferenceFunctionRadialParaCrystal_exposer_t;
+ InterferenceFunctionRadialParaCrystal_exposer_t InterferenceFunctionRadialParaCrystal_exposer = InterferenceFunctionRadialParaCrystal_exposer_t( "InterferenceFunctionRadialParaCrystal", bp::init< double, bp::optional< double > >(( bp::arg("peak_distance"), bp::arg("damping_length")=0.0 )) );
+ bp::scope InterferenceFunctionRadialParaCrystal_scope( InterferenceFunctionRadialParaCrystal_exposer );
+ { //::InterferenceFunctionRadialParaCrystal::FTPDF
- typedef ::complex_t ( ::InterferenceFunction1DParaCrystal::*FTPDF_function_type)( double ) const;
+ typedef ::complex_t ( ::InterferenceFunctionRadialParaCrystal::*FTPDF_function_type)( double ) const;
- InterferenceFunction1DParaCrystal_exposer.def(
+ InterferenceFunctionRadialParaCrystal_exposer.def(
"FTPDF"
- , FTPDF_function_type( &::InterferenceFunction1DParaCrystal::FTPDF )
+ , FTPDF_function_type( &::InterferenceFunctionRadialParaCrystal::FTPDF )
, ( bp::arg("qpar") ) );
}
- { //::InterferenceFunction1DParaCrystal::clone
+ { //::InterferenceFunctionRadialParaCrystal::clone
- typedef ::InterferenceFunction1DParaCrystal * ( ::InterferenceFunction1DParaCrystal::*clone_function_type)( ) const;
- typedef ::InterferenceFunction1DParaCrystal * ( InterferenceFunction1DParaCrystal_wrapper::*default_clone_function_type)( ) const;
+ typedef ::InterferenceFunctionRadialParaCrystal * ( ::InterferenceFunctionRadialParaCrystal::*clone_function_type)( ) const;
+ typedef ::InterferenceFunctionRadialParaCrystal * ( InterferenceFunctionRadialParaCrystal_wrapper::*default_clone_function_type)( ) const;
- InterferenceFunction1DParaCrystal_exposer.def(
+ InterferenceFunctionRadialParaCrystal_exposer.def(
"clone"
- , clone_function_type(&::InterferenceFunction1DParaCrystal::clone)
- , default_clone_function_type(&InterferenceFunction1DParaCrystal_wrapper::default_clone)
+ , clone_function_type(&::InterferenceFunctionRadialParaCrystal::clone)
+ , default_clone_function_type(&InterferenceFunctionRadialParaCrystal_wrapper::default_clone)
, bp::return_value_policy< bp::manage_new_object >() );
}
- { //::InterferenceFunction1DParaCrystal::evaluate
+ { //::InterferenceFunctionRadialParaCrystal::evaluate
- typedef double ( ::InterferenceFunction1DParaCrystal::*evaluate_function_type)( ::cvector_t const & ) const;
- typedef double ( InterferenceFunction1DParaCrystal_wrapper::*default_evaluate_function_type)( ::cvector_t const & ) const;
+ typedef double ( ::InterferenceFunctionRadialParaCrystal::*evaluate_function_type)( ::cvector_t const & ) const;
+ typedef double ( InterferenceFunctionRadialParaCrystal_wrapper::*default_evaluate_function_type)( ::cvector_t const & ) const;
- InterferenceFunction1DParaCrystal_exposer.def(
+ InterferenceFunctionRadialParaCrystal_exposer.def(
"evaluate"
- , evaluate_function_type(&::InterferenceFunction1DParaCrystal::evaluate)
- , default_evaluate_function_type(&InterferenceFunction1DParaCrystal_wrapper::default_evaluate)
+ , evaluate_function_type(&::InterferenceFunctionRadialParaCrystal::evaluate)
+ , default_evaluate_function_type(&InterferenceFunctionRadialParaCrystal_wrapper::default_evaluate)
, ( bp::arg("q") ) );
}
- { //::InterferenceFunction1DParaCrystal::getDampingLength
+ { //::InterferenceFunctionRadialParaCrystal::getDampingLength
- typedef double ( ::InterferenceFunction1DParaCrystal::*getDampingLength_function_type)( ) const;
+ typedef double ( ::InterferenceFunctionRadialParaCrystal::*getDampingLength_function_type)( ) const;
- InterferenceFunction1DParaCrystal_exposer.def(
+ InterferenceFunctionRadialParaCrystal_exposer.def(
"getDampingLength"
- , getDampingLength_function_type( &::InterferenceFunction1DParaCrystal::getDampingLength ) );
+ , getDampingLength_function_type( &::InterferenceFunctionRadialParaCrystal::getDampingLength ) );
}
- { //::InterferenceFunction1DParaCrystal::getDomainSize
+ { //::InterferenceFunctionRadialParaCrystal::getDomainSize
- typedef double ( ::InterferenceFunction1DParaCrystal::*getDomainSize_function_type)( ) const;
+ typedef double ( ::InterferenceFunctionRadialParaCrystal::*getDomainSize_function_type)( ) const;
- InterferenceFunction1DParaCrystal_exposer.def(
+ InterferenceFunctionRadialParaCrystal_exposer.def(
"getDomainSize"
- , getDomainSize_function_type( &::InterferenceFunction1DParaCrystal::getDomainSize ) );
+ , getDomainSize_function_type( &::InterferenceFunctionRadialParaCrystal::getDomainSize ) );
}
- { //::InterferenceFunction1DParaCrystal::getKappa
+ { //::InterferenceFunctionRadialParaCrystal::getKappa
- typedef double ( ::InterferenceFunction1DParaCrystal::*getKappa_function_type)( ) const;
- typedef double ( InterferenceFunction1DParaCrystal_wrapper::*default_getKappa_function_type)( ) const;
+ typedef double ( ::InterferenceFunctionRadialParaCrystal::*getKappa_function_type)( ) const;
+ typedef double ( InterferenceFunctionRadialParaCrystal_wrapper::*default_getKappa_function_type)( ) const;
- InterferenceFunction1DParaCrystal_exposer.def(
+ InterferenceFunctionRadialParaCrystal_exposer.def(
"getKappa"
- , getKappa_function_type(&::InterferenceFunction1DParaCrystal::getKappa)
- , default_getKappa_function_type(&InterferenceFunction1DParaCrystal_wrapper::default_getKappa) );
+ , getKappa_function_type(&::InterferenceFunctionRadialParaCrystal::getKappa)
+ , default_getKappa_function_type(&InterferenceFunctionRadialParaCrystal_wrapper::default_getKappa) );
}
- { //::InterferenceFunction1DParaCrystal::getPeakDistance
+ { //::InterferenceFunctionRadialParaCrystal::getPeakDistance
- typedef double ( ::InterferenceFunction1DParaCrystal::*getPeakDistance_function_type)( ) const;
+ typedef double ( ::InterferenceFunctionRadialParaCrystal::*getPeakDistance_function_type)( ) const;
- InterferenceFunction1DParaCrystal_exposer.def(
+ InterferenceFunctionRadialParaCrystal_exposer.def(
"getPeakDistance"
- , getPeakDistance_function_type( &::InterferenceFunction1DParaCrystal::getPeakDistance ) );
+ , getPeakDistance_function_type( &::InterferenceFunctionRadialParaCrystal::getPeakDistance ) );
}
- { //::InterferenceFunction1DParaCrystal::getPropabilityDistribution
+ { //::InterferenceFunctionRadialParaCrystal::getPropabilityDistribution
- typedef ::IFTDistribution1D const * ( ::InterferenceFunction1DParaCrystal::*getPropabilityDistribution_function_type)( ) const;
+ typedef ::IFTDistribution1D const * ( ::InterferenceFunctionRadialParaCrystal::*getPropabilityDistribution_function_type)( ) const;
- InterferenceFunction1DParaCrystal_exposer.def(
+ InterferenceFunctionRadialParaCrystal_exposer.def(
"getPropabilityDistribution"
- , getPropabilityDistribution_function_type( &::InterferenceFunction1DParaCrystal::getPropabilityDistribution )
+ , getPropabilityDistribution_function_type( &::InterferenceFunctionRadialParaCrystal::getPropabilityDistribution )
, bp::return_value_policy< bp::reference_existing_object >() );
}
- { //::InterferenceFunction1DParaCrystal::setDomainSize
+ { //::InterferenceFunctionRadialParaCrystal::setDomainSize
- typedef void ( ::InterferenceFunction1DParaCrystal::*setDomainSize_function_type)( double ) ;
+ typedef void ( ::InterferenceFunctionRadialParaCrystal::*setDomainSize_function_type)( double ) ;
- InterferenceFunction1DParaCrystal_exposer.def(
+ InterferenceFunctionRadialParaCrystal_exposer.def(
"setDomainSize"
- , setDomainSize_function_type( &::InterferenceFunction1DParaCrystal::setDomainSize )
+ , setDomainSize_function_type( &::InterferenceFunctionRadialParaCrystal::setDomainSize )
, ( bp::arg("size") ) );
}
- { //::InterferenceFunction1DParaCrystal::setKappa
+ { //::InterferenceFunctionRadialParaCrystal::setKappa
- typedef void ( ::InterferenceFunction1DParaCrystal::*setKappa_function_type)( double ) ;
+ typedef void ( ::InterferenceFunctionRadialParaCrystal::*setKappa_function_type)( double ) ;
- InterferenceFunction1DParaCrystal_exposer.def(
+ InterferenceFunctionRadialParaCrystal_exposer.def(
"setKappa"
- , setKappa_function_type( &::InterferenceFunction1DParaCrystal::setKappa )
+ , setKappa_function_type( &::InterferenceFunctionRadialParaCrystal::setKappa )
, ( bp::arg("kappa") ) );
}
- { //::InterferenceFunction1DParaCrystal::setProbabilityDistribution
+ { //::InterferenceFunctionRadialParaCrystal::setProbabilityDistribution
- typedef void ( ::InterferenceFunction1DParaCrystal::*setProbabilityDistribution_function_type)( ::IFTDistribution1D const & ) ;
+ typedef void ( ::InterferenceFunctionRadialParaCrystal::*setProbabilityDistribution_function_type)( ::IFTDistribution1D const & ) ;
- InterferenceFunction1DParaCrystal_exposer.def(
+ InterferenceFunctionRadialParaCrystal_exposer.def(
"setProbabilityDistribution"
- , setProbabilityDistribution_function_type( &::InterferenceFunction1DParaCrystal::setProbabilityDistribution )
+ , setProbabilityDistribution_function_type( &::InterferenceFunctionRadialParaCrystal::setProbabilityDistribution )
, ( bp::arg("pdf") ) );
}
{ //::IParameterized::areParametersChanged
typedef bool ( ::IParameterized::*areParametersChanged_function_type)( ) ;
- typedef bool ( InterferenceFunction1DParaCrystal_wrapper::*default_areParametersChanged_function_type)( ) ;
+ typedef bool ( InterferenceFunctionRadialParaCrystal_wrapper::*default_areParametersChanged_function_type)( ) ;
- InterferenceFunction1DParaCrystal_exposer.def(
+ InterferenceFunctionRadialParaCrystal_exposer.def(
"areParametersChanged"
, areParametersChanged_function_type(&::IParameterized::areParametersChanged)
- , default_areParametersChanged_function_type(&InterferenceFunction1DParaCrystal_wrapper::default_areParametersChanged) );
+ , default_areParametersChanged_function_type(&InterferenceFunctionRadialParaCrystal_wrapper::default_areParametersChanged) );
}
{ //::IParameterized::clearParameterPool
typedef void ( ::IParameterized::*clearParameterPool_function_type)( ) ;
- typedef void ( InterferenceFunction1DParaCrystal_wrapper::*default_clearParameterPool_function_type)( ) ;
+ typedef void ( InterferenceFunctionRadialParaCrystal_wrapper::*default_clearParameterPool_function_type)( ) ;
- InterferenceFunction1DParaCrystal_exposer.def(
+ InterferenceFunctionRadialParaCrystal_exposer.def(
"clearParameterPool"
, clearParameterPool_function_type(&::IParameterized::clearParameterPool)
- , default_clearParameterPool_function_type(&InterferenceFunction1DParaCrystal_wrapper::default_clearParameterPool) );
+ , default_clearParameterPool_function_type(&InterferenceFunctionRadialParaCrystal_wrapper::default_clearParameterPool) );
}
{ //::ISample::cloneInvertB
typedef ::ISample * ( ::ISample::*cloneInvertB_function_type)( ) const;
- typedef ::ISample * ( InterferenceFunction1DParaCrystal_wrapper::*default_cloneInvertB_function_type)( ) const;
+ typedef ::ISample * ( InterferenceFunctionRadialParaCrystal_wrapper::*default_cloneInvertB_function_type)( ) const;
- InterferenceFunction1DParaCrystal_exposer.def(
+ InterferenceFunctionRadialParaCrystal_exposer.def(
"cloneInvertB"
, cloneInvertB_function_type(&::ISample::cloneInvertB)
- , default_cloneInvertB_function_type(&InterferenceFunction1DParaCrystal_wrapper::default_cloneInvertB)
+ , default_cloneInvertB_function_type(&InterferenceFunctionRadialParaCrystal_wrapper::default_cloneInvertB)
, bp::return_value_policy< bp::reference_existing_object >() );
}
{ //::ISample::containsMagneticMaterial
typedef bool ( ::ISample::*containsMagneticMaterial_function_type)( ) const;
- typedef bool ( InterferenceFunction1DParaCrystal_wrapper::*default_containsMagneticMaterial_function_type)( ) const;
+ typedef bool ( InterferenceFunctionRadialParaCrystal_wrapper::*default_containsMagneticMaterial_function_type)( ) const;
- InterferenceFunction1DParaCrystal_exposer.def(
+ InterferenceFunctionRadialParaCrystal_exposer.def(
"containsMagneticMaterial"
, containsMagneticMaterial_function_type(&::ISample::containsMagneticMaterial)
- , default_containsMagneticMaterial_function_type(&InterferenceFunction1DParaCrystal_wrapper::default_containsMagneticMaterial) );
+ , default_containsMagneticMaterial_function_type(&InterferenceFunctionRadialParaCrystal_wrapper::default_containsMagneticMaterial) );
}
{ //::IParameterized::createParameterTree
typedef ::ParameterPool * ( ::IParameterized::*createParameterTree_function_type)( ) const;
- typedef ::ParameterPool * ( InterferenceFunction1DParaCrystal_wrapper::*default_createParameterTree_function_type)( ) const;
+ typedef ::ParameterPool * ( InterferenceFunctionRadialParaCrystal_wrapper::*default_createParameterTree_function_type)( ) const;
- InterferenceFunction1DParaCrystal_exposer.def(
+ InterferenceFunctionRadialParaCrystal_exposer.def(
"createParameterTree"
, createParameterTree_function_type(&::IParameterized::createParameterTree)
- , default_createParameterTree_function_type(&InterferenceFunction1DParaCrystal_wrapper::default_createParameterTree)
+ , default_createParameterTree_function_type(&InterferenceFunctionRadialParaCrystal_wrapper::default_createParameterTree)
, bp::return_value_policy< bp::manage_new_object >() );
}
{ //::ISample::getCompositeSample
typedef ::ICompositeSample * ( ::ISample::*getCompositeSample_function_type)( ) ;
- typedef ::ICompositeSample * ( InterferenceFunction1DParaCrystal_wrapper::*default_getCompositeSample_function_type)( ) ;
+ typedef ::ICompositeSample * ( InterferenceFunctionRadialParaCrystal_wrapper::*default_getCompositeSample_function_type)( ) ;
- InterferenceFunction1DParaCrystal_exposer.def(
+ InterferenceFunctionRadialParaCrystal_exposer.def(
"getCompositeSample"
, getCompositeSample_function_type(&::ISample::getCompositeSample)
- , default_getCompositeSample_function_type(&InterferenceFunction1DParaCrystal_wrapper::default_getCompositeSample)
+ , default_getCompositeSample_function_type(&InterferenceFunctionRadialParaCrystal_wrapper::default_getCompositeSample)
, bp::return_value_policy< bp::reference_existing_object >() );
}
{ //::ISample::getCompositeSample
typedef ::ICompositeSample const * ( ::ISample::*getCompositeSample_function_type)( ) const;
- typedef ::ICompositeSample const * ( InterferenceFunction1DParaCrystal_wrapper::*default_getCompositeSample_function_type)( ) const;
+ typedef ::ICompositeSample const * ( InterferenceFunctionRadialParaCrystal_wrapper::*default_getCompositeSample_function_type)( ) const;
- InterferenceFunction1DParaCrystal_exposer.def(
+ InterferenceFunctionRadialParaCrystal_exposer.def(
"getCompositeSample"
, getCompositeSample_function_type(&::ISample::getCompositeSample)
- , default_getCompositeSample_function_type(&InterferenceFunction1DParaCrystal_wrapper::default_getCompositeSample)
+ , default_getCompositeSample_function_type(&InterferenceFunctionRadialParaCrystal_wrapper::default_getCompositeSample)
, bp::return_value_policy< bp::reference_existing_object >() );
}
{ //::ISample::preprocess
typedef bool ( ::ISample::*preprocess_function_type)( ) ;
- typedef bool ( InterferenceFunction1DParaCrystal_wrapper::*default_preprocess_function_type)( ) ;
+ typedef bool ( InterferenceFunctionRadialParaCrystal_wrapper::*default_preprocess_function_type)( ) ;
- InterferenceFunction1DParaCrystal_exposer.def(
+ InterferenceFunctionRadialParaCrystal_exposer.def(
"preprocess"
, preprocess_function_type(&::ISample::preprocess)
- , default_preprocess_function_type(&InterferenceFunction1DParaCrystal_wrapper::default_preprocess) );
+ , default_preprocess_function_type(&InterferenceFunctionRadialParaCrystal_wrapper::default_preprocess) );
}
{ //::IParameterized::printParameters
typedef void ( ::IParameterized::*printParameters_function_type)( ) const;
- typedef void ( InterferenceFunction1DParaCrystal_wrapper::*default_printParameters_function_type)( ) const;
+ typedef void ( InterferenceFunctionRadialParaCrystal_wrapper::*default_printParameters_function_type)( ) const;
- InterferenceFunction1DParaCrystal_exposer.def(
+ InterferenceFunctionRadialParaCrystal_exposer.def(
"printParameters"
, printParameters_function_type(&::IParameterized::printParameters)
- , default_printParameters_function_type(&InterferenceFunction1DParaCrystal_wrapper::default_printParameters) );
+ , default_printParameters_function_type(&InterferenceFunctionRadialParaCrystal_wrapper::default_printParameters) );
}
{ //::ISample::printSampleTree
typedef void ( ::ISample::*printSampleTree_function_type)( ) ;
- typedef void ( InterferenceFunction1DParaCrystal_wrapper::*default_printSampleTree_function_type)( ) ;
+ typedef void ( InterferenceFunctionRadialParaCrystal_wrapper::*default_printSampleTree_function_type)( ) ;
- InterferenceFunction1DParaCrystal_exposer.def(
+ InterferenceFunctionRadialParaCrystal_exposer.def(
"printSampleTree"
, printSampleTree_function_type(&::ISample::printSampleTree)
- , default_printSampleTree_function_type(&InterferenceFunction1DParaCrystal_wrapper::default_printSampleTree) );
+ , default_printSampleTree_function_type(&InterferenceFunctionRadialParaCrystal_wrapper::default_printSampleTree) );
}
{ //::IParameterized::registerParameter
typedef void ( *default_registerParameter_function_type )( ::IParameterized &,::std::string const &,long unsigned int );
- InterferenceFunction1DParaCrystal_exposer.def(
+ InterferenceFunctionRadialParaCrystal_exposer.def(
"registerParameter"
- , default_registerParameter_function_type( &InterferenceFunction1DParaCrystal_wrapper::default_registerParameter )
+ , default_registerParameter_function_type( &InterferenceFunctionRadialParaCrystal_wrapper::default_registerParameter )
, ( bp::arg("inst"), bp::arg("name"), bp::arg("parpointer") ) );
}
{ //::IParameterized::setParameterValue
typedef bool ( ::IParameterized::*setParameterValue_function_type)( ::std::string const &,double ) ;
- typedef bool ( InterferenceFunction1DParaCrystal_wrapper::*default_setParameterValue_function_type)( ::std::string const &,double ) ;
+ typedef bool ( InterferenceFunctionRadialParaCrystal_wrapper::*default_setParameterValue_function_type)( ::std::string const &,double ) ;
- InterferenceFunction1DParaCrystal_exposer.def(
+ InterferenceFunctionRadialParaCrystal_exposer.def(
"setParameterValue"
, setParameterValue_function_type(&::IParameterized::setParameterValue)
- , default_setParameterValue_function_type(&InterferenceFunction1DParaCrystal_wrapper::default_setParameterValue)
+ , default_setParameterValue_function_type(&InterferenceFunctionRadialParaCrystal_wrapper::default_setParameterValue)
, ( bp::arg("name"), bp::arg("value") ) );
}
{ //::IParameterized::setParametersAreChanged
typedef void ( ::IParameterized::*setParametersAreChanged_function_type)( ) ;
- typedef void ( InterferenceFunction1DParaCrystal_wrapper::*default_setParametersAreChanged_function_type)( ) ;
+ typedef void ( InterferenceFunctionRadialParaCrystal_wrapper::*default_setParametersAreChanged_function_type)( ) ;
- InterferenceFunction1DParaCrystal_exposer.def(
+ InterferenceFunctionRadialParaCrystal_exposer.def(
"setParametersAreChanged"
, setParametersAreChanged_function_type(&::IParameterized::setParametersAreChanged)
- , default_setParametersAreChanged_function_type(&InterferenceFunction1DParaCrystal_wrapper::default_setParametersAreChanged) );
+ , default_setParametersAreChanged_function_type(&InterferenceFunctionRadialParaCrystal_wrapper::default_setParametersAreChanged) );
}
{ //::ICloneable::transferToCPP
typedef void ( ::ICloneable::*transferToCPP_function_type)( ) ;
- typedef void ( InterferenceFunction1DParaCrystal_wrapper::*default_transferToCPP_function_type)( ) ;
+ typedef void ( InterferenceFunctionRadialParaCrystal_wrapper::*default_transferToCPP_function_type)( ) ;
- InterferenceFunction1DParaCrystal_exposer.def(
+ InterferenceFunctionRadialParaCrystal_exposer.def(
"transferToCPP"
, transferToCPP_function_type(&::ICloneable::transferToCPP)
- , default_transferToCPP_function_type(&InterferenceFunction1DParaCrystal_wrapper::default_transferToCPP) );
+ , default_transferToCPP_function_type(&InterferenceFunctionRadialParaCrystal_wrapper::default_transferToCPP) );
}
}
diff --git a/Core/PythonAPI/src/PythonModule.cpp b/Core/PythonAPI/src/PythonModule.cpp
index 43c2f51e748904d1abac0c19b4c8313fb9be91bd..f8da0464b555b8049ec71c3ac703561ca93ac0b6 100644
--- a/Core/PythonAPI/src/PythonModule.cpp
+++ b/Core/PythonAPI/src/PythonModule.cpp
@@ -26,6 +26,7 @@ GCC_DIAG_ON(missing-field-initializers)
#include "FTDistribution1DCosine.pypp.h"
#include "FTDistribution1DTriangle.pypp.h"
#include "FormFactorWeighted.pypp.h"
+#include "InterferenceFunctionRadialParaCrystal.pypp.h"
#include "DistributionGaussian.pypp.h"
#include "IDetectorResolution.pypp.h"
#include "FormFactorCylinder.pypp.h"
@@ -55,7 +56,6 @@ GCC_DIAG_ON(missing-field-initializers)
#include "FormFactorSphereUniformRadius.pypp.h"
#include "OffSpecSimulation.pypp.h"
#include "FormFactorRipple1.pypp.h"
-#include "InterferenceFunction1DParaCrystal.pypp.h"
#include "Simulation.pypp.h"
#include "IObservable.pypp.h"
#include "FormFactorLorentz.pypp.h"
@@ -235,10 +235,10 @@ BOOST_PYTHON_MODULE(libBornAgainCore){
register_IntensityDataFunctions_class();
register_IntensityDataIOFactory_class();
register_InterferenceFunction1DLattice_class();
- register_InterferenceFunction1DParaCrystal_class();
register_InterferenceFunction2DLattice_class();
register_InterferenceFunction2DParaCrystal_class();
register_InterferenceFunctionNone_class();
+ register_InterferenceFunctionRadialParaCrystal_class();
register_Lattice_class();
register_Lattice1DIFParameters_class();
register_Lattice2DIFParameters_class();
diff --git a/Core/Samples/inc/ISampleVisitor.h b/Core/Samples/inc/ISampleVisitor.h
index 0cdea97f3f5e02f46d4d5224c4af571797884911..e52e371c659fb79c617b985b29e1b88455caed11 100644
--- a/Core/Samples/inc/ISampleVisitor.h
+++ b/Core/Samples/inc/ISampleVisitor.h
@@ -93,7 +93,7 @@ class FormFactorDecoratorTransformation;
// -
class IInterferenceFunction;
class InterferenceFunction1DLattice;
-class InterferenceFunction1DParaCrystal;
+class InterferenceFunctionRadialParaCrystal;
class InterferenceFunction2DLattice;
class InterferenceFunction2DParaCrystal;
class InterferenceFunctionNone;
@@ -190,7 +190,7 @@ public:
virtual void visit(const IInterferenceFunction *);
virtual void visit(const InterferenceFunction1DLattice *);
- virtual void visit(const InterferenceFunction1DParaCrystal *);
+ virtual void visit(const InterferenceFunctionRadialParaCrystal *);
virtual void visit(const InterferenceFunction2DLattice *);
virtual void visit(const InterferenceFunction2DParaCrystal *);
virtual void visit(const InterferenceFunctionNone *);
diff --git a/Core/Samples/inc/InterferenceFunction1DParaCrystal.h b/Core/Samples/inc/InterferenceFunctionRadialParaCrystal.h
similarity index 79%
rename from Core/Samples/inc/InterferenceFunction1DParaCrystal.h
rename to Core/Samples/inc/InterferenceFunctionRadialParaCrystal.h
index 3bd3e3ba584ac4bcfa8a925429afecadc338104f..55f9b87a86ba1a624c8d514672a142e21a5fc241 100644
--- a/Core/Samples/inc/InterferenceFunction1DParaCrystal.h
+++ b/Core/Samples/inc/InterferenceFunctionRadialParaCrystal.h
@@ -2,8 +2,8 @@
//
// BornAgain: simulate and fit scattering at grazing incidence
//
-//! @file Samples/inc/InterferenceFunction1DParaCrystal.h
-//! @brief Defines class InterferenceFunction1DParaCrystal.
+//! @file Samples/inc/InterferenceFunctionRadialParaCrystal.h
+//! @brief Defines class InterferenceFunctionRadialParaCrystal.
//!
//! @homepage http://apps.jcns.fz-juelich.de/BornAgain
//! @license GNU General Public License v3 or higher (see COPYING)
@@ -13,30 +13,30 @@
//
// ************************************************************************** //
-#ifndef INTERFERENCEFUNCTION1DPARACRYSTAL_H_
-#define INTERFERENCEFUNCTION1DPARACRYSTAL_H_
+#ifndef INTERFERENCEFUNCTIONRADIALPARACRYSTAL_H_
+#define INTERFERENCEFUNCTIONRADIALPARACRYSTAL_H_
#include "IInterferenceFunction.h"
#include "FTDistributions.h"
-//! @class InterferenceFunction1DParaCrystal
+//! @class InterferenceFunctionRadialParaCrystal
//! @ingroup interference
-//! @brief Interference function of 1D paracrystal.
+//! @brief Interference function of radial paracrystal.
-class BA_CORE_API_ InterferenceFunction1DParaCrystal
+class BA_CORE_API_ InterferenceFunctionRadialParaCrystal
: public IInterferenceFunction
{
public:
- //! @brief constructor of 1D paracrystal interference function
+ //! @brief constructor of radial paracrystal interference function
//! @param peak_distance The distance to the first neighbor peak.
//! @param width Width parameter in the pair correlation function.
//! @param m_corr_length Correlation length of paracrystal.
- InterferenceFunction1DParaCrystal(
+ InterferenceFunctionRadialParaCrystal(
double peak_distance, double damping_length=0.0);
- virtual ~InterferenceFunction1DParaCrystal() {}
- virtual InterferenceFunction1DParaCrystal *clone() const;
+ virtual ~InterferenceFunctionRadialParaCrystal() {}
+ virtual InterferenceFunctionRadialParaCrystal *clone() const;
virtual void accept(ISampleVisitor *visitor) const { visitor->visit(this); }
@@ -89,6 +89,6 @@ private:
virtual void init_parameters();
};
-#endif /* INTERFERENCEFUNCTION1DPARACRYSTAL_H_ */
+#endif /* INTERFERENCEFUNCTIONRADIALPARACRYSTAL_H_ */
diff --git a/Core/Samples/inc/InterferenceFunctions.h b/Core/Samples/inc/InterferenceFunctions.h
index 654aa52cd8f9d8ec1d5701fff3cd5b1c3eefed06..ff34cb9fd70dde898ad43172a4b9dc54ffc58e27 100644
--- a/Core/Samples/inc/InterferenceFunctions.h
+++ b/Core/Samples/inc/InterferenceFunctions.h
@@ -17,7 +17,7 @@
#define INTERFERENCEFUNCTIONS_H_
#include "InterferenceFunctionNone.h"
-#include "InterferenceFunction1DParaCrystal.h"
+#include "InterferenceFunctionRadialParaCrystal.h"
#include "InterferenceFunction1DLattice.h"
#include "InterferenceFunction2DLattice.h"
#include "InterferenceFunction2DParaCrystal.h"
diff --git a/Core/Samples/src/ISampleVisitor.cpp b/Core/Samples/src/ISampleVisitor.cpp
index 6a538a36e95c5233b38e65d8ddcd48099434105c..a235d2d7a306f22c9db209cf029eca392b749e92 100644
--- a/Core/Samples/src/ISampleVisitor.cpp
+++ b/Core/Samples/src/ISampleVisitor.cpp
@@ -382,8 +382,8 @@ void ISampleVisitor::visit(const InterferenceFunction1DLattice *)
throw NotImplementedException("ISampleVisitor::visit(const InterferenceFunction1DLattice *) -> Error. Not implemented.");
}
-void ISampleVisitor::visit(const InterferenceFunction1DParaCrystal *){
- throw NotImplementedException("ISampleVisitor::visit(const InterferenceFunction1DParaCrystal *) -> Error. Not implemented.");
+void ISampleVisitor::visit(const InterferenceFunctionRadialParaCrystal *){
+ throw NotImplementedException("ISampleVisitor::visit(const InterferenceFunctionRadialParaCrystal *) -> Error. Not implemented.");
}
diff --git a/Core/Samples/src/InterferenceFunction1DParaCrystal.cpp b/Core/Samples/src/InterferenceFunctionRadialParaCrystal.cpp
similarity index 77%
rename from Core/Samples/src/InterferenceFunction1DParaCrystal.cpp
rename to Core/Samples/src/InterferenceFunctionRadialParaCrystal.cpp
index 65b6de955f31eb932c39d4c6382cd78435573e21..2eea179d80f921e5ee09d310ca200ec4da852cde 100644
--- a/Core/Samples/src/InterferenceFunction1DParaCrystal.cpp
+++ b/Core/Samples/src/InterferenceFunctionRadialParaCrystal.cpp
@@ -2,8 +2,8 @@
//
// BornAgain: simulate and fit scattering at grazing incidence
//
-//! @file Samples/src/InterferenceFunction1DParaCrystal.cpp
-//! @brief Implements class InterferenceFunction1DParaCrystal.
+//! @file Samples/src/InterferenceFunctionRadialParaCrystal.cpp
+//! @brief Implements class InterferenceFunctionRadialParaCrystal.
//!
//! @homepage http://apps.jcns.fz-juelich.de/BornAgain
//! @license GNU General Public License v3 or higher (see COPYING)
@@ -13,10 +13,10 @@
//
// ************************************************************************** //
-#include "InterferenceFunction1DParaCrystal.h"
+#include "InterferenceFunctionRadialParaCrystal.h"
#include "MathFunctions.h"
-InterferenceFunction1DParaCrystal::InterferenceFunction1DParaCrystal(
+InterferenceFunctionRadialParaCrystal::InterferenceFunctionRadialParaCrystal(
double peak_distance, double damping_length)
: m_peak_distance(peak_distance)
, m_damping_length(damping_length)
@@ -25,14 +25,14 @@ InterferenceFunction1DParaCrystal::InterferenceFunction1DParaCrystal(
, m_kappa(0.0)
, m_domain_size(0.0)
{
- setName("InterferenceFunction1DParaCrystal");
+ setName("InterferenceFunctionRadialParaCrystal");
if (m_damping_length==0.0) {
m_use_damping_length = false;
}
init_parameters();
}
-void InterferenceFunction1DParaCrystal::init_parameters()
+void InterferenceFunctionRadialParaCrystal::init_parameters()
{
clearParameterPool();
registerParameter("peak_distance", &m_peak_distance);
@@ -42,9 +42,9 @@ void InterferenceFunction1DParaCrystal::init_parameters()
}
-InterferenceFunction1DParaCrystal *InterferenceFunction1DParaCrystal::clone() const {
- InterferenceFunction1DParaCrystal *result =
- new InterferenceFunction1DParaCrystal(
+InterferenceFunctionRadialParaCrystal *InterferenceFunctionRadialParaCrystal::clone() const {
+ InterferenceFunctionRadialParaCrystal *result =
+ new InterferenceFunctionRadialParaCrystal(
m_peak_distance, m_damping_length);
result->setName(getName());
result->setDomainSize(getDomainSize());
@@ -56,10 +56,10 @@ InterferenceFunction1DParaCrystal *InterferenceFunction1DParaCrystal::clone() co
}
-double InterferenceFunction1DParaCrystal::evaluate(const cvector_t& q) const
+double InterferenceFunctionRadialParaCrystal::evaluate(const cvector_t& q) const
{
if (!mp_pdf) {
- throw NullPointerException("InterferenceFunction1DParaCrystal::"
+ throw NullPointerException("InterferenceFunctionRadialParaCrystal::"
"evaluate() -> Error! Probability distribution for "
"interference funtion not properly initialized");
}
@@ -96,7 +96,7 @@ double InterferenceFunction1DParaCrystal::evaluate(const cvector_t& q) const
return result;
}
-complex_t InterferenceFunction1DParaCrystal::FTPDF(
+complex_t InterferenceFunctionRadialParaCrystal::FTPDF(
double qpar) const
{
complex_t phase = std::exp(complex_t(0.0, 1.0)*qpar*m_peak_distance);
@@ -108,7 +108,7 @@ complex_t InterferenceFunction1DParaCrystal::FTPDF(
return result;
}
-void InterferenceFunction1DParaCrystal::setProbabilityDistribution(
+void InterferenceFunctionRadialParaCrystal::setProbabilityDistribution(
const IFTDistribution1D &pdf)
{
if (mp_pdf != &pdf) {
@@ -118,7 +118,7 @@ void InterferenceFunction1DParaCrystal::setProbabilityDistribution(
}
const IFTDistribution1D
- *InterferenceFunction1DParaCrystal::getPropabilityDistribution() const
+ *InterferenceFunctionRadialParaCrystal::getPropabilityDistribution() const
{
return mp_pdf;
}
diff --git a/Core/Samples/src/ParticleLayout.cpp b/Core/Samples/src/ParticleLayout.cpp
index 1f5805e8039d969979cbb0a300bf3bcd17610f03..47f54a03cfa5f679a0114d769e41738f5f82abf1 100644
--- a/Core/Samples/src/ParticleLayout.cpp
+++ b/Core/Samples/src/ParticleLayout.cpp
@@ -16,7 +16,7 @@
#include "ParticleLayout.h"
#include "InterferenceFunctionNone.h"
#include "DecouplingApproximationStrategy.h"
-#include "InterferenceFunction1DParaCrystal.h"
+#include "InterferenceFunctionRadialParaCrystal.h"
#include "SizeSpacingCorrelationApproximationStrategy.h"
#include "MessageService.h"
#include "ParticleDistribution.h"
diff --git a/Core/StandardSamples/IsGISAXS04Builder.cpp b/Core/StandardSamples/IsGISAXS04Builder.cpp
index 1dab26359bf4a4bc85a05aa3223c2558f3a3c8a8..6fedca65ca64a0e57552a146d32b0b3b1ec05127 100644
--- a/Core/StandardSamples/IsGISAXS04Builder.cpp
+++ b/Core/StandardSamples/IsGISAXS04Builder.cpp
@@ -17,7 +17,7 @@
#include "MultiLayer.h"
#include "ParticleLayout.h"
#include "Materials.h"
-#include "InterferenceFunction1DParaCrystal.h"
+#include "InterferenceFunctionRadialParaCrystal.h"
#include "InterferenceFunction2DParaCrystal.h"
#include "FormFactorCylinder.h"
#include "Units.h"
@@ -54,8 +54,8 @@ ISample *IsGISAXS04Para1DBuilder::buildSample() const
Layer air_layer(air_material);
Layer substrate_layer(substrate_material);
- InterferenceFunction1DParaCrystal *p_interference_function =
- new InterferenceFunction1DParaCrystal(
+ InterferenceFunctionRadialParaCrystal *p_interference_function =
+ new InterferenceFunctionRadialParaCrystal(
m_corr_peak_distance, m_corr_length);
FTDistribution1DGauss pdf(m_corr_width);
p_interference_function->setProbabilityDistribution(pdf);
diff --git a/Core/StandardSamples/IsGISAXS10Builder.cpp b/Core/StandardSamples/IsGISAXS10Builder.cpp
index 8ebaae427ae17595a4fac194fc4013bcd1d1c9b2..5d94426aec8be05435ce3e6c856f8beae2c71e26 100644
--- a/Core/StandardSamples/IsGISAXS10Builder.cpp
+++ b/Core/StandardSamples/IsGISAXS10Builder.cpp
@@ -18,7 +18,7 @@
#include "ParticleLayout.h"
#include "Materials.h"
#include "FormFactorCylinder.h"
-#include "InterferenceFunction1DParaCrystal.h"
+#include "InterferenceFunctionRadialParaCrystal.h"
#include "Units.h"
IsGISAXS10Builder::IsGISAXS10Builder()
@@ -48,8 +48,8 @@ ISample *IsGISAXS10Builder::buildSample() const
Layer air_layer(air_material);
Layer substrate_layer(substrate_material);
- InterferenceFunction1DParaCrystal *p_interference_function =
- new InterferenceFunction1DParaCrystal(20.0*Units::nanometer,
+ InterferenceFunctionRadialParaCrystal *p_interference_function =
+ new InterferenceFunctionRadialParaCrystal(20.0*Units::nanometer,
1e7*Units::nanometer);
FTDistribution1DGauss pdf(7*Units::nanometer);
p_interference_function->setProbabilityDistribution(pdf);
diff --git a/Core/StandardSamples/IsGISAXS15Builder.cpp b/Core/StandardSamples/IsGISAXS15Builder.cpp
index a8b9a7b8c1645da932ea61863fba384931092cfe..5a83803c046c3fc235c9d5bb44633cd6c7b6aa13 100644
--- a/Core/StandardSamples/IsGISAXS15Builder.cpp
+++ b/Core/StandardSamples/IsGISAXS15Builder.cpp
@@ -18,7 +18,7 @@
#include "ParticleLayout.h"
#include "Materials.h"
#include "Units.h"
-#include "InterferenceFunction1DParaCrystal.h"
+#include "InterferenceFunctionRadialParaCrystal.h"
#include "FormFactorCylinder.h"
#include "Distributions.h"
#include "ParticleDistribution.h"
@@ -37,8 +37,8 @@ ISample *IsGISAXS15Builder::buildSample() const
Layer air_layer(air_material);
- InterferenceFunction1DParaCrystal *p_interference_function =
- new InterferenceFunction1DParaCrystal(15.0*Units::nanometer,
+ InterferenceFunctionRadialParaCrystal *p_interference_function =
+ new InterferenceFunctionRadialParaCrystal(15.0*Units::nanometer,
1e3*Units::nanometer);
FTDistribution1DGauss pdf(5*Units::nanometer);
p_interference_function->setProbabilityDistribution(pdf);
diff --git a/Core/StandardSamples/Ripple1Builder.cpp b/Core/StandardSamples/Ripple1Builder.cpp
index 5b833593b0d067863c58a0135dff2148b11e5829..872833cb64cade35aff626d5e806ae09de5624ed 100644
--- a/Core/StandardSamples/Ripple1Builder.cpp
+++ b/Core/StandardSamples/Ripple1Builder.cpp
@@ -19,7 +19,7 @@
#include "Materials.h"
#include "FormFactorRipple1.h"
#include "Units.h"
-#include "InterferenceFunction1DParaCrystal.h"
+#include "InterferenceFunctionRadialParaCrystal.h"
Ripple1Builder::Ripple1Builder()
: m_w(20.0*Units::nanometer)
@@ -57,8 +57,8 @@ ISample *Ripple1Builder::buildSample() const
ParticleLayout particle_layout;
particle_layout.addParticle(ripple,0.0,1.0);
- InterferenceFunction1DParaCrystal *p_interference_function =
- new InterferenceFunction1DParaCrystal(m_interf_distance,
+ InterferenceFunctionRadialParaCrystal *p_interference_function =
+ new InterferenceFunctionRadialParaCrystal(m_interf_distance,
1e7*Units::nanometer); // peak_distance, corr_length
FTDistribution1DGauss pdf(m_interf_width);
p_interference_function->setProbabilityDistribution(pdf);
diff --git a/Core/StandardSamples/Ripple2Builder.cpp b/Core/StandardSamples/Ripple2Builder.cpp
index 0bf7d03f581a15939e33c1e4a74144182152c8db..03a734eb00318c139b24744be8f84d2a5305fcad 100644
--- a/Core/StandardSamples/Ripple2Builder.cpp
+++ b/Core/StandardSamples/Ripple2Builder.cpp
@@ -19,7 +19,7 @@
#include "Materials.h"
#include "FormFactorRipple2.h"
#include "Units.h"
-#include "InterferenceFunction1DParaCrystal.h"
+#include "InterferenceFunctionRadialParaCrystal.h"
Ripple2Builder::Ripple2Builder()
: m_w(20.0*Units::nanometer)
@@ -59,8 +59,8 @@ ISample *Ripple2Builder::buildSample() const
ParticleLayout particle_layout;
particle_layout.addParticle(ripple,0.0,1.0);
- InterferenceFunction1DParaCrystal *p_interference_function =
- new InterferenceFunction1DParaCrystal(m_interf_distance,
+ InterferenceFunctionRadialParaCrystal *p_interference_function =
+ new InterferenceFunctionRadialParaCrystal(m_interf_distance,
1e7*Units::nanometer); // peak_distance, corr_length
FTDistribution1DGauss pdf(m_interf_width);
p_interference_function->setProbabilityDistribution(pdf);
diff --git a/Core/Tools/inc/PyGenVisitor.h b/Core/Tools/inc/PyGenVisitor.h
index 4a2242aa45943a4a6e7c34759a407475002b72fd..cda2204149ab813cff9f7082f15a7cf2f42f445f 100644
--- a/Core/Tools/inc/PyGenVisitor.h
+++ b/Core/Tools/inc/PyGenVisitor.h
@@ -42,7 +42,7 @@ public:
void visit(const FormFactorTruncatedSpheroid *sample);
void visit(const InterferenceFunctionNone *);
void visit(const InterferenceFunction1DLattice *);
- void visit(const InterferenceFunction1DParaCrystal *);
+ void visit(const InterferenceFunctionRadialParaCrystal *);
void visit(const InterferenceFunction2DLattice *);
void visit(const InterferenceFunction2DParaCrystal *);
void visit(const Layer *sample);
diff --git a/Core/Tools/inc/SampleMaterialVisitor.h b/Core/Tools/inc/SampleMaterialVisitor.h
index ac270dca81e7ea44f675223090059438bde70eb2..763865c6ff1686f0d78794dd96816953d6328052 100644
--- a/Core/Tools/inc/SampleMaterialVisitor.h
+++ b/Core/Tools/inc/SampleMaterialVisitor.h
@@ -108,7 +108,7 @@ public:
virtual void visit(const IInterferenceFunction *sample);
virtual void visit(const InterferenceFunction1DLattice *sample);
- virtual void visit(const InterferenceFunction1DParaCrystal *sample);
+ virtual void visit(const InterferenceFunctionRadialParaCrystal *sample);
virtual void visit(const InterferenceFunction2DLattice *sample);
virtual void visit(const InterferenceFunction2DParaCrystal *sample);
virtual void visit(const InterferenceFunctionNone *sample);
diff --git a/Core/Tools/inc/SamplePrintVisitor.h b/Core/Tools/inc/SamplePrintVisitor.h
index 4f957762b15ac9c7e94e3bf27673016e78ab2cb7..9fdaf2c173100d22ccb4736fa27a07c52b468057 100644
--- a/Core/Tools/inc/SamplePrintVisitor.h
+++ b/Core/Tools/inc/SamplePrintVisitor.h
@@ -105,7 +105,7 @@ public:
virtual void visit(const IInterferenceFunction *sample);
virtual void visit(const InterferenceFunction1DLattice *sample);
- virtual void visit(const InterferenceFunction1DParaCrystal *sample);
+ virtual void visit(const InterferenceFunctionRadialParaCrystal *sample);
virtual void visit(const InterferenceFunction2DLattice *sample);
virtual void visit(const InterferenceFunction2DParaCrystal *sample);
virtual void visit(const InterferenceFunctionNone *sample);
diff --git a/Core/Tools/src/PyGenVisitor.cpp b/Core/Tools/src/PyGenVisitor.cpp
index 80331c2c4518eddd5f0c02e5398ededa609ffc75..d9b0fbda1114008cc0cef93bc2ebe4c181ce465c 100644
--- a/Core/Tools/src/PyGenVisitor.cpp
+++ b/Core/Tools/src/PyGenVisitor.cpp
@@ -478,11 +478,11 @@ std::string PyGenVisitor::writePyScript(const Simulation *simulation)
}
}
- else if (const InterferenceFunction1DParaCrystal *oneDParaCrystal =
- dynamic_cast<const InterferenceFunction1DParaCrystal *>(interference))
+ else if (const InterferenceFunctionRadialParaCrystal *oneDParaCrystal =
+ dynamic_cast<const InterferenceFunctionRadialParaCrystal *>(interference))
{
result << "\t" << it->second
- << " = InterferenceFunction1DParaCrystal("
+ << " = InterferenceFunctionRadialParaCrystal("
<< oneDParaCrystal->getPeakDistance() << "*nanometer,"
<< oneDParaCrystal->getDampingLength() << "*nanometer)\n";
@@ -1350,7 +1350,7 @@ void PyGenVisitor::visit(const InterferenceFunction1DLattice *sample)
m_label->setLabel(sample);
}
-void PyGenVisitor::visit(const InterferenceFunction1DParaCrystal *sample)
+void PyGenVisitor::visit(const InterferenceFunctionRadialParaCrystal *sample)
{
m_label->setLabel(sample);
}
diff --git a/Core/Tools/src/SampleMaterialVisitor.cpp b/Core/Tools/src/SampleMaterialVisitor.cpp
index 95168ec7e26293814944287a27664083cb17d3db..d7526ea6fe89b93cd352c2651e3c72a95a12686f 100644
--- a/Core/Tools/src/SampleMaterialVisitor.cpp
+++ b/Core/Tools/src/SampleMaterialVisitor.cpp
@@ -287,7 +287,7 @@ void SampleMaterialVisitor::visit(const InterferenceFunction1DLattice *)
{
}
-void SampleMaterialVisitor::visit(const InterferenceFunction1DParaCrystal *)
+void SampleMaterialVisitor::visit(const InterferenceFunctionRadialParaCrystal *)
{
}
diff --git a/Core/Tools/src/SamplePrintVisitor.cpp b/Core/Tools/src/SamplePrintVisitor.cpp
index d2f752ede46de1c6eed071c2b5cdd1a909d16f41..8df9cfdf89ea6549d6b8f43ccaace94673e10aec 100644
--- a/Core/Tools/src/SamplePrintVisitor.cpp
+++ b/Core/Tools/src/SamplePrintVisitor.cpp
@@ -400,7 +400,7 @@ void SamplePrintVisitor::visit(const InterferenceFunction1DLattice *sample)
print_default(sample);
}
-void SamplePrintVisitor::visit(const InterferenceFunction1DParaCrystal *sample)
+void SamplePrintVisitor::visit(const InterferenceFunctionRadialParaCrystal *sample)
{
print_default(sample);
diff --git a/Doc/Doxygen/defgroups.doc b/Doc/Doxygen/defgroups.doc
index 718b84ca1506700c9adbf47a33b5e21bd4671faf..4c7745a0dfbbbeb83697b4e3b5d95e632ac8c467 100644
--- a/Doc/Doxygen/defgroups.doc
+++ b/Doc/Doxygen/defgroups.doc
@@ -66,7 +66,7 @@ A probability distribution function (pdf) is required in order to apply some mo
-InterferenceFunction1DParaCrystal (peak\_distance, width, corr\_length)
+InterferenceFunctionRadialParaCrystal (peak\_distance, width, corr\_length)
where peak\_distance, width, corr\_length are the parameters characterizing the probability distribution function.
diff --git a/Doc/UserManual/Theory.tex b/Doc/UserManual/Theory.tex
index 0eeb1f194b3cd8762823419354475184010149e3..0d4d80dcc5cb9c43009e609ddc458c35a589720d 100755
--- a/Doc/UserManual/Theory.tex
+++ b/Doc/UserManual/Theory.tex
@@ -195,7 +195,7 @@ The interference function is specified when building the sample. It is linked wi
\begin{itemize}
\item \Code{InterferenceFunctionNone()}
\item \Code{InterferenceFunction1DLattice(lattice\_parameters)}
-\item \Code{InterferenceFunction1DParaCrystal(peak\_distance, width,corr\_length)}
+\item \Code{InterferenceFunctionRadialParaCrystal(peak\_distance, width,corr\_length)}
\item \Code{InterferenceFunction2DLattice(lattice\_parameters)}
\item \Code{InterferenceFunction2DParaCrystal(length\_1, length\_2, $\alpha$\_lattice, $\xi$, \\ damping\_length)}
\end{itemize}
@@ -306,7 +306,7 @@ def get_sample():
\newpage
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsubsection{\ding{253} \Code{InterferenceFunction1DParaCrystal(peak\_distance, width, corr\_length)}}
+\subsubsection{\ding{253} \Code{InterferenceFunctionRadialParaCrystal(peak\_distance, width, corr\_length)}}
\begin{itemize}
\item[where] \Code{peak\_distance} is the average distance to the first neighbor peak,
\item[]\Code{width} is the width parameter of the probability distribution,
@@ -360,7 +360,7 @@ To illustrate the 1D paracrystal interference function, we use the same sample a
\begin{lstlisting}[language=python, style=eclipseboxed,numbers=none,nolol,caption={\Code{Python} script to define the 1D paracrystal interference function between half-spheres, where \Code{trsphere} is of type \Code{Particle}.},label={lst:1dpara}]
particle_layout = ParticleLayout()
particle_layout.addParticle(trsphere, 0.0, 1.0)
- interference = InterferenceFunction1DParaCrystal(25.0*nanometer, 7*nanometer, 1e3*nanometer)
+ interference = InterferenceFunctionRadialParaCrystal(25.0*nanometer, 7*nanometer, 1e3*nanometer)
particle_layout.addInterferenceFunction(interference)
\end{lstlisting}
@@ -500,7 +500,7 @@ Function & Parameters & Comments\\
\Code{InterferenceFunction1DLattice} & \Code{lattice\_length} & use only with infinitely long/wide particles \\
& $\xi=\widehat{(\mathbf{x},\mathbf{a})}$ & pdf=(Cauchy, Gauss or Voigt) to be defined\\
\hline
- \Code{InterferenceFunction1DParaCrystal} & peak\_distance of pdf & only Gaussian pdf implemented (no option)\\
+ \Code{InterferenceFunctionRadialParaCrystal} & peak\_distance of pdf & only Gaussian pdf implemented (no option)\\
& width of pdf &\\
& corr\_length (optional) & \\
\hline
diff --git a/Doc/UserManual/interferences.tex b/Doc/UserManual/interferences.tex
index 9ec90a3b41eb38a046f97c65fe6dbdf99149853a..6be86ff674b998134700cc6c300f56952622aa70 100755
--- a/Doc/UserManual/interferences.tex
+++ b/Doc/UserManual/interferences.tex
@@ -140,7 +140,7 @@ The interference function is specified when building the sample. It is linked wi
\begin{itemize}
\item \Code{InterferenceFunctionNone()}
\item \Code{InterferenceFunction1DLattice(lattice\_parameters)}
-\item \Code{InterferenceFunction1DParaCrystal(peak\_distance, width,corr\_length)}
+\item \Code{InterferenceFunctionRadialParaCrystal(peak\_distance, width,corr\_length)}
\item \Code{InterferenceFunction2DLattice(lattice\_parameters)}
\item \Code{InterferenceFunction2DParaCrystal(length\_1, length\_2, $\alpha$\_lattice, $\xi$, \\ corr\_length)}
\end{itemize}
@@ -258,7 +258,7 @@ def get_sample():
\newpage{\cleardoublepage}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsubsection{\ding{253} \Code{InterferenceFunction1DParaCrystal(peak\_distance, width, corr\_length)}} \label{paragraph1dpara}
+\subsubsection{\ding{253} \Code{InterferenceFunctionRadialParaCrystal(peak\_distance, width, corr\_length)}} \label{paragraph1dpara}
\begin{itemize}
\item[where] \Code{peak\_distance} is the average distance to the first neighbor peak,
\item[]\Code{width} is the width parameter of the probability distribution,
@@ -298,7 +298,7 @@ To illustrate the 1D paracrystal interference function, we use the same sample a
\begin{lstlisting}[language=python, style=eclipseboxed,numbers=none,nolol,caption={\Code{Python} script to define the 1D paracrystal interference function between half-spheres, where \Code{trsphere} is of type \Code{Particle}.},label={lst:1dpara}]
particle_layout = ParticleLayout()
particle_layout.addParticle(trsphere, 0.0, 1.0)
- interference = InterferenceFunction1DParaCrystal(25.0*nanometer, 7*nanometer, 1e3*nanometer)
+ interference = InterferenceFunctionRadialParaCrystal(25.0*nanometer, 7*nanometer, 1e3*nanometer)
particle_layout.addInterferenceFunction(interference)
\end{lstlisting}
@@ -434,7 +434,7 @@ Function & Parameters & Comments\\
\Code{InterferenceFunction1DLattice} & \Code{lattice\_length} & use only with infinitely long/wide particles \\
\ref{paragraph1dlatt} & $\xi=\widehat{(\mathbf{x},\mathbf{a})}$ & pdf=(Cauchy, Gauss or Voigt) to be defined\\
\hline
- \Code{InterferenceFunction1DParaCrystal} & peak\_distance of pdf & only Gaussian pdf implemented (no option)\\
+ \Code{InterferenceFunctionRadialParaCrystal} & peak\_distance of pdf & only Gaussian pdf implemented (no option)\\
\ref{paragraph1dpara} & width of pdf &\\
& corr\_length (optional) & \\
\hline
diff --git a/Examples/Demos/simul_demo_cyl_SSCA.py b/Examples/Demos/simul_demo_cyl_SSCA.py
index db1abd44c37b930cb83d9be9c1ba8083fb290531..62121ed22c730483f1ef0edd3124ddc81b00cd64 100644
--- a/Examples/Demos/simul_demo_cyl_SSCA.py
+++ b/Examples/Demos/simul_demo_cyl_SSCA.py
@@ -27,7 +27,7 @@ def RunSimulation():
particle_layout.addParticle(cylinder1)
particle_layout.addParticle(cylinder2)
particle_layout.addParticle(cylinder3)
- interference = InterferenceFunction1DParaCrystal(5 * nanometer)
+ interference = InterferenceFunctionRadialParaCrystal(5 * nanometer)
pdf = FTDistribution1DGauss(1 * nanometer)
interference.setProbabilityDistribution(pdf)
# set coupling between size and space
diff --git a/Examples/Demos/simul_demo_cylsphere.py b/Examples/Demos/simul_demo_cylsphere.py
index 0c5180973d322fd2f9ac109d7f337faffe173b0f..9be7c13f9f2379ae9ac40029318ea6d98467b02d 100644
--- a/Examples/Demos/simul_demo_cylsphere.py
+++ b/Examples/Demos/simul_demo_cylsphere.py
@@ -23,7 +23,7 @@ def RunSimulation():
particle_layout = ParticleLayout()
particle_layout.addParticle(cylinder)
particle_layout.addParticle(sphere)
- interference = InterferenceFunction1DParaCrystal(20 * nanometer)
+ interference = InterferenceFunctionRadialParaCrystal(20 * nanometer)
pdf = FTDistribution1DGauss(2 * nanometer)
interference.setProbabilityDistribution(pdf)
particle_layout.addInterferenceFunction(interference)
diff --git a/Examples/Demos/simul_demo_movie.py b/Examples/Demos/simul_demo_movie.py
index 07673a6c5420e15dc7bc581f210ca10dc4e10565..819aab31e0d8eb777554d3e244f8b6e4b84d2efb 100644
--- a/Examples/Demos/simul_demo_movie.py
+++ b/Examples/Demos/simul_demo_movie.py
@@ -28,7 +28,7 @@ def RunSimulation():
particle_layout.addParticle(cylinder)
# interference function
- interference = InterferenceFunction1DParaCrystal(distance)
+ interference = InterferenceFunctionRadialParaCrystal(distance)
pdf = FTDistribution1DGauss(3 * nanometer)
interference.setProbabilityDistribution(pdf)
particle_layout.addInterferenceFunction(interference)
diff --git a/Examples/Demos/simul_demo_movie2.py b/Examples/Demos/simul_demo_movie2.py
index 9ccdfa0b5df3bf8e41d359e798569d8202e6ab89..fc14ab64cf37a5d934fcf31ab40caf1f25d6dfc1 100644
--- a/Examples/Demos/simul_demo_movie2.py
+++ b/Examples/Demos/simul_demo_movie2.py
@@ -27,7 +27,7 @@ def RunSimulation():
particle_layout.addParticle(semisphere)
# interference function
- interference = InterferenceFunction1DParaCrystal(6 * nanometer)
+ interference = InterferenceFunctionRadialParaCrystal(6 * nanometer)
pdf = FTDistribution1DGauss(1 * nanometer)
interference.setProbabilityDistribution(pdf)
particle_layout.addInterferenceFunction(interference)
diff --git a/Examples/Demos/simul_demo_movie3.py b/Examples/Demos/simul_demo_movie3.py
index 6e358c83eb1da155fdf76ac2f0aa168194378690..6663a3104dfcf21c067efdbaa63d69eb53c5475c 100644
--- a/Examples/Demos/simul_demo_movie3.py
+++ b/Examples/Demos/simul_demo_movie3.py
@@ -31,7 +31,7 @@ def RunSimulation():
particle_layout.addParticle(cylinder1)
particle_layout.addParticle(cylinder2)
particle_layout.addParticle(cylinder3)
- interference = InterferenceFunction1DParaCrystal(6 * nanometer)
+ interference = InterferenceFunctionRadialParaCrystal(6 * nanometer)
pdf = FTDistribution1DGauss(.5 * nanometer)
interference.setProbabilityDistribution(pdf)
# set coupling between size and space
diff --git a/Examples/Demos/simul_demo_polarization.py b/Examples/Demos/simul_demo_polarization.py
index f924d53d345c1d18670fa70be8d98bc2374c5f36..4d8a74e087fd6d6baf0c1fa13a36127ae22912a1 100644
--- a/Examples/Demos/simul_demo_polarization.py
+++ b/Examples/Demos/simul_demo_polarization.py
@@ -26,7 +26,7 @@ def RunSimulation():
particle_layout = ParticleLayout()
particle_layout.addParticle(cylinder)
# particle_layout.addParticle(sphere)
-# interference = InterferenceFunction1DParaCrystal(20 * nanometer, 2 * nanometer)
+# interference = InterferenceFunctionRadialParaCrystal(20 * nanometer, 2 * nanometer)
# pdf = FTDistribution1DGauss(2 * nanometer)
# interference.setProbabilityDistribution(pdf)
# particle_layout.addInterferenceFunction(interference)
diff --git a/Examples/python/UserManual/UMInterferences1DParaCrystal.py b/Examples/python/UserManual/UMInterferences1DParaCrystal.py
index cd18a39f3c1f3c3a75372bff0b4cb94583f1f985..6434c077c0e66cc244116563df1a2d8cec3cfa03 100644
--- a/Examples/python/UserManual/UMInterferences1DParaCrystal.py
+++ b/Examples/python/UserManual/UMInterferences1DParaCrystal.py
@@ -20,7 +20,7 @@ def get_sample():
particle_layout.addParticle(sphere, 0.0, 1.0)
# interferences
- interference = InterferenceFunction1DParaCrystal(25.0*nanometer, 1e3*nanometer)
+ interference = InterferenceFunctionRadialParaCrystal(25.0*nanometer, 1e3*nanometer)
pdf = FTDistribution1DGauss(7 * nanometer)
interference.setProbabilityDistribution(pdf)
particle_layout.addInterferenceFunction(interference)
diff --git a/Examples/python/simulation/ex03_InterferenceFunctions/InterferenceParaCrystal1D.py b/Examples/python/simulation/ex03_InterferenceFunctions/InterferenceParaCrystal1D.py
index c8b8d385969a488f35136af124758ed23a71a1bc..e8a7f1d9f5e5b2153d9d762ba012b7c9a724d5f1 100644
--- a/Examples/python/simulation/ex03_InterferenceFunctions/InterferenceParaCrystal1D.py
+++ b/Examples/python/simulation/ex03_InterferenceFunctions/InterferenceParaCrystal1D.py
@@ -23,7 +23,7 @@ def get_sample():
cylinder_ff = FormFactorCylinder(5*nanometer, 5*nanometer)
cylinder = Particle(m_particle, cylinder_ff)
- interference = InterferenceFunction1DParaCrystal(20.0*nanometer, 1e3*nanometer)
+ interference = InterferenceFunctionRadialParaCrystal(20.0*nanometer, 1e3*nanometer)
pdf = FTDistribution1DGauss(7 * nanometer)
interference.setProbabilityDistribution(pdf)
diff --git a/GUI/coregui/Models/GUIObjectBuilder.cpp b/GUI/coregui/Models/GUIObjectBuilder.cpp
index 8de04c501f8f41d66babb17c4892a0a5da1a1ee6..4b304e801c82add87ac2e18e7a6a226cb682763d 100644
--- a/GUI/coregui/Models/GUIObjectBuilder.cpp
+++ b/GUI/coregui/Models/GUIObjectBuilder.cpp
@@ -579,12 +579,12 @@ void GUIObjectBuilder::visit(const FormFactorTruncatedSpheroid *sample)
m_levelToParentItem[getLevel()] = particleItem;
}
-void GUIObjectBuilder::visit(const InterferenceFunction1DParaCrystal *sample)
+void GUIObjectBuilder::visit(const InterferenceFunctionRadialParaCrystal *sample)
{
ParameterizedItem *parent = m_levelToParentItem[getLevel()-1];
Q_ASSERT(parent);
ParameterizedItem *item = m_sampleModel->insertNewItem(
- Constants::InterferenceFunction1DParaCrystalType,
+ Constants::InterferenceFunctionRadialParaCrystalType,
m_sampleModel->indexOfItem(parent));
Q_ASSERT(item);
TransformFromDomain::setItemFromSample(item, sample);
diff --git a/GUI/coregui/Models/GUIObjectBuilder.h b/GUI/coregui/Models/GUIObjectBuilder.h
index 23ba1c9b4de163dfd60581b1e06ec1977d149f9e..cfac7d1f293d6b203150f03986809c7a4165757c 100644
--- a/GUI/coregui/Models/GUIObjectBuilder.h
+++ b/GUI/coregui/Models/GUIObjectBuilder.h
@@ -74,7 +74,7 @@ public:
void visit(const FormFactorTruncatedSphere *);
void visit(const FormFactorTruncatedSpheroid *);
- void visit(const InterferenceFunction1DParaCrystal *);
+ void visit(const InterferenceFunctionRadialParaCrystal *);
void visit(const InterferenceFunction2DParaCrystal *);
void visit(const InterferenceFunction2DLattice *);
void visit(const InterferenceFunctionNone *);
diff --git a/GUI/coregui/Models/InterferenceFunctionItems.cpp b/GUI/coregui/Models/InterferenceFunctionItems.cpp
index 6b437b51d87dd7e4732a5cc7d70d7b8e7ae76553..68ddc0cb6f7a522f5c5ed73a6a413ec88dd78957 100644
--- a/GUI/coregui/Models/InterferenceFunctionItems.cpp
+++ b/GUI/coregui/Models/InterferenceFunctionItems.cpp
@@ -2,15 +2,15 @@
#include "Units.h"
#include <QDebug>
-const QString InterferenceFunction1DParaCrystalItem::P_PEAK_DISTANCE =
+const QString InterferenceFunctionRadialParaCrystalItem::P_PEAK_DISTANCE =
"Peak_distance";
-const QString InterferenceFunction1DParaCrystalItem::P_DAMPING_LENGTH =
+const QString InterferenceFunctionRadialParaCrystalItem::P_DAMPING_LENGTH =
"Damping_length";
-const QString InterferenceFunction1DParaCrystalItem::P_DOMAIN_SIZE =
+const QString InterferenceFunctionRadialParaCrystalItem::P_DOMAIN_SIZE =
"Domain_size";
-const QString InterferenceFunction1DParaCrystalItem::P_KAPPA =
+const QString InterferenceFunctionRadialParaCrystalItem::P_KAPPA =
"Size_space_coupling";
-const QString InterferenceFunction1DParaCrystalItem::P_PDF = "PDF";
+const QString InterferenceFunctionRadialParaCrystalItem::P_PDF = "PDF";
const QString InterferenceFunction2DParaCrystalItem::P_LATTICE_TYPE =
"Lattice_type";
@@ -33,12 +33,12 @@ const QString InterferenceFunction2DLatticeItem::P_ROTATION_ANGLE =
"Rotation_angle";
const QString InterferenceFunction2DLatticeItem::P_PDF = "PDF";
-InterferenceFunction1DParaCrystalItem::InterferenceFunction1DParaCrystalItem(
+InterferenceFunctionRadialParaCrystalItem::InterferenceFunctionRadialParaCrystalItem(
ParameterizedItem *parent)
- : ParameterizedGraphicsItem(Constants::InterferenceFunction1DParaCrystalType,
+ : ParameterizedGraphicsItem(Constants::InterferenceFunctionRadialParaCrystalType,
parent)
{
- setItemName(Constants::InterferenceFunction1DParaCrystalType);
+ setItemName(Constants::InterferenceFunctionRadialParaCrystalType);
setItemPort(ParameterizedItem::PortInfo::PORT_1);
registerProperty(P_PEAK_DISTANCE, 20.0*Units::nanometer);
registerProperty(P_DAMPING_LENGTH, 1000.0*Units::micrometer);
diff --git a/GUI/coregui/Models/InterferenceFunctionItems.h b/GUI/coregui/Models/InterferenceFunctionItems.h
index 3119e737556f5c6e27279dc4693a6fc43e421d88..5679f045a5647353989f4cbe82ec226b7283a7b0 100644
--- a/GUI/coregui/Models/InterferenceFunctionItems.h
+++ b/GUI/coregui/Models/InterferenceFunctionItems.h
@@ -4,7 +4,7 @@
#include "ParameterizedGraphicsItem.h"
-class BA_CORE_API_ InterferenceFunction1DParaCrystalItem : public ParameterizedGraphicsItem
+class BA_CORE_API_ InterferenceFunctionRadialParaCrystalItem : public ParameterizedGraphicsItem
{
Q_OBJECT
public:
@@ -13,8 +13,8 @@ public:
static const QString P_DOMAIN_SIZE;
static const QString P_KAPPA;
static const QString P_PDF;
- explicit InterferenceFunction1DParaCrystalItem(ParameterizedItem *parent=0);
- ~InterferenceFunction1DParaCrystalItem(){}
+ explicit InterferenceFunctionRadialParaCrystalItem(ParameterizedItem *parent=0);
+ ~InterferenceFunctionRadialParaCrystalItem(){}
};
diff --git a/GUI/coregui/Models/ItemFactory.cpp b/GUI/coregui/Models/ItemFactory.cpp
index ab8e005fc83cfcdcbe686cff05943d29364bab9f..54d5a413ccb38ebaa852226c8d894f927cb11664 100644
--- a/GUI/coregui/Models/ItemFactory.cpp
+++ b/GUI/coregui/Models/ItemFactory.cpp
@@ -52,7 +52,7 @@ ItemFactory::ItemMap_t initializeItemMap() {
result[Constants::TransformationType] = &createInstance<TransformationItem>;
result[Constants::ParticleCoreShellType] = &createInstance<ParticleCoreShellItem>;
result[Constants::ParticleDistributionType] = &createInstance<ParticleDistributionItem>;
- result[Constants::InterferenceFunction1DParaCrystalType] = &createInstance<InterferenceFunction1DParaCrystalItem>;
+ result[Constants::InterferenceFunctionRadialParaCrystalType] = &createInstance<InterferenceFunctionRadialParaCrystalItem>;
result[Constants::InterferenceFunction2DParaCrystalType] = &createInstance<InterferenceFunction2DParaCrystalItem>;
result[Constants::InterferenceFunction2DLatticeType] = &createInstance<InterferenceFunction2DLatticeItem>;
result[Constants::InstrumentType] = &createInstance<InstrumentItem>;
@@ -133,7 +133,7 @@ QStringList ItemFactory::m_valid_top_item_names = QStringList()
<< Constants::TransformationType
<< Constants::ParticleCoreShellType
<< Constants::ParticleDistributionType
- << Constants::InterferenceFunction1DParaCrystalType
+ << Constants::InterferenceFunctionRadialParaCrystalType
<< Constants::InterferenceFunction2DParaCrystalType
<< Constants::InterferenceFunction2DLatticeType;
diff --git a/GUI/coregui/Models/ParticleLayoutItem.cpp b/GUI/coregui/Models/ParticleLayoutItem.cpp
index ec3d5ccaa1afc23820065011d7eec8ab1c0c3aa0..4938b37d33002e9081294b32992e2dd6af7897d6 100644
--- a/GUI/coregui/Models/ParticleLayoutItem.cpp
+++ b/GUI/coregui/Models/ParticleLayoutItem.cpp
@@ -33,7 +33,7 @@ ParticleLayoutItem::ParticleLayoutItem(ParameterizedItem *parent)
addToValidChildren(Constants::ParticleType, PortInfo::PORT_0);
addToValidChildren(Constants::ParticleCoreShellType, PortInfo::PORT_0);
addToValidChildren(Constants::ParticleDistributionType, PortInfo::PORT_0);
- addToValidChildren(Constants::InterferenceFunction1DParaCrystalType, PortInfo::PORT_1, 1);
+ addToValidChildren(Constants::InterferenceFunctionRadialParaCrystalType, PortInfo::PORT_1, 1);
addToValidChildren(Constants::InterferenceFunction2DParaCrystalType, PortInfo::PORT_1, 1);
addToValidChildren(Constants::InterferenceFunction2DLatticeType, PortInfo::PORT_1, 1);
}
diff --git a/GUI/coregui/Models/TransformFromDomain.cpp b/GUI/coregui/Models/TransformFromDomain.cpp
index 36da2c02adb35e04c0278ea859e99db52ffa1714..9f3cc0ff05375e13908f00852ebf050619df37af 100644
--- a/GUI/coregui/Models/TransformFromDomain.cpp
+++ b/GUI/coregui/Models/TransformFromDomain.cpp
@@ -30,24 +30,24 @@
void TransformFromDomain::setItemFromSample(ParameterizedItem *item,
- const InterferenceFunction1DParaCrystal *sample)
+ const InterferenceFunctionRadialParaCrystal *sample)
{
item->setRegisteredProperty(
- InterferenceFunction1DParaCrystalItem::P_PEAK_DISTANCE,
+ InterferenceFunctionRadialParaCrystalItem::P_PEAK_DISTANCE,
sample->getPeakDistance() );
item->setRegisteredProperty(
- InterferenceFunction1DParaCrystalItem::P_DAMPING_LENGTH,
+ InterferenceFunctionRadialParaCrystalItem::P_DAMPING_LENGTH,
sample->getDampingLength() );
item->setRegisteredProperty(
- InterferenceFunction1DParaCrystalItem::P_DOMAIN_SIZE,
+ InterferenceFunctionRadialParaCrystalItem::P_DOMAIN_SIZE,
sample->getDomainSize() );
item->setRegisteredProperty(
- InterferenceFunction1DParaCrystalItem::P_KAPPA,
+ InterferenceFunctionRadialParaCrystalItem::P_KAPPA,
sample->getKappa() );
const IFTDistribution1D *ipdf = sample->getPropabilityDistribution();
- QString group_name = InterferenceFunction1DParaCrystalItem::P_PDF;
+ QString group_name = InterferenceFunctionRadialParaCrystalItem::P_PDF;
qDebug() << " group_name" << group_name;
if(const FTDistribution1DCauchy *pdf =
diff --git a/GUI/coregui/Models/TransformFromDomain.h b/GUI/coregui/Models/TransformFromDomain.h
index 981eb70f5c246f4c46baefc34328652ed08adee1..99e4be8eabedfc7f9d37b058719aa56429d40fdf 100644
--- a/GUI/coregui/Models/TransformFromDomain.h
+++ b/GUI/coregui/Models/TransformFromDomain.h
@@ -6,7 +6,7 @@
class FormFactorAnisoPyramid;
class ParameterizedItem;
-class InterferenceFunction1DParaCrystal;
+class InterferenceFunctionRadialParaCrystal;
class InterferenceFunction2DParaCrystal;
class InterferenceFunction2DLattice;
class LayerRoughness;
@@ -21,7 +21,7 @@ BA_CORE_API_ void setItemFromSample(ParameterizedItem *item,
const FormFactorAnisoPyramid *sample);
BA_CORE_API_ void setItemFromSample(ParameterizedItem *item,
- const InterferenceFunction1DParaCrystal *sample);
+ const InterferenceFunctionRadialParaCrystal *sample);
BA_CORE_API_ void setItemFromSample(ParameterizedItem *item,
const InterferenceFunction2DParaCrystal *sample);
diff --git a/GUI/coregui/Models/TransformToDomain.cpp b/GUI/coregui/Models/TransformToDomain.cpp
index 40a5bda94b329e0525b4f01e771974c31be96bd7..fa386bc687f0c6b3bfe3441a24cd4d286f9f05ce 100644
--- a/GUI/coregui/Models/TransformToDomain.cpp
+++ b/GUI/coregui/Models/TransformToDomain.cpp
@@ -136,27 +136,27 @@ IDistribution1D *TransformToDomain::createDistribution(
IInterferenceFunction *TransformToDomain::createInterferenceFunction(
const ParameterizedItem &item)
{
- if(item.modelType() == Constants::InterferenceFunction1DParaCrystalType) {
+ if(item.modelType() == Constants::InterferenceFunctionRadialParaCrystalType) {
double peak_distance = item.getRegisteredProperty(
- InterferenceFunction1DParaCrystalItem::P_PEAK_DISTANCE)
+ InterferenceFunctionRadialParaCrystalItem::P_PEAK_DISTANCE)
.toDouble();
double damping_length = item.getRegisteredProperty(
- InterferenceFunction1DParaCrystalItem::P_DAMPING_LENGTH)
+ InterferenceFunctionRadialParaCrystalItem::P_DAMPING_LENGTH)
.toDouble();
double domain_size = item.getRegisteredProperty(
- InterferenceFunction1DParaCrystalItem::P_DOMAIN_SIZE)
+ InterferenceFunctionRadialParaCrystalItem::P_DOMAIN_SIZE)
.toDouble();
double kappa = item.getRegisteredProperty(
- InterferenceFunction1DParaCrystalItem::P_KAPPA)
+ InterferenceFunctionRadialParaCrystalItem::P_KAPPA)
.toDouble();
- InterferenceFunction1DParaCrystal *result =
- new InterferenceFunction1DParaCrystal(peak_distance,
+ InterferenceFunctionRadialParaCrystal *result =
+ new InterferenceFunctionRadialParaCrystal(peak_distance,
damping_length);
result->setDomainSize(domain_size);
result->setKappa(kappa);
ParameterizedItem *pdfItem = item.getSubItems()[
- InterferenceFunction1DParaCrystalItem::P_PDF];
+ InterferenceFunctionRadialParaCrystalItem::P_PDF];
Q_ASSERT(pdfItem);
boost::scoped_ptr<IFTDistribution1D> pdf(
diff --git a/GUI/coregui/Models/item_constants.h b/GUI/coregui/Models/item_constants.h
index c529acd53f8ffb1c07af99919397ccce2bf79bca..cc084d62298852ac808808fc56431f1efab34853 100644
--- a/GUI/coregui/Models/item_constants.h
+++ b/GUI/coregui/Models/item_constants.h
@@ -16,7 +16,7 @@ const ModelType ParticleLayoutType = "ParticleLayout";
const ModelType ParticleCoreShellType = "ParticleCoreShell";
const ModelType ParticleDistributionType = "ParticleDistribution";
const ModelType TransformationType = "Transformation";
-const ModelType InterferenceFunction1DParaCrystalType = "InterferenceFunction1DParaCrystal";
+const ModelType InterferenceFunctionRadialParaCrystalType = "InterferenceFunctionRadialParaCrystal";
const ModelType InterferenceFunction2DParaCrystalType = "InterferenceFunction2DParaCrystal";
const ModelType InterferenceFunction2DLatticeType = "InterferenceFunction2DLattice";
const ModelType InstrumentType = "Instrument";
diff --git a/GUI/coregui/Views/Components/SampleDesigner/DesignerHelper.h b/GUI/coregui/Views/Components/SampleDesigner/DesignerHelper.h
index 0a4ba970a21f3cb0661dfb8e4fbd118429c7cbca..518fc2850f8a40b80e7ac401f67654f7c3d2aaa5 100644
--- a/GUI/coregui/Views/Components/SampleDesigner/DesignerHelper.h
+++ b/GUI/coregui/Views/Components/SampleDesigner/DesignerHelper.h
@@ -22,7 +22,7 @@ public:
LAYER,
PARTICLE_LAYOUT,
INTERFERENCE_FUNCTION,
- INTERFERENCE_FUNCTION_1D_PARA,
+ INTERFERENCE_FUNCTION_RADIAL_PARA,
INTERFERENCE_FUNCTION_2D_PARA,
INTERFERENCE_FUNCTION_2D_LATTICE,
PARTICLE,
diff --git a/GUI/coregui/Views/Components/SampleDesigner/InterferenceFunctionViews.cpp b/GUI/coregui/Views/Components/SampleDesigner/InterferenceFunctionViews.cpp
index bfce9ace47b51b80f7fd83492e5db10ff480e551..b8574f64ede21236df402ac9bc59263b747763ec 100644
--- a/GUI/coregui/Views/Components/SampleDesigner/InterferenceFunctionViews.cpp
+++ b/GUI/coregui/Views/Components/SampleDesigner/InterferenceFunctionViews.cpp
@@ -3,10 +3,10 @@
#include "item_constants.h"
-InterferenceFunction1DParaCrystalView::InterferenceFunction1DParaCrystalView(QGraphicsItem *parent)
+InterferenceFunctionRadialParaCrystalView::InterferenceFunctionRadialParaCrystalView(QGraphicsItem *parent)
: ConnectableView(parent)
{
- setName(Constants::InterferenceFunction1DParaCrystalType);
+ setName(Constants::InterferenceFunctionRadialParaCrystalType);
setLabel("Interference \n1D paracrystal");
setColor(QColor(255, 236, 139));
setRectangle( DesignerHelper::getDefaultBoundingRect(getName()) );
diff --git a/GUI/coregui/Views/Components/SampleDesigner/InterferenceFunctionViews.h b/GUI/coregui/Views/Components/SampleDesigner/InterferenceFunctionViews.h
index bc50a9a83fe4fd3a7c8f0f5cc440e2d14606269c..40bd6a5084d116134a93ff0b44c31cdcd694500a 100644
--- a/GUI/coregui/Views/Components/SampleDesigner/InterferenceFunctionViews.h
+++ b/GUI/coregui/Views/Components/SampleDesigner/InterferenceFunctionViews.h
@@ -4,14 +4,14 @@
#include "ConnectableView.h"
-class BA_CORE_API_ InterferenceFunction1DParaCrystalView : public ConnectableView
+class BA_CORE_API_ InterferenceFunctionRadialParaCrystalView : public ConnectableView
{
Q_OBJECT
public:
- enum { TYPE = DesignerHelper::INTERFERENCE_FUNCTION_1D_PARA };
+ enum { TYPE = DesignerHelper::INTERFERENCE_FUNCTION_RADIAL_PARA };
- InterferenceFunction1DParaCrystalView(QGraphicsItem *parent = 0);
+ InterferenceFunctionRadialParaCrystalView(QGraphicsItem *parent = 0);
int type() const { return TYPE; }
};
diff --git a/GUI/coregui/Views/Components/SampleDesigner/ParticleLayoutView.cpp b/GUI/coregui/Views/Components/SampleDesigner/ParticleLayoutView.cpp
index 0227a9b104688d72474e1424788ee69bc969bb8f..d343187dfcbcf7b416e8a0b4e31345be7c819ab7 100644
--- a/GUI/coregui/Views/Components/SampleDesigner/ParticleLayoutView.cpp
+++ b/GUI/coregui/Views/Components/SampleDesigner/ParticleLayoutView.cpp
@@ -26,7 +26,7 @@ void ParticleLayoutView::addView(IView *childView, int /* row */)
if(childView->type() == DesignerHelper::PARTICLE) {
connectInputPort(dynamic_cast<ConnectableView *>(childView), 0);
}
- else if(childView->type() == DesignerHelper::INTERFERENCE_FUNCTION_1D_PARA
+ else if(childView->type() == DesignerHelper::INTERFERENCE_FUNCTION_RADIAL_PARA
|| childView->type() == DesignerHelper::INTERFERENCE_FUNCTION_2D_PARA
|| childView->type() == DesignerHelper::INTERFERENCE_FUNCTION_2D_LATTICE) {
connectInputPort(dynamic_cast<ConnectableView *>(childView), 1);
diff --git a/GUI/coregui/Views/Components/SampleDesigner/SampleViewFactory.cpp b/GUI/coregui/Views/Components/SampleDesigner/SampleViewFactory.cpp
index 24461676a4fc8b19338c4612b0cb967841c34366..bbda913155452196ed42d4772cabbed0c73674c4 100644
--- a/GUI/coregui/Views/Components/SampleDesigner/SampleViewFactory.cpp
+++ b/GUI/coregui/Views/Components/SampleDesigner/SampleViewFactory.cpp
@@ -20,7 +20,7 @@ QStringList SampleViewFactory::m_valid_item_names = QStringList()
<< Constants::TransformationType
<< Constants::ParticleCoreShellType
<< Constants::ParticleDistributionType
- << Constants::InterferenceFunction1DParaCrystalType
+ << Constants::InterferenceFunctionRadialParaCrystalType
<< Constants::InterferenceFunction2DParaCrystalType
<< Constants::InterferenceFunction2DLatticeType;
@@ -58,8 +58,8 @@ IView *SampleViewFactory::createSampleView(const QString &name)
else if (name==Constants::ParticleDistributionType) {
return new ParticleDistributionView();
}
- else if (name==Constants::InterferenceFunction1DParaCrystalType) {
- return new InterferenceFunction1DParaCrystalView();
+ else if (name==Constants::InterferenceFunctionRadialParaCrystalType) {
+ return new InterferenceFunctionRadialParaCrystalView();
}
else if (name==Constants::InterferenceFunction2DParaCrystalType) {
return new InterferenceFunction2DParaCrystalView();
diff --git a/GUI/coregui/Views/Components/widgetbox/widgetbox.xml b/GUI/coregui/Views/Components/widgetbox/widgetbox.xml
index 700c10c0a92d400637d92b0195772e4f8fa9e43c..02298401f2467800e201fa6ccb6ba14daf8646da 100644
--- a/GUI/coregui/Views/Components/widgetbox/widgetbox.xml
+++ b/GUI/coregui/Views/Components/widgetbox/widgetbox.xml
@@ -36,7 +36,7 @@
<category name="Interference functions">
<categoryentry name="1D paracrystal" icon="images/ParaCrystal1D.png">
- <widget class="InterferenceFunction1DParaCrystal">
+ <widget class="InterferenceFunctionRadialParaCrystal">
<property name="objectName">
<string notr="true">somestring</string>
</property>
diff --git a/GUI/coregui/mainwindow/tooltips.xml b/GUI/coregui/mainwindow/tooltips.xml
index c9f0ad3e8ca689fee2d1411d25bf9fd9c8ec3804..2b948ab5533b09f880b19484cd44f26a3fde7873 100644
--- a/GUI/coregui/mainwindow/tooltips.xml
+++ b/GUI/coregui/mainwindow/tooltips.xml
@@ -44,7 +44,7 @@
</category>
- <category name="InterferenceFunction1DParaCrystal">
+ <category name="InterferenceFunctionRadialParaCrystal">
<property name="Title">
<tooltip>Interference 1D Paracrystal</tooltip>
</property>
diff --git a/GUI/test_sample_builder.py b/GUI/test_sample_builder.py
index 4004737a9f570462c842c18bec565084afa92fab..9a355238f6d233d3f685da42eeaac4bc2c1c1da1 100644
--- a/GUI/test_sample_builder.py
+++ b/GUI/test_sample_builder.py
@@ -30,7 +30,7 @@ def BuildSample(m_layer_thickness, m_cylinder_height, m_cylinder_radius):
middle_layer = Layer(p_layer_material, m_layer_thickness)
substrate_layer = Layer(p_substrate_material)
- interference_funtion = InterferenceFunction1DParaCrystal(20.0*nanometer, 7*nanometer, 1e7*nanometer)
+ interference_funtion = InterferenceFunctionRadialParaCrystal(20.0*nanometer, 7*nanometer, 1e7*nanometer)
ff_cylinder = FormFactorCylinder(m_cylinder_radius, m_cylinder_height)
nano_particle = Particle(n_particle, ff_cylinder )
particle_collection = ParticleDecoration()
diff --git a/Tests/FunctionalTests/TestPyCore/isgisaxs04.py b/Tests/FunctionalTests/TestPyCore/isgisaxs04.py
index 86f5902d13fe68bd2e697369cc332e89dc35b0ee..7ce68b161c4829fb7d8a8ee811bbe8cf8a0243ae 100644
--- a/Tests/FunctionalTests/TestPyCore/isgisaxs04.py
+++ b/Tests/FunctionalTests/TestPyCore/isgisaxs04.py
@@ -23,7 +23,7 @@ def RunSimulation1():
# collection of particles
cylinder_ff = FormFactorCylinder(5 * nanometer, 5 * nanometer)
cylinder = Particle(mParticle, cylinder_ff)
- interference = InterferenceFunction1DParaCrystal(20.0 * nanometer, 1e3 * nanometer)
+ interference = InterferenceFunctionRadialParaCrystal(20.0 * nanometer, 1e3 * nanometer)
pdf = FTDistribution1DGauss(7 * nanometer)
interference.setProbabilityDistribution(pdf)
particle_layout = ParticleLayout()
diff --git a/Tests/FunctionalTests/TestPyCore/isgisaxs10.py b/Tests/FunctionalTests/TestPyCore/isgisaxs10.py
index 0838148164e60865c06c74a7335120314914bdb8..e3a3bd8fa666a91a670aae8250e57a2a9097c787 100644
--- a/Tests/FunctionalTests/TestPyCore/isgisaxs10.py
+++ b/Tests/FunctionalTests/TestPyCore/isgisaxs10.py
@@ -22,7 +22,7 @@ def RunSimulation():
# collection of particles
cylinder_ff = FormFactorCylinder(5 * nanometer, 5 * nanometer)
cylinder = Particle(mParticle, cylinder_ff)
- interference = InterferenceFunction1DParaCrystal(20.0 * nanometer, 1e7 * nanometer)
+ interference = InterferenceFunctionRadialParaCrystal(20.0 * nanometer, 1e7 * nanometer)
pdf = FTDistribution1DGauss(7 * nanometer)
interference.setProbabilityDistribution(pdf)
particle_layout = ParticleLayout()
diff --git a/Tests/FunctionalTests/TestPyCore/isgisaxs15.py b/Tests/FunctionalTests/TestPyCore/isgisaxs15.py
index 84b4c6d993a2c2e3e0ed2da25ebde4b46ceeee1d..1e4fe591c2a45a9b6b9a69cc83d0dba170538e35 100644
--- a/Tests/FunctionalTests/TestPyCore/isgisaxs15.py
+++ b/Tests/FunctionalTests/TestPyCore/isgisaxs15.py
@@ -20,7 +20,7 @@ def RunSimulation():
# collection of particles
cylinder_ff = FormFactorCylinder(5 * nanometer, 5 * nanometer)
- interference = InterferenceFunction1DParaCrystal(15.0 * nanometer, 1e3 * nanometer)
+ interference = InterferenceFunctionRadialParaCrystal(15.0 * nanometer, 1e3 * nanometer)
pdf = FTDistribution1DGauss(5 * nanometer)
interference.setProbabilityDistribution(pdf)
interference.setKappa(4.02698)
diff --git a/Tests/FunctionalTests/TestPyCore/ripple1.py b/Tests/FunctionalTests/TestPyCore/ripple1.py
index 9696b85bef6ac9de83b4341a8e5cc0d816bbc6a6..fee8305049d2eaab980f22767977058b88d6ca29 100644
--- a/Tests/FunctionalTests/TestPyCore/ripple1.py
+++ b/Tests/FunctionalTests/TestPyCore/ripple1.py
@@ -27,7 +27,7 @@ def RunSimulation():
particle_layout = ParticleLayout()
particle_layout.addParticle(ripple, 0.0, 1.0)
- interference = InterferenceFunction1DParaCrystal(20 * nanometer, 1e7 * nanometer)
+ interference = InterferenceFunctionRadialParaCrystal(20 * nanometer, 1e7 * nanometer)
pdf = FTDistribution1DGauss(4 * nanometer)
interference.setProbabilityDistribution(pdf)
particle_layout.addInterferenceFunction(interference)
diff --git a/Tests/FunctionalTests/TestPyCore/ripple2_asym.py b/Tests/FunctionalTests/TestPyCore/ripple2_asym.py
index 26f7fce81d52937752507095bb96cd1f820b5c15..10a846c8830171db6436c8dde91ab366ba754d85 100644
--- a/Tests/FunctionalTests/TestPyCore/ripple2_asym.py
+++ b/Tests/FunctionalTests/TestPyCore/ripple2_asym.py
@@ -27,7 +27,7 @@ def RunSimulation():
particle_layout = ParticleLayout()
particle_layout.addParticle(ripple, 0.0, 1.0)
- interference = InterferenceFunction1DParaCrystal(20 * nanometer, 1e7 * nanometer)
+ interference = InterferenceFunctionRadialParaCrystal(20 * nanometer, 1e7 * nanometer)
pdf = FTDistribution1DGauss(4 * nanometer)
interference.setProbabilityDistribution(pdf)
particle_layout.addInterferenceFunction(interference)
diff --git a/Tests/FunctionalTests/TestPyCore/ripple2_sym.py b/Tests/FunctionalTests/TestPyCore/ripple2_sym.py
index 5c5570867c541cb9a741e5baaf64bca1f6da925e..52bf7717b88e28ea6d22fcbb5d58ec5ca455c4b1 100644
--- a/Tests/FunctionalTests/TestPyCore/ripple2_sym.py
+++ b/Tests/FunctionalTests/TestPyCore/ripple2_sym.py
@@ -28,7 +28,7 @@ def RunSimulation():
particle_layout = ParticleLayout()
particle_layout.addParticle(ripple, 0.0, 1.0)
- interference = InterferenceFunction1DParaCrystal(20 * nanometer, 1e7 * nanometer)
+ interference = InterferenceFunctionRadialParaCrystal(20 * nanometer, 1e7 * nanometer)
pdf = FTDistribution1DGauss(4 * nanometer)
interference.setProbabilityDistribution(pdf)
particle_layout.addInterferenceFunction(interference)
diff --git a/Tests/UnitTests/TestGUI/TestParaCrystalItems.h b/Tests/UnitTests/TestGUI/TestParaCrystalItems.h
index dd74ca53439898ca11a96048360857cbf58e8e46..343d2a319877c60e911302b64f10e7734b91b683 100644
--- a/Tests/UnitTests/TestGUI/TestParaCrystalItems.h
+++ b/Tests/UnitTests/TestGUI/TestParaCrystalItems.h
@@ -16,26 +16,26 @@ private slots:
inline void TestParaCrystalItems::test_Para1D_InitialState()
{
- InterferenceFunction1DParaCrystalItem item;
- QCOMPARE(item.modelType(), Constants::InterferenceFunction1DParaCrystalType);
- QCOMPARE(item.itemName(), Constants::InterferenceFunction1DParaCrystalType);
+ InterferenceFunctionRadialParaCrystalItem item;
+ QCOMPARE(item.modelType(), Constants::InterferenceFunctionRadialParaCrystalType);
+ QCOMPARE(item.itemName(), Constants::InterferenceFunctionRadialParaCrystalType);
QCOMPARE(item.getSubItems().size(), 1);
- QCOMPARE(item.getRegisteredProperty(InterferenceFunction1DParaCrystalItem::P_PEAK_DISTANCE).toDouble(), 20.0*Units::nanometer);
- QCOMPARE(item.getRegisteredProperty(InterferenceFunction1DParaCrystalItem::P_DAMPING_LENGTH).toDouble(), 1000.0*Units::micrometer);
- QCOMPARE(item.getRegisteredProperty(InterferenceFunction1DParaCrystalItem::P_DOMAIN_SIZE).toDouble(), 20.0*Units::micrometer);
- QCOMPARE(item.getRegisteredProperty(InterferenceFunction1DParaCrystalItem::P_KAPPA).toDouble(), 0.0);
+ QCOMPARE(item.getRegisteredProperty(InterferenceFunctionRadialParaCrystalItem::P_PEAK_DISTANCE).toDouble(), 20.0*Units::nanometer);
+ QCOMPARE(item.getRegisteredProperty(InterferenceFunctionRadialParaCrystalItem::P_DAMPING_LENGTH).toDouble(), 1000.0*Units::micrometer);
+ QCOMPARE(item.getRegisteredProperty(InterferenceFunctionRadialParaCrystalItem::P_DOMAIN_SIZE).toDouble(), 20.0*Units::micrometer);
+ QCOMPARE(item.getRegisteredProperty(InterferenceFunctionRadialParaCrystalItem::P_KAPPA).toDouble(), 0.0);
- QCOMPARE(item.getSubItems()[InterferenceFunction1DParaCrystalItem::P_PDF]->modelType(), Constants::FTDistribution1DCauchyType);
+ QCOMPARE(item.getSubItems()[InterferenceFunctionRadialParaCrystalItem::P_PDF]->modelType(), Constants::FTDistribution1DCauchyType);
- FancyGroupProperty_t group_property = item.getRegisteredProperty(InterferenceFunction1DParaCrystalItem::P_PDF).value<FancyGroupProperty_t>();
+ FancyGroupProperty_t group_property = item.getRegisteredProperty(InterferenceFunctionRadialParaCrystalItem::P_PDF).value<FancyGroupProperty_t>();
QCOMPARE(group_property->type(), FancyGroupProperty::SELECTABLE);
}
inline void TestParaCrystalItems::test_Para1D_PDFGroupProperty()
{
- InterferenceFunction1DParaCrystalItem item;
+ InterferenceFunctionRadialParaCrystalItem item;
// check that request for new subItem generates item of correct modelType and
// correct signals (one propertyItemChanged, and no propertyChanged)
@@ -50,10 +50,10 @@ inline void TestParaCrystalItems::test_Para1D_PDFGroupProperty()
foreach(QString pdf_name, pdfs) {
QSignalSpy spyItem(&item, SIGNAL(propertyChanged(QString)));
QSignalSpy spyPropertyItem(&item, SIGNAL(propertyItemChanged(QString)));
- ParameterizedItem *pdfItem = item.setGroupProperty(InterferenceFunction1DParaCrystalItem::P_PDF, pdf_name);
+ ParameterizedItem *pdfItem = item.setGroupProperty(InterferenceFunctionRadialParaCrystalItem::P_PDF, pdf_name);
QVERIFY(pdfItem);
QCOMPARE(item.getSubItems().size(), 1);
- QCOMPARE(pdfItem, item.getSubItems()[InterferenceFunction1DParaCrystalItem::P_PDF]);
+ QCOMPARE(pdfItem, item.getSubItems()[InterferenceFunctionRadialParaCrystalItem::P_PDF]);
QCOMPARE(spyItem.count(), 0);
if(pdf_name == Constants::FTDistribution1DCauchyType) { // default ff
@@ -61,7 +61,7 @@ inline void TestParaCrystalItems::test_Para1D_PDFGroupProperty()
} else {
QCOMPARE(spyPropertyItem.count(), 1);
QList<QVariant> arguments = spyPropertyItem.takeFirst(); // take the first signal
- QCOMPARE(arguments.at(0).toString(), InterferenceFunction1DParaCrystalItem::P_PDF);
+ QCOMPARE(arguments.at(0).toString(), InterferenceFunctionRadialParaCrystalItem::P_PDF);
}
QCOMPARE(pdfItem->modelType(), pdf_name);
diff --git a/dev-tools/python-bindings/settings_core.py b/dev-tools/python-bindings/settings_core.py
index 7bb03804977ff759b283c4bdbce1a566a2b9d532..c2ef864c91c576226b7d5a4233ef6d2c1cdd4572 100644
--- a/dev-tools/python-bindings/settings_core.py
+++ b/dev-tools/python-bindings/settings_core.py
@@ -122,7 +122,7 @@ include_classes = [
"Transform3D",
"Instrument",
"InterferenceFunction1DLattice",
- "InterferenceFunction1DParaCrystal",
+ "InterferenceFunctionRadialParaCrystal",
"InterferenceFunction2DLattice",
"InterferenceFunction2DParaCrystal",
"InterferenceFunctionNone",
diff --git a/dev-tools/user-api/docstring.py b/dev-tools/user-api/docstring.py
index 169007ce670e0814a6e16af1a4a22884a10c97ea..06ed5e3017659159ca90c12527e302c782b0e5cf 100644
--- a/dev-tools/user-api/docstring.py
+++ b/dev-tools/user-api/docstring.py
@@ -27,8 +27,8 @@ user_api = [
"FormFactorSphere",
"FormFactorSphereGaussianRadius",
"IFormFactorBorn.evaluate_for_q",
- "InterferenceFunction1DParaCrystal",
- "InterferenceFunction1DParaCrystal.setKappa",
+ "InterferenceFunctionRadialParaCrystal",
+ "InterferenceFunctionRadialParaCrystal.setKappa",
"InterferenceFunction2DLattice",
"InterferenceFunction2DParaCrystal",
"InterferenceFunction2DParaCrystal.createHexagonal",