CMS 3D CMS Logo

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
ImpactParameterCalibration.cc
Go to the documentation of this file.
1 // -*- C++ -*-
2 //
3 // Package: ImpactParameterCalibration
4 // Class: ImpactParameterCalibration
5 //
13 //
14 // Original Author: Jeremy Andrea/Andrea Rizzi
15 // Created: Mon Aug 6 16:10:38 CEST 2007
16 // $Id: ImpactParameterCalibration.cc,v 1.13 2010/01/22 08:56:41 arizzi Exp $
17 //
18 //
19 // system include files
20 
30 
34 
35 
39 
42 
43 #include "TClass.h"
44 
45 #include "TBufferFile.h"
46 
47 #include "TBufferXML.h"
48 #include <iostream>
49 #include <fstream>
50 #include <sstream>
51 #include <string>
52 #include <vector>
53 #include <memory>
54 
55 #include "TrackClassMatch.h"
56 
57 
58 using namespace reco;
59 using namespace std;
60 //
61 // class decleration
62 //
63 
64 
65 
67  public:
70 
71 
72  private:
73  virtual void beginJob() ;
74  virtual void analyze(const edm::Event&, const edm::EventSetup&);
75  virtual void endJob() ;
76 
77  virtual void initFromFirstES(const edm::EventSetup&);
80  TrackProbabilityCalibration * fromXml(edm::FileInPath xmlCalibration);
81 
82  static TrackProbabilityCategoryData createCategory(double pmin,double pmax,
83  double etamin, double etamax,
84  int nhitmin, int nhitmax,
85  int npixelhitsmin, int npixelhitsmax,
86  double cmin, double cmax, int withFirst)
87  {
89  c.pMin=pmin;
90  c.pMax=pmax;
91  c.etaMin=etamin;
92  c.etaMax=etamax;
93  c.nHitsMin=nhitmin;
94  c.nHitsMax=nhitmax;
95  c.nPixelHitsMin=npixelhitsmin;
96  c.nPixelHitsMax=npixelhitsmax;
97  c.chiMin=cmin;
98  c.chiMax=cmax;
99  c.withFirstPixel=withFirst;
100  return c;
101  }
102 
103  TrackProbabilityCalibration * m_calibration[2];
106  unsigned int minLoop, maxLoop;
107 
108 };
109 
111 {
112  m_needInitFromES = false;
113  m_iptaginfo = iConfig.getParameter<edm::InputTag>("tagInfoSrc");
114  m_pv = iConfig.getParameter<edm::InputTag>("primaryVertexSrc");
115  bool createOnlyOne = iConfig.getUntrackedParameter<bool>("createOnlyOneCalibration", false);
116  minLoop=0;
117  maxLoop=1;
118  if (createOnlyOne == true){
119  int whichCalib = iConfig.getUntrackedParameter<int>("dimension", 2);
120  if (whichCalib==2){
121  std::cout <<" Writing only 2D calibrations"<<std::endl;
122  minLoop=1;
123  maxLoop=1;
124  }else if (whichCalib==3){
125  std::cout <<" Writing only 3D calibrations"<<std::endl;
126  minLoop=0;
127  maxLoop=0;
128  }else {
129  std::cout <<" Dimension not found: "<<whichCalib<<"; it must be either 2 or 3"<<std::endl;
130  }
131  }
132 
133 }
134 
135 
137 {
138 }
139 
140 
141 void
143 {
144  if(m_needInitFromES) initFromFirstES(iSetup);
145  using namespace edm;
146  using namespace reco;
147 
149  iEvent.getByLabel(m_iptaginfo, ipHandle);
150  const TrackIPTagInfoCollection & ip = *(ipHandle.product());
151 
152 // cout << "Found " << ip.size() << " TagInfo" << endl;
153 
154  Handle<reco::VertexCollection> primaryVertex;
155  iEvent.getByLabel(m_pv,primaryVertex);
156 
157  vector<TrackProbabilityCalibration::Entry>::iterator found;
158  vector<TrackProbabilityCalibration::Entry>::iterator it_begin;
159  vector<TrackProbabilityCalibration::Entry>::iterator it_end;
160 
161 
162  TrackIPTagInfoCollection::const_iterator it = ip.begin();
163  for(; it != ip.end(); it++)
164  {
165  TrackRefVector selTracks=it->selectedTracks();
166 // if(it->primaryVertex().isNull()) continue;
167  if(primaryVertex.product()->size() == 0)
168  {
169  std::cout << "No PV in the event!!" << std::endl;
170  continue;
171  }
172  const Vertex & pv = *(primaryVertex.product()->begin());
173 
174  for(unsigned int i=minLoop; i <= maxLoop;i++)
175  {
176  it_begin=m_calibration[i]->data.begin();
177  it_end=m_calibration[i]->data.end();
178 
179  for(unsigned int j=0;j<selTracks.size(); j++)
180  {
181  double ipsig;
182  if (i==0) ipsig = it->impactParameterData()[j].ip3d.significance();
183  else ipsig = it->impactParameterData()[j].ip2d.significance();
184  TrackClassMatch::Input input(*selTracks[j],*it->jet(),pv);
185  if(ipsig < 0)
186  {
187  found = std::find_if(it_begin,it_end,bind1st(TrackClassMatch(),input));
188 // std::cout << ip[j].significance() << std::endl;
189  if(found!=it_end)
190  found->histogram.fill(-ipsig);
191  else
192  {std::cout << "No category for this track!!" << std::endl;
193  std::cout << "p " <<(*selTracks[j]).p () << std::endl;
194  std::cout << "eta " << (*selTracks[j]).eta() << std::endl;
195  std::cout << "NHit " << (*selTracks[j]).numberOfValidHits() << std::endl;
196  std::cout << "NPixHit " << (*selTracks[j]).hitPattern().numberOfValidPixelHits() << std::endl;
197  std::cout << "FPIXHIT " << (*selTracks[j]).hitPattern().hasValidHitInFirstPixelBarrel() << std::endl;}
198 
199  }
200  }
201  }
202  }
203 
204 
205 
206 }
207 
208 
209 
210 
211 
212 
213 
215 {
216  using namespace edm;
217 
218  CalibratedHistogram hist(config.getParameter<int>("nBins"),0,config.getParameter<double>("maxSignificance"));
219  bool resetHistogram = config.getParameter<bool>("resetHistograms");
221  iSetup.get<BTagTrackProbability2DRcd>().get(calib2DHandle);
223  iSetup.get<BTagTrackProbability3DRcd>().get(calib3DHandle);
224  const TrackProbabilityCalibration * ca[2];
225  ca[0] = calib3DHandle.product();
226  ca[1] = calib2DHandle.product();
227  for(unsigned int i=minLoop;i <=maxLoop ;i++)
228  for(unsigned int j=0;j<ca[i]->data.size() ; j++)
229  {
231  e.category=ca[i]->data[j].category;
232 
233  if(resetHistogram)
234  e.histogram=hist;
235  else
236  e.histogram=ca[i]->data[j].histogram;
237 
238  m_calibration[i]->data.push_back(e);
239  }
240 
241 
242 }
243 
244 
245 // ------------ method called once each job just before starting event loop ------------
246 void
248 {
249  using namespace edm;
252 
253  CalibratedHistogram hist(config.getParameter<int>("nBins"),0,config.getParameter<double>("maxSignificance"));
254 
255  std::string categories = config.getParameter<std::string>("inputCategories");
256 
257  if(categories == "HardCoded")
258  {
259  vector<TrackProbabilityCategoryData> v;
260  //TrackProbabilityCategoryData {pMin, pMax, etaMin, etaMax,
261  //nHitsMin, nHitsMax, nPixelHitsMin, nPixelHitsMax, chiMin,chiMax, withFirstPixel;
262  //trackQuality;
263  v.push_back(createCategory(0, 5000, 0 , 2.5, 8 , 50, 1, 1, 0 , 5 , 0));
264  v.push_back(createCategory(0, 5000, 0 , 2.5, 8 , 50, 2, 8, 2.5, 5 , 0));
265  v.push_back(createCategory(0, 8 , 0 , 0.8, 8 , 50, 3, 8, 0 , 2.5, 0));
266  v.push_back(createCategory(0, 8 , 0.8, 1.6, 8 , 50, 3, 8, 0 , 2.5, 0));
267  v.push_back(createCategory(0, 8 , 1.6, 2.5, 8 , 50, 3, 8, 0 , 2.5, 0));
268  v.push_back(createCategory(0, 8 , 0 , 2.5, 8 , 50, 2, 8, 0 , 2.5, 0));
269  v.push_back(createCategory(8, 5000, 0 , 0.8, 8 , 50, 3, 8, 0 , 2.5, 0));
270  v.push_back(createCategory(8, 5000, 0.8, 1.6, 8 , 50, 3, 8, 0 , 2.5, 0));
271  v.push_back(createCategory(8, 5000, 1.6, 2.5, 8 , 50, 3, 8, 0 , 2.5, 0));
272  v.push_back(createCategory(8, 5000, 0 , 2.5, 8 , 50, 2 ,2, 0 , 2.5, 0));
273  for(unsigned int i=minLoop;i <=maxLoop ;i++)
274  for(unsigned int j=0;j<v.size() ; j++)
275  {
277  e.category=v[j];
278  e.histogram=hist;
279  m_calibration[i]->data.push_back(e);
280  }
281 
282  }
283  if(categories == "RootXML")
284  {
285  bool resetHistogram = config.getParameter<bool>("resetHistograms");
286  const TrackProbabilityCalibration * ca[2];
287  ca[0] = fromXml(config.getParameter<edm::FileInPath>("calibFile3d"));
288  ca[1] = fromXml(config.getParameter<edm::FileInPath>("calibFile2d"));
289 
290  for(unsigned int i=minLoop;i <=maxLoop ;i++)
291  for(unsigned int j=0;j<ca[i]->data.size() ; j++)
292  {
294  e.category=ca[i]->data[j].category;
295 
296  if(resetHistogram)
297  e.histogram=hist;
298  else
299  e.histogram=ca[i]->data[j].histogram;
300 
301  m_calibration[i]->data.push_back(e);
302  }
303 
304  delete ca[0];
305  delete ca[1];
306 
307  }
308  if(categories == "EventSetup")
309  {
310  m_needInitFromES=true;
311  }
312 
313 
314 
315 /* edm::FileInPath f2d(m_xmlfilename2D);
316  edm::FileInPath f3d(m_xmlfilename3D);
317  calibrationNew = new AlgorithmCalibration<TrackClassFilterCategory,CalibratedHistogramXML>((f3d.fullPath()).c_str());
318  calibration2dNew = new AlgorithmCalibration<TrackClassFilterCategory,CalibratedHistogramXML>((f2d.fullPath()).c_str());
319  vector<float> * bins =0;
320  if(m_resetData)
321  {
322  if(m_newBinning) bins = new vector<float>(CalibratedHistogram::constantBinning(m_nBin,0,m_range));
323  vector<pair<TrackClassFilterCategory, CalibratedHistogramXML> > data = calibrationNew->categoriesWithData();
324  vector<pair<TrackClassFilterCategory, CalibratedHistogramXML> > data2d = calibration2dNew->categoriesWithData();
325  std::cout << data.size() << std::endl;
326  for(unsigned int i = 0 ; i < data.size();i++)
327  {
328  data[i].second.reset();
329  if(bins) data[i].second.setUpperLimits(*bins);
330  }
331  for(unsigned int i = 0 ; i < data2d.size();i++)
332  {
333  data2d[i].second.reset();
334  if(bins) data2d[i].second.setUpperLimits(*bins);
335  }
336 
337  }
338  if(bins) delete bins;
339 
340 */
341 
342 
343 }
344 
346 {
347  std::ifstream xmlFile(xmlCalibration.fullPath().c_str());
348  if (!xmlFile.good())
349  throw cms::Exception("BTauFakeMVAJetTagConditions")
350  << "File \"" << xmlCalibration.fullPath()
351  << "\" could not be opened for reading."
352  << std::endl;
353  std::ostringstream ss;
354  ss << xmlFile.rdbuf();
355  xmlFile.close();
356  TClass *classType = 0;
357  void *ptr = TBufferXML(TBuffer::kRead).ConvertFromXMLAny(
358  ss.str().c_str(), &classType, kTRUE, kFALSE);
359  if (!ptr)
360  throw cms::Exception("ImpactParameterCalibration")
361  << "Unknown error parsing XML serialization"
362  << std::endl;
363 
364  if (std::strcmp(classType->GetName(),
365  "TrackProbabilityCalibration")) {
366  classType->Destructor(ptr);
367  throw cms::Exception("ImpactParameterCalibration")
368  << "Serialized object has wrong C++ type."
369  << std::endl;
370  }
371 
372  return static_cast<TrackProbabilityCalibration*>(ptr);
373 }
374 
375 
376 
377 
378 // ------------ method called once each job just after ending the event loop ------------
379 void
381 
382  if(config.getParameter<bool>("writeToDB"))
383  {
385  if( !mydbservice.isAvailable() ) return;
386  if(minLoop == 0 ) mydbservice->createNewIOV<TrackProbabilityCalibration>(m_calibration[0], mydbservice->beginOfTime(), mydbservice->endOfTime(),"BTagTrackProbability3DRcd");
387  if(maxLoop == 1) mydbservice->createNewIOV<TrackProbabilityCalibration>(m_calibration[1], mydbservice->beginOfTime(), mydbservice->endOfTime(),"BTagTrackProbability2DRcd");
388  }
389 
390 
391  if(config.getParameter<bool>("writeToRootXML"))
392  {
393  if(maxLoop == 1 ){
394  std::ofstream of2("2d.xml");
395  TBufferXML b2(TBuffer::kWrite);
396  of2 << b2.ConvertToXML(const_cast<void*>(static_cast<const void*>(m_calibration[1])),
397  TClass::GetClass("TrackProbabilityCalibration"),
398  kTRUE, kFALSE);
399  of2.close();
400  }
401  if(minLoop == 0 ){
402  std::ofstream of3("3d.xml");
403  TBufferXML b3(TBuffer::kWrite);
404  of3 << b3.ConvertToXML(const_cast<void*>(static_cast<const void*>(m_calibration[0])),
405  TClass::GetClass("TrackProbabilityCalibration"),
406  kTRUE, kFALSE);
407  of3.close();
408  }
409  }
410 
411 
412  if(config.getParameter<bool>("writeToBinary"))
413  {
414  if(maxLoop == 1 ){
415 
416  std::ofstream ofile("2d.dat");
417  TBufferFile buffer(TBuffer::kWrite);
418  buffer.StreamObject(const_cast<void*>(static_cast<const void*>(m_calibration[1])),
419  TClass::GetClass("TrackProbabilityCalibration"));
420  Int_t size = buffer.Length();
421  ofile.write(buffer.Buffer(),size);
422  ofile.close();
423  }
424  if(minLoop == 0 ){
425  std::ofstream ofile3("3d.dat");
426  TBufferFile buffer3(TBuffer::kWrite);
427  buffer3.StreamObject(const_cast<void*>(static_cast<const void*>(m_calibration[0])),
428  TClass::GetClass("TrackProbabilityCalibration"));
429  Int_t size3 = buffer3.Length();
430  ofile3.write(buffer3.Buffer(),size3);
431  ofile3.close();
432  }
433  }
434 
435 
436 
437 
438 
439 }
440 
441 //define this as a plug-in
TrackProbabilityCalibration * fromXml(edm::FileInPath xmlCalibration)
T getParameter(std::string const &) const
T getUntrackedParameter(std::string const &, T const &) const
int i
Definition: DBlmapReader.cc:9
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:17
ImpactParameterCalibration(const edm::ParameterSet &)
TrackProbabilityCalibration * m_calibration[2]
T eta() const
static TrackProbabilityCategoryData createCategory(double pmin, double pmax, double etamin, double etamax, int nhitmin, int nhitmax, int npixelhitsmin, int npixelhitsmax, double cmin, double cmax, int withFirst)
void beginJob()
Definition: Breakpoints.cc:15
int iEvent
Definition: GenABIO.cc:243
bool isAvailable() const
Definition: Service.h:47
int j
Definition: DBlmapReader.cc:9
bool getByLabel(InputTag const &tag, Handle< PROD > &result) const
Definition: Event.h:355
void createNewIOV(T *firstPayloadObj, cond::Time_t firstSinceTime, cond::Time_t firstTillTime, const std::string &recordName, bool withlogging=false)
virtual void initFromFirstES(const edm::EventSetup &)
tuple input
Definition: collect_tpl.py:10
PhysicsTools::Calibration::HistogramF histogram
tuple ofile
Definition: indexGen.py:101
const T & get() const
Definition: EventSetup.h:55
virtual void analyze(const edm::Event &, const edm::EventSetup &)
bool xmlFile(const std::string fParam)
size_type size() const
Size of the RefVector.
Definition: RefVector.h:84
tuple cout
Definition: gather_cfg.py:41
std::string fullPath() const
Definition: FileInPath.cc:170
tuple size
Write out results.
mathSSE::Vec4< T > v