imstkNewtonSolver.h

/*
** This file is part of the Interactive Medical Simulation Toolkit (iMSTK)
** iMSTK is distributed under the Apache License, Version 2.0.
** See accompanying NOTICE for details.
*/

#pragma once

#include "imstkNonLinearSolver.h"
#include "imstkLinearSolver.h"

namespace imstk
{
template<typename SystemMatrix>
class NewtonSolver : public NonLinearSolver<SystemMatrix>
{
public:
    using LinearSolverType = LinearSolver<SystemMatrix>;

    NewtonSolver();
    ~NewtonSolver() override = default;

    NewtonSolver(const NewtonSolver& other)  = delete;
    NewtonSolver(const NewtonSolver&& other) = delete;
    NewtonSolver& operator=(const NewtonSolver& other)  = delete;
    NewtonSolver& operator=(const NewtonSolver&& other) = delete;

    void solveGivenState(Vectord& x) override;
    void solve() override;

    void updateForcingTerm(const double ratio,
                           const double stopTolerance,
                           const double fnorm);

    void setLinearSolver(std::shared_ptr<LinearSolverType> newLinearSolver)
    {
        m_linearSolver = newLinearSolver;
    }

    // std::shared_ptr<LinearSolverType> getLinearSolver() const;
    auto getLinearSolver() const->std::shared_ptr<LinearSolverType>;

    double updateJacobian(const Vectord& x);

    //SystemMatrix& getJacobianMatrix();

    void setAbsoluteTolerance(const double aTolerance);

    double getAbsoluteTolerance() const;

    void setRelativeTolerance(const double newRelativeTolerance)
    {
        m_relativeTolerance = newRelativeTolerance;
    }

    double getRelativeTolerance() const { return m_relativeTolerance; }

    void setGamma(const double newGamma) { m_gamma = newGamma; }

    double getGamma() const { return m_gamma; }

    void setEtaMax(const double newEtaMax)
    {
        m_etaMax = newEtaMax;
    }

    double getEtaMax() const { return m_etaMax; }

    void setMaxIterations(const size_t newMaxIterations)
    {
        m_maxIterations = newMaxIterations;
    }

    size_t getMaxIterations() const { return m_maxIterations; }

    void setUseArmijo(const bool value)
    {
        m_useArmijo = value;
        (value) ? this->m_armijoMax = 30 : this->m_armijoMax = 0;
    }

    bool getUseArmijo() const { return m_useArmijo; }

    void setForcingTerm(const double value) { m_forcingTerm = value; }

    double getForcingTerm() const { return m_forcingTerm; }

    void setToFullyImplicit() override
    {
        this->m_isSemiImplicit = false;
    }

    void setToSemiImplicit() override
    {
        this->m_isSemiImplicit = true;
        m_maxIterations = 1;
    }

private:
    std::shared_ptr<LinearSolverType> m_linearSolver; 
    double m_forcingTerm;                             
    double m_absoluteTolerance;                       
    double m_relativeTolerance;                       
    double m_gamma;                                   
    double m_etaMax;                                  
    size_t m_maxIterations;                           
    bool   m_useArmijo;                               
    std::vector<double> m_fnorms;                     
};
} // namespace imstk