diff --git a/Sim/Scan/AlphaScan.cpp b/Sim/Scan/AlphaScan.cpp
index 2e9e76bc54ffaa0d829295b84c3299a6e3b8d973..c80226783445aee82423216f26323e23b9ee8e78 100644
--- a/Sim/Scan/AlphaScan.cpp
+++ b/Sim/Scan/AlphaScan.cpp
@@ -110,44 +110,6 @@ void AlphaScan::setAbsoluteAngularResolution(const IRangedDistribution& distr, d
     setAngleResolution(*resolution);
 }
 
-std::vector<double> AlphaScan::footprint(size_t start, size_t n_elements) const
-{
-    if (start + n_elements > nSteps())
-        throw std::runtime_error("Error in AlphaScan::footprint: given index exceeds the "
-                                 "number of simulation elements");
-
-    std::vector<double> result(n_elements, 1.0);
-    if (!m_footprint)
-        return result;
-
-    const size_t n_wl_samples = m_lambda_distrib->nSamples();
-    const size_t n_inc_samples = m_alpha_distrib->nSamples();
-
-    const DistrOutput alphaDistrib =
-        m_alpha_distrib->generateResolutionSamples(m_alpha_axis->binCenters());
-
-    const size_t pos_out = start / (n_wl_samples * n_inc_samples);
-    size_t pos_inc = (start - pos_out * n_wl_samples * n_inc_samples) / n_wl_samples;
-    size_t pos_wl = (start - pos_inc * n_wl_samples);
-    int left = static_cast<int>(n_elements);
-    size_t pos_res = 0;
-    for (size_t i = pos_out; left > 0; ++i) {
-        for (size_t k = pos_inc; k < n_inc_samples && left > 0; ++k) {
-            pos_inc = 0;
-            const double angle = alphaDistrib[i][k].value;
-            const double footprint =
-                (angle >= 0 && angle <= M_PI_2) ? m_footprint->calculate(angle) : 1.0;
-            for (size_t j = pos_wl; j < n_wl_samples && left > 0; ++j) {
-                pos_wl = 0;
-                result[pos_res] = footprint;
-                ++pos_res;
-                --left;
-            }
-        }
-    }
-    return result;
-}
-
 size_t AlphaScan::nSteps() const
 {
     return m_alpha_axis->size() * m_lambda_distrib->nSamples() * m_alpha_distrib->nSamples();
diff --git a/Sim/Scan/AlphaScan.h b/Sim/Scan/AlphaScan.h
index 4e6f7506db18096d0b95f21668bc247e7db2ee9a..9edac60e9127cdf93a629e0fc1e077c3c3dc661b 100644
--- a/Sim/Scan/AlphaScan.h
+++ b/Sim/Scan/AlphaScan.h
@@ -19,7 +19,6 @@
 #include <memory>
 
 class ParameterSample;
-class IFootprintFactor;
 class IRangedDistribution;
 class IScanResolution;
 
@@ -66,10 +65,6 @@ public:
         return m_footprint.get();
     }
 
-    //! Returns footprint correction factor for a range of simulation elements of size _n_elements_
-    //! and starting from element with index _i_.
-    std::vector<double> footprint(size_t start, size_t n_elements) const override;
-
     //! Returns the number of simulation elements
     size_t nSteps() const override;
 
diff --git a/Sim/Scan/ISpecularScan.h b/Sim/Scan/ISpecularScan.h
index 8d37f0820c4b11166f3a53fcde8987be823d51a0..4acbd6b85cf46419c21dda8147c4b913619c0464 100644
--- a/Sim/Scan/ISpecularScan.h
+++ b/Sim/Scan/ISpecularScan.h
@@ -57,19 +57,17 @@ public:
     SpinMatrix polarizerMatrix() const;
     SpinMatrix analyzerMatrix() const;
 
