NormalAdhesionForm.hpp

Go to the documentation of this file.

#pragma once
 
#include "Form.hpp"
 
#include <polyfem/utils/Types.hpp>
#include <polysolve/nonlinear/PostStepData.hpp>
 
#include <ipc/broad_phase/broad_phase.hpp>
#include <ipc/broad_phase/create_broad_phase.hpp>
#include <ipc/candidates/candidates.hpp>
#include <ipc/ccd/tight_inclusion_ccd.hpp>
#include <ipc/collisions/normal/normal_collisions.hpp>
#include <ipc/collision_mesh.hpp>
#include <ipc/potentials/normal_adhesion_potential.hpp>
 
#include <memory>
 
namespace polyfem::solver
{
    class NormalAdhesionForm : public Form
    {
        friend class NormalAdhesionForceDerivative;
 
    public:
        NormalAdhesionForm(const ipc::CollisionMesh &collision_mesh,
                           const double dhat_p,
                           const double dhat_a,
                           const double Y,
                           const bool is_time_dependent,
                           const bool enable_shape_derivatives,
                           const ipc::BroadPhaseMethod broad_phase_method,
                           const double ccd_tolerance,
                           const int ccd_max_iterations);
        virtual ~NormalAdhesionForm() = default;
 
        std::string name() const override { return "normal adhesion"; }
 
        void init(const Eigen::VectorXd &x) override;
 
    protected:
        virtual double value_unweighted(const Eigen::VectorXd &x) const override;
 
        Eigen::VectorXd value_per_element_unweighted(const Eigen::VectorXd &x) const override;
 
        virtual void first_derivative_unweighted(const Eigen::VectorXd &x, Eigen::VectorXd &gradv) const override;
 
        virtual void second_derivative_unweighted(const Eigen::VectorXd &x, StiffnessMatrix &hessian) const override;
 
    public:
        void update_quantities(const double t, const Eigen::VectorXd &x) override;
 
        void line_search_begin(const Eigen::VectorXd &x0, const Eigen::VectorXd &x1) override;
 
        void line_search_end() override;
 
        void solution_changed(const Eigen::VectorXd &new_x) override;
 
        void post_step(const polysolve::nonlinear::PostStepData &data) override;
 
        Eigen::MatrixXd compute_displaced_surface(const Eigen::VectorXd &x) const;
 
        bool enable_shape_derivatives() const { return enable_shape_derivatives_; }
 
        bool save_ccd_debug_meshes = false;
 
        double dhat_a() const { return dhat_a_; }
        double dhat_p() const { return dhat_p_; }
        double Y() const { return Y_; }
        const ipc::NormalCollisions &collision_set() const { return collision_set_; }
        const ipc::NormalAdhesionPotential &normal_adhesion_potential() const { return normal_adhesion_potential_; }
 
    protected:
        void update_collision_set(const Eigen::MatrixXd &displaced_surface);
 
        const ipc::CollisionMesh &collision_mesh_;
 
        const double dhat_p_;
 
        const double dhat_a_;
 
        const double Y_;
 
        const double dmin_ = 0;
 
        const bool is_time_dependent_;
 
        const bool enable_shape_derivatives_;
 
        const ipc::BroadPhaseMethod broad_phase_method_;
        const std::shared_ptr<ipc::BroadPhase> broad_phase_;
        const ipc::TightInclusionCCD tight_inclusion_ccd_;
 
        double prev_distance_;
 
        bool use_cached_candidates_ = false;
        ipc::NormalCollisions collision_set_;
        ipc::Candidates candidates_;
 
        const ipc::NormalAdhesionPotential normal_adhesion_potential_;
    };
} // namespace polyfem::solver