JetResolution Class Reference

#include <JetResolution.h>

Public Member Functions
void	initialize (const std::string &fileName, bool doGaussian=false)
	JetResolution ()
	JetResolution (const std::string &fileName, bool doGaussian=false)
const std::string &	name () const
TF1 *	parameter (const std::string &parameterName, const std::vector< float > &x)
TF1 *	parameterEta (const std::string &parameterName, float eta)
double	parameterEtaEval (const std::string &parameterName, float eta, float pt)
const JetCorrectorParameters &	parameters (int i) const
TF1 *	resolution (const std::vector< float > &x, const std::vector< float > &y) const
TF1 *	resolutionEtaPt (float eta, float pt) const
virtual	~JetResolution ()

Private Attributes
std::string	name_
std::vector< TF1 * >	parameterFncs_
std::vector < JetCorrectorParameters * >	parameters_
TF1 *	resolutionFnc_

Detailed Description

Definition at line 11 of file JetResolution.h.

Constructor & Destructor Documentation

JetResolution::JetResolution

(

)

Definition at line 36 of file JetResolution.cc.

References resolutionFnc_.

: resolutionFnc_(nullptr) { resolutionFnc_ = new TF1(); }

JetResolution::JetResolution	(	const std::string &	fileName,
		bool	doGaussian = false
	)

JetResolution::~JetResolution ( )

virtual

Definition at line 44 of file JetResolution.cc.

References mps_fire::i, parameterFncs_, parameters_, and resolutionFnc_.

                              {
  delete resolutionFnc_;
  for (unsigned i = 0; i < parameterFncs_.size(); i++)
    delete parameterFncs_[i];
  for (unsigned i = 0; i < parameters_.size(); i++)
    delete parameters_[i];
}

Member Function Documentation

void JetResolution::initialize	(	const std::string &	fileName,
		bool	doGaussian = false
	)

Definition at line 57 of file JetResolution.cc.

References cms::cuda::assert(), JetCorrectorParameters::definitions(), MillePedeFileConverter_cfg::fileName, fnc_dscb(), fnc_gaussalpha(), fnc_gaussalpha1alpha2(), EcalElecEmulTccOnlyExample_cfg::formula, JetCorrectorParameters::Definitions::formula(), JetCorrectorParameters::Definitions::level(), name(), name_, parameterFncs_, parameters_, resolutionFnc_, and createJobs::tmp.

                                                                      {
  size_t pos;

  name_ = fileName;
  pos = name_.find_last_of('.');
  name_ = name_.substr(0, pos);
  pos = name_.find_last_of('/');
  name_ = name_.substr(pos + 1);

  JetCorrectorParameters resolutionPars(fileName, "resolution");
  string fncname = "fResolution_" + name_;
  string formula = resolutionPars.definitions().formula();
  if (doGaussian)
    resolutionFnc_ = new TF1(fncname.c_str(), "gaus", 0., 5.);
  else if (formula == "DSCB")
    resolutionFnc_ = new TF1(fncname.c_str(), fnc_dscb, 0., 5., 7);
  else if (formula == "GaussAlpha1Alpha2")
    resolutionFnc_ = new TF1(fncname.c_str(), fnc_gaussalpha1alpha2, -5., 5., 5);
  else if (formula == "GaussAlpha")
    resolutionFnc_ = new TF1(fncname.c_str(), fnc_gaussalpha, -5., 5., 4);
  else
    resolutionFnc_ = new TF1(fncname.c_str(), formula.c_str(), 0., 5.);

  resolutionFnc_->SetNpx(200);
  resolutionFnc_->SetParName(0, "N");
  resolutionFnc_->SetParameter(0, 1.0);
  unsigned nPar(1);

  string tmp = resolutionPars.definitions().level();
  pos = tmp.find(':');
  while (!tmp.empty()) {
    string paramAsStr = tmp.substr(0, pos);
    if (!doGaussian || paramAsStr == "mean" || paramAsStr == "sigma") {
      parameters_.push_back(new JetCorrectorParameters(fileName, paramAsStr));
      formula = parameters_.back()->definitions().formula();
      parameterFncs_.push_back(new TF1(("f" + paramAsStr + "_" + name()).c_str(),
                                       formula.c_str(),
                                       parameters_.back()->record(0).parameters()[0],
                                       parameters_.back()->record(0).parameters()[1]));
      resolutionFnc_->SetParName(nPar, parameters_.back()->definitions().level().c_str());
      nPar++;
    }
    tmp = (pos == string::npos) ? "" : tmp.substr(pos + 1);
    pos = tmp.find(':');
  }

  assert(nPar == (unsigned)resolutionFnc_->GetNpar());
  assert(!doGaussian || nPar == 3);
}