+    virtual const IFootprintFactor* footprintFactor() const
+    {
+        return nullptr;
+    }
+
     //! Generates simulation elements for specular simulations
     virtual std::vector<SpecularElement> generateElements() const = 0;
 
     //! Returns coordinate axis assigned to the data holder
     virtual const IAxis* coordinateAxis() const = 0;
 
-    //! Returns IFootprintFactor object pointer
-    virtual const IFootprintFactor* footprintFactor() const = 0;
-
-    //! Returns footprint correction factor for a range of simulation elements of size _n_elements_
-    //! and starting from element with index _i_.
-    virtual std::vector<double> footprint(size_t i, size_t n_elements) const = 0;
-
     //! Returns the number of simulation elements
     virtual size_t nSteps() const = 0;
 
diff --git a/Sim/Scan/QzScan.cpp b/Sim/Scan/QzScan.cpp
index 6bba289d0470ab47e07ff957b1a83122a96074d3..7e6ed2829098f4ae3184c4d204a5eeedf7b03181 100644
--- a/Sim/Scan/QzScan.cpp
+++ b/Sim/Scan/QzScan.cpp
@@ -89,13 +89,6 @@ std::vector<SpecularElement> QzScan::generateElements() const
     return result;
 }
 
-std::vector<double> QzScan::footprint(size_t i, size_t n_elements) const
-{
-    ASSERT(i + n_elements <= nSteps());
-    // There is no way to set a footprint correction for q scans.
-    return std::vector<double>(n_elements, 1.0);
-}
-
 //! Returns the number of simulation elements
 size_t QzScan::nSteps() const
 {
diff --git a/Sim/Scan/QzScan.h b/Sim/Scan/QzScan.h
index d093789586d5322651e7fe91b1dc78de500cdefd..62e73b24cabe118ce9b5ecd7b5ddc7b2b42ae038 100644
--- a/Sim/Scan/QzScan.h
+++ b/Sim/Scan/QzScan.h
@@ -70,16 +70,6 @@ public:
         return m_qs.get();
     }
 
-    //! Returns IFootprintFactor object pointer
-    const IFootprintFactor* footprintFactor() const override
-    {
-        return nullptr;
-    }
-
-    //! Returns footprint correction factor for a range of simulation elements of size _n_elements_
-    //! and starting from element with index _i_.
-    std::vector<double> footprint(size_t i, size_t n_elements) const override;
-
     //! Returns the number of simulation elements
     size_t nSteps() const override;
 
diff --git a/Sim/Simulation/ISimulation.h b/Sim/Simulation/ISimulation.h
index 936cfffbdc7552f344d992cfcad79d6e47831519..5e5cc4c0b37fdfb205a745547e9ec7fcc0719fb5 100644
--- a/Sim/Simulation/ISimulation.h
+++ b/Sim/Simulation/ISimulation.h
@@ -104,7 +104,7 @@ private:
     virtual void runComputation(const ReSample& re_sample, size_t iElement) = 0;
 
     //! Normalizes the detector counts to beam intensity, to solid angle, and to exposure angle.
-    virtual void normalize(size_t start, size_t n_elements) {}
+    virtual void normalize(size_t /*start*/, size_t /*n_elements*/) {}
 
     virtual void addBackgroundIntensity(size_t start, size_t n_elements) = 0;
 
diff --git a/Tests/Unit/Sim/SpecularScanTest.cpp b/Tests/Unit/Sim/SpecularScanTest.cpp
index 178e007b32c1a555b527a1e1e1afc2e57c95ce6a..24428442777fdf1a624af8ed1465280367998b36 100644
--- a/Tests/Unit/Sim/SpecularScanTest.cpp
+++ b/Tests/Unit/Sim/SpecularScanTest.cpp
@@ -1,6 +1,5 @@
 #include "Base/Axis/FixedBinAxis.h"
 #include "Base/Axis/PointwiseAxis.h"
-#include "Device/Beam/FootprintGauss.h"
 #include "Param/Distrib/ParameterSample.h"
 #include "Param/Distrib/RangedDistributions.h"
 #include "Resample/Element/SpecularElement.h"
