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
  }
 
template <typename T, typename S>
inline void init_or_throw_ginkgo(SF::abstract_nonlinear_solver<T, S>** object)
{
#ifndef WITH_GINKGO
  throw std::runtime_error("The Ginkgo backend was not enabled");
#else
  init_nl_solver_ginkgo(object); //init nonlinear ginkgo_solver needs to be defined
#endif
}
 
  template <typename T, typename S>
  inline void init_or_throw_petsc(SF::abstract_vector<T, S>** 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
  }
 
template <typename T, typename S>
inline void init_or_throw_petsc(SF::abstract_nonlinear_solver<T, S>** object)
{
#ifndef WITH_PETSC
  throw std::runtime_error("The PETSc backend was not enabled");
#else
  init_nl_solver_petsc(object); //init nonlinear petsc solver still needs to be defined
#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);
  }
}
 
// same for nonlinear solver
template <class T, class S>
inline void init_solver(SF::abstract_nonlinear_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_