CMS 3D CMS Logo

JetCorrectorParameters.cc
Go to the documentation of this file.
1 //
2 // Original Author: Fedor Ratnikov Nov 9, 2007
3 // $Id: JetCorrectorParameters.cc,v 1.20 2012/03/01 18:24:53 srappocc Exp $
4 //
5 // Generic parameters for Jet corrections
6 //
9 #include <iostream>
10 #include <iomanip>
11 #include <fstream>
12 #include <sstream>
13 #include <cstdlib>
14 #include <algorithm>
15 #include <cmath>
16 #include <iterator>
17 
18 //------------------------------------------------------------------------
19 //--- JetCorrectorParameters::Definitions constructor --------------------
20 //--- takes specific arguments for the member variables ------------------
21 //------------------------------------------------------------------------
22 JetCorrectorParameters::Definitions::Definitions(const std::vector<std::string>& fBinVar, const std::vector<std::string>& fParVar, const std::string& fFormula, bool fIsResponse)
23 {
24  for(unsigned i=0;i<fBinVar.size();i++)
25  mBinVar.push_back(fBinVar[i]);
26  for(unsigned i=0;i<fParVar.size();i++)
27  mParVar.push_back(fParVar[i]);
28  mFormula = fFormula;
29  mIsResponse = fIsResponse;
30  mLevel = "";
31 }
32 //------------------------------------------------------------------------
33 //--- JetCorrectorParameters::Definitions constructor --------------------
34 //--- reads the member variables from a string ---------------------------
35 //------------------------------------------------------------------------
37 {
38  std::vector<std::string> tokens = getTokens(fLine);
39  if (!tokens.empty())
40  {
41  if (tokens.size() < 6)
42  {
43  std::stringstream sserr;
44  sserr<<"(line "<<fLine<<"): less than 6 expected tokens:"<<tokens.size();
45  handleError("JetCorrectorParameters::Definitions",sserr.str());
46  }
47  unsigned nvar = getUnsigned(tokens[0]);
48  unsigned npar = getUnsigned(tokens[nvar+1]);
49  for(unsigned i=0;i<nvar;i++)
50  mBinVar.push_back(tokens[i+1]);
51  for(unsigned i=0;i<npar;i++)
52  mParVar.push_back(tokens[nvar+2+i]);
53  mFormula = tokens[npar+nvar+2];
54  std::string ss = tokens[npar+nvar+3];
55  if (ss == "Response")
56  mIsResponse = true;
57  else if (ss == "Correction")
58  mIsResponse = false;
59  else if (ss == "Resolution")
60  mIsResponse = false;
61  else if (ss.find("PAR")==0)
62  mIsResponse = false;
63  else
64  {
65  std::stringstream sserr;
66  sserr<<"unknown option ("<<ss<<")";
67  handleError("JetCorrectorParameters::Definitions",sserr.str());
68  }
69  mLevel = tokens[npar+nvar+4];
70  }
71 }
72 //------------------------------------------------------------------------
73 //--- JetCorrectorParameters::Record constructor -------------------------
74 //--- reads the member variables from a string ---------------------------
75 //------------------------------------------------------------------------
76 JetCorrectorParameters::Record::Record(const std::string& fLine,unsigned fNvar) : mMin(0),mMax(0)
77 {
78  mNvar = fNvar;
79  // quckly parse the line
80  std::vector<std::string> tokens = getTokens(fLine);
81  if (!tokens.empty())
82  {
83  if (tokens.size() < 3)
84  {
85  std::stringstream sserr;
86  sserr<<"(line "<<fLine<<"): "<<"three tokens expected, "<<tokens.size()<<" provided.";
87  handleError("JetCorrectorParameters::Record",sserr.str());
88  }
89  for(unsigned i=0;i<mNvar;i++)
90  {
91  mMin.push_back(getFloat(tokens[i*2]));
92  mMax.push_back(getFloat(tokens[i*2+1]));
93  }
94  unsigned nParam = getUnsigned(tokens[2*mNvar]);
95  if (nParam != tokens.size()-(2*mNvar+1))
96  {
97  std::stringstream sserr;
98  sserr<<"(line "<<fLine<<"): "<<tokens.size()-(2*mNvar+1)<<" parameters, but nParam="<<nParam<<".";
99  handleError("JetCorrectorParameters::Record",sserr.str());
100  }
101  for (unsigned i = (2*mNvar+1); i < tokens.size(); ++i)
102  mParameters.push_back(getFloat(tokens[i]));
103  }
104 }
105 std::ostream& operator<<(std::ostream& out, const JetCorrectorParameters::Record& fBin)
106 {
107  for(unsigned j=0;j<fBin.nVar();j++)
108  out<<fBin.xMin(j)<<" "<<fBin.xMax(j)<<" ";
109  out<<fBin.nParameters()<<" ";
110  for(unsigned j=0;j<fBin.nParameters();j++)
111  out<<fBin.parameter(j)<<" ";
112  out<<std::endl;
113  return out;
114 }
115 //------------------------------------------------------------------------
116 //--- JetCorrectorParameters constructor ---------------------------------
117 //--- reads the member variables from a string ---------------------------
118 //------------------------------------------------------------------------
120 {
121  std::ifstream input(fFile.c_str());
122  std::string currentSection = "";
124  std::string currentDefinitions = "";
125  while (std::getline(input,line))
126  {
128  std::string tmp = getDefinitions(line);
129  if (!section.empty() && tmp.empty())
130  {
131  currentSection = section;
132  continue;
133  }
134  if (currentSection == fSection)
135  {
136  if (!tmp.empty())
137  {
138  currentDefinitions = tmp;
139  continue;
140  }
141  Definitions definitions(currentDefinitions);
142  if (!(definitions.nBinVar()==0 && definitions.formula()==""))
145  bool check(true);
146  for(unsigned i=0;i<mDefinitions.nBinVar();++i)
147  if (record.xMin(i)==0 && record.xMax(i)==0)
148  check = false;
149  if (record.nParameters() == 0)
150  check = false;
151  if (check)
152  mRecords.push_back(record);
153  }
154  }
155  if (currentDefinitions=="")
156  handleError("JetCorrectorParameters","No definitions found!!!");
157  if (mRecords.empty() && currentSection == "") mRecords.push_back(Record());
158  if (mRecords.empty() && currentSection != "")
159  {
160  std::stringstream sserr;
161  sserr<<"the requested section "<<fSection<<" doesn't exist!";
162  handleError("JetCorrectorParameters",sserr.str());
163  }
164  std::sort(mRecords.begin(), mRecords.end());
165  valid_ = true;
166 
168  {
169  init();
170  }
171  else
172  {
173  std::stringstream sserr;
174  sserr<<"since the binned dimensionality is greater than "<<MAX_SIZE_DIMENSIONALITY
175  <<" the SimpleJetCorrector will default to using the legacy binIndex function!";
176  handleError("JetCorrectorParameters",sserr.str());
177  }
178 }
179 //------------------------------------------------------------------------
180 //--- initializes the correct JetCorrectorParametersHelper ---------------
181 //------------------------------------------------------------------------
183 {
184  std::sort(mRecords.begin(), mRecords.end());
185  helper = std::make_shared<JetCorrectorParametersHelper>();
186  helper->init(mDefinitions,mRecords);
187 }
188 //------------------------------------------------------------------------
189 //--- returns the index of the record defined by fX ----------------------
190 //------------------------------------------------------------------------
191 int JetCorrectorParameters::binIndex(const std::vector<float>& fX) const
192 {
193  int result = -1;
194  unsigned N = mDefinitions.nBinVar();
195  if (N != fX.size())
196  {
197  std::stringstream sserr;
198  sserr<<"# bin variables "<<N<<" doesn't correspont to requested #: "<<fX.size();
199  handleError("JetCorrectorParameters",sserr.str());
200  }
201  unsigned tmp;
202  for (unsigned i = 0; i < size(); ++i)
203  {
204  tmp = 0;
205  for (unsigned j=0;j<N;j++)
206  if (fX[j] >= record(i).xMin(j) && fX[j] < record(i).xMax(j))
207  tmp+=1;
208  if (tmp==N)
209  {
210  result = i;
211  break;
212  }
213  }
214  return result;
215 }
216 //------------------------------------------------------------------------
217 //--- returns the index of the record defined by fX (non-linear search) --
218 //------------------------------------------------------------------------
219 int JetCorrectorParameters::binIndexN(const std::vector<float>& fX) const
220 {
221  if(helper->size()>0)
222  {
223  return helper->binIndexN(fX,mRecords);
224  }
225  else
226  {
227  return -1;
228  }
229 }
230 //------------------------------------------------------------------------
231 //--- returns the neighbouring bins of fIndex in the direction of fVar ---
232 //------------------------------------------------------------------------
233 int JetCorrectorParameters::neighbourBin(unsigned fIndex, unsigned fVar, bool fNext) const
234 {
235  int result = -1;
236  unsigned N = mDefinitions.nBinVar();
237  if (fVar >= N)
238  {
239  std::stringstream sserr;
240  sserr<<"# of bin variables "<<N<<" doesn't correspond to requested #: "<<fVar;
241  handleError("JetCorrectorParameters",sserr.str());
242  }
243  unsigned tmp;
244  for (unsigned i = 0; i < size(); ++i)
245  {
246  tmp = 0;
247  for (unsigned j=0;j<fVar;j++)
248  if (fabs(record(i).xMin(j)-record(fIndex).xMin(j))<0.0001)
249  tmp+=1;
250  for (unsigned j=fVar+1;j<N;j++)
251  if (fabs(record(i).xMin(j)-record(fIndex).xMin(j))<0.0001)
252  tmp+=1;
253  if (tmp<N-1)
254  continue;
255  if (tmp==N-1)
256  {
257  if (fNext)
258  if (fabs(record(i).xMin(fVar)-record(fIndex).xMax(fVar))<0.0001)
259  tmp+=1;
260  if (!fNext)
261  if (fabs(record(i).xMax(fVar)-record(fIndex).xMin(fVar))<0.0001)
262  tmp+=1;
263  }
264  if (tmp==N)
265  {
266  result = i;
267  break;
268  }
269  }
270  return result;
271 }
272 //------------------------------------------------------------------------
273 //--- returns the number of bins in the direction of fVar ----------------
274 //------------------------------------------------------------------------
275 unsigned JetCorrectorParameters::size(unsigned fVar) const
276 {
277  if (fVar >= mDefinitions.nBinVar())
278  {
279  std::stringstream sserr;
280  sserr<<"requested bin variable index "<<fVar<<" is greater than number of variables "<<mDefinitions.nBinVar();
281  handleError("JetCorrectorParameters",sserr.str());
282  }
283  unsigned result = 0;
284  float tmpMin(-9999),tmpMax(-9999);
285  for (unsigned i = 0; i < size(); ++i)
286  if (record(i).xMin(fVar) > tmpMin && record(i).xMax(fVar) > tmpMax)
287  {
288  result++;
289  tmpMin = record(i).xMin(fVar);
290  tmpMax = record(i).xMax(fVar);
291  }
292  return result;
293 }
294 //------------------------------------------------------------------------
295 //--- returns the vector of bin centers of fVar --------------------------
296 //------------------------------------------------------------------------
297 std::vector<float> JetCorrectorParameters::binCenters(unsigned fVar) const
298 {
299  std::vector<float> result;
300  for (unsigned i = 0; i < size(); ++i)
301  result.push_back(record(i).xMiddle(fVar));
302  return result;
303 }
304 //------------------------------------------------------------------------
305 //--- prints parameters on screen ----------------------------------------
306 //------------------------------------------------------------------------
308 {
309  std::cout<<"--------------------------------------------"<<std::endl;
310  std::cout<<"//////// PARAMETERS: //////////////////////"<<std::endl;
311  std::cout<<"--------------------------------------------"<<std::endl;
312  std::cout<<"Number of binning variables: "<<definitions().nBinVar()<<std::endl;
313  std::cout<<"Names of binning variables: ";
314  for(unsigned i=0;i<definitions().nBinVar();i++)
315  std::cout<<definitions().binVar(i)<<" ";
316  std::cout<<std::endl;
317  std::cout<<"--------------------------------------------"<<std::endl;
318  std::cout<<"Number of parameter variables: "<<definitions().nParVar()<<std::endl;
319  std::cout<<"Names of parameter variables: ";
320  for(unsigned i=0;i<definitions().nParVar();i++)
321  std::cout<<definitions().parVar(i)<<" ";
322  std::cout<<std::endl;
323  std::cout<<"--------------------------------------------"<<std::endl;
324  std::cout<<"Parametrization Formula: "<<definitions().formula()<<std::endl;
325  if (definitions().isResponse())
326  std::cout<<"Type (Response or Correction): "<<"Response"<<std::endl;
327  else
328  std::cout<<"Type (Response or Correction): "<<"Correction"<<std::endl;
329  std::cout<<"Correction Level: "<<definitions().level()<<std::endl;
330  std::cout<<"--------------------------------------------"<<std::endl;
331  std::cout<<"------- Bin contents -----------------------"<<std::endl;
332  for(unsigned i=0;i<size();i++)
333  {
334  for(unsigned j=0;j<definitions().nBinVar();j++)
335  std::cout<<record(i).xMin(j)<<" "<<record(i).xMax(j)<<" ";
336  std::cout<<record(i).nParameters()<<" ";
337  for(unsigned j=0;j<record(i).nParameters();j++)
338  std::cout<<record(i).parameter(j)<<" ";
339  std::cout<<std::endl;
340  }
341 }
342 //------------------------------------------------------------------------
343 //--- prints parameters on file ----------------------------------------
344 //------------------------------------------------------------------------
345 void JetCorrectorParameters::printFile(const std::string& fFileName) const
346 {
347  std::ofstream txtFile;
348  txtFile.open(fFileName.c_str());
349  txtFile.setf(std::ios::right);
350  txtFile<<"{"<<definitions().nBinVar()<<std::setw(15);
351  for(unsigned i=0;i<definitions().nBinVar();i++)
352  txtFile<<definitions().binVar(i)<<std::setw(15);
353  txtFile<<definitions().nParVar()<<std::setw(15);
354  for(unsigned i=0;i<definitions().nParVar();i++)
355  txtFile<<definitions().parVar(i)<<std::setw(15);
356  txtFile<<std::setw(definitions().formula().size()+15)<<definitions().formula()<<std::setw(15);
357  if (definitions().isResponse())
358  txtFile<<"Response"<<std::setw(15);
359  else
360  txtFile<<"Correction"<<std::setw(15);
361  txtFile<<definitions().level()<<"}"<<"\n";
362  for(unsigned i=0;i<size();i++)
363  {
364  for(unsigned j=0;j<definitions().nBinVar();j++)
365  txtFile<<record(i).xMin(j)<<std::setw(15)<<record(i).xMax(j)<<std::setw(15);
366  txtFile<<record(i).nParameters()<<std::setw(15);
367  for(unsigned j=0;j<record(i).nParameters();j++)
368  txtFile<<record(i).parameter(j)<<std::setw(15);
369  txtFile<<"\n";
370  }
371  txtFile.close();
372 }
373 
374 namespace {
375 const std::vector<std::string> labels_ = {
376  "L1Offset",
377  "L2Relative",
378  "L3Absolute",
379  "L4EMF",
380  "L5Flavor",
381  "L6UE",
382  "L7Parton",
383  "L1JPTOffset",
384  "L2L3Residual",
385  "Uncertainty",
386  "L1FastJet",
387  "UncertaintyAbsolute",
388  "UncertaintyHighPtExtra",
389  "UncertaintySinglePionECAL",
390  "UncertaintyFlavor",
391  "UncertaintyTime",
392  "UncertaintyRelativeJEREC1",
393  "UncertaintyRelativeJEREC2",
394  "UncertaintyRelativeJERHF",
395  "UncertaintyRelativeStatEC2",
396  "UncertaintyRelativeStatHF",
397  "UncertaintyRelativeFSR",
398  "UncertaintyPileUpDataMC",
399  "UncertaintyPileUpOOT",
400  "UncertaintyPileUpPtBB",
401  "UncertaintyPileUpBias",
402  "UncertaintyPileUpJetRate",
403  "UncertaintySinglePionHCAL",
404  "UncertaintyRelativePtEC1",
405  "UncertaintyRelativePtEC2",
406  "UncertaintyRelativePtHF",
407  "UncertaintyRelativeSample",
408  "UncertaintyPileUpPtEC",
409  "UncertaintyPileUpPtHF",
410  "L1RC",
411  "L1Residual",
412  "UncertaintyAux3",
413  "UncertaintyAux4",
414 };
415 
416 const std::vector<std::string> l5Flavors_ = {
417  "L5Flavor_bJ",
418  "L5Flavor_cJ",
419  "L5Flavor_qJ",
420  "L5Flavor_gJ",
421  "L5Flavor_bT",
422  "L5Flavor_cT",
423  "L5Flavor_qT",
424  "L5Flavor_gT"
425 };
426 
427 const std::vector<std::string> l7Partons_ = {
428  "L7Parton_gJ",
429  "L7Parton_qJ",
430  "L7Parton_cJ",
431  "L7Parton_bJ",
432  "L7Parton_jJ",
433  "L7Parton_qT",
434  "L7Parton_cT",
435  "L7Parton_bT",
436  "L7Parton_tT"
437 };
438 }
441  if ( isL5(k) ) return findL5Flavor(k);
442  else if ( isL7(k) ) return findL7Parton(k);
443  else return labels_[k];
444 }
445 
448  if ( k == L5Flavor ) return labels_[L5Flavor];
449  else
450  return l5Flavors_[k / 100 - 1];
451 }
452 
455  if ( k == L7Parton ) return labels_[L7Parton];
456  else
457  return l7Partons_[k / 1000 - 1];
458 }
459 
461  std::vector<std::string> & outputs )
462 {
463  outputs.clear();
464  std::ifstream input( inputFile.c_str() );
465  while( !input.eof() ) {
466  char buff[10000];
467  input.getline(buff,10000);
468  std::string in(buff);
469  if ( in[0] == '[' ) {
470  std::string tok = getSection(in);
471  if ( tok != "" ) {
472  outputs.push_back( tok );
473  }
474  }
475  }
476  std::cout << "Found these sections for file: " << std::endl;
477  copy(outputs.begin(),outputs.end(), std::ostream_iterator<std::string>(std::cout, "\n") );
478 }
479 
480 
481 // Add a JetCorrectorParameter object, possibly with flavor.
483  std::cout << "i = " << i << std::endl;
484  std::cout << "flav = " << flav << std::endl;
485  if ( isL5(i) ) {
486  std::cout << "This is L5, getL5Bin = " << getL5Bin(flav) << std::endl;
487  correctionsL5_.push_back( pair_type(getL5Bin(flav),j) );
488  }
489  else if ( isL7(i) ) {
490  std::cout << "This is L7, getL7Bin = " << getL7Bin(flav) << std::endl;
491  correctionsL7_.push_back( pair_type(getL7Bin(flav),j) );
492  }
493  else if ( flav == "" ) {
494  corrections_.push_back( pair_type(i,j) );
495  } else {
496  std::cout << "***** NOT ADDING " << flav << ", corresponding position in JetCorrectorParameters is not found." << std::endl;
497  }
498 }
499 
500 
501 // Access the JetCorrectorParameter via the key k.
502 // key_type is hashed to deal with the three collections
504  collection_type::const_iterator ibegin, iend, i;
505  if ( isL5(k) ) {
506  ibegin = correctionsL5_.begin();
507  iend = correctionsL5_.end();
508  i = ibegin;
509  } else if ( isL7(k) ) {
510  ibegin = correctionsL7_.begin();
511  iend = correctionsL7_.end();
512  i = ibegin;
513  } else {
514  ibegin = corrections_.begin();
515  iend = corrections_.end();
516  i = ibegin;
517  }
518  for ( ; i != iend; ++i ) {
519  if ( k == i->first ) return i->second;
520  }
521  throw cms::Exception("InvalidInput") << " cannot find key " << static_cast<int>(k)
522  << " in the JEC payload, this usually means you have to change the global tag" << std::endl;
523 }
524 
525 // Get a list of valid keys. These will contain hashed keys
526 // that are aware of all three collections.
527 void JetCorrectorParametersCollection::validKeys(std::vector<key_type> & keys ) const {
528  keys.clear();
529  for ( collection_type::const_iterator ibegin = corrections_.begin(),
530  iend = corrections_.end(), i = ibegin; i != iend; ++i ) {
531  keys.push_back( i->first );
532  }
533  for ( collection_type::const_iterator ibegin = correctionsL5_.begin(),
534  iend = correctionsL5_.end(), i = ibegin; i != iend; ++i ) {
535  keys.push_back( i->first );
536  }
537  for ( collection_type::const_iterator ibegin = correctionsL7_.begin(),
538  iend = correctionsL7_.end(), i = ibegin; i != iend; ++i ) {
539  keys.push_back( i->first );
540  }
541 }
542 
543 
544 // Find the L5 bin for hashing
547  std::vector<std::string>::const_iterator found =
548  find( l5Flavors_.begin(), l5Flavors_.end(), flav );
549  if ( found != l5Flavors_.end() ) {
550  return (found - l5Flavors_.begin() + 1) * 100;
551  }
552  else return L5Flavor;
553 }
554 // Find the L7 bin for hashing
557  std::vector<std::string>::const_iterator found =
558  find( l7Partons_.begin(), l7Partons_.end(), flav );
559  if ( found != l7Partons_.end() ) {
560  return (found - l7Partons_.begin() + 1) * 1000;
561  }
562  else return L7Parton;
563 }
564 
565 // Check if this is an L5 hashed value
567  return k == L5Flavor ||
568  ( k / 100 > 0 && k / 1000 == 0 );
569 }
570 // Check if this is an L7 hashed value
572  return k == L7Parton ||
573  ( k / 1000 > 0 );
574 }
575 
576 
577 // Find the key corresponding to each label
580 
581  // First check L5 corrections
582  std::vector<std::string>::const_iterator found1 =
583  find( l5Flavors_.begin(), l5Flavors_.end(), label );
584  if ( found1 != l5Flavors_.end() ) {
585  return getL5Bin(label);
586  }
587 
588  // Next check L7 corrections
589  std::vector<std::string>::const_iterator found2 =
590  find( l7Partons_.begin(), l7Partons_.end(), label );
591  if ( found2 != l7Partons_.end() ) {
592  return getL7Bin(label);
593  }
594 
595  // Finally check the default corrections
596  std::vector<std::string>::const_iterator found3 =
597  find( labels_.begin(), labels_.end(), label );
598  if ( found3 != labels_.end() ) {
599  return static_cast<key_type>(found3 - labels_.begin());
600  }
601 
602  // Didn't find default corrections, throw exception
603  throw cms::Exception("InvalidInput") << " Cannot find label " << label << std::endl;
604 
605 }
606 
607 
608 //#include "FWCore/Framework/interface/EventSetup.h"
609 //#include "FWCore/Framework/interface/ESHandle.h"
610 //#include "FWCore/Framework/interface/ModuleFactory.h"
612 
float xMin(unsigned fVar) const
JetCorrectorParametersCollection::pair_type pair_type
Definition: classes.h:11
Definition: helper.py:1
def copy(args, dbName)
static std::string findLabel(key_type k)
void push_back(key_type i, value_type const &j, label_type const &flav="")
const Definitions & definitions() const
static key_type getL5Bin(std::string const &flav)
std::vector< JetCorrectorParameters::Record > mRecords
const Record & record(unsigned fBin) const
std::vector< std::string > parVar() const
void find(edm::Handle< EcalRecHitCollection > &hits, DetId thisDet, std::vector< EcalRecHitCollection::const_iterator > &hit, bool debug=false)
Definition: FindCaloHit.cc:20
static std::string const input
Definition: EdmProvDump.cc:48
static std::string findL5Flavor(key_type k)
float parameter(unsigned fIndex) const
char const * label
std::ostream & operator<<(std::ostream &out, const JetCorrectorParameters::Record &fBin)
void printFile(const std::string &fFileName) const
int binIndex(const std::vector< float > &fX) const
std::vector< float > binCenters(unsigned fVar) const
static std::string findL7Parton(key_type k)
static const int MAX_SIZE_DIMENSIONALITY
float xMiddle(unsigned fVar) const
key_type findKey(std::string const &label) const
float xMax(unsigned fVar) const
int k[5][pyjets_maxn]
#define TYPELOOKUP_DATA_REG(_dataclass_)
Definition: typelookup.h:102
def getSection(rootNode, name)
#define N
Definition: blowfish.cc:9
int binIndexN(const std::vector< float > &fX) const
static key_type getL7Bin(std::string const &flav)
std::vector< std::vector< double > > tmp
Definition: MVATrainer.cc:100
static void getSections(std::string inputFile, std::vector< std::string > &outputs)
void validKeys(std::vector< key_type > &keys) const
std::vector< std::string > binVar() const
def check(config)
Definition: trackerTree.py:14
JetCorrectorParameters::Definitions mDefinitions
int neighbourBin(unsigned fIndex, unsigned fVar, bool fNext) const
JetCorrectorParameters const & operator[](key_type k) const