NeutrinoFluxReweight::CentralValuesAndUncertainties Class Reference

A class to manage parameter central values and their uncertanities. More...

#include <CentralValuesAndUncertainties.h>

Public Member Functions
	CentralValuesAndUncertainties ()
void	readFromXML (const char *filename)
	Read a xml file name to parse the parameters. More...
void	addUncorrelated (Parameter &cv_par, double uncertainty)
	Add a parameter with its central value and its uncertainty. The parameter is specified as uncorrelated with all other parameters in the table, and any others that will be added. In that case, the uncertainty can be represented as a single floating point value. More...
void	addCorrelated (ParameterTable &cv_pars, TMatrixD &cov_mx)
	Add a set of parameters with correlated uncertainties. The central values of the parameters must be provided along with the covariance matrix of the parameters. These parameters are assumed to be block uncorrelated with all the other parameters. More...
void	setBaseSeed (int val)
	Set a beggining/base seed to be used in generating random parameter shifts for the many universe method. This base seed should be unique and not shared by any other many universe error calculator. More...
ParameterTable	calculateParsForUniverse (int universe)
	Calculate a table of randomly varied parameters for a particular universe i. The universe number is used, along with the base seed, to calculate a unique seed for this universe, allowing our computation to be repeatable. We loop over all uncorrelated parameters and sample each from a normal distribution with mean=CV parameter and variance=sqrate of the uncertainty. We loop over all correlated sets of parameters. For each, we have a list of N central values x and a single joint NxN covariance matrix V. We execute a cholesky decomposition of V to find a lower left diagonal matrix L such that L L^T =V. Then we generate. More...
ParameterTable	getCVPars ()
	Get the central value parameters. More...

Static Public Member Functions
static CentralValuesAndUncertainties *	getInstance ()

Private Attributes
ParameterTable	uncorrelated_pars
boost::interprocess::flat_map< std::string, double >	uncorrelated_errors
std::vector< ParameterTable >	correlated_par_tables
std::vector< TMatrixD >	covariance_matrices
TRandom3 *	r3
int	baseSeed

Static Private Attributes
static CentralValuesAndUncertainties *	instance = 0

Detailed Description

A class to manage parameter central values and their uncertanities.

Definition at line 20 of file CentralValuesAndUncertainties.h.

Constructor & Destructor Documentation

NeutrinoFluxReweight::CentralValuesAndUncertainties::CentralValuesAndUncertainties

(

)

Setting the seed to zero.

Definition at line 20 of file CentralValuesAndUncertainties.cpp.

                                                              {
    //! Setting the seed to zero. 
    r3=new TRandom3(0);
    baseSeed = 0;
  }

Member Function Documentation

void NeutrinoFluxReweight::CentralValuesAndUncertainties::addCorrelated	(	ParameterTable &	cv_pars,
		TMatrixD &	cov_mx
	)

Add a set of parameters with correlated uncertainties. The central values of the parameters must be provided along with the covariance matrix of the parameters. These parameters are assumed to be block uncorrelated with all the other parameters.

Definition at line 127 of file CentralValuesAndUncertainties.cpp.

                                                                                            {
    correlated_par_tables.push_back(cv_pars);
    covariance_matrices.push_back(cov_mx);
  } 

void NeutrinoFluxReweight::CentralValuesAndUncertainties::addUncorrelated	(	Parameter &	cv_par,
		double	uncertainty
	)

Add a parameter with its central value and its uncertainty. The parameter is specified as uncorrelated with all other parameters in the table, and any others that will be added. In that case, the uncertainty can be represented as a single floating point value.

Definition at line 121 of file CentralValuesAndUncertainties.cpp.

                                                                                          {
    uncorrelated_pars.setParameter(cv_par);
    uncorrelated_errors[cv_par.first] = uncertainty;
  }

ParameterTable NeutrinoFluxReweight::CentralValuesAndUncertainties::calculateParsForUniverse

(

int

universe

)

Calculate a table of randomly varied parameters for a particular universe i. The universe number is used, along with the base seed, to calculate a unique seed for this universe, allowing our computation to be repeatable. We loop over all uncorrelated parameters and sample each from a normal distribution with mean=CV parameter and variance=sqrate of the uncertainty. We loop over all correlated sets of parameters. For each, we have a list of N central values x and a single joint NxN covariance matrix V. We execute a cholesky decomposition of V to find a lower left diagonal matrix L such that L L^T =V. Then we generate.

We are going to use 100% correlated bin-to-bin for systematic errors in thin target data:

