diff --git a/Base/Math/FourierTransform.cpp b/Base/Math/FourierTransform.cpp
index 3709ce55d32777e457eed9031e13ec5820eb6191..7952afc35386cc61bf27d66a1fb85a96eaab69f7 100644
--- a/Base/Math/FourierTransform.cpp
+++ b/Base/Math/FourierTransform.cpp
@@ -156,7 +156,7 @@ complex2d_t FourierTransform::ifftshift(const complex2d_t& src)
 /* ************************************************************************* */
 // Fourier Transform in 1D
 /* ************************************************************************* */
-complex1d_t FourierTransform::rfft(const double1d_t& src)
+std::vector<complex_t> FourierTransform::rfft(const std::vector<double>& src)
 {
     // we simply create 2d arrays with length of first dimension equal to 1, and call 2d FT
     double2d_t src2d{src};
@@ -166,7 +166,7 @@ complex1d_t FourierTransform::rfft(const double1d_t& src)
     return result2d[0];
 }
 
-double1d_t FourierTransform::irfft(const complex1d_t& src, int w_src)
+std::vector<double> FourierTransform::irfft(const std::vector<complex_t>& src, int w_src)
 {
     // we simply create 2d arrays with length of first dimension equal to 1, and call 2d FT
     complex2d_t source2d{src};
@@ -176,7 +176,7 @@ double1d_t FourierTransform::irfft(const complex1d_t& src, int w_src)
     return result2d[0];
 }
 
