MCEngine.h

Go to the documentation of this file.

#ifndef MC_ENGINE_H
#define MC_ENGINE_H
 
#include <vector>
#include <random>
#include <string>
#include <memory>
 
#include "INuisanceSampler.h"
#include "ports/IModel.h"
#include "Statistics.h"
#include "GaussianApprox.h"
#include "Indexing.h"
#include "StatisticProgress.h"
 
struct MCConfig {
    std::size_t draws = 10000;
 
    double skew_abs_threshold = 0.2;
 
    double covariance_ridge_rel = 1e-8;
 
    double covariance_ridge_abs = 1e-12;
 
    bool retry_failed_predictions = true;
 
    std::size_t max_prediction_failures = 20000;
 
    std::size_t n_threads = 1;
 
    bool force_decay_threads_to_one = true;
 
    std::size_t forced_decay_threads = 1;
 
    bool print_progress = false;
 
    std::size_t progress_probe_draws = 5;
 
    std::size_t progress_update_every = 1;
 
    std::shared_ptr<StatisticProgressMonitor> progress_monitor {};
 
    bool write_samples_csv = false;
 
    std::string samples_csv_path = "obs_samples.csv";
};
 
struct MCRealization {
    ObsSamples sampled_obss;
 
    NuisanceSamples sampled_params;
};
 
struct MCObservableCovariance {
    std::vector<BinnedObservableId> ids;
 
    std::vector<double> mean;
 
    RealMatrix covariance;
 
    RealMatrix covariance_inv;
};
 
MCObservableCovariance covariance_from_obs_samples(
    const ObsSamples& S,
    const std::vector<BinnedObservableId>& ids,
    double ridge_rel = 1e-8,
    double ridge_abs = 1e-12
);
 
std::vector<BinnedObservableId> covariance_ids_from_first_sample(
    const ObsSamples& S
);
 
struct MCResult {
    MCRealization mc_real;
 
    std::vector<GaussianSummary> summary;
 
    MCObservableCovariance covariance;
};
 
class MonteCarloEngine {
public:
    MonteCarloEngine(const std::shared_ptr<IModel>& model, const INuisanceSampler& sampler, MCConfig cfg)
    : model_(model), sampler_(sampler), cfg_(cfg) {}
 
    MCRealization sample_predictions(const std::map<ParamId, double>& p) const;
 
    MCRealization sample_predictions_serial(const std::map<ParamId, double>& p) const;
    MCRealization sample_predictions_parallel(const std::map<ParamId, double>& p) const;
 
    MCResult summarize(const std::map<ParamId, double>& p) const;
 
private:
    const std::shared_ptr<IModel>& model_;  
    const INuisanceSampler& sampler_;       
    MCConfig cfg_;                          
};
 
#endif