Definition at line 135 of file CentralValuesAndUncertainties.cpp.

                                                                                    {
    
    //If universe = -1, then it is the central value:
    double cvfactor = 1.0;
    if(universe==-1)cvfactor = 0.0;
    int univ_seed = baseSeed + universe;
    r3->SetSeed(univ_seed);    
    
    ParameterTable ptable;
    
    //! We are going to use 100% correlated bin-to-bin for systematic errors in thin target data:
    double sigma_pc_pip = r3->Gaus(0.0,1.0);
    double sigma_pc_pim = r3->Gaus(0.0,1.0);
    double sigma_pc_kap = r3->Gaus(0.0,1.0);
    double sigma_pc_kam = r3->Gaus(0.0,1.0);
    double sigma_pc_p   = r3->Gaus(0.0,1.0);
    double sigma_pc_n   = r3->Gaus(0.0,1.0);

    const boost::interprocess::flat_map<std::string, double>& table_uncorr_pars = uncorrelated_pars.getMap();
    boost::interprocess::flat_map<std::string, double>::const_iterator it = table_uncorr_pars.begin();
    for(;it!=table_uncorr_pars.end();++it){
      double sigma = r3->Gaus(0.0,1.0);
      //redefining sigma for 100% correlation:
      if((it->first).find("ThinTarget_pC_pip_sys")<10)sigma = sigma_pc_pip;
      if((it->first).find("ThinTarget_pC_pim_sys")<10)sigma = sigma_pc_pim;
      if((it->first).find("ThinTargetLowxF_pC_kap_sys")<10)sigma = sigma_pc_kap;
      if((it->first).find("ThinTargetLowxF_pC_kam_sys")<10)sigma = sigma_pc_kam;
      if((it->first).find("ThinTarget_pC_p_sys")<10)  sigma = sigma_pc_p;
      if((it->first).find("ThinTarget_pC_n_sys")<10)  sigma = sigma_pc_n;
      double new_val = it->second  + cvfactor*sigma*uncorrelated_errors[it->first];
      Parameter p(it->first,new_val);
      ptable.setParameter(p);      
    }
    
    TDecompChol *decomp;
    
    for(size_t ii=0;ii<covariance_matrices.size();++ii){
      
      decomp=new TDecompChol(covariance_matrices[ii],0.0);
      
      bool isPosDef=decomp->Decompose();
      TMatrixD MxU = decomp->GetU();
      delete decomp;
      TMatrixD MxV(MxU); 
      MxV.Transpose(MxU);
      int nmat = MxV.GetNcols();
      TVectorD vsigma(nmat);
      for(int jj=0;jj<nmat;jj++){
        vsigma[jj]=cvfactor*(r3->Gaus(0.0,1.0));
      }   
      TVectorD vecDShift = MxV*vsigma;
      
      const boost::interprocess::flat_map<std::string, double>& tb = (correlated_par_tables[ii]).getMap();
      boost::interprocess::flat_map<std::string, double>::const_iterator it_tb = tb.begin();

      for(;it_tb != tb.end();++it_tb){
        std::string tmp_name = it_tb->first;
        std::string snID = tmp_name.substr((it_tb->first).rfind("_")+1,(it_tb->first).length());
        std::stringstream ssID(snID);
        int nID;
        ssID >> nID;
        double new_val = it_tb->second + vecDShift[nID];        
        Parameter p(it_tb->first,new_val); 
        if(isPosDef)ptable.setParameter(p);
      }
      
    }
    
    return ptable; 
    
  }  

ParameterTable NeutrinoFluxReweight::CentralValuesAndUncertainties::getCVPars

(

)

Get the central value parameters.

Definition at line 207 of file CentralValuesAndUncertainties.cpp.

                                                         {      

    ParameterTable ptableCV;
    
    const boost::interprocess::flat_map<std::string, double>& table_pars=uncorrelated_pars.getMap();
    boost::interprocess::flat_map<std::string, double>::const_iterator it = table_pars.begin();
    for(;it!=table_pars.end();it++){
      Parameter p(it->first,it->second); 
      ptableCV.setParameter(p);      
    }
    
    //Correlated:
    for(size_t ii=0;ii<covariance_matrices.size();ii++){
      const boost::interprocess::flat_map<std::string, double>& corr_table_pars = correlated_par_tables[ii].getMap();
      it = corr_table_pars.begin();
      for(;it != corr_table_pars.end();it++){
        Parameter p(it->first,it->second); 
        ptableCV.setParameter(p);
      }
      
    }
    
    return ptableCV;
    
  }

CentralValuesAndUncertainties * NeutrinoFluxReweight::CentralValuesAndUncertainties::getInstance ( )

static

Definition at line 233 of file CentralValuesAndUncertainties.cpp.

                                                                           {
    if (instance == 0) instance = new CentralValuesAndUncertainties;
    return instance;
  }

void NeutrinoFluxReweight::CentralValuesAndUncertainties::readFromXML

(

const char *

filename

)

Read a xml file name to parse the parameters.

Reading the uncorrelated parameters:

Reading the uncorrelated list:

Reading the correlated parameters:

