SF_abstract_lin_solver.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// openCARP is an open cardiac electrophysiology simulator.
//
// Copyright (C) 2020 openCARP project
//
// This program is licensed under the openCARP Academic Public License (APL)
// v1.0: You can use and redistribute it and/or modify it in non-commercial
// academic environments under the terms of APL as published by the openCARP
// project v1.0, or (at your option) any later version. Commercial use requires
// a commercial license (info@opencarp.org).
//
// This program is distributed without any warranty; see the openCARP APL for
// more details.
//
// You should have received a copy of the openCARP APL along with this program
// and can find it online: http://www.opencarp.org/license
// ----------------------------------------------------------------------------
 
#ifndef _SF_ABSTRACT_LIN_SOLVER_H
#define _SF_ABSTRACT_LIN_SOLVER_H
 
#include "SF_abstract_matrix.h"
#include "SF_abstract_vector.h"
 
//das nur für snes
#include "petscsnes.h"
 
namespace SF {
 
template<class T, class S>
struct abstract_linear_solver
{
  std::string         name;         
  const char*         options_file; 
 
  enum norm_t {absPreResidual, absUnpreResidual, relResidual, absPreRelResidual, norm_unset};
  norm_t norm = norm_unset;
 
  // solver statistics
  double       final_residual    = -1.0;                 
  int          niter             = -1;                   
  int          max_it            = 0;                    
  int          reason            = 0;                    
  double       time              = 0.0;                  
 
  virtual void operator() (abstract_vector<T,S> & x, const abstract_vector<T,S> & b) = 0;
 
  virtual ~abstract_linear_solver() = default;
 
  virtual void setup_solver(abstract_matrix<T, S>& mat, double tol, int max_it,
                            short norm, std::string name, bool has_nullspace,
                            void*       logger,  // TODO: maybe solver logging needs to be revisited
                            const char* solver_opts_file,
                            const char* default_opts) = 0;
 
 protected:
  virtual void set_stopping_criterion(norm_t normtype, double tol, int max_it,
                                      bool verbose, void* logger) = 0;
 
  norm_t convert_param_norm_type(short param_norm_type) const
  {
    norm_t normtype = absPreResidual;
 
    switch (param_norm_type) {
      default:
      case 0: normtype = absPreResidual; break;
      case 1: normtype = absUnpreResidual; break;
      case 2: normtype = relResidual; break;
      case 3: normtype = absPreRelResidual; break;
    }
 
    return normtype;
  }
};
 
template<class T, class S>
 
struct abstract_nonlinear_solver
{
  const char*         name;         
  const char*         options_file; 
 
  enum norm_t {absPreResidual, absUnpreResidual, relResidual, absPreRelResidual, norm_unset};
  norm_t norm = norm_unset;
 
  // solver statistics
  double       final_residual    = -1.0;                 
  int          niter             = -1;                   
  int          max_it            = 0;                    
  int          reason            = 0;                    
  double       time              = 0.0;                  
 
  virtual void operator() (abstract_vector<T,S> & x, const abstract_vector<T,S> & b) = 0;
 
  virtual ~abstract_nonlinear_solver() = default;
 
//  virtual void setup_solver(abstract_matrix<T, S>& mat, double tol, int max_it,
//                            short norm, const char* name, bool has_nullspace,
//                            void*       logger,  // TODO: maybe solver logging needs to be revisited
//                            const char* solver_opts_file,
//                            const char* default_opts) = 0;
  virtual void setup_solver(abstract_vector<T, S> &residuum, abstract_matrix<T, S>& mat, double tol, int max_it, short norm, const char* name, bool has_nullspace, void* logger, const char   *solver_opts_file, const char* default_opts, PetscErrorCode function(SNES, Vec, Vec, void*), PetscErrorCode jacobian(SNES, Vec, Mat, Mat, void*), void * solver_pointer = NULL) = 0;
 
 protected:
  virtual void set_stopping_criterion(norm_t normtype, double tol, int max_it,
                                      bool verbose, void* logger) = 0;
 
  norm_t convert_param_norm_type(short param_norm_type) const
  {
    norm_t normtype = absPreResidual;
 
    switch (param_norm_type) {
      default:
      case 0: normtype = absPreResidual; break;
      case 1: normtype = absUnpreResidual; break;
      case 2: normtype = relResidual; break;
      case 3: normtype = absPreRelResidual; break;
    }
 
    return normtype;
  }
};
 
} // namespace SF
 
 
#endif // _SF_ABSTRACT_LIN_SOLVER_H