Modules/src/JetResolution.cc

0001 #ifndef STANDALONE
0002 #include <JetMETCorrections/Modules/interface/JetResolution.h>
0003 #include <FWCore/Framework/interface/EventSetup.h>
0004 #include <FWCore/Framework/interface/ESHandle.h>
0005
0006 #include <CondFormats/DataRecord/interface/JetResolutionRcd.h>
0007 #include <CondFormats/DataRecord/interface/JetResolutionScaleFactorRcd.h>
0008 #else
0009 #include "JetResolution.h"
0010 #endif
0011
0012 #include <algorithm>
0013
0014 namespace JME {
0015
0016   JetResolution::JetResolution(const std::string& filename) {
0017     m_object = std::make_shared<JetResolutionObject>(filename);
0018   }
0019
0020   JetResolution::JetResolution(const JetResolutionObject& object) {
0021     m_object = std::make_shared<JetResolutionObject>(object);
0022   }
0023
0024 #ifndef STANDALONE
0025   const JetResolution JetResolution::get(const edm::EventSetup& setup, const Token& token) {
0026     return setup.getData(token);
0027   }
0028 #endif
0029
0030   float JetResolution::getResolution(const JetParameters& parameters) const {
0031     const JetResolutionObject::Record* record = m_object->getRecord(parameters);
0032     if (!record)
0033       return 1;
0034
0035     return m_object->evaluateFormula(*record, parameters);
0036   }
0037
0038   JetResolutionScaleFactor::JetResolutionScaleFactor(const std::string& filename) {
0039     m_object = std::make_shared<JetResolutionObject>(filename);
0040   }
0041
0042   JetResolutionScaleFactor::JetResolutionScaleFactor(const JetResolutionObject& object) {
0043     m_object = std::make_shared<JetResolutionObject>(object);
0044   }
0045
0046 #ifndef STANDALONE
0047   const JetResolutionScaleFactor JetResolutionScaleFactor::get(const edm::EventSetup& setup, const Token& token) {
0048     return setup.getData(token);
0049   }
0050 #endif
0051
0052   float JetResolutionScaleFactor::getScaleFactor(const JetParameters& parameters,
0053                                                  Variation variation /* = Variation::NOMINAL*/,
0054                                                  std::string uncertaintySource /* = ""*/) const {
0055     const JetResolutionObject::Record* record = m_object->getRecord(parameters);
0056     if (!record)
0057       return 1;
0058
0059     const std::vector<float>& parameters_values = record->getParametersValues();
0060     const std::vector<std::string>& parameter_names = m_object->getDefinition().getParametersName();
0061     size_t parameter = static_cast<size_t>(variation);
0062     if (!uncertaintySource.empty()) {
0063       if (variation == Variation::DOWN)
0064         parameter =
0065             std::distance(parameter_names.begin(),
0066                           std::find(parameter_names.begin(), parameter_names.end(), uncertaintySource + "Down"));
0067       else if (variation == Variation::UP)
0068         parameter = std::distance(parameter_names.begin(),
0069                                   std::find(parameter_names.begin(), parameter_names.end(), uncertaintySource + "Up"));
0070       if (parameter >= parameter_names.size()) {
0071         std::string s;
0072         for (const auto& piece : parameter_names)
0073           s += piece + " ";
0074         throw cms::Exception("InvalidParameter")
0075             << "Invalid value for 'uncertaintySource' parameter. Only " + s + " are supported.\n";
0076       }
0077     }
0078     return parameters_values[parameter];
0079   }
0080
0081 }  // namespace JME
0082
0083 #ifndef STANDALONE
0084 #include "FWCore/Utilities/interface/typelookup.h"
0085 TYPELOOKUP_DATA_REG(JME::JetResolution);
0086 TYPELOOKUP_DATA_REG(JME::JetResolutionScaleFactor);
0087 #endif