ObsManager.h

Go to the documentation of this file.

#ifndef OBSERVABLEMANAGER_H
#define OBSERVABLEMANAGER_H
 
#include <memory>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <optional>
#include <any>
 
#include "ParamID.h"
#include "Observable.h"
#include "Decays.h"
#include "IObsParameterProxy.h"
#include "ObsPortsConfig.h"
 
struct ObservableSelectionSnapshot {
    BinnedObservableId id;
    QCDOrder order = QCDOrder::LO;
    std::unordered_set<ParamId> dependencies;
    bool binned = false;
};
 
using DecayThreadSnapshot = std::unordered_map<DecayId, size_t>;
using DecayConfigSnapshot = std::unordered_map<DecayId, std::any>;
 
class ObsManager {
public:
    ObsManager(ObservablePortsConfig obs_port_conf, bool init_default_decays=true);
 
    ObsManager add_obs(Observables id, QCDOrder order, bool add_deps=false);
 
    ObsManager remove_obs(Observables id);
 
    ObsManager add_obs(ObservableId id, QCDOrder order, bool add_deps=false);
 
    ObsManager add_obs(BinnedObservableId id, QCDOrder order, bool add_deps=false);
 
    bool is_decay_binned(Decays decay) const;
 
    bool is_decay_binned(DecayId decay) const;
 
    bool is_observable_binned(Observables obs) const;
 
    bool is_observable_binned(ObservableId obs) const;
 
    ObsManager remove_obs(ObservableId id);
 
    std::vector<ObservableValue> evaluate(Observables id);
 
    std::vector<ObservableValue> evaluate(ObservableId id);
 
    ObservableValue evaluate(BinnedObservableId id);
 
    std::map<ObservableId, std::vector<ObservableValue>> evaluate_all();
 
    void add_custom_decay(DecayId id, std::shared_ptr<DecayParent> ptr);
 
    void add_obs_dep(Observables id, ParamId param);
 
    void add_obs_deps(Observables id, std::unordered_set<ParamId> params);
 
    void add_obs_dep(ObservableId id, ParamId param);
 
    void add_obs_deps(ObservableId id, std::unordered_set<ParamId> params);
 
    std::unordered_set<ParamId> get_all_ops_deps(ObservableId id);
 
    void add_all_obs_deps(Observables id);
 
    void add_all_obs_deps(ObservableId id);
 
    std::vector<BinnedObservableId> get_current_obss();
 
    std::shared_ptr<Observable> get_obs(Observables id);
 
    std::shared_ptr<Observable> get_obs(ObservableId id);
 
    ObservablePortsConfig& get_ports() {return obs_port_conf;}
 
    void select_decay(ObservableId id);
 
    void reload_params();
 
    void enable_obs();
 
    void set_decay_config(Decays dec, std::any config);
 
    ObsManager set_decay_threads(Decays dec, size_t n_threads);
 
    DecayThreadSnapshot snapshot_decay_threads() const;
 
    void set_all_decay_threads(size_t n_threads);
 
    void restore_decay_threads(const DecayThreadSnapshot& snapshot);
 
    DecayConfigSnapshot snapshot_decay_configs() const;
 
    void restore_decay_configs(const DecayConfigSnapshot& snapshot);
 
    std::vector<ObservableSelectionSnapshot> snapshot_observable_selection() const;
 
    ObsManager set_bkstarll_threads(size_t n_threads);
 
    ObsManager set_bkll_threads(size_t n_threads);
 
    ObsManager set_bsphi_threads(size_t n_threads);
 
    ObsManager set_lblll_threads(size_t n_threads);
 
private:
    std::unordered_map<DecayId, std::shared_ptr<DecayParent>> decays;
 
    std::map<ObservableId, std::shared_ptr<Observable>> obss;
 
    ObservableId ensure_present(Observables id, bool critical=true);
 
    ObservableId ensure_present(ObservableId id, bool critical=true);
 
    ObservablePortsConfig obs_port_conf;
 
    std::optional<DecayId> active_decay;
};
 
#endif // OBSERVABLEMANAGER_H