diff --git a/Core/Computation/DelayedProgressCounter.cpp b/Core/Computation/DelayedProgressCounter.cpp
index 9c2de575e190388c62031f1f992a1d12c6c92dcc..93c5e59fa801768c330cd406fdf3f4c1dbe0d92b 100644
--- a/Core/Computation/DelayedProgressCounter.cpp
+++ b/Core/Computation/DelayedProgressCounter.cpp
@@ -15,11 +15,17 @@
 #include "ProgressHandler.h"
 #include "DelayedProgressCounter.h"
 
-void DelayedProgressCounter::stepProgress(ProgressHandler* progress)
+DelayedProgressCounter::DelayedProgressCounter(ProgressHandler* p_progress, size_t interval)
+    : mp_progress(p_progress)
+    , m_interval(interval)
+    , m_count(0)
+{}
+
+void DelayedProgressCounter::stepProgress()
 {
     ++m_count;
     if( m_count==m_interval ) {
-        progress->incrementDone(m_interval);
+        mp_progress->incrementDone(m_interval);
         m_count = 0;
     }
 }
diff --git a/Core/Computation/DelayedProgressCounter.h b/Core/Computation/DelayedProgressCounter.h
index 0f551178b483c0f7c1e9b8c31a3e4065e3fff4e0..bf3d7f2df36cf255625d21ac9889c4f269d86d31 100644
--- a/Core/Computation/DelayedProgressCounter.h
+++ b/Core/Computation/DelayedProgressCounter.h
@@ -24,12 +24,13 @@ class ProgressHandler;
 class DelayedProgressCounter
 {
 public:
-    DelayedProgressCounter(size_t interval) : m_interval(interval), m_count(0) {}
+    DelayedProgressCounter(ProgressHandler* p_progress, size_t interval);
     ~DelayedProgressCounter() {}
 
     //! Increments inner counter; at regular intervals updates progress handler.
-    void stepProgress(ProgressHandler* progress);
+    void stepProgress();
 private:
+    ProgressHandler* mp_progress;
     const size_t m_interval;
     size_t m_count;
 };
diff --git a/Core/Computation/GISASSpecularComputationTerm.h b/Core/Computation/GISASSpecularComputationTerm.h
index 2ebaeb20f1a491b93a65b5a5c556cdf5bb0a3d32..2c385ec3ea5e389f159073ec69cdaa880e2bcd7d 100644
--- a/Core/Computation/GISASSpecularComputationTerm.h
+++ b/Core/Computation/GISASSpecularComputationTerm.h
@@ -25,6 +25,8 @@ class GISASSpecularComputationTerm final : public IComputationTerm
 public:
     GISASSpecularComputationTerm(const MultiLayer* p_multi_layer, const IFresnelMap* p_fresnel_map);
 
+    void setProgressHandler(ProgressHandler*) override {}
+
     void eval(ProgressHandler* progress, const std::vector<SimulationElement>::iterator& begin_it,
               const std::vector<SimulationElement>::iterator& end_it) const override;
 
diff --git a/Core/Computation/IComputationTerm.cpp b/Core/Computation/IComputationTerm.cpp
index abca4d95afe2c37591b95e2e46039171ac3e7ade..c5282962d9ee0be0d852a8285ef868b36a206ab5 100644
--- a/Core/Computation/IComputationTerm.cpp
+++ b/Core/Computation/IComputationTerm.cpp
@@ -19,17 +19,11 @@ IComputationTerm::IComputationTerm(const MultiLayer* p_multilayer,
                                    const IFresnelMap* p_fresnel_map)
     : mp_multilayer(p_multilayer)
     , mp_fresnel_map(p_fresnel_map)
-    , mp_progress(nullptr)
 {}
 
 IComputationTerm::~IComputationTerm()
 {}
 
-void IComputationTerm::setProgressHandler(ProgressHandler* p_progress)
-{
-    mp_progress = p_progress;
-}
-
 void IComputationTerm::mergeRegionMap(
         std::map<size_t, std::vector<HomogeneousRegion> >& region_map) const
 {
diff --git a/Core/Computation/IComputationTerm.h b/Core/Computation/IComputationTerm.h
index b9a70101660017607708b0991aafc433f79b0259..cb7479d9243507ab60c1800babf5ae776eedf13f 100644
--- a/Core/Computation/IComputationTerm.h
+++ b/Core/Computation/IComputationTerm.h
@@ -36,7 +36,7 @@ public:
     IComputationTerm(const MultiLayer* p_multilayer, const IFresnelMap* p_fresnel_map);
     virtual ~IComputationTerm();
 
-    void setProgressHandler(ProgressHandler* p_progress);
+    virtual void setProgressHandler(ProgressHandler* p_progress) =0;
 
     //! Calculate scattering intensity for each SimulationElement
     //! returns false if nothing needed to be calculated
@@ -51,7 +51,6 @@ protected:
     const MultiLayer* mp_multilayer;
     const IFresnelMap* mp_fresnel_map;
     std::map<size_t, std::vector<HomogeneousRegion>> m_region_map;
-    ProgressHandler* mp_progress;
 };
 
 #endif // ICOMPUTATIONTERM_H
diff --git a/Core/Computation/ParticleLayoutComputation.cpp b/Core/Computation/ParticleLayoutComputation.cpp
index b5fab7eaabcecc7dc3c0d573bf234cc5e8f86e5d..2967678b8d9fb9219bbca717ca094bcf3d5a4aac 100644
--- a/Core/Computation/ParticleLayoutComputation.cpp
+++ b/Core/Computation/ParticleLayoutComputation.cpp
@@ -35,12 +35,16 @@ ParticleLayoutComputation::ParticleLayoutComputation(
     m_surface_density = p_layout->totalParticleSurfaceDensity();
 }
 
