AdjointNLProblem.hpp

Go to the documentation of this file.

#pragma once
 
#include <polyfem/Common.hpp>
#include <polyfem/solver/FullNLProblem.hpp>
#include <polyfem/optimization/DiffCache.hpp>
#include <polyfem/optimization/var2sims/VariableToSimulationGroup.hpp>
#include <polyfem/utils/Types.hpp>
 
#include <Eigen/Core>
 
#include <functional>
#include <memory>
#include <vector>
#include <fstream>
 
namespace polyfem::solver
{
    class AdjointForm;
 
    class AdjointNLProblem : public FullNLProblem
    {
    public:
        AdjointNLProblem(std::shared_ptr<AdjointForm> form,
                         const VariableToSimulationGroup &variables_to_simulation,
                         const std::vector<std::shared_ptr<varform::DifferentiableVarForm>> &all_varforms,
                         const std::vector<std::shared_ptr<DiffCache>> &all_diff_caches,
                         const json &args,
                         std::function<bool()> remeshing_trigger = {});
        AdjointNLProblem(std::shared_ptr<AdjointForm> form,
                         const std::vector<std::shared_ptr<AdjointForm>> &stopping_conditions,
                         const VariableToSimulationGroup &variables_to_simulation,
                         const std::vector<std::shared_ptr<varform::DifferentiableVarForm>> &all_varforms,
                         const std::vector<std::shared_ptr<DiffCache>> &all_diff_caches,
                         const json &args,
                         std::function<bool()> remeshing_trigger = {});
 
        double value(const Eigen::VectorXd &x) override;
 
        void gradient(const Eigen::VectorXd &x, Eigen::VectorXd &gradv) override;
        void hessian(const Eigen::VectorXd &x, StiffnessMatrix &hessian) override;
        void save_to_file(const int iter_num, const Eigen::VectorXd &x0);
        bool is_step_valid(const Eigen::VectorXd &x0, const Eigen::VectorXd &x1) override;
        bool is_step_collision_free(const Eigen::VectorXd &x0, const Eigen::VectorXd &x1) override;
        double max_step_size(const Eigen::VectorXd &x0, const Eigen::VectorXd &x1) override;
 
        void line_search_begin(const Eigen::VectorXd &x0, const Eigen::VectorXd &x1) override;
        void line_search_end() override;
        void post_step(const polysolve::nonlinear::PostStepData &data) override;
        bool stop(const TVector &x) override;
 
        void solution_changed(const Eigen::VectorXd &new_x) override;
        bool after_line_search_custom_operation(const Eigen::VectorXd &x0, const Eigen::VectorXd &x1) override;
        void solve_pde();
 
    private:
        std::shared_ptr<AdjointForm> form_;
        VariableToSimulationGroup variables_to_simulation_;
        std::vector<std::shared_ptr<varform::DifferentiableVarForm>> all_varforms_;
        std::vector<std::shared_ptr<DiffCache>> all_diff_caches_;
        std::vector<bool> active_varform_mask;
        Eigen::VectorXd cur_grad;
        Eigen::VectorXd curr_x;
 
        int save_freq;
        std::ofstream solution_ostream;
 
        bool enable_slim;
        bool smooth_line_search;
 
        bool solve_in_parallel;
        std::vector<int> solve_in_order;
        std::vector<int> initial_guess_sources_;
 
        int save_iter = 0;
 
        std::vector<std::shared_ptr<AdjointForm>> stopping_conditions_; // if all the stopping conditions are non-positive, stop the optimization
        std::function<bool()> remeshing_trigger_;
    };
} // namespace polyfem::solver