ImplicitTimeIntegrator.hpp

Go to the documentation of this file.

#pragma once
 
#include <polyfem/Common.hpp>
 
#include <Eigen/Core>
 
#include <map>
#include <functional>
#include <vector>
#include <deque>
 
namespace polyfem::io
{
    class CheckpointReader;
    class CheckpointWriter;
} // namespace polyfem::io
 
namespace polyfem::time_integrator
{
    class BDF;
 
    class ImplicitTimeIntegrator
    {
    public:
        enum class DynamicOrder
        {
            First,
            Second,
        };
 
        ImplicitTimeIntegrator(const DynamicOrder dynamic_order)
            : dynamic_order_(dynamic_order) {}
        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_; }
        DynamicOrder dynamic_order() const { return dynamic_order_; }
        int maximum_steps() const { return max_steps(); }
 
        void serialize_checkpoint(io::CheckpointWriter &writer, const std::string &group) const;
        void deserialize_checkpoint(
            const io::CheckpointReader &reader,
            const std::string &group,
            double expected_dt,
            const std::function<void(Eigen::MatrixXd &)> &transform = {});
 
        virtual void save_state(const std::string &state_path) const;
 
        static std::shared_ptr<ImplicitTimeIntegrator> construct_time_integrator(
            const json &params,
            DynamicOrder dynamic_order = DynamicOrder::Second);
 
        static std::shared_ptr<BDF> construct_bdf_integrator(
            const json &params,
            DynamicOrder dynamic_order = DynamicOrder::Second);
 
        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:
        const DynamicOrder dynamic_order_;
 
        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