+void ParticleLayoutComputation::setProgressHandler(ProgressHandler* p_progress)
+{
+    mP_progress_counter.reset(new DelayedProgressCounter(p_progress, 100));
+}
+
 //! Computes scattering intensity for given range of simulation elements.
 void ParticleLayoutComputation::eval(ProgressHandler* progress,
     const std::vector<SimulationElement>::iterator& begin_it,
     const std::vector<SimulationElement>::iterator& end_it) const
 {
-    DelayedProgressCounter counter(100);
     for (std::vector<SimulationElement>::iterator it = begin_it; it != end_it; ++it) {
         if (!progress->alive())
             return;
@@ -51,6 +55,8 @@ void ParticleLayoutComputation::eval(ProgressHandler* progress,
         } else {
             it->addIntensity(mP_strategy->evaluate(*it) * m_surface_density);
         }
-        counter.stepProgress(progress);
+        if (mP_progress_counter) {
+            mP_progress_counter->stepProgress();
+        }
     }
 }
diff --git a/Core/Computation/ParticleLayoutComputation.h b/Core/Computation/ParticleLayoutComputation.h
index 4a71d89ccbad4c3d362c0d0489840bf6edde2ddb..e33f326251e5c35436e83a991891da1287e128c7 100644
--- a/Core/Computation/ParticleLayoutComputation.h
+++ b/Core/Computation/ParticleLayoutComputation.h
@@ -20,6 +20,7 @@
 
 using std::size_t;
 
+class DelayedProgressCounter;
 class ILayout;
 class IInterferenceFunctionStrategy;
 
@@ -34,6 +35,8 @@ public:
         const MultiLayer* p_multilayer, const IFresnelMap* p_fresnel_map, const ILayout* p_layout,
         size_t layer_index, const SimulationOptions& options, bool polarized);
 
+    void setProgressHandler(ProgressHandler* p_progress) override;
+
     void eval(ProgressHandler* progress,
               const std::vector<SimulationElement>::iterator& begin_it,
               const std::vector<SimulationElement>::iterator& end_it) const override;
@@ -41,6 +44,7 @@ public:
 private:
     std::unique_ptr<const IInterferenceFunctionStrategy> mP_strategy;
     double m_surface_density;
+    std::unique_ptr<DelayedProgressCounter> mP_progress_counter;
 };
 
 #endif // PARTICLELAYOUTCOMPUTATION_H
diff --git a/Core/Computation/RoughMultiLayerComputation.cpp b/Core/Computation/RoughMultiLayerComputation.cpp
index 8dac2bbd710e10aaca4d76f0f416a2231fccfb79..53ed64d310b1ed2a028fb184e39c77c684081aae 100644
--- a/Core/Computation/RoughMultiLayerComputation.cpp
+++ b/Core/Computation/RoughMultiLayerComputation.cpp
@@ -44,6 +44,11 @@ RoughMultiLayerComputation::RoughMultiLayerComputation(const MultiLayer *p_multi
     : IComputationTerm(p_multi_layer, p_fresnel_map)
 {}
 
+void RoughMultiLayerComputation::setProgressHandler(ProgressHandler* p_progress)
+{
+    mP_progress_counter.reset(new DelayedProgressCounter(p_progress, 100));
+}
+
 void RoughMultiLayerComputation::eval(ProgressHandler* progress,
     const std::vector<SimulationElement>::iterator& begin_it,
     const std::vector<SimulationElement>::iterator& end_it) const
@@ -51,12 +56,11 @@ void RoughMultiLayerComputation::eval(ProgressHandler* progress,
     if (mp_multilayer->requiresMatrixRTCoefficients()) {
         return;
     }
-    DelayedProgressCounter counter(100);
     for (std::vector<SimulationElement>::iterator it = begin_it; it != end_it; ++it) {
         if (!progress->alive())
             return;
         it->addIntensity(evaluate(*it));
-        counter.stepProgress(progress);
+        mP_progress_counter->stepProgress();
     }
 }
 
diff --git a/Core/Computation/RoughMultiLayerComputation.h b/Core/Computation/RoughMultiLayerComputation.h
index 92bfd930a61b2529bc64b66d7b2d2ebc4d9966c0..2ea9914ece605be85a48bcdc2d43cb78f4609791 100644
--- a/Core/Computation/RoughMultiLayerComputation.h
+++ b/Core/Computation/RoughMultiLayerComputation.h
@@ -19,6 +19,7 @@
 #include "IComputationTerm.h"
 #include <vector>
 
+class DelayedProgressCounter;
 class ProgressHandler;
 class SimulationElement;
 
@@ -32,6 +33,8 @@ public:
     RoughMultiLayerComputation(const MultiLayer* p_multi_layer,
                                const IFresnelMap* p_fresnel_map);
 
+    void setProgressHandler(ProgressHandler* p_progress) override;
+
     void eval(ProgressHandler* progress,
               const std::vector<SimulationElement>::iterator& begin_it,
               const std::vector<SimulationElement>::iterator& end_it) const override;
@@ -40,6 +43,7 @@ private:
     double evaluate(const SimulationElement& sim_element) const;
     complex_t get_refractive_term(size_t ilayer, double wavelength) const;
     complex_t get_sum8terms(size_t ilayer, const SimulationElement& sim_element) const;
+    std::unique_ptr<DelayedProgressCounter> mP_progress_counter;
 };
 
 #endif // ROUGHMULTILAYERCOMPUTATION_H