NeulandParticleFilter.h

Go to the documentation of this file.

#pragma once
#include "R3BNeulandPoint.h"
#include <R3BPDGConverter.h>
#include <cstdint>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
 
namespace R3B::Neuland
{
    class ParticleFilter
    {
      public:
        enum class Mode : uint8_t
        {
            whitelist,
            blacklist,
            pass,
        };

        struct Options
        {
            Mode mode = Mode::pass;                  
            double global_min_energy = 0.;           
            double global_max_energy = 0.;           
            std::vector<std::string> particle_names; 
            std::vector<double> energy_range_mins;   
            std::vector<double> energy_range_maxs;   
        };

        ParticleFilter() = default;

        explicit ParticleFilter(Mode mode)
            : mode_{ mode }
        {
        }

        static auto Create(const Options& options) -> ParticleFilter;

        void AddParticle(const std::string& particle_name, double min_energy = 0., double max_energy = 0.);

        void SetMinEnergy(double energy) { minimum_allowed_energy_ = energy; }

        void SetMaxEnergy(double energy) { maximum_allowed_energy_ = energy; }

        void SetMode(Mode mode) { mode_ = mode; }

        [[nodiscard]] auto GetMinEnergy() const -> double { return minimum_allowed_energy_; }

        [[nodiscard]] auto GetMaxEnergy() const -> double { return maximum_allowed_energy_; }

        [[nodiscard]] auto GetMode() const -> Mode { return mode_; }

        auto IsPointAllowed(const R3BNeulandPoint& neuland_point) -> bool;

        void Reset();

        auto Print() -> std::string;
 
        // void SetFilter(R3B::Neuland::BitSetParticle filtered_particles);
        // void SetFilter(R3B::Neuland::BitSetParticle filtered_particles, double minimum_allowed_energy);
        // [[nodiscard]] auto GetFilter() const -> R3B::Neuland::BitSetParticle { return filtered_particles_; }
 
      private:
        Mode mode_ = Mode::pass;                                      
        double minimum_allowed_energy_ = 0.;                          
        double maximum_allowed_energy_ = 0.;                          
        std::unordered_map<int32_t, std::pair<double, double>> list_; 
        PDGConverter pdg_converter_;
        // R3B::Neuland::BitSetParticle filtered_particles_ = R3B::Neuland::BitSetParticle::none;
        auto is_allowed_with_whitelist(const R3BNeulandPoint& neuland_point) -> bool;
        auto is_allowed_with_blacklist(const R3BNeulandPoint& neuland_point) -> bool;
    };
 
} // namespace R3B::Neuland