#include <JetResolutionObject.h>

Public Member Functions
	Definition ()

	Definition (const std::string &definition)

std::string	getBinName (size_t bin) const

const std::vector< Binning > &	getBins () const

const std::vector< std::string > &	getBinsName () const

TFormula const *	getFormula () const

std::string	getFormulaString () const

const std::vector< std::string > &	getParametersName () const

std::string	getVariableName (size_t variable) const

const std::vector< Binning > &	getVariables () const

const std::vector< std::string > &	getVariablesName () const

void	init ()

size_t	nBins () const

size_t	nParameters () const

size_t	nVariables () const

Private Attributes
	COND_SERIALIZABLE

std::shared_ptr< TFormula > m_formula	COND_TRANSIENT

std::vector< Binning > m_bins	COND_TRANSIENT

std::vector< Binning > m_variables	COND_TRANSIENT

std::vector< std::string > m_parameters_name	COND_TRANSIENT

std::vector< std::string >	m_bins_name

std::string	m_formula_str

std::vector< std::string >	m_variables_name

Detailed Description

Definition at line 142 of file JetResolutionObject.h.

Constructor & Destructor Documentation

JME::JetResolutionObject::Definition::Definition ( )

inline

Definition at line 145 of file JetResolutionObject.h.

                                  {
                         // Empty
                     }

JME::JetResolutionObject::Definition::Definition ( const std::string & definition )

Definition at line 128 of file JetResolutionObject.cc.

References edm::errors::ConfigFileReadError, and JME::throwException().

                                                                          {
 
         std::vector<std::string> tokens = getTokens(definition);
 
         // We need at least 3 tokens
         if (tokens.size() < 3) {
             throwException(edm::errors::ConfigFileReadError, "Definition line needs at least three tokens. Please check file format.");
         }
 
         size_t n_bins = std::stoul(tokens[0]);
 
         if (tokens.size() < (n_bins + 2)) {
             throwException(edm::errors::ConfigFileReadError, "Invalid file format. Please check.");
         }
 
         for (size_t i = 0; i < n_bins; i++) {
             m_bins_name.push_back(tokens[i + 1]);
         }
 
         size_t n_variables = std::stoul(tokens[n_bins + 1]);
 
         if (tokens.size() < (1 + n_bins + 1 + n_variables + 1)) {
             throwException(edm::errors::ConfigFileReadError, "Invalid file format. Please check.");
         }
 
         for (size_t i = 0; i < n_variables; i++) {
             m_variables_name.push_back(tokens[n_bins + 2 + i]);
         }
 
         m_formula_str = tokens[n_bins + n_variables + 2];
 
         std::string formula_str_lower = m_formula_str;
         std::transform(formula_str_lower.begin(), formula_str_lower.end(), formula_str_lower.begin(), ::tolower);
 
         if (formula_str_lower == "none") {
           m_formula_str = "";
 
           if ((tokens.size() > n_bins + n_variables + 3) && (std::atoi(tokens[n_bins + n_variables + 3].c_str()))) {
             size_t n_parameters = std::stoul(tokens[n_bins + n_variables + 3]);
 
             if (tokens.size() < (1 + n_bins + 1 + n_variables + 1 + 1 + n_parameters)) {
               throwException(edm::errors::ConfigFileReadError, "Invalid file format. Please check.");
             }
 
             for (size_t i = 0; i < n_parameters; i++) {
               m_formula_str += tokens[n_bins + n_variables + 4 + i] + " ";
             }
           }
         }
 
         init();
     }

Member Function Documentation

std::string JME::JetResolutionObject::Definition::getBinName ( size_t bin ) const

inline

Definition at line 159 of file JetResolutionObject.h.

                                                            {
                         return m_bins_name[bin];
                     }

const std::vector<Binning>& JME::JetResolutionObject::Definition::getBins ( ) const

inline

Definition at line 155 of file JetResolutionObject.h.

                                                               {
                         return m_bins;
                     }

const std::vector<std::string>& JME::JetResolutionObject::Definition::getBinsName ( ) const

inline

Definition at line 151 of file JetResolutionObject.h.

                                                                     {
                         return m_bins_name;
                     }

TFormula const* JME::JetResolutionObject::Definition::getFormula ( ) const

