diff --git a/Core/Algorithms/src/Detector.cpp b/Core/Algorithms/src/Detector.cpp
index 9054056671cde0e91272d2df03420f9137df9b27..79f0311e0fcde4605c6c61c32c569e816d43055c 100644
--- a/Core/Algorithms/src/Detector.cpp
+++ b/Core/Algorithms/src/Detector.cpp
@@ -19,10 +19,8 @@
#include "AxisDouble.h"
#include "MessageService.h"
#include "BornAgainNamespace.h"
-#include "AsymmetricBinAxis.h"
#include "FixedBinAxis.h"
-#include "AngleBinAxis.h"
-#include "IsGisaxsAxis.h"
+#include "CustomBinAxis.h"
#include <iostream>
@@ -83,7 +81,7 @@ void Detector::addAxis(const AxisParameters& axis_params)
// p_new_axis = AsymmetricBinAxis::createIsGISAXSAxis(axis_params.m_name, axis_params.m_range.getNSamples(), axis_params.m_range.getLowerBound(), axis_params.m_range.getUpperBound());
// p_new_axis = AngleBinAxis::createIsGISAXSAxis(axis_params.m_name, axis_params.m_range.getNSamples(), axis_params.m_range.getLowerBound(), axis_params.m_range.getUpperBound());
std::cout << "XXX " << axis_params.m_name << " " << axis_params.m_range.getNSamples() << " " << axis_params.m_range.getLowerBound() << " " << axis_params.m_range.getUpperBound() << std::endl;
- p_new_axis = new IsGisaxsAxis(axis_params.m_name, axis_params.m_range.getNSamples(), axis_params.m_range.getLowerBound(), axis_params.m_range.getUpperBound());
+ p_new_axis = new CustomBinAxis(axis_params.m_name, axis_params.m_range.getNSamples(), axis_params.m_range.getLowerBound(), axis_params.m_range.getUpperBound());
break;
}
diff --git a/Core/PythonAPI/inc/IsGisaxsAxis.pypp.h b/Core/PythonAPI/inc/CustomBinAxis.pypp.h
similarity index 50%
rename from Core/PythonAPI/inc/IsGisaxsAxis.pypp.h
rename to Core/PythonAPI/inc/CustomBinAxis.pypp.h
index d8d6e2818a2a16a082706f0dd7663b57e68250bd..1e7cbbeb299b6cfbb0d3cee678558a9e30f73343 100644
--- a/Core/PythonAPI/inc/IsGisaxsAxis.pypp.h
+++ b/Core/PythonAPI/inc/CustomBinAxis.pypp.h
@@ -3,9 +3,9 @@
// BornAgain: simulate and fit scattering at grazing incidence
//! @brief Automatically generated boost::python code for PythonCoreAPI
-#ifndef IsGisaxsAxis_hpp__pyplusplus_wrapper
-#define IsGisaxsAxis_hpp__pyplusplus_wrapper
+#ifndef CustomBinAxis_hpp__pyplusplus_wrapper
+#define CustomBinAxis_hpp__pyplusplus_wrapper
-void register_IsGisaxsAxis_class();
+void register_CustomBinAxis_class();
-#endif//IsGisaxsAxis_hpp__pyplusplus_wrapper
+#endif//CustomBinAxis_hpp__pyplusplus_wrapper
diff --git a/Core/PythonAPI/inc/PythonCoreList.h b/Core/PythonAPI/inc/PythonCoreList.h
index fc3c1ddbae6795504a100c3b5d0f519c54641d52..cf4a2451b00302c6f3f734a7ebaa2df91c247077 100644
--- a/Core/PythonAPI/inc/PythonCoreList.h
+++ b/Core/PythonAPI/inc/PythonCoreList.h
@@ -4,13 +4,10 @@
//! list of files to process with Py++
#include "IAxis.h"
-#include "AxisBin.h"
-#include "AxisDouble.h"
#include "FixedBinAxis.h"
#include "VariableBinAxis.h"
-#include "AngleBinAxis.h"
#include "ConstKBinAxis.h"
-#include "IsGisaxsAxis.h"
+#include "CustomBinAxis.h"
#include "BasicVector3D.h"
#include "BAVersion.h"
#include "Bin.h"
diff --git a/Core/PythonAPI/src/IsGisaxsAxis.pypp.cpp b/Core/PythonAPI/src/CustomBinAxis.pypp.cpp
similarity index 57%
rename from Core/PythonAPI/src/IsGisaxsAxis.pypp.cpp
rename to Core/PythonAPI/src/CustomBinAxis.pypp.cpp
index a3b23143662277db1e4892a4ba0d26a26027fc5f..eea2c49359495b198170c27bba1cf8739359ccba 100644
--- a/Core/PythonAPI/src/IsGisaxsAxis.pypp.cpp
+++ b/Core/PythonAPI/src/CustomBinAxis.pypp.cpp
@@ -10,60 +10,60 @@ GCC_DIAG_OFF(missing-field-initializers)
GCC_DIAG_ON(unused-parameter)
GCC_DIAG_ON(missing-field-initializers)
#include "PythonCoreList.h"
-#include "IsGisaxsAxis.pypp.h"
+#include "CustomBinAxis.pypp.h"
namespace bp = boost::python;
-struct IsGisaxsAxis_wrapper : IsGisaxsAxis, bp::wrapper< IsGisaxsAxis > {
+struct CustomBinAxis_wrapper : CustomBinAxis, bp::wrapper< CustomBinAxis > {
- IsGisaxsAxis_wrapper(IsGisaxsAxis const & arg )
- : IsGisaxsAxis( arg )
- , bp::wrapper< IsGisaxsAxis >(){
+ CustomBinAxis_wrapper(CustomBinAxis const & arg )
+ : CustomBinAxis( arg )
+ , bp::wrapper< CustomBinAxis >(){
// copy constructor
}
- IsGisaxsAxis_wrapper(::std::string name, ::std::size_t nbins, double start, double end )
- : IsGisaxsAxis( name, nbins, start, end )
- , bp::wrapper< IsGisaxsAxis >(){
+ CustomBinAxis_wrapper(::std::string name, ::std::size_t nbins, double start, double end )
+ : CustomBinAxis( name, nbins, start, end )
+ , bp::wrapper< CustomBinAxis >(){
// constructor
}
- virtual ::IsGisaxsAxis * clone( ) const {
+ virtual ::CustomBinAxis * clone( ) const {
if( bp::override func_clone = this->get_override( "clone" ) )
return func_clone( );
else
- return this->IsGisaxsAxis::clone( );
+ return this->CustomBinAxis::clone( );
}
- ::IsGisaxsAxis * default_clone( ) const {
- return IsGisaxsAxis::clone( );
+ ::CustomBinAxis * default_clone( ) const {
+ return CustomBinAxis::clone( );
}
virtual ::Bin1D getBin( ::std::size_t index ) const {
if( bp::override func_getBin = this->get_override( "getBin" ) )
return func_getBin( index );
else
- return this->IsGisaxsAxis::getBin( index );
+ return this->CustomBinAxis::getBin( index );
}
::Bin1D default_getBin( ::std::size_t index ) const {
- return IsGisaxsAxis::getBin( index );
+ return CustomBinAxis::getBin( index );
}
virtual ::std::vector< double > getBinCenters( ) const {
if( bp::override func_getBinCenters = this->get_override( "getBinCenters" ) )
return func_getBinCenters( );
else
- return this->IsGisaxsAxis::getBinCenters( );
+ return this->CustomBinAxis::getBinCenters( );
}
::std::vector< double > default_getBinCenters( ) const {
- return IsGisaxsAxis::getBinCenters( );
+ return CustomBinAxis::getBinCenters( );
}
virtual ::IAxis * createDoubleBinSize( ) const {
@@ -140,113 +140,113 @@ struct IsGisaxsAxis_wrapper : IsGisaxsAxis, bp::wrapper< IsGisaxsAxis > {
};
-void register_IsGisaxsAxis_class(){
+void register_CustomBinAxis_class(){
- { //::IsGisaxsAxis
- typedef bp::class_< IsGisaxsAxis_wrapper, bp::bases< VariableBinAxis > > IsGisaxsAxis_exposer_t;
- IsGisaxsAxis_exposer_t IsGisaxsAxis_exposer = IsGisaxsAxis_exposer_t( "IsGisaxsAxis", bp::init< std::string, std::size_t, double, double >(( bp::arg("name"), bp::arg("nbins"), bp::arg("start"), bp::arg("end") )) );
- bp::scope IsGisaxsAxis_scope( IsGisaxsAxis_exposer );
- { //::IsGisaxsAxis::clone
+ { //::CustomBinAxis
+ typedef bp::class_< CustomBinAxis_wrapper, bp::bases< VariableBinAxis > > CustomBinAxis_exposer_t;
+ CustomBinAxis_exposer_t CustomBinAxis_exposer = CustomBinAxis_exposer_t( "CustomBinAxis", bp::init< std::string, std::size_t, double, double >(( bp::arg("name"), bp::arg("nbins"), bp::arg("start"), bp::arg("end") )) );
+ bp::scope CustomBinAxis_scope( CustomBinAxis_exposer );
+ { //::CustomBinAxis::clone
- typedef ::IsGisaxsAxis * ( ::IsGisaxsAxis::*clone_function_type )( ) const;
- typedef ::IsGisaxsAxis * ( IsGisaxsAxis_wrapper::*default_clone_function_type )( ) const;
+ typedef ::CustomBinAxis * ( ::CustomBinAxis::*clone_function_type )( ) const;
+ typedef ::CustomBinAxis * ( CustomBinAxis_wrapper::*default_clone_function_type )( ) const;
- IsGisaxsAxis_exposer.def(
+ CustomBinAxis_exposer.def(
"clone"
- , clone_function_type(&::IsGisaxsAxis::clone)
- , default_clone_function_type(&IsGisaxsAxis_wrapper::default_clone)
+ , clone_function_type(&::CustomBinAxis::clone)
+ , default_clone_function_type(&CustomBinAxis_wrapper::default_clone)
, bp::return_value_policy< bp::manage_new_object >() );
}
- { //::IsGisaxsAxis::getBin
+ { //::CustomBinAxis::getBin
- typedef ::Bin1D ( ::IsGisaxsAxis::*getBin_function_type )( ::std::size_t ) const;
- typedef ::Bin1D ( IsGisaxsAxis_wrapper::*default_getBin_function_type )( ::std::size_t ) const;
+ typedef ::Bin1D ( ::CustomBinAxis::*getBin_function_type )( ::std::size_t ) const;
+ typedef ::Bin1D ( CustomBinAxis_wrapper::*default_getBin_function_type )( ::std::size_t ) const;
- IsGisaxsAxis_exposer.def(
+ CustomBinAxis_exposer.def(
"getBin"
- , getBin_function_type(&::IsGisaxsAxis::getBin)
- , default_getBin_function_type(&IsGisaxsAxis_wrapper::default_getBin)
+ , getBin_function_type(&::CustomBinAxis::getBin)
+ , default_getBin_function_type(&CustomBinAxis_wrapper::default_getBin)
, ( bp::arg("index") ) );
}
- { //::IsGisaxsAxis::getBinCenters
+ { //::CustomBinAxis::getBinCenters
- typedef ::std::vector< double > ( ::IsGisaxsAxis::*getBinCenters_function_type )( ) const;
- typedef ::std::vector< double > ( IsGisaxsAxis_wrapper::*default_getBinCenters_function_type )( ) const;
+ typedef ::std::vector< double > ( ::CustomBinAxis::*getBinCenters_function_type )( ) const;
+ typedef ::std::vector< double > ( CustomBinAxis_wrapper::*default_getBinCenters_function_type )( ) const;
- IsGisaxsAxis_exposer.def(
+ CustomBinAxis_exposer.def(
"getBinCenters"
- , getBinCenters_function_type(&::IsGisaxsAxis::getBinCenters)
- , default_getBinCenters_function_type(&IsGisaxsAxis_wrapper::default_getBinCenters) );
+ , getBinCenters_function_type(&::CustomBinAxis::getBinCenters)
+ , default_getBinCenters_function_type(&CustomBinAxis_wrapper::default_getBinCenters) );
}
{ //::IAxis::createDoubleBinSize
typedef ::IAxis * ( ::IAxis::*createDoubleBinSize_function_type )( ) const;
- typedef ::IAxis * ( IsGisaxsAxis_wrapper::*default_createDoubleBinSize_function_type )( ) const;
+ typedef ::IAxis * ( CustomBinAxis_wrapper::*default_createDoubleBinSize_function_type )( ) const;
- IsGisaxsAxis_exposer.def(
+ CustomBinAxis_exposer.def(
"createDoubleBinSize"
, createDoubleBinSize_function_type(&::IAxis::createDoubleBinSize)
- , default_createDoubleBinSize_function_type(&IsGisaxsAxis_wrapper::default_createDoubleBinSize)
+ , default_createDoubleBinSize_function_type(&CustomBinAxis_wrapper::default_createDoubleBinSize)
, bp::return_value_policy< bp::manage_new_object >() );
}
{ //::VariableBinAxis::findClosestIndex
typedef ::std::size_t ( ::VariableBinAxis::*findClosestIndex_function_type )( double ) const;
- typedef ::std::size_t ( IsGisaxsAxis_wrapper::*default_findClosestIndex_function_type )( double ) const;
+ typedef ::std::size_t ( CustomBinAxis_wrapper::*default_findClosestIndex_function_type )( double ) const;
- IsGisaxsAxis_exposer.def(
+ CustomBinAxis_exposer.def(
"findClosestIndex"
, findClosestIndex_function_type(&::VariableBinAxis::findClosestIndex)
- , default_findClosestIndex_function_type(&IsGisaxsAxis_wrapper::default_findClosestIndex)
+ , default_findClosestIndex_function_type(&CustomBinAxis_wrapper::default_findClosestIndex)
, ( bp::arg("value") ) );
}
{ //::VariableBinAxis::getBinBoundaries
typedef ::std::vector< double > ( ::VariableBinAxis::*getBinBoundaries_function_type )( ) const;
- typedef ::std::vector< double > ( IsGisaxsAxis_wrapper::*default_getBinBoundaries_function_type )( ) const;
+ typedef ::std::vector< double > ( CustomBinAxis_wrapper::*default_getBinBoundaries_function_type )( ) const;
- IsGisaxsAxis_exposer.def(
+ CustomBinAxis_exposer.def(
"getBinBoundaries"
, getBinBoundaries_function_type(&::VariableBinAxis::getBinBoundaries)
- , default_getBinBoundaries_function_type(&IsGisaxsAxis_wrapper::default_getBinBoundaries) );
+ , default_getBinBoundaries_function_type(&CustomBinAxis_wrapper::default_getBinBoundaries) );
}
{ //::VariableBinAxis::getMax
typedef double ( ::VariableBinAxis::*getMax_function_type )( ) const;
- typedef double ( IsGisaxsAxis_wrapper::*default_getMax_function_type )( ) const;
+ typedef double ( CustomBinAxis_wrapper::*default_getMax_function_type )( ) const;
- IsGisaxsAxis_exposer.def(
+ CustomBinAxis_exposer.def(
"getMax"
, getMax_function_type(&::VariableBinAxis::getMax)
- , default_getMax_function_type(&IsGisaxsAxis_wrapper::default_getMax) );
+ , default_getMax_function_type(&CustomBinAxis_wrapper::default_getMax) );
}
{ //::VariableBinAxis::getMin
typedef double ( ::VariableBinAxis::*getMin_function_type )( ) const;
- typedef double ( IsGisaxsAxis_wrapper::*default_getMin_function_type )( ) const;
+ typedef double ( CustomBinAxis_wrapper::*default_getMin_function_type )( ) const;
- IsGisaxsAxis_exposer.def(
+ CustomBinAxis_exposer.def(
"getMin"
, getMin_function_type(&::VariableBinAxis::getMin)
- , default_getMin_function_type(&IsGisaxsAxis_wrapper::default_getMin) );
+ , default_getMin_function_type(&CustomBinAxis_wrapper::default_getMin) );
}
{ //::VariableBinAxis::getSize
typedef ::std::size_t ( ::VariableBinAxis::*getSize_function_type )( ) const;
- typedef ::std::size_t ( IsGisaxsAxis_wrapper::*default_getSize_function_type )( ) const;
+ typedef ::std::size_t ( CustomBinAxis_wrapper::*default_getSize_function_type )( ) const;
- IsGisaxsAxis_exposer.def(
+ CustomBinAxis_exposer.def(
"getSize"
, getSize_function_type(&::VariableBinAxis::getSize)
- , default_getSize_function_type(&IsGisaxsAxis_wrapper::default_getSize) );
+ , default_getSize_function_type(&CustomBinAxis_wrapper::default_getSize) );
}
}
diff --git a/Core/PythonAPI/src/PythonModule.cpp b/Core/PythonAPI/src/PythonModule.cpp
index 6efef8f44c12774730ddbb3ad4ac94078bd96fc7..643f1cbfa5023dd51fd17fc0e8a75262a2a585be 100644
--- a/Core/PythonAPI/src/PythonModule.cpp
+++ b/Core/PythonAPI/src/PythonModule.cpp
@@ -29,7 +29,6 @@ GCC_DIAG_ON(missing-field-initializers)
#include "HomogeneousMaterial.pypp.h"
#include "FormFactorCone6.pypp.h"
#include "vector_integer_t.pypp.h"
-#include "AxisDouble.pypp.h"
#include "FormFactorInfLongRipple2.pypp.h"
#include "IAxis.pypp.h"
#include "FormFactorTetrahedron.pypp.h"
@@ -44,7 +43,6 @@ GCC_DIAG_ON(missing-field-initializers)
#include "ResolutionFunction2DSimple.pypp.h"
#include "SimulationParameters.pypp.h"
#include "FormFactorSphereUniformRadius.pypp.h"
-#include "AxisBin.pypp.h"
#include "FormFactorGauss.pypp.h"
#include "FormFactorFullSpheroid.pypp.h"
#include "FormFactorAnisoPyramid.pypp.h"
@@ -66,7 +64,6 @@ GCC_DIAG_ON(missing-field-initializers)
#include "DistributionLorentz.pypp.h"
#include "FTDistribution2DCauchy.pypp.h"
#include "FTDistribution2DVoigt.pypp.h"
-#include "AngleBinAxis.pypp.h"
#include "ICompositeSample.pypp.h"
#include "cvector_t.pypp.h"
#include "ParameterPool.pypp.h"
@@ -117,6 +114,7 @@ GCC_DIAG_ON(missing-field-initializers)
#include "FormFactorLorentz.pypp.h"
#include "OutputDataIOFactory.pypp.h"
#include "FTDistribution1DCauchy.pypp.h"
+#include "CustomBinAxis.pypp.h"
#include "vector_kvector_t.pypp.h"
#include "InterferenceFunction1DParaCrystal.pypp.h"
#include "InterferenceFunctionNone.pypp.h"
@@ -125,7 +123,6 @@ GCC_DIAG_ON(missing-field-initializers)
#include "PythonInterface_free_functions.pypp.h"
#include "Lattice1DIFParameters.pypp.h"
#include "FTDistribution1DGauss.pypp.h"
-#include "IsGisaxsAxis.pypp.h"
#include "kvector_t.pypp.h"
#include "FTDistribution1DVoigt.pypp.h"
#include "Simulation.pypp.h"
@@ -151,14 +148,11 @@ BOOST_PYTHON_MODULE(libBornAgainCore){
register_vdouble1d_t_class();
register_vector_IFormFactorPtr_t_class();
register_vector_kvector_t_class();
- register_IAxis_class();
- register_AngleBinAxis_class();
- register_AxisBin_class();
- register_AxisDouble_class();
register_IParameterized_class();
register_Beam_class();
register_Bin1D_class();
register_Bin1DCVector_class();
+ register_IAxis_class();
register_VariableBinAxis_class();
register_ConstKBinAxis_class();
register_ICloneable_class();
@@ -166,6 +160,7 @@ BOOST_PYTHON_MODULE(libBornAgainCore){
register_ICompositeSample_class();
register_IClusteredParticles_class();
register_Crystal_class();
+ register_CustomBinAxis_class();
register_Detector_class();
register_IDistribution1D_class();
register_DistributionCosine_class();
@@ -240,7 +235,6 @@ BOOST_PYTHON_MODULE(libBornAgainCore){
register_InterferenceFunction2DLattice_class();
register_InterferenceFunction2DParaCrystal_class();
register_InterferenceFunctionNone_class();
- register_IsGisaxsAxis_class();
register_Lattice_class();
register_Lattice1DIFParameters_class();
register_Lattice2DIFParameters_class();
diff --git a/Core/Tools/inc/IsGisaxsAxis.h b/Core/Tools/inc/CustomBinAxis.h
similarity index 75%
rename from Core/Tools/inc/IsGisaxsAxis.h
rename to Core/Tools/inc/CustomBinAxis.h
index 2c8ed02a1a22b8db1d3d45cf84ab7f651f9d5155..aa3505e3db125e3e6a9125e848345030433fc522 100644
--- a/Core/Tools/inc/IsGisaxsAxis.h
+++ b/Core/Tools/inc/CustomBinAxis.h
@@ -2,8 +2,8 @@
//
// BornAgain: simulate and fit scattering at grazing incidence
//
-//! @file Tools/inc/IsGisaxsAxis.h
-//! @brief Defines class IsGisaxsAxis.
+//! @file Tools/inc/CustomBinAxis.h
+//! @brief Defines class CustomBinAxis.
//!
//! @homepage http://apps.jcns.fz-juelich.de/BornAgain
//! @license GNU General Public License v3 or higher (see COPYING)
@@ -13,30 +13,30 @@
//
// ************************************************************************** //
-#ifndef ISGISAXSAXIS_H
-#define ISGISAXSAXIS_H
+#ifndef CUSTOMBINAXIS_H
+#define CUSTOMBINAXIS_H
#include "VariableBinAxis.h"
-//! @class IsGisaxsAxis
+//! @class CustomBinAxis
//! @ingroup tools
//! @brief Axis with fixed bin size in sin(angle) space used for numerical
//! comparison with IsGisaxs. The main feature of the axis that it produces
//! zero bins size.
-class BA_CORE_API_ IsGisaxsAxis : public VariableBinAxis
+class BA_CORE_API_ CustomBinAxis : public VariableBinAxis
{
public:
- //! @brief IsGisaxsAxis constructor
+ //! @brief CustomBinAxis constructor
//! @param name Axis name
//! @param nbins number of bins
//! @param start center of first bin (IsGisaxs convention)
//! @param end center of last bin (IsGisaxs convention)
- IsGisaxsAxis(std::string name, size_t nbins, double start, double end);
- virtual ~IsGisaxsAxis() {}
+ CustomBinAxis(std::string name, size_t nbins, double start, double end);
+ virtual ~CustomBinAxis() {}
- IsGisaxsAxis *clone() const;
+ CustomBinAxis *clone() const;
Bin1D getBin(size_t index) const;
diff --git a/Core/Tools/inc/OutputDataIOHelper.h b/Core/Tools/inc/OutputDataIOHelper.h
index 1ade4496b1ccf4ddb5a17bdd674eebb7feda200d..d64f3cd9311cd7381d9d030e0727bc2917066dbd 100644
--- a/Core/Tools/inc/OutputDataIOHelper.h
+++ b/Core/Tools/inc/OutputDataIOHelper.h
@@ -27,7 +27,7 @@ namespace OutputDataIOHelper {
const std::string FixedBinAxisType = "FixedBinAxis";
const std::string VariableBinAxisType = "VariableBinAxis";
const std::string ConstKBinAxisType = "ConstKBinAxis";
-const std::string IsGisaxsAxisType = "IsGisaxsAxis";
+const std::string CustomBinAxisType = "CustomBinAxis";
bool isSimilarToFixedBinAxisType(const std::string &line);
bool isVariableBinAxisType(const std::string &line);
diff --git a/Core/Tools/src/IsGisaxsAxis.cpp b/Core/Tools/src/CustomBinAxis.cpp
similarity index 61%
rename from Core/Tools/src/IsGisaxsAxis.cpp
rename to Core/Tools/src/CustomBinAxis.cpp
index 9e8bc35dc9eb64b4f8b63b32e80e251132b153f0..601b6518e2ff4d6e7e73944a8ae8d3a0f43b6224 100644
--- a/Core/Tools/src/IsGisaxsAxis.cpp
+++ b/Core/Tools/src/CustomBinAxis.cpp
@@ -1,14 +1,14 @@
-#include "IsGisaxsAxis.h"
+#include "CustomBinAxis.h"
#include "Units.h"
#include <iomanip>
-IsGisaxsAxis::IsGisaxsAxis(std::string name, size_t nbins, double start, double end)
+CustomBinAxis::CustomBinAxis(std::string name, size_t nbins, double start, double end)
: VariableBinAxis(name, nbins)
, m_start(start)
, m_end(end)
{
if(m_start >= m_end)
- throw Exceptions::LogicErrorException("IsGisaxsAxis::IsGisaxsAxis() -> Error. start >= end is not allowed.");
+ throw Exceptions::LogicErrorException("CustomBinAxis::CustomBinAxis() -> Error. start >= end is not allowed.");
double start_sin = std::sin(start);
double end_sin = std::sin(end);
@@ -33,36 +33,36 @@ IsGisaxsAxis::IsGisaxsAxis(std::string name, size_t nbins, double start, double
}
-IsGisaxsAxis *IsGisaxsAxis::clone() const
+CustomBinAxis *CustomBinAxis::clone() const
{
- return new IsGisaxsAxis(getName(), m_nbins, m_start, m_end);
+ return new CustomBinAxis(getName(), m_nbins, m_start, m_end);
}
-Bin1D IsGisaxsAxis::getBin(size_t index) const
+Bin1D CustomBinAxis::getBin(size_t index) const
{
if(index >= m_nbins)
- throw Exceptions::OutOfBoundsException("IsGisaxsAxis::getBin() -> Error. Wrong index.");
+ throw Exceptions::OutOfBoundsException("CustomBinAxis::getBin() -> Error. Wrong index.");
Bin1D result = { m_bin_centers[index], m_bin_centers[index] };
return result;
}
-std::vector<double> IsGisaxsAxis::getBinCenters() const
+std::vector<double> CustomBinAxis::getBinCenters() const
{
return m_bin_centers;
}
-void IsGisaxsAxis::print(std::ostream &ostr) const
+void CustomBinAxis::print(std::ostream &ostr) const
{
- ostr << "IsGisaxsAxis(\"" << m_name << "\", " << getSize() << ", " << std::setprecision(std::numeric_limits<double>::digits10+2) << m_start << ", " << m_end << ")";
+ ostr << "CustomBinAxis(\"" << m_name << "\", " << getSize() << ", " << std::setprecision(std::numeric_limits<double>::digits10+2) << m_start << ", " << m_end << ")";
}
-bool IsGisaxsAxis::equals(const IAxis &other) const
+bool CustomBinAxis::equals(const IAxis &other) const
{
if (!IAxis::equals(other)) return false;
- if (const IsGisaxsAxis *otherAxis = dynamic_cast<const IsGisaxsAxis *>(&other)) {
+ if (const CustomBinAxis *otherAxis = dynamic_cast<const CustomBinAxis *>(&other)) {
if (getSize() != otherAxis->getSize()) return false;
if ( std::abs(m_start - otherAxis->m_start) > Numeric::double_epsilon) return false;
if ( std::abs(m_end - otherAxis->m_end) > Numeric::double_epsilon) return false;
diff --git a/Core/Tools/src/OutputDataIOHelper.cpp b/Core/Tools/src/OutputDataIOHelper.cpp
index e00cd9f368a186563de8222b98570b50ca728b07..4008d2cf95955bc35094a6eb4f95888a6f246a5f 100644
--- a/Core/Tools/src/OutputDataIOHelper.cpp
+++ b/Core/Tools/src/OutputDataIOHelper.cpp
@@ -2,7 +2,7 @@
#include "FixedBinAxis.h"
#include "VariableBinAxis.h"
#include "ConstKBinAxis.h"
-#include "IsGisaxsAxis.h"
+#include "CustomBinAxis.h"
#include "Exceptions.h"
#include "Utils.h"
#include "OutputData.h"
@@ -13,13 +13,13 @@
//! Returns true if string representation of the axis contains one of
-//! FixedBinAxis, ConstKBinAxis or IsGisaxsBinAxis to parse it later in
+//! FixedBinAxis, ConstKBinAxis or CustomBinAxis to parse it later in
//! similar way.
bool OutputDataIOHelper::isSimilarToFixedBinAxisType(const std::string &line)
{
if(line.find(FixedBinAxisType) != std::string::npos ||
line.find(ConstKBinAxisType) != std::string::npos ||
- line.find(IsGisaxsAxisType) != std::string::npos)
+ line.find(CustomBinAxisType) != std::string::npos)
{
return true;
}
@@ -61,7 +61,7 @@ IAxis *OutputDataIOHelper::createAxis(std::istream &input_stream)
//! Create one of FixedBinAxis from string representation
//! FixedBinAxis("axis0", 10, -1, 1)
//! ConstKBinAxis("axis0", 10, -1, 1)
-//! IsGisaxsAxis("axis0", 10, -1, 1)
+//! CustomBinAxis("axis0", 10, -1, 1)
IAxis *OutputDataIOHelper::createFixedBinAxis(std::string line)
{
std::vector<std::string> to_replace = boost::assign::list_of(",")("\"")("(")(")");
@@ -89,8 +89,8 @@ IAxis *OutputDataIOHelper::createFixedBinAxis(std::string line)
else if(type == ConstKBinAxisType) {
return new ConstKBinAxis(name, nbins, boundaries[0], boundaries[1]);
}
- else if(type == IsGisaxsAxisType) {
- return new IsGisaxsAxis(name, nbins, boundaries[0], boundaries[1]);
+ else if(type == CustomBinAxisType) {
+ return new CustomBinAxis(name, nbins, boundaries[0], boundaries[1]);
}
else {
throw Exceptions::LogicErrorException("OutputDataIOHelper::createOneOfFixedBinAxis() -> Error. Unexpected place.");
diff --git a/Tests/FunctionalTests/TestPyCore/intensitydata.py b/Tests/FunctionalTests/TestPyCore/intensitydata.py
index 076acc562a896cfd6659171a8c1ab72341dc837b..4b03172613bd50ed500f84dcf4dd19fc57ab6ca3 100644
--- a/Tests/FunctionalTests/TestPyCore/intensitydata.py
+++ b/Tests/FunctionalTests/TestPyCore/intensitydata.py
@@ -30,7 +30,7 @@ class IntensityDataTest(unittest.TestCase):
self.assertEqual(0, data.totalSum())
def test_create_1d_object(self):
- axis0 = AxisDouble("angle", 20, 0.0, 20.)
+ axis0 = FixedBinAxis("angle", 20, 0.0, 20.)
self.assertEqual(20, axis0.getSize())
self.assertEqual(0.0, axis0.getMin())
self.assertEqual(20.0, axis0.getMax())
diff --git a/Tests/FunctionalTests/TestPyCore/intensitydata_io.py b/Tests/FunctionalTests/TestPyCore/intensitydata_io.py
index 2d20ede67ec2828fb3fe0eb9300ee73a86e85c7b..489284bbf6f04206fa97a9922905592e3d5a4246 100644
--- a/Tests/FunctionalTests/TestPyCore/intensitydata_io.py
+++ b/Tests/FunctionalTests/TestPyCore/intensitydata_io.py
@@ -121,10 +121,10 @@ class OutputDataIOTest(unittest.TestCase):
newdata = OutputDataIOFactory.readIntensityData("tmp.baint")
self.assertTrue(is_the_same_data(data, newdata))
- def test_08_IsGisaxsAxis_2D(self):
+ def test_08_CustomBinAxis_2D(self):
data = IntensityData()
- data.addAxis(IsGisaxsAxis("axis0", 9, -1.00000001*degree, 1.0*degree))
- data.addAxis(IsGisaxsAxis("axis1", 3, -4.0*degree, 5.0*degree))
+ data.addAxis(CustomBinAxis("axis0", 9, -1.00000001*degree, 1.0*degree))
+ data.addAxis(CustomBinAxis("axis1", 3, -4.0*degree, 5.0*degree))
fill_data(data)
OutputDataIOFactory.writeIntensityData(data, "tmp.baint")
newdata = OutputDataIOFactory.readIntensityData("tmp.baint")
diff --git a/Tests/UnitTests/TestCore/CustomBinAxisTest.h b/Tests/UnitTests/TestCore/CustomBinAxisTest.h
new file mode 100644
index 0000000000000000000000000000000000000000..3be891535b33abb27cbf66eb357281821dc78c24
--- /dev/null
+++ b/Tests/UnitTests/TestCore/CustomBinAxisTest.h
@@ -0,0 +1,38 @@
+#ifndef CUSTOMBINAXISTEST_H
+#define CUSTOMBINAXISTEST_H
+
+#include "CustomBinAxis.h"
+#include "OutputDataIOHelper.h"
+#include "Units.h"
+#include "gtest/gtest.h"
+#include <vector>
+
+class CusomBinAxisTest: public ::testing::Test
+{
+protected:
+ CusomBinAxisTest()
+ : m_axis("name", 100, -1.0, 1.0){}
+ CustomBinAxis m_axis;
+};
+
+
+TEST_F(CusomBinAxisTest, CheckClone)
+{
+ CustomBinAxis *clone=m_axis.clone();
+ EXPECT_TRUE(m_axis == *clone);
+ delete clone;
+}
+
+TEST_F(CusomBinAxisTest, IOStream)
+{
+
+ std::ostringstream oss;
+ oss << m_axis;
+
+ CustomBinAxis *result = dynamic_cast<CustomBinAxis *>(OutputDataIOHelper::createFixedBinAxis(oss.str()));
+ EXPECT_TRUE(m_axis == *result);
+ delete result;
+}
+
+
+#endif
diff --git a/Tests/UnitTests/TestCore/IsGisaxsAxisTest.h b/Tests/UnitTests/TestCore/IsGisaxsAxisTest.h
deleted file mode 100644
index 029c46ea2ed014efebd7b4aec4b7ee567888e6cf..0000000000000000000000000000000000000000
--- a/Tests/UnitTests/TestCore/IsGisaxsAxisTest.h
+++ /dev/null
@@ -1,56 +0,0 @@
-#ifndef ISGISAXSAXISTEST_H
-#define ISGISAXSAXISTEST_H
-
-#include "IsGisaxsAxis.h"
-#include "OutputDataIOHelper.h"
-#include "Units.h"
-#include "gtest/gtest.h"
-#include <vector>
-
-class IsGisaxsAxisTest: public ::testing::Test
-{
-protected:
- IsGisaxsAxisTest()
- : m_axis("name", 100, -1.0, 1.0){}
- IsGisaxsAxis m_axis;
-};
-
-
-//TEST_F(IsGisaxsAxisTest, TypicalAxis)
-//{
-// EXPECT_EQ(m_nbins, m_axis.getSize());
-// EXPECT_EQ(m_start, m_axis.getMin());
-// EXPECT_EQ(m_end, m_axis.getMax());
-
-// for(size_t i=0; i<m_axis.getSize(); ++i) {
-// EXPECT_DOUBLE_EQ( m_centers[i], m_axis[i]);
-// }
-
-// for(size_t i=0; i<m_axis.getSize(); ++i) {
-// EXPECT_DOUBLE_EQ( m_boundaries[i], m_axis.getBin(i).m_lower);
-// EXPECT_DOUBLE_EQ( m_boundaries[i+1], m_axis.getBin(i).m_upper);
-// }
-//}
-
-
-TEST_F(IsGisaxsAxisTest, CheckClone)
-{
- IsGisaxsAxis *clone=m_axis.clone();
- EXPECT_TRUE(m_axis == *clone);
- delete clone;
-}
-
-
-TEST_F(IsGisaxsAxisTest, IOStream)
-{
-
- std::ostringstream oss;
- oss << m_axis;
-
- IsGisaxsAxis *result = dynamic_cast<IsGisaxsAxis *>(OutputDataIOHelper::createFixedBinAxis(oss.str()));
- EXPECT_TRUE(m_axis == *result);
- delete result;
-}
-
-
-#endif
diff --git a/Tests/UnitTests/TestCore/main.cpp b/Tests/UnitTests/TestCore/main.cpp
index d344444a6c38b703ee9a441a986cc46301cff07f..3dc97d2ce8c655fd1a3b4f99cdd90e1715dd3cde 100644
--- a/Tests/UnitTests/TestCore/main.cpp
+++ b/Tests/UnitTests/TestCore/main.cpp
@@ -40,10 +40,8 @@
#include "MathFunctionsTest.h"
#include "FixedBinAxisTest.h"
#include "VariableBinAxisTest.h"
-#include "AsymmetricBinAxisTest.h"
-#include "AngleBinAxisTest.h"
#include "ConstKBinAxisTest.h"
-#include "IsGisaxsAxisTest.h"
+#include "CustomBinAxisTest.h"
struct ErrorStreamRedirect {
ErrorStreamRedirect( std::streambuf * new_buffer )
diff --git a/dev-tools/python-bindings/settings_core.py b/dev-tools/python-bindings/settings_core.py
index 4b4e1d336e20ba677935611781b9a5fc9f048adf..a345736b609466adfbb91b4e8e58e2767b458532 100644
--- a/dev-tools/python-bindings/settings_core.py
+++ b/dev-tools/python-bindings/settings_core.py
@@ -37,13 +37,10 @@ include_dirs = [
]
include_classes = [
- "AxisDouble",
- "AxisBin",
"FixedBinAxis",
"VariableBinAxis",
- "AngleBinAxis",
"ConstKBinAxis",
- "IsGisaxsAxis",
+ "CustomBinAxis",
"BasicVector3D<double>",
"BasicVector3D<std::complex<double> >",
"Beam",