const std::string& JetResolution::name ( ) const

inline

Definition at line 28 of file JetResolution.h.

References name_.

Referenced by config.CFG::__str__(), geometryComparison.GeometryComparison::createScript(), validation.Sample::digest(), primaryVertexResolution.PrimaryVertexResolution::getRepMap(), primaryVertexValidation.PrimaryVertexValidation::getRepMap(), zMuMuValidation.ZMuMuValidation::getRepMap(), initialize(), and VIDSelectorBase.VIDSelectorBase::initialize().

{ return name_; }

TF1 * JetResolution::parameter	(	const std::string &	parameterName,
		const std::vector< float > &	x
	)

Definition at line 142 of file JetResolution.cc.

References cms::cuda::assert(), newFWLiteAna::bin, EcnaPython_AdcPeg12_S1_10_R170298_1_0_150_Dee0::cerr, mps_fire::i, cuy::ii, N, parameterFncs_, parameters_, mps_fire::result, and findQualityFiles::size.

Referenced by parameterEta().

                                                                                 {
  TF1* result(nullptr);
  for (unsigned i = 0; i < parameterFncs_.size() && result == nullptr; i++) {
    string fncname = parameterFncs_[i]->GetName();
    if (fncname.find("f" + parameterName) == 0) {
      stringstream ssname;
      ssname << parameterFncs_[i]->GetName();
      for (unsigned ii = 0; ii < x.size(); ii++)
        ssname << "_" << parameters_[i]->definitions().binVar(ii) << x[ii];
      result = (TF1*)parameterFncs_[i]->Clone();
      result->SetName(ssname.str().c_str());
      int N = parameters_[i]->definitions().nParVar();
      int bin = parameters_[i]->binIndex(x);
      assert(bin >= 0);
      assert(bin < (int)parameters_[i]->size());
      const std::vector<float>& pars = parameters_[i]->record(bin).parameters();
      for (unsigned ii = 2 * N; ii < pars.size(); ii++)
        result->SetParameter(ii - 2 * N, pars[ii]);
    }
  }

  if (nullptr == result)
    cerr << "JetResolution::parameter() ERROR: no parameter " << parameterName << " found." << endl;

  return result;
}

TF1 * JetResolution::parameterEta	(	const std::string &	parameterName,
		float	eta
	)

Definition at line 135 of file JetResolution.cc.

References parameter(), and x.

Referenced by main().

                                                                       {
  vector<float> x;
  x.push_back(eta);
  return parameter(parameterName, x);
}

double JetResolution::parameterEtaEval	(	const std::string &	parameterName,
		float	eta,
		float	pt
	)

Definition at line 170 of file JetResolution.cc.