@@ -17,10 +16,6 @@ TEST(SpecularScanTest, AngularScanInit)
         EXPECT_EQ(scan.wavelength(), 0.1);
         EXPECT_EQ(axis, *scan.coordinateAxis());
         EXPECT_EQ(scan.nSteps(), axis.size());
-        EXPECT_EQ(scan.footprintFactor(), nullptr);
-        EXPECT_EQ(scan.footprint(0, 1), std::vector<double>{1.0});
-        EXPECT_THROW(scan.footprint(1, axis.size()), std::runtime_error);
-        EXPECT_NO_THROW(scan.footprint(0, axis.size()));
     };
 
     const PointwiseAxis pointwise_axis("inc_angles", std::vector<double>{0.1, 0.2, 0.3});
@@ -32,94 +27,11 @@ TEST(SpecularScanTest, AngularScanInit)
     check(scan3, fixed_axis);
 }
 
-TEST(SpecularScanTest, AngularScanWithFootprint)
-{
-    AlphaScan scan(0.1, 3, 0.05, 0.35);
-    EXPECT_EQ(scan.footprintFactor(), nullptr);
-
-    const IFootprintFactor& f_factor = FootprintGauss(0.1);
-    scan.setFootprintFactor(&f_factor);
-
-    EXPECT_EQ(scan.footprint(0, 1), std::vector<double>{f_factor.calculate(0.1)});
-    EXPECT_NE(scan.footprintFactor(), &f_factor);
-
-    scan.setFootprintFactor(nullptr);
-    EXPECT_EQ(scan.footprintFactor(), nullptr);
-    EXPECT_EQ(scan.footprint(0, 1), std::vector<double>{1.0});
-}
-
-TEST(SpecularScanTest, FootprintAndWavelengthResolution)
-{
-    AlphaScan scan(0.1, 3, 0.05, 0.35);
-    auto scan_res = std::unique_ptr<IScanResolution>(
-        scanRelativeResolution(RangedDistributionGate(3, 2.0), 0.1));
-    scan.setWavelengthResolution(*scan_res);
-
-    const IFootprintFactor& f_factor = FootprintGauss(0.1);
-    scan.setFootprintFactor(&f_factor);
-
-    std::vector<double> expected{
-        f_factor.calculate(0.1), f_factor.calculate(0.1), f_factor.calculate(0.1),
-        f_factor.calculate(0.2), f_factor.calculate(0.2), f_factor.calculate(0.2),
-        f_factor.calculate(0.3), f_factor.calculate(0.3), f_factor.calculate(0.3)};
-    std::vector<double> actual = scan.footprint(0, 9);
-
-    EXPECT_EQ(expected.size(), actual.size());
-    for (size_t i = 0; i < expected.size(); ++i)
-        EXPECT_DOUBLE_EQ(expected[i], actual[i]);
-
-    auto expected_part = std::vector<double>(expected.begin() + 1, expected.begin() + 8);
-    actual = scan.footprint(1, 7);
-
-    EXPECT_EQ(expected_part.size(), actual.size());
-    for (size_t i = 0; i < expected_part.size(); ++i)
-        EXPECT_DOUBLE_EQ(expected_part[i], actual[i]);
-}
-
-TEST(SpecularScanTest, FootprintAndAllResolutions)
-{
-    AlphaScan scan(0.1, 3, 0.05, 0.35);
-    auto wl_res = std::unique_ptr<IScanResolution>(
-        scanRelativeResolution(RangedDistributionGate(2, 2.0), 0.1));
-    scan.setWavelengthResolution(*wl_res);
-    auto inc_res = std::unique_ptr<IScanResolution>(
-        scanRelativeResolution(RangedDistributionGate(2, 2.0), 0.1));
-    scan.setAngleResolution(*inc_res);
-
-    const IFootprintFactor& f_factor = FootprintGauss(0.1);
-    scan.setFootprintFactor(&f_factor);
-
-    auto samples = inc_res->generateResolutionSamples(std::vector<double>{0.1, 0.2, 0.3});
-    std::vector<double> expected{
-        f_factor.calculate(samples[0][0].value), f_factor.calculate(samples[0][0].value),
-        f_factor.calculate(samples[0][1].value), f_factor.calculate(samples[0][1].value),
-        f_factor.calculate(samples[1][0].value), f_factor.calculate(samples[1][0].value),
-        f_factor.calculate(samples[1][1].value), f_factor.calculate(samples[1][1].value),
-        f_factor.calculate(samples[2][0].value), f_factor.calculate(samples[2][0].value),
-        f_factor.calculate(samples[2][1].value), f_factor.calculate(samples[2][1].value)};
-    std::vector<double> actual = scan.footprint(0, 12);
-
-    EXPECT_EQ(expected.size(), actual.size());
-    for (size_t i = 0; i < expected.size(); ++i)
-        EXPECT_DOUBLE_EQ(expected[i], actual[i]);
-
-    auto expected_part = std::vector<double>(expected.begin() + 1, expected.begin() + 8);
-    actual = scan.footprint(1, 7);
-
-    EXPECT_EQ(expected_part.size(), actual.size());
-    for (size_t i = 0; i < expected_part.size(); ++i)
-        EXPECT_DOUBLE_EQ(expected_part[i], actual[i]);
-}
-
 TEST(SpecularScanTest, QScanInit)
 {
     auto check = [](const QzScan& scan, const IAxis& axis) {
         EXPECT_EQ(axis, *scan.coordinateAxis());
         EXPECT_EQ(scan.nSteps(), axis.size());
-        EXPECT_EQ(scan.footprintFactor(), nullptr);
-        EXPECT_EQ(scan.footprint(0, 1), std::vector<double>{1.0});
-        EXPECT_THROW(scan.footprint(1, axis.size()), std::runtime_error);
-        EXPECT_NO_THROW(scan.footprint(0, axis.size()));
     };
 
     const PointwiseAxis pointwise_axis("qs", std::vector<double>{0.1, 0.2, 0.3});
@@ -145,19 +57,10 @@ TEST(SpecularScanTest, AngularScanClone)
     EXPECT_EQ(*scan_clone->coordinateAxis(), *scan.coordinateAxis());
     EXPECT_NE(scan_clone->coordinateAxis(), scan.coordinateAxis());
     EXPECT_EQ(scan_clone->wavelength(), scan.wavelength());
-    EXPECT_EQ(scan_clone->footprintFactor(), nullptr);
-
-    const IFootprintFactor& f_factor = FootprintGauss(0.1);
-    scan.setFootprintFactor(&f_factor);
 
     std::unique_ptr<AlphaScan> scan_clone2(scan.clone());
     EXPECT_EQ(*scan_clone2->coordinateAxis(), *scan.coordinateAxis());
     EXPECT_EQ(scan_clone2->wavelength(), scan.wavelength());
-
-    EXPECT_EQ(scan_clone2->footprintFactor()->widthRatio(), f_factor.widthRatio());
-    EXPECT_NE(scan_clone2->footprintFactor(), scan.footprintFactor());
-    EXPECT_NE(scan_clone2->footprintFactor(), &f_factor);
-    EXPECT_NE(dynamic_cast<const FootprintGauss*>(scan_clone2->footprintFactor()), nullptr);
 }
 
 TEST(SpecularScanTest, QScanClone)
@@ -170,7 +73,6 @@ TEST(SpecularScanTest, QScanClone)
     std::unique_ptr<QzScan> scan_clone(scan.clone());
     EXPECT_EQ(*scan_clone->coordinateAxis(), *scan.coordinateAxis());
     EXPECT_NE(scan_clone->coordinateAxis(), scan.coordinateAxis());
-    EXPECT_EQ(scan_clone->footprintFactor(), nullptr);
 
     const auto* resolution = scan.resolution();
     const auto* distributionClone =