IEigenSolver.h

Go to the documentation of this file.

/*
 * Copyright 2020 IFPEN-CEA
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * SPDX-License-Identifier: Apache-2.0
 */

 
#pragma once
 
#include <alien/utils/Precomp.h>
#include <vector>
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Alien
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class IMatrix;
 
class IVector;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

class EigenProblem
{
 public:
  EigenProblem(IMatrix const& A)
  : m_A(A)
  {}

  virtual ~EigenProblem() {}

  IMatrix const& getA() const { return m_A; }

  std::vector<Arccore::Real> const& getRealEigenValues() const
  {
    return m_real_eigen_values;
  }

  std::vector<Arccore::Real>& getRealEigenValues() { return m_real_eigen_values; }

  std::vector<Arccore::Real> const& getImaginaryEigenValues() const
  {
    return m_imaginary_eigen_values;
  }

  std::vector<Arccore::Real>& getImaginaryEigenValues()
  {
    return m_imaginary_eigen_values;
  }

  virtual Arccore::Integer getNbEigenVectors() const = 0;
 
 protected:
  IMatrix const& m_A;
  std::vector<Arccore::Real> m_real_eigen_values;
  std::vector<Arccore::Real> m_imaginary_eigen_values;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

class GeneralizedEigenProblem : public EigenProblem
{
 public:
  GeneralizedEigenProblem(IMatrix const& A, IMatrix const& B)
  : EigenProblem(A)
  , m_B(B)
  {}

  virtual ~GeneralizedEigenProblem() {}

  IMatrix const& getB() const { return m_B; }
 
 protected:
  IMatrix const& m_B;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

class IEigenSolver
{
 public:
  struct Status
  {
    bool m_succeeded = false;
    Integer m_nconv = 0;
    Real m_residual = -1.;
    Integer m_iteration_count = 0;
    Integer m_error = 0;
  };

  typedef enum
  {
    SmallestMagnitude,
    LargestMagnitude,
    SmallestReal,
    LargestReal,
    SmallestImaginary,
    LargestImaginary
  } eEigenValuesOrder;
 
 public:
  IEigenSolver() {}

  virtual ~IEigenSolver(){};
 
 public:
  virtual Arccore::String getBackEndName() const = 0;

  virtual void init() = 0;

  virtual bool solve(EigenProblem& problem) = 0;
 
  /*
   * \brief Whether or not the solver is parallel
   * \returns Parallel support of the solver
   */
  virtual bool hasParallelSupport() const = 0;

  virtual const Status& getStatus() const = 0;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

class IGeneralizedEigenSolver : public IEigenSolver
{
 public:
  IGeneralizedEigenSolver()
  : IEigenSolver()
  {}

  virtual ~IGeneralizedEigenSolver(){};
 
 public:
  virtual bool solve(EigenProblem& problem) = 0;

  virtual bool solve(GeneralizedEigenProblem& problem) = 0;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Alien
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/