OutStatsData.hpp

Go to the documentation of this file.

#pragma once
 
#include <polyfem/Common.hpp>
 
#include <polyfem/assembler/Problem.hpp>
#include <polyfem/basis/ElementBases.hpp>
#include <polyfem/mesh/Mesh.hpp>
 
#include <Eigen/Dense>
 
#include <string>
#include <vector>
 
namespace polyfem::io
{
    class OutRuntimeData
    {
    public:
        double building_basis_time = 0;
        double loading_mesh_time = 0;
        double computing_poly_basis_time = 0;
        double assembling_stiffness_mat_time = 0;
        double assembling_mass_mat_time = 0;
        double assigning_rhs_time = 0;
        double solving_time = 0;
 
        double total_time() const
        {
            return building_basis_time
                   + loading_mesh_time
                   + computing_poly_basis_time
                   + assembling_stiffness_mat_time
                   + assembling_mass_mat_time
                   + assigning_rhs_time
                   + solving_time;
        }
    };
 
    class OutStatsData
    {
    public:
        Eigen::Vector4d spectrum = Eigen::Vector4d::Zero();
 
        json solver_info;
 
        double mesh_size = 0;
        double min_edge_length = 0;
        double average_edge_length = 0;
 
        double l2_err = 0, linf_err = 0, lp_err = 0, h1_err = 0, h1_semi_err = 0, grad_max_err = 0;
 
        long long nn_zero = 0, mat_size = 0, num_dofs = 0;
 
        double max_angle = 0;
        double sigma_max = 0, sigma_min = 0, sigma_avg = 0;
 
        int n_flipped = 0;
 
        int simplex_count = 0;
        int prism_count = 0;
        int pyramid_count = 0;
        int regular_count = 0;
        int regular_boundary_count = 0;
        int simple_singular_count = 0;
        int multi_singular_count = 0;
        int boundary_count = 0;
        int non_regular_boundary_count = 0;
        int non_regular_count = 0;
        int undefined_count = 0;
        int multi_singular_boundary_count = 0;
 
        void compute_errors(const int n_bases,
                            const std::vector<polyfem::basis::ElementBases> &bases,
                            const std::vector<polyfem::basis::ElementBases> &gbases,
                            const polyfem::mesh::Mesh &mesh,
                            const assembler::Problem &problem,
                            const double tend,
                            const Eigen::MatrixXd &sol);
 
        void compute_mesh_stats(const polyfem::mesh::Mesh &mesh);
 
        void compute_mesh_size(const polyfem::mesh::Mesh &mesh_in, const std::vector<polyfem::basis::ElementBases> &bases_in, const int n_samples, const bool use_curved_mesh_size);
 
        void reset();
 
        void count_flipped_elements(const polyfem::mesh::Mesh &mesh, const std::vector<polyfem::basis::ElementBases> &gbases);
 
 
        void save_json(const nlohmann::json &args,
                       const int n_bases, const int n_pressure_bases,
                       const Eigen::MatrixXd &sol,
                       const mesh::Mesh &mesh,
                       const Eigen::VectorXi &disc_orders,
                       const Eigen::VectorXi &disc_ordersq,
                       const assembler::Problem &problem,
                       const OutRuntimeData &runtime,
                       const std::string &formulation,
                       const bool isoparametric,
                       const int sol_at_node_id,
                       nlohmann::json &j) const;
    };
} // namespace polyfem::io