linear_solver.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Pooyan Dadvand
//                   Riccardo Rossi
//
//
 
 
#if !defined(KRATOS_LINEAR_SOLVER_H_INCLUDED )
#define  KRATOS_LINEAR_SOLVER_H_INCLUDED
 
 
// System includes
 
 
// External includes
 
// Project includes
#include "includes/define.h"
#include "reorderer.h"
#include "includes/model_part.h"
 
namespace Kratos
{
 
 
 
 
 
 
 
template<class TSparseSpaceType, class TDenseSpaceType, class TReordererType = Reorderer<TSparseSpaceType, TDenseSpaceType> >
class LinearSolver
{
public:
 
    KRATOS_CLASS_POINTER_DEFINITION(LinearSolver);
 
    typedef typename TSparseSpaceType::MatrixType SparseMatrixType;
 
    typedef typename TSparseSpaceType::MatrixPointerType SparseMatrixPointerType;
 
    typedef typename TSparseSpaceType::VectorType VectorType;
 
    typedef typename TSparseSpaceType::VectorPointerType VectorPointerType;
 
    typedef typename TDenseSpaceType::MatrixType DenseMatrixType;
 
    typedef typename TDenseSpaceType::VectorType DenseVectorType;
 
    typedef std::size_t SizeType;
 
    typedef typename TSparseSpaceType::IndexType IndexType;
 
 
    LinearSolver() : mpReorderer(new TReordererType()) {}
 
    LinearSolver(TReordererType NewReorderer) : mpReorderer(NewReorderer) {}
 
    LinearSolver(const LinearSolver& Other) : mpReorderer(Other.mpReorderer) {}
 
    virtual ~LinearSolver() {}
 
 
 
    LinearSolver& operator=(const LinearSolver& Other)
    {
        mpReorderer = Other.mpReorderer;
 
        return *this;
    }
 
 
 
    virtual void Initialize(SparseMatrixType& rA, VectorType& rX, VectorType& rB)
    {
        mpReorderer->Initialize(rA, rX, rB);
    }
 
    virtual void InitializeSolutionStep(SparseMatrixType& rA, VectorType& rX, VectorType& rB)
    {
    }
 
    virtual void PerformSolutionStep(SparseMatrixType& rA, VectorType& rX, VectorType& rB)
    {
        KRATOS_ERROR << "Calling linear solver base class" << std::endl;
    }
 
    virtual void FinalizeSolutionStep(SparseMatrixType& rA, VectorType& rX, VectorType& rB)
    {
    }
 
    virtual void Clear()
    {
    }
 
 
    virtual bool Solve(SparseMatrixType& rA, VectorType& rX, VectorType& rB)
    {
        KRATOS_ERROR << "Calling linear solver base class" << std::endl;
        return false;
    }
 
    virtual bool Solve(SparseMatrixType& rA, DenseMatrixType& rX, DenseMatrixType& rB)
    {
        KRATOS_ERROR << "Calling linear solver base class" << std::endl;
        return false;
    }
 
    virtual  void Solve(SparseMatrixType& K,
                        SparseMatrixType& M,
                        DenseVectorType& Eigenvalues,
                        DenseMatrixType& Eigenvectors)
    {
        KRATOS_ERROR << "Calling linear solver base class" << std::endl;
    }
 
    virtual bool AdditionalPhysicalDataIsNeeded()
    {
        return false;
    }
 
    virtual void ProvideAdditionalData(
        SparseMatrixType& rA,
        VectorType& rX,
        VectorType& rB,
        typename ModelPart::DofsArrayType& rDoFSet,
        ModelPart& rModelPart
    )
    {}
 
 
    virtual typename TReordererType::Pointer GetReorderer()
    {
        return mpReorderer;
    }
 
    virtual void SetReorderer(typename TReordererType::Pointer pNewReorderer)
    {
        mpReorderer = pNewReorderer;
    }
 
    virtual void SetTolerance(double NewTolerance)
    {
        KRATOS_WARNING("LinearSolver") << "Accessed base function \"SetTolerance\". This does nothing !" << std::endl;
    }
 
    virtual double GetTolerance()
    {
        KRATOS_WARNING("LinearSolver") << "Accessed base function \"GetTolerance\". No tolerance defined, returning 0 !" << std::endl ;
        return 0;
    }
 
    virtual IndexType GetIterationsNumber()
    {
        KRATOS_WARNING("LinearSolver") << "Accessed base function \"GetIterationsNumber\", returning 0 !" << std::endl ;
 
        return 0;
    }
 
 
    virtual bool IsConsistent(
        SparseMatrixType& rA, 
        VectorType& rX, 
        VectorType& rB
        )
    {
        const SizeType size = TSparseSpaceType::Size1(rA);
        const SizeType size_a = TSparseSpaceType::Size2(rA);
        const SizeType size_x = TSparseSpaceType::Size(rX);
        const SizeType size_b = TSparseSpaceType::Size(rB);
 
        return ((size ==  size_a) &&
                (size ==  size_x) &&
                (size ==  size_b));
    }
 
    virtual bool IsConsistent(
        SparseMatrixType& rA, 
        DenseMatrixType& rX,
        DenseMatrixType& rB
        ) 
    {
        const SizeType size = TSparseSpaceType::Size1(rA);
        const SizeType size_a = TSparseSpaceType::Size2(rA);
        const SizeType size_1_x = TDenseSpaceType::Size1(rX);
        const SizeType size_1_b = TDenseSpaceType::Size1(rB);
        const SizeType size_2_x = TDenseSpaceType::Size2(rX);
        const SizeType size_2_b = TDenseSpaceType::Size2(rB);
 
        return ((size ==  size_a) &&
                (size ==  size_1_x) &&
                (size ==  size_1_b) &&
                (size_2_x == size_2_b));
    }
 
    virtual bool IsNotConsistent(
        SparseMatrixType& rA, 
        VectorType& rX, 
        VectorType& rB
        )
    {
        return (!IsConsistent(rA, rX, rB));
    }
    
    virtual bool IsNotConsistent(
        SparseMatrixType& rA, 
        DenseMatrixType& rX, 
        DenseMatrixType& rB
        ) 
    {
        return (!IsConsistent(rA, rX, rB));
    }
 
 
    virtual std::string Info() const
    {
        return "Linear solver";
    }
 
    virtual void PrintInfo(std::ostream& rOStream) const
    {
        rOStream << "Linear solver";
    }
 
    virtual void PrintData(std::ostream& rOStream) const
    {
    }
 
 
 
 
protected:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
private:
 
 
 
    typename TReordererType::Pointer mpReorderer;
 
 
 
 
 
 
 
 
 
 
 
 
}; 
 
 
 
 
 
 
template<class TSparseSpaceType, class TDenseSpaceType, class TReordererType>
inline std::istream& operator >> (std::istream& IStream,
                                  LinearSolver<TSparseSpaceType, TDenseSpaceType, TReordererType>& rThis)
{
    return IStream;
}
 
template<class TSparseSpaceType, class TDenseSpaceType, class TReordererType>
inline std::ostream& operator << (std::ostream& rOStream,
                                  const LinearSolver<TSparseSpaceType, TDenseSpaceType, TReordererType>& rThis)
{
    rThis.PrintInfo(rOStream);
    rOStream << std::endl;
    rThis.PrintData(rOStream);
 
    return rOStream;
}
 
 
}  // namespace Kratos.
 
#endif // KRATOS_LINEAR_SOLVER_H_INCLUDED  defined