inline

Definition at line 191 of file JetResolutionObject.h.

                                                         {
                         return m_formula.get();
                     }

std::string JME::JetResolutionObject::Definition::getFormulaString ( ) const

inline

Definition at line 187 of file JetResolutionObject.h.

                                                        {
                         return m_formula_str;
                     }

const std::vector<std::string>& JME::JetResolutionObject::Definition::getParametersName ( ) const

inline

Definition at line 183 of file JetResolutionObject.h.

183 { return m_parameters_name; }

std::string JME::JetResolutionObject::Definition::getVariableName ( size_t variable ) const

inline

Definition at line 175 of file JetResolutionObject.h.

                                                                      {
                         return m_variables_name[variable];
                     }

const std::vector<Binning>& JME::JetResolutionObject::Definition::getVariables ( ) const

inline

Definition at line 171 of file JetResolutionObject.h.

                                                                    {
                         return m_variables;
                     }

const std::vector<std::string>& JME::JetResolutionObject::Definition::getVariablesName ( ) const

inline

Definition at line 167 of file JetResolutionObject.h.

                                                                          {
                         return m_variables_name;
                     }

void JME::JetResolutionObject::Definition::init ( )

Definition at line 181 of file JetResolutionObject.cc.

References JME::throwException(), and edm::errors::UnimplementedFeature.

                                              {
         if (!m_formula_str.empty()) {
          if (m_formula_str.find(' ') == std::string::npos)
             m_formula = std::make_shared<TFormula>("jet_resolution_formula", m_formula_str.c_str());
          else
           m_parameters_name = getTokens(m_formula_str);
         }
         for (const auto& bin: m_bins_name) {
             const auto& b = JetParameters::binning_to_string.right.find(bin);
             if (b == JetParameters::binning_to_string.right.cend()) {
                 throwException(edm::errors::UnimplementedFeature, "Bin name not supported: '" + bin + "'");
             }
             m_bins.push_back(b->second);
         }
 
         for (const auto& v: m_variables_name) {
             const auto& var = JetParameters::binning_to_string.right.find(v);
             if (var == JetParameters::binning_to_string.right.cend()) {
                 throwException(edm::errors::UnimplementedFeature, "Variable name not supported: '" + v + "'");
             }
             m_variables.push_back(var->second);
         }
     }

size_t JME::JetResolutionObject::Definition::nBins ( ) const

inline

Definition at line 163 of file JetResolutionObject.h.

Referenced by JME::JetResolutionObject::Record::Record().

                                          {
                         return m_bins_name.size();
                     }

size_t JME::JetResolutionObject::Definition::nParameters ( ) const

inline

Definition at line 185 of file JetResolutionObject.h.

185 { return m_parameters_name.size(); }

size_t JME::JetResolutionObject::Definition::nVariables ( ) const

inline

Definition at line 179 of file JetResolutionObject.h.

Referenced by JME::JetResolutionObject::Record::Record().

                                               {
                         return m_variables.size();
                     }

Member Data Documentation

JME::JetResolutionObject::Definition::COND_SERIALIZABLE

private

Definition at line 206 of file JetResolutionObject.h.

std::shared_ptr<TFormula> m_formula JME::JetResolutionObject::Definition::COND_TRANSIENT

private

Definition at line 201 of file JetResolutionObject.h.

std::vector<Binning> m_bins JME::JetResolutionObject::Definition::COND_TRANSIENT

private

Definition at line 202 of file JetResolutionObject.h.

std::vector<Binning> m_variables JME::JetResolutionObject::Definition::COND_TRANSIENT

private

Definition at line 203 of file JetResolutionObject.h.

std::vector<std::string> m_parameters_name JME::JetResolutionObject::Definition::COND_TRANSIENT

private

Definition at line 204 of file JetResolutionObject.h.

std::vector<std::string> JME::JetResolutionObject::Definition::m_bins_name

private

Definition at line 197 of file JetResolutionObject.h.

std::string JME::JetResolutionObject::Definition::m_formula_str

private

Definition at line 199 of file JetResolutionObject.h.

std::vector<std::string> JME::JetResolutionObject::Definition::m_variables_name

private

Definition at line 198 of file JetResolutionObject.h.

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

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation