replace DataUtil::create2DArrayfromDatafield by Datafield::values2D

Device/Analyze/Fourier.cpp

@@ -32,7 +32,7 @@ std::vector<std::vector<double>> FT2DArray(const std::vector<std::vector<double>
 
 Datafield Analyze::createFFT(const Datafield& data)
 {
-    auto array_2d = DataUtil::create2DArrayfromDatafield(data);
+    auto array_2d = data.values2D();
     auto fft_array_2d = FT2DArray(array_2d);
     return DataUtil::vecvecToDatafield(fft_array_2d);
 }

Device/Data/DataUtil.cpp

@@ -120,28 +120,6 @@ Datafield DataUtil::createRearrangedDataSet(const Datafield& data, int n)
     return *output;
 }
 
-std::vector<std::vector<double>> DataUtil::create2DArrayfromDatafield(const Datafield& data)
-{
-    ASSERT(data.rank() == 2);
-    std::vector<std::vector<double>> array_2d;
-    std::vector<double> row_vec; // row vector for constructing each row of 2D array
-
-    size_t nrows = data.axis(0).size();
-    size_t ncols = data.axis(1).size();
-
-    size_t it = 0; // iterator of 'data'
-    for (size_t row = 0; row < nrows; row++) {
-        row_vec.clear();
-        for (size_t col = 0; col < ncols; col++) {
-            row_vec.push_back(data[it]);
-            it++;
-        }
-        array_2d.push_back(row_vec);
-    }
-
-    return array_2d;
-}
-
 Datafield DataUtil::vecvecToDatafield(const std::vector<std::vector<double>>& array_2d)
 {
     size_t nrows = array_2d.size();

Device/Data/Datafield.cpp

@@ -417,3 +417,27 @@ Datafield Datafield::normalizedToMax() const
     }
     return {title(), frame().clone(), outval, errval};
 }
+
+std::vector<std::vector<double>> Datafield::values2D() const
+{
+    return to2Dvector(m_values);
+}
+
+std::vector<std::vector<double>> Datafield::to2Dvector(const std::vector<double>& in) const
+{
+    ASSERT(rank() == 2);
+    std::vector<std::vector<double>> result;
+
+    const size_t nrows = axis(1).size();
+    const size_t ncols = axis(0).size();
+
+    result.resize(nrows);
+
+    for (size_t row = 0; row < nrows; ++row) {
+        result[row].resize(ncols, 0.0);
+        for (size_t col = 0; col < ncols; ++col)
+            result[row][col] = in[row * ncols + col];
+    }
+
+    return result;
+}

Device/Data/Datafield.h

@@ -147,6 +147,8 @@ public:
     bool hasErrorSigmas() const;
     std::vector<double>& errorSigmas();
 
+    std::vector<std::vector<double>> values2D() const;
+
 private:
     std::string m_title;
     std::unique_ptr<const Frame> m_frame;
@@ -161,6 +163,8 @@ private:
     //! between [xbinlow, xbinup].
     Datafield* create_yProjection(int xbinlow, int xbinup) const;
 
+    std::vector<std::vector<double>> to2Dvector(const std::vector<double>& in) const;
+
 #endif // SWIG
 };
 

Tests/Unit/Device/IntensityDataFunctionsTest.cpp

@@ -94,11 +94,11 @@ TEST(DataUtilTest, datafieldToFromBinf)
 TEST(DataUtilTest, create2DArrayfromDatafield)
 {
     Datafield out_data{
-        {newEquiDivision("axis0", 2, 1.0, 2.0), newEquiDivision("axis1", 3, 3.0, 4.0)}};
+        {newEquiDivision("axis0", 3, 1.0, 3.0), newEquiDivision("axis1", 2, 10., 20.)}};
     EXPECT_EQ(6u, out_data.size());
 
-    EXPECT_EQ(2u, out_data.axis(0).size()); // no. of rows
-    EXPECT_EQ(3u, out_data.axis(1).size()); // no. of cols
+    EXPECT_EQ(3u, out_data.axis(0).size()); // no. of rows
+    EXPECT_EQ(2u, out_data.axis(1).size()); // no. of cols
 
     std::vector<double> arr_in{1, 2, 3, 4, 5, 6};
     out_data.setVector(arr_in);
@@ -113,7 +113,7 @@ TEST(DataUtilTest, create2DArrayfromDatafield)
     auto arr_out = out_data.flatVector();
     EXPECT_EQ(arr_in, arr_out);
 
-    auto array_2d = DataUtil::create2DArrayfromDatafield(out_data);
+    auto array_2d = out_data.values2D();
 
     std::vector<std::vector<double>> array_expected_2d{{arr_in[0], arr_in[1], arr_in[2]},
                                                        {arr_in[3], arr_in[4], arr_in[5]}};