SF_abstract_lin_solver.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) NumeriCor GmbH
// SPDX-License-Identifier: Apache-2.0
 
#ifndef _SF_ABSTRACT_LIN_SOLVER_H
#define _SF_ABSTRACT_LIN_SOLVER_H
 
#include "SF_abstract_matrix.h"
#include "SF_abstract_vector.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
  SF_real final_residual    = -1.0;                 
  SF_real time              = 0.0;                  
  SF_int  niter             = -1;                   
  SF_int  max_it            = 0;                    
  SF_int  reason            = 0;                    
 
  virtual const char* reason_str() const = 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;
  }
};
 
} // namespace SF
 
 
#endif // _SF_ABSTRACT_LIN_SOLVER_H