diff --git a/src/atlas/CMakeLists.txt b/src/atlas/CMakeLists.txt
index bc2be2afe..1ea3b58dd 100644
--- a/src/atlas/CMakeLists.txt
+++ b/src/atlas/CMakeLists.txt
@@ -706,6 +706,8 @@ linalg/sparse.h
 linalg/sparse/Backend.h
 linalg/sparse/Backend.cc
 linalg/sparse/MakeEckitSparseMatrix.h
+linalg/sparse/MakeSparseMatrixStorageEckit.h
+linalg/sparse/MakeSparseMatrixStorageEigen.h
 linalg/sparse/SparseMatrixMultiply.h
 linalg/sparse/SparseMatrixMultiply.tcc
 linalg/sparse/SparseMatrixMultiply_EckitLinalg.h
@@ -714,8 +716,7 @@ linalg/sparse/SparseMatrixMultiply_OpenMP.h
 linalg/sparse/SparseMatrixMultiply_OpenMP.cc
 linalg/sparse/SparseMatrixStorage.cc
 linalg/sparse/SparseMatrixStorage.h
-linalg/sparse/SparseMatrixConvertor.h
-linalg/sparse/SparseMatrixAdaptor.h
+linalg/sparse/SparseMatrixView.h
 linalg/dense.h
 linalg/dense/Backend.h
 linalg/dense/Backend.cc
diff --git a/src/atlas/interpolation/method/Method.cc b/src/atlas/interpolation/method/Method.cc
index 189485528..a11fc1c65 100644
--- a/src/atlas/interpolation/method/Method.cc
+++ b/src/atlas/interpolation/method/Method.cc
@@ -270,7 +270,7 @@ void Method::setup(const FunctionSpace& source, const FunctionSpace& target) {
         if (not matrix_->empty()) {
             eckit::linalg::SparseMatrix matrix_copy = make_eckit_sparse_matrix(*matrix_); // Makes a copy!
             matrix_copy.transpose(); // transpose the copy in place
-            matrix_transpose_ = atlas::linalg::SparseMatrixStorage(std::move(matrix_copy)); // Move the copy into storage
+            matrix_transpose_ = linalg::make_sparse_matrix_storage(std::move(matrix_copy)); // Move the copy into storage
         }
     }
 }
diff --git a/src/atlas/interpolation/method/Method.h b/src/atlas/interpolation/method/Method.h
index 8b1fef295..994ad9f7c 100644
--- a/src/atlas/interpolation/method/Method.h
+++ b/src/atlas/interpolation/method/Method.h
@@ -21,6 +21,7 @@
 #include "atlas/util/Object.h"
 #include "eckit/config/Configuration.h"
 #include "eckit/linalg/SparseMatrix.h"
