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 116 of file JetResolutionObject.h.

Constructor & Destructor Documentation

JME::JetResolutionObject::JetResolutionObject

(

const std::string &

filename

)

Definition at line 230 of file JetResolutionObject.cc.

References f, edm::errors::FileReadError, JME::getDefinitionLine(), mps_splice::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 254 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 262 of file JetResolutionObject.cc.

                                           {
    // Empty
  }

Member Function Documentation

void JME::JetResolutionObject::dump

(

void

)

const

Definition at line 266 of file JetResolutionObject.cc.

References newFWLiteAna::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 377 of file JetResolutionObject.cc.

References clip(), JME::JetParameters::createVector(), pfMETCorrectionType0_cfi::formula, JME::JetResolutionObject::Record::getParametersValues(), JME::JetResolutionObject::Record::getVariablesRange(), and L1TEGammaDiff_cfi::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 224 of file JetResolutionObject.h.

Referenced by JetResolutionDemo::analyze().

{ return m_definition; }

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

(

const JetParameters &

bins

)

const

Definition at line 347 of file JetResolutionObject.cc.

References newFWLiteAna::bin, trigObjTnPSource_cfi::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 222 of file JetResolutionObject.h.

Referenced by JetResolutionDemo::analyze().

{ return m_records; }

void JME::JetResolutionObject::saveToFile

(

const std::string &

file

)

const

Definition at line 310 of file JetResolutionObject.cc.

References newFWLiteAna::bin, groupFilesInBlocks::fout, JetCorrectorParameters::Record::nParameters(), AlCaHLTBitMon_ParallelJobs::p, alignCSCRings::r, record, and trigObjTnPSource_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 232 of file JetResolutionObject.h.

template<typename CondSerializationT , typename Enabled >

friend struct cond::serialization::access

friend

Definition at line 232 of file JetResolutionObject.h.

Member Data Documentation

Definition JME::JetResolutionObject::m_definition

private

Definition at line 227 of file JetResolutionObject.h.

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

private

Definition at line 228 of file JetResolutionObject.h.

bool JME::JetResolutionObject::m_valid = false

private

Definition at line 230 of file JetResolutionObject.h.