ObservableInterface.h

Go to the documentation of this file.

#ifndef OBSERVABLE_INTERFACE_H
#define OBSERVABLE_INTERFACE_H
 
#include <map>
#include <memory>
#include <vector>
#include <string>
#include <exception>
#include <iostream>
#include <cmath>
#include <utility>
 
#include "Include.h"
#include "Decays.h"
#include "ObsManager.h"
#include "ObsUseMarty.h"
#include "WilsonFreezer.h"
#include "LambdaDecay.h"
#include "WilsonMatchingPatch.h"
 
class ObservableInterface {
private:
    std::shared_ptr<ObsManager> manager;
 
    std::shared_ptr<ObservablePortsConfig> ports;
 
public:
    ObservableInterface();
 
    void add_custom_decay(DecayId id, std::shared_ptr<DecayParent> ptr);
 
    ObservableInterface& add_lambda_decay(LambdaDecayConfig config, bool add_observables=true);
 
    ObservableInterface& add_matching_patch(const WilsonMatchingPatch& patch);
 
    ObservableInterface& addMatchingPatch(const WilsonMatchingPatch& patch);
 
    ObservableInterface& add_observable(Observables obs, QCDOrder order, bool add_dependencies=false);
 
    ObservableInterface& add_observable(ObservableId obs, QCDOrder order, bool add_dependencies=false);
 
    ObservableInterface& add_observable(BinnedObservableId obs, QCDOrder order, bool add_dependencies=false);
 
    void add_observables(std::map<Observables, QCDOrder> obss, bool add_dependencies=false);
 
    void add_observables(std::map<ObservableId, QCDOrder> obss, bool add_dependencies=false);
 
    void add_observables(Decays decay, QCDOrder order, bool add_dependencies=false,
                         std::pair<double, double> bin={1.0, 6.0});
 
    void add_observables(DecayId decay, QCDOrder order, bool add_dependencies=false,
                         std::pair<double, double> bin={1.0, 6.0});
 
    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;
 
    void add_observable_parameter(Observables obs, ParamId pid);
 
    void add_observable_parameter(ObservableId obs, ParamId pid);
 
    void add_observable_parameters(Observables obs, std::unordered_set<ParamId> pids);
 
    void add_observable_parameters(ObservableId obs, std::unordered_set<ParamId> pids);
 
    std::vector<ObservableValue> compute_observable(Observables obs) const;
 
    std::vector<ObservableValue> compute_observable(ObservableId obs) const;
 
    ObservableValue compute_observable(BinnedObservableId obs) const;
 
    void remove_observable(Observables id);
 
    void remove_observable(ObservableId id);
 
    void remove_observables(std::unordered_set<Observables> ids);
    
    void remove_observables(Decays dec);
 
    scalar_t get_exp_value(Observables id);
 
    scalar_t get_exp_value(ObservableId id);
 
    scalar_t get_exp_value(BinnedObservableId id);
 
    scalar_t get_exp_value(ExperimentObs id);
    
    scalar_t get_exp_uncertainty(Observables id, UncertaintyType u_type=UncertaintyType::COMBINED);
 
    scalar_t get_exp_uncertainty(ObservableId id, UncertaintyType u_type=UncertaintyType::COMBINED);
 
    scalar_t get_exp_uncertainty(BinnedObservableId id, UncertaintyType u_type=UncertaintyType::COMBINED);
 
    scalar_t get_exp_uncertainty(ExperimentObs id, UncertaintyType u_type=UncertaintyType::COMBINED);
 
    std::vector<BinnedObservableId> get_current_observables();
 
    std::shared_ptr<ObservableInterface> clone_for_worker() const;
 
    DecayThreadSnapshot snapshot_decay_threads() const;
 
    void set_all_decay_threads(size_t n_threads);
 
    void restore_decay_threads(const DecayThreadSnapshot& snapshot);
 
    std::map<ObservableId, std::vector<ObservableValue>> compute_all();
 
    void set_param(const std::string& block, LhaID code, double value, ParameterType type);
 
    double get_param(const std::string& block, LhaID code, ParameterType type);
 
    std::unordered_set<ParamId> get_all_ops_deps(ObservableId id);
 
    std::unordered_set<ParamId> get_all_ops_deps(Observables id);
 
    void reload_params();
 
    void enable_obs();
 
    void set_decay_config(Decays dec, std::any config);
 
    void set_decay_threads(Decays dec, size_t n_threads);
 
    void set_bkstarll_threads(size_t n_threads);
 
    void set_bkll_threads(size_t n_threads);
 
    void set_bsphi_threads(size_t n_threads);
 
    void set_lblll_threads(size_t n_threads);
 
    ObservablePortsConfig& get_ports();
};
 
#endif