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

JetResolutionObject() [1/3]

JME::JetResolutionObject::JetResolutionObject

(

const std::string &

filename

)

Definition at line 247 of file JetResolutionObject.cc.

References f, corrVsCorr::filename, edm::errors::FileReadError, JME::getDefinitionLine(), mps_splice::line, m_definition, m_records, m_valid, HLT_2022v15_cff::Record, 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;
  }

JetResolutionObject() [2/3]

JME::JetResolutionObject::JetResolutionObject

(

const JetResolutionObject &

filename

)

Definition at line 271 of file JetResolutionObject.cc.

References JME::JetResolutionObject::Definition::init(), m_definition, m_records, and m_valid.

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

    m_definition.init();
  }

JetResolutionObject() [3/3]

JME::JetResolutionObject::JetResolutionObject

(

)

Definition at line 279 of file JetResolutionObject.cc.

                                           {
    // Empty
  }

Member Function Documentation

dump()

void JME::JetResolutionObject::dump

(

void

)

const

Definition at line 283 of file JetResolutionObject.cc.

References newFWLiteAna::bin, gather_cfg::cout, JME::JetResolutionObject::Definition::getBinName(), JME::JetResolutionObject::Definition::getBinsName(), JME::JetResolutionObject::Definition::getFormulaString(), JME::JetResolutionObject::Definition::getVariableName(), JME::JetResolutionObject::Definition::getVariablesName(), m_definition, m_records, JME::JetResolutionObject::Definition::nBins(), JME::JetResolutionObject::Definition::nVariables(), and AlCaHarvesting_cff::record.

                                       {
    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++;
      }
    }
  }

evaluateFormula()

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

Definition at line 394 of file JetResolutionObject.cc.

References clip(), JME::JetParameters::createVector(), pfMETCorrectionType0_cfi::formula, JME::JetResolutionObject::Definition::getFormula(), JME::JetResolutionObject::Definition::getVariables(), m_definition, m_valid, JME::JetResolutionObject::Definition::nVariables(), AlCaHarvesting_cff::record, 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
  }

getDefinition()

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

inline

Definition at line 229 of file JetResolutionObject.h.

References m_definition.

{ return m_definition; }

getRecord()

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

(

const JetParameters &

bins

)

const

Definition at line 364 of file JetResolutionObject.cc.

References newFWLiteAna::bin, trigObjTnPSource_cfi::bins, JME::JetParameters::createVector(), JME::JetResolutionObject::Definition::getBins(), m_definition, m_records, m_valid, JME::JetResolutionObject::Definition::nBins(), and AlCaHarvesting_cff::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;
  }

getRecords()

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

inline

Definition at line 227 of file JetResolutionObject.h.

References m_records.

{ return m_records; }

saveToFile()

void JME::JetResolutionObject::saveToFile

(

const std::string &

file

)

const

Definition at line 327 of file JetResolutionObject.cc.

References newFWLiteAna::bin, geometryDiff::file, groupFilesInBlocks::fout, JME::JetResolutionObject::Definition::getBinsName(), JME::JetResolutionObject::Definition::getFormulaString(), JME::JetResolutionObject::Definition::getVariablesName(), m_definition, m_records, JME::JetResolutionObject::Definition::nBins(), JME::JetResolutionObject::Definition::nVariables(), AlCaHLTBitMon_ParallelJobs::p, AlCaHarvesting_cff::record, and trigObjTnPSource_cfi::var.

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

serialize()

template<class Archive >

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

private

Friends And Related Function Documentation

boost::serialization::access

friend class boost::serialization::access

friend

Definition at line 237 of file JetResolutionObject.h.

cond::serialization::access

template<typename CondSerializationT , typename Enabled >

friend struct cond::serialization::access

friend

Definition at line 237 of file JetResolutionObject.h.

Member Data Documentation

m_definition

Definition JME::JetResolutionObject::m_definition

private

Definition at line 232 of file JetResolutionObject.h.

Referenced by dump(), evaluateFormula(), getDefinition(), getRecord(), JetResolutionObject(), and saveToFile().

m_records

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

private

Definition at line 233 of file JetResolutionObject.h.

Referenced by dump(), getRecord(), getRecords(), JetResolutionObject(), and saveToFile().

m_valid

bool JME::JetResolutionObject::m_valid = false

private

Definition at line 235 of file JetResolutionObject.h.

Referenced by evaluateFormula(), getRecord(), and JetResolutionObject().