ParameterManager.h

Go to the documentation of this file.

#ifndef PARAMETER_MANAGER_H
#define PARAMETER_MANAGER_H
 
#include <deal.II/base/parameter_acceptor.h>
#include <deal.II/base/conditional_ostream.h>
#include <deal.II/base/mpi.h>
#include <string>
 
// ANSI color codes for output formatting
#ifndef RESET
#define RESET   "\033[0m"
#define CYAN    "\033[36m"
#define BLUE    "\033[34m"
#define GREEN   "\033[32m"
#define MAGENTA "\033[35m"
#define YELLOW  "\033[33m"
#define RED     "\033[31m"
#define BOLD    "\033[1m"
#endif
 
using namespace dealii;
 
class SotParameterManager : public ParameterAcceptor
{
public:
    SotParameterManager(const MPI_Comm &comm);
 
    struct MeshParameters {
        unsigned int n_refinements = 0;          
        std::string grid_generator_function;     
        std::string grid_generator_arguments;    
        bool use_tetrahedral_mesh = false;      
        bool use_custom_density = false;        
        std::string density_file_path;          
        std::string density_file_format = "vtk"; 
        std::string density_field_name = "normalized_density"; 
    };
 
    struct SolverParameters {
        unsigned int max_iterations = 1000;      
        double tolerance = 1;                    
        std::string solver_control_type = "l1norm"; 
        double epsilon = 1e-3;      
        double tau = 1e-8;                       
        std::string distance_threshold_type = "pointwise"; 
        bool verbose_output = true;              
        std::string solver_type = "BFGS";        
        unsigned int quadrature_order = 3;       
        unsigned int nb_points = 1000;           
        unsigned int n_threads = 0;              
        bool use_epsilon_scaling = false;        
        double epsilon_scaling_factor = 2.0;     
        unsigned int epsilon_scaling_steps = 5;  
        bool use_log_sum_exp_trick = false;     
    };
 
    struct MultilevelParameters {
        // Source mesh hierarchy parameters
        bool source_enabled = false;             
        int source_min_vertices = 1000;         
        int source_max_vertices = 10000;        
        std::string source_hierarchy_dir = "output/data_multilevel/source_multilevel";  
        
        // Target point cloud hierarchy parameters
        bool target_enabled = false;            
        int target_min_points = 100;            
        int target_max_points = 1000;           
        std::string target_hierarchy_dir = "output/data_multilevel/target_multilevel";  
        bool use_softmax_potential_transfer = true;
        
        // Python clustering parameters
        bool use_python_clustering = false;     
        std::string python_script_name = "multilevel_clustering_scipy.py"; 
        
        // Common parameters
        std::string output_prefix = "output/multilevel/sot";  
    };
 
    struct PowerDiagramParameters {
        std::string implementation = "dealii";   
    };
 
    struct TransportMapParameters {
        double truncation_radius = -1.0;        
    };
 
    struct ConditionalDensityParameters {
        std::vector<unsigned int> indices;      
        std::string potential_folder = "";      
        double truncation_radius = -1.0;        
    };
 
    // Const access to parameters through getters
    const MeshParameters& get_source_params() const { return source_params; }
    const MeshParameters& get_target_params() const { return target_params; }
    const SolverParameters& get_solver_params() const { return solver_params; }
    const MultilevelParameters& get_multilevel_params() const { return multilevel_params; }
    const PowerDiagramParameters& get_power_diagram_params() const { return power_diagram_params; }
    const TransportMapParameters& get_transport_map_params() const { return transport_map_params; }
    const ConditionalDensityParameters& get_conditional_density_params() const { return conditional_density_params; }
 
    // Direct access to parameters through references
    MeshParameters& source_params;
    MeshParameters& target_params;
    SolverParameters& solver_params;
    MultilevelParameters& multilevel_params;
    PowerDiagramParameters& power_diagram_params;
    TransportMapParameters& transport_map_params;
    ConditionalDensityParameters& conditional_density_params;
    std::string& selected_task;
    std::string& io_coding;
 
    // MPI-related getters
    const MPI_Comm& get_mpi_communicator() const { return mpi_communicator; }
    const ConditionalOStream& get_pcout() const { return pcout; }
 
    void print_logo() const;
    virtual void print_parameters() const;
protected:
    // MPI members
    MPI_Comm mpi_communicator;
    const unsigned int n_mpi_processes;
    const unsigned int this_mpi_process;
    ConditionalOStream pcout;
 
    // Helper methods for printing specific parameter groups
    void print_mesh_parameters() const;
    void print_solver_parameters() const;
    void print_multilevel_parameters() const;
    void print_power_diagram_parameters() const;
    void print_transport_map_parameters() const;
    void print_conditional_density_parameters() const;
    void print_task_information() const;
    void print_section_header(const std::string& section_name) const;
    
private:
 
    // Storage for parameters
    std::string selected_task_storage;
    std::string io_coding_storage = "txt";
    MeshParameters source_params_storage;
    MeshParameters target_params_storage;
    SolverParameters solver_params_storage;
    MultilevelParameters multilevel_params_storage;
    PowerDiagramParameters power_diagram_params_storage;
    TransportMapParameters transport_map_params_storage;
    ConditionalDensityParameters conditional_density_params_storage;
};
 
 class LloydParameterManager : public SotParameterManager
 {
 public:
    LloydParameterManager(const MPI_Comm &comm);
 
    struct LloydParameters {
        unsigned int max_iterations = 1000;          
        double relative_tolerance = 1e-8;                     
    };
    
    const LloydParameters& get_lloyd_params() const { return lloyd_params; }
 
    // Direct access to parameters through references
    LloydParameters& lloyd_params;
    
    virtual void print_parameters() const override;
 private:
    // Helper methods for printing specific parameter groups
    void print_lloyd_parameters() const;
    void print_task_information() const;
    
    // Storage for parameters
    LloydParameters lloyd_params_storage;
 };
 
#endif