Form.hpp

Go to the documentation of this file.

#pragma once
 
#include <polyfem/utils/Types.hpp>
#include <polysolve/nonlinear/PostStepData.hpp>
 
#include <filesystem>
 
namespace polyfem::solver
{
    class Form
    {
    public:
        virtual ~Form() {}
 
        virtual std::string name() const = 0;
 
        virtual void init(const Eigen::VectorXd &x) {}
 
        virtual void finish() {}
 
        inline virtual double value(const Eigen::VectorXd &x) const
        {
            return weight() * value_unweighted(x);
        }
 
        inline Eigen::VectorXd value_per_element(const Eigen::VectorXd &x) const
        {
            return weight_ * value_per_element_unweighted(x);
        }
 
        inline virtual void first_derivative(const Eigen::VectorXd &x, Eigen::VectorXd &gradv) const
        {
            first_derivative_unweighted(x, gradv);
            gradv *= weight();
        }
 
        inline void second_derivative(const Eigen::VectorXd &x, StiffnessMatrix &hessian) const
        {
            second_derivative_unweighted(x, hessian);
            hessian *= weight();
        }
 
        virtual bool is_step_valid(const Eigen::VectorXd &x0, const Eigen::VectorXd &x1) const { return true; }
 
        virtual double max_step_size(const Eigen::VectorXd &x0, const Eigen::VectorXd &x1) const { return 1; }
 
        virtual void line_search_begin(const Eigen::VectorXd &x0, const Eigen::VectorXd &x1) {}
 
        virtual void line_search_end() {}
 
        virtual void post_step(const polysolve::nonlinear::PostStepData &data) {}
 
        virtual void solution_changed(const Eigen::VectorXd &new_x) {}
 
        virtual void update_quantities(const double t, const Eigen::VectorXd &x) {}
 
        virtual void init_lagging(const Eigen::VectorXd &x) {};
 
        virtual void update_lagging(const Eigen::VectorXd &x, const int iter_num) {};
 
        virtual int max_lagging_iterations() const { return 1; }
 
        virtual bool uses_lagging() const { return false; }
 
        void set_project_to_psd(bool val) { project_to_psd_ = val; }
 
        bool is_project_to_psd() const { return project_to_psd_; }
 
        void enable() { enabled_ = true; }
        void disable() { enabled_ = false; }
        void set_enabled(const bool enabled) { enabled_ = enabled; }
 
        bool enabled() const { return enabled_; }
 
        virtual double weight() const { return weight_; }
 
        void set_weight(const double weight) { weight_ = weight; }
 
        // NOTE: The following functions are really specific to the different form and should be implemented in the derived class.
 
        virtual bool is_step_collision_free(const Eigen::VectorXd &x0, const Eigen::VectorXd &x1) const { return true; }
 
        void set_output_dir(const std::string &output_dir) { output_dir_ = output_dir; }
 
    protected:
        bool project_to_psd_ = false; 
 
        double weight_ = 1; 
 
        bool enabled_ = true; 
 
        std::string output_dir_;
 
        std::string resolve_output_path(const std::string &path) const
        {
            if (output_dir_.empty() || path.empty() || std::filesystem::path(path).is_absolute())
                return path;
            return std::filesystem::weakly_canonical(std::filesystem::path(output_dir_) / path).string();
        }
 
        virtual double value_unweighted(const Eigen::VectorXd &x) const = 0;
 
        virtual Eigen::VectorXd value_per_element_unweighted(const Eigen::VectorXd &x) const
        {
            throw std::runtime_error("Not implemented");
        }
 
        virtual void first_derivative_unweighted(const Eigen::VectorXd &x, Eigen::VectorXd &gradv) const = 0;
 
        virtual void second_derivative_unweighted(const Eigen::VectorXd &x, StiffnessMatrix &hessian) const = 0;
    };
} // namespace polyfem::solver