Parameters.h

Go to the documentation of this file.

#ifndef PARAMETERS_H
#define PARAMETERS_H
 
#include <memory>
#include <ranges>
#include <algorithm>
#include <unordered_set>
#include <functional>
 
#include "ParameterRouter.h"
#include "BlockAccessor.h"
#include "Interface.h"
#include "QCDHelper.h"
#include "EWHelper.h"
#include "config.hpp"
#include "SourcesView.h"
#include "DependentParameter.h"
 
// Forward declaration for strategy interface
class Parameters;
 
class ModelStrategy {
public:
    virtual std::unordered_set<BlockName> initializeParameters(class Parameters& params) = 0;
 
    virtual void postInitialization(Parameters& params) = 0;
 
    virtual ~ModelStrategy() = default;
 
    void add_absent_block(std::unordered_set<BlockName> _) {absent_blocks = _;};
 
    void remove_absent_block() {absent_blocks = std::unordered_set<BlockName>();}
protected:
    std::unordered_set<BlockName> absent_blocks;  
};
 
class SMModelStrategy : public ModelStrategy {
public:
    std::unordered_set<BlockName> initializeParameters(class Parameters& params) override;
 
    void postInitialization(Parameters& params) override;
};
 
class BSMModelStrategy : public ModelStrategy {
public:
    std::unordered_set<BlockName> initializeParameters(class Parameters& params) override;
 
    void postInitialization(Parameters& params) override;
};
 
class FlavorStrategy : public ModelStrategy {
public:
    std::unordered_set<BlockName> initializeParameters(class Parameters& params) override;
 
    void postInitialization(Parameters&) override {}
};
 
class GeneralModelStrategy : public ModelStrategy {
public:
    std::unordered_set<BlockName> initializeParameters(class Parameters& params) override;
 
    void postInitialization(Parameters&) override {}
};
 
class WilsonInputStrategy : public ModelStrategy {
public:
    std::unordered_set<BlockName> initializeParameters(class Parameters& params) override;
 
    void postInitialization(Parameters& params) override;
};
 
class DecayStrategy : public ModelStrategy {
public:
    std::unordered_set<BlockName> initializeParameters(class Parameters& params) override;
 
    void postInitialization(Parameters&) override {}
};
 
class ObservableStrategy : public ModelStrategy {
public:
    std::unordered_set<BlockName> initializeParameters(class Parameters& params) override;
 
    void postInitialization(Parameters&) override {}
};
 
class PassthroughStrategy : public ModelStrategy {
public:
    std::unordered_set<BlockName> initializeParameters(class Parameters& params) override;
 
    void postInitialization(Parameters&) override {}
};
 
class Parameters {
public:
    static std::shared_ptr<Parameters> GetInstance(ParameterType id = ParameterType::SM);
 
    void CleanupInstance(ParameterType id = ParameterType::SM);
 
    bool exist(const BlockName& block, LhaID pdgCode);
    
    scalar_t operator()(const BlockName& block, LhaID pdgCode) const;
 
    std::shared_ptr<Parameter> get_parameter(const BlockName& block, LhaID pdgCode);
 
    void setBlockValue(const BlockName& name, LhaID pdgCode, scalar_t value);
 
    std::map<LhaID, scalar_t> get_block_infos(BlockName blockName);
 
    double get_block_scale(BlockName blockName) const;
    
 
    std::unordered_set<BlockName> get_blocks_list();
 
    bool is_dependent_block(const BlockName& blockName) const;
 
    std::vector<std::string> get_source_blocks(const BlockName& blockName) const;
 
    std::vector<std::string> get_dependent_blocks(const BlockName& blockName) const;
 
    std::vector<std::string> get_all_source_blocks(const BlockName& blockName) const;
 
    std::vector<std::string> get_all_dependent_blocks(const BlockName& blockName) const;
    
    void changeParameterMode(const ParamId& param_id, ParameterMode new_mode);
 
    void shiftParameter(const ParamId& param_id, scalar_t shift_value);
 
    std::unordered_set<BlockName> init_blocks(ParameterType type);
 
    void freeze_block(const BlockName& blockName);
 
    void unfreeze_block(const BlockName& blockName);
 
    void freeze_param(const BlockName& blockName, const LhaID& id);
 
    void unfreeze_param(const BlockName& blockName, const LhaID& id);
 
    void detach_block(const BlockName& blockName);
 
    void reattach_block(const BlockName& blockName);
 
    void detach_param(const BlockName& blockName, const LhaID& id);
 
    void reattach_param(const BlockName& blockName, const LhaID& id);
 
    std::shared_ptr<BlockAccessor> get_block_accessor() { return this->blockAccessor;}
 
    void print_block(const std::string blockname);
    
    friend std::ostream& operator<<(std::ostream&, std::shared_ptr<Parameters>);
    
    ~Parameters() { LOG_DEBUG("Parameters at ", this); }
 
private:
    void claim_parameters(ParameterType type);
    
    explicit Parameters(std::shared_ptr<ModelStrategy> modelStrategy);
 
    static std::map<ParameterType, std::shared_ptr<Parameters>> instances;  
    std::shared_ptr<ModelStrategy> strategy;                                
    std::shared_ptr<BlockAccessor> blockAccessor;                           
 
    friend class ParametersFactory;                                          
    friend class DependentBlockManager;                                      
};
 
class ParametersFactory {
public:
    static std::shared_ptr<Parameters> GetParameters(ParameterType id);
 
    static std::shared_ptr<Parameters> CreateUncached(ParameterType id);
 
    static std::shared_ptr<Parameters> CreateUncachedRegistered(
        ParameterType id,
        const std::function<void(const std::shared_ptr<Parameters>&)>& register_before_postinit
    );
 
    static void removeParameters(ParameterType id);
 
    static void clear();
private:
    static std::map<ParameterType, std::shared_ptr<Parameters>> instances;  
 
    static std::shared_ptr<ModelStrategy> createStrategy(ParameterType id);
};
 
#endif