OutData.hpp

Go to the documentation of this file.

#pragma once
 
#include <polyfem/Common.hpp>
 
#include <polyfem/basis/ElementBases.hpp>
 
#include <polyfem/mesh/Mesh.hpp>
 
#include <polyfem/io/OutputData.hpp>
#include <polyfem/io/OutStatsData.hpp>
 
#include <paraviewo/ParaviewWriter.hpp>
#include <paraviewo/VTUWriter.hpp>
#include <paraviewo/HDF5VTUWriter.hpp>
 
#include <polyfem/utils/RefElementSampler.hpp>
 
#include <Eigen/Dense>
 
namespace paraviewo
{
    class VTMWriter;
}
 
namespace polyfem::io
{
    class OutGeometryData
    {
    public:
        struct ExportOptions
        {
            std::vector<std::string> fields; // fields to export, empty means all
 
            bool volume;
            bool surface;
            bool wire;
            bool points;
            bool contact_forces;
            bool friction_forces;
            bool normal_adhesion_forces;
            bool tangential_adhesion_forces;
 
            bool use_sampler;
            bool boundary_only;
            bool sol_on_grid;
            bool discretization_order;
            bool reorder_output;
 
            bool use_hdf5;
 
            ExportOptions(const json &args,
                          const bool is_mesh_linear,
                          const bool mesh_has_prisms,
                          const bool is_problem_scalar);
 
            inline std::string file_extension() const
            {
                return use_hdf5 ? ".hdf" : ".vtu";
            }
 
            bool export_field(const std::string &field) const;
        };
 
        static void extract_boundary_mesh(
            const mesh::Mesh &mesh,
            const int n_bases,
            const std::vector<basis::ElementBases> &bases,
            const std::vector<mesh::LocalBoundary> &total_local_boundary,
            Eigen::MatrixXd &node_positions,
            Eigen::MatrixXi &boundary_edges,
            Eigen::MatrixXi &boundary_triangles,
            std::vector<Eigen::Triplet<double>> &displacement_map_entries);
 
        static void extract_boundary_mesh_sampled(
            const mesh::Mesh &mesh,
            const int n_bases,
            const std::vector<basis::ElementBases> &bases,
            const std::vector<mesh::LocalBoundary> &total_local_boundary,
            Eigen::MatrixXd &node_positions,
            Eigen::MatrixXi &boundary_edges,
            Eigen::MatrixXi &boundary_triangles,
            std::vector<Eigen::Triplet<double>> &displacement_map_entries,
            const int sampling_order = 0);
 
        void init_sampler(const polyfem::mesh::Mesh &mesh, const double vismesh_rel_area);
 
        void build_grid(const polyfem::mesh::Mesh &mesh, const double spacing);
 
        void export_data(
            const OutputSpace &space,
            const OutputFieldFunction &output_fields,
            const bool is_time_dependent,
            const double tend_in,
            const double dt,
            const ExportOptions &opts,
            const std::string &vis_mesh_path) const;
 
        void save_vtu(const std::string &path,
                      const OutputSpace &space,
                      const OutputFieldFunction &output_fields,
                      const double t,
                      const double dt,
                      const ExportOptions &opts) const;
 
        void save_vtu(const std::string &path,
                      const OutputSpace &space,
                      const OutputFieldFunction &output_fields,
                      const double t,
                      const double dt,
                      const ExportOptions &opts,
                      paraviewo::VTMWriter &vtm,
                      const std::string &block_prefix) const;
 
        void save_volume(const std::string &path,
                         const OutputSpace &space,
                         const OutputFieldFunction &output_fields,
                         const double t,
                         const double dt,
                         const ExportOptions &opts) const;
 
        void save_surface(const std::string &export_surface,
                          const OutputSpace &space,
                          const OutputFieldFunction &output_fields,
                          const double t,
                          const double dt_in,
                          const ExportOptions &opts) const;
 
        void save_contact_surface(
            const std::string &export_surface,
            const OutputSpace &space,
            const OutputFieldFunction &output_fields,
            const double t,
            const double dt_in,
            const ExportOptions &opts) const;
 
        void save_wire(const std::string &name,
                       const OutputSpace &space,
                       const OutputFieldFunction &output_fields,
                       const double t,
                       const ExportOptions &opts) const;
 
        void save_points(
            const std::string &path,
            const OutputSpace &space,
            const OutputFieldFunction &output_fields,
            const ExportOptions &opts) const;
 
        void save_pvd(const std::string &name, const std::function<std::string(int)> &vtu_names,
                      int time_steps, double t0, double dt, int skip_frame = 1) const;
 
    private:
        utils::RefElementSampler ref_element_sampler;
 
        Eigen::MatrixXd grid_points;
        Eigen::MatrixXi grid_points_to_elements;
        Eigen::MatrixXd grid_points_bc;
 
        void build_vis_boundary_mesh(
            const mesh::Mesh &mesh,
            const std::vector<basis::ElementBases> &gbases,
            const std::vector<mesh::LocalBoundary> &total_local_boundary,
            Eigen::MatrixXd &boundary_vis_vertices,
            Eigen::MatrixXd &boundary_vis_local_vertices,
            Eigen::MatrixXi &boundary_vis_elements,
            Eigen::MatrixXi &boundary_vis_elements_ids,
            Eigen::MatrixXi &boundary_vis_primitive_ids,
            Eigen::MatrixXd &boundary_vis_normals) const;
 
        void build_vis_mesh(
            const mesh::Mesh &mesh,
            const Eigen::VectorXi &disc_orders,
            const std::vector<basis::ElementBases> &gbases,
            const std::map<int, Eigen::MatrixXd> &polys,
            const std::map<int, std::pair<Eigen::MatrixXd, Eigen::MatrixXi>> &polys_3d,
            const bool boundary_only,
            Eigen::MatrixXd &points,
            Eigen::MatrixXi &tets,
            Eigen::MatrixXi &el_id,
            Eigen::MatrixXd &discr,
            Eigen::MatrixXd &local_points) const;
 
        void build_high_order_vis_mesh(
            const mesh::Mesh &mesh,
            const Eigen::VectorXi &output_orders,
            const std::vector<basis::ElementBases> &bases,
            Eigen::MatrixXd &points,
            std::vector<paraviewo::CellElement> &elements,
            Eigen::MatrixXi &el_id,
            Eigen::MatrixXd &discr,
            Eigen::MatrixXd &local_points) const;
    };
 
} // namespace polyfem::io