diff --git a/Core/Computation/MainComputation.cpp b/Core/Computation/MainComputation.cpp
index 714a91f33e88b328f29b61fdb0e2c9db029c3b56..2407a0de5f0acd6d4dbb9f6141018c313eb9cf09 100644
--- a/Core/Computation/MainComputation.cpp
+++ b/Core/Computation/MainComputation.cpp
@@ -41,7 +41,6 @@ MainComputation::MainComputation(
     , m_progress(&progress)
     , m_begin_it(begin_it)
     , m_end_it(end_it)
-    , mp_roughness_computation(nullptr)
 {
     msglog(Logging::DEBUG2) << "MainComputation::init()";
 
@@ -49,22 +48,21 @@ MainComputation::MainComputation(
     for (size_t i=0; i<nLayers; ++i) {
         const Layer* layer = mP_multi_layer->getLayer(i);
         for (size_t j=0; j<layer->getNumberOfLayouts(); ++j)
-            m_layer_computation.push_back(
+            m_computation_terms.push_back(
                         new ParticleLayoutComputation(mP_multi_layer.get(),
                                                       layer->getLayout(j), i));
     }
     // scattering from rough surfaces in DWBA
     if (mP_multi_layer->hasRoughness())
-        mp_roughness_computation = new RoughMultiLayerComputation(mP_multi_layer.get());
+        m_computation_terms.push_back(new RoughMultiLayerComputation(mP_multi_layer.get()));
     mp_specular_computation = new SpecularComputation();
 }
 
 MainComputation::~MainComputation()
 {
-    delete mp_roughness_computation;
-    delete mp_specular_computation;
-    for (ParticleLayoutComputation* comp: m_layer_computation)
+    for (IComputationTerm* comp: m_computation_terms)
         delete comp;
+    delete mp_specular_computation;
 }
 
 void MainComputation::run()
@@ -93,11 +91,11 @@ void MainComputation::runProtected()
     else
         collectRTCoefficientsScalar();
 
-    // run through layers and run layer simulations
     std::vector<SimulationElement> layer_elements;
     std::copy(m_begin_it, m_end_it, std::back_inserter(layer_elements));
     bool polarized = mP_multi_layer->containsMagneticMaterial();
-    for (const ParticleLayoutComputation* comp: m_layer_computation) {
+    // add all IComputationTerms:
+    for (const IComputationTerm* comp: m_computation_terms) {
         if (!m_progress->alive())
             return;
         comp->eval(m_sim_options, m_progress, polarized,
@@ -105,15 +103,7 @@ void MainComputation::runProtected()
         addElementsWithWeight(layer_elements.begin(), layer_elements.end(), m_begin_it, 1.0);
     }
 
-    if (!mP_multi_layer->requiresMatrixRTCoefficients() && mp_roughness_computation) {
-        msglog(Logging::DEBUG2) << "MainComputation::run() -> roughness";
-        if (!m_progress->alive())
-            return;
-        mp_roughness_computation->eval(m_sim_options, m_progress, polarized,
-                                       layer_elements.begin(), layer_elements.end());
-        addElementsWithWeight(layer_elements.begin(), layer_elements.end(), m_begin_it, 1.0);
-    }
-
+    // Specular computation currently overwrites the pixel value (intended behaviour)
     if (m_sim_options.includeSpecular())
         mp_specular_computation->eval(m_sim_options, m_progress, polarized, m_begin_it, m_end_it);
 }
@@ -128,15 +118,12 @@ void MainComputation::collectRTCoefficientsScalar()
         m_fresnel_info.push_back(new ScalarSpecularInfoMap(mP_multi_layer.get(), i));
     }
 
-    // layer DWBA simulation
-    for (ParticleLayoutComputation* comp: m_layer_computation) {
+    // IComputationTerm simulation
+    for (IComputationTerm* comp: m_computation_terms) {
         comp->setSpecularInfo(&m_fresnel_info);
     }
     // specular simulation (R^2 at top layer)
     mp_specular_computation->setSpecularInfo(&m_fresnel_info);
-    // layer roughness DWBA
-    if (mp_roughness_computation)
-        mp_roughness_computation->setSpecularInfo(&m_fresnel_info);
 }
 
 void MainComputation::collectRTCoefficientsMatrix()
@@ -151,8 +138,8 @@ void MainComputation::collectRTCoefficientsMatrix()
                                                            mP_inverted_multilayer.get(), i));
     }
 
-    // layer DWBA simulation
-    for (ParticleLayoutComputation* comp: m_layer_computation) {
+    // IComputationTerm simulation
+    for (IComputationTerm* comp: m_computation_terms) {
         comp->setSpecularInfo(&m_fresnel_info);
     }
 }
diff --git a/Core/Computation/MainComputation.h b/Core/Computation/MainComputation.h
index f1a0348b6a84ae2bd7ffc228b5dbad453aa3fa97..968de00b94301f2143d5b6f3eb9b78bec4db7317 100644
--- a/Core/Computation/MainComputation.h
+++ b/Core/Computation/MainComputation.h
@@ -26,7 +26,7 @@
 
 class ILayerSpecularInfo;
 class MultiLayer;
-class ParticleLayoutComputation;
+class IComputationTerm;
 class ProgressHandler;
 class RoughMultiLayerComputation;
 class SimulationElement;
@@ -68,9 +68,8 @@ private:
     //! these iterators define the span of detector bins this simulation will work on
     std::vector<SimulationElement>::iterator m_begin_it, m_end_it;
 
-    RoughMultiLayerComputation* mp_roughness_computation;
+    std::vector<IComputationTerm*> m_computation_terms;
     SpecularComputation *mp_specular_computation;
-    std::vector<ParticleLayoutComputation*> m_layer_computation;
 
     //! contains the information, necessary to calculate the Fresnel coefficients
     SafePointerVector<ILayerSpecularInfo> m_fresnel_info;
diff --git a/Core/Computation/RoughMultiLayerComputation.cpp b/Core/Computation/RoughMultiLayerComputation.cpp
index d388eae2992d1e0598e56b00e934b7446627a9f2..370196eeadf3bdd624725664e694901fd5be1fbe 100644
--- a/Core/Computation/RoughMultiLayerComputation.cpp
+++ b/Core/Computation/RoughMultiLayerComputation.cpp
@@ -54,6 +54,12 @@ void RoughMultiLayerComputation::eval(
     const std::vector<SimulationElement>::iterator& begin_it,
     const std::vector<SimulationElement>::iterator& end_it) const
 {
+    if (mp_multilayer->requiresMatrixRTCoefficients()) {
+        for (std::vector<SimulationElement>::iterator it = begin_it; it != end_it; ++it) {
+            it->setIntensity(0.0);
+        }
+        return;
+    }
     DelayedProgressCounter counter(100);
     for (std::vector<SimulationElement>::iterator it = begin_it; it != end_it; ++it) {
         if (!progress->alive())