ImplicitTimeIntegrator.hpp

Go to the documentation of this file.

#pragma once
 
#include <polyfem/Common.hpp>
 
#include <Eigen/Core>
 
#include <map>
#include <vector>
#include <deque>
 
namespace polyfem::time_integrator
{
    class ImplicitTimeIntegrator
    {
    public:
        ImplicitTimeIntegrator() {}
        virtual ~ImplicitTimeIntegrator() = default;
 
        virtual void set_parameters(const json &params) {}
 
        virtual void init(const Eigen::MatrixXd &x_prevs, const Eigen::MatrixXd &v_prevs, const Eigen::MatrixXd &a_prevs, double dt);
 
        virtual void update_quantities(const Eigen::VectorXd &x) = 0;
 
        virtual Eigen::VectorXd x_tilde() const = 0;
 
        virtual Eigen::VectorXd compute_velocity(const Eigen::VectorXd &x) const = 0;
 
        virtual Eigen::VectorXd compute_acceleration(const Eigen::VectorXd &v) const = 0;
 
        virtual double acceleration_scaling() const = 0;
 
        virtual double dv_dx(const unsigned prev_ti = 0) const = 0;
 
        const double &dt() const { return dt_; }
 
        virtual void save_state(const std::string &state_path) const;
 
        static std::shared_ptr<ImplicitTimeIntegrator> construct_time_integrator(const json &params);
 
        static const std::vector<std::string> &get_time_integrator_names();
 
        const Eigen::VectorXd &x_prev() const { return x_prevs_.front(); }
        const Eigen::VectorXd &v_prev() const { return v_prevs_.front(); }
        const Eigen::VectorXd &a_prev() const { return a_prevs_.front(); }
 
        const std::deque<Eigen::VectorXd> &x_prevs() const { return x_prevs_; }
        const std::deque<Eigen::VectorXd> &v_prevs() const { return v_prevs_; }
        const std::deque<Eigen::VectorXd> &a_prevs() const { return a_prevs_; }
 
        int steps() const { return x_prevs_.size(); }
 
    protected:
        virtual int max_steps() const { return 1; }
 
        double dt_ = 1;
 
        std::deque<Eigen::VectorXd> x_prevs_;
        std::deque<Eigen::VectorXd> v_prevs_;
        std::deque<Eigen::VectorXd> a_prevs_;
 
        void set_x_prev(const Eigen::VectorXd &x_prev) { x_prevs_.front() = x_prev; }
        void set_v_prev(const Eigen::VectorXd &v_prev) { v_prevs_.front() = v_prev; }
        void set_a_prev(const Eigen::VectorXd &a_prev) { a_prevs_.front() = a_prev; }
    };
} // namespace polyfem::time_integrator