AdjointTools.hpp

Go to the documentation of this file.

#pragma once
 
#include <polyfem/Common.hpp>
#include <polyfem/optimization/DiffCache.hpp>
#include <polyfem/optimization/var2sims/ParameterType.hpp>
 
#include <Eigen/Core>
 
#include <vector>
#include <set>
 
namespace polyfem
{
    namespace legacy
    {
        class State;
    }
    class IntegrableFunctional;
 
    namespace solver
    {
        class PeriodicMeshToMesh;
    }
} // namespace polyfem
 
namespace polyfem::solver
{
    enum class SpatialIntegralType
    {
        Volume,
        Surface,
        VertexSum
    };
 
    namespace AdjointTools
    {
        double integrate_objective(
            const legacy::State &state,
            const IntegrableFunctional &j,
            const Eigen::MatrixXd &solution,
            const std::set<int> &interested_ids, // either body id or surface id
            const SpatialIntegralType spatial_integral_type,
            const int cur_step = 0);
        void dJ_du_step(
            const legacy::State &state,
            const IntegrableFunctional &j,
            const Eigen::MatrixXd &solution,
            const std::set<int> &interested_ids,
            const SpatialIntegralType spatial_integral_type,
            const int cur_step,
            Eigen::VectorXd &term);
        void compute_shape_derivative_functional_term(
            const legacy::State &state,
            const Eigen::MatrixXd &solution,
            const IntegrableFunctional &j,
            const std::set<int> &interested_ids, // either body id or surface id
            const SpatialIntegralType spatial_integral_type,
            Eigen::VectorXd &term,
            const int cur_time_step);
        void dJ_shape_static_adjoint_term(
            const legacy::State &state,
            const DiffCache &diff_cache,
            const Eigen::MatrixXd &sol,
            const Eigen::MatrixXd &adjoint,
            Eigen::VectorXd &one_form);
 
        // The periodic simulation result may not be differentiable wrt.
        // every vertex of the periodic mesh, since a pair of periodic
        // vertices cannot move freely, in which case
        // dJ_periodic_shape_adjoint_term() instead of
        // dJ_shape_homogenization_adjoint_term() should be used: When it
        // computes shape derivatives, it considers the pair of periodic
        // vertices as only one degree of freedom.
        void dJ_shape_homogenization_adjoint_term(
            const legacy::State &state,
            const DiffCache &diff_cache,
            const Eigen::MatrixXd &sol,
            const Eigen::MatrixXd &adjoint,
            Eigen::VectorXd &one_form);
        void dJ_periodic_shape_adjoint_term(
            const legacy::State &state,
            const DiffCache &diff_cache,
            const PeriodicMeshToMesh &periodic_mesh_map,
            const Eigen::VectorXd &periodic_mesh_representation,
            const Eigen::MatrixXd &sol,
            const Eigen::MatrixXd &adjoint,
            Eigen::VectorXd &one_form);
 
        void dJ_shape_transient_adjoint_term(
            const legacy::State &state,
            const DiffCache &diff_cache,
            const Eigen::MatrixXd &adjoint_nu,
            const Eigen::MatrixXd &adjoint_p,
            Eigen::VectorXd &one_form);
        void dJ_material_static_adjoint_term(
            const legacy::State &state,
            const Eigen::MatrixXd &sol,
            const Eigen::MatrixXd &adjoint,
            Eigen::VectorXd &one_form);
        void dJ_material_transient_adjoint_term(
            const legacy::State &state,
            const DiffCache &diff_cache,
            const Eigen::MatrixXd &adjoint_nu,
            const Eigen::MatrixXd &adjoint_p,
            Eigen::VectorXd &one_form);
        void dJ_friction_transient_adjoint_term(
            const legacy::State &state,
            const DiffCache &diff_cache,
            const Eigen::MatrixXd &adjoint_nu,
            const Eigen::MatrixXd &adjoint_p,
            Eigen::VectorXd &one_form);
        void dJ_damping_transient_adjoint_term(
            const legacy::State &state,
            const DiffCache &diff_cache,
            const Eigen::MatrixXd &adjoint_nu,
            const Eigen::MatrixXd &adjoint_p,
            Eigen::VectorXd &one_form);
        void dJ_initial_condition_adjoint_term(
            const legacy::State &state,
            const Eigen::MatrixXd &adjoint_nu,
            const Eigen::MatrixXd &adjoint_p,
            Eigen::VectorXd &one_form);
        void dJ_dirichlet_static_adjoint_term(
            const legacy::State &state,
            const DiffCache &diff_cache,
            const Eigen::MatrixXd &adjoint,
            Eigen::VectorXd &one_form);
        void dJ_dirichlet_transient_adjoint_term(
            const legacy::State &state,
            const Eigen::MatrixXd &adjoint_nu,
            const Eigen::MatrixXd &adjoint_p,
            Eigen::VectorXd &one_form);
        void dJ_pressure_static_adjoint_term(
            const legacy::State &state,
            const std::vector<int> &boundary_ids,
            const Eigen::MatrixXd &sol,
            const Eigen::MatrixXd &adjoint,
            Eigen::VectorXd &one_form);
        void dJ_pressure_transient_adjoint_term(
            const legacy::State &state,
            const DiffCache &diff_cache,
            const std::vector<int> &boundary_ids,
            const Eigen::MatrixXd &adjoint_nu,
            const Eigen::MatrixXd &adjoint_p,
            Eigen::VectorXd &one_form);
 
        Eigen::VectorXd map_primitive_to_node_order(
            const legacy::State &state,
            const Eigen::VectorXd &primitives);
        Eigen::VectorXd map_node_to_primitive_order(
            const legacy::State &state,
            const Eigen::VectorXd &nodes);
 
        Eigen::MatrixXd edge_normal_gradient(
            const Eigen::MatrixXd &V);
        Eigen::MatrixXd face_normal_gradient(
            const Eigen::MatrixXd &V);
 
        Eigen::MatrixXd edge_velocity_divergence(
            const Eigen::MatrixXd &V);
        Eigen::MatrixXd face_velocity_divergence(
            const Eigen::MatrixXd &V);
 
        void scaled_jacobian(const Eigen::MatrixXd &V, const Eigen::MatrixXi &F, Eigen::VectorXd &quality);
    }; // namespace AdjointTools
} // namespace polyfem::solver