MartyWilson.h

Go to the documentation of this file.

#ifndef MARTY_WILSON_H
#define MARTY_WILSON_H
 
#include <complex>
#include <iostream>
#include <math.h>
 
#include "Wilson.h"
#include "DataFrame.h"
#include "CSVReader.h"
#include "InterpretedParam.h" //Only for template argument !!
#include "IMartyWilsonProxy.h"
#include "IMartyWilsonPathProxy.h"
#include "Utils.h"
 
struct MartyWilsonConfig {
    std::string model_name{"SM"};
 
    std::string generation_model_name{"SM"};
 
    bool sm_like_filter{false};
 
    bool bsm_split_generation{false};
 
    bool full_target_generation{false};
    
    LhaID coeff_id;
 
    std::string storage_block;
 
    fs::path model_path{};
 
    std::shared_ptr<IMartyWilsonProxy<InterpretedParam>> marty_proxy;
 
    std::shared_ptr<IMartyWilsonPathProxy> path_provider;
 
    std::string csv_path;
 
    static fs::path fallback_csv_path(const std::string& model_name) {
        return fs::temp_directory_path() / "pyhyperiso" / "MartyTemp" / (model_name + "_wilson.csv");
    }
 
    void refresh_csv_path() {
        if (path_provider) {
            csv_path = path_provider->wilson_csv_path(model_name).string();
        } else {
            csv_path = fallback_csv_path(model_name).string();
        }
    }
 
    MartyWilsonConfig(const LhaID& id,
                      const std::string& storage_block_name,
                      fs::path model_path,
                      std::shared_ptr<IMartyWilsonProxy<InterpretedParam>> proxy,
                      std::shared_ptr<IMartyWilsonPathProxy> paths = nullptr)
        : coeff_id(id),
          storage_block(storage_block_name),
          model_path(model_path),
          marty_proxy(proxy),
          path_provider(paths) {
        refresh_csv_path();
    }
 
    MartyWilsonConfig(const std::string& model_name,
                      const LhaID& id,
                      const std::string& storage_block_name,
                      fs::path model_path,
                      std::shared_ptr<IMartyWilsonProxy<InterpretedParam>> proxy,
                      std::shared_ptr<IMartyWilsonPathProxy> paths = nullptr)
        : model_name(model_name),
          generation_model_name(model_name),
          coeff_id(id),
          storage_block(storage_block_name),
          model_path(model_path),
          marty_proxy(proxy),
          path_provider(paths) {
        refresh_csv_path();
    }
 
    MartyWilsonConfig(const std::string& output_model_name,
                      const std::string& generation_model_name,
                      bool sm_like_filter,
                      bool bsm_split_generation,
                      bool full_target_generation,
                      const LhaID& id,
                      const std::string& storage_block_name,
                      fs::path model_path,
                      std::shared_ptr<IMartyWilsonProxy<InterpretedParam>> proxy,
                      std::shared_ptr<IMartyWilsonPathProxy> paths = nullptr)
        : model_name(output_model_name),
          generation_model_name(generation_model_name),
          sm_like_filter(sm_like_filter),
          bsm_split_generation(bsm_split_generation),
          full_target_generation(full_target_generation),
          coeff_id(id),
          storage_block(storage_block_name),
          model_path(model_path),
          marty_proxy(proxy),
          path_provider(paths) {
        refresh_csv_path();
    }
};
 
class MartyWilson : public WilsonCoefficient {
public:
    MartyWilson(MartyWilsonConfig config);
 
    std::string get_model() {
        return this->model;
    }
 
    void set_model(std::string model) {
        this->model = model;
    }
 
    std::shared_ptr<WilsonCoefficient> clone() const override {
        return std::make_shared<MartyWilson>(*this);
    }
 
private:
    std::string model{"SM"};
 
};
 
#endif // MARTY_WILSON_H