A class for correlated Gaussian parameters. More...

#include <CorrelatedGaussianParameters.h>

Collaboration diagram for CorrelatedGaussianParameters:

Detailed Description

A class for correlated Gaussian parameters.

Author: HEPfit Collaboration

Copyright: GNU General Public License

This class builds the correlated Gaussian parameters that are specified in the SomeModel.conf file or specified by the user.

Definition at line 29 of file CorrelatedGaussianParameters.h.

Public Member Functions
void	AddPar (ModelParameter &Par_i)
	A method to add parameters to the list of correlated Gaussian parameters. More...

	CorrelatedGaussianParameters (std::string name_i)
	Constructor. More...

	CorrelatedGaussianParameters ()
	The default Constructor. More...

	CorrelatedGaussianParameters (const CorrelatedGaussianParameters &orig)
	The copy constructor. More...

void	DiagonalizePars (gslpp::matrix< double > Corr)
	Diagonalizes the correlated Gaussian parameters set. More...

gslpp::matrix< double >	getCov () const
	A get method to access the covariance matrix of the correlated Gaussian parameters. More...

const std::vector< ModelParameter > &	getDiagPars () const
	A get method to access the diagonalized parameters. More...

std::string	getName () const
	A get method to access the name of the correlated Gaussian parameters set. More...

std::vector< double >	getOrigParsValue (const std::vector< double > &DiagPars_i) const

ModelParameter	getPar (int i) const
	A get method to access an element of the vector of parameters that are defined in one correlated Gaussian parameters set. More...

const std::vector< ModelParameter > &	getPars () const
	A get method to access the vector of parameters that are defined in one correlated Gaussian parameters set. More...

bool	isEOF ()
	A method to check if the end of file has been reached. More...

int	ParseCGP (std::vector< ModelParameter > &ModPars, std::string &filename, std::ifstream &ifile, boost::tokenizer< boost::char_separator< char > >::iterator &beg, int lineNo, int rank)
	The parser for CorrelatedGaussianParameters. More...

virtual	~CorrelatedGaussianParameters ()
	The default destructor. More...

Private Attributes
gslpp::matrix< double > *	Cov
	The covariance matrix. More...

std::vector< ModelParameter >	DiagPars
	The eigenvector of the covariance matrix. More...

gslpp::vector< double > *	e
	The diagonalized parameters. More...

bool	IsEOF

std::string	name
	The name of the correlated Gaussian Parameters set. More...

std::vector< ModelParameter >	Pars
	A vector of parameters whose correlation will be calculated. More...

gslpp::matrix< double > *	v
	The rotation matrix form the diagonalized parameters to the original parameters. More...

Constructor & Destructor Documentation

CorrelatedGaussianParameters::CorrelatedGaussianParameters ( std::string name_i )

Constructor.

Parameters

[in] name_i a given name for the set of correlated Gaussian parameters

Definition at line 16 of file CorrelatedGaussianParameters.cpp.

 {
     name = name_i;
     Cov = NULL; 
     v = NULL;
     e = NULL;
 }

CorrelatedGaussianParameters::CorrelatedGaussianParameters ( )

The default Constructor.

Definition at line 24 of file CorrelatedGaussianParameters.cpp.

 {
     Cov = NULL; 
     v = NULL;
     e = NULL;
 }

CorrelatedGaussianParameters::CorrelatedGaussianParameters ( const CorrelatedGaussianParameters & orig )

The copy constructor.

Definition at line 31 of file CorrelatedGaussianParameters.cpp.

 {
     Pars = orig.Pars;
     name = orig.name;
     Cov = new gslpp::matrix<double>(*orig.Cov);
     v = new gslpp::matrix<double>(*orig.v);
     e = new gslpp::vector<double>(*orig.e);
     DiagPars = orig.DiagPars;
 }

CorrelatedGaussianParameters::~CorrelatedGaussianParameters ( )

virtual

The default destructor.

Definition at line 41 of file CorrelatedGaussianParameters.cpp.

 {   
     //Cov = new gslpp::matrix<double>(10, 10, 0.); /** Put in to prevent seg fault during error handling in InputParser **/
     if(Cov != NULL)
         delete(Cov);
     if(v != NULL)
         delete(v);
     if(e != NULL)
         delete(e);
 }

Member Function Documentation

void CorrelatedGaussianParameters::AddPar ( ModelParameter & Par_i )

A method to add parameters to the list of correlated Gaussian parameters.

Parameters

Par_i reference to an object of type ModelParameter

Definition at line 52 of file CorrelatedGaussianParameters.cpp.

 {
     Pars.push_back(Par_i);
 }

