TangentialAdhesionForm.hpp

Go to the documentation of this file.

#pragma once
 
#include "Form.hpp"
#include "NormalAdhesionForm.hpp"
 
#include <polyfem/time_integrator/ImplicitTimeIntegrator.hpp>
#include <polyfem/utils/Types.hpp>
 
#include <ipc/ipc.hpp>
#include <ipc/collision_mesh.hpp>
#include <ipc/collisions/tangential/tangential_collisions.hpp>
#include <ipc/potentials/tangential_adhesion_potential.hpp>
#include <ipc/broad_phase/create_broad_phase.hpp>
 
namespace polyfem::solver
{
    class TangentialAdhesionForm : public Form
    {
        friend class TangentialAdhesionForceDerivative;
 
    public:
        TangentialAdhesionForm(
            const ipc::CollisionMesh &collision_mesh,
            const std::shared_ptr<time_integrator::ImplicitTimeIntegrator> time_integrator,
            const double epsa,
            const double mu,
            const ipc::BroadPhaseMethod broad_phase_method,
            const NormalAdhesionForm &normal_adhesion_form,
            const int n_lagging_iters);
 
        std::string name() const override { return "tangential adhesion"; }
 
    protected:
        double value_unweighted(const Eigen::VectorXd &x) const override;
 
        void first_derivative_unweighted(const Eigen::VectorXd &x, Eigen::VectorXd &gradv) const override;
 
        void second_derivative_unweighted(const Eigen::VectorXd &x, StiffnessMatrix &hessian) const override;
 
    public:
        void init_lagging(const Eigen::VectorXd &x) override { update_lagging(x, 0); }
 
        void update_lagging(const Eigen::VectorXd &x, const int iter_num) override;
 
        void update_lagging(const Eigen::VectorXd &x) { update_lagging(x, -1); };
 
        int max_lagging_iterations() const override { return n_lagging_iters_; }
 
        bool uses_lagging() const override { return true; }
 
        Eigen::MatrixXd compute_displaced_surface(const Eigen::VectorXd &x) const;
        Eigen::MatrixXd compute_surface_velocities(const Eigen::VectorXd &x) const;
        double dv_dx() const;
 
        double mu() const { return mu_; }
        double epsa() const { return epsa_; }
        const ipc::TangentialCollisions &tangential_collision_set() const { return tangential_collision_set_; }
        const ipc::TangentialAdhesionPotential &tangential_adhesion_potential() const { return tangential_adhesion_potential_; }
 
    private:
        const ipc::CollisionMesh &collision_mesh_;
 
        const std::shared_ptr<time_integrator::ImplicitTimeIntegrator> time_integrator_;
 
        const double epsa_;                              
        const double mu_;                                
        const ipc::BroadPhaseMethod broad_phase_method_; 
        const std::shared_ptr<ipc::BroadPhase> broad_phase_;
        const int n_lagging_iters_; 
 
        ipc::TangentialCollisions tangential_collision_set_; 
 
        const NormalAdhesionForm &normal_adhesion_form_; 
 
        const ipc::TangentialAdhesionPotential tangential_adhesion_potential_;
    };
} // namespace polyfem::solver