References newFWLiteAna::bin, JetCorrectorParameters::binIndex(), JetCorrectorParameters::definitions(), EnergyCorrector::etas, cms::cuda::func, cuy::ii, N, JetCorrectorParameters::Definitions::nParVar(), parameterFncs_, JetCorrectorParameters::Record::parameters(), parameters_, submitPVValidationJobs::params, JetCorrectorParameters::record(), JetCorrectorParameters::size(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                          {
  TF1* func(nullptr);
  JetCorrectorParameters* params(nullptr);
  for (std::vector<TF1*>::size_type ifunc = 0; ifunc < parameterFncs_.size(); ++ifunc) {
    std::string fncname = parameterFncs_[ifunc]->GetName();
    if (!(fncname.find("f" + parameterName) == 0))
      continue;
    params = parameters_[ifunc];
    func = (TF1*)parameterFncs_[ifunc];
    break;
  }

  if (!func)
    edm::LogError("ParameterNotFound") << "JetResolution::parameterEtaEval(): no parameter \"" << parameterName
                                       << "\" found" << std::endl;

  std::vector<float> etas;
  etas.push_back(eta);
  int bin = params->binIndex(etas);

  if (!(0 <= bin && bin < (int)params->size()))
    edm::LogError("ParameterNotFound") << "JetResolution::parameterEtaEval(): bin out of range: " << bin << std::endl;

  const std::vector<float>& pars = params->record(bin).parameters();

  int N = params->definitions().nParVar();
  for (unsigned ii = 2 * N; ii < pars.size(); ++ii) {
    func->SetParameter(ii - 2 * N, pars[ii]);
  }

  return func->Eval(pt);
}

const JetCorrectorParameters& JetResolution::parameters ( int  i ) const

inline

Definition at line 36 of file JetResolution.h.

References mps_fire::i, and parameters_.

{ return *(parameters_[i]); }

TF1 * JetResolution::resolution	(	const std::vector< float > &	x,
		const std::vector< float > &	y
	)		const

Definition at line 117 of file JetResolution.cc.

References cms::cuda::assert(), newFWLiteAna::bin, mps_fire::i, N, parameterFncs_, parameters_, resolutionFnc_, and findQualityFiles::size.

Referenced by resolutionEtaPt().

                                                                                   {
  unsigned N(y.size());
  for (unsigned iPar = 0; iPar < parameters_.size(); iPar++) {
    int bin = parameters_[iPar]->binIndex(x);
    assert(bin >= 0);
    assert(bin < (int)parameters_[iPar]->size());
    const std::vector<float>& pars = parameters_[iPar]->record(bin).parameters();
    for (unsigned i = 2 * N; i < pars.size(); i++)
      parameterFncs_[iPar]->SetParameter(i - 2 * N, pars[i]);
    float yy[4] = {};
    for (unsigned i = 0; i < N; i++)
      yy[i] = (y[i] < pars[2 * i]) ? pars[2 * i] : (y[i] > pars[2 * i + 1]) ? pars[2 * i + 1] : y[i];
    resolutionFnc_->SetParameter(iPar + 1, parameterFncs_[iPar]->Eval(yy[0], yy[1], yy[2], yy[3]));
  }
  return resolutionFnc_;
}

TF1 * JetResolution::resolutionEtaPt	(	float	eta,
		float	pt
	)		const

Definition at line 108 of file JetResolution.cc.

References resolution(), x, and y.

Referenced by main().

                                                             {
  vector<float> x;
  x.push_back(eta);
  vector<float> y;
  y.push_back(pt);
  return resolution(x, y);
}

Member Data Documentation

std::string JetResolution::name_

private

Definition at line 42 of file JetResolution.h.

Referenced by initialize(), and name().

std::vector<TF1*> JetResolution::parameterFncs_

private

Definition at line 44 of file JetResolution.h.

Referenced by initialize(), parameter(), parameterEtaEval(), resolution(), and ~JetResolution().

std::vector<JetCorrectorParameters*> JetResolution::parameters_

private

Definition at line 45 of file JetResolution.h.

Referenced by Mixins._TypedParameterizable::clone(), Types.PSet::clone(), Types.EDAlias::clone(), Mixins._TypedParameterizable::copy(), initialize(), parameter(), parameterEtaEval(), parameters(), resolution(), and ~JetResolution().

TF1* JetResolution::resolutionFnc_

mutableprivate

Definition at line 43 of file JetResolution.h.

Referenced by initialize(), JetResolution(), resolution(), and ~JetResolution().