ctd: df is a Datafield

Device/Resolution/ConvolutionDetectorResolution.cpp

@@ -53,13 +53,13 @@ std::vector<const INode*> ConvolutionDetectorResolution::nodeChildren() const
     return std::vector<const INode*>() << m_res_function_2d;
 }
 
-void ConvolutionDetectorResolution::applyDetectorResolution(Datafield* intensity_map) const
+void ConvolutionDetectorResolution::applyDetectorResolution(Datafield* df) const
 {
-    ASSERT(intensity_map->rank() == m_rank);
+    ASSERT(df->rank() == m_rank);
     if (m_rank == 1)
-        apply1dConvolution(intensity_map);
+        apply1dConvolution(df);
     else if (m_rank == 2)
-        apply2dConvolution(intensity_map);
+        apply2dConvolution(df);
     else
         ASSERT_NEVER;
 }
@@ -69,14 +69,14 @@ void ConvolutionDetectorResolution::setResolutionFunction(const IResolutionFunct
     m_res_function_2d.reset(resFunc.clone());
 }
 
-void ConvolutionDetectorResolution::apply1dConvolution(Datafield* intensity_map) const
+void ConvolutionDetectorResolution::apply1dConvolution(Datafield* df) const
 {
     ASSERT(m_res_function_1d);
-    ASSERT(intensity_map->rank() == 1);
+    ASSERT(df->rank() == 1);
 
-    const Scale& axis = intensity_map->axis(0);
+    const Scale& axis = df->axis(0);
     // Construct source vector from original intensity map
-    std::vector<double> source_vector = intensity_map->flatVector();
+    std::vector<double> source_vector = df->flatVector();
     size_t n = source_vector.size();
     if (n < 2)
         return; // No convolution for sets of zero or one element
@@ -94,22 +94,22 @@ void ConvolutionDetectorResolution::apply1dConvolution(Datafield* intensity_map)
     for (double& e : result)
         e = std::max(0.0, e);
     // Populate intensity map with results
-    intensity_map->setVector(result);
+    df->setVector(result);
 }
 
-void ConvolutionDetectorResolution::apply2dConvolution(Datafield* intensity_map) const
+void ConvolutionDetectorResolution::apply2dConvolution(Datafield* df) const
 {
     ASSERT(m_res_function_2d);
-    ASSERT(intensity_map->rank() == 2);
-    const Scale& X = intensity_map->axis(0);
-    const Scale& Y = intensity_map->axis(1);
+    ASSERT(df->rank() == 2);
+    const Scale& X = df->axis(0);
+    const Scale& Y = df->axis(1);
     size_t nx = X.size();
     size_t ny = Y.size();
     ASSERT(nx > 1);
     ASSERT(ny > 1);
 
     // Construct source vector array from original intensity map
-    std::vector<double> raw_source_vector = intensity_map->flatVector();
+    std::vector<double> raw_source_vector = df->flatVector();
     std::vector<std::vector<double>> source;
     size_t raw_data_size = raw_source_vector.size();
     ASSERT(raw_data_size == nx * ny);
@@ -145,11 +145,11 @@ void ConvolutionDetectorResolution::apply2dConvolution(Datafield* intensity_map)
             result_vector.push_back(value);
         }
     }
-    ASSERT(nx * ny == intensity_map->size());
-    for (size_t i = 0; i < intensity_map->size(); ++i) {
-        size_t i0 = intensity_map->frame().projectedIndex(i, 0);
-        size_t i1 = intensity_map->frame().projectedIndex(i, 1);
-        (*intensity_map)[i] = std::max(0.0, result[i0][i1]);
+    ASSERT(nx * ny == df->size());
+    for (size_t i = 0; i < df->size(); ++i) {
+        size_t i0 = df->frame().projectedIndex(i, 0);
+        size_t i1 = df->frame().projectedIndex(i, 1);
+        (*df)[i] = std::max(0.0, result[i0][i1]);
     }
 }