diff --git a/.travis.yml b/.travis.yml
index 7321634ac..89b3b0f1f 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -8,8 +8,10 @@ os:
   - linux
 
 env:
-    - VERSION=8
-    - VERSION=7
+    - VERSION=8 EXTERNAL_GINKGO=OFF
+    - VERSION=8 EXTERNAL_GINKGO=ON
+    - VERSION=7 EXTERNAL_GINKGO=OFF
+    - VERSION=7 EXTERNAL_GINKGO=ON
 
 cache:
   directories:
@@ -33,12 +35,13 @@ before_install:
 install:
   - sudo apt-get -y install openfoam$VERSION
   - source /opt/openfoam$VERSION/etc/bashrc
+  - ./scripts/travis_install_external_ginkgo.sh
 
 before_script:
-  - cmake --version
+  - cmake --version 
   - mkdir build
   - cd build
-  - cmake ..
+  - cmake -DOGL_USE_EXTERNAL_GINKGO=$EXTERNAL_GINKGO ..
 
 script:
   - make -j4
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 059916a1d..8babb3cc7 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -92,6 +92,11 @@ add_compile_definitions(
 
 target_sources(OGL
   PRIVATE
+common/common.C
+IOHandler/IOPtr/IOPtr.C
+IOHandler/IOSortingIdxHandler/IOSortingIdxHandler.C
+IOHandler/IOExecutorHandler/IOExecutorHandler.C
+IOHandler/IOGKOMatrixHandler/IOGKOMatrixHandler.C
 lduMatrix/GKOlduBase/GKOlduBase.C
 lduMatrix/GKOCG/GKOCG.C
 lduMatrix/GKOIR/GKOIR.C
@@ -99,6 +104,11 @@ lduMatrix/GKOBiCGStab/GKOBiCGStab.C
 LduMatrix/GKOLduBase/GKOLduBase.C
 LduMatrix/GKOACG/GKOACG.C
   PUBLIC
+common/common.H
+IOHandler/IOPtr/IOPtr.H
+IOHandler/IOSortingIdxHandler/IOSortingIdxHandler.H
+IOHandler/IOExecutorHandler/IOExecutorHandler.H
+IOHandler/IOGKOMatrixHandler/IOGKOMatrixHandler.H
 lduMatrix/GKOlduBase/GKOlduBase.H
 lduMatrix/GKOCG/GKOCG.H
 lduMatrix/GKOIR/GKOIR.H
@@ -110,13 +120,17 @@ LduMatrix/GKOACG/GKOACG.H
 
 target_include_directories(OGL
   PUBLIC
-  $ENV{FOAM_SRC}/OpenFOAM/lnInclude
-  $ENV{FOAM_SRC}/meshTools/lnInclude
   $ENV{FOAM_SRC}/finiteVolume/lnInclude
+  $ENV{FOAM_SRC}/meshTools/lnInclude
+  $ENV{FOAM_SRC}/OpenFOAM/lnInclude
   $ENV{FOAM_SRC}/OSspecific/POSIX/lnInclude
-    common/
-    lduMatrix/GKOlduBase
-    LduMatrix/GKOLduBase
+  common/
+  IOHandler/IOPtr
+  IOHandler/IOExecutorHandler/
+  IOHandler/IOSortingIdxHandler/
+  IOHandler/IOGKOMatrixHandler/
+  lduMatrix/GKOlduBase
+  LduMatrix/GKOLduBase
   )
 
 
diff --git a/IOHandler/IOExecutorHandler/IOExecutorHandler.C b/IOHandler/IOExecutorHandler/IOExecutorHandler.C
new file mode 100644
index 000000000..3f0b225bc
--- /dev/null
+++ b/IOHandler/IOExecutorHandler/IOExecutorHandler.C
@@ -0,0 +1,82 @@
+
+#include <ginkgo/ginkgo.hpp>
+#include <type_traits>
+
+#include "IOExecutorHandler.H"
+
+namespace Foam {
+
+IOExecutorHandler::IOExecutorHandler(const objectRegistry &db,
+                                     const dictionary &controlDict)
+    : device_executor_name_(
+          controlDict.lookupOrDefault("executor", word("reference"))),
+      app_executor_name_(
+          controlDict.lookupOrDefault("app_executor", word("reference")))
+{
+    // create executors
+    bool app_exec_stored = db.foundObject<regIOobject>(app_executor_name_);
+
+    if (app_exec_stored) {
+        ref_exec_ptr_ =
+            &db.lookupObjectRef<GKOReferenceExecPtr>(app_executor_name_);
+        if (device_executor_name_ == app_executor_name_) {
+            return;
+        }
+    }
+
+
+    bool device_exec_stored =
+        db.foundObject<regIOobject>(device_executor_name_);
+    if (device_exec_stored) {
+        if (device_executor_name_ == "omp") {
+            omp_exec_ptr_ =
+                &db.lookupObjectRef<GKOOmpExecPtr>(device_executor_name_);
+            return;
+        }
+        if (device_executor_name_ == "cuda") {
+            cuda_exec_ptr_ =
+                &db.lookupObjectRef<GKOCudaExecPtr>(device_executor_name_);
+            return;
+        }
+        if (device_executor_name_ == "hip") {
+            hip_exec_ptr_ =
+                &db.lookupObjectRef<GKOHipExecPtr>(device_executor_name_);
+            return;
+        }
+    }
+
+    const fileName app_exec_store = app_executor_name_;
+    ref_exec_ptr_ =
+        new GKOReferenceExecPtr(IOobject(app_exec_store, db),
+                                gko::give(gko::ReferenceExecutor::create()));
+
+    const fileName device_exec_store = device_executor_name_;
+    const fileName omp_exec_store = "omp";
+    omp_exec_ptr_ = new GKOOmpExecPtr(IOobject(omp_exec_store, db),
+                                      gko::OmpExecutor::create());
+
+    if (device_executor_name_ == "cuda") {
+        cuda_exec_ptr_ =
+            new GKOCudaExecPtr(IOobject(device_exec_store, db),
+                               gko::give(gko::CudaExecutor::create(
+                                   0, omp_exec_ptr_->get_ptr(), true)));
+    }
+    if (device_executor_name_ == "hip") {
+        hip_exec_ptr_ =
+            new GKOHipExecPtr(IOobject(device_exec_store, db),
+                              gko::give(gko::HipExecutor::create(
+                                  0, omp_exec_ptr_->get_ptr(), true)));
+    }
+    if (device_executor_name_ == "omp") {
+        omp_exec_ptr_ = new GKOOmpExecPtr(IOobject(device_exec_store, db),
+                                          omp_exec_ptr_->get_ptr());
+    }
+}
+
+defineTemplateTypeNameWithName(GKOExecPtr, "ExecIOPtr");
+defineTemplateTypeNameWithName(GKOCudaExecPtr, "CudaExecIOPtr");
+defineTemplateTypeNameWithName(GKOOmpExecPtr, "OmpExecIOPtr");
+defineTemplateTypeNameWithName(GKOHipExecPtr, "HipExecIOPtr");
+defineTemplateTypeNameWithName(GKOReferenceExecPtr, "ReferenceExecIOPtr");
+
+}  // namespace Foam
diff --git a/IOHandler/IOExecutorHandler/IOExecutorHandler.H b/IOHandler/IOExecutorHandler/IOExecutorHandler.H
new file mode 100644
index 000000000..6a4b45a9d
--- /dev/null
+++ b/IOHandler/IOExecutorHandler/IOExecutorHandler.H
@@ -0,0 +1,110 @@
+/*---------------------------------------------------------------------------*\
+License
+    This file is part of OGL.
+
+    OGL is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OGL.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::IOExecutorHandler
+
+Author: Gregor Olenik <go@hpsim.de>
+
+SourceFiles
+    IOExecutorHandler.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef OGL_IOExecutorHandler_INCLUDED_H
+#define OGL_IOExecutorHandler_INCLUDED_H
+
+#include "../IOPtr/IOPtr.H"
+#include "fvCFD.H"
+#include "regIOobject.H"
+
+#include <ginkgo/ginkgo.hpp>
+
+namespace Foam {
+
+using vec = gko::matrix::Dense<scalar>;
+using mtx = gko::matrix::Coo<scalar>;
+
+
+class IOExecutorHandler {
+private:
+    const word device_executor_name_;
+
+    const word app_executor_name_;
+
+    // executor where Ginkgo will perform the computation
+    GKOExecPtr *device_exec_ptr_;
+
+    // executor of the application
+    GKOExecPtr *app_exec_ptr_;
+
+    GKOReferenceExecPtr *ref_exec_ptr_;
+
+    GKOCudaExecPtr *cuda_exec_ptr_;
+
+    GKOOmpExecPtr *omp_exec_ptr_;
+
+    GKOHipExecPtr *hip_exec_ptr_;
+
+public:
+    IOExecutorHandler(const objectRegistry &db, const dictionary &controlDict);
+
+    word get_device_executor_name() const { return device_executor_name_; }
+
+    std::shared_ptr<gko::Executor> get_device_executor() const
+    {
+        const word device_executor_name{get_device_executor_name()};
+        if (device_executor_name == "omp") {
+            return omp_exec();
+        }
+        if (device_executor_name == "cuda") {
+            return cuda_exec();
+        }
+        if (device_executor_name == "hip") {
+            return hip_exec();
+        }
+        return ref_exec();
+    };
+
+    std::shared_ptr<gko::Executor> app_exec() const
+    {
+        return app_exec_ptr_->get_ptr();
+    };
+
+    std::shared_ptr<gko::OmpExecutor> omp_exec() const
+    {
+        return omp_exec_ptr_->get_ptr();
+    };
+
+    std::shared_ptr<gko::CudaExecutor> cuda_exec() const
+    {
+        return cuda_exec_ptr_->get_ptr();
+    };
+
+    std::shared_ptr<gko::HipExecutor> hip_exec() const
+    {
+        return hip_exec_ptr_->get_ptr();
+    };
+
+    std::shared_ptr<gko::ReferenceExecutor> ref_exec() const
+    {
+        return ref_exec_ptr_->get_ptr();
+    };
+};
+
+}  // namespace Foam
+#endif
diff --git a/IOHandler/IOGKOMatrixHandler/IOGKOMatrixHandler.C b/IOHandler/IOGKOMatrixHandler/IOGKOMatrixHandler.C
new file mode 100644
index 000000000..cd25a3800
--- /dev/null
+++ b/IOHandler/IOGKOMatrixHandler/IOGKOMatrixHandler.C
@@ -0,0 +1,97 @@
+/*---------------------------------------------------------------------------*\
+License
+    This file is part of OGL.
+
+    OGL is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OGL.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::GKOCG
+
+Author: Gregor Olenik <go@hpsim.de>
+
+SourceFiles
+    GKOCG.C
+
+\*---------------------------------------------------------------------------*/
+#include <ginkgo/ginkgo.hpp>
+#include "IOGKOMatrixHandler.H"
+
+namespace Foam {
+
+void IOGKOMatrixHandler::init_device_matrix(
+    const objectRegistry &db, std::vector<scalar> &values_host,
+    std::vector<label> &col_idxs_host, std::vector<label> &row_idxs_host,
+    const label nElems, const label nCells, const bool store) const
+{
+    std::shared_ptr<gko::Executor> device_exec = get_device_executor();
+
+    if (sys_matrix_stored_) {
+        gkomatrix_ptr_ = &db.lookupObjectRef<GKOCOOIOPtr>(sys_matrix_name_);
+        return;
+    }
+
+    std::shared_ptr<idx_array> col_idx;
+    std::shared_ptr<idx_array> row_idx;
+    if (sparsity_pattern_stored_) {
+        io_col_idxs_ptr_ =
+            &db.lookupObjectRef<GKOIDXIOPtr>(sparsity_pattern_name_cols_);
+        io_row_idxs_ptr_ =
+            &db.lookupObjectRef<GKOIDXIOPtr>(sparsity_pattern_name_rows_);
+        col_idx = io_col_idxs_ptr_->get_ptr();
+        row_idx = io_row_idxs_ptr_->get_ptr();
+    } else {
+        // if not stored yet create sparsity pattern from correspondent
+        // views
+        auto col_idx_view = idx_array::view(gko::ReferenceExecutor::create(),
+                                            nElems, &col_idxs_host[0]);
+        auto row_idx_view = idx_array::view(gko::ReferenceExecutor::create(),
+                                            nElems, &row_idxs_host[0]);
+
+        // copy sparsity pattern to device and leave it there
+        col_idx = std::make_shared<idx_array>(col_idx_view);
+        col_idx->set_executor(device_exec);
+        row_idx = std::make_shared<idx_array>(row_idx_view);
+        row_idx->set_executor(device_exec);
+    }
+
+    // if system matrix is not stored create it and set shared pointer
+    auto gkomatrix =
+        gko::share(mtx::create(device_exec, gko::dim<2>(nCells, nCells),
+                               val_array::view(gko::ReferenceExecutor::create(),
+                                               nElems, &values_host[0]),
+                               *col_idx.get(), *row_idx.get()));
+
+    // if updating system matrix is not needed store ptr in obj registry
+    if (store) {
+        const fileName path = sys_matrix_name_;
+        gkomatrix_ptr_ = new GKOCOOIOPtr(IOobject(path, db), gkomatrix);
+    } else {
+        gkomatrix_ptr_ = NULL;
+        gkomatrix_ = gkomatrix;
+    }
+
+
+    // in any case store sparsity pattern
+    const fileName path_col = sparsity_pattern_name_cols_;
+    const fileName path_row = sparsity_pattern_name_rows_;
+    io_col_idxs_ptr_ = new GKOIDXIOPtr(IOobject(path_col, db), col_idx);
+    io_row_idxs_ptr_ = new GKOIDXIOPtr(IOobject(path_row, db), row_idx);
+};
+
+
+defineTemplateTypeNameWithName(GKOIDXIOPtr, "IDXIOPtr");
+defineTemplateTypeNameWithName(GKOCOOIOPtr, "COOIOPtr");
+defineTemplateTypeNameWithName(GKOVECIOPtr, "VECIOPtr");
+
+}  // namespace Foam
diff --git a/IOHandler/IOGKOMatrixHandler/IOGKOMatrixHandler.H b/IOHandler/IOGKOMatrixHandler/IOGKOMatrixHandler.H
new file mode 100644
index 000000000..d60ca4b9c
--- /dev/null
+++ b/IOHandler/IOGKOMatrixHandler/IOGKOMatrixHandler.H
@@ -0,0 +1,181 @@
+/*---------------------------------------------------------------------------*\
+License
+    This file is part of OGL.
+
+    OGL is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OGL.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::GKOCG
+
+Author: Gregor Olenik <go@hpsim.de>
+
+SourceFiles
+    GKOCG.C
+
+\*---------------------------------------------------------------------------*/
+#ifndef OGL_IOGKOMatrixHandler_INCLUDED_H
+#define OGL_IOGKOMatrixHandler_INCLUDED_H
+
+#include "fvCFD.H"
+#include "regIOobject.H"
+
+#include "../IOExecutorHandler/IOExecutorHandler.H"
+#include "../IOPtr/IOPtr.H"
+
+namespace Foam {
+
+using mtx = gko::matrix::Coo<scalar>;
+using vec = gko::matrix::Dense<scalar>;
+using val_array = gko::Array<scalar>;
+using idx_array = gko::Array<label>;
+
+class IOGKOMatrixHandler : public IOExecutorHandler {
+private:
+    const word sys_matrix_name_;
+
+    const bool sys_matrix_stored_;
+
+    const word update_sysMatrix_;
+
+    const word sparsity_pattern_name_cols_;
+
+    const word sparsity_pattern_name_rows_;
+
+    const bool sparsity_pattern_stored_;
+
+    const word init_guess_vector_name_;
+
+    const bool init_guess_vector_stored_;
+
+    const bool update_init_guess_vector_;
+
+    const bool export_;
+
+    mutable std::shared_ptr<mtx> gkomatrix_ = NULL;
+
+    mutable GKOCOOIOPtr *gkomatrix_ptr_ = NULL;
+
+    mutable GKOIDXIOPtr *io_col_idxs_ptr_ = NULL;
+
+    mutable GKOIDXIOPtr *io_row_idxs_ptr_ = NULL;
+
+    mutable std::shared_ptr<vec> init_guess_ = NULL;
+
+    mutable GKOVECIOPtr *io_init_guess_ptr_ = NULL;
+
+public:
+    IOGKOMatrixHandler(const objectRegistry &db, const dictionary &controlDict,
+                       const word sys_matrix_name)
+        : IOExecutorHandler(db, controlDict),
+          sys_matrix_name_(sys_matrix_name + "_gko"),
+          sys_matrix_stored_(db.foundObject<regIOobject>(sys_matrix_name_)),
+          update_sysMatrix_(
+              controlDict.lookupOrDefault("updateSysMatrix", word("yes"))),
+          sparsity_pattern_name_cols_("gko_sparsity_pattern_cols"),
+          sparsity_pattern_name_rows_("gko_sparsity_pattern_rows"),
+          sparsity_pattern_stored_(
+              db.foundObject<regIOobject>(sparsity_pattern_name_cols_)),
+          init_guess_vector_name_(sys_matrix_name_ + "_init_guess"),
+          init_guess_vector_stored_(
+              db.foundObject<regIOobject>(init_guess_vector_name_)),
+          update_init_guess_vector_(
+              controlDict.lookupOrDefault<Switch>("updateInitVector", false)),
+
+          export_(controlDict.lookupOrDefault<Switch>("export", false)){};
+
+    bool get_sys_matrix_stored() const { return sys_matrix_stored_; };
+
+    void init_device_matrix(const objectRegistry &db,
+                            std::vector<scalar> &values_host,
+                            std::vector<label> &col_idxs_host,
+                            std::vector<label> &row_idxs_host,
+                            const label nElems, const label nCells,
+                            const bool store) const;
+
+    std::shared_ptr<mtx> get_gkomatrix() const
+    {
+        if (gkomatrix_ptr_ == NULL) {
+            return gkomatrix_;
+        }
+        return gkomatrix_ptr_->get_ptr();
+    };
+
+    void init_initial_guess(const scalarField &psi, const objectRegistry &db,
+                            const label nCells) const
+    {
+        std::shared_ptr<gko::Executor> device_exec = get_device_executor();
+
+        if (init_guess_vector_stored_ && !update_init_guess_vector_) {
+            std::cout << " init_initial_guess do nothing" << std::endl;
+            io_init_guess_ptr_ =
+                &db.lookupObjectRef<GKOVECIOPtr>(init_guess_vector_name_);
+            return;
+        }
+
+        std::cout << " init_initial_guess create psi_view" << std::endl;
+        auto psi_view = val_array::view(gko::ReferenceExecutor::create(),
+                                        nCells, const_cast<scalar *>(&psi[0]));
+
+        std::cout << " init_initial_guess create x" << std::endl;
+        auto x = gko::share(
+            vec::create(device_exec, gko::dim<2>(nCells, 1), psi_view, 1));
+
+        const fileName path_init_guess = init_guess_vector_name_;
+        std::cout << " init_initial_guess create io_init_guess_ptr_"
+                  << std::endl;
+        io_init_guess_ptr_ = new GKOVECIOPtr(IOobject(path_init_guess, db), x);
+    }
+
+
+    std::shared_ptr<vec> get_initial_guess() const
+    {
+        std::cout << "get_initial_guess" << std::endl;
+        if (io_init_guess_ptr_ == NULL) {
+            std::cout << "is Null" << std::endl;
+            return init_guess_;
+        }
+        return io_init_guess_ptr_->get_ptr();
+    }
+
+    void copy_result_back(const scalarField &psi, const label nCells) const
+    {
+        std::cout << "copy back" << std::endl;
+        auto device_x = vec::create(ref_exec(), gko::dim<2>(nCells, 1));
+        std::cout << "copy back 2" << std::endl;
+        device_x->copy_from(gko::lend(get_initial_guess()));
+
+        std::cout << "create x_view back" << std::endl;
+        auto x_view =
+            val_array::view(ref_exec(), nCells, device_x->get_values());
+        // for (label i = 0; i < nCells; i++) {
+        //     std::cout << x_view[i] << std::endl;
+        // }
+
+        // move frome device
+        std::cout << "create psi_view " << std::endl;
+        auto psi_view =
+            val_array::view(ref_exec(), nCells, const_cast<scalar *>(&psi[0]));
+
+        std::cout << "copy x_view to psi_view " << std::endl;
+
+        psi_view = x_view;
+    }
+
+    bool get_update_sys_matrix() const { return (update_sysMatrix_ == "yes"); }
+
+    bool get_export() const { return export_; }
+};
+}  // namespace Foam
+
+#endif
diff --git a/IOHandler/IOPtr/IOPtr.C b/IOHandler/IOPtr/IOPtr.C
new file mode 100644
index 000000000..776f15ebb
--- /dev/null
+++ b/IOHandler/IOPtr/IOPtr.C
@@ -0,0 +1,7 @@
+
+#include "IOPtr.H"
+
+namespace Foam {
+
+
+}  // namespace Foam
diff --git a/IOHandler/IOPtr/IOPtr.H b/IOHandler/IOPtr/IOPtr.H
new file mode 100644
index 000000000..ab4ba78bb
--- /dev/null
+++ b/IOHandler/IOPtr/IOPtr.H
@@ -0,0 +1,70 @@
+/*---------------------------------------------------------------------------*\
+License
+    This file is part of OGL.
+
+    OGL is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OGL.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::IOExecutorHandler
+
+Author: Gregor Olenik <go@hpsim.de>
+
+SourceFiles
+    IOExecutorHandler.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef OGL_IOPtr_INCLUDED_H
+#define OGL_IOPtr_INCLUDED_H
+
+#include <ginkgo/ginkgo.hpp>
+#include "fvCFD.H"
+
+namespace Foam {
+
+using mtx = gko::matrix::Coo<scalar>;
+using val_array = gko::Array<scalar>;
+using idx_array = gko::Array<label>;
+
+template <class T>
+class IOPtr : public regIOobject {
+private:
+    std::shared_ptr<T> ptr_;
+
+public:
+    // - Runtime type information
+    TypeName("IOPtr");
+
+    //- Construct from IOobject and a PtrList
+    IOPtr(const IOobject &io, std::shared_ptr<T> in_ptr)
+        : regIOobject(io), ptr_(in_ptr){};
+
+    std::shared_ptr<T> get_ptr() { return ptr_; };
+
+    bool writeData(Ostream &) const { return false; };
+};
+
+typedef IOPtr<gko::Executor> GKOExecPtr;
+typedef IOPtr<gko::CudaExecutor> GKOCudaExecPtr;
+typedef IOPtr<gko::ReferenceExecutor> GKOReferenceExecPtr;
+typedef IOPtr<gko::OmpExecutor> GKOOmpExecPtr;
+typedef IOPtr<gko::HipExecutor> GKOHipExecPtr;
+typedef IOPtr<idx_array> GKOIDXIOPtr;
+typedef IOPtr<gko::matrix::Coo<scalar>> GKOCOOIOPtr;
+typedef IOPtr<gko::matrix::Dense<scalar>> GKOVECIOPtr;
+
+
+}  // namespace Foam
+
+#endif
diff --git a/IOHandler/IOSortingIdxHandler/IOSortingIdxHandler.C b/IOHandler/IOSortingIdxHandler/IOSortingIdxHandler.C
new file mode 100644
index 000000000..97a6b9709
--- /dev/null
+++ b/IOHandler/IOSortingIdxHandler/IOSortingIdxHandler.C
@@ -0,0 +1,51 @@
+
+#include "IOSortingIdxHandler.H"
+
+namespace Foam {
+
+IOSortingIdxHandler::IOSortingIdxHandler(const objectRegistry &db,
+                                         const label nElems, const bool sort)
+    : nElems_(nElems), is_sorted_(false), sort_(sort)
+{
+    // check object registry if sorting idxs exists
+    word sorting_idxs_name = "sorting_idxs_";
+    if (db.foundObject<IOField<label>>(sorting_idxs_name)) {
+        IOField<label> &labelListRef =
+            db.lookupObjectRef<IOField<label>>(sorting_idxs_name);
+        sorting_idxs_ = &labelListRef;
+        set_is_sorted(true);
+    } else {
+        const fileName path = sorting_idxs_name;
+        sorting_idxs_ = new IOField<label>(IOobject(path, db));
+        init_sorting_idxs();
+        set_is_sorted(false);
+    }
+};
+
+void IOSortingIdxHandler::compute_sorting_idxs(
+    const std::vector<label> &row_idxs)
+{
+    // sort indexes based on comparing values in v
+    // using std::stable_sort instead of std::sort
+    // to avoid unnecessary index re-orderings
+    // when v contains elements of equal values
+    std::cout << " compute sorting idxs " << nElems_ << std::endl;
+    std::stable_sort(sorting_idxs_->data(), &sorting_idxs_->data()[nElems_],
+                     [this, &row_idxs](size_t i1, size_t i2) {
+                         return row_idxs[i1] < row_idxs[i2];
+                     });
+};
+
+void IOSortingIdxHandler::init_sorting_idxs()
+{
+    // initialize original index locations
+    sorting_idxs_->resize(nElems_);
+
+    // set sorting idxs from 0 .. n
+    for (int i = 0; i < nElems_; i++) {
+        sorting_idxs_->operator[](i) = i;
+    }
+};
+
+
+}  // namespace Foam
diff --git a/IOHandler/IOSortingIdxHandler/IOSortingIdxHandler.H b/IOHandler/IOSortingIdxHandler/IOSortingIdxHandler.H
new file mode 100644
index 000000000..d7af83537
--- /dev/null
+++ b/IOHandler/IOSortingIdxHandler/IOSortingIdxHandler.H
@@ -0,0 +1,68 @@
+/*---------------------------------------------------------------------------*\
+License
+    This file is part of OGL.
+
+    OGL is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OGL.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::IOSortingIdxHandler
+
+Author: Gregor Olenik <go@hpsim.de>
+
+SourceFiles
+    IOSortingIdxHandler.H
+
+\*---------------------------------------------------------------------------*/
+#ifndef OGL_IOSortingIdxHandler_INCLUDED_H
+#define OGL_IOSortingIdxHandler_INCLUDED_H
+
+#include <vector>
+#include "fvCFD.H"
+#include "regIOobject.H"
+
+
+namespace Foam {
+class IOSortingIdxHandler {
+private:
+    const label nElems_;
+
+    // if sorting_idxs_ was found in object registry it does not
+    // need to be resorted
+    mutable bool is_sorted_;
+
+    // flag to set wheter the idxs for creating the gko coo matrix
+    // should be sorted
+    const bool sort_;
+
+    IOField<label> *sorting_idxs_ = NULL;
+
+public:
+    IOSortingIdxHandler(const objectRegistry &db, const label nElems,
+                        const bool sort);
+
+    void init_sorting_idxs();
+
+    void compute_sorting_idxs(const std::vector<label> &row_idxs);
+
+    bool get_sort() const { return sort_; }
+
+    void set_is_sorted(bool is_sorted) const { is_sorted_ = is_sorted; }
+
+    bool get_is_sorted() const { return is_sorted_; }
+
+    const IOField<label> *get_sorting_idxs() const { return sorting_idxs_; }
+};
+}  // namespace Foam
+
+#endif
diff --git a/LduMatrix/GKOLduBase/GKOLduBase.H b/LduMatrix/GKOLduBase/GKOLduBase.H
index c77154f23..4bb7d769a 100644
--- a/LduMatrix/GKOLduBase/GKOLduBase.H
+++ b/LduMatrix/GKOLduBase/GKOLduBase.H
@@ -28,6 +28,9 @@ SourceFiles
 #ifndef GKO_LDUBase_H
 #define GKO_LDUBase_H
 
+#include "../IOExecutorHandler/IOExecutorHandler.H"
+#include "../IOHandler/IOSortingIdxHandler/IOSortingIdxHandler.H"
+#include "../common/StoppingCriterion.H"
 #include "../common/common.H"
 #include "LduMatrix.H"
 
@@ -40,9 +43,11 @@ namespace Foam {
 \*---------------------------------------------------------------------------*/
 
 template <class Type, class LDUType, class SolverFactory>
-class GKOLduBaseSolver : public LduMatrix<Type, LDUType, LDUType>::solver,
+class GKOLduBaseSolver : public HostMatrix<LduMatrix<Type, LDUType, LDUType>>,
                          public SolverFactory,
-                         public lduLduCommonBase {
+                         public StoppingCriterion,
+                         public IOSortingIdxHandler,
+                         public IOGKOMatrixHandler {
 public:
     // Some shortcuts
     using IndexType = label;
@@ -57,7 +62,6 @@ private:
     // to keep values contiguous in memory
     // executor where Ginkgo will perform the computation
 
-public:
     std::vector<scalar> sorting_idxs_;
 
     mutable std::vector<scalar> values_;
@@ -71,79 +75,63 @@ public:
     GKOLduBaseSolver(const word &fieldName,
                      const LduMatrix<Type, LDUType, LDUType> &matrix,
                      const dictionary &solverControls)
-        : LduMatrix<Type, LDUType, LDUType>::solver(fieldName, matrix,
-                                                    solverControls),
-          SolverFactory(this->controlDict_),
-          lduLduCommonBase(matrix.mesh().thisDb(), matrix.diag().size(),
-                           matrix.lduAddr().upperAddr().size(), solverControls)
+        : HostMatrix<LduMatrix<Type, LDUType, LDUType>>(fieldName, matrix,
+                                                        solverControls),
+          SolverFactory(solverControls),
+          StoppingCriterion(solverControls),
+          IOSortingIdxHandler(
+              matrix.mesh().thisDb(), this->nElems(),
+              solverControls.lookupOrDefault<Switch>("sort", true)),
+          IOGKOMatrixHandler(matrix.mesh().thisDb(), solverControls, fieldName)
     {
-        // create executors
-        if (get_update_sys_matrix()) {
-            SIMPLE_TIME(update_gko_mtx, update_GKOMatrix();)
-        }
-
-        //   if (!get_is_sorted()) {
-        //     SIMPLE_TIME(compute_sort, compute_sorting_idxs();)
-        //   }
-        //   if (get_sort()) {
-        //     SIMPLE_TIME(sort_gko_mtx, sort_GKOMatrix();)
-        //   }
-    }
-
-    const std::vector<scalar> &vals() const { return values_; };
-
-    const std::vector<label> &col_idx() const { return col_idxs_; };
-
-    const std::vector<label> &row_idx() const { return row_idxs_; };
-
-    // NOTE move to base lduLduBase
-    void update_GKOMatrix() const
-    {
-        // reset vectors
-        values_.resize(0);
-        col_idxs_.resize(0);
-        row_idxs_.resize(0);
-
-        values_.reserve(nElems());
-
-        col_idxs_.reserve(nElems());
-        row_idxs_.reserve(nElems());
-
-        // fill vectors unsorted
-        for (IndexType i = 0; i < nNeighbours(); ++i) {
-            values_.push_back(this->matrix_.lower()[i]);
-            row_idxs_.push_back(this->matrix_.lduAddr().lowerAddr()[i]);
-            col_idxs_.push_back(this->matrix_.lduAddr().upperAddr()[i]);
+        // if sys_matrix is not stored updating is neccesary
+        // initially
+        bool stored = get_sys_matrix_stored();
+        if (!stored) {
+            SIMPLE_TIME(init_host_sparsity_pattern,
+                        this->init_host_sparsity_pattern();)
+            std::cout << " matrix not stored update host matrix " << std::endl;
+            SIMPLE_TIME(update_host_mtx, this->update_host_matrix_data();)
+        } else {
+            // if sys_matrix is  stored updating is only neccesary
+            // when requested explictly
+            std::cout
+                << " matrix is stored and  update of host matrix requested"
+                << std::endl;
+            if (get_update_sys_matrix()) {
+                SIMPLE_TIME(exp_update_host_mtx,
+                            this->update_host_matrix_data();)
+            }
         }
 
-        for (IndexType i = 0; i < nCells(); ++i) {
-            values_.push_back(this->matrix_.diag()[i]);
-
-            col_idxs_.push_back(i);
-            row_idxs_.push_back(i);
+        // after updating the host matrix the host matrix needs to be sorted
+        if (!get_is_sorted()) {
+            std::cout << "matrix is not yet sorted, compute sorting idxs "
+                      << std::endl;
+            SIMPLE_TIME(compute_sort,
+                        this->compute_sorting_idxs(this->row_idxs());)
         }
 
-        for (IndexType i = 0; i < nNeighbours(); ++i) {
-            values_.push_back(this->matrix_.upper()[i]);
-
-            row_idxs_.push_back(this->matrix_.lduAddr().upperAddr()[i]);
-            col_idxs_.push_back(this->matrix_.lduAddr().lowerAddr()[i]);
+        if (!stored && get_sort()) {
+            std::cout << "matrix is not yet sorted,  sorting host matrix "
+                      << std::endl;
+            SIMPLE_TIME(
+                sort_host_mtx_sparsity_pattern,
+                this->sort_host_matrix_sparsity_pattern(get_sorting_idxs());)
+            SIMPLE_TIME(sort_host_mtx,
+                        this->sort_host_matrix_data(this->get_sorting_idxs());)
         }
-    };
 
-    scalar compute_residual(mtx *const A, vec *const x, vec *const b) const
-    {
-        auto one = gko::initialize<vec>({1.0}, exec());
-        auto neg_one = gko::initialize<vec>({-1.0}, exec());
-        auto res = gko::initialize<vec>({0.0}, exec());
-        A->apply(lend(one), lend(x), lend(neg_one), lend(b));
-        b->compute_norm2(lend(res));
+        init_device_matrix(matrix.mesh().thisDb(), this->values(),
+                           this->col_idxs(), this->row_idxs(), this->nElems(),
+                           this->nCells(), !get_update_sys_matrix());
+    }
 
-        return res->at(0);
-    };
 
     virtual SolverPerformance<Type> solve_impl(Field<Type> &psi) const
     {
+        std::shared_ptr<gko::Executor> device_exec =
+            this->get_device_executor();
         // --- Setup class containing solver performance data
         // Implement
         word preconditionerName(this->controlDict_.lookup("preconditioner"));
@@ -152,66 +140,45 @@ public:
                                            this->fieldName_);
 
         auto source_view_x = val_array::view(
-            app_exec(), 3 * nCells(),
-            const_cast<scalar *>(&this->matrix_.source()[0].x()));
+            ref_exec(), 3 * this->nCells(),
+            const_cast<scalar *>(&this->matrix().source()[0].x()));
         auto source_view_y = val_array::view(
-            app_exec(), 3 * nCells(),
-            const_cast<scalar *>(&this->matrix_.source()[0].y()));
+            ref_exec(), 3 * this->nCells(),
+            const_cast<scalar *>(&this->matrix().source()[0].y()));
         auto source_view_z = val_array::view(
-            app_exec(), 3 * nCells(),
-            const_cast<scalar *>(&this->matrix_.source()[0].z()));
+            ref_exec(), 3 * this->nCells(),
+            const_cast<scalar *>(&this->matrix().source()[0].z()));
 
-        auto b_x =
-            vec::create(app_exec(), gko::dim<2>(nCells(), 1), source_view_x, 3);
-        auto b_y =
-            vec::create(app_exec(), gko::dim<2>(nCells(), 1), source_view_y, 3);
-        auto b_z =
-            vec::create(app_exec(), gko::dim<2>(nCells(), 1), source_view_z, 3);
+        auto b_x = vec::create(ref_exec(), gko::dim<2>(this->nCells(), 1),
+                               source_view_x, 3);
+        auto b_y = vec::create(ref_exec(), gko::dim<2>(this->nCells(), 1),
+                               source_view_y, 3);
+        auto b_z = vec::create(ref_exec(), gko::dim<2>(this->nCells(), 1),
+                               source_view_z, 3);
 
-        auto psi_view_x = val_array::view(app_exec(), 3 * nCells(),
+        auto psi_view_x = val_array::view(ref_exec(), 3 * this->nCells(),
                                           const_cast<scalar *>(&psi[0].x()));
-        auto psi_view_y = val_array::view(app_exec(), 3 * nCells(),
+        auto psi_view_y = val_array::view(ref_exec(), 3 * this->nCells(),
                                           const_cast<scalar *>(&psi[0].y()));
-        auto psi_view_z = val_array::view(app_exec(), 3 * nCells(),
+        auto psi_view_z = val_array::view(ref_exec(), 3 * this->nCells(),
                                           const_cast<scalar *>(&psi[0].z()));
 
-        auto x =
-            vec::create(app_exec(), gko::dim<2>(nCells(), 1), psi_view_x, 3);
-        auto y =
-            vec::create(app_exec(), gko::dim<2>(nCells(), 1), psi_view_y, 3);
-        auto z =
-            vec::create(app_exec(), gko::dim<2>(nCells(), 1), psi_view_z, 3);
+        auto x = vec::create(ref_exec(), gko::dim<2>(this->nCells(), 1),
+                             psi_view_x, 3);
+        auto y = vec::create(ref_exec(), gko::dim<2>(this->nCells(), 1),
+                             psi_view_y, 3);
+        auto z = vec::create(ref_exec(), gko::dim<2>(this->nCells(), 1),
+                             psi_view_z, 3);
 
         std::vector<std::shared_ptr<const gko::stop::CriterionFactory>>
             criterion_vec{};
 
-        auto tolerance_stop = gko::stop::AbsoluteResidualNorm<scalar>::build()
-                                  .with_tolerance(tolerance())
-                                  .on(exec());
-
-        // NOTE currently minIter
-        // TODO move to base class
-        if (minIter() == 0) {
-            auto max_iter_stop =
-                gko::stop::Iteration::build().with_max_iters(maxIter()).on(
-                    exec());
-            criterion_vec.push_back(gko::share(tolerance_stop));
-            criterion_vec.push_back(gko::share(max_iter_stop));
-        } else {
-            auto max_iter_stop =
-                gko::stop::Iteration::build().with_max_iters(minIter()).on(
-                    exec());
-            criterion_vec.push_back(gko::share(max_iter_stop));
-        }
+        criterion_vec.push_back(build_stopping_criterion(device_exec, 1.0));
 
         // Generate solver
-        auto solver_gen = this->create_solver(exec(), criterion_vec);
+        auto solver_gen = this->create_solver(device_exec, criterion_vec);
 
-        auto gkomatrix = gko::give(
-            mtx::create(exec(), gko::dim<2>(nCells()),
-                        val_array::view(app_exec(), nElems(), &values_[0]),
-                        idx_array::view(app_exec(), nElems(), &col_idxs_[0]),
-                        idx_array::view(app_exec(), nElems(), &row_idxs_[0])));
+        std::shared_ptr<mtx> gkomatrix = get_gkomatrix();
 
         auto solver = solver_gen->generate(gko::give(gkomatrix));
 
@@ -219,19 +186,21 @@ public:
         SIMPLE_TIME(solve_y, solver->apply(gko::lend(b_y), gko::lend(y));)
         SIMPLE_TIME(solve_z, solver->apply(gko::lend(b_z), gko::lend(z));)
 
-        auto x_view = val_array::view(app_exec(), nCells(), x->get_values());
+        auto x_view =
+            val_array::view(ref_exec(), this->nCells(), x->get_values());
         auto x_clone =
-            vec::create(app_exec(), gko::dim<2>(nCells(), 1), x_view, 1);
-
-        auto y_view = val_array::view(app_exec(), nCells(), y->get_values());
+            vec::create(ref_exec(), gko::dim<2>(this->nCells(), 1), x_view, 1);
+        auto y_view =
+            val_array::view(ref_exec(), this->nCells(), y->get_values());
         auto y_clone =
-            vec::create(app_exec(), gko::dim<2>(nCells(), 1), y_view, 1);
+            vec::create(ref_exec(), gko::dim<2>(this->nCells(), 1), y_view, 1);
 
-        auto z_view = val_array::view(app_exec(), nCells(), z->get_values());
+        auto z_view =
+            val_array::view(ref_exec(), this->nCells(), z->get_values());
         auto z_clone =
-            vec::create(app_exec(), gko::dim<2>(nCells(), 1), z_view, 1);
+            vec::create(ref_exec(), gko::dim<2>(this->nCells(), 1), z_view, 1);
 
-        for (size_t i = 0; i < nCells(); i++) {
+        for (size_t i = 0; i < this->nCells(); i++) {
             psi[i].x() = x_clone->at(i);
             psi[i].y() = y_clone->at(i);
             psi[i].z() = z_clone->at(i);
diff --git a/Make/files b/Make/files
deleted file mode 100644
index 018b131cf..000000000
--- a/Make/files
+++ /dev/null
@@ -1,9 +0,0 @@
-common/common.C
-lduMatrix/GKOlduBase/GKOlduBase.C
-lduMatrix/GKOCG/GKOCG.C
-lduMatrix/GKOIR/GKOIR.C
-lduMatrix/GKOBiCGStab/GKOBiCGStab.C
-LduMatrix/GKOLduBase/GKOLduBase.C
-LduMatrix/GKOACG/GKOACG.C
-
-LIB = $(FOAM_USER_LIBBIN)/libOGL
diff --git a/Make/options b/Make/options
deleted file mode 100644
index 050a94b47..000000000
--- a/Make/options
+++ /dev/null
@@ -1,11 +0,0 @@
-EXE_INC = \
-    -I$(LIB_SRC)/finiteVolume/lnInclude \
-    -I$(LIB_SRC)/meshTools/lnInclude \
-    -std=c++14
-
-LIB_LIBS = \
-    -lginkgo \
-    -lfiniteVolume \
-    -lmeshTools
-
-
diff --git a/common/StoppingCriterion.H b/common/StoppingCriterion.H
index 2f64f4d0f..5e1f4cac5 100644
--- a/common/StoppingCriterion.H
+++ b/common/StoppingCriterion.H
@@ -32,101 +32,133 @@ SourceFiles
 #include "fvCFD.H"
 
 namespace Foam {
-class OpenFOAMStoppingCriterion
-    : public gko::EnablePolymorphicObject<OpenFOAMStoppingCriterion,
-                                          gko::stop::Criterion> {
-    friend class gko::EnablePolymorphicObject<OpenFOAMStoppingCriterion,
-                                              gko::stop::Criterion>;
-    using Criterion = gko::stop::Criterion;
-    using vec = gko::matrix::Dense<scalar>;
 
-private:
-    label iter_ = 0;
-
-public:
-    GKO_CREATE_FACTORY_PARAMETERS(parameters, Factory)
-    {
-        /**
-         * Boolean set by the user to stop the iteration process
-         */
-        // TODO check why GKO_FACTORY_PARAMETER_SCALAR does not work
-        scalar GKO_FACTORY_PARAMETER(openfoam_absolute_tolerance, 1.0e-6);
-
-        scalar GKO_FACTORY_PARAMETER(openfoam_relative_tolerance, 0.0);
+class StoppingCriterion {
+    class OpenFOAMStoppingCriterion
+        : public gko::EnablePolymorphicObject<OpenFOAMStoppingCriterion,
+                                              gko::stop::Criterion> {
+        friend class gko::EnablePolymorphicObject<OpenFOAMStoppingCriterion,
+                                                  gko::stop::Criterion>;
+        using Criterion = gko::stop::Criterion;
+        using vec = gko::matrix::Dense<scalar>;
+
+    private:
+        label iter_ = 0;
+
+    public:
+        GKO_CREATE_FACTORY_PARAMETERS(parameters, Factory)
+        {
+            /**
+             * Boolean set by the user to stop the iteration process
+             */
+            // TODO check why GKO_FACTORY_PARAMETER_SCALAR does not work
+            scalar GKO_FACTORY_PARAMETER(openfoam_absolute_tolerance, 1.0e-6);
+
+            scalar GKO_FACTORY_PARAMETER(openfoam_relative_tolerance, 0.0);
+
+            scalar GKO_FACTORY_PARAMETER(openfoam_norm_factor, 1.0);
+
+            label GKO_FACTORY_PARAMETER(openfoam_minIter, 0);
+
+            label GKO_FACTORY_PARAMETER(openfoam_maxIter, 0);
+        };
+
+        GKO_ENABLE_CRITERION_FACTORY(OpenFOAMStoppingCriterion, parameters,
+                                     Factory);
+
+        GKO_ENABLE_BUILD_METHOD(Factory);
+
+    protected:
+        bool check_impl(gko::uint8 stoppingId, bool setFinalized,
+                        gko::Array<gko::stopping_status> *stop_status,
+                        bool *one_changed,
+                        const Criterion::Updater &updater) override
+        {
+            iter_++;
+
+            auto *dense_r = gko::as<vec>(updater.residual_);
+            auto exec = dense_r->get_executor();
+            auto res = vec::create(exec, gko::dim<2>{1, 1});
+            auto vec_abs = gko::clone(dense_r);
+            const label cells = dense_r->get_size()[0];
+            vec_abs->compute_absolute_inplace();
+            auto unit = vec::create(dense_r->get_executor(),
+                                    gko::dim<2>{(unsigned long)cells, 1});
+            unit->fill(1.0);
+
+            const auto unit_t = unit->transpose();
+
+            unit_t->apply(gko::lend(vec_abs), gko::lend(res));
+
+            auto res_host = vec::create(exec->get_master(), gko::dim<2>{1, 1});
+            res_host->copy_from(gko::lend(res));
+
+            bool result = false;
+            scalar normalised_res_norm =
+                res_host->at(0) / parameters_.openfoam_norm_factor;
+            // printf("normalised res norm %f\n", normalised_res_norm);
+            // printf("iter %d\n", iter_);
+
+            if ((normalised_res_norm <
+                 parameters_.openfoam_absolute_tolerance) &&
+                (iter_ >= parameters_.openfoam_minIter)) {
+                result = true;
+            }
+
+            if (iter_ >= parameters_.openfoam_maxIter) {
+                result = true;
+            }
+
+            if (result) {
+                this->set_all_statuses(stoppingId, setFinalized, stop_status);
+                *one_changed = true;
+            }
+
+            return result;
+        }
 
-        scalar GKO_FACTORY_PARAMETER(openfoam_norm_factor, 1.0);
+        explicit OpenFOAMStoppingCriterion(
+            std::shared_ptr<const gko::Executor> exec)
+            : EnablePolymorphicObject<OpenFOAMStoppingCriterion, Criterion>(
+                  std::move(exec))
+        {}
 
-        label GKO_FACTORY_PARAMETER(openfoam_minIter, 0);
+        explicit OpenFOAMStoppingCriterion(const Factory *factory,
+                                           const gko::stop::CriterionArgs &args)
 
-        label GKO_FACTORY_PARAMETER(openfoam_maxIter, 0);
+            : EnablePolymorphicObject<OpenFOAMStoppingCriterion, Criterion>(
+                  factory->get_executor()),
+              parameters_{factory->get_parameters()}
+        {}
     };
 
-    GKO_ENABLE_CRITERION_FACTORY(OpenFOAMStoppingCriterion, parameters,
-                                 Factory);
-
-    GKO_ENABLE_BUILD_METHOD(Factory);
-
-protected:
-    bool check_impl(gko::uint8 stoppingId, bool setFinalized,
-                    gko::Array<gko::stopping_status> *stop_status,
-                    bool *one_changed,
-                    const Criterion::Updater &updater) override
-    {
-        iter_++;
-
-        auto *dense_r = gko::as<vec>(updater.residual_);
-        auto exec = dense_r->get_executor();
-        auto res = vec::create(exec, gko::dim<2>{1, 1});
-        auto vec_abs = gko::clone(dense_r);
-        const label cells = dense_r->get_size()[0];
-        vec_abs->compute_absolute_inplace();
-        auto unit = vec::create(dense_r->get_executor(),
-                                gko::dim<2>{(unsigned long)cells, 1});
-        unit->fill(1.0);
-
-        const auto unit_t = unit->transpose();
-
-        unit_t->apply(gko::lend(vec_abs), gko::lend(res));
-
-        auto res_host = vec::create(exec->get_master(), gko::dim<2>{1, 1});
-        res_host->copy_from(gko::lend(res));
-
-        bool result = false;
-        scalar normalised_res_norm =
-            res_host->at(0) / parameters_.openfoam_norm_factor;
-        // printf("normalised res norm %f\n", normalised_res_norm);
-        // printf("iter %d\n", iter_);
-
-        if ((normalised_res_norm < parameters_.openfoam_absolute_tolerance) &&
-            (iter_ >= parameters_.openfoam_minIter)) {
-            result = true;
-        }
+    const label maxIter_;
 
-        if (iter_ >= parameters_.openfoam_maxIter) {
-            result = true;
-        }
+    const label minIter_;
 
-        if (result) {
-            this->set_all_statuses(stoppingId, setFinalized, stop_status);
-            *one_changed = true;
-        }
+    const scalar tolerance_;
 
-        return result;
-    }
+    const scalar relTol_;
 
-    explicit OpenFOAMStoppingCriterion(
-        std::shared_ptr<const gko::Executor> exec)
-        : EnablePolymorphicObject<OpenFOAMStoppingCriterion, Criterion>(
-              std::move(exec))
+public:
+    StoppingCriterion(const dictionary &controlDict)
+        : maxIter_(controlDict.lookupOrDefault("maxIter", label(1000))),
+          minIter_(controlDict.lookupOrDefault("minIter", label(0))),
+          tolerance_(controlDict.lookupOrDefault("tolerance", scalar(1e-6))),
+          relTol_(controlDict.lookupOrDefault("relTol", scalar(1e-6)))
     {}
 
-    explicit OpenFOAMStoppingCriterion(const Factory *factory,
-                                       const gko::stop::CriterionArgs &args)
-
-        : EnablePolymorphicObject<OpenFOAMStoppingCriterion, Criterion>(
-              factory->get_executor()),
-          parameters_{factory->get_parameters()}
-    {}
+    std::shared_ptr<const gko::stop::CriterionFactory> build_stopping_criterion(
+        std::shared_ptr<gko::Executor> device_exec, scalar norm_factor) const
+    {
+        return OpenFOAMStoppingCriterion::build()
+            .with_openfoam_absolute_tolerance(tolerance_)
+            .with_openfoam_relative_tolerance(0)
+            .with_openfoam_norm_factor(norm_factor)
+            .with_openfoam_minIter(minIter_)
+            .with_openfoam_maxIter(maxIter_)
+            .on(device_exec);
+    };
 };
 }  // namespace Foam
 
diff --git a/common/common.C b/common/common.C
index f731163bf..8f879816b 100644
--- a/common/common.C
+++ b/common/common.C
@@ -28,12 +28,6 @@ void export_system(const word fieldName, const mtx *A, const vec *x,
     gko::write(stream_x, x);
 };
 
-defineTemplateTypeNameWithName(GKOCOOIOPtr, "COOIOPtr");
-defineTemplateTypeNameWithName(GKOExecPtr, "ExecIOPtr");
-defineTemplateTypeNameWithName(GKOCudaExecPtr, "CudaExecIOPtr");
-defineTemplateTypeNameWithName(GKOOmpExecPtr, "OmpExecIOPtr");
-defineTemplateTypeNameWithName(GKOHipExecPtr, "HipExecIOPtr");
-defineTemplateTypeNameWithName(GKOReferenceExecPtr, "ReferenceExecIOPtr");
 
 // // IOPtr::addsymMatrixConstructorToTable<GKOCG>
 // // addGKOCGSymMatrixConstructorToTable_;
diff --git a/common/common.H b/common/common.H
index bdbdb1e2a..3a3cb45c0 100644
--- a/common/common.H
+++ b/common/common.H
@@ -30,6 +30,8 @@ SourceFiles
 #include "fvCFD.H"
 #include "regIOobject.H"
 
+#include "../IOGKOMatrixHandler/IOGKOMatrixHandler.H"
+
 #include <ginkgo/ginkgo.hpp>
 #include <map>
 
@@ -44,199 +46,113 @@ SourceFiles
 
 namespace Foam {
 
-using vec = gko::matrix::Dense<scalar>;
-using mtx = gko::matrix::Coo<scalar>;
-
-void export_system(const word fieldName, const mtx *A, const vec *x,
-                   const vec *b);
-
-template <class T>
-class IOPtr : public regIOobject {
+template <class MatrixType>
+class HostMatrix : public MatrixType::solver {
 private:
-    std::shared_ptr<T> ptr_;
-
-public:
-    // - Runtime type information
-    TypeName("IOPtr");
-
-    //- Construct from IOobject and a PtrList
-    IOPtr(const IOobject &io, std::shared_ptr<T> in_ptr)
-        : regIOobject(io), ptr_(in_ptr){};
-
-    std::shared_ptr<T> get_ptr() { return ptr_; };
-
-    bool writeData(Ostream &) const { return false; };
-};
-
-typedef IOPtr<gko::matrix::Coo<scalar>> GKOCOOIOPtr;
-typedef IOPtr<gko::Executor> GKOExecPtr;
-typedef IOPtr<gko::CudaExecutor> GKOCudaExecPtr;
-typedef IOPtr<gko::ReferenceExecutor> GKOReferenceExecPtr;
-typedef IOPtr<gko::OmpExecutor> GKOOmpExecPtr;
-typedef IOPtr<gko::HipExecutor> GKOHipExecPtr;
-
-// Logs the number of iteration executed
-struct IterationLogger : gko::log::Logger {
-    void on_iteration_complete(const gko::LinOp *,
-                               const gko::size_type &num_iterations,
-                               const gko::LinOp *residual,
-                               const gko::LinOp *res_norm,
-                               const gko::LinOp *) const override
-    {
-        this->num_iters = num_iterations;
-    }
-
-    IterationLogger(std::shared_ptr<const gko::Executor> exec)
-        : exec(exec),
-          gko::log::Logger(exec, gko::log::Logger::iteration_complete_mask)
-    {}
-
-    gko::size_type get_iters() { return num_iters; }
-
-private:
-    std::shared_ptr<const gko::Executor> exec;
-    mutable gko::size_type num_iters{0};
-};
-
-class lduLduCommonBase {
-    const objectRegistry &db_;
-
-    const label maxIter_;
-
-    const label minIter_;
-
-    const scalar tolerance_;
-
-    const scalar relTol_;
-
-    const word update_sysMatrix_;
-
     const label nCells_;
 
     const label nNeighbours_;
 
     const label nElems_;
 
-    const bool export_;
+    mutable std::vector<scalar> values_;
 
-    // flag to set wheter the idxs for creating the gko coo matrix
-    // should be sorted
-    const bool sort_;
+    mutable std::vector<label> col_idxs_;
 
-    const bool verbose_;
+    mutable std::vector<label> row_idxs_;
 
-    const word device_executor_name_;
+public:
+    HostMatrix(const word &fieldName, const MatrixType &matrix,
+               const FieldField<Field, scalar> &interfaceBouCoeffs,
+               const FieldField<Field, scalar> &interfaceIntCoeffs,
+               const lduInterfaceFieldPtrsList &interfaces,
+               const dictionary &solverControls)
+        : MatrixType::solver(fieldName, matrix, interfaceBouCoeffs,
+                             interfaceIntCoeffs, interfaces, solverControls),
+          nCells_(matrix.diag().size()),
+          nNeighbours_(matrix.lduAddr().upperAddr().size()),
+          nElems_(nCells_ + 2 * nNeighbours_){};
+
+    HostMatrix(const word &fieldName, const MatrixType &matrix,
+               const dictionary &solverControls)
+        : MatrixType::solver(fieldName, matrix, solverControls),
+          nCells_(matrix.diag().size()),
+          nNeighbours_(matrix.lduAddr().upperAddr().size()),
+          nElems_(nCells_ + 2 * nNeighbours_){};
+
+    void init_host_sparsity_pattern() const
+    {
+        col_idxs_.resize(0);
+        row_idxs_.resize(0);
 
-    const word app_executor_name_;
+        col_idxs_.reserve(nElems());
+        row_idxs_.reserve(nElems());
 
-    // if sorting_idxs_ was found in object registry it does not
-    // need to be resorted
-    mutable bool is_sorted_;
+        // fill vectors unsorted
+        for (label i = 0; i < nNeighbours(); ++i) {
+            row_idxs_.push_back(this->matrix().lduAddr().lowerAddr()[i]);
+            col_idxs_.push_back(this->matrix().lduAddr().upperAddr()[i]);
+        }
 
-    // executor where Ginkgo will perform the computation
-    GKOExecPtr *device_exec_ptr_;
+        for (label i = 0; i < nCells(); ++i) {
+            col_idxs_.push_back(i);
+            row_idxs_.push_back(i);
+        }
 
-    // executor of the application
-    GKOExecPtr *app_exec_ptr_;
+        for (label i = 0; i < nNeighbours(); ++i) {
+            row_idxs_.push_back(this->matrix().lduAddr().upperAddr()[i]);
+            col_idxs_.push_back(this->matrix().lduAddr().lowerAddr()[i]);
+        }
+    }
 
-    GKOReferenceExecPtr *ref_exec_ptr_;
+    void update_host_matrix_data() const
+    {
+        // reset vectors
+        values_.resize(0);
 
-    GKOCudaExecPtr *cuda_exec_ptr_;
+        values_.reserve(nElems());
 
-    GKOOmpExecPtr *omp_exec_ptr_;
+        // fill vectors unsorted
+        for (label i = 0; i < nNeighbours(); ++i) {
+            values_.push_back(this->matrix().lower()[i]);
+        }
 
-    GKOHipExecPtr *hip_exec_ptr_;
+        for (label i = 0; i < nCells(); ++i) {
+            values_.push_back(this->matrix().diag()[i]);
+        }
 
-public:
-    lduLduCommonBase(const objectRegistry &db, label nCells, label nNeighbours,
-                     const dictionary &controlDict)
-        : db_(db),
-          maxIter_(controlDict.lookupOrDefault("maxIter", label(1000))),
-          minIter_(controlDict.lookupOrDefault("minIter", label(0))),
-          tolerance_(controlDict.lookupOrDefault("tolerance", scalar(1e-6))),
-          relTol_(controlDict.lookupOrDefault("relTol", scalar(1e-6))),
-          update_sysMatrix_(
-              controlDict.lookupOrDefault("updateSysMatrix", word("yes"))),
-          nCells_(nCells),
-          nNeighbours_(nNeighbours),
-          nElems_(nCells_ + 2 * nNeighbours_),
-          export_(controlDict.lookupOrDefault<Switch>("export", false)),
-          sort_(controlDict.lookupOrDefault<Switch>("sort", true)),
-          verbose_(controlDict.lookupOrDefault<Switch>("verbose", false)),
-          device_executor_name_(
-              controlDict.lookupOrDefault("executor", word("reference"))),
-          app_executor_name_(
-              controlDict.lookupOrDefault("app_executor", word("reference")))
-    {
-        // create executors
-        bool app_exec_stored =
-            get_db().foundObject<regIOobject>(app_executor_name_);
-
-        if (app_exec_stored) {
-            ref_exec_ptr_ = &get_db().lookupObjectRef<GKOReferenceExecPtr>(
-                app_executor_name_);
-            if (device_executor_name_ == app_executor_name_) {
-                return;
-            }
+        for (label i = 0; i < nNeighbours(); ++i) {
+            values_.push_back(this->matrix().upper()[i]);
         }
+    };
 
+    void sort_host_matrix_sparsity_pattern(
+        const IOField<label> *sorting_idxs) const
+    {
+        std::vector<label> tmp_col_idxs(nElems());
+        std::vector<label> tmp_row_idxs(nElems());
 
-        bool device_exec_stored =
-            get_db().foundObject<regIOobject>(device_executor_name_);
-        if (device_exec_stored) {
-            if (device_executor_name_ == "omp") {
-                omp_exec_ptr_ = &get_db().lookupObjectRef<GKOOmpExecPtr>(
-                    device_executor_name_);
-                return;
-            }
-            if (device_executor_name_ == "cuda") {
-                cuda_exec_ptr_ = &get_db().lookupObjectRef<GKOCudaExecPtr>(
-                    device_executor_name_);
-                return;
-            }
-            if (device_executor_name_ == "hip") {
-                hip_exec_ptr_ = &get_db().lookupObjectRef<GKOHipExecPtr>(
-                    device_executor_name_);
-                return;
-            }
-        }
+        for (label i = 0; i < nElems(); i++) tmp_col_idxs[i] = col_idxs_[i];
+        for (label i = 0; i < nElems(); i++) tmp_row_idxs[i] = row_idxs_[i];
 
-        const fileName app_exec_store = app_executor_name_;
-        ref_exec_ptr_ = new GKOReferenceExecPtr(
-            IOobject(app_exec_store, get_db()),
-            gko::give(gko::ReferenceExecutor::create()));
-
-        const fileName device_exec_store = device_executor_name_;
-        const fileName omp_exec_store = "omp";
-        omp_exec_ptr_ = new GKOOmpExecPtr(IOobject(omp_exec_store, get_db()),
-                                          gko::OmpExecutor::create());
-
-        if (device_executor_name_ == "cuda") {
-            cuda_exec_ptr_ =
-                new GKOCudaExecPtr(IOobject(device_exec_store, get_db()),
-                                   gko::give(gko::CudaExecutor::create(
-                                       0, omp_exec_ptr_->get_ptr(), true)));
+        for (label i = 0; i < nElems(); i++) {
+            label j = sorting_idxs->operator[](i);
+            col_idxs_[i] = tmp_col_idxs[j];
+            row_idxs_[i] = tmp_row_idxs[j];
         }
-        if (device_executor_name_ == "hip") {
-            hip_exec_ptr_ =
-                new GKOHipExecPtr(IOobject(device_exec_store, get_db()),
-                                  gko::give(gko::HipExecutor::create(
-                                      0, omp_exec_ptr_->get_ptr(), true)));
-        }
-        if (device_executor_name_ == "omp") {
-            omp_exec_ptr_ =
-                new GKOOmpExecPtr(IOobject(device_exec_store, get_db()),
-                                  omp_exec_ptr_->get_ptr());
-        }
-    }
-
-    const objectRegistry &get_db() { return db_; };
+    };
 
-    scalar tolerance() const { return tolerance_; }
+    void sort_host_matrix_data(const IOField<label> *sorting_idxs) const
+    {
+        std::vector<scalar> tmp_values(nElems());
 
-    label minIter() const { return minIter_; }
+        for (label i = 0; i < nElems(); i++) tmp_values[i] = values_[i];
 
-    label maxIter() const { return maxIter_; }
+        for (label i = 0; i < nElems(); i++) {
+            label j = sorting_idxs->operator[](i);
+            values_[i] = tmp_values[j];
+        }
+    };
 
     label nCells() const { return nCells_; };
 
@@ -244,49 +160,45 @@ public:
 
     label nNeighbours() const { return nNeighbours_; };
 
-    //
-    bool get_update_sys_matrix() const { return (update_sysMatrix_ == "yes"); }
+    std::vector<scalar> &values() const { return values_; };
 
-    bool get_export() const { return export_; }
+    std::vector<label> &col_idxs() const { return col_idxs_; };
 
-    bool get_sort() const { return sort_; }
+    std::vector<label> &row_idxs() const { return row_idxs_; };
+};
 
-    bool get_is_sorted() const { return is_sorted_; }
+using vec = gko::matrix::Dense<scalar>;
+using mtx = gko::matrix::Coo<scalar>;
+using idx_array = gko::Array<label>;
 
-    void set_is_sorted(bool is_sorted) const { is_sorted_ = is_sorted; }
+void export_system(const word fieldName, const mtx *A, const vec *x,
+                   const vec *b);
 
-    word get_device_executor_name() const { return device_executor_name_; }
 
-    std::shared_ptr<gko::Executor> exec() const
+// Logs the number of iteration executed
+struct IterationLogger : gko::log::Logger {
+    void on_iteration_complete(const gko::LinOp *,
+                               const gko::size_type &num_iterations,
+                               const gko::LinOp *residual,
+                               const gko::LinOp *res_norm,
+                               const gko::LinOp *) const override
     {
-        return device_exec_ptr_->get_ptr();
-    };
+        this->num_iters = num_iterations;
+    }
 
-    std::shared_ptr<gko::Executor> app_exec() const
-    {
-        return app_exec_ptr_->get_ptr();
-    };
+    IterationLogger(std::shared_ptr<const gko::Executor> exec)
+        : exec(exec),
+          gko::log::Logger(exec, gko::log::Logger::iteration_complete_mask)
+    {}
 
-    std::shared_ptr<gko::OmpExecutor> omp_exec() const
-    {
-        return omp_exec_ptr_->get_ptr();
-    };
+    gko::size_type get_iters() { return num_iters; }
 
-    std::shared_ptr<gko::CudaExecutor> cuda_exec() const
-    {
-        return cuda_exec_ptr_->get_ptr();
-    };
+private:
+    std::shared_ptr<const gko::Executor> exec;
+    mutable gko::size_type num_iters{0};
+};
 
-    std::shared_ptr<gko::HipExecutor> hip_exec() const
-    {
-        return hip_exec_ptr_->get_ptr();
-    };
 
-    std::shared_ptr<gko::ReferenceExecutor> ref_exec() const
-    {
-        return ref_exec_ptr_->get_ptr();
-    };
-};
 }  // namespace Foam
 
 #endif
diff --git a/lduMatrix/GKOIR/GKOIR.H b/lduMatrix/GKOIR/GKOIR.H
index ccb0de7cf..643d3b48a 100644
--- a/lduMatrix/GKOIR/GKOIR.H
+++ b/lduMatrix/GKOIR/GKOIR.H
@@ -37,13 +37,19 @@ namespace Foam {
 class GKOIRFactory {
 private:
     // executor where Ginkgo will perform the computation
+    //
+    const word inner_solver_;
 
     const scalar inner_reduction_factor_;
 
+    const label blockSize_;
+
 public:
-    GKOIRFactory(const dictionary &controlDict_)
-        : inner_reduction_factor_(controlDict_.lookupOrDefault(
-              "innerReductionFactor", scalar(1e-2))){};
+    GKOIRFactory(const dictionary &dictionary)
+        : inner_solver_(dictionary.lookupOrDefault("innerSolver", word("CG"))),
+          inner_reduction_factor_(
+              dictionary.lookupOrDefault("innerReductionFactor", scalar(1e-2))),
+          blockSize_(dictionary.lookupOrDefault("maxBlockSize", label(16))){};
 
     std::unique_ptr<gko::solver::Ir<double>::Factory,
                     std::default_delete<gko::solver::Ir<double>::Factory>>
@@ -52,6 +58,9 @@ public:
         std::vector<std::shared_ptr<const gko::stop::CriterionFactory>>
             criterion_vec) const
     {
+        if (inner_solver_ == "scalarJacobi") {
+            return create_scalar_jacobi(exec, criterion_vec);
+        }
         return create_default(exec, criterion_vec);
     };
 
@@ -73,6 +82,26 @@ public:
             .with_criteria(criterion_vec)
             .on(exec);
     };
+    std::unique_ptr<gko::solver::Ir<double>::Factory,
+                    std::default_delete<gko::solver::Ir<double>::Factory>>
+    create_scalar_jacobi(
+        std::shared_ptr<gko::Executor> exec,
+        std::vector<std::shared_ptr<const gko::stop::CriterionFactory>>
+            criterion_vec) const
+    {
+        int sweeps = 3;
+        using bj = gko::preconditioner::Jacobi<>;
+        auto bj_factory = bj::build()
+                              .with_max_block_size(blockSize_)
+                              // .with_storage_optimization(
+                              //     gko::precision_reduction::autodetect())
+                              .on(exec);
+
+        return gko::solver::Ir<scalar>::build()
+            .with_solver(gko::share(bj_factory))
+            .with_criteria(criterion_vec)
+            .on(exec);
+    };
 };
 
 /*---------------------------------------------------------------------------*\
diff --git a/lduMatrix/GKOlduBase/GKOlduBase.H b/lduMatrix/GKOlduBase/GKOlduBase.H
index 3597f36d0..9252b58d6 100644
--- a/lduMatrix/GKOlduBase/GKOlduBase.H
+++ b/lduMatrix/GKOlduBase/GKOlduBase.H
@@ -13,7 +13,7 @@ License
     for more details.
 
     You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+    along with OGL.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
     Foam::GKOCG
@@ -27,6 +27,9 @@ SourceFiles
 
 #ifndef GKOlduBase_H
 #define GKOlduBase_H
+
+#include "../IOHandler/IOExecutorHandler/IOExecutorHandler.H"
+#include "../IOHandler/IOSortingIdxHandler/IOSortingIdxHandler.H"
 #include "../common/StoppingCriterion.H"
 #include "../common/common.H"
 
@@ -39,34 +42,29 @@ SourceFiles
 namespace Foam {
 
 /*---------------------------------------------------------------------------*\
-                           Class GKOCG Declaration
+                           Class GKOlduBaseSolver Declaration
 \*---------------------------------------------------------------------------*/
 
+
 template <class SolverFactory>
-class GKOlduBaseSolver : public lduMatrix::solver,
+class GKOlduBaseSolver : public HostMatrix<lduMatrix>,
                          public SolverFactory,
-                         public lduLduCommonBase {
+                         public StoppingCriterion,
+                         public IOSortingIdxHandler,
+                         public IOGKOMatrixHandler {
 public:
     // Some shortcuts
     using IndexType = label;
     using vec = gko::matrix::Dense<scalar>;
+    using idx_vec = gko::matrix::Dense<label>;
     using mtx = gko::matrix::Coo<scalar>;
     using val_array = gko::Array<scalar>;
     using idx_array = gko::Array<label>;
     using cg = gko::solver::Cg<scalar>;
 
-    IOField<label> *sorting_idxs_ = NULL;
-
-    mutable GKOCOOIOPtr *gkomatrix_ptr = NULL;
 
     // for now a copy of the OF matrix is stored
     // to keep values contiguous in memory
-public:
-    mutable std::vector<scalar> values_;
-
-    mutable std::vector<label> col_idxs_;
-
-    mutable std::vector<label> row_idxs_;
 
 public:
     //- Construct from matrix components and solver controls
@@ -75,226 +73,86 @@ public:
                      const FieldField<Field, scalar> &interfaceIntCoeffs,
                      const lduInterfaceFieldPtrsList &interfaces,
                      const dictionary &solverControls)
-        : lduMatrix::solver(fieldName, matrix, interfaceBouCoeffs,
-                            interfaceIntCoeffs, interfaces, solverControls),
-          SolverFactory(controlDict_),
-          lduLduCommonBase(matrix.mesh().thisDb(), matrix.diag().size(),
-                           matrix.lduAddr().upperAddr().size(), solverControls)
-
+        : HostMatrix<lduMatrix>(fieldName, matrix, interfaceBouCoeffs,
+                                interfaceIntCoeffs, interfaces, solverControls),
+          SolverFactory(solverControls),
+          StoppingCriterion(solverControls),
+          IOSortingIdxHandler(
+              matrix.mesh().thisDb(), nElems(),
+              solverControls.lookupOrDefault<Switch>("sort", true)),
+          IOGKOMatrixHandler(matrix.mesh().thisDb(), solverControls, fieldName)
     {
-        std::shared_ptr<gko::Executor> device_exec{};
-        set_device_executor(device_exec);
-
-        // TODO refactor to separate function
-        // check object registry if sorting idxs exists
-        word sorting_idxs_name = "sorting_idxs_";
-        const objectRegistry &db = get_db();
-        if (db.foundObject<IOField<label>>(sorting_idxs_name)) {
-            IOField<label> &labelListRef =
-                db.lookupObjectRef<IOField<label>>(sorting_idxs_name);
-            sorting_idxs_ = &labelListRef;
-            set_is_sorted(true);
+        // if sys_matrix is not stored updating is neccesary
+        // initially
+        bool stored = get_sys_matrix_stored();
+        if (!stored) {
+            SIMPLE_TIME(init_host_sparsity_pattern,
+                        init_host_sparsity_pattern();)
+            SIMPLE_TIME(update_host_mtx, update_host_matrix_data();)
         } else {
-            const fileName path = sorting_idxs_name;
-            sorting_idxs_ = new IOField<label>(IOobject(path, db));
-            init_sorting_idxs();
-            set_is_sorted(false);
-        }
-
-
-        // TODO use different matrix names
-        word sys_matrix_name = "gko_sys_matrix";
-        bool sys_matrix_stored = db.foundObject<regIOobject>(sys_matrix_name);
-
-        if (sys_matrix_stored) {
-            gkomatrix_ptr = &db.lookupObjectRef<GKOCOOIOPtr>(sys_matrix_name);
-            return;
-        }
-
-        // if sys_matrix is not stored updating is only neccesary
-        // when requested explictly or initially
-        if (get_update_sys_matrix()) {
-            SIMPLE_TIME(update_gko_mtx, update_GKOMatrix();)
-        }
-
-        if (!get_update_sys_matrix() && !sys_matrix_stored) {
-            SIMPLE_TIME(update_gko_mtx, update_GKOMatrix();)
-        }
-
+            // if sys_matrix is  stored updating is only neccesary
+            // when requested explictly
+            if (get_update_sys_matrix()) {
+                // since sparsity pattern should already be stored
+                // on device no init_host_sparsity_pattern call is needed
+                SIMPLE_TIME(exp_update_host_mtx, update_host_matrix_data();)
+            }
+        }
+
+        // TODO move compute_sorting_idxs in the if clause above to have all
+        // init calls together
+        // after updating the host matrix the host matrix needs to be sorted
         if (!get_is_sorted()) {
-            SIMPLE_TIME(compute_sort, compute_sorting_idxs();)
+            SIMPLE_TIME(compute_sorting_idxs, compute_sorting_idxs(row_idxs());)
         }
 
-        if (get_sort()) {
-            SIMPLE_TIME(sort_gko_mtx, sort_GKOMatrix();)
+        // TODO move compute_sorting_idxs in the if clause above to have all
+        // init calls together
+        if (!stored && get_sort()) {
+            SIMPLE_TIME(sort_host_mtx_sparsity_pattern,
+                        sort_host_matrix_sparsity_pattern(get_sorting_idxs());)
+            SIMPLE_TIME(sort_host_mtx_data,
+                        sort_host_matrix_data(get_sorting_idxs());)
         }
 
-        // if system matrix is not stored create it
-        // and set shared pointer
-        //
-        auto gkomatrix = gko::share(
-            mtx::create(device_exec, gko::dim<2>(nCells(), nCells()),
-                        val_array::view(gko::ReferenceExecutor::create(),
-                                        nElems(), &values_[0]),
-                        idx_array::view(gko::ReferenceExecutor::create(),
-                                        nElems(), &col_idxs_[0]),
-                        idx_array::view(gko::ReferenceExecutor::create(),
-                                        nElems(), &row_idxs_[0])));
-
-        // if updating system matrix is not needed store ptr in obj registry
-        if (!get_update_sys_matrix()) {
-            Info << "store sys matrix" << endl;
-            const fileName path = sys_matrix_name;
-            gkomatrix_ptr = new GKOCOOIOPtr(IOobject(path, db), gkomatrix);
-        }
-    };
-
-    void set_device_executor(std::shared_ptr<gko::Executor> &device_exec) const
-    {
-        const word device_executor_name{get_device_executor_name()};
-        if (device_executor_name == "omp") {
-            device_exec = omp_exec();
-        }
-        if (device_executor_name == "cuda") {
-            device_exec = cuda_exec();
-        }
-        if (device_executor_name == "hip") {
-            device_exec = hip_exec();
-        }
-        if (device_executor_name == "reference") {
-            device_exec = ref_exec();
-        }
-    };
-
-    void init_sorting_idxs()
-    {
-        // initialize original index locations
-        sorting_idxs_->resize(nElems());
-
-        // set sorting idxs from 0 .. n
-        for (int i = 0; i < nElems(); i++) {
-            sorting_idxs_->operator[](i) = i;
-        }
-    };
-
-    void compute_sorting_idxs()
-    {
-        // sort indexes based on comparing values in v
-        // using std::stable_sort instead of std::sort
-        // to avoid unnecessary index re-orderings
-        // when v contains elements of equal values
-        std::stable_sort(sorting_idxs_->data(),
-                         &sorting_idxs_->data()[nElems()],
-                         [this](size_t i1, size_t i2) {
-                             return row_idxs_[i1] < row_idxs_[i2];
-                         });
-    };
-
-    const std::vector<scalar> &vals() const { return values_; };
-
-    const std::vector<label> &col_idx() const { return col_idxs_; };
-
-    const std::vector<label> &row_idx() const { return row_idxs_; };
-
-    void update_GKOMatrix() const
-    {
-        // reset vectors
-        values_.resize(0);
-        col_idxs_.resize(0);
-        row_idxs_.resize(0);
-
-        values_.reserve(nElems());
-        col_idxs_.reserve(nElems());
-        row_idxs_.reserve(nElems());
-
-        // fill vectors unsorted
-        for (IndexType i = 0; i < nNeighbours(); ++i) {
-            values_.push_back(matrix().lower()[i]);
-            row_idxs_.push_back(matrix().lduAddr().lowerAddr()[i]);
-            col_idxs_.push_back(matrix().lduAddr().upperAddr()[i]);
-        }
-
-        for (IndexType i = 0; i < nCells(); ++i) {
-            values_.push_back(matrix().diag()[i]);
-            col_idxs_.push_back(i);
-            row_idxs_.push_back(i);
-        }
-
-        for (IndexType i = 0; i < nNeighbours(); ++i) {
-            values_.push_back(matrix().upper()[i]);
-            row_idxs_.push_back(matrix().lduAddr().upperAddr()[i]);
-            col_idxs_.push_back(matrix().lduAddr().lowerAddr()[i]);
-        }
-    };
-
-    void sort_GKOMatrix() const
-    {
-        std::vector<scalar> tmp_values(nElems());
-        std::vector<label> tmp_col_idxs(nElems());
-        std::vector<label> tmp_row_idxs(nElems());
-
-        for (label i = 0; i < nElems(); i++) tmp_values[i] = values_[i];
-        for (label i = 0; i < nElems(); i++) tmp_col_idxs[i] = col_idxs_[i];
-        for (label i = 0; i < nElems(); i++) tmp_row_idxs[i] = row_idxs_[i];
-
-        // TODO parallelise
-        for (label i = 0; i < nElems(); i++) {
-            label j = sorting_idxs_->operator[](i);
-            values_[i] = tmp_values[j];
-            col_idxs_[i] = tmp_col_idxs[j];
-            row_idxs_[i] = tmp_row_idxs[j];
-            // std::cout << "elem " << i << ": " << row_idxs_[i] << " " <<
-            // col_idxs_[i] << std::endl;
-        }
-    };
-
-    scalar compute_residual(mtx *const A, vec *const x, vec *const b) const
-    {
-        auto one = gko::initialize<vec>({1.0}, ref_exec());
-        auto neg_one = gko::initialize<vec>({-1.0}, ref_exec());
-        auto res = gko::initialize<vec>({0.0}, ref_exec());
-        A->apply(lend(one), lend(x), lend(neg_one), lend(b));
-        b->compute_norm2(lend(res));
-
-        return res->at(0);
+        init_device_matrix(matrix.mesh().thisDb(), values(), col_idxs(),
+                           row_idxs(), nElems(), nCells(),
+                           !get_update_sys_matrix());
     };
 
     virtual solverPerformance solve_impl(word typeName, scalarField &psi,
                                          const scalarField &source,
                                          const direction cmpt = 0) const
     {
-        std::shared_ptr<gko::Executor> device_exec{};
-        set_device_executor(device_exec);
+        std::shared_ptr<gko::Executor> device_exec =
+            this->get_device_executor();
 
         // --- Setup class containing solver performance data
         solverPerformance solverPerf(
             lduMatrix::preconditioner::getName(controlDict_) + typeName,
             fieldName_);
+
         scalarField pA(nCells());
         scalarField wA(nCells());
         matrix_.Amul(wA, psi, interfaceBouCoeffs_, interfaces_, cmpt);
         scalar norm_factor = this->normFactor(psi, source, wA, pA);
 
-        auto psi_view = val_array::view(ref_exec(), nCells(),
-                                        const_cast<scalar *>(&psi[0]));
         auto source_view = val_array::view(ref_exec(), nCells(),
                                            const_cast<scalar *>(&source[0]));
         auto b =
             vec::create(ref_exec(), gko::dim<2>(nCells(), 1), source_view, 1);
 
-        auto x = vec::create(ref_exec(), gko::dim<2>(nCells(), 1), psi_view, 1);
+        std::cout << "solve_impl init_initial_guess" << std::endl;
+        init_initial_guess(psi, matrix().mesh().thisDb(), nCells());
+        std::cout << "solve_impl init_initial_guess done" << std::endl;
+        auto x = this->get_initial_guess();
+        std::cout << "solve_impl get_initial_guess done" << std::endl;
 
         std::vector<std::shared_ptr<const gko::stop::CriterionFactory>>
             criterion_vec{};
 
         criterion_vec.push_back(
-            OpenFOAMStoppingCriterion::build()
-                .with_openfoam_absolute_tolerance(tolerance())
-                .with_openfoam_relative_tolerance(0)
-                .with_openfoam_norm_factor(norm_factor)
-                .with_openfoam_minIter(minIter())
-                .with_openfoam_maxIter(maxIter())
-                .on(device_exec));
+            build_stopping_criterion(device_exec, norm_factor));
 
         // Generate solver
         auto solver_gen = this->create_solver(device_exec, criterion_vec);
@@ -307,44 +165,27 @@ public:
         // from this factory.
         solver_gen->add_logger(logger);
 
-        auto b_clone = gko::clone(b);
-        std::shared_ptr<mtx> gkomatrix{};
-        if (gkomatrix_ptr == NULL) {
-            gkomatrix = gko::share(
-                mtx::create(device_exec, gko::dim<2>(nCells(), nCells()),
-                            val_array::view(gko::ReferenceExecutor::create(),
-                                            nElems(), &values_[0]),
-                            idx_array::view(gko::ReferenceExecutor::create(),
-                                            nElems(), &col_idxs_[0]),
-                            idx_array::view(gko::ReferenceExecutor::create(),
-                                            nElems(), &row_idxs_[0])));
-        } else {
-            gkomatrix = gkomatrix_ptr->get_ptr();
-        }
+        // auto b_clone = gko::clone(b);
+
+        std::shared_ptr<mtx> gkomatrix = get_gkomatrix();
 
         if (get_export())
             export_system(fieldName(), gko::lend(gkomatrix), gko::lend(x),
                           gko::lend(b));
 
 
-        solverPerf.initialResidual() = compute_residual(
-            gko::lend(gkomatrix), gko::lend(x), gko::lend(b_clone));
+        solverPerf.initialResidual() = 0.0;
 
         auto solver = solver_gen->generate(gko::share(gkomatrix));
 
         // Solve system
         SIMPLE_TIME(solve, solver->apply(gko::lend(b), gko::lend(x));)
 
-        auto x_view = val_array::view(ref_exec(), nCells(), x->get_values());
-        auto x_clone =
-            vec::create(ref_exec(), gko::dim<2>(nCells(), 1), x_view, 1);
-        psi_view = x_view;
-        b_clone->copy_from(gko::lend(b));
+        this->copy_result_back(psi, nCells());
+
+        // b_clone->copy_from(gko::lend(b));
 
-        // solverPerf.finalResidual() =
-        //     compute_residual(gko::lend(ginkgo_host_matrix),
-        //     gko::lend(x_clone),
-        //                      gko::lend(b_clone));
+        solverPerf.finalResidual() = 0.0;
 
         solverPerf.nIterations() = logger->get_iters();
 
diff --git a/scripts/travis_install_external_ginkgo.sh b/scripts/travis_install_external_ginkgo.sh
new file mode 100755
index 000000000..760f74d4e
--- /dev/null
+++ b/scripts/travis_install_external_ginkgo.sh
@@ -0,0 +1,21 @@
+#!/bin/bash
+
+
+if [ $EXTERNAL_GINKGO = ON ]
+then
+    git clone https://github.com/ginkgo-project/ginkgo.git
+    mkdir ginkgo/build
+    cd ginkgo/build
+    cmake \
+        -DGINKGO_BUILD_BENCHMARKS=OFF \
+        -DGINKGO_BUILD_EXAMPLES=OFF \
+        -DGINKGO_BUILD_CUDA=off \
+        -DGINKGO_BUILD_HIP=off \
+        -DGINKGO_BUILD_OMP=off \
+        -DGINKGO_BUILD_TESTS=off\
+        -DGINKGO_BUILD_REFERENCE=on \
+        -DCMAKE_BUILD_TYPE=Release \
+        -DGINKGO_BUILD_HWLOC=off \
+        ..
+    make  && sudo make install
+fi