void CorrelatedGaussianParameters::DiagonalizePars ( gslpp::matrix< double > Corr )

Diagonalizes the correlated Gaussian parameters set.

Parameters

Corr	the correlation matrix for the correlated Gaussian parameters set

Definition at line 57 of file CorrelatedGaussianParameters.cpp.

 {
     unsigned int size = Pars.size();
     if (Corr.size_i() != size || Corr.size_j() != size)
         throw std::runtime_error("The size of the correlated parameters in " + name + " does not match the size of the correlation matrix!");
     Cov = new gslpp::matrix<double>(size, size, 0.);
     for (unsigned int i = 0; i < size; i++)
         for (unsigned int j = 0; j < size; j++)
             (*Cov)(i, j) = Pars.at(i).geterrg() * Corr(i, j) * Pars.at(j).geterrg();
 
     *Cov = Cov->inverse();
     
     gslpp::matrix<gslpp::complex>vv(size, size, 0.);
     gslpp::vector<gslpp::complex>ee(size, 0.);
 
     Cov->eigensystem(vv, ee);
 
     v = new gslpp::matrix<double>(size, size, 0.);
     e = new gslpp::vector<double>(size, 0.);
     *v = vv.real();
     *e = ee.real();
 
     gslpp::vector<double> ave_in(size, 0.);
     
     int ind = 0;
     for(std::vector<ModelParameter>::iterator it = Pars.begin(); it != Pars.end(); it++)
     {
         ave_in(ind) = it->getave();
         ind++;
     }
     
     gslpp::vector<double> ave = v->transpose() * ave_in;
     
     for (unsigned int i = 0; i < size; i++)
     {
         std::stringstream ss;
         ss << (i+1);
         std::string namei = name + ss.str();
         ModelParameter current(namei,ave(i),1./sqrt((*e)(i)),0.);
         current.setCgp_name(name);
         DiagPars.push_back(current);
     }
 }

gslpp::matrix<double> CorrelatedGaussianParameters::getCov ( ) const

inline

A get method to access the covariance matrix of the correlated Gaussian parameters.

Definition at line 97 of file CorrelatedGaussianParameters.h.

     {
         return *Cov;
     }

const std::vector<ModelParameter>& CorrelatedGaussianParameters::getDiagPars ( ) const

inline

A get method to access the diagonalized parameters.

Returns: a vector of type ModelParameters

Definition at line 106 of file CorrelatedGaussianParameters.h.

     {
         return DiagPars;
     }   

std::string CorrelatedGaussianParameters::getName ( ) const

inline

A get method to access the name of the correlated Gaussian parameters set.

Returns: the name

Definition at line 89 of file CorrelatedGaussianParameters.h.

     {
         return name;
     }

std::vector< double > CorrelatedGaussianParameters::getOrigParsValue ( const std::vector< double > & DiagPars_i ) const

Definition at line 101 of file CorrelatedGaussianParameters.cpp.

 {
     if (DiagPars_i.size() != DiagPars.size()) {
         std::stringstream out;
         out << DiagPars_i.size();
         throw std::runtime_error("CorrelatedGaussianParameters::getOrigParsValue(DiagPars_i): DiagPars_i.size() = " + out.str() + " does not match the size of DiagPars");
     }
     gslpp::vector<double> pars_in(DiagPars_i.size(), 0.);
 
     int ind = 0;
     for (std::vector<double>::const_iterator it = DiagPars_i.begin(); it != DiagPars_i.end(); it++) {
         pars_in(ind) = *it;
         ind++;
     }
 
     gslpp::vector<double> val = (*v) * pars_in;
 
     std::vector<double> res;
 
     for (unsigned int i = 0; i < DiagPars_i.size(); i++) {
         res.push_back(val(i));
     }
     return (res);
 }

ModelParameter CorrelatedGaussianParameters::getPar ( int i ) const

inline

A get method to access an element of the vector of parameters that are defined in one correlated Gaussian parameters set.

Returns: an element of the vector of type ModelParameter()

Definition at line 80 of file CorrelatedGaussianParameters.h.

     {
         return (Pars.at(i));
     }

const std::vector<ModelParameter>& CorrelatedGaussianParameters::getPars ( ) const

inline

A get method to access the vector of parameters that are defined in one correlated Gaussian parameters set.

Returns: a vector of type ModelParameter()

Definition at line 70 of file CorrelatedGaussianParameters.h.

     {
         return Pars;
     }

bool CorrelatedGaussianParameters::isEOF ( )

inline

A method to check if the end of file has been reached.

Returns: a boolean which is true if the end of file has been reached