+#include "atlas/linalg/sparse/MakeSparseMatrixStorageEckit.h"
 
 namespace atlas {
 class Field;
@@ -122,7 +123,7 @@ class Method : public util::Object {
     }
 
     void setMatrix(eckit::linalg::SparseMatrix&& m, const std::string& uid = "") {
-        setMatrix( Matrix(std::move(m)), uid );
+        setMatrix( linalg::make_sparse_matrix_storage(std::move(m)), uid );
     }
 
     void setMatrix(std::size_t rows, std::size_t cols, const Triplets& triplets, const std::string& uid = "") {
diff --git a/src/atlas/linalg/sparse.h b/src/atlas/linalg/sparse.h
index b2228335a..4c6ebc02e 100644
--- a/src/atlas/linalg/sparse.h
+++ b/src/atlas/linalg/sparse.h
@@ -11,10 +11,10 @@
 
 #include "sparse/Backend.h"
 #include "sparse/MakeEckitSparseMatrix.h"
-#include "sparse/SparseMatrixAdaptor.h"
-#include "sparse/SparseMatrixConvertor.h"
+#include "sparse/MakeSparseMatrixStorageEckit.h"
 #include "sparse/SparseMatrixMultiply.h"
 #include "sparse/SparseMatrixStorage.h"
+#include "sparse/SparseMatrixView.h"
 
 namespace atlas {
 namespace linalg {}  // namespace linalg
diff --git a/src/atlas/linalg/sparse/MakeSparseMatrixStorageEckit.h b/src/atlas/linalg/sparse/MakeSparseMatrixStorageEckit.h
new file mode 100644
index 000000000..fffbf9eeb
--- /dev/null
+++ b/src/atlas/linalg/sparse/MakeSparseMatrixStorageEckit.h
@@ -0,0 +1,135 @@
+/*
+ * (C) Copyright 2024- ECMWF.
+ *
+ * This software is licensed under the terms of the Apache Licence Version 2.0
+ * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
+ * In applying this licence, ECMWF does not waive the privileges and immunities
+ * granted to it by virtue of its status as an intergovernmental organisation
+ * nor does it submit to any jurisdiction.
+ */
+
+#pragma once
+
+#include <any>
+#include <memory>
+#include <algorithm>
+#include <type_traits>
+
+#include "eckit/linalg/SparseMatrix.h"
+
+#include "atlas/array.h"
+#include "atlas/linalg/sparse/SparseMatrixStorage.h"
+
+namespace atlas {
+namespace linalg {
+
+//----------------------------------------------------------------------------------------------------------------------
+
+template<typename OutputT, typename InputT>
+void host_copy_eckit (const InputT* input_data, array::Array& output) {
+        auto size = output.size();
+        OutputT* output_data = output.host_data<OutputT>();
+        std::copy( input_data, input_data + size, output_data );
+}
+
+inline SparseMatrixStorage make_sparse_matrix_storage(eckit::linalg::SparseMatrix&& m) {
+    using Index = eckit::linalg::Index;
+    using Value = eckit::linalg::Scalar;
+    std::cout << "make_sparse_matrix_storage move" << std::endl;
+
+    std::size_t rows = m.rows();
+    std::size_t cols = m.cols();
+    std::size_t nnz  = m.nonZeros();
+    auto* outer = array::Array::wrap(const_cast<Index*>(m.outer()), array::make_shape(rows+1));
+    auto* inner = array::Array::wrap(const_cast<Index*>(m.inner()), array::make_shape(nnz));
+    auto* value = array::Array::wrap(const_cast<Value*>(m.data()),  array::make_shape(nnz));
+
+    // We now move the eckit::linalg::SparseMatrix into a generic storage so
+    //   the wrapped array data does not go out of scope
+    auto storage = std::make_any<eckit::linalg::SparseMatrix>(std::move(m));
+
+    return SparseMatrixStorage::make( rows, cols, nnz,
+        std::unique_ptr<array::Array>(value),
+        std::unique_ptr<array::Array>(inner),
+        std::unique_ptr<array::Array>(outer),
+        std::move(storage)
+    );
+}
+
+template< typename value_type, typename index_type = eckit::linalg::Index>
+SparseMatrixStorage make_sparse_matrix_storage(eckit::linalg::SparseMatrix&& m) {
+    std::cout << "make_sparse_matrix_storage move or convert" << std::endl;
+
+    if (std::is_same_v<eckit::linalg::Scalar, value_type> && std::is_same_v<eckit::linalg::Index, index_type>) {
+        return make_sparse_matrix_storage(std::move(m));
+    }
+    std::size_t rows = m.rows();
+    std::size_t cols = m.cols();
+    std::size_t nnz  = m.nonZeros();
+    auto* outer = array::Array::create<index_type>(rows+1);
+    auto* inner = array::Array::create<index_type>(nnz);
+    auto* value = array::Array::create<value_type>(nnz);
+
+    host_copy_eckit<index_type>(m.outer(), *outer);
+    host_copy_eckit<index_type>(m.inner(), *inner);
+    host_copy_eckit<value_type>(m.data(),  *value);
+
+    return SparseMatrixStorage::make( rows, cols, nnz,
+        std::unique_ptr<array::Array>(value),
+        std::unique_ptr<array::Array>(inner),
+        std::unique_ptr<array::Array>(outer),
+        std::any()
+    );
+}
+
+
+inline SparseMatrixStorage make_sparse_matrix_storage(const eckit::linalg::SparseMatrix& m) {
+    using Index = eckit::linalg::Index;
+    using Value = eckit::linalg::Scalar;
+
+    std::cout << "make_sparse_matrix_storage copy" << std::endl;
+    std::size_t rows = m.rows();
+    std::size_t cols = m.cols();
+    std::size_t nnz  = m.nonZeros();
+    auto* outer = array::Array::create<Index>(rows+1);
+    auto* inner = array::Array::create<Index>(nnz);
+    auto* value = array::Array::create<Value>(nnz);
+
+    host_copy_eckit<Index>(m.outer(), *outer);
+    host_copy_eckit<Index>(m.inner(), *inner);
+    host_copy_eckit<Value>(m.data(),  *value);
+
+    return SparseMatrixStorage::make( rows, cols, nnz,
+        std::unique_ptr<array::Array>(value),
+        std::unique_ptr<array::Array>(inner),
+        std::unique_ptr<array::Array>(outer),
+        std::any()
+    );
+}
+
+template< typename value_type, typename index_type = eckit::linalg::Index>
+SparseMatrixStorage make_sparse_matrix_storage(const eckit::linalg::SparseMatrix& m) {
+    std::cout << "make_sparse_matrix_storage copy and convert" << std::endl;
+
+    std::size_t rows = m.rows();
+    std::size_t cols = m.cols();
+    std::size_t nnz  = m.nonZeros();
+    auto* outer = array::Array::create<index_type>(rows+1);
+    auto* inner = array::Array::create<index_type>(nnz);
+    auto* value = array::Array::create<value_type>(nnz);
+    host_copy_eckit<index_type>(m.outer(), *outer);
+    host_copy_eckit<index_type>(m.inner(), *inner);
+    host_copy_eckit<value_type>(m.data(),  *value);
+
+    return SparseMatrixStorage::make( rows, cols, nnz,
+        std::unique_ptr<array::Array>(value),
+        std::unique_ptr<array::Array>(inner),
+        std::unique_ptr<array::Array>(outer),
+        std::any()
+    );
+}
+
+//----------------------------------------------------------------------------------------------------------------------
+
+}  // namespace linalg
+}  // namespace atlas
\ No newline at end of file
diff --git a/src/atlas/linalg/sparse/MakeSparseMatrixStorageEigen.h b/src/atlas/linalg/sparse/MakeSparseMatrixStorageEigen.h
new file mode 100644
index 000000000..f306e85f0
--- /dev/null
+++ b/src/atlas/linalg/sparse/MakeSparseMatrixStorageEigen.h
@@ -0,0 +1,142 @@
+/*
+ * (C) Copyright 2024- ECMWF.
+ *
+ * This software is licensed under the terms of the Apache Licence Version 2.0
+ * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
+ * In applying this licence, ECMWF does not waive the privileges and immunities
+ * granted to it by virtue of its status as an intergovernmental organisation
+ * nor does it submit to any jurisdiction.
+ */
+
+#pragma once
+
+#include <any>
+#include <memory>
+#include <algorithm>
+#include <type_traits>
+
+#include "atlas/library/defines.h"
+#if ATLAS_HAVE_EIGEN
+#include <Eigen/Sparse>
+#endif
+
+#include "atlas/array.h"
+#include "atlas/linalg/sparse/SparseMatrixStorage.h"
+
+namespace atlas {
+namespace linalg {
+
+//----------------------------------------------------------------------------------------------------------------------
+
+#if ATLAS_HAVE_EIGEN
+
+template<typename OutputT, typename InputT>
+void host_copy_eigen (const InputT* input_data, atlas::array::Array& output) {
+        auto size = output.size();
+        OutputT* output_data = output.host_data<OutputT>();
+        std::copy( input_data, input_data + size, output_data );
+}
+
+template <typename Value, typename Index>
+SparseMatrixStorage make_sparse_matrix_storage(Eigen::SparseMatrix<Value, Eigen::RowMajor, Index>&& m) {
+    std::cout << "make_sparse_matrix_storage move" << std::endl;
+
+    std::size_t rows = m.rows();
+    std::size_t cols = m.cols();
+    std::size_t nnz  = m.nonZeros();
+    auto* outer = atlas::array::Array::wrap(const_cast<Index*>(m.outerIndexPtr()), atlas::array::make_shape(rows+1));
+    auto* inner = atlas::array::Array::wrap(const_cast<Index*>(m.innerIndexPtr()), atlas::array::make_shape(nnz));
+    auto* value = atlas::array::Array::wrap(const_cast<Value*>(m.valuePtr()),      atlas::array::make_shape(nnz));
+
+    using EigenMatrix = Eigen::SparseMatrix<Value, Eigen::RowMajor, Index>;
+    auto m_ptr = std::make_shared<EigenMatrix>();
+    m_ptr->swap(m);
+    auto storage = std::make_any<std::shared_ptr<EigenMatrix>>(std::move(m_ptr));
+
+    return SparseMatrixStorage::make( rows, cols, nnz,
+        std::unique_ptr<atlas::array::Array>(value),
+        std::unique_ptr<atlas::array::Array>(inner),
+        std::unique_ptr<atlas::array::Array>(outer),
+        std::move(storage)
+    );
+}
+
+template< typename value_type, typename index_type = eckit::linalg::Index, typename Value, typename Index,
+          typename = std::enable_if_t < !std::is_same_v<value_type,Value>>>
+SparseMatrixStorage make_sparse_matrix_storage(Eigen::SparseMatrix<Value, Eigen::RowMajor, Index>&& m) {
+    std::cout << "make_sparse_matrix_storage move or convert" << std::endl;
+
+    if (std::is_same_v<Value, value_type> && std::is_same_v<Index, index_type>) {
+        return make_sparse_matrix_storage(std::move(m));
+    }
+    std::size_t rows = m.rows();
+    std::size_t cols = m.cols();
+    std::size_t nnz  = m.nonZeros();
+    auto* outer = atlas::array::Array::create<index_type>(rows+1);
+    auto* inner = atlas::array::Array::create<index_type>(nnz);
+    auto* value = atlas::array::Array::create<value_type>(nnz);
+
+    host_copy_eigen<index_type>(m.outerIndexPtr(), *outer);
+    host_copy_eigen<index_type>(m.innerIndexPtr(), *inner);
+    host_copy_eigen<value_type>(m.valuePtr(),      *value);
+
+    return SparseMatrixStorage::make( rows, cols, nnz,
+        std::unique_ptr<atlas::array::Array>(value),
+        std::unique_ptr<atlas::array::Array>(inner),
+        std::unique_ptr<atlas::array::Array>(outer),
+        std::any()
+    );
+}
+
+
+template <typename Value, typename Index>
+SparseMatrixStorage make_sparse_matrix_storage(const Eigen::SparseMatrix<Value, Eigen::RowMajor, Index>& m) {
+    std::cout << "make_sparse_matrix_storage copy" << std::endl;
+    std::size_t rows = m.rows();
+    std::size_t cols = m.cols();
+    std::size_t nnz  = m.nonZeros();
+    auto* outer = atlas::array::Array::create<Index>(rows+1);
+    auto* inner = atlas::array::Array::create<Index>(nnz);
+    auto* value = atlas::array::Array::create<Value>(nnz);
+
+    host_copy_eigen<Index>(m.outerIndexPtr(), *outer);
+    host_copy_eigen<Index>(m.innerIndexPtr(), *inner);
+    host_copy_eigen<Value>(m.valuePtr(),      *value);
+
+    return SparseMatrixStorage::make( rows, cols, nnz,
+        std::unique_ptr<atlas::array::Array>(value),
+        std::unique_ptr<atlas::array::Array>(inner),
+        std::unique_ptr<atlas::array::Array>(outer),
+        std::any()
+    );
+}
+
+template< typename value_type, typename index_type = eckit::linalg::Index, typename Value, typename Index,
+          typename = std::enable_if_t < !std::is_same_v<value_type,Value>>>
+SparseMatrixStorage make_sparse_matrix_storage(const Eigen::SparseMatrix<Value, Eigen::RowMajor, Index>& m) {
+    std::cout << "make_sparse_matrix_storage copy and convert" << std::endl;
+
+    std::size_t rows = m.rows();
+    std::size_t cols = m.cols();
+    std::size_t nnz  = m.nonZeros();
+    auto* outer = atlas::array::Array::create<index_type>(rows+1);
+    auto* inner = atlas::array::Array::create<index_type>(nnz);
+    auto* value = atlas::array::Array::create<value_type>(nnz);
+    host_copy_eigen<index_type>(m.outerIndexPtr(), *outer);
+    host_copy_eigen<index_type>(m.innerIndexPtr(), *inner);
+    host_copy_eigen<value_type>(m.valuePtr(),      *value);
+
+    return SparseMatrixStorage::make( rows, cols, nnz,
+        std::unique_ptr<atlas::array::Array>(value),
+        std::unique_ptr<atlas::array::Array>(inner),
+        std::unique_ptr<atlas::array::Array>(outer),
+        std::any()
+    );
+}
+
+#endif
+
+//----------------------------------------------------------------------------------------------------------------------
+
+}  // namespace linalg
+}  // namespace atlas
\ No newline at end of file
diff --git a/src/atlas/linalg/sparse/SparseMatrixAdaptor.h b/src/atlas/linalg/sparse/SparseMatrixAdaptor.h
deleted file mode 100644
index d4f1baa39..000000000
--- a/src/atlas/linalg/sparse/SparseMatrixAdaptor.h
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * (C) Copyright 2024- ECMWF.
- *
- * This software is licensed under the terms of the Apache Licence Version 2.0
- * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
- * In applying this licence, ECMWF does not waive the privileges and immunities
- * granted to it by virtue of its status as an intergovernmental organisation
- * nor does it submit to any jurisdiction.
- */
-
-#pragma once
-
-#include "atlas/library/defines.h"
-#if ATLAS_HAVE_EIGEN
-#include <Eigen/Sparse>
-#endif
-#include "eckit/linalg/SparseMatrix.h"
-
-#include "atlas/array.h"
-
-namespace atlas {
-namespace linalg {
-
-//----------------------------------------------------------------------------------------------------------------------
-
-/// @brief Wrap existing sparse matrix formats into SparseMatrixStorage.
-///        This means that the host_data is not owned, but device_data is owned
-class SparseMatrixAdaptor : public SparseMatrixStorage {
-public:
-    SparseMatrixAdaptor(const eckit::linalg::SparseMatrix& m) {
-        nnz_   = m.nonZeros();
-        rows_  = m.rows();
-        cols_  = m.cols();
-        outer_.reset(atlas::array::Array::wrap(const_cast<eckit::linalg::Index*>(m.outer()), atlas::array::make_shape(rows_+1)));
-        inner_.reset(atlas::array::Array::wrap(const_cast<eckit::linalg::Index*>(m.inner()), atlas::array::make_shape(nnz_)));
-        value_.reset(atlas::array::Array::wrap(const_cast<eckit::linalg::Scalar*>(m.data()), atlas::array::make_shape(nnz_)));
-    }
-
-#if ATLAS_HAVE_EIGEN
-    template <typename Value, typename Index>
-    SparseMatrixAdaptor(const Eigen::SparseMatrix<Value, Eigen::RowMajor, Index>& m) {
-        nnz_   = m.nonZeros();
-        rows_  = m.rows();
-        cols_  = m.cols();
-        outer_.reset(atlas::array::Array::wrap(const_cast<std::decay_t<Index>*>(m.outerIndexPtr()), atlas::array::make_shape(rows_+1)));
-        inner_.reset(atlas::array::Array::wrap(const_cast<std::decay_t<Index>*>(m.innerIndexPtr()), atlas::array::make_shape(nnz_)));
-        value_.reset(atlas::array::Array::wrap(const_cast<std::decay_t<Value>*>(m.valuePtr()),      atlas::array::make_shape(nnz_)));
-    }
-#endif
-};
-
-//----------------------------------------------------------------------------------------------------------------------
-
-}  // namespace linalg
-}  // namespace atlas
\ No newline at end of file
diff --git a/src/atlas/linalg/sparse/SparseMatrixConvertor.h b/src/atlas/linalg/sparse/SparseMatrixConvertor.h
deleted file mode 100644
index 05950e635..000000000
--- a/src/atlas/linalg/sparse/SparseMatrixConvertor.h
+++ /dev/null
@@ -1,168 +0,0 @@
-/*
- * (C) Copyright 2024- ECMWF.
- *
- * This software is licensed under the terms of the Apache Licence Version 2.0
- * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
- * In applying this licence, ECMWF does not waive the privileges and immunities
- * granted to it by virtue of its status as an intergovernmental organisation
- * nor does it submit to any jurisdiction.
- */
-
-#pragma once
-
-#include <algorithm>
-#include <any>
-
-#include "atlas/library/defines.h"
-#if ATLAS_HAVE_EIGEN
-#include <Eigen/Sparse>
-#endif
-#include "eckit/linalg/SparseMatrix.h"
-
-#include "atlas/array.h"
-
-namespace atlas {
-namespace linalg {
-
-//----------------------------------------------------------------------------------------------------------------------
-
-template <typename Value, typename Index = eckit::linalg::Index>
-struct SparseMatrixConvertor : public SparseMatrixStorage {
-    using value_type = Value;
-    using index_type = Index;
-
-private:
-
-    template<typename InputT, typename OutputT>
-    void host_copy(const InputT* input_data, atlas::array::Array& output) {
-        auto size = output.size();
-        OutputT* output_data = output.host_data<OutputT>();
-        std::copy( input_data, input_data + size, output_data );
-    }
-
-    template<typename InputT, typename OutputT>
-    void host_copy(const atlas::array::Array& input, atlas::array::Array& output) {
-        host_copy<InputT,OutputT>( input.host_data<InputT>(), output );
-    }
-
-public:
-    virtual ~SparseMatrixConvertor() = default;
-
-    SparseMatrixConvertor() = default;
-
-    explicit SparseMatrixConvertor(eckit::linalg::SparseMatrix&& m) {
-        nnz_   = m.nonZeros();
-        rows_  = m.rows();
-        cols_  = m.cols();
-
-        if constexpr(std::is_same_v<index_type, eckit::linalg::Index> && std::is_same_v<value_type, eckit::linalg::Scalar>) {
-            outer_.reset(atlas::array::Array::wrap(const_cast<eckit::linalg::Index*>(m.outer()), atlas::array::make_shape(rows_+1)));
-            inner_.reset(atlas::array::Array::wrap(const_cast<eckit::linalg::Index*>(m.inner()), atlas::array::make_shape(nnz_)));
-            value_.reset(atlas::array::Array::wrap(const_cast<eckit::linalg::Scalar*>(m.data()), atlas::array::make_shape(nnz_)));
-
-            // We now move the eckit::linalg::SparseMatrix into a generic storage so
-            //   the wrapped array data does not go out of scope
-            storage_ = std::make_any<eckit::linalg::SparseMatrix>(std::move(m));
-        }
-        else {
-            outer_.reset(atlas::array::Array::create<index_type>(rows_+1));
-            inner_.reset(atlas::array::Array::create<index_type>(nnz_));
-            value_.reset(atlas::array::Array::create<value_type>(nnz_));
-            host_copy<eckit::linalg::Index, index_type>(m.outer(), *outer_);
-            host_copy<eckit::linalg::Index, index_type>(m.inner(), *inner_);
-            host_copy<eckit::linalg::Scalar,value_type>(m.data(),  *value_);
-        }
-    }
-
-
-    /// Create copy of eckit::linalg::SparseMatrix
-    explicit SparseMatrixConvertor(const eckit::linalg::SparseMatrix& other) {
-        nnz_   = other.nonZeros();
-        rows_  = other.rows();
-        cols_  = other.cols();
-        outer_.reset(atlas::array::Array::create<index_type>(rows_+1));
-        inner_.reset(atlas::array::Array::create<index_type>(nnz_));
-        value_.reset(atlas::array::Array::create<value_type>(nnz_));
-        host_copy<eckit::linalg::Index, index_type>(other.outer(), *outer_);
-        host_copy<eckit::linalg::Index, index_type>(other.inner(), *inner_);
-        host_copy<eckit::linalg::Scalar,value_type>(other.data(),  *value_);
-    }
-
-
-    template <typename ValueT, typename IndexT>
-    SparseMatrixConvertor(const SparseMatrixConvertor<ValueT,IndexT>& other) {
-        nnz_   = other.nnz();
-        rows_  = other.rows();
-        cols_  = other.cols();
-        outer_.reset(atlas::array::Array::create<index_type>(rows_+1));
-        inner_.reset(atlas::array::Array::create<index_type>(nnz_));
-        value_.reset(atlas::array::Array::create<value_type>(nnz_));
-        host_copy<IndexT,index_type>(other.outer(), *outer_);
-        host_copy<IndexT,index_type>(other.inner(), *inner_);
-        host_copy<ValueT,value_type>(other.value(), *value_);
-    }
-
-    SparseMatrixConvertor(SparseMatrixConvertor&& other) {
-        nnz_   = other.nnz_;
-        rows_  = other.rows_;
-        cols_  = other.cols_;
-        outer_ = std::move(other.outer_);
-        inner_ = std::move(other.inner_);
-        value_ = std::move(other.value_);
-        other.nnz_ = 0;
-        other.rows_ = 0;
-        other.cols_ = 0;
-        storage_ = std::move(other.storage_);
-    }
-
-#if ATLAS_HAVE_EIGEN
-    template <typename ValueT, typename IndexT>
-    SparseMatrixConvertor(const Eigen::SparseMatrix<ValueT, Eigen::RowMajor, IndexT>& m) {
-        nnz_   = m.nonZeros();
-        rows_  = m.rows();
-        cols_  = m.cols();
-        outer_.reset(atlas::array::Array::create<Index>(rows_+1));
-        inner_.reset(atlas::array::Array::create<Index>(nnz_));
-        value_.reset(atlas::array::Array::create<Value>(nnz_));
-        host_copy<IndexT,index_type>(m.outerIndexPtr(), *outer_);
-        host_copy<IndexT,index_type>(m.innerIndexPtr(), *inner_);
-        host_copy<ValueT,value_type>(m.valuePtr(),      *value_);
-    }
-
-    template <typename ValueT, typename IndexT>
-    SparseMatrixConvertor(Eigen::SparseMatrix<ValueT, Eigen::RowMajor, IndexT>&& m) {
-        nnz_   = m.nonZeros();
-        rows_  = m.rows();
-        cols_  = m.cols();
-
-        if constexpr(std::is_same_v<std::decay_t<index_type>, std::decay_t<IndexT>> && std::is_same_v<std::decay_t<value_type>, std::decay_t<ValueT>>) {
-
-            outer_.reset(atlas::array::Array::wrap(const_cast<index_type*>(m.outerIndexPtr()), atlas::array::make_shape(rows_+1)));
-            inner_.reset(atlas::array::Array::wrap(const_cast<index_type*>(m.innerIndexPtr()), atlas::array::make_shape(nnz_)));
-            value_.reset(atlas::array::Array::wrap(const_cast<value_type*>(m.valuePtr()),      atlas::array::make_shape(nnz_)));
-
-            // We now move the eckit::linalg::SparseMatrix into a generic storage so
-            //   the wrapped array data does not go out of scope
-            //   Note: Eigen move constructor only available since 3.5; use swap instead.
-            using EigenMatrix = Eigen::SparseMatrix<ValueT, Eigen::RowMajor, IndexT>;
-            auto m_ptr = std::make_shared<EigenMatrix>();
-            m_ptr->swap(m);
-            storage_ = std::make_any<std::shared_ptr<EigenMatrix>>(std::move(m_ptr));
-        }
-        else {
-            outer_.reset(atlas::array::Array::create<index_type>(rows_+1));
-            inner_.reset(atlas::array::Array::create<index_type>(nnz_));
-            value_.reset(atlas::array::Array::create<value_type>(nnz_));
-            host_copy<IndexT, index_type>(m.outerIndexPtr(), *outer_);
-            host_copy<IndexT, index_type>(m.innerIndexPtr(), *inner_);
-            host_copy<ValueT, value_type>(m.valuePtr(),      *value_);
-        }
-    }
-#endif
-
-};
-
-//----------------------------------------------------------------------------------------------------------------------
-
-}  // namespace linalg
-}  // namespace atlas
\ No newline at end of file
diff --git a/src/atlas/linalg/sparse/SparseMatrixStorage.cc b/src/atlas/linalg/sparse/SparseMatrixStorage.cc
index c3634570e..2e956558a 100644
--- a/src/atlas/linalg/sparse/SparseMatrixStorage.cc
+++ b/src/atlas/linalg/sparse/SparseMatrixStorage.cc
@@ -40,32 +40,6 @@ SparseMatrixStorage::SparseMatrixStorage(const SparseMatrixStorage& other) {
     value_->copy(*other.value_);
 }
 
-SparseMatrixStorage::SparseMatrixStorage(eckit::linalg::SparseMatrix&& m) {
-    nnz_   = m.nonZeros();
-    rows_  = m.rows();
-    cols_  = m.cols();
-    outer_.reset(atlas::array::Array::wrap(const_cast<eckit::linalg::Index*>(m.outer()), atlas::array::make_shape(rows_+1)));
-    inner_.reset(atlas::array::Array::wrap(const_cast<eckit::linalg::Index*>(m.inner()), atlas::array::make_shape(nnz_)));
-    value_.reset(atlas::array::Array::wrap(const_cast<eckit::linalg::Scalar*>(m.data()), atlas::array::make_shape(nnz_)));
-
-    // We now move the eckit::linalg::SparseMatrix into a generic storage so
-    //   the wrapped array data does not go out of scope
-    storage_ = std::make_any<eckit::linalg::SparseMatrix>(std::move(m));
-}
-
-/// Create copy of eckit::linalg::SparseMatrix
-SparseMatrixStorage::SparseMatrixStorage(const eckit::linalg::SparseMatrix& other) {
-    nnz_   = other.nonZeros();
-    rows_  = other.rows();
-    cols_  = other.cols();
-    outer_.reset(atlas::array::Array::create<eckit::linalg::Index>(rows_+1));
-    inner_.reset(atlas::array::Array::create<eckit::linalg::Index>(nnz_));
-    value_.reset(atlas::array::Array::create<eckit::linalg::Scalar>(nnz_));
-    host_copy(other.outer(), *outer_);
-    host_copy(other.inner(), *inner_);
-    host_copy(other.data(),  *value_);
-}
-
 SparseMatrixStorage& SparseMatrixStorage::operator=(SparseMatrixStorage&& other) {
     nnz_     = other.nnz_;
     rows_    = other.rows_;
diff --git a/src/atlas/linalg/sparse/SparseMatrixStorage.h b/src/atlas/linalg/sparse/SparseMatrixStorage.h
index 73157eaad..624c09664 100644
--- a/src/atlas/linalg/sparse/SparseMatrixStorage.h
+++ b/src/atlas/linalg/sparse/SparseMatrixStorage.h
@@ -13,11 +13,8 @@
 #include <algorithm>
 #include <any>
 #include <memory>
+#include <utility>
 
-#include "atlas/library/defines.h"
-#if ATLAS_HAVE_EIGEN
-#include <Eigen/Sparse>
-#endif
 #include "eckit/linalg/SparseMatrix.h"
 
 #include "atlas/array.h"
@@ -39,31 +36,31 @@ namespace linalg {
 ///
 /// To construct it, taking ownership of a constructed Eigen::SparseMatrix
 ///
-///     SparseMatrixStorage s {std::move(eigen_matrix)};
+///     SparseMatrixStorage s = make_sparse_matrix_storage(std::move(eigen_matrix));
 ///
 /// To construct it, taking a copy of a constructed Eigen::SparseMatrix
 ///
-///     SparseMatrixStorage s {eigen_matrix};
+///     SparseMatrixStorage s = make_sparse_matrix_storage(eigen_matrix);
 ///
 /// To construct it, taking ownership of a constructed eckit::linalg::SparseMatrix, avoiding copies if data types match
 ///
-///     SparseMatrixStorage s {std::move(eckit_matrix)};
+///     SparseMatrixStorage s = make_sparse_matrix_storage(std::move(eckit_matrix));
 ///
 ///
 /// To construct it, taking a copy of a constructed eckit::linalg::SparseMatrix (no std::move)
 ///
-///     SparseMatrixStorage s {eckit_matrix};
+///     SparseMatrixStorage s = make_sparse_matrix_storage(eckit_matrix);
 ///
 ///
 /// It is also possible to initialise empty and move into it at later stage:
 ///
 ///     SparseMatrixStorage s;
-///     s = SparseMatrixStorage{eckit_matrix};
+///     s = make_sparse_matrix_storage(eckit_matrix);
 ///
 ///
 /// To construct it, taking a single precision copy of a constructed eckit::linalg::SparseMatrix
 ///
-///     SparseMatrixStorage s {SparseMatrixConvertor<float>{eckit_matrix}};
+///     s = make_sparse_matrix_storage<float>(eckit_matrix);
 ///
 
 class SparseMatrixStorage {
@@ -85,20 +82,6 @@ class SparseMatrixStorage {
     template<typename Value, typename Index>
     SparseMatrixStorage(const SparseMatrixView<Value,Index>& host_view);
 
-    /// Move constructor from eckit::linalg::SparseMatrix, takes ownership!
-    explicit SparseMatrixStorage(eckit::linalg::SparseMatrix&& eckit_matrix);
-
-    /// Copy constructor from eckit::linalg::SparseMatrix, makes copy!
-    explicit SparseMatrixStorage(const eckit::linalg::SparseMatrix& eckit_matrix);
-
-    /// Move constructor from Eigen::SparseMatrix, takes ownership!
-    template<typename Value, typename Index>
-    explicit SparseMatrixStorage(Eigen::SparseMatrix<Value, Eigen::RowMajor, Index>&& eigen_matrix);
-
-    /// Copy constructor from Eigen::SparseMatrix, makes copy!
-    template<typename Value, typename Index>
-    explicit SparseMatrixStorage(const Eigen::SparseMatrix<Value, Eigen::RowMajor, Index>& eigen_matrix);
-
     /// Move assign from other SparseMatrixStorage, takes ownership!
     SparseMatrixStorage& operator=(SparseMatrixStorage&& other);
 
@@ -135,6 +118,47 @@ class SparseMatrixStorage {
     void allocateDevice() const;
 
     void deallocateDevice() const;
+
+    static SparseMatrixStorage make(
+        std::size_t rows,
+        std::size_t cols,
+        std::size_t nnz,
+        std::unique_ptr<atlas::array::Array>&& value,
+        std::unique_ptr<atlas::array::Array>&& inner,
+        std::unique_ptr<atlas::array::Array>&& outer,
+        std::any&& storage) {
+            SparseMatrixStorage S;
+            S.rows_    = rows;
+            S.cols_    = cols;
+            S.nnz_     = nnz;
+            S.outer_   = std::move(outer);
+            S.inner_   = std::move(inner);
+            S.value_   = std::move(value);
+            S.storage_ = std::move(storage);
+            return S;
+    }
+
+    void swap(SparseMatrixStorage& other) {
+        std::swap(other.rows_,    rows_);
+        std::swap(other.cols_,    cols_);
+        std::swap(other.nnz_,     nnz_);
+        std::swap(other.value_,   value_);
+        std::swap(other.inner_,   inner_);
+        std::swap(other.outer_,   outer_);
+        std::swap(other.storage_, storage_);
+    }
+
+    bool contains(DataType value_type, DataType index_type) {
+        if (empty()) {
+            return false;
+        }
+        return value_->datatype() == value_type && outer_->datatype() == index_type;
+    }
+
+    template <typename value_type, typename index_type>
+    bool contains() {
+        return contains(make_datatype<value_type>(), make_datatype<index_type>());
+    }
     
 protected:
     std::size_t nnz_{0};
@@ -175,40 +199,80 @@ SparseMatrixStorage::SparseMatrixStorage(const SparseMatrixView<Value,Index>& ho
 
 //----------------------------------------------------------------------------------------------------------------------
 
-#if ATLAS_HAVE_EIGEN
-template <typename Value, typename Index>
-SparseMatrixStorage::SparseMatrixStorage(Eigen::SparseMatrix<Value, Eigen::RowMajor, Index>&& m) {
-    nnz_   = m.nonZeros();
-    rows_  = m.rows();
-    cols_  = m.cols();
-
-    outer_.reset(atlas::array::Array::wrap(const_cast<Index*>(m.outerIndexPtr()), atlas::array::make_shape(rows_+1)));
-    inner_.reset(atlas::array::Array::wrap(const_cast<Index*>(m.innerIndexPtr()), atlas::array::make_shape(nnz_)));
-    value_.reset(atlas::array::Array::wrap(const_cast<Value*>(m.valuePtr()),      atlas::array::make_shape(nnz_)));
-
-    // We now move the eckit::linalg::SparseMatrix into a generic storage so
-    //   the wrapped array data does not go out of scope
-    //   Note: Eigen move constructor only available since 3.5; use swap instead.
-    using EigenMatrix = Eigen::SparseMatrix<Value, Eigen::RowMajor, Index>;
-    auto m_ptr = std::make_shared<EigenMatrix>();
-    m_ptr->swap(m);
-    storage_ = std::make_any<std::shared_ptr<EigenMatrix>>(std::move(m_ptr));
+namespace {
+template<typename OutputT, typename InputT>
+void host_copy(const InputT* input_data, array::Array& output) {
+    auto size = output.size();
+    OutputT* output_data = output.host_data<OutputT>();
+    std::copy( input_data, input_data + size, output_data );
 }
 
-template <typename Value, typename Index>
-SparseMatrixStorage::SparseMatrixStorage(const Eigen::SparseMatrix<Value, Eigen::RowMajor, Index>& m) {
-    nnz_   = m.nonZeros();
-    rows_  = m.rows();
-    cols_  = m.cols();
-
-    outer_.reset(atlas::array::Array::create<Index>(rows_+1));
-    inner_.reset(atlas::array::Array::create<Index>(nnz_));
-    value_.reset(atlas::array::Array::create<Value>(nnz_));
-    host_copy(m.outerIndexPtr(), *outer_);
-    host_copy(m.innerIndexPtr(), *inner_);
-    host_copy(m.valuePtr(),      *value_);
+template<typename InputT, typename OutputT>
+void host_copy(const array::Array& input, array::Array& output) {
+    host_copy<OutputT>( input.host_data<InputT>(), output );
+}
+
+template<typename OutputT>
+void host_copy(const array::Array& input, array::Array& output) {
+    switch(input.datatype().kind()) {
+        case DataType::kind<int>():           return host_copy<int,OutputT>( input, output );
+        case DataType::kind<long>():          return host_copy<long,OutputT>( input, output );
+        case DataType::kind<float>():         return host_copy<float,OutputT>( input, output );
+        case DataType::kind<double>():        return host_copy<double,OutputT>( input, output );
+        case DataType::kind<unsigned int>():  return host_copy<unsigned int,OutputT>( input, output );
+        case DataType::kind<unsigned long>(): return host_copy<unsigned long,OutputT>( input, output );
+        default:  ATLAS_NOTIMPLEMENTED;
+    }
+}
+void host_copy(const array::Array& input, array::Array& output) {
+    switch(output.datatype().kind()) {
+        case DataType::kind<int>():           return host_copy<int>( input, output );
+        case DataType::kind<long>():          return host_copy<long>( input, output );
+        case DataType::kind<float>():         return host_copy<float>( input, output );
+        case DataType::kind<double>():        return host_copy<double>( input, output );
+        case DataType::kind<unsigned int>():  return host_copy<unsigned int>( input, output );
+        case DataType::kind<unsigned long>(): return host_copy<unsigned long>( input, output );
+        default:  ATLAS_NOTIMPLEMENTED;
+    }
+}
+
+}
+
+template<typename value_type, typename index_type = eckit::linalg::Index>
+SparseMatrixStorage make_sparse_matrix_storage(const SparseMatrixStorage& other) {
+    auto rows  = other.rows();
+    auto cols  = other.cols();
+    auto nnz   = other.nnz();
+    std::unique_ptr<array::Array> value(array::Array::create<value_type>(nnz));
+    std::unique_ptr<array::Array> inner(array::Array::create<index_type>(nnz));
+    std::unique_ptr<array::Array> outer(array::Array::create<index_type>(rows+1));
+    host_copy<value_type>(other.value(), *value);
+    host_copy<index_type>(other.inner(), *inner);
+    host_copy<index_type>(other.outer(), *outer);
+    return SparseMatrixStorage::make(rows,cols,nnz,std::move(value), std::move(inner), std::move(outer), std::any());
+}
+
+template<typename value_type, typename index_type = eckit::linalg::Index>
+SparseMatrixStorage make_sparse_matrix_storage(SparseMatrixStorage&& other) {
+    SparseMatrixStorage S;
+
+    if (other.contains<value_type,index_type>()) {
+        S = std::move(other);
+    }
+    else {
+        auto rows  = other.rows();
+        auto cols  = other.cols();
+        auto nnz   = other.nnz();
+        std::unique_ptr<array::Array> value(array::Array::create<value_type>(nnz));
+        std::unique_ptr<array::Array> inner(array::Array::create<index_type>(nnz));
+        std::unique_ptr<array::Array> outer(array::Array::create<index_type>(rows+1));
+        host_copy<value_type>(other.value(), *value);
+        host_copy<index_type>(other.inner(), *inner);
+        host_copy<index_type>(other.outer(), *outer);
+        S = SparseMatrixStorage::make(rows,cols,nnz,std::move(value), std::move(inner), std::move(outer), std::any());
+    }
+    return S;
 }
-#endif
 
 //----------------------------------------------------------------------------------------------------------------------
 
diff --git a/src/tests/interpolation/test_interpolation_finite_element_cached.cc b/src/tests/interpolation/test_interpolation_finite_element_cached.cc
index 992e263a3..5d75a8dfd 100644
--- a/src/tests/interpolation/test_interpolation_finite_element_cached.cc
+++ b/src/tests/interpolation/test_interpolation_finite_element_cached.cc
@@ -114,7 +114,7 @@ CASE("extract cache, copy it, and move it for use") {
     EXPECT(not eckit_matrix_view.empty());
     EXPECT(not eckit_matrix_copy.empty());
 
-    auto cache = interpolation::MatrixCache(atlas::linalg::SparseMatrixStorage(std::move(eckit_matrix_copy)));
+    auto cache = interpolation::MatrixCache(atlas::linalg::make_sparse_matrix_storage(std::move(eckit_matrix_copy)));
 
     EXPECT(not eckit_matrix_view.empty()); // We didn't touch the view
     EXPECT(eckit_matrix_copy.empty());     // This has been moved into the new 'cache'
diff --git a/src/tests/linalg/test_linalg_sparse_matrix.cc b/src/tests/linalg/test_linalg_sparse_matrix.cc
index 85be4e2b6..f6c43645b 100644
--- a/src/tests/linalg/test_linalg_sparse_matrix.cc
+++ b/src/tests/linalg/test_linalg_sparse_matrix.cc
@@ -13,12 +13,11 @@
 
 #include "atlas/linalg/sparse/SparseMatrixStorage.h"
 #include "atlas/linalg/sparse/SparseMatrixView.h"
-#include "atlas/linalg/sparse/SparseMatrixConvertor.h"
-#include "atlas/linalg/sparse/SparseMatrixAdaptor.h"
+#include "atlas/linalg/sparse/MakeSparseMatrixStorageEigen.h"
+#include "atlas/linalg/sparse/MakeSparseMatrixStorageEckit.h"
 
 using atlas::linalg::SparseMatrixStorage;
-using atlas::linalg::SparseMatrixAdaptor;
-using atlas::linalg::SparseMatrixConvertor;
+using atlas::linalg::make_sparse_matrix_storage;
 
 namespace atlas {
 namespace test {
@@ -58,8 +57,8 @@ eckit::linalg::SparseMatrix create_eckit_sparsematrix() {
 }
 
 template <typename Value, typename Index = eckit::linalg::Index>
-SparseMatrixConvertor<Value,Index> create_sparsematrix_storage() {
-    return SparseMatrixConvertor<Value,Index>(create_eckit_sparsematrix());
+SparseMatrixStorage create_sparsematrix_storage() {
+    return make_sparse_matrix_storage<Value,Index>(create_eckit_sparsematrix());
 }
 
 template<typename Value>
@@ -134,33 +133,39 @@ void check_matrix(const SparseMatrixStorage& m) {
 }
 
 CASE("Create SparseMatrix moving eckit::linalg::SparseMatrix") {
-    SparseMatrixStorage S( create_eckit_sparsematrix() );
+    SparseMatrixStorage S = make_sparse_matrix_storage(create_eckit_sparsematrix());
+    EXPECT_NO_THROW(check_matrix(S));
+}
+
+CASE("Create SparseMatrix moving eckit::linalg::SparseMatrix using std::move") {
+    auto A = create_eckit_sparsematrix();
+    SparseMatrixStorage S = make_sparse_matrix_storage(std::move(A));
     EXPECT_NO_THROW(check_matrix(S));
 }
 
 CASE("Create SparseMatrix copying eckit::linalg::SparseMatrix") {
     auto A = create_eckit_sparsematrix();
-    SparseMatrixStorage S(A);
+    SparseMatrixStorage S = make_sparse_matrix_storage(A);
     EXPECT_NO_THROW(check_matrix(S));
 }
 
 CASE("Create single precision SparseMatrix copying from double precision SparseMatrix ") {
     auto Sdouble = create_sparsematrix_storage<double>();
-    SparseMatrixConvertor<float> S(Sdouble);
+    SparseMatrixStorage S = make_sparse_matrix_storage<float>(Sdouble);
     EXPECT_NO_THROW(check_matrix(S));
 }
 
 CASE("Create single precision SparseMatrix moving from double precision SparseMatrix which causes copy") {
-    SparseMatrixConvertor<float> S(create_sparsematrix_storage<double>());
+    SparseMatrixStorage S = make_sparse_matrix_storage<float>(create_sparsematrix_storage<double>());
     EXPECT_NO_THROW(check_matrix(S));
 }
 CASE("Create double precision SparseMatrix copying from single precision SparseMatrix ") {
     auto Sfloat = create_sparsematrix_storage<float>();
-    SparseMatrixConvertor<double> S(Sfloat);
+    SparseMatrixStorage S = make_sparse_matrix_storage<double>(Sfloat);
     EXPECT_NO_THROW(check_matrix(S));
 }
 CASE("Create double precision SparseMatrix moving from single precision SparseMatrix which causes copy") {
-    SparseMatrixConvertor<double> S(create_sparsematrix_storage<float>());
+    SparseMatrixStorage S = make_sparse_matrix_storage<double>(create_sparsematrix_storage<float>());
     EXPECT_NO_THROW(check_matrix(S));
 }
 CASE("Create base with copy constructor from double precision") {
@@ -183,69 +188,57 @@ CASE("Create base with move constructor from single precision") {
     EXPECT_NO_THROW(check_matrix(S));
 }
 
-CASE("Create SparseMatrix wrapping eckit::linalg::SparseMatrix") {
-    auto A = create_eckit_sparsematrix();
-    SparseMatrixStorage S = SparseMatrixAdaptor( A );
-    EXPECT_NO_THROW(check_matrix(S));
-}
-
-
 #if ATLAS_HAVE_EIGEN
 CASE("Copy from Eigen double") {
     auto eigen_matrix = create_eigen_sparsematrix<double>();
-    SparseMatrixStorage S(eigen_matrix);
+    SparseMatrixStorage S = make_sparse_matrix_storage(eigen_matrix);
     EXPECT_NO_THROW(check_matrix(S));
 }
 
 CASE("Move from Eigen double, avoiding copy") {
-    SparseMatrixStorage S(create_eigen_sparsematrix<double>());
+    SparseMatrixStorage S = make_sparse_matrix_storage(create_eigen_sparsematrix<double>());
     EXPECT_NO_THROW(check_matrix(S));
 }
 
 CASE("Copy and convert double from Eigen to single precision") {
     auto eigen_matrix = create_eigen_sparsematrix<double>();
-    SparseMatrixConvertor<float> S(eigen_matrix);
+    SparseMatrixStorage S = make_sparse_matrix_storage<float>(eigen_matrix);
     EXPECT_NO_THROW(check_matrix(S));
 }
 
 CASE("Move and convert double from Eigen to single precision, should cause copy") {
-    SparseMatrixConvertor<float> S(create_eigen_sparsematrix<double>());
+    SparseMatrixStorage S = make_sparse_matrix_storage<float>(create_eigen_sparsematrix<double>());
     EXPECT_NO_THROW(check_matrix(S));
 }
 
 CASE("Copy from Eigen single") {
     auto eigen_matrix = create_eigen_sparsematrix<float>();
-    SparseMatrixStorage S(eigen_matrix);
+    SparseMatrixStorage S = make_sparse_matrix_storage(eigen_matrix);
     EXPECT_NO_THROW(check_matrix(S));
 }
 
 CASE("Move from Eigen single, avoiding copy") {
-    SparseMatrixStorage S(create_eigen_sparsematrix<float>());
+    SparseMatrixStorage S = make_sparse_matrix_storage(create_eigen_sparsematrix<float>());
     EXPECT_NO_THROW(check_matrix(S));
 }
 
 CASE("Copy and convert single from Eigen to double precision") {
     auto eigen_matrix = create_eigen_sparsematrix<float>();
-    SparseMatrixConvertor<double> S(eigen_matrix);
+    SparseMatrixStorage S = make_sparse_matrix_storage<double>(eigen_matrix);
     EXPECT_NO_THROW(check_matrix(S));
 }
 
 CASE("Move and convert single from Eigen to double precision, should cause copy") {
-    SparseMatrixConvertor<double> S(create_eigen_sparsematrix<float>());
+    SparseMatrixStorage S = make_sparse_matrix_storage<double>(create_eigen_sparsematrix<float>());
     EXPECT_NO_THROW(check_matrix(S));
 }
 
 CASE("Create chain of moves from eigen double") {
-    SparseMatrixStorage S( SparseMatrixConvertor<double>( create_eigen_sparsematrix<double>() ) );
+    SparseMatrixStorage S = make_sparse_matrix_storage<double>(create_eigen_sparsematrix<double>());
     EXPECT_NO_THROW(check_matrix(S));
 }
 CASE("Create chain of moves from eigen single") {
-    SparseMatrixStorage S( SparseMatrixConvertor<float>( create_eigen_sparsematrix<float>() ) );
-    EXPECT_NO_THROW(check_matrix(S));
-}
-CASE("Create SparseMatrix wrapping Eigen matrix: no copy, no move") {
-    auto A = create_eigen_sparsematrix<float>();
-    SparseMatrixStorage S = SparseMatrixAdaptor( A );
+    SparseMatrixStorage S = make_sparse_matrix_storage<float>(create_eigen_sparsematrix<float>());
     EXPECT_NO_THROW(check_matrix(S));
 }
 #endif
diff --git a/src/tests/linalg/test_linalg_sparse_matrix_gpu.cc b/src/tests/linalg/test_linalg_sparse_matrix_gpu.cc
index 8b804d4ea..5bb2da54d 100644
--- a/src/tests/linalg/test_linalg_sparse_matrix_gpu.cc
+++ b/src/tests/linalg/test_linalg_sparse_matrix_gpu.cc
@@ -18,12 +18,11 @@
 
 #include "atlas/linalg/sparse/SparseMatrixStorage.h"
 #include "atlas/linalg/sparse/SparseMatrixView.h"
-#include "atlas/linalg/sparse/SparseMatrixConvertor.h"
-#include "atlas/linalg/sparse/SparseMatrixAdaptor.h"
+#include "atlas/linalg/sparse/MakeSparseMatrixStorageEigen.h"
+#include "atlas/linalg/sparse/MakeSparseMatrixStorageEckit.h"
 
 using atlas::linalg::SparseMatrixStorage;
-using atlas::linalg::SparseMatrixAdaptor;
-using atlas::linalg::SparseMatrixConvertor;
+using atlas::linalg::make_sparse_matrix_storage;
 using atlas::linalg::make_host_view;
 using atlas::linalg::make_device_view;
 
@@ -149,8 +148,8 @@ eckit::linalg::SparseMatrix create_eckit_sparsematrix() {
 }
 
 template <typename Value, typename Index = eckit::linalg::Index>
-SparseMatrixConvertor<Value,Index> create_sparsematrix_storage() {
-    return SparseMatrixConvertor<Value,Index>(create_eckit_sparsematrix());
+SparseMatrixStorage create_sparsematrix_storage() {
+    return make_sparse_matrix_storage<Value,Index>(create_eckit_sparsematrix());
 }
 
 template<typename Value>
@@ -240,33 +239,39 @@ void check_matrix(const SparseMatrixStorage& m) {
 }
 
 CASE("Create SparseMatrix moving eckit::linalg::SparseMatrix") {
-    SparseMatrixStorage S( create_eckit_sparsematrix() );
+    SparseMatrixStorage S = make_sparse_matrix_storage(create_eckit_sparsematrix());
+    EXPECT_NO_THROW(check_matrix(S));
+}
+
+CASE("Create SparseMatrix moving eckit::linalg::SparseMatrix using std::move") {
+    auto A = create_eckit_sparsematrix();
+    SparseMatrixStorage S = make_sparse_matrix_storage(std::move(A));
     EXPECT_NO_THROW(check_matrix(S));
 }
 
 CASE("Create SparseMatrix copying eckit::linalg::SparseMatrix") {
     auto A = create_eckit_sparsematrix();
-    SparseMatrixStorage S(A);
+    SparseMatrixStorage S = make_sparse_matrix_storage(A);
     EXPECT_NO_THROW(check_matrix(S));
 }
 
 CASE("Create single precision SparseMatrix copying from double precision SparseMatrix ") {
     auto Sdouble = create_sparsematrix_storage<double>();
-    SparseMatrixConvertor<float> S(Sdouble);
+    SparseMatrixStorage S = make_sparse_matrix_storage<float>(Sdouble);
     EXPECT_NO_THROW(check_matrix(S));
 }
 
 CASE("Create single precision SparseMatrix moving from double precision SparseMatrix which causes copy") {
-    SparseMatrixConvertor<float> S(create_sparsematrix_storage<double>());
+    SparseMatrixStorage S = make_sparse_matrix_storage<float>(create_sparsematrix_storage<double>());
     EXPECT_NO_THROW(check_matrix(S));
 }
 CASE("Create double precision SparseMatrix copying from single precision SparseMatrix ") {
     auto Sfloat = create_sparsematrix_storage<float>();
-    SparseMatrixConvertor<double> S(Sfloat);
+    SparseMatrixStorage S = make_sparse_matrix_storage<double>(Sfloat);
     EXPECT_NO_THROW(check_matrix(S));
 }
 CASE("Create double precision SparseMatrix moving from single precision SparseMatrix which causes copy") {
-    SparseMatrixConvertor<double> S(create_sparsematrix_storage<float>());
+    SparseMatrixStorage S = make_sparse_matrix_storage<double>(create_sparsematrix_storage<float>());
     EXPECT_NO_THROW(check_matrix(S));
 }
 CASE("Create base with copy constructor from double precision") {
@@ -289,71 +294,60 @@ CASE("Create base with move constructor from single precision") {
     EXPECT_NO_THROW(check_matrix(S));
 }
 
-CASE("Create SparseMatrix wrapping eckit::linalg::SparseMatrix, no move, no copy") {
-    auto A = create_eckit_sparsematrix();
-    SparseMatrixStorage S = SparseMatrixAdaptor( A );
-    EXPECT_NO_THROW(check_matrix(S));
-}
-
-
 #if ATLAS_HAVE_EIGEN
 CASE("Copy from Eigen double") {
     auto eigen_matrix = create_eigen_sparsematrix<double>();
-    SparseMatrixConvertor<double> S(eigen_matrix);
+    SparseMatrixStorage S = make_sparse_matrix_storage(eigen_matrix);
     EXPECT_NO_THROW(check_matrix(S));
 }
 
 CASE("Move from Eigen double, avoiding copy") {
-    SparseMatrixConvertor<double> S(create_eigen_sparsematrix<double>());
+    SparseMatrixStorage S = make_sparse_matrix_storage(create_eigen_sparsematrix<double>());
     EXPECT_NO_THROW(check_matrix(S));
 }
 
 CASE("Copy and convert double from Eigen to single precision") {
     auto eigen_matrix = create_eigen_sparsematrix<double>();
-    SparseMatrixConvertor<float> S(eigen_matrix);
+    SparseMatrixStorage S = make_sparse_matrix_storage<float>(eigen_matrix);
     EXPECT_NO_THROW(check_matrix(S));
 }
 
 CASE("Move and convert double from Eigen to single precision, should cause copy") {
-    SparseMatrixConvertor<float> S(create_eigen_sparsematrix<double>());
+    SparseMatrixStorage S = make_sparse_matrix_storage<float>(create_eigen_sparsematrix<double>());
     EXPECT_NO_THROW(check_matrix(S));
 }
 
 CASE("Copy from Eigen single") {
     auto eigen_matrix = create_eigen_sparsematrix<float>();
-    SparseMatrixConvertor<float> S(eigen_matrix);
+    SparseMatrixStorage S = make_sparse_matrix_storage(eigen_matrix);
     EXPECT_NO_THROW(check_matrix(S));
 }
 
 CASE("Move from Eigen single, avoiding copy") {
-    SparseMatrixConvertor<float> S(create_eigen_sparsematrix<float>());
+    SparseMatrixStorage S = make_sparse_matrix_storage(create_eigen_sparsematrix<float>());
     EXPECT_NO_THROW(check_matrix(S));
 }
 
 CASE("Copy and convert single from Eigen to double precision") {
     auto eigen_matrix = create_eigen_sparsematrix<float>();
-    SparseMatrixConvertor<double> S(eigen_matrix);
+    SparseMatrixStorage S = make_sparse_matrix_storage<double>(eigen_matrix);
     EXPECT_NO_THROW(check_matrix(S));
 }
 
 CASE("Move and convert single from Eigen to double precision, should cause copy") {
-    SparseMatrixConvertor<double> S(create_eigen_sparsematrix<float>());
+    SparseMatrixStorage S = make_sparse_matrix_storage<double>(create_eigen_sparsematrix<float>());
     EXPECT_NO_THROW(check_matrix(S));
 }
 
 CASE("Create chain of moves from eigen double") {
-    SparseMatrixStorage S( SparseMatrixConvertor<double>( create_eigen_sparsematrix<double>() ) );
+    SparseMatrixStorage S = make_sparse_matrix_storage<double>(create_eigen_sparsematrix<double>());
     EXPECT_NO_THROW(check_matrix(S));
 }
 CASE("Create chain of moves from eigen single") {
-    SparseMatrixStorage S( SparseMatrixConvertor<float>( create_eigen_sparsematrix<float>() ) );
-    EXPECT_NO_THROW(check_matrix(S));
-}
-CASE("Create SparseMatrix wrapping Eigen matrix") {
-    auto A = create_eigen_sparsematrix<float>();
-    SparseMatrixStorage S = SparseMatrixAdaptor( A );
+    SparseMatrixStorage S = make_sparse_matrix_storage<float>(create_eigen_sparsematrix<float>());
     EXPECT_NO_THROW(check_matrix(S));
 }
+
 #endif
 
 CASE("Test exceptions in make_host_view") {