Definition at line 26 of file CentralValuesAndUncertainties.cpp.

                                                                     {
    using boost::property_tree::ptree;
    ptree top;
    
    read_xml(filename,top,2); // option 2 removes comment strings
    
    //! Reading the uncorrelated parameters:
    ptree& uncorrelated = top.get_child("pars.uncorrelated");
    ptree::iterator it = uncorrelated.begin();
    for(; it!=uncorrelated.end(); ++it){
      // it->first is the name
      // it->second is the child property tree
      double cv=it->second.get<double>("cv");
      double err=it->second.get<double>("err");
      Parameter p(it->first,cv);
      CentralValuesAndUncertainties::addUncorrelated(p,err);
    }

    //! Reading the uncorrelated list:
    ptree& uncorrelated_list = top.get_child("pars.uncorrelated_list");
    it = uncorrelated_list.begin();
    for(; it!=uncorrelated_list.end(); ++it){
      // it->first is the name
      // it->second is the child property tree

      std::string cvs_string=it->second.get<std::string>("cvs");
      std::string errs_string=it->second.get<std::string>("errs");
      double cv=0;
      int ii=0;
      std::string name;
      std::stringstream ss(cvs_string);
      std::vector<Parameter> tmp_par;
      while(ss >> cv){
        std::stringstream sID;
        sID << ii;
        std::string nameID = sID.str();
        name = it->first + "_" + nameID;
        Parameter p(name,cv);
        tmp_par.push_back(p);
        ii++;
      };
      
      double err=0;
      std::stringstream sserr(errs_string);
      ii=0;
      while(sserr >> err){
        CentralValuesAndUncertainties::addUncorrelated(tmp_par[ii],err);
        ii++;
      }     
      
    }
    
    //! Reading the correlated parameters:
    ptree& correlated = top.get_child("pars.correlated");
    it = correlated.begin();
    for(; it!=correlated.end(); ++it){
      // it->first is the name
      // it->second is the child property tree
      std::string cvs_string=it->second.get<std::string>("cvs");
      std::string covmx_string=it->second.get<std::string>("covmx");

      //filling the Parameter table:
      std::stringstream ss(cvs_string);
      double cv=0;
      int ii=0;
      std::string name;
      ParameterTable ptable;
      while(ss >> cv){
        std::stringstream sID;
        sID << ii;
        std::string nameID = sID.str();
        name = it->first + "_" +nameID;
        Parameter p(name,cv);
        ptable.setParameter(p);
        ii++;
      };
      TMatrixD mcov(ii,ii);
      //filling the matrix:
      std::stringstream ssmx(covmx_string);
      double err;
      int idx = 0;
      while(ssmx >> err){
        mcov(idx/ii,idx%ii) = err;
        idx++;
      }
      CentralValuesAndUncertainties::addCorrelated(ptable,mcov);
    }

    //Auxiliar parameter.
    //cv=1.0 and error 100%:
    Parameter par_aux("aux_parameter",1.0);
    CentralValuesAndUncertainties::addUncorrelated(par_aux,1.0);

  }

void NeutrinoFluxReweight::CentralValuesAndUncertainties::setBaseSeed

(

int

val

)

Set a beggining/base seed to be used in generating random parameter shifts for the many universe method. This base seed should be unique and not shared by any other many universe error calculator.

Definition at line 132 of file CentralValuesAndUncertainties.cpp.

                                                        {
    baseSeed = val;
  }

Member Data Documentation

int NeutrinoFluxReweight::CentralValuesAndUncertainties::baseSeed

private

Definition at line 54 of file CentralValuesAndUncertainties.h.

std::vector<ParameterTable> NeutrinoFluxReweight::CentralValuesAndUncertainties::correlated_par_tables

private

Definition at line 51 of file CentralValuesAndUncertainties.h.

std::vector<TMatrixD> NeutrinoFluxReweight::CentralValuesAndUncertainties::covariance_matrices

private

Definition at line 52 of file CentralValuesAndUncertainties.h.

CentralValuesAndUncertainties * NeutrinoFluxReweight::CentralValuesAndUncertainties::instance = 0

staticprivate

Definition at line 47 of file CentralValuesAndUncertainties.h.

TRandom3* NeutrinoFluxReweight::CentralValuesAndUncertainties::r3

private

Definition at line 53 of file CentralValuesAndUncertainties.h.

boost::interprocess::flat_map<std::string, double> NeutrinoFluxReweight::CentralValuesAndUncertainties::uncorrelated_errors

private

Definition at line 50 of file CentralValuesAndUncertainties.h.

ParameterTable NeutrinoFluxReweight::CentralValuesAndUncertainties::uncorrelated_pars

private

Definition at line 49 of file CentralValuesAndUncertainties.h.

---

The documentation for this class was generated from the following files:

• ppfx/include/CentralValuesAndUncertainties.h
• ppfx/src/CentralValuesAndUncertainties.cpp