ScanResolution w/o 'Single'

Sim/Scan/ScanResolution.cpp

@@ -24,21 +24,21 @@ const std::string relative_resolution = "scanRelativeResolution";
 const std::string absolute_resolution = "scanAbsoluteResolution";
 
 //  ************************************************************************************************
-//  ScanSingleRelativeResolution
+//  ScanRelativeResolution
 //  ************************************************************************************************
 
-class ScanSingleRelativeResolution : public IScanResolution {
+class ScanRelativeResolution : public IScanResolution {
 public:
-    ScanSingleRelativeResolution(const IRangedDistribution& distr, double reldev)
+    ScanRelativeResolution(const IRangedDistribution& distr, double reldev)
         : IScanResolution(distr)
         , m_reldev(reldev)
     {
     }
-    ~ScanSingleRelativeResolution() override = default;
+    ~ScanRelativeResolution() override = default;
 
     IScanResolution* clone() const override
     {
-        return new ScanSingleRelativeResolution(*rdistribution(), m_reldev);
+        return new ScanRelativeResolution(*rdistribution(), m_reldev);
     }
 
     DistrOutput generateResolutionSamples(const std::vector<double>& mean) const override;
@@ -55,7 +55,7 @@ private:
 };
 
 IScanResolution::DistrOutput
-ScanSingleRelativeResolution::generateResolutionSamples(const std::vector<double>& mean) const
+ScanRelativeResolution::generateResolutionSamples(const std::vector<double>& mean) const
 {
     ASSERT(!mean.empty());
     DistrOutput result;
@@ -65,12 +65,12 @@ ScanSingleRelativeResolution::generateResolutionSamples(const std::vector<double
     return result;
 }
 
-std::vector<double> ScanSingleRelativeResolution::stdDevs(double mean, size_t n_times) const
+std::vector<double> ScanRelativeResolution::stdDevs(double mean, size_t n_times) const
 {
     return std::vector<double>(n_times, mean * m_reldev);
 }
 
-std::vector<double> ScanSingleRelativeResolution::stdDevs(const std::vector<double>& mean) const
+std::vector<double> ScanRelativeResolution::stdDevs(const std::vector<double>& mean) const
 {
     ASSERT(!mean.empty());
     std::vector<double> result;
@@ -81,21 +81,21 @@ std::vector<double> ScanSingleRelativeResolution::stdDevs(const std::vector<doub
 }
 
 //  ************************************************************************************************
-//  ScanSingleAbsoluteResolution
+//  ScanAbsoluteResolution
 //  ************************************************************************************************
 
-class ScanSingleAbsoluteResolution : public IScanResolution {
+class ScanAbsoluteResolution : public IScanResolution {
 public:
-    ScanSingleAbsoluteResolution(const IRangedDistribution& distr, double stddev)
+    ScanAbsoluteResolution(const IRangedDistribution& distr, double stddev)
         : IScanResolution(distr)
         , m_stddev(stddev)
     {
     }
-    ~ScanSingleAbsoluteResolution() override = default;
+    ~ScanAbsoluteResolution() override = default;
 
     IScanResolution* clone() const override
     {
-        return new ScanSingleAbsoluteResolution(*rdistribution(), m_stddev);
+        return new ScanAbsoluteResolution(*rdistribution(), m_stddev);
     }
 
     DistrOutput generateResolutionSamples(const std::vector<double>& mean) const override;
@@ -112,7 +112,7 @@ private:
 };
 
 IScanResolution::DistrOutput
-ScanSingleAbsoluteResolution::generateResolutionSamples(const std::vector<double>& mean) const
+ScanAbsoluteResolution::generateResolutionSamples(const std::vector<double>& mean) const
 {
     ASSERT(!mean.empty());
     DistrOutput result;
@@ -122,19 +122,19 @@ ScanSingleAbsoluteResolution::generateResolutionSamples(const std::vector<double
     return result;
 }
 
-std::vector<double> ScanSingleAbsoluteResolution::stdDevs(double, size_t n_times) const
+std::vector<double> ScanAbsoluteResolution::stdDevs(double, size_t n_times) const
 {
     return std::vector<double>(n_times, m_stddev);
 }
 
-std::vector<double> ScanSingleAbsoluteResolution::stdDevs(const std::vector<double>& mean) const
+std::vector<double> ScanAbsoluteResolution::stdDevs(const std::vector<double>& mean) const
 {
     ASSERT(!mean.empty());
     return std::vector<double>(mean.size(), m_stddev);
 }
 
 //  ************************************************************************************************
-//  ScanSingleVectorResolution
+//  ScanVectorResolution
 //  ************************************************************************************************
 
 class ScanVectorResolution : public IScanResolution {
@@ -265,12 +265,12 @@ IScanResolution::DistrOutput IScanResolution::generateResolutionSamples(double m
 
 IScanResolution* scanRelativeResolution(const IRangedDistribution& distr, double stddev)
 {
-    return new ScanSingleRelativeResolution(distr, stddev);
+    return new ScanRelativeResolution(distr, stddev);
 }
 
 IScanResolution* scanAbsoluteResolution(const IRangedDistribution& distr, double stddev)
 {
-    return new ScanSingleAbsoluteResolution(distr, stddev);
+    return new ScanAbsoluteResolution(distr, stddev);
 }
 
 IScanResolution* scanVectorResolution(const IRangedDistribution& distr,