FrictionForm.hpp

Go to the documentation of this file.

#pragma once
 
#include "Form.hpp"
#include "ContactForm.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/friction_potential.hpp>
#include <ipc/broad_phase/create_broad_phase.hpp>
 
#include <memory>
 
namespace polyfem::solver
{
    class FrictionForm : public Form
    {
        friend class FrictionForceDerivative;
 
    public:
        FrictionForm(
            const ipc::CollisionMesh &collision_mesh,
            const std::shared_ptr<time_integrator::ImplicitTimeIntegrator> time_integrator,
            const double epsv,
            const double mu,
            const ipc::BroadPhaseMethod broad_phase_method,
            const ContactForm &contact_form,
            const int n_lagging_iters);
 
        std::string name() const override { return "friction"; }
 
    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 epsv() const { return epsv_; }
        const ipc::TangentialCollisions &friction_collision_set() const { return friction_collision_set_; }
        const ipc::FrictionPotential &friction_potential() const { return friction_potential_; }
 
    private:
        const ipc::CollisionMesh &collision_mesh_;
 
        const std::shared_ptr<time_integrator::ImplicitTimeIntegrator> time_integrator_;
 
        const double epsv_;                              
        const double mu_;                                
        const ipc::BroadPhaseMethod broad_phase_method_; 
        const int n_lagging_iters_;                      
 
        ipc::TangentialCollisions friction_collision_set_; 
 
        const ContactForm &contact_form_; 
 
        const ipc::FrictionPotential friction_potential_;
    };
} // namespace polyfem::solver