Definition at line 135 of file CorrelatedGaussianParameters.h.

     {
         return IsEOF;
     }

int CorrelatedGaussianParameters::ParseCGP	(	std::vector< ModelParameter > &	ModPars,
		std::string &	filename,
		std::ifstream &	ifile,
		boost::tokenizer< boost::char_separator< char > >::iterator &	beg,
		int	lineNo,
		int	rank
	)

The parser for CorrelatedGaussianParameters.

Parameters

[in]	ModPars	the vector containing the model parameters
[in]	filename	the name of the config file being parsed
[in]	ifile	the stream containing the config file to be parsed
[in]	beg	the iterator that parses a line in the config file
[in]	lineNo	the current line number at which the file is being parsed
[in]	rank	the rank of the process that is using the parser

Returns: the line number (integer) after the parsing is done

Definition at line 126 of file CorrelatedGaussianParameters.cpp.

 {
     name = *beg;
     ++beg;
     int size = atoi((*beg).c_str());
     int nlines = 0;
     std::string line;
     boost::char_separator<char>sep(" \t");
     for (int i = 0; i < size; i++) {
         IsEOF = getline(ifile, line).eof();
         if (line.empty() || line.at(0) == '#') {
             if (rank == 0) throw std::runtime_error("ERROR: no comments or empty lines in CorrelatedGaussianParameters please! In line no." + boost::lexical_cast<std::string>(lineNo) + " of file " + filename);
             else sleep(2);
         }
         lineNo++;
         boost::tokenizer<boost::char_separator<char> > tok(line, sep);
         beg = tok.begin();
         std::string type = *beg;
         ++beg;
         if (type.compare("ModelParameter") != 0){
             if (rank == 0) throw std::runtime_error("ERROR: in line no." + boost::lexical_cast<std::string>(lineNo) + " of file " + filename + ", expecting a ModelParameter type here...\n");
             else sleep(2);
         }
         ModelParameter tmpMP;
         beg = tmpMP.ParseModelParameter(beg);
         if (beg != tok.end())
                 if (rank == 0) std::cout << "WARNING: unread information in parameter " << tmpMP.getname() << std::endl;
         tmpMP.setCgp_name(name);
         AddPar(tmpMP);
         nlines++;
     }
     if (nlines > 1) {
         gslpp::matrix<double> myCorr(gslpp::matrix<double>::Id(nlines));
         int ni = 0;
         for (int i = 0; i < size; i++) {
             IsEOF = getline(ifile, line).eof();
             if (line.empty() || line.at(0) == '#') {
                 if (rank == 0) throw std::runtime_error("ERROR: no comments or empty lines in CorrelatedGaussianParameters please! In line no." + boost::lexical_cast<std::string>(lineNo) + " of file " + filename);
                 else sleep(2);
             }
             lineNo++;
             boost::tokenizer<boost::char_separator<char> > mytok(line, sep);
             beg = mytok.begin();
             int nj = 0;
             for (int j = 0; j < size; j++) {
                 if ((*beg).compare(0, 1, "0") == 0
                         || (*beg).compare(0, 1, "1") == 0
                         || (*beg).compare(0, 1, "-") == 0) {
                     if (std::distance(mytok.begin(), mytok.end()) < size) { 
                         if (rank == 0) throw std::runtime_error("ERROR: invalid correlation matrix for " + name + ". Check element (" + boost::lexical_cast<std::string>(ni + 1) + "," + boost::lexical_cast<std::string>(nj + 1) + ") in line number " + boost::lexical_cast<std::string>(lineNo) + " in file " + filename + ".\n");
                         else sleep(2);
                     }
                     myCorr(ni, nj) = atof((*beg).c_str());
                     nj++;
                     beg++;
                 } else {
                     if (rank == 0) std::cout << "ERROR: invalid correlation matrix for "
                             << name << ". Check element (" << ni + 1 << "," << nj + 1 << ") in line number " + boost::lexical_cast<std::string>(lineNo) << std::endl;
                     exit(EXIT_FAILURE);
                 }
             }
             ni++;
         }
         DiagonalizePars(myCorr);
         ModPars.insert(ModPars.end(), getDiagPars().begin(), getDiagPars().end());
 
     } else {
         if (rank == 0) std::cout << "\nWARNING: Correlated Gaussian Parameters " << name.c_str() << " defined with less than two correlated parameters. The set is being marked as normal Parameters." << std::endl;
         if (getPars().size() == 1) ModPars.push_back(ModelParameter(getPar(0)));
         for (int i = 0; i < size; i++) {
             IsEOF = getline(ifile, line).eof();
             lineNo++;
         }
     }
     return lineNo;
 }