merge ScanAbsoluteResolution into IScanResolution

Sim/Scan/ScanResolution.cpp

@@ -17,63 +17,35 @@
 #include "Param/Distrib/ParameterSample.h"
 #include "Param/Distrib/RangedDistributions.h"
 
-namespace {
-
-//  ************************************************************************************************
-//  ScanAbsoluteResolution
-//  ************************************************************************************************
-
-class ScanAbsoluteResolution : public IScanResolution {
-public:
-    ScanAbsoluteResolution(const IRangedDistribution& distr, double stddev)
-        : IScanResolution(distr)
-        , m_stddev(stddev)
-    {
-    }
-    ~ScanAbsoluteResolution() override = default;
-
-    IScanResolution* clone() const override
-    {
-        return new ScanAbsoluteResolution(*rdistribution(), m_stddev);
-    }
-
-    std::vector<ParameterSample> resolutionSamples(double mean) const override;
-    std::vector<double> stdDevs(double mean, size_t n_times) const override;
-    std::vector<double> stdDevs(const std::vector<double>& mean) const override;
-
-    double delta() const override { return m_stddev; }
+IScanResolution::IScanResolution(const IRangedDistribution& distr, double stddev)
+    : m_distr(distr.clone())
+    , m_stddev(stddev)
+{
+}
 
-protected:
-    std::string resolutionFactoryName() const override { return "scanAbsoluteResolution"; }
+IScanResolution::~IScanResolution() = default;
 
-private:
-    double m_stddev; //!< deltas for computing resolutions
-};
+IScanResolution* IScanResolution::clone() const
+{
+    return new IScanResolution(*rdistribution(), m_stddev);
+}
 
-std::vector<ParameterSample> ScanAbsoluteResolution::resolutionSamples(double mean) const
+std::vector<ParameterSample> IScanResolution::resolutionSamples(double mean) const
 {
     return rdistribution()->generateSamples(mean, m_stddev);
 }
 
-std::vector<double> ScanAbsoluteResolution::stdDevs(double, size_t n_times) const
+std::vector<double> IScanResolution::stdDevs(double, size_t n_times) const
 {
     return std::vector<double>(n_times, m_stddev);
 }
 
-std::vector<double> ScanAbsoluteResolution::stdDevs(const std::vector<double>& mean) const
+std::vector<double> IScanResolution::stdDevs(const std::vector<double>& mean) const
 {
     ASSERT(!mean.empty());
     return std::vector<double>(mean.size(), m_stddev);
 }
 
-} // namespace
-
-//  ************************************************************************************************
-//  IScanResolution
-//  ************************************************************************************************
-
-IScanResolution::~IScanResolution() = default;
-
 size_t IScanResolution::nSamples() const
 {
     if (m_distr)
@@ -81,18 +53,11 @@ size_t IScanResolution::nSamples() const
     return 1;
 }
 
-IScanResolution::IScanResolution() = default;
-
-IScanResolution::IScanResolution(const IRangedDistribution& distr)
-    : m_distr(distr.clone())
-{
-}
-
 //  ************************************************************************************************
 //  Factory functions
 //  ************************************************************************************************
 
 IScanResolution* scanAbsoluteResolution(const IRangedDistribution& distr, double stddev)
 {
-    return new ScanAbsoluteResolution(distr, stddev);
+    return new IScanResolution(distr, stddev);
 }

Sim/Scan/ScanResolution.h

@@ -27,37 +27,40 @@ class ParameterSample;
 //! Child classes have local scope only (declared and implemented in ScanResolution.cpp);
 //! they can only be created through the factory functions declared below.
 class IScanResolution : public ICloneable {
-protected:
-    using DistrOutput = std::vector<std::vector<ParameterSample>>;
-
 public:
+    IScanResolution(const IRangedDistribution& distr, double stddev);
     ~IScanResolution() override;
+
 #ifndef SWIG
-    IScanResolution* clone() const override = 0;
+    IScanResolution* clone() const override;
     const IRangedDistribution* rdistribution() const
     {
         return m_distr.get();
     }
     size_t nSamples() const;
 
-    virtual std::vector<ParameterSample> resolutionSamples(double mean) const = 0;
+    std::vector<ParameterSample> resolutionSamples(double mean) const;
 
-    virtual std::vector<double> stdDevs(double mean, size_t n_times) const = 0;
-    virtual std::vector<double> stdDevs(const std::vector<double>& mean) const = 0;
+    std::vector<double> stdDevs(double mean, size_t n_times) const;
+    std::vector<double> stdDevs(const std::vector<double>& mean) const;
 
     //... For export:
-    virtual std::string resolutionFactoryName() const = 0;
-    virtual double delta() const = 0;
+    std::string resolutionFactoryName() const
+    {
+        return "scanAbsoluteResolution";
+    }
+    double delta() const
+    {
+        return m_stddev;
+    }
 
 protected:
-    IScanResolution();
-    IScanResolution(const IRangedDistribution& distr);
-
-private:
     std::unique_ptr<IRangedDistribution> m_distr; //!< basic distribution function
+    double m_stddev;                              //!< deltas for computing resolutions
 #endif                                            // SWIG
 };
 
+
 IScanResolution* scanAbsoluteResolution(const IRangedDistribution& distr, double stddev);
 
 #endif // BORNAGAIN_SIM_SCAN_SCANRESOLUTION_H