BCLagrangianForm.hpp

Go to the documentation of this file.

#pragma once
 
#include "Form.hpp"
#include <polyfem/assembler/RhsAssembler.hpp>
 
#include <polyfem/mesh/Obstacle.hpp>
#include <polyfem/mesh/LocalBoundary.hpp>
 
namespace polyfem::solver
{
    class BCLagrangianForm : public Form
    {
    public:
        BCLagrangianForm(const int ndof,
                         const std::vector<int> &boundary_nodes,
                         const std::vector<mesh::LocalBoundary> &local_boundary,
                         const std::vector<mesh::LocalBoundary> &local_neumann_boundary,
                         const int n_boundary_samples,
                         const StiffnessMatrix &mass,
                         const assembler::RhsAssembler &rhs_assembler,
                         const size_t obstacle_ndof,
                         const bool is_time_dependent,
                         const double t);
 
        std::string name() const override { return "bc-lagrangian"; }
 
        BCLagrangianForm(const int ndof,
                         const std::vector<int> &boundary_nodes,
                         const StiffnessMatrix &mass,
                         const size_t obstacle_ndof,
                         const Eigen::MatrixXd &target_x);
 
        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 update_quantities(const double t, const Eigen::VectorXd &x) override;
 
        void update_lagrangian(const Eigen::VectorXd &x, const double k_al);
 
    private:
        const std::vector<int> &boundary_nodes_;
        const std::vector<mesh::LocalBoundary> *local_boundary_;
        const std::vector<mesh::LocalBoundary> *local_neumann_boundary_;
        const int n_boundary_samples_;
 
        const assembler::RhsAssembler *rhs_assembler_; 
        const bool is_time_dependent_;
 
        StiffnessMatrix masked_lumped_mass_sqrt_; 
        Eigen::MatrixXd target_x_;                
        Eigen::VectorXd lagr_mults_;              
 
        void init_masked_lumped_mass(
            const int ndof,
            const StiffnessMatrix &mass,
            const size_t obstacle_ndof);
 
        void update_target(const double t);
    };
} // namespace polyfem::solver