BCLagrangianForm.hpp

Go to the documentation of this file.

#pragma once
 
#include "AugmentedLagrangianForm.hpp"
#include <polyfem/assembler/RhsAssembler.hpp>
 
#include <polyfem/mesh/Obstacle.hpp>
#include <polyfem/mesh/LocalBoundary.hpp>
 
namespace polyfem::utils
{
    class PeriodicBoundary;
} // namespace polyfem::utils
 
namespace polyfem::solver
{
    class BCLagrangianForm : public AugmentedLagrangianForm
    {
    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,
                         const std::shared_ptr<utils::PeriodicBoundary> &periodic_bc = nullptr);
 
        std::string name() const override
        {
            return "bc-alagrangian";
        }
 
        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) override;
 
        StiffnessMatrix &mask()
        {
            return mask_;
        }
        const StiffnessMatrix &mask() const { return mask_; }
        Eigen::VectorXd target(const Eigen::VectorXd &) const override { return target_x_; }
 
        double compute_error(const Eigen::VectorXd &x) const override;
 
    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_; 
        StiffnessMatrix masked_lumped_mass_;      
        StiffnessMatrix mask_;                    
 
        Eigen::MatrixXd target_x_; 
 
        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