imstkNonLinearSystem.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 "imstkMath.h"
#include <utility>

namespace imstk
{
template<typename Matrix>
class NonLinearSystem
{
public:
    using VectorFunctionType = std::function<const Vectord& (const Vectord&, const bool)>;
    using MatrixFunctionType = std::function<const Matrix& (const Vectord&)>;
    // using VecMatPair = std::pair<const Vectord&, const Matrix&>;
    using VecMatPair = std::pair<const Vectord*, const Matrix*>;
    using VectorMatrixFunctionType    = std::function<VecMatPair(const Vectord&, const bool)>;
    using UpdateFunctionType          = std::function<void (const Vectord&, const bool)>;
    using UpdatePrevStateFunctionType = std::function<void ()>;

    NonLinearSystem() { }
    NonLinearSystem(const VectorFunctionType& F, const MatrixFunctionType& dF);
    NonLinearSystem(const VectorFunctionType& F, const MatrixFunctionType& dF, const VectorMatrixFunctionType& F_dF);

    virtual ~NonLinearSystem() { }

    virtual void setFunction(const VectorFunctionType& function);

    virtual void setJacobian(const MatrixFunctionType& function);

    virtual const Vectord& evaluateF(const Vectord& x, const bool isSemiImplicit);

    virtual const Matrix& evaluateJacobian(const Vectord& x);

    void setUnknownVector(Vectord& v)
    {
        m_unknown = &v;
    }

    Vectord& getUnknownVector()
    {
        return *m_unknown;
    }

    /*void setLinearProjectors(std::vector<LinearProjectionConstraint>& f)
    {
        m_LinearProjConstraints = &f;
    }

    std::vector<LinearProjectionConstraint>& getLinearProjectors()
    {
        return *m_LinearProjConstraints;
    }*/

    void setUpdateFunction(const UpdateFunctionType& updateFunc)
    {
        m_FUpdate = updateFunc;
    }

    void setUpdatePreviousStatesFunction(const UpdatePrevStateFunctionType& updateFunc)
    {
        m_FUpdatePrevState = updateFunc;
    }

/*void setDynamicLinearProjectors(std::vector<LinearProjectionConstraint>* f)
    {
        m_DynamicLinearProjConstraints = f;
    }

    std::vector<LinearProjectionConstraint>& getDynamicLinearProjectors()
    {
        return *m_DynamicLinearProjConstraints;
    }*/

    VectorFunctionType       m_F;  
    MatrixFunctionType       m_dF; 
    VectorMatrixFunctionType m_F_dF;
    Vectord* m_unknown = nullptr;

    UpdateFunctionType m_FUpdate;
    UpdatePrevStateFunctionType m_FUpdatePrevState;
    /*std::vector<LinearProjectionConstraint>  *m_LinearProjConstraints;
    std::vector<LinearProjectionConstraint>  *m_DynamicLinearProjConstraints;*/
};
} // namespace imstk