-double1d_t FourierTransform::ramplitude(const double1d_t& src)
+std::vector<double> FourierTransform::ramplitude(const std::vector<double>& src)
 {
     complex2d_t complex_result2d{rfft(src)};
 
@@ -189,20 +189,20 @@ double1d_t FourierTransform::ramplitude(const double1d_t& src)
 /* ************************************************************************* */
 // Fourier Transform 1D shift - center around zero frequency
 /* ************************************************************************* */
-double1d_t FourierTransform::fftshift(const double1d_t& src)
+std::vector<double> FourierTransform::fftshift(const std::vector<double>& src)
 {
     return ::fftshift_1d(src, false);
 }
-complex1d_t FourierTransform::fftshift(const complex1d_t& src)
+std::vector<complex_t> FourierTransform::fftshift(const std::vector<complex_t>& src)
 {
     return ::fftshift_1d(src, false);
 }
 
-double1d_t FourierTransform::ifftshift(const double1d_t& src)
+std::vector<double> FourierTransform::ifftshift(const std::vector<double>& src)
 {
     return ::fftshift_1d(src, true);
 }
-complex1d_t FourierTransform::ifftshift(const complex1d_t& src)
+std::vector<complex_t> FourierTransform::ifftshift(const std::vector<complex_t>& src)
 {
     return ::fftshift_1d(src, true);
 }
@@ -255,7 +255,7 @@ complex2d_t FourierTransform::rfft2complex_vec() const
 {
     ASSERT(ws.arr_fftw);
 
-    complex2d_t result(ws.h, complex1d_t(ws.w_fftw));
+    complex2d_t result(ws.h, std::vector<complex_t>(ws.w_fftw));
     double* ptr = ws.arr_fftw;
 
     // Storing FT output
diff --git a/Base/Math/FourierTransform.h b/Base/Math/FourierTransform.h
index 43fc3518eaa846c7c00c02dab0655d8e2f32e9f2..d4db52666789f68a1d23e99cc6421e8bdc78151a 100644
--- a/Base/Math/FourierTransform.h
+++ b/Base/Math/FourierTransform.h
@@ -27,15 +27,15 @@ public:
     FourierTransform();
 
     // forward transform
-    complex1d_t rfft(const double1d_t& src);
+    std::vector<complex_t> rfft(const std::vector<double>& src);
     complex2d_t rfft(const double2d_t& src);
 
     // forward transform with real-valued amplitudes in output
-    double1d_t ramplitude(const double1d_t& src);
+    std::vector<double> ramplitude(const std::vector<double>& src);
     double2d_t ramplitude(const double2d_t& src);
 
     // backward transform
-    double1d_t irfft(const complex1d_t& src, int w_src);
+    std::vector<double> irfft(const std::vector<complex_t>& src, int w_src);
     double2d_t irfft(const complex2d_t& src, int w_real);
 
     // Frequency shifts are useful for providing different representations of spectrum: with lowest
@@ -43,14 +43,14 @@ public:
     // array
 
     // shift low frequency from corners to center
-    static double1d_t fftshift(const double1d_t& src);
-    static complex1d_t fftshift(const complex1d_t& src);
+    static std::vector<double> fftshift(const std::vector<double>& src);
+    static std::vector<complex_t> fftshift(const std::vector<complex_t>& src);
     static double2d_t fftshift(const double2d_t& src);
     static complex2d_t fftshift(const complex2d_t& src);
 
     // shift low frequency from center to corners
-    static double1d_t ifftshift(const double1d_t& src);
-    static complex1d_t ifftshift(const complex1d_t& src);
+    static std::vector<double> ifftshift(const std::vector<double>& src);
+    static std::vector<complex_t> ifftshift(const std::vector<complex_t>& src);
     static double2d_t ifftshift(const double2d_t& src);
     static complex2d_t ifftshift(const complex2d_t& src);
 
diff --git a/Base/Type/Vector.h b/Base/Type/Vector.h
index ccb2b368c1df02de54e8d09ed9644a7aaf234f76..5efe90e09e77a4cea9f97d8c43037d9f7940ee4a 100644
--- a/Base/Type/Vector.h
+++ b/Base/Type/Vector.h
@@ -18,9 +18,7 @@
 #include <heinz/Complex.h>
 #include <vector>
 
-using double1d_t = std::vector<double>;
-using double2d_t = std::vector<double1d_t>;
-using complex1d_t = std::vector<complex_t>;
-using complex2d_t = std::vector<complex1d_t>;
+using double2d_t = std::vector<std::vector<double>>;
+using complex2d_t = std::vector<std::vector<complex_t>>;
 
 #endif // BORNAGAIN_BASE_TYPE_VECTOR_H
diff --git a/Device/Resolution/Convolve.cpp b/Device/Resolution/Convolve.cpp
index 4ceed5e6c2141954acb8882cd87f932ffd8d5915..a85af775d25a2c7dcc0fb528ba8096eec0856a0d 100644
--- a/Device/Resolution/Convolve.cpp
+++ b/Device/Resolution/Convolve.cpp
@@ -118,7 +118,8 @@ void Convolve::fftconvolve2D(const double2d_t& source, const double2d_t& kernel,
     }
 }
 
-void Convolve::fftconvolve1D(const double1d_t& source, const double1d_t& kernel, double1d_t& result)
+void Convolve::fftconvolve1D(const std::vector<double>& source, const std::vector<double>& kernel,
+                             std::vector<double>& result)
 {
     // we simply create 2d arrays with length of first dimension equal to 1, and call 2d convolution
     double2d_t source2d, kernel2d;
diff --git a/Device/Resolution/Convolve.h b/Device/Resolution/Convolve.h
index 0e3c3bfd5e8104b22f2f32245921c6c9a653f6b3..aecb9d17896a02e06128142b82b5b44d187287e6 100644
--- a/Device/Resolution/Convolve.h
+++ b/Device/Resolution/Convolve.h
@@ -51,7 +51,8 @@ public:
     };
 
     //! convolution in 1D
-    void fftconvolve1D(const double1d_t& source, const double1d_t& kernel, double1d_t& result);
+    void fftconvolve1D(const std::vector<double>& source, const std::vector<double>& kernel,
+                       std::vector<double>& result);
 
     //! convolution in 2D
     void fftconvolve2D(const double2d_t& source, const double2d_t& kernel, double2d_t& result);
diff --git a/Sample/Interface/RoughnessMap.cpp b/Sample/Interface/RoughnessMap.cpp
index ca7d483581fbf3a04e1858da274ab32bb8200969..ec672300b2fa4904601da99b2ae8372abdf13ad8 100644
--- a/Sample/Interface/RoughnessMap.cpp
+++ b/Sample/Interface/RoughnessMap.cpp
@@ -77,18 +77,18 @@ double2d_t RoughnessMap::mapFromHeights() const
     const double step = 2 * z_limit / (z_steps - 1);
 
     // create mesh of values
-    double1d_t z_points(z_steps);
+    std::vector<double> z_points(z_steps);
     for (size_t i = 0; i < z_steps; i++)
         z_points[i] = -z_limit + step * i;
 
     // fill mesh with weights
-    double1d_t z_weights(z_steps);
+    std::vector<double> z_weights(z_steps);
     for (size_t i = 0; i < z_steps; i++)
         z_weights[i] = m_layerRoughness->roughnessModel()->distribution(z_points[i], sigma);
 
     // fill map with random values
     std::discrete_distribution<int> d(z_weights.begin(), z_weights.end());
-    double2d_t result(m_y_points, double1d_t(m_x_points));
+    double2d_t result(m_y_points, std::vector<double>(m_x_points));
     for (int j = 0; j < m_y_points; j++)
         for (int i = 0; i < m_x_points; i++)
             result[j][i] = z_points[d(m_gen)];
@@ -105,15 +105,15 @@ double2d_t RoughnessMap::mapFromSpectrum() const
     const int N = m_x_points / 2 + 1;
     const int M = m_y_points / 2 + 1;
 
-    double1d_t fx(N);
+    std::vector<double> fx(N);
     for (int i = 0; i < N; i++)
         fx[i] = 2 * pi * i * dfx;
 
-    double1d_t fy(M);
+    std::vector<double> fy(M);
     for (int j = 0; j < M; j++)
         fy[j] = 2 * pi * j * dfy;
 
-    double2d_t psd_mag(m_y_points, double1d_t(N));
+    double2d_t psd_mag(m_y_points, std::vector<double>(N));
     for (int i = 0; i < N; i++) {
         for (int j = 0; j < M; j++)
             psd_mag[j][i] = std::sqrt(m_layerRoughness->spectralFunction(R3(fx[i], fy[j], 0)));
@@ -123,7 +123,7 @@ double2d_t RoughnessMap::mapFromSpectrum() const
     psd_mag[0][0] = 0; // average height (amplitude at zero frequency) is null
 
     std::uniform_real_distribution<double> d(-pi, pi);
-    double2d_t phase(m_y_points, double1d_t(N));
+    double2d_t phase(m_y_points, std::vector<double>(N));
 
     // main axes
     // x axis
@@ -147,7 +147,7 @@ double2d_t RoughnessMap::mapFromSpectrum() const
                 phase[pos_j][pos_i] = +phase[sym_pos_j][pos_i];
         }
     }
-    complex2d_t spectrum(m_y_points, complex1d_t(N));
+    complex2d_t spectrum(m_y_points, std::vector<complex_t>(N));
     for (int j = 0; j < m_y_points; j++)
         for (int i = 0; i < N; i++)
             spectrum[j][i] = psd_mag[j][i] * std::exp(I * phase[j][i]) * fft_factor;
@@ -197,7 +197,7 @@ double2d_t RoughnessMap::applyHeightsToSpectrum(const double2d_t& h_map,
 void RoughnessMap::createMap()
 {
     if (m_layerRoughness->sigma() < 1e-10) {
-        m_rough_map = double2d_t(m_y_points, double1d_t(m_x_points));
+        m_rough_map = double2d_t(m_y_points, std::vector<double>(m_x_points));
         return;
     }