SF_init.h

Go to the documentation of this file.

#ifndef _SF_INIT_H_
#define _SF_INIT_H_

#include "SF_abstract_vector.h"
#include "SF_abstract_matrix.h"
#include "SF_abstract_lin_solver.h"

#include "SF_ginkgo_vector.h"
#include "SF_ginkgo_matrix.h"
#include "SF_ginkgo_solver.h"

#include "SF_petsc_vector.h"
#include "SF_petsc_matrix.h"
#include "SF_petsc_solver.h"

namespace SF {
namespace detail {

  template <typename T, typename S>
  inline void init_or_throw_ginkgo(SF::abstract_vector<T, S>** object)
  {
#ifndef WITH_GINKGO
    throw std::runtime_error("The Ginkgo backend was not enabled");
#else
    init_vector_ginkgo(object);
#endif
  }

  template <typename T, typename S>
  inline void init_or_throw_ginkgo(SF::abstract_matrix<T, S>** object)
  {
#ifndef WITH_GINKGO
    throw std::runtime_error("The Ginkgo backend was not enabled");
#else
    init_matrix_ginkgo(object);
#endif
  }

  template <typename T, typename S>
  inline void init_or_throw_ginkgo(SF::abstract_linear_solver<T, S>** object)
  {
#ifndef WITH_GINKGO
    throw std::runtime_error("The Ginkgo backend was not enabled");
#else
    init_solver_ginkgo(object);
#endif
  }

  inline void init_or_throw_petsc(SF::abstract_vector<SF_int,SF_real>** object)
  {
#ifndef WITH_PETSC
    throw std::runtime_error("The PETSc backend was not enabled");
#else
    init_vector_petsc(object);
#endif
  }

  template <typename T, typename S>
  inline void init_or_throw_petsc(SF::abstract_matrix<T, S>** object)
  {
#ifndef WITH_PETSC
    throw std::runtime_error("The PETSc backend was not enabled");
#else
    init_matrix_petsc(object);
#endif
  }

  template <typename T, typename S>
  inline void init_or_throw_petsc(SF::abstract_linear_solver<T, S>** object)
  {
#ifndef WITH_PETSC
    throw std::runtime_error("The PETSc backend was not enabled");
#else
    init_solver_petsc(object);
#endif
  }

}  // namespace detail


template <class T, class S>
inline void init_vector(SF::abstract_vector<T, S>** vec)
{
  if ((param_globals::flavor != nullptr) && (std::string{param_globals::flavor} == "ginkgo")) {
    detail::init_or_throw_ginkgo(vec);
  } else {
    detail::init_or_throw_petsc(vec);
  }
}

template <class T, class S>
inline void init_vector(SF::abstract_vector<T, S>** vec, int igsize,
                        int ilsize, int idpn = 1,
                        typename abstract_vector<T, S>::ltype ilayout = abstract_vector<T, S>::unset)
{
  if ((param_globals::flavor != nullptr) && (std::string{param_globals::flavor} == "ginkgo")) {
    detail::init_or_throw_ginkgo(vec);
  } else {
    detail::init_or_throw_petsc(vec);
  }
  (*vec)->init(igsize, ilsize, idpn, ilayout);
}

template <class T, class S>
inline void init_vector(SF::abstract_vector<T, S>** vec,
                        const SF::meshdata<mesh_int_t, mesh_real_t>& mesh,
                        int i, typename SF::abstract_vector<T, S>::ltype ltype)
{
  if ((param_globals::flavor != nullptr) && (std::string{param_globals::flavor} == "ginkgo")) {
    detail::init_or_throw_ginkgo(vec);
  } else {
    detail::init_or_throw_petsc(vec);
  }
  (*vec)->init(mesh, i, ltype);
}

template <class T, class S>
inline void init_vector(SF::abstract_vector<T, S>** vec,
                        SF::abstract_vector<T, S>* in)
{
  if ((param_globals::flavor != nullptr) && (std::string{param_globals::flavor} == "ginkgo")) {
    detail::init_or_throw_ginkgo(vec);
  } else {
    detail::init_or_throw_petsc(vec);
  }
  (*vec)->init(*in);
}

template <class T, class S>
inline void init_matrix(SF::abstract_matrix<T, S>** mat)
{
  if ((param_globals::flavor != nullptr) && (std::string{param_globals::flavor} == "ginkgo")) {
    detail::init_or_throw_ginkgo(mat);
  } else {
    detail::init_or_throw_petsc(mat);
  }
}

template <class T, class S>
inline void init_solver(SF::abstract_linear_solver<T, S>** sol)
{
  if ((param_globals::flavor != nullptr) && (std::string{param_globals::flavor} == "ginkgo")) {
    detail::init_or_throw_ginkgo(sol);
  } else {
    detail::init_or_throw_petsc(sol);
  }
}


}  // namespace SF

#endif  // _SF_INIT_H_