JME::JetResolutionObject Class Reference

#include <JetResolutionObject.h>

Classes
class	Definition
struct	Range
class	Record

Public Member Functions
void	dump () const
float	evaluateFormula (const Record &record, const JetParameters &variables) const
const Definition &	getDefinition () const
const Record *	getRecord (const JetParameters &bins) const
const std::vector< Record > &	getRecords () const
	JetResolutionObject (const std::string &filename)
	JetResolutionObject (const JetResolutionObject &filename)
	JetResolutionObject ()
void	saveToFile (const std::string &file) const

Private Member Functions
template<class Archive >
void	serialize (Archive &ar, const unsigned int version)

Private Attributes
Definition	m_definition
std::vector< Record >	m_records
bool	m_valid = false

Friends
class	boost::serialization::access
template<typename CondSerializationT , typename Enabled >
struct	cond::serialization::access

Detailed Description

Definition at line 124 of file JetResolutionObject.h.

Constructor & Destructor Documentation

JME::JetResolutionObject::JetResolutionObject

(

const std::string &

filename

)

Definition at line 236 of file JetResolutionObject.cc.

References f, edm::errors::FileReadError, JME::getDefinitionLine(), geometryCSVtoXML::line, AlCaHLTBitMon_QueryRunRegistry::string, and JME::throwException().

                                                                      {

        // Parse file
        std::ifstream f(filename);

        if (! f.good()) {
            throwException(edm::errors::FileReadError, "Can't read input file '" + filename + "'");
        }

        for (std::string line; std::getline(f, line); ) {
            if ((line.empty()) || (line[0] == '#'))
                continue;

            std::string definition = getDefinitionLine(line);

            if (!definition.empty()) {
                m_definition = Definition(definition);
            } else {
                m_records.push_back(Record(line, m_definition));
            }
        }

        m_valid = true;
    }

JME::JetResolutionObject::JetResolutionObject

(

const JetResolutionObject &

filename

)

Definition at line 261 of file JetResolutionObject.cc.

                                                                              {
        m_definition = object.m_definition;
        m_records = object.m_records;
        m_valid = object.m_valid;

        m_definition.init();
    }

JME::JetResolutionObject::JetResolutionObject

(

)

Definition at line 269 of file JetResolutionObject.cc.

                                             {
        // Empty
    }

Member Function Documentation

void JME::JetResolutionObject::dump

(

void

)

const

Definition at line 274 of file JetResolutionObject.cc.

References stringResolutionProvider_cfi::bin, gather_cfg::cout, alignCSCRings::r, and record.

Referenced by JetResolutionDBReader::analyze(), and JetResolutionScaleFactorDBReader::analyze().

                                         {
        std::cout << "Definition: " << std::endl;
        std::cout << "    Number of binning variables: " << m_definition.nBins() << std::endl;
        std::cout << "        ";
        for (const auto& bin: m_definition.getBinsName()) {
            std::cout << bin << ", ";
        }
        std::cout << std::endl;
        std::cout << "    Number of variables: " << m_definition.nVariables() << std::endl;
        std::cout << "        ";
        for (const auto& bin: m_definition.getVariablesName()) {
            std::cout << bin << ", ";
        }
        std::cout << std::endl;
        std::cout << "    Formula: " << m_definition.getFormulaString() << std::endl;

        std::cout << std::endl << "Bin contents" << std::endl;

        for (const auto& record: m_records) {
            std::cout << "    Bins" << std::endl;
            size_t index = 0;
            for (const auto& bin: record.getBinsRange()) {
                std::cout << "        " << m_definition.getBinName(index) << " [" << bin.min << " - " << bin.max << "]" << std::endl;
                index++;
            }

            std::cout << "    Variables" << std::endl;
            index = 0;
            for (const auto& r: record.getVariablesRange()) {
                std::cout << "        " << m_definition.getVariableName(index) << " [" << r.min << " - " << r.max << "] " << std::endl;
                index++;
            }

            std::cout << "    Parameters" << std::endl;
            index = 0;
            for (const auto& par: record.getParametersValues()) {
                std::cout << "        Parameter #" << index << " = " << par << std::endl;
                index++;
            }
        }
    }

float JME::JetResolutionObject::evaluateFormula	(	const Record &	record,
		const JetParameters &	variables
	)		const

Definition at line 385 of file JetResolutionObject.cc.

