Parameter.h

Go to the documentation of this file.

#ifndef PARAMETER_H
#define PARAMETER_H
 
#include <string>
#include <iostream>
#include <functional>
 
#include "Logger.h"
#include "Include.h"
#include "Math.h"
 
class Block;
 
enum class ParameterMode {
    FIXED,      
    SHIFTABLE   
};
 
class Parameter : public std::enable_shared_from_this<Parameter> {
protected:
    ParamId id;                                         
    scalar_t expected;                                  
    scalar_t deviation_stat;                            
    scalar_t deviation_syst;                            
    scalar_t shift;                                     
    ParameterMode mode;                                 
    std::vector<std::shared_ptr<Parameter>> observers;  
    std::weak_ptr<Block> owner_block;                   
    std::optional<double> scale;                        
    std::optional<std::pair<double, double>> binning;   
 
public:
    inline Parameter() : id({ParameterType::SM, "NullBlock", 0}), expected(0), deviation_stat(0), deviation_syst(0), shift(0), mode(ParameterMode::FIXED) {}
    
    Parameter(ParamId id, scalar_t mean, scalar_t std_stat, scalar_t std_syst);
 
    Parameter(const Parameter& other);
 
    void set_mode(ParameterMode mode);
 
    void set_std(scalar_t stat, scalar_t syst);
 
    void set_scale(double scale);
 
    void set_bin(std::pair<double, double> bin);
 
    void set_id(ParamId id);
 
    virtual scalar_t get_val() const;
 
    void set_expected(scalar_t val);
 
    void set_expected_silent(scalar_t val);
 
    scalar_t get_combined_std() const;
 
    std::pair<scalar_t, scalar_t> get_std() const;
 
    double get_scale();
 
    std::pair<double, double> get_bin();
 
 
    ParamId get_id() const;
 
    void set_owner(ParameterType type);
 
    void set_shift(scalar_t shift);
 
    void addObserver(std::shared_ptr<Parameter> observer);
 
    void removeObserver(std::shared_ptr<Parameter> observer);
 
    void notifyObservers();
 
    void notifyParamObserversOnly();
 
    virtual void update() {}
 
    virtual void freeze() {}
 
    virtual void unfreeze() {}
 
    virtual void clear_above() {}
 
    virtual void clear_below();
 
    virtual std::unordered_map<ParamId, std::shared_ptr<Parameter>> get_source_parameters() const;
 
    void set_owner_block(std::weak_ptr<Block> owner);
 
    std::weak_ptr<Block> get_owner_block() const;
    
    void overwrite_payload_from(const Parameter& other);
    
    Parameter& operator=(const Parameter& other);
 
    friend std::ostream& operator<<(std::ostream& os, const Parameter& p);
 
    Parameter& operator+=(const Parameter& other);
 
    Parameter& operator*=(const scalar_t& scale);
 
    virtual ~Parameter() = default;
};
 
 
 
#endif // PARAMETER_H