CorrelatedGaussianParameters Class Reference

A class for correlated Gaussian parameters. More...

#include <CorrelatedGaussianParameters.h>

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 23 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 ()
	The default Constructor. More...
	CorrelatedGaussianParameters (const CorrelatedGaussianParameters &orig)
	The copy constructor. More...
	CorrelatedGaussianParameters (std::string name_i)
	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() [1/3]

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;
    IsEOF = false;
}

CorrelatedGaussianParameters() [2/3]

CorrelatedGaussianParameters::CorrelatedGaussianParameters

(

)

The default Constructor.

Definition at line 25 of file CorrelatedGaussianParameters.cpp.

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

CorrelatedGaussianParameters() [3/3]

CorrelatedGaussianParameters::CorrelatedGaussianParameters

(

const CorrelatedGaussianParameters &

orig

)

The copy constructor.

Definition at line 33 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;
    IsEOF = orig.IsEOF;
}

~CorrelatedGaussianParameters()

CorrelatedGaussianParameters::~CorrelatedGaussianParameters ( )

virtual

The default destructor.

Definition at line 44 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

AddPar()

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 55 of file CorrelatedGaussianParameters.cpp.

{
    Pars.push_back(Par_i);
}

DiagonalizePars()

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 60 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);
    }
}

getCov()

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

inline

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

Definition at line 91 of file CorrelatedGaussianParameters.h.

    {
        return *Cov;
    }

getDiagPars()

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 100 of file CorrelatedGaussianParameters.h.

    {
        return DiagPars;
    }   

getName()

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 83 of file CorrelatedGaussianParameters.h.

    {
        return name;
    }

getOrigParsValue()

std::vector< double > CorrelatedGaussianParameters::getOrigParsValue

(

const std::vector< double > &

DiagPars_i

)

const

Definition at line 104 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);
}

getPar()

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 74 of file CorrelatedGaussianParameters.h.

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

getPars()

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 64 of file CorrelatedGaussianParameters.h.

    {
        return Pars;
    }

isEOF()

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 129 of file CorrelatedGaussianParameters.h.

    {
        return IsEOF;
    }

ParseCGP()

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 129 of file CorrelatedGaussianParameters.cpp.

{
    name = *beg;
    ++beg;
    int size = atoi((*beg).c_str());
    int nlines = 0;
    std::vector<bool> lines;
    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);
        lines.push_back(!tmpMP.IsFixed());
        if (beg != tok.end())
                if (rank == 0) std::cout << "WARNING: unread information in parameter " << tmpMP.getname() << std::endl;
        if (!tmpMP.IsFixed()) {
            tmpMP.setCgp_name(name);
            AddPar(tmpMP);
            nlines++;
        } else {
            ModPars.push_back(tmpMP);
        }
    }
    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++;
            if (lines.at(i)) {
                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);
                        }
                        if (lines.at(j)) {
                            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;
}

Member Data Documentation

Cov

gslpp::matrix<double>* CorrelatedGaussianParameters::Cov

private

The covariance matrix.

Definition at line 136 of file CorrelatedGaussianParameters.h.

DiagPars

std::vector<ModelParameter> CorrelatedGaussianParameters::DiagPars

private

The eigenvector of the covariance matrix.

Definition at line 140 of file CorrelatedGaussianParameters.h.

e

gslpp::vector<double>* CorrelatedGaussianParameters::e

private

The diagonalized parameters.

Definition at line 139 of file CorrelatedGaussianParameters.h.

IsEOF

bool CorrelatedGaussianParameters::IsEOF

private

Definition at line 141 of file CorrelatedGaussianParameters.h.

name

std::string CorrelatedGaussianParameters::name

private

The name of the correlated Gaussian Parameters set.

Definition at line 137 of file CorrelatedGaussianParameters.h.

Pars

std::vector<ModelParameter> CorrelatedGaussianParameters::Pars

private

A vector of parameters whose correlation will be calculated.

Definition at line 135 of file CorrelatedGaussianParameters.h.

v

gslpp::matrix<double>* CorrelatedGaussianParameters::v

private

The rotation matrix form the diagonalized parameters to the original parameters.

Definition at line 138 of file CorrelatedGaussianParameters.h.

---

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

• CorrelatedGaussianParameters.h
• CorrelatedGaussianParameters.cpp