References clip(), JME::JetParameters::createVector(), EcalElecEmulTccOnlyExample_cfg::formula, JME::JetResolutionObject::Record::getParametersValues(), JME::JetResolutionObject::Record::getVariablesRange(), and objects.autophobj::variables.

                                                                                                                                       {

        if (! m_valid)
            return 1;

#ifndef STANDALONE
        const auto* formula = m_definition.getFormula();
#else
        // Set parameters
        auto const* pFormula = m_definition.getFormula();
        if (! pFormula)
            return 1;
        auto formula = *pFormula;
#endif
        // Create vector of variables value. Throw if some values are missing
        std::vector<float> variables = variables_parameters.createVector(m_definition.getVariables());

        double variables_[4] = {0};
        for (size_t index = 0; index < m_definition.nVariables(); index++) {
            variables_[index] = clip(variables[index], record.getVariablesRange()[index].min, record.getVariablesRange()[index].max);
        }
        const std::vector<float>& parameters = record.getParametersValues();

#ifndef STANDALONE
        //ArrayAdaptor only takes doubles
        std::vector<double> parametersD(parameters.begin(),parameters.end());
        return formula->evaluate(
            reco::formula::ArrayAdaptor(variables_,m_definition.nVariables()),
            reco::formula::ArrayAdaptor(parametersD.data(),parametersD.size())
        );
#else
        for (size_t index = 0; index < parameters.size(); index++) {
            formula.SetParameter(index, parameters[index]);
        }

        return formula.EvalPar(variables_);
#endif
    }

const Definition& JME::JetResolutionObject::getDefinition ( ) const

inline

Definition at line 271 of file JetResolutionObject.h.

Referenced by JetResolutionDemo::analyze().

                                                    {
                return m_definition;
            }

const JetResolutionObject::Record * JME::JetResolutionObject::getRecord

(

const JetParameters &

bins

)

const

Definition at line 354 of file JetResolutionObject.cc.

References stringResolutionProvider_cfi::bin, create_public_pileup_plots::bins, JME::JetParameters::createVector(), and record.

                                                                                                              {
        // Find record for bins
        if (! m_valid)
            return nullptr;

        // Create vector of bins value. Throw if some values are missing
        std::vector<float> bins = bins_parameters.createVector(m_definition.getBins());

        // Iterate over all records, and find the one for which all bins are valid
        const Record* good_record = nullptr;
        for (const auto& record: m_records) {

            // Iterate over bins
            size_t valid_bins = 0;
            size_t current_bin = 0;
            for (const auto& bin: record.getBinsRange()) {
                if (bin.is_inside(bins[current_bin]))
                    valid_bins++;

                current_bin++;
            }

            if (valid_bins == m_definition.nBins()) {
                good_record = &record;
                break;
            }
        }

        return good_record;
    }

const std::vector<Record>& JME::JetResolutionObject::getRecords ( ) const

inline

Definition at line 267 of file JetResolutionObject.h.

Referenced by JetResolutionDemo::analyze().

                                                        {
                return m_records;
            }

void JME::JetResolutionObject::saveToFile

(

const std::string &

file

)

const

Definition at line 316 of file JetResolutionObject.cc.

References stringResolutionProvider_cfi::bin, groupFilesInBlocks::fout, JetCorrectorParameters::Record::nParameters(), AlCaHLTBitMon_ParallelJobs::p, alignCSCRings::r, record, and JetChargeProducer_cfi::var.

Referenced by JetResolutionDBReader::analyze(), and JetResolutionScaleFactorDBReader::analyze().

                                                                    {

        std::ofstream fout(file);
        fout.setf(std::ios::right);

        // Definition
        fout << "{" << m_definition.nBins();

        for (auto& bin: m_definition.getBinsName())
            fout << "    " << bin;

        fout << "    " << m_definition.nVariables();

        for (auto& var: m_definition.getVariablesName())
            fout << "    " << var;

        fout << "    " << (m_definition.getFormulaString().empty() ? "None" : m_definition.getFormulaString()) << "    Resolution}" << std::endl;

        // Records
        for (auto& record: m_records) {
            for (auto& r: record.getBinsRange()) {
                fout << std::left << std::setw(15) << r.min << std::setw(15) << r.max << std::setw(15);
            }
            fout << (record.nVariables() * 2 + record.nParameters()) << std::setw(15);

            for (auto& r: record.getVariablesRange()) {
                fout << r.min << std::setw(15) << r.max << std::setw(15);
            }

            for (auto& p: record.getParametersValues()) {
                fout << p << std::setw(15);
            }

            fout << std::endl << std::setw(0);
        }

    }

template<class Archive >

void JME::JetResolutionObject::serialize ( Archive &  ar, const unsigned int  version  )

private

Friends And Related Function Documentation

friend class boost::serialization::access

friend

Definition at line 281 of file JetResolutionObject.h.

template<typename CondSerializationT , typename Enabled >

friend struct cond::serialization::access

friend

Definition at line 281 of file JetResolutionObject.h.

Member Data Documentation

Definition JME::JetResolutionObject::m_definition

private

Definition at line 276 of file JetResolutionObject.h.

std::vector<Record> JME::JetResolutionObject::m_records

private

Definition at line 277 of file JetResolutionObject.h.

bool JME::JetResolutionObject::m_valid = false

private

Definition at line 279 of file JetResolutionObject.h.