datahandler.h

Go to the documentation of this file.

//
// Author: Valerio Bertone: valerio.bertone@cern.ch
//
 
#pragma once
 
#include <string>
#include <vector>
#include <utility>
 
#include <apfel/apfelxx.h>
#include <yaml-cpp/yaml.h>
#include <gsl/gsl_rng.h>
 
namespace NangaParbat
{
  class DataHandler
  {
  public:
 
    enum Process: int {UnknownProcess = -1, DY = 0, SIDIS = 1, SIA = 2, DIA = 3};
 
    enum Observable: int {UnknownObservable = -1, dsigma_dxdydz = 0, dsigma_dxdQdz = 1, multiplicity = 2, F_uut = 3, opposite_sign_ratio = 4};
 
    struct Kinematics
    {
      Kinematics();
      bool empty() const;
      int                                    ndata;    
      double                                 Vs;       
      std::vector<double>                    qTv;      
      std::vector<std::pair<double, double>> qTmap;    
      std::vector<double>                    qTfact;   
      std::pair<double, double>              var1b;    
      std::pair<double, double>              var2b;    
      std::pair<double, double>              var3b;    
      bool                                   IntqT;    
      bool                                   Intv1;    
      bool                                   Intv2;    
      bool                                   Intv3;    
      bool                                   PSRed;    
      double                                 pTMin;    
      std::pair<double, double>              etaRange; 
    };
 
    struct Binning
    {
      Binning();
      double zmin;
      double zmax;
      double zav;
      bool Intz;
      double xmin;
      double xmax;
      double xav;
      bool Intx;
      double Qmin;
      double Qmax;
      double Qav;
      bool IntQ;
      double ymin;
      double ymax;
      double yav;
      bool Inty;
    };
 
    DataHandler(DataHandler const &DH);
 
    DataHandler(std::string const& name, YAML::Node const& datafile, gsl_rng* rng = nullptr, int const& fluctuation = 0, std::vector<double> const& t0 = {});
 
    void FluctuateData(gsl_rng *rng, int const &fluctuation);
 
    void SetMeans(std::vector<double> const& means, gsl_rng* rng = nullptr, int const& fluctuation = 0);
 
    std::string GetName() const { return _name; };
 
    YAML::Node GetDataFile() const { return _datafile; };
 
    Process GetProcess() const { return _proc; };
 
    Observable GetObservable() const { return _obs; };
 
    double GetTargetIsoscalarity() const { return _targetiso; };
 
    std::string GetHadron() const { return _hadron; };
 
    int GetCharge() const { return _charge; };
 
    std::vector<apfel::QuarkFlavour> GetTagging() const { return _tagging; };
 
    double GetPrefactor() const { return _prefact; };
 
    Kinematics GetKinematics() const { return _kin; };
 
    std::vector<double> GetMeanValues() const { return _means; };
 
    std::vector<double> GetFluctutatedData() const { return _fluctuations; };
 
    std::vector<double> GetUncorrelatedUnc() const { return _uncor; };
 
    std::vector<std::vector<double>> GetAddCorrelatedUnc() const { return _corra; };
 
    std::vector<std::vector<double>> GetMultCorrelatedUnc() const { return _corrm; };
 
    std::vector<std::vector<double>> GetCorrelatedUnc() const { return _corr; };
 
    apfel::matrix<double> GetCovarianceMatrix() const { return _covmat; };
 
    apfel::matrix<double> GetCholeskyDecomposition() const { return _CholL; };
 
    std::vector<double> GetT0() const { return _t0; };
 
    std::map<std::string, std::string> GetLabels() const { return _labels; };
 
    std::vector<Binning> GetBinning() const { return _bins; }
 
  protected:
 
    std::string                        _name;         
    YAML::Node                         _datafile;     
    Process                            _proc;         
    Observable                         _obs;          
    double                             _targetiso;    
    std::string                        _hadron;       
    double                             _charge;       
    std::vector<apfel::QuarkFlavour>   _tagging;      
    double                             _prefact;      
    Kinematics                         _kin;          
    std::vector<double>                _means;        
    std::vector<double>                _uncor;        
    std::vector<std::vector<double>>   _corra;        
    std::vector<std::vector<double>>   _corrm;        
    std::vector<std::vector<double>>   _corr;         
    apfel::matrix<double>              _covmat;       
    apfel::matrix<double>              _CholL;        
    std::map<std::string, std::string> _labels;       
    std::vector<double>                _fluctuations; 
    std::vector<double>                _t0;           
    std::vector<Binning>               _bins;         
 
    friend std::ostream& operator << (std::ostream& os, DataHandler const& DH);
  };
 
  std::ostream& operator << (std::ostream &os, DataHandler const& DH);
}