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

Public Member Functions
void	AddPar (ModelParameter &Par_i)
	A method to add parameters to the list of correlated Gaussian parameters.
	CorrelatedGaussianParameters ()
	The default Constructor.
	CorrelatedGaussianParameters (const CorrelatedGaussianParameters &orig)
	The copy constructor.
	CorrelatedGaussianParameters (std::string name_i)
	Constructor.
void	DiagonalizePars (TMatrixDSym Corr)
	Diagonalizes the correlated Gaussian parameters set.
const TMatrixDSym &	getCov () const
	A get method to access the covariance matrix of the correlated Gaussian parameters.
const std::vector< ModelParameter > &	getDiagPars () const
	A get method to access the diagonalized parameters.
std::string	getName () const
	A get method to access the name of the correlated Gaussian parameters set.
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.
const std::vector< ModelParameter > &	getPars () const
	A get method to access the vector of parameters that are defined in one correlated Gaussian parameters set.
bool	isEOF ()
	A method to check if the end of file has been reached.
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.
virtual	~CorrelatedGaussianParameters ()
	The default destructor.

Private Attributes
TMatrixDSym	Cov
	The covariance matrix.
std::vector< ModelParameter >	DiagPars
	The eigenvector of the covariance matrix.
gslpp::vector< double > *	e
	The diagonalized parameters.
bool	IsEOF
std::string	name
	The name of the correlated Gaussian Parameters set.
std::vector< ModelParameter >	Pars
	A vector of parameters whose correlation will be calculated.
gslpp::matrix< double > *	v
	The rotation matrix form the diagonalized parameters to the original parameters.

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

CorrelatedGaussianParameters() [2/3]

CorrelatedGaussianParameters::CorrelatedGaussianParameters

(

)

The default Constructor.

Definition at line 23 of file CorrelatedGaussianParameters.cpp.

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

CorrelatedGaussianParameters() [3/3]

CorrelatedGaussianParameters::CorrelatedGaussianParameters

(

const CorrelatedGaussianParameters &

orig

)

The copy constructor.

Definition at line 29 of file CorrelatedGaussianParameters.cpp.

                                                                                                   : Cov(orig.Cov)
 {
    Pars = orig.Pars;
    name = orig.name;
    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 39 of file CorrelatedGaussianParameters.cpp.

                                                            {
    //Cov = new gslpp::matrix<double>(10, 10, 0.); /** Put in to prevent seg fault during error handling in InputParser **/
    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 47 of file CorrelatedGaussianParameters.cpp.

                                                               {
    Pars.push_back(Par_i);
}

DiagonalizePars()

void CorrelatedGaussianParameters::DiagonalizePars

(

TMatrixDSym

Corr

)

Diagonalizes the correlated Gaussian parameters set.

Parameters

Corr	the correlation matrix for the correlated Gaussian parameters set

Definition at line 51 of file CorrelatedGaussianParameters.cpp.

                                                                   {
    unsigned int size = Pars.size();
    if (Corr.GetNrows() != size || Corr.GetNcols() != size)
        throw std::runtime_error("The size of the correlated parameters in " + name + " does not match the size of the correlation matrix!");
    Cov.ResizeTo(size,size);
    for (unsigned int i = 0; i < size; i++) {
        for (unsigned int j = i; j < size; j++) {
            Cov(i, j) = Pars.at(i).geterrg() * Corr(i, j) * Pars.at(j).geterrg();
            Cov(j, i) = Cov(i, j); // Make sure TMatrixDsym element (j,i) is stored symmetrically
        }
    }
 
    //    *Cov = Cov->inverse();
 
    TMatrixDSymEigen SE(Cov);
 
    TMatrixD vv(SE.GetEigenVectors());
    TVectorD ee(SE.GetEigenValues());
    unsigned int EVbad = 0;
 
    v = new gslpp::matrix<double>(size, size, 0.);
    e = new gslpp::vector<double>(size, 0.);
 
    for (unsigned int i = 0; i < size; i++) {
        (*e)(i) = ee(i);
        for (unsigned int j = 0; j < size; j++) {
            (*v)(i, j) = vv(i, j);
        }
        
        if (ee(i) <= 0.) {
            EVbad++;
        }
        
    }
    
    if (EVbad > 0) {
        std::cout << "WARNING: Covariance matrix of the correlated parameters in "<< name <<" is not a positive definite matrix!" << std::endl;
        std::cout << "("<< EVbad <<" non positive eigenvalue(s).)" << std::endl;
        sleep(2);
    }
    
    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.);
        ModelParameter current(namei, ave(i), sqrt((*e)(i)), 0.);
        current.setCgp_name(name);
        DiagPars.push_back(current);
        //std::cout << current << std::endl;
    }
}

getCov()

const TMatrixDSym & CorrelatedGaussianParameters::getCov ( ) const

inline

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

Definition at line 92 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 101 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 84 of file CorrelatedGaussianParameters.h.

    {
        return name;
    }

getOrigParsValue()

std::vector< double > CorrelatedGaussianParameters::getOrigParsValue

(

const std::vector< double > &

DiagPars_i

)

const

Definition at line 114 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 75 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 65 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 130 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 138 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) {
        TMatrixD myCorr(nlines, 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++;
            }
        }
        if (!myCorr.IsSymmetric()) {
            if (rank == 0) std::cout << "ERROR: invalid correlation matrix for "
                    << name << ". Correlation matrix is not symmetric." << std::endl;
            exit(EXIT_FAILURE);
        } else {
            TMatrixDSym mySCorr(nlines);
            for (int i = 0; i < nlines; i++) {
                for (int j = 0; j <= i; j++) {
                    mySCorr(i, j) = myCorr(i, j);
                    mySCorr(j, i) = mySCorr(i, j); // Make sure TMatrixDsym element (j,i) is stored symmetrically
                }
            }
            DiagonalizePars(mySCorr);
            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

TMatrixDSym CorrelatedGaussianParameters::Cov

private

The covariance matrix.

Definition at line 137 of file CorrelatedGaussianParameters.h.

DiagPars

std::vector<ModelParameter> CorrelatedGaussianParameters::DiagPars

private

The eigenvector of the covariance matrix.

Definition at line 141 of file CorrelatedGaussianParameters.h.

e

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

private

The diagonalized parameters.

Definition at line 140 of file CorrelatedGaussianParameters.h.

IsEOF

bool CorrelatedGaussianParameters::IsEOF

private

Definition at line 142 of file CorrelatedGaussianParameters.h.

name

std::string CorrelatedGaussianParameters::name

private

The name of the correlated Gaussian Parameters set.

Definition at line 138 of file CorrelatedGaussianParameters.h.

Pars

std::vector<ModelParameter> CorrelatedGaussianParameters::Pars

private

A vector of parameters whose correlation will be calculated.

Definition at line 136 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 139 of file CorrelatedGaussianParameters.h.

---

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

• CorrelatedGaussianParameters.h
• CorrelatedGaussianParameters.cpp