CMS 3D CMS Logo
ApeEstimator.cc
Go to the documentation of this file.
1 // -*- C++ -*-
2 //
3 // Package: ApeEstimator
4 // Class: ApeEstimator
5 //
13 //
14 // Original Author: Johannes Hauk
15 // Created: Tue Jan 6 15:02:09 CET 2009
16 // Modified by: Christian Schomakers (RWTH Aachen)
17 // $Id: ApeEstimator.cc,v 1.27 2012/06/26 09:42:33 hauk Exp $
18 //
19 //
20 
21 // system include files
22 #include <memory>
23 #include <sstream>
24 #include <fstream>
25 
26 // user include files
27 #include "FWCore/Framework/interface/Frameworkfwd.h"
28 #include "FWCore/Framework/interface/one/EDAnalyzer.h"
29 #include "FWCore/Framework/interface/Event.h"
30 #include "FWCore/Framework/interface/EventSetup.h"
31 #include "FWCore/Framework/interface/MakerMacros.h"
32 #include "FWCore/MessageLogger/interface/MessageLogger.h"
33 #include "FWCore/ParameterSet/interface/ParameterSet.h"
34 #include "FWCore/ServiceRegistry/interface/Service.h"
35 #include "FWCore/Utilities/interface/InputTag.h"
36 #include "FWCore/Utilities/interface/EDGetToken.h"
37 
38 #include "CommonTools/UtilAlgos/interface/TFileService.h"
39 #include "CommonTools/Utils/interface/TFileDirectory.h"
40 
41 #include "DataFormats/Common/interface/Handle.h"
42 #include "DataFormats/TrackReco/interface/Track.h"
43 #include "DataFormats/TrackReco/interface/HitPattern.h"
44 #include "DataFormats/TrackingRecHit/interface/TrackingRecHit.h"
45 #include "DataFormats/DetId/interface/DetId.h"
46 #include "DataFormats/TrackerRecHit2D/interface/SiStripRecHit1D.h"
47 #include "DataFormats/TrackerRecHit2D/interface/SiStripRecHit2D.h"
48 #include "DataFormats/TrackerRecHit2D/interface/SiStripMatchedRecHit2D.h"
49 #include "DataFormats/TrackerRecHit2D/interface/ProjectedSiStripRecHit2D.h"
50 #include "DataFormats/TrackerRecHit2D/interface/SiPixelRecHit.h"
51 #include "DataFormats/GeometryVector/interface/LocalPoint.h"
52 #include "DataFormats/GeometrySurface/interface/LocalError.h"
53 #include "DataFormats/GeometryCommonDetAlgo/interface/MeasurementPoint.h"
54 #include "DataFormats/GeometryCommonDetAlgo/interface/MeasurementError.h"
55 #include "DataFormats/SiPixelDetId/interface/PixelSubdetector.h"
56 #include "DataFormats/SiStripDetId/interface/StripSubdetector.h"
57 #include "DataFormats/SiStripDetId/interface/SiStripDetId.h"
58 #include "DataFormats/SiPixelCluster/interface/SiPixelCluster.h"
59 #include "DataFormats/SiStripCluster/interface/SiStripCluster.h"
60 
61 #include "TrackingTools/PatternTools/interface/Trajectory.h"
62 #include "TrackingTools/PatternTools/interface/TrajTrackAssociation.h"
63 #include "TrackingTools/PatternTools/interface/TrajectoryMeasurement.h"
64 #include "TrackingTools/PatternTools/interface/MeasurementExtractor.h"
65 #include "TrackingTools/TrackFitters/interface/TrajectoryStateCombiner.h"
66 #include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHit.h"
67 #include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h"
68 
69 #include "Geometry/CommonDetUnit/interface/GeomDet.h"
70 #include "Geometry/CommonDetUnit/interface/GeomDetType.h"
71 #include "Geometry/CommonTopologies/interface/RadialStripTopology.h"
72 //added by Ajay 6Nov 2014
73 //.......................
74 #include "Geometry/CommonTopologies/interface/PixelTopology.h"
75 #include "Geometry/CommonDetUnit/interface/PixelGeomDetUnit.h"
76 
77 #include "CondFormats/AlignmentRecord/interface/TrackerAlignmentErrorExtendedRcd.h"
78 
79 //...............
80 //
81 
83 #include "Geometry/TrackerGeometryBuilder/interface/StripGeomDetUnit.h"
84 
85 #include "CondFormats/Alignment/interface/Definitions.h"
86 
87 #include "RecoLocalTracker/SiStripClusterizer/interface/SiStripClusterInfo.h"
88 
89 #include "Alignment/APEEstimation/interface/TrackerSectorStruct.h"
90 #include "Alignment/APEEstimation/interface/TrackerDetectorStruct.h"
91 #include "Alignment/APEEstimation/interface/EventVariables.h"
92 #include "Alignment/APEEstimation/interface/ReducedTrackerTreeVariables.h"
93 
94 #include "TH1.h"
95 #include "TH2.h"
96 #include "TProfile.h"
97 #include "TFile.h"
98 #include "TTree.h"
99 #include "TF1.h"
100 #include "TString.h"
101 #include "TMath.h"
102 
103 #include "RecoLocalTracker/SiStripRecHitConverter/interface/StripCPE.h"
104 #include "Geometry/CommonTopologies/interface/StripTopology.h"
105 
106 #include "MagneticField/Engine/interface/MagneticField.h"
107 #include "CondFormats/SiStripObjects/interface/SiStripLorentzAngle.h"
108 //ADDED BY LOIC QUERTENMONT
109 #include "FWCore/Framework/interface/DependentRecordImplementation.h"
110 #include "CalibTracker/Records/interface/SiStripDependentRecords.h"
112 #include "DataFormats/GeometryVector/interface/LocalVector.h"
113 #include "DataFormats/GeometrySurface/interface/Bounds.h"
114 #include "FWCore/Framework/interface/ESHandle.h"
115 #include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
116 #include "CondFormats/DataRecord/interface/SiStripLorentzAngleRcd.h"
117 #include "DataFormats/BeamSpot/interface/BeamSpot.h"
118 #include "DataFormats/Math/interface/Point3D.h"
119 #include "FWCore/Utilities/interface/EDMException.h"
120 
121 //
122 // class decleration
123 //
124 
125 class ApeEstimator : public edm::one::EDAnalyzer<> {
126 public:
127  explicit ApeEstimator(const edm::ParameterSet&);
128  ~ApeEstimator() override;
129 
130 private:
131  struct PositionAndError2 {
132  PositionAndError2() : posX(-999.F), posY(-999.F), errX2(-999.F), errY2(-999.F){};
133  PositionAndError2(float x, float y, float eX, float eY) : posX(x), posY(y), errX2(eX), errY2(eY){};
134  float posX;
135  float posY;
136  float errX2;
137  float errY2;
138  };
139  typedef std::pair<TrackStruct::HitState, PositionAndError2> StatePositionAndError2;
140 
141  void beginJob() override;
142  void analyze(const edm::Event&, const edm::EventSetup&) override;
143  void endJob() override;
144 
145  bool isHit2D(const TrackingRecHit&) const;
146 
147  void sectorBuilder();
148  bool checkIntervalsForSectors(const unsigned int sectorCounter, const std::vector<double>&) const;
149  bool checkModuleIds(const unsigned int, const std::vector<unsigned int>&) const;
150  bool checkModuleBools(const bool, const std::vector<unsigned int>&) const;
151  bool checkModuleDirections(const int, const std::vector<int>&) const;
152  bool checkModulePositions(const float, const std::vector<double>&) const;
153  void statistics(const TrackerSectorStruct&, const int) const;
154 
155  void residualErrorBinning();
156 
157  void bookSectorHistsForAnalyzerMode();
158  void bookSectorHistsForApeCalculation();
159  void bookTrackHists();
160 
161  TrackStruct::TrackParameterStruct fillTrackVariables(const reco::Track&, const Trajectory&, const reco::BeamSpot&);
162  TrackStruct::HitParameterStruct fillHitVariables(const TrajectoryMeasurement&, const edm::EventSetup&);
163 
164  StatePositionAndError2 positionAndError2(const LocalPoint&, const LocalError&, const TransientTrackingRecHit&);
165  PositionAndError2 rectangularPositionAndError2(const LocalPoint&, const LocalError&);
166  PositionAndError2 radialPositionAndError2(const LocalPoint&, const LocalError&, const RadialStripTopology&);
167 
168  void hitSelection();
169  void setHitSelectionMap(const std::string&);
170  void setHitSelectionMapUInt(const std::string&);
171  bool hitSelected(TrackStruct::HitParameterStruct&) const;
172  bool inDoubleInterval(const std::vector<double>&, const float) const;
173  bool inUintInterval(const std::vector<unsigned int>&, const unsigned int, const unsigned int = 999) const;
174 
175  void fillHistsForAnalyzerMode(const TrackStruct&);
176  void fillHitHistsXForAnalyzerMode(const TrackStruct::HitParameterStruct&, TrackerSectorStruct&);
177  void fillHitHistsYForAnalyzerMode(const TrackStruct::HitParameterStruct&, TrackerSectorStruct&);
178  void fillHistsForApeCalculation(const TrackStruct&);
179 
180  void calculateAPE();
181 
182  // ----------member data ---------------------------
183  const edm::ParameterSet parameterSet_;
184  std::map<unsigned int, TrackerSectorStruct> m_tkSector_;
185  TrackerDetectorStruct tkDetector_;
186  SiStripClusterInfo siStripClusterInfo_;
187 
188  edm::EDGetTokenT<TrajTrackAssociationCollection> tjTagToken_;
189  edm::EDGetTokenT<reco::BeamSpot> offlinebeamSpot_;
190 
191  std::map<unsigned int, std::pair<double, double> > m_resErrBins_;
192  std::map<unsigned int, ReducedTrackerTreeVariables> m_tkTreeVar_;
193 
194  std::map<std::string, std::vector<double> > m_hitSelection_;
195  std::map<std::string, std::vector<unsigned int> > m_hitSelectionUInt_;
196 
197  bool trackCut_;
198 
199  const unsigned int maxTracksPerEvent_;
200  const unsigned int minGoodHitsPerTrack_;
201 
202  const bool analyzerMode_;
203 
204  const bool calculateApe_;
205 
206  unsigned int counter1, counter2, counter3, counter4, counter5, counter6;
207 };
208 
209 //
210 // constants, enums and typedefs
211 //
212 
213 //
214 // static data member definitions
215 //
216 
217 //
218 // constructors and destructor
219 //
220 ApeEstimator::ApeEstimator(const edm::ParameterSet& iConfig)
221  : parameterSet_(iConfig),
222  siStripClusterInfo_(consumesCollector(), std::string("")),
223  tjTagToken_(
224  consumes<TrajTrackAssociationCollection>(parameterSet_.getParameter<edm::InputTag>("tjTkAssociationMapTag"))),
225  offlinebeamSpot_(consumes<reco::BeamSpot>(edm::InputTag("offlineBeamSpot"))),
226  trackCut_(false),
227  maxTracksPerEvent_(parameterSet_.getParameter<unsigned int>("maxTracksPerEvent")),
228  minGoodHitsPerTrack_(parameterSet_.getParameter<unsigned int>("minGoodHitsPerTrack")),
229  analyzerMode_(parameterSet_.getParameter<bool>("analyzerMode")),
230  calculateApe_(parameterSet_.getParameter<bool>("calculateApe")) {
231  counter1 = counter2 = counter3 = counter4 = counter5 = counter6 = 0;
232 }
233 
234 ApeEstimator::~ApeEstimator() {}
235 
236 //
237 // member functions
238 //
239 
240 // -----------------------------------------------------------------------------------------------------------
241 
242 void ApeEstimator::sectorBuilder() {
243  TFile* tkTreeFile(TFile::Open((parameterSet_.getParameter<std::string>("TrackerTreeFile")).c_str()));
244  if (tkTreeFile) {
245  edm::LogInfo("SectorBuilder") << "TrackerTreeFile OK";
246  } else {
247  edm::LogError("SectorBuilder") << "TrackerTreeFile not found";
248  return;
249  }
250  TTree* tkTree(nullptr);
251  tkTreeFile->GetObject("TrackerTreeGenerator/TrackerTree/TrackerTree", tkTree);
252  if (tkTree) {
253  edm::LogInfo("SectorBuilder") << "TrackerTree OK";
254  } else {
255  edm::LogError("SectorBuilder") << "TrackerTree not found in file";
256  return;
257  }
258  unsigned int rawId(999), subdetId(999), layer(999), side(999), half(999), rod(999), ring(999), petal(999), blade(999),
259  panel(999), outerInner(999), module(999), nStrips(999);
260  bool isDoubleSide(false), isRPhi(false), isStereo(false);
261  int uDirection(999), vDirection(999), wDirection(999);
262  float posR(999.F), posPhi(999.F), posEta(999.F), posX(999.F), posY(999.F), posZ(999.F);
263 
264  tkTree->SetBranchAddress("RawId", &rawId);
265  tkTree->SetBranchAddress("SubdetId", &subdetId);
266  tkTree->SetBranchAddress("Layer", &layer);
267  tkTree->SetBranchAddress("Side", &side);
268  tkTree->SetBranchAddress("Half", &half);
269  tkTree->SetBranchAddress("Rod", &rod);
270  tkTree->SetBranchAddress("Ring", &ring);
271  tkTree->SetBranchAddress("Petal", &petal);
272  tkTree->SetBranchAddress("Blade", &blade);
273  tkTree->SetBranchAddress("Panel", &panel);
274  tkTree->SetBranchAddress("OuterInner", &outerInner);
275  tkTree->SetBranchAddress("Module", &module);
276  tkTree->SetBranchAddress("NStrips", &nStrips);
277  tkTree->SetBranchAddress("IsDoubleSide", &isDoubleSide);
278  tkTree->SetBranchAddress("IsRPhi", &isRPhi);
279  tkTree->SetBranchAddress("IsStereo", &isStereo);
280  tkTree->SetBranchAddress("UDirection", &uDirection);
281  tkTree->SetBranchAddress("VDirection", &vDirection);
282  tkTree->SetBranchAddress("WDirection", &wDirection);
283  tkTree->SetBranchAddress("PosR", &posR);
284  tkTree->SetBranchAddress("PosPhi", &posPhi);
285  tkTree->SetBranchAddress("PosEta", &posEta);
286  tkTree->SetBranchAddress("PosX", &posX);
287  tkTree->SetBranchAddress("PosY", &posY);
288  tkTree->SetBranchAddress("PosZ", &posZ);
289 
290  int nModules(tkTree->GetEntries());
291  TrackerSectorStruct allSectors;
292 
293  //Loop over all Sectors
294  unsigned int sectorCounter(0);
295  std::vector<edm::ParameterSet> v_sectorDef(parameterSet_.getParameter<std::vector<edm::ParameterSet> >("Sectors"));
296  edm::LogInfo("SectorBuilder") << "There are " << v_sectorDef.size() << " Sectors definded";
297  for (auto const& parSet : v_sectorDef) {
298  ++sectorCounter;
299  const std::string& sectorName(parSet.getParameter<std::string>("name"));
300  std::vector<unsigned int> v_rawId(parSet.getParameter<std::vector<unsigned int> >("rawId")),
301  v_subdetId(parSet.getParameter<std::vector<unsigned int> >("subdetId")),
302  v_layer(parSet.getParameter<std::vector<unsigned int> >("layer")),
303  v_side(parSet.getParameter<std::vector<unsigned int> >("side")),
304  v_half(parSet.getParameter<std::vector<unsigned int> >("half")),
305  v_rod(parSet.getParameter<std::vector<unsigned int> >("rod")),
306  v_ring(parSet.getParameter<std::vector<unsigned int> >("ring")),
307  v_petal(parSet.getParameter<std::vector<unsigned int> >("petal")),
308  v_blade(parSet.getParameter<std::vector<unsigned int> >("blade")),
309  v_panel(parSet.getParameter<std::vector<unsigned int> >("panel")),
310  v_outerInner(parSet.getParameter<std::vector<unsigned int> >("outerInner")),
311  v_module(parSet.getParameter<std::vector<unsigned int> >("module")),
312  v_nStrips(parSet.getParameter<std::vector<unsigned int> >("nStrips")),
313  v_isDoubleSide(parSet.getParameter<std::vector<unsigned int> >("isDoubleSide")),
314  v_isRPhi(parSet.getParameter<std::vector<unsigned int> >("isRPhi")),
315  v_isStereo(parSet.getParameter<std::vector<unsigned int> >("isStereo"));
316  std::vector<int> v_uDirection(parSet.getParameter<std::vector<int> >("uDirection")),
317  v_vDirection(parSet.getParameter<std::vector<int> >("vDirection")),
318  v_wDirection(parSet.getParameter<std::vector<int> >("wDirection"));
319  std::vector<double> v_posR(parSet.getParameter<std::vector<double> >("posR")),
320  v_posPhi(parSet.getParameter<std::vector<double> >("posPhi")),
321  v_posEta(parSet.getParameter<std::vector<double> >("posEta")),
322  v_posX(parSet.getParameter<std::vector<double> >("posX")),
323  v_posY(parSet.getParameter<std::vector<double> >("posY")),
324  v_posZ(parSet.getParameter<std::vector<double> >("posZ"));
325 
326  if (!this->checkIntervalsForSectors(sectorCounter, v_posR) ||
327  !this->checkIntervalsForSectors(sectorCounter, v_posPhi) ||
328  !this->checkIntervalsForSectors(sectorCounter, v_posEta) ||
329  !this->checkIntervalsForSectors(sectorCounter, v_posX) ||
330  !this->checkIntervalsForSectors(sectorCounter, v_posY) ||
331  !this->checkIntervalsForSectors(sectorCounter, v_posZ))
332  continue;
333 
334  TrackerSectorStruct tkSector;
335  tkSector.name = sectorName;
336 
337  ReducedTrackerTreeVariables tkTreeVar;
338 
339  //Loop over all Modules
340  for (int module = 0; module < nModules; ++module) {
341  tkTree->GetEntry(module);
342 
343  if (sectorCounter == 1) {
344  tkTreeVar.subdetId = subdetId;
345  tkTreeVar.nStrips = nStrips;
346  tkTreeVar.uDirection = uDirection;
347  tkTreeVar.vDirection = vDirection;
348  tkTreeVar.wDirection = wDirection;
349  m_tkTreeVar_[rawId] = tkTreeVar;
350  }
351 
352  if (!this->checkModuleIds(rawId, v_rawId))
353  continue;
354  if (!this->checkModuleIds(subdetId, v_subdetId))
355  continue;
356  if (!this->checkModuleIds(layer, v_layer))
357  continue;
358  if (!this->checkModuleIds(side, v_side))
359  continue;
360  if (!this->checkModuleIds(half, v_half))
361  continue;
362  if (!this->checkModuleIds(rod, v_rod))
363  continue;
364  if (!this->checkModuleIds(ring, v_ring))
365  continue;
366  if (!this->checkModuleIds(petal, v_petal))
367  continue;
368  if (!this->checkModuleIds(blade, v_blade))
369  continue;
370  if (!this->checkModuleIds(panel, v_panel))
371  continue;
372  if (!this->checkModuleIds(outerInner, v_outerInner))
373  continue;
374  if (!this->checkModuleIds(module, v_module))
375  continue;
376  if (!this->checkModuleIds(nStrips, v_nStrips))
377  continue;
378  if (!this->checkModuleBools(isDoubleSide, v_isDoubleSide))
379  continue;
380  if (!this->checkModuleBools(isRPhi, v_isRPhi))
381  continue;
382  if (!this->checkModuleBools(isStereo, v_isStereo))
383  continue;
384  if (!this->checkModuleDirections(uDirection, v_uDirection))
385  continue;
386  if (!this->checkModuleDirections(vDirection, v_vDirection))
387  continue;
388  if (!this->checkModuleDirections(wDirection, v_wDirection))
389  continue;
390  if (!this->checkModulePositions(posR, v_posR))
391  continue;
392  if (!this->checkModulePositions(posPhi, v_posPhi))
393  continue;
394  if (!this->checkModulePositions(posEta, v_posEta))
395  continue;
396  if (!this->checkModulePositions(posX, v_posX))
397  continue;
398  if (!this->checkModulePositions(posY, v_posY))
399  continue;
400  if (!this->checkModulePositions(posZ, v_posZ))
401  continue;
402 
403  tkSector.v_rawId.push_back(rawId);
404  bool moduleSelected(false);
405  for (auto const& i_rawId : allSectors.v_rawId) {
406  if (rawId == i_rawId)
407  moduleSelected = true;
408  }
409  if (!moduleSelected)
410  allSectors.v_rawId.push_back(rawId);
411  }
412 
413  bool isPixel(false);
414  bool isStrip(false);
415  for (auto const& i_rawId : tkSector.v_rawId) {
416  switch (m_tkTreeVar_[i_rawId].subdetId) {
417  case PixelSubdetector::PixelBarrel:
418  case PixelSubdetector::PixelEndcap:
419  isPixel = true;
420  break;
421  case StripSubdetector::TIB:
422  case StripSubdetector::TOB:
423  case StripSubdetector::TID:
424  case StripSubdetector::TEC:
425  isStrip = true;
426  break;
427  }
428  }
429 
430  if (isPixel && isStrip) {
431  edm::LogError("SectorBuilder")
432  << "Incorrect Sector Definition: there are pixel and strip modules within one sector"
433  << "\n... sector selection is not applied, sector " << sectorCounter << " is not built";
434  continue;
435  }
436  tkSector.isPixel = isPixel;
437 
438  m_tkSector_[sectorCounter] = tkSector;
439  edm::LogInfo("SectorBuilder") << "There are " << tkSector.v_rawId.size() << " Modules in Sector " << sectorCounter;
440  }
441  this->statistics(allSectors, nModules);
442  return;
443 }
444 
445 // -----------------------------------------------------------------------------------------------------------
446 
447 bool ApeEstimator::checkIntervalsForSectors(const unsigned int sectorCounter, const std::vector<double>& v_id) const {
448  if (v_id.empty())
449  return true;
450  if (v_id.size() % 2 == 1) {
451  edm::LogError("SectorBuilder")
452  << "Incorrect Sector Definition: Position Vectors need even number of arguments (Intervals)"
453  << "\n... sector selection is not applied, sector " << sectorCounter << " is not built";
454  return false;
455  }
456  int entry(0);
457  double intervalBegin(999.);
458  for (auto const& i_id : v_id) {
459  ++entry;
460  if (entry % 2 == 1)
461  intervalBegin = i_id;
462  if (entry % 2 == 0 && intervalBegin > i_id) {
463  edm::LogError("SectorBuilder") << "Incorrect Sector Definition (Position Vector Intervals): \t" << intervalBegin
464  << " is bigger than " << i_id << " but is expected to be smaller"
465  << "\n... sector selection is not applied, sector " << sectorCounter
466  << " is not built";
467  return false;
468  }
469  }
470  return true;
471 }
472 
473 bool ApeEstimator::checkModuleIds(const unsigned int id, const std::vector<unsigned int>& v_id) const {
474  if (v_id.empty())
475  return true;
476  for (auto const& i_id : v_id) {
477  if (id == i_id)
478  return true;
479  }
480  return false;
481 }
482 
483 bool ApeEstimator::checkModuleBools(const bool id, const std::vector<unsigned int>& v_id) const {
484  if (v_id.empty())
485  return true;
486  for (auto const& i_id : v_id) {
487  if (1 == i_id && id)
488  return true;
489  if (2 == i_id && !id)
490  return true;
491  }
492  return false;
493 }
494 
495 bool ApeEstimator::checkModuleDirections(const int id, const std::vector<int>& v_id) const {
496  if (v_id.empty())
497  return true;
498  for (auto const& i_id : v_id) {
499  if (id == i_id)
500  return true;
501  }
502  return false;
503 }
504 
505 bool ApeEstimator::checkModulePositions(const float id, const std::vector<double>& v_id) const {
506  if (v_id.empty())
507  return true;
508  int entry(0);
509  double intervalBegin(999.);
510  for (auto const& i_id : v_id) {
511  ++entry;
512  if (entry % 2 == 1)
513  intervalBegin = i_id;
514  if (entry % 2 == 0 && id >= intervalBegin && id < i_id)
515  return true;
516  }
517  return false;
518 }
519 
520 void ApeEstimator::statistics(const TrackerSectorStruct& allSectors, const int nModules) const {
521  bool commonModules(false);
522  for (std::map<unsigned int, TrackerSectorStruct>::const_iterator i_sector = m_tkSector_.begin();
523  i_sector != m_tkSector_.end();
524  ++i_sector) {
525  std::map<unsigned int, TrackerSectorStruct>::const_iterator i_sector2(i_sector);
526  for (++i_sector2; i_sector2 != m_tkSector_.end(); ++i_sector2) {
527  unsigned int nCommonModules(0);
528  for (auto const& i_module : (*i_sector).second.v_rawId) {
529  for (auto const& i_module2 : (*i_sector2).second.v_rawId) {
530  if (i_module2 == i_module)
531  ++nCommonModules;
532  }
533  }
534  if (nCommonModules == 0)
535  ; //edm::LogInfo("SectorBuilder")<<"Sector "<<(*i_sector).first<<" and Sector "<<(*i_sector2).first<< " have ZERO Modules in common";
536  else {
537  edm::LogError("SectorBuilder") << "Sector " << (*i_sector).first << " and Sector " << (*i_sector2).first
538  << " have " << nCommonModules << " Modules in common";
539  commonModules = true;
540  }
541  }
542  }
543  if (static_cast<int>(allSectors.v_rawId.size()) == nModules)
544  edm::LogInfo("SectorBuilder") << "ALL Tracker Modules are contained in the Sectors";
545  else
546  edm::LogWarning("SectorBuilder") << "There are " << allSectors.v_rawId.size() << " Modules in all Sectors"
547  << " out of " << nModules << " Tracker Modules";
548  if (!commonModules)
549  edm::LogInfo("SectorBuilder") << "There are ZERO modules associated to different sectors, no ambiguities exist";
550  else
551  edm::LogError("SectorBuilder")
552  << "There are modules associated to different sectors, APE value cannot be assigned reasonably";
553 }
554 
555 // -----------------------------------------------------------------------------------------------------------
556 
557 void ApeEstimator::residualErrorBinning() {
558  std::vector<double> v_residualErrorBinning(parameterSet_.getParameter<std::vector<double> >("residualErrorBinning"));
559  if (v_residualErrorBinning.size() == 1) {
560  edm::LogError("ResidualErrorBinning") << "Incorrect selection of Residual Error Bins (used for APE calculation): \t"
561  << "Only one argument passed, so no interval is specified"
562  << "\n... delete whole bin selection"; //m_resErrBins_ remains empty
563  return;
564  }
565  double xMin(0.), xMax(0.);
566  unsigned int binCounter(-1);
567  for (auto const& i_binning : v_residualErrorBinning) {
568  ++binCounter;
569  if (binCounter == 0) {
570  xMin = i_binning;
571  continue;
572  }
573  xMax = i_binning;
574  if (xMax <= xMin) {
575  edm::LogError("ResidualErrorBinning")
576  << "Incorrect selection of Residual Error Bins (used for APE calculation): \t" << xMin << " is bigger than "
577  << xMax << " but is expected to be smaller"
578  << "\n... delete whole bin selection";
579  m_resErrBins_.clear();
580  return;
581  }
582  m_resErrBins_[binCounter].first = xMin;
583  m_resErrBins_[binCounter].second = xMax;
584  xMin = xMax;
585  }
586  edm::LogInfo("ResidualErrorBinning")
587  << m_resErrBins_.size() << " Intervals of residual errors used for separate APE calculation sucessfully set";
588 }
589 
590 // -----------------------------------------------------------------------------------------------------------
591 
592 void ApeEstimator::bookSectorHistsForAnalyzerMode() {
593  std::vector<unsigned int> v_errHists(parameterSet_.getParameter<std::vector<unsigned int> >("vErrHists"));
594  for (std::vector<unsigned int>::iterator i_errHists = v_errHists.begin(); i_errHists != v_errHists.end();
595  ++i_errHists) {
596  for (std::vector<unsigned int>::iterator i_errHists2 = i_errHists; i_errHists2 != v_errHists.end();) {
597  ++i_errHists2;
598  if (*i_errHists == *i_errHists2) {
599  edm::LogError("BookSectorHists") << "Value of vErrHists in config exists twice: " << *i_errHists
600  << "\n... delete one of both";
601  v_errHists.erase(i_errHists2);
602  }
603  }
604  }
605 
606  for (auto& i_sector : m_tkSector_) {
607  bool zoomHists(parameterSet_.getParameter<bool>("zoomHists"));
608 
609  double widthMax = zoomHists ? 20. : 200.;
610  double chargePixelMax = zoomHists ? 200000. : 2000000.;
611  double chargeStripMax = zoomHists ? 1000. : 10000.;
612  double sOverNMax = zoomHists ? 200. : 2000.;
613  double logClusterProbMin = zoomHists ? -5. : -15.;
614 
615  double resXAbsMax = zoomHists ? 0.5 : 5.;
616  double norResXAbsMax = zoomHists ? 10. : 50.;
617  double probXMin = zoomHists ? -0.01 : -0.1;
618  double probXMax = zoomHists ? 0.11 : 1.1;
619  double sigmaXMin = zoomHists ? 0. : -0.05;
620  double sigmaXMax = zoomHists ? 0.02 : 1.;
621  double sigmaX2Max = sigmaXMax * sigmaXMax;
622  double sigmaXHitMax = zoomHists ? 0.02 : 1.;
623  double phiSensXMax = zoomHists ? 31. : 93.;
624 
625  double norChi2Max = zoomHists ? 5. : 1000.;
626  double d0Max = zoomHists ? 0.02 : 40.; // cosmics: 100.|100.
627  double dzMax = zoomHists ? 15. : 100.; // cosmics: 200.|600.
628  double pMax = zoomHists ? 200. : 2000.;
629  double invPMax = zoomHists ? 0.05 : 10.; //begins at 20GeV, 0.1GeV
630 
631  edm::Service<TFileService> fileService;
632  if (!fileService) {
633  throw edm::Exception(edm::errors::Configuration, "TFileService is not registered in cfg file");
634  }
635 
636  std::stringstream sector;
637  sector << "Sector_" << i_sector.first;
638  TFileDirectory secDir = fileService->mkdir(sector.str());
639 
640  // Dummy histo containing the sector name as title
641  i_sector.second.Name = secDir.make<TH1F>("z_name", i_sector.second.name.c_str(), 1, 0, 1);
642 
643  // Do not book histos for empty sectors
644  if (i_sector.second.v_rawId.empty()) {
645  continue;
646  }
647  // Set parameters for correlationHists
648  i_sector.second.setCorrHistParams(&secDir, norResXAbsMax, sigmaXHitMax, sigmaXMax);
649 
650  // Book pixel or strip specific hists
651  const bool pixelSector(i_sector.second.isPixel);
652 
653  // Cluster Parameters
654  i_sector.second.m_correlationHistsX["WidthX"] = i_sector.second.bookCorrHistsX("WidthX",
655  "cluster width",
656  "w_{cl,x}",
657  "[# channels]",
658  static_cast<int>(widthMax),
659  static_cast<int>(widthMax),
660  0.,
661  widthMax,
662  "nph");
663  i_sector.second.m_correlationHistsX["BaryStripX"] = i_sector.second.bookCorrHistsX(
664  "BaryStripX", "barycenter of cluster charge", "b_{cl,x}", "[# channels]", 800, 100, -10., 790., "nph");
665 
666  if (pixelSector) {
667  i_sector.second.m_correlationHistsY["WidthY"] = i_sector.second.bookCorrHistsY("WidthY",
668  "cluster width",
669  "w_{cl,y}",
670  "[# channels]",
671  static_cast<int>(widthMax),
672  static_cast<int>(widthMax),
673  0.,
674  widthMax,
675  "nph");
676  i_sector.second.m_correlationHistsY["BaryStripY"] = i_sector.second.bookCorrHistsY(
677  "BaryStripY", "barycenter of cluster charge", "b_{cl,y}", "[# channels]", 800, 100, -10., 790., "nph");
678 
679  i_sector.second.m_correlationHistsX["ChargePixel"] = i_sector.second.bookCorrHistsX(
680  "ChargePixel", "cluster charge", "c_{cl}", "[e]", 100, 50, 0., chargePixelMax, "nph");
681  i_sector.second.m_correlationHistsX["ClusterProbXY"] = i_sector.second.bookCorrHistsX(
682  "ClusterProbXY", "cluster probability xy", "prob_{cl,xy}", "", 100, 50, 0., 1., "nph");
683  i_sector.second.m_correlationHistsX["ClusterProbQ"] = i_sector.second.bookCorrHistsX(
684  "ClusterProbQ", "cluster probability q", "prob_{cl,q}", "", 100, 50, 0., 1., "nph");
685  i_sector.second.m_correlationHistsX["ClusterProbXYQ"] = i_sector.second.bookCorrHistsX(
686  "ClusterProbXYQ", "cluster probability xyq", "prob_{cl,xyq}", "", 100, 50, 0., 1., "nph");
687  i_sector.second.m_correlationHistsX["LogClusterProb"] = i_sector.second.bookCorrHistsX(
688  "LogClusterProb", "cluster probability xy", "log(prob_{cl,xy})", "", 60, 30, logClusterProbMin, 0., "nph");
689  i_sector.second.m_correlationHistsX["IsOnEdge"] =
690  i_sector.second.bookCorrHistsX("IsOnEdge", "IsOnEdge", "isOnEdge", "", 2, 2, 0, 2, "nph");
691  i_sector.second.m_correlationHistsX["HasBadPixels"] =
692  i_sector.second.bookCorrHistsX("HasBadPixels", "HasBadPixels", "hasBadPixels", "", 2, 2, 0, 2, "nph");
693  i_sector.second.m_correlationHistsX["SpansTwoRoc"] =
694  i_sector.second.bookCorrHistsX("SpansTwoRoc", "SpansTwoRoc", "spansTwoRoc", "", 2, 2, 0, 2, "nph");
695  i_sector.second.m_correlationHistsX["QBin"] =
696  i_sector.second.bookCorrHistsX("QBin", "q bin", "q bin", "", 8, 8, 0, 8, "nph");
697 
698  i_sector.second.m_correlationHistsY["ChargePixel"] = i_sector.second.bookCorrHistsY(
699  "ChargePixel", "cluster charge", "c_{cl}", "[e]", 100, 50, 0., chargePixelMax, "nph");
700  i_sector.second.m_correlationHistsY["ClusterProbXY"] = i_sector.second.bookCorrHistsY(
701  "ClusterProbXY", "cluster probability xy", "prob_{cl,xy}", "", 100, 50, 0., 1., "nph");
702  i_sector.second.m_correlationHistsY["ClusterProbQ"] = i_sector.second.bookCorrHistsY(
703  "ClusterProbQ", "cluster probability q", "prob_{cl,q}", "", 100, 50, 0., 1., "nph");
704  i_sector.second.m_correlationHistsY["ClusterProbXYQ"] = i_sector.second.bookCorrHistsY(
705  "ClusterProbXYQ", "cluster probability xyq", "prob_{cl,xyq}", "", 100, 50, 0., 1., "nph");
706  i_sector.second.m_correlationHistsY["LogClusterProb"] = i_sector.second.bookCorrHistsY(
707  "LogClusterProb", "cluster probability xy", "log(prob_{cl,xy})", "", 60, 30, logClusterProbMin, 0., "nph");
708  i_sector.second.m_correlationHistsY["IsOnEdge"] =
709  i_sector.second.bookCorrHistsY("IsOnEdge", "IsOnEdge", "isOnEdge", "", 2, 2, 0, 2, "nph");
710  i_sector.second.m_correlationHistsY["HasBadPixels"] =
711  i_sector.second.bookCorrHistsY("HasBadPixels", "HasBadPixels", "hasBadPixels", "", 2, 2, 0, 2, "nph");
712  i_sector.second.m_correlationHistsY["SpansTwoRoc"] =
713  i_sector.second.bookCorrHistsY("SpansTwoRoc", "SpansTwoRoc", "spansTwoRoc", "", 2, 2, 0, 2, "nph");
714  i_sector.second.m_correlationHistsY["QBin"] =
715  i_sector.second.bookCorrHistsY("QBin", "q bin", "q bin", "", 8, 8, 0, 8, "nph");
716  }
717 
718  else {
719  i_sector.second.m_correlationHistsX["ChargeStrip"] = i_sector.second.bookCorrHistsX(
720  "ChargeStrip", "cluster charge", "c_{cl}", "[APV counts]", 100, 50, 0., chargeStripMax, "nph");
721  i_sector.second.m_correlationHistsX["MaxStrip"] = i_sector.second.bookCorrHistsX(
722  "MaxStrip", "strip with max. charge", "n_{cl,max}", "[# strips]", 800, 800, -10., 790., "npht");
723  i_sector.second.m_correlationHistsX["MaxCharge"] = i_sector.second.bookCorrHistsX(
724  "MaxCharge", "charge of strip with max. charge", "c_{cl,max}", "[APV counts]", 300, 75, -10., 290., "nph");
725  i_sector.second.m_correlationHistsX["MaxIndex"] = i_sector.second.bookCorrHistsX(
726  "MaxIndex", "cluster-index of strip with max. charge", "i_{cl,max}", "[# strips]", 10, 10, 0., 10., "nph");
727  i_sector.second.m_correlationHistsX["ChargeOnEdges"] =
728  i_sector.second.bookCorrHistsX("ChargeOnEdges",
729  "fraction of charge on edge strips",
730  "(c_{st,L}+c_{st,R})/c_{cl}",
731  "",
732  60,
733  60,
734  -0.1,
735  1.1,
736  "nph");
737  i_sector.second.m_correlationHistsX["ChargeAsymmetry"] =
738  i_sector.second.bookCorrHistsX("ChargeAsymmetry",
739  "asymmetry of charge on edge strips",
740  "(c_{st,L}-c_{st,R})/c_{cl}",
741  "",
742  110,
743  55,
744  -1.1,
745  1.1,
746  "nph");
747  i_sector.second.m_correlationHistsX["ChargeLRplus"] =
748  i_sector.second.bookCorrHistsX("ChargeLRplus",
749  "fraction of charge not on maxStrip",
750  "(c_{cl,L}+c_{cl,R})/c_{cl}",
751  "",
752  60,
753  60,
754  -0.1,
755  1.1,
756  "nph");
757  i_sector.second.m_correlationHistsX["ChargeLRminus"] =
758  i_sector.second.bookCorrHistsX("ChargeLRminus",
759  "asymmetry of charge L and R of maxStrip",
760  "(c_{cl,L}-c_{cl,R})/c_{cl}",
761  "",
762  110,
763  55,
764  -1.1,
765  1.1,
766  "nph");
767  i_sector.second.m_correlationHistsX["SOverN"] =
768  i_sector.second.bookCorrHistsX("SOverN", "signal over noise", "s/N", "", 100, 50, 0, sOverNMax, "nph");
769  i_sector.second.m_correlationHistsX["WidthProj"] = i_sector.second.bookCorrHistsX(
770  "WidthProj", "projected width", "w_{p}", "[# strips]", 200, 20, 0., widthMax, "nph");
771  i_sector.second.m_correlationHistsX["WidthDiff"] = i_sector.second.bookCorrHistsX("WidthDiff",
772  "width difference",
773  "w_{p} - w_{cl}",
774  "[# strips]",
775  200,
776  20,
777  -widthMax / 2.,
778  widthMax / 2.,
779  "nph");
780 
781  i_sector.second.WidthVsWidthProjected = secDir.make<TH2F>("h2_widthVsWidthProj",
782  "w_{cl} vs. w_{p};w_{p} [# strips];w_{cl} [# strips]",
783  static_cast<int>(widthMax),
784  0,
785  widthMax,
786  static_cast<int>(widthMax),
787  0,
788  widthMax);
789  i_sector.second.PWidthVsWidthProjected =
790  secDir.make<TProfile>("p_widthVsWidthProj",
791  "w_{cl} vs. w_{p};w_{p} [# strips];w_{cl} [# strips]",
792  static_cast<int>(widthMax),
793  0,
794  widthMax);
795 
796  i_sector.second.WidthDiffVsMaxStrip =
797  secDir.make<TH2F>("h2_widthDiffVsMaxStrip",
798  "(w_{p} - w_{cl}) vs. n_{cl,max};n_{cl,max};w_{p} - w_{cl} [# strips]",
799  800,
800  -10.,
801  790.,
802  static_cast<int>(widthMax),
803  -widthMax / 2.,
804  widthMax / 2.);
805  i_sector.second.PWidthDiffVsMaxStrip =
806  secDir.make<TProfile>("p_widthDiffVsMaxStrip",
807  "(w_{p} - w_{cl}) vs. n_{cl,max};n_{cl,max};w_{p} - w_{cl} [# strips]",
808  800,
809  -10.,
810  790.);
811 
812  i_sector.second.WidthDiffVsSigmaXHit =
813  secDir.make<TH2F>("h2_widthDiffVsSigmaXHit",
814  "(w_{p} - w_{cl}) vs. #sigma_{hit,x};#sigma_{hit,x} [cm];w_{p} - w_{cl} [# strips]",
815  100,
816  0.,
817  sigmaXMax,
818  100,
819  -10.,
820  10.);
821  i_sector.second.PWidthDiffVsSigmaXHit =
822  secDir.make<TProfile>("p_widthDiffVsSigmaXHit",
823  "(w_{p} - w_{cl}) vs. #sigma_{hit,x};#sigma_{hit,x} [cm];w_{p} - w_{cl} [# strips]",
824  100,
825  0.,
826  sigmaXMax);
827 
828  i_sector.second.WidthVsPhiSensX =
829  secDir.make<TH2F>("h2_widthVsPhiSensX",
830  "w_{cl} vs. #phi_{module,x};#phi_{module,x} [ ^{o}];w_{cl} [# strips]",
831  93,
832  -93,
833  93,
834  static_cast<int>(widthMax),
835  0,
836  widthMax);
837  i_sector.second.PWidthVsPhiSensX = secDir.make<TProfile>(
838  "p_widthVsPhiSensX", "w_{cl} vs. #phi_{module,x};#phi_{module,x} [ ^{o}];w_{cl} [# strips]", 93, -93, 93);
839  }
840 
841  // Hit Parameters (transform errors and residuals from [cm] in [mum])
842  i_sector.second.m_correlationHistsX["SigmaXHit"] = i_sector.second.bookCorrHistsX(
843  "SigmaXHit", "hit error", "#sigma_{hit,x}", "[#mum]", 105, 20, sigmaXMin * 10000., sigmaXMax * 10000., "np");
844  i_sector.second.m_correlationHistsX["SigmaXTrk"] = i_sector.second.bookCorrHistsX(
845  "SigmaXTrk", "track error", "#sigma_{trk,x}", "[#mum]", 105, 20, sigmaXMin * 10000., sigmaXMax * 10000., "np");
846  i_sector.second.m_correlationHistsX["SigmaX"] = i_sector.second.bookCorrHistsX(
847  "SigmaX", "residual error", "#sigma_{r,x}", "[#mum]", 105, 20, sigmaXMin * 10000., sigmaXMax * 10000., "np");
848  i_sector.second.m_correlationHistsX["PhiSens"] = i_sector.second.bookCorrHistsX(
849  "PhiSens", "track angle on sensor", "#phi_{module}", "[ ^{o}]", 96, 48, -3, 93, "nphtr");
850  i_sector.second.m_correlationHistsX["PhiSensX"] = i_sector.second.bookCorrHistsX(
851  "PhiSensX", "track angle on sensor", "#phi_{module,x}", "[ ^{o}]", 186, 93, -phiSensXMax, phiSensXMax, "nphtr");
852  i_sector.second.m_correlationHistsX["PhiSensY"] = i_sector.second.bookCorrHistsX(
853  "PhiSensY", "track angle on sensor", "#phi_{module,y}", "[ ^{o}]", 186, 93, -93, 93, "nphtr");
854 
855  i_sector.second.XHit = secDir.make<TH1F>("h_XHit", " hit measurement x_{hit};x_{hit} [cm];# hits", 100, -20, 20);
856  i_sector.second.XTrk = secDir.make<TH1F>("h_XTrk", "track prediction x_{trk};x_{trk} [cm];# hits", 100, -20, 20);
857  i_sector.second.SigmaX2 =
858  secDir.make<TH1F>("h_SigmaX2",
859  "squared residual error #sigma_{r,x}^{2};#sigma_{r,x}^{2} [#mum^{2}];# hits",
860  105,
861  sigmaXMin * 10000.,
862  sigmaX2Max * 10000. * 10000.); //no mistake !
863  i_sector.second.ResX = secDir.make<TH1F>(
864  "h_ResX", "residual r_{x};x_{trk}-x_{hit} [#mum];# hits", 100, -resXAbsMax * 10000., resXAbsMax * 10000.);
865  i_sector.second.NorResX =
866  secDir.make<TH1F>("h_NorResX",
867  "normalized residual r_{x}/#sigma_{r,x};(x_{trk}-x_{hit})/#sigma_{r,x};# hits",
868  100,
869  -norResXAbsMax,
870  norResXAbsMax);
871  i_sector.second.ProbX = secDir.make<TH1F>(
872  "h_ProbX", "residual probability;prob(r_{x}^{2}/#sigma_{r,x}^{2},1);# hits", 60, probXMin, probXMax);
873 
874  i_sector.second.PhiSensXVsBarycentreX =
875  secDir.make<TH2F>("h2_phiSensXVsBarycentreX",
876  "#phi_{module,x} vs. b_{cl,x};b_{cl,x} [# channels];#phi_{module,x} [ ^{o}]",
877  200,
878  -10.,
879  790.,
880  93,
881  -93,
882  93);
883  i_sector.second.PPhiSensXVsBarycentreX =
884  secDir.make<TProfile>("p_phiSensXVsBarycentreX",
885  "#phi_{module,x} vs. b_{cl,x};b_{cl,x} [# channels];#phi_{module,x} [ ^{o}]",
886  200,
887  -10.,
888  790.);
889 
890  if (pixelSector) {
891  i_sector.second.m_correlationHistsY["SigmaYHit"] = i_sector.second.bookCorrHistsY(
892  "SigmaYHit", "hit error", "#sigma_{hit,y}", "[#mum]", 105, 20, sigmaXMin * 10000., sigmaXMax * 10000., "np");
893  i_sector.second.m_correlationHistsY["SigmaYTrk"] = i_sector.second.bookCorrHistsY(
894  "SigmaYTrk", "track error", "#sigma_{trk,y}", "[#mum]", 105, 20, sigmaXMin * 10000., sigmaXMax * 10000., "np");
895  i_sector.second.m_correlationHistsY["SigmaY"] = i_sector.second.bookCorrHistsY(
896  "SigmaY", "residual error", "#sigma_{r,y}", "[#mum]", 105, 20, sigmaXMin * 10000., sigmaXMax * 10000., "np");
897  i_sector.second.m_correlationHistsY["PhiSens"] = i_sector.second.bookCorrHistsY(
898  "PhiSens", "track angle on sensor", "#phi_{module}", "[ ^{o}]", 96, 48, -3, 93, "nphtr");
899  i_sector.second.m_correlationHistsY["PhiSensX"] = i_sector.second.bookCorrHistsY("PhiSensX",
900  "track angle on sensor",
901  "#phi_{module,x}",
902  "[ ^{o}]",
903  186,
904  93,
905  -phiSensXMax,
906  phiSensXMax,
907  "nphtr");
908  i_sector.second.m_correlationHistsY["PhiSensY"] = i_sector.second.bookCorrHistsY(
909  "PhiSensY", "track angle on sensor", "#phi_{module,y}", "[ ^{o}]", 186, 93, -93, 93, "nphtr");
910 
911  i_sector.second.YHit = secDir.make<TH1F>("h_YHit", " hit measurement y_{hit};y_{hit} [cm];# hits", 100, -20, 20);
912  i_sector.second.YTrk = secDir.make<TH1F>("h_YTrk", "track prediction y_{trk};y_{trk} [cm];# hits", 100, -20, 20);
913  i_sector.second.SigmaY2 =
914  secDir.make<TH1F>("h_SigmaY2",
915  "squared residual error #sigma_{r,y}^{2};#sigma_{r,y}^{2} [#mum^{2}];# hits",
916  105,
917  sigmaXMin * 10000.,
918  sigmaX2Max * 10000. * 10000.); //no mistake !
919  i_sector.second.ResY = secDir.make<TH1F>(
920  "h_ResY", "residual r_{y};y_{trk}-y_{hit} [#mum];# hits", 100, -resXAbsMax * 10000., resXAbsMax * 10000.);
921  i_sector.second.NorResY =
922  secDir.make<TH1F>("h_NorResY",
923  "normalized residual r_{y}/#sigma_{r,y};(y_{trk}-y_{hit})/#sigma_{r,y};# hits",
924  100,
925  -norResXAbsMax,
926  norResXAbsMax);
927  i_sector.second.ProbY = secDir.make<TH1F>(
928  "h_ProbY", "residual probability;prob(r_{y}^{2}/#sigma_{r,y}^{2},1);# hits", 60, probXMin, probXMax);
929 
930  i_sector.second.PhiSensYVsBarycentreY =
931  secDir.make<TH2F>("h2_phiSensYVsBarycentreY",
932  "#phi_{module,y} vs. b_{cl,y};b_{cl,y} [# channels];#phi_{module,y} [ ^{o}]",
933  200,
934  -10.,
935  790.,
936  93,
937  -93,
938  93);
939  i_sector.second.PPhiSensYVsBarycentreY =
940  secDir.make<TProfile>("p_phiSensYVsBarycentreY",
941  "#phi_{module,y} vs. b_{cl,y};b_{cl,y} [# channels];#phi_{module,y} [ ^{o}]",
942  200,
943  -10.,
944  790.);
945  }
946 
947  // Track Parameters
948  i_sector.second.m_correlationHistsX["HitsValid"] =
949  i_sector.second.bookCorrHistsX("HitsValid", "# hits", "[valid]", 50, 0, 50, "npt");
950  i_sector.second.m_correlationHistsX["HitsInvalid"] =
951  i_sector.second.bookCorrHistsX("HitsInvalid", "# hits", "[invalid]", 20, 0, 20, "npt");
952  i_sector.second.m_correlationHistsX["Hits2D"] =
953  i_sector.second.bookCorrHistsX("Hits2D", "# hits", "[2D]", 20, 0, 20, "npt");
954  i_sector.second.m_correlationHistsX["LayersMissed"] =
955  i_sector.second.bookCorrHistsX("LayersMissed", "# layers", "[missed]", 10, 0, 10, "npt");
956  i_sector.second.m_correlationHistsX["HitsPixel"] =
957  i_sector.second.bookCorrHistsX("HitsPixel", "# hits", "[pixel]", 10, 0, 10, "npt");
958  i_sector.second.m_correlationHistsX["HitsStrip"] =
959  i_sector.second.bookCorrHistsX("HitsStrip", "# hits", "[strip]", 40, 0, 40, "npt");
960  i_sector.second.m_correlationHistsX["HitsGood"] =
961  i_sector.second.bookCorrHistsX("HitsGood", "# hits", "[good]", 50, 0, 50, "npt");
962  i_sector.second.m_correlationHistsX["NorChi2"] =
963  i_sector.second.bookCorrHistsX("NorChi2", "#chi^{2}/f", "", 50, 0, norChi2Max, "npr");
964  i_sector.second.m_correlationHistsX["Theta"] =
965  i_sector.second.bookCorrHistsX("Theta", "#theta", "[ ^{o}]", 40, -10, 190, "npt");
966  i_sector.second.m_correlationHistsX["Phi"] =
967  i_sector.second.bookCorrHistsX("Phi", "#phi", "[ ^{o}]", 76, -190, 190, "npt");
968  i_sector.second.m_correlationHistsX["D0Beamspot"] =
969  i_sector.second.bookCorrHistsX("D0Beamspot", "d_{0, BS}", "[cm]", 40, -d0Max, d0Max, "npt");
970  i_sector.second.m_correlationHistsX["Dz"] =
971  i_sector.second.bookCorrHistsX("Dz", "d_{z}", "[cm]", 40, -dzMax, dzMax, "npt");
972  i_sector.second.m_correlationHistsX["Pt"] =
973  i_sector.second.bookCorrHistsX("Pt", "p_{t}", "[GeV]", 50, 0, pMax, "npt");
974  i_sector.second.m_correlationHistsX["P"] = i_sector.second.bookCorrHistsX("P", "|p|", "[GeV]", 50, 0, pMax, "npt");
975  i_sector.second.m_correlationHistsX["InvP"] =
976  i_sector.second.bookCorrHistsX("InvP", "1/|p|", "[GeV^{-1}]", 25, 0, invPMax, "t");
977  i_sector.second.m_correlationHistsX["MeanAngle"] =
978  i_sector.second.bookCorrHistsX("MeanAngle", "<#phi_{module}>", "[ ^{o}]", 25, -5, 95, "npt");
979  //i_sector.second.m_correlationHistsX[""] = i_sector.second.bookCorrHistsX("","","",,,,"nphtr");
980 
981  if (pixelSector) {
982  i_sector.second.m_correlationHistsY["HitsValid"] =
983  i_sector.second.bookCorrHistsY("HitsValid", "# hits", "[valid]", 50, 0, 50, "npt");
984  i_sector.second.m_correlationHistsY["HitsInvalid"] =
985  i_sector.second.bookCorrHistsY("HitsInvalid", "# hits", "[invalid]", 20, 0, 20, "npt");
986  i_sector.second.m_correlationHistsY["Hits2D"] =
987  i_sector.second.bookCorrHistsY("Hits2D", "# hits", "[2D]", 20, 0, 20, "npt");
988  i_sector.second.m_correlationHistsY["LayersMissed"] =
989  i_sector.second.bookCorrHistsY("LayersMissed", "# layers", "[missed]", 10, 0, 10, "npt");
990  i_sector.second.m_correlationHistsY["HitsPixel"] =
991  i_sector.second.bookCorrHistsY("HitsPixel", "# hits", "[pixel]", 10, 0, 10, "npt");
992  i_sector.second.m_correlationHistsY["HitsStrip"] =
993  i_sector.second.bookCorrHistsY("HitsStrip", "# hits", "[strip]", 40, 0, 40, "npt");
994  i_sector.second.m_correlationHistsY["HitsGood"] =
995  i_sector.second.bookCorrHistsY("HitsGood", "# hits", "[good]", 50, 0, 50, "npt");
996  i_sector.second.m_correlationHistsY["NorChi2"] =
997  i_sector.second.bookCorrHistsY("NorChi2", "#chi^{2}/f", "", 50, 0, norChi2Max, "npr");
998  i_sector.second.m_correlationHistsY["Theta"] =
999  i_sector.second.bookCorrHistsY("Theta", "#theta", "[ ^{o}]", 40, -10, 190, "npt");
1000  i_sector.second.m_correlationHistsY["Phi"] =
1001  i_sector.second.bookCorrHistsY("Phi", "#phi", "[ ^{o}]", 76, -190, 190, "npt");
1002  i_sector.second.m_correlationHistsY["D0Beamspot"] =
1003  i_sector.second.bookCorrHistsY("D0Beamspot", "d_{0, BS}", "[cm]", 40, -d0Max, d0Max, "npt");
1004  i_sector.second.m_correlationHistsY["Dz"] =
1005  i_sector.second.bookCorrHistsY("Dz", "d_{z}", "[cm]", 40, -dzMax, dzMax, "npt");
1006  i_sector.second.m_correlationHistsY["Pt"] =
1007  i_sector.second.bookCorrHistsY("Pt", "p_{t}", "[GeV]", 50, 0, pMax, "npt");
1008  i_sector.second.m_correlationHistsY["P"] =
1009  i_sector.second.bookCorrHistsY("P", "|p|", "[GeV]", 50, 0, pMax, "npt");
1010  i_sector.second.m_correlationHistsY["InvP"] =
1011  i_sector.second.bookCorrHistsY("InvP", "1/|p|", "[GeV^{-1}]", 25, 0, invPMax, "t");
1012  i_sector.second.m_correlationHistsY["MeanAngle"] =
1013  i_sector.second.bookCorrHistsY("MeanAngle", "<#phi_{module}>", "[ ^{o}]", 25, -5, 95, "npt");
1014  }
1015 
1016  // (transform errors and residuals from [cm] in [mum])
1017  for (auto const& i_errHists : v_errHists) {
1018  double xMin(0.01 * (i_errHists - 1)), xMax(0.01 * (i_errHists));
1019  std::stringstream sigmaXHit, sigmaXTrk, sigmaX;
1020  sigmaXHit << "h_sigmaXHit_" << i_errHists;
1021  sigmaXTrk << "h_sigmaXTrk_" << i_errHists;
1022  sigmaX << "h_sigmaX_" << i_errHists;
1023  i_sector.second.m_sigmaX["sigmaXHit"].push_back(
1024  secDir.make<TH1F>(sigmaXHit.str().c_str(),
1025  "hit error #sigma_{hit,x};#sigma_{hit,x} [#mum];# hits",
1026  100,
1027  xMin * 10000.,
1028  xMax * 10000.));
1029  i_sector.second.m_sigmaX["sigmaXTrk"].push_back(
1030  secDir.make<TH1F>(sigmaXTrk.str().c_str(),
1031  "track error #sigma_{trk,x};#sigma_{trk,x} [#mum];# hits",
1032  100,
1033  xMin * 10000.,
1034  xMax * 10000.));
1035  i_sector.second.m_sigmaX["sigmaX"].push_back(
1036  secDir.make<TH1F>(sigmaX.str().c_str(),
1037  "residual error #sigma_{r,x};#sigma_{r,x} [#mum];# hits",
1038  100,
1039  xMin * 10000.,
1040  xMax * 10000.));
1041  if (pixelSector) {
1042  std::stringstream sigmaYHit, sigmaYTrk, sigmaY;
1043  sigmaYHit << "h_sigmaYHit_" << i_errHists;
1044  sigmaYTrk << "h_sigmaYTrk_" << i_errHists;
1045  sigmaY << "h_sigmaY_" << i_errHists;
1046  i_sector.second.m_sigmaY["sigmaYHit"].push_back(
1047  secDir.make<TH1F>(sigmaYHit.str().c_str(),
1048  "hit error #sigma_{hit,y};#sigma_{hit,y} [#mum];# hits",
1049  100,
1050  xMin * 10000.,
1051  xMax * 10000.));
1052  i_sector.second.m_sigmaY["sigmaYTrk"].push_back(
1053  secDir.make<TH1F>(sigmaYTrk.str().c_str(),
1054  "track error #sigma_{trk,y};#sigma_{trk,y} [#mum];# hits",
1055  100,
1056  xMin * 10000.,
1057  xMax * 10000.));
1058  i_sector.second.m_sigmaY["sigmaY"].push_back(
1059  secDir.make<TH1F>(sigmaY.str().c_str(),
1060  "residual error #sigma_{r,y};#sigma_{r,y} [#mum];# hits",
1061  100,
1062  xMin * 10000.,
1063  xMax * 10000.));
1064  }
1065  }
1066  }
1067 }
1068 
1069 void ApeEstimator::bookSectorHistsForApeCalculation() {
1070  std::vector<unsigned int> v_errHists(parameterSet_.getParameter<std::vector<unsigned int> >("vErrHists"));
1071  for (std::vector<unsigned int>::iterator i_errHists = v_errHists.begin(); i_errHists != v_errHists.end();
1072  ++i_errHists) {
1073  for (std::vector<unsigned int>::iterator i_errHists2 = i_errHists; i_errHists2 != v_errHists.end();) {
1074  ++i_errHists2;
1075  if (*i_errHists == *i_errHists2) {
1076  edm::LogError("BookSectorHists") << "Value of vErrHists in config exists twice: " << *i_errHists
1077  << "\n... delete one of both";
1078  v_errHists.erase(i_errHists2);
1079  }
1080  }
1081  }
1082 
1083  for (auto& i_sector : m_tkSector_) {
1084  edm::Service<TFileService> fileService;
1085  if (!fileService) {
1086  throw edm::Exception(edm::errors::Configuration, "TFileService is not registered in cfg file");
1087  }
1088 
1089  std::stringstream sector;
1090  sector << "Sector_" << i_sector.first;
1091  TFileDirectory secDir = fileService->mkdir(sector.str());
1092 
1093  // Dummy histo containing the sector name as title
1094  i_sector.second.Name = secDir.make<TH1F>("z_name", i_sector.second.name.c_str(), 1, 0, 1);
1095 
1096  // Do not book histos for empty sectors
1097  if (i_sector.second.v_rawId.empty()) {
1098  continue;
1099  }
1100 
1101  // Distributions in each interval (stay in [cm], to have all calculations in [cm])
1102  if (m_resErrBins_
1103  .empty()) { // default if no selection taken into account: calculate APE with one bin with residual error 0-100um
1104  m_resErrBins_[1].first = 0.;
1105  m_resErrBins_[1].second = 0.01;
1106  }
1107  for (auto const& i_errBins : m_resErrBins_) {
1108  std::stringstream interval;
1109  interval << "Interval_" << i_errBins.first;
1110  TFileDirectory intDir = secDir.mkdir(interval.str());
1111  i_sector.second.m_binnedHists[i_errBins.first]["sigmaX"] =
1112  intDir.make<TH1F>("h_sigmaX", "residual resolution #sigma_{x};#sigma_{x} [cm];# hits", 100, 0., 0.01);
1113  i_sector.second.m_binnedHists[i_errBins.first]["norResX"] = intDir.make<TH1F>(
1114  "h_norResX", "normalized residual r_{x}/#sigma_{r,x};(x_{trk}-x_{hit})/#sigma_{r,x};# hits", 100, -10, 10);
1115  if (i_sector.second.isPixel) {
1116  i_sector.second.m_binnedHists[i_errBins.first]["sigmaY"] =
1117  intDir.make<TH1F>("h_sigmaY", "residual resolution #sigma_{y};#sigma_{y} [cm];# hits", 100, 0., 0.01);
1118  i_sector.second.m_binnedHists[i_errBins.first]["norResY"] = intDir.make<TH1F>(
1119  "h_norResY", "normalized residual r_{y}/#sigma_{r,y};(y_{trk}-y_{hit})/#sigma_{r,y};# hits", 100, -10, 10);
1120  }
1121  }
1122 
1123  TFileDirectory resDir = secDir.mkdir("Results");
1124 
1125  // TTree containing rawIds of all modules in sector
1126  unsigned int rawId(0);
1127  i_sector.second.RawId = resDir.make<TTree>("rawIdTree", "Tree containing rawIds of all modules in sector");
1128  i_sector.second.RawId->Branch("RawId", &rawId, "RawId/i");
1129  for (auto const& i_rawId : i_sector.second.v_rawId) {
1130  rawId = i_rawId;
1131  i_sector.second.RawId->Fill();
1132  }
1133 
1134  // Result plots (one hist per sector containing one bin per interval)
1135  // (transform errors and residuals from [cm] in [mum])
1136  std::vector<double> v_binX(parameterSet_.getParameter<std::vector<double> >("residualErrorBinning"));
1137  for (auto& i_binX : v_binX) {
1138  i_binX *= 10000.;
1139  }
1140  i_sector.second.EntriesX =
1141  resDir.make<TH1F>("h_entriesX", "# hits used;#sigma_{x} [#mum];# hits", v_binX.size() - 1, &(v_binX[0]));
1142  if (i_sector.second.isPixel) {
1143  i_sector.second.EntriesY =
1144  resDir.make<TH1F>("h_entriesY", "# hits used;#sigma_{y} [#mum];# hits", v_binX.size() - 1, &(v_binX[0]));
1145  }
1146 
1147  // In fact these are un-needed Analyzer plots, but I want to have them always for every sector visible
1148  // (transform errors and residuals from [cm] in [mum])
1149  i_sector.second.ResX = resDir.make<TH1F>(
1150  "h_ResX", "residual r_{x};x_{trk}-x_{hit} [#mum];# hits", 100, -0.03 * 10000., 0.03 * 10000.);
1151  i_sector.second.NorResX = resDir.make<TH1F>(
1152  "h_NorResX", "normalized residual r_{x}/#sigma_{r,x};(x_{trk}-x_{hit})/#sigma_{r,x};# hits", 100, -5., 5.);
1153  if (i_sector.second.isPixel) {
1154  i_sector.second.ResY = resDir.make<TH1F>(
1155  "h_ResY", "residual r_{y};y_{trk}-y_{hit} [#mum];# hits", 100, -0.03 * 10000., 0.03 * 10000.);
1156  i_sector.second.NorResY = resDir.make<TH1F>(
1157  "h_NorResY", "normalized residual r_{y}/#sigma_{r,y};(y_{trk}-y_{hit})/#sigma_{r,y};# hits", 100, -5., 5.);
1158  }
1159  }
1160 }
1161 
1162 // -----------------------------------------------------------------------------------------------------------
1163 
1164 void ApeEstimator::bookTrackHists() {
1165  bool zoomHists(parameterSet_.getParameter<bool>("zoomHists"));
1166 
1167  int trackSizeBins = zoomHists ? 6 : 201;
1168  double trackSizeMax = trackSizeBins - 1;
1169 
1170  double chi2Max = zoomHists ? 100. : 2000.;
1171  double norChi2Max = zoomHists ? 5. : 1000.;
1172  double d0max = zoomHists ? 0.02 : 40.; // cosmics: 100.|100.
1173  double dzmax = zoomHists ? 15. : 100.; // cosmics: 200.|600.
1174  double pMax = zoomHists ? 200. : 2000.;
1175 
1176  edm::Service<TFileService> fileService;
1177  TFileDirectory evtDir = fileService->mkdir("EventVariables");
1178  tkDetector_.TrkSize =
1179  evtDir.make<TH1F>("h_trackSize", "# tracks [all];# tracks;# events", trackSizeBins, -1, trackSizeMax);
1180  tkDetector_.TrkSizeGood =
1181  evtDir.make<TH1F>("h_trackSizeGood", "# tracks [good];# tracks;# events", trackSizeBins, -1, trackSizeMax);
1182  TFileDirectory trkDir = fileService->mkdir("TrackVariables");
1183  tkDetector_.HitsSize = trkDir.make<TH1F>("h_hitsSize", "# hits;# hits;# tracks", 51, -1, 50);
1184  tkDetector_.HitsValid = trkDir.make<TH1F>("h_hitsValid", "# hits [valid];# hits [valid];# tracks", 51, -1, 50);
1185  tkDetector_.HitsInvalid =
1186  trkDir.make<TH1F>("h_hitsInvalid", "# hits [invalid];# hits [invalid];# tracks", 21, -1, 20);
1187  tkDetector_.Hits2D = trkDir.make<TH1F>("h_hits2D", "# hits [2D];# hits [2D];# tracks", 21, -1, 20);
1188  tkDetector_.LayersMissed =
1189  trkDir.make<TH1F>("h_layersMissed", "# layers [missed];# layers [missed];# tracks", 11, -1, 10);
1190  tkDetector_.HitsPixel = trkDir.make<TH1F>("h_hitsPixel", "# hits [pixel];# hits [pixel];# tracks", 11, -1, 10);
1191  tkDetector_.HitsStrip = trkDir.make<TH1F>("h_hitsStrip", "# hits [strip];# hits [strip];# tracks", 41, -1, 40);
1192  tkDetector_.Charge = trkDir.make<TH1F>("h_charge", "charge q;q [e];# tracks", 5, -2, 3);
1193  tkDetector_.Chi2 = trkDir.make<TH1F>("h_chi2", " #chi^{2};#chi^{2};# tracks", 100, 0, chi2Max);
1194  tkDetector_.Ndof = trkDir.make<TH1F>("h_ndof", "# degrees of freedom f;f;# tracks", 101, -1, 100);
1195  tkDetector_.NorChi2 = trkDir.make<TH1F>("h_norChi2", "normalized #chi^{2};#chi^{2}/f;# tracks", 200, 0, norChi2Max);
1196  tkDetector_.Prob = trkDir.make<TH1F>("h_prob", " #chi^{2} probability;prob(#chi^{2},f);# tracks", 50, 0, 1);
1197  tkDetector_.Eta = trkDir.make<TH1F>("h_eta", "pseudorapidity #eta;#eta;# tracks", 100, -5, 5);
1198  tkDetector_.EtaErr = trkDir.make<TH1F>("h_etaErr", "Error of #eta;#sigma(#eta);# tracks", 100, 0, 0.001);
1199  tkDetector_.EtaSig =
1200  trkDir.make<TH1F>("h_etaSig", "Significance of #eta;#eta/#sigma(#eta);# tracks", 100, -20000, 20000);
1201  tkDetector_.Theta = trkDir.make<TH1F>("h_theta", "polar angle #theta;#theta [ ^{o}];# tracks", 100, -10, 190);
1202  tkDetector_.Phi = trkDir.make<TH1F>("h_phi", "azimuth angle #phi;#phi [ ^{o}];# tracks", 190, -190, 190);
1203  tkDetector_.PhiErr = trkDir.make<TH1F>("h_phiErr", "Error of #phi;#sigma(#phi) [ ^{o}];# tracks", 100, 0, 0.04);
1204  tkDetector_.PhiSig =
1205  trkDir.make<TH1F>("h_phiSig", "Significance of #phi;#phi/#sigma(#phi) [ ^{o}];# tracks", 100, -50000, 50000);
1206  tkDetector_.D0Beamspot = trkDir.make<TH1F>(
1207  "h_d0Beamspot", "Closest approach d_{0} wrt. beamspot;d_{0, BS} [cm];# tracks", 200, -d0max, d0max);
1208  tkDetector_.D0BeamspotErr =
1209  trkDir.make<TH1F>("h_d0BeamspotErr", "Error of d_{0, BS};#sigma(d_{0, BS}) [cm];# tracks", 200, 0, 0.01);
1210  tkDetector_.D0BeamspotSig = trkDir.make<TH1F>(
1211  "h_d0BeamspotSig", "Significance of d_{0, BS};d_{0, BS}/#sigma(d_{0, BS});# tracks", 100, -5, 5);
1212  tkDetector_.Dz = trkDir.make<TH1F>("h_dz", "Closest approach d_{z};d_{z} [cm];# tracks", 200, -dzmax, dzmax);
1213  tkDetector_.DzErr = trkDir.make<TH1F>("h_dzErr", "Error of d_{z};#sigma(d_{z}) [cm];# tracks", 200, 0, 0.01);
1214  tkDetector_.DzSig =
1215  trkDir.make<TH1F>("h_dzSig", "Significance of d_{z};d_{z}/#sigma(d_{z});# tracks", 100, -10000, 10000);
1216  tkDetector_.Pt = trkDir.make<TH1F>("h_pt", "transverse momentum p_{t};p_{t} [GeV];# tracks", 100, 0, pMax);
1217  tkDetector_.PtErr = trkDir.make<TH1F>("h_ptErr", "Error of p_{t};#sigma(p_{t}) [GeV];# tracks", 100, 0, 1.6);
1218  tkDetector_.PtSig = trkDir.make<TH1F>("h_ptSig", "Significance of p_{t};p_{t}/#sigma(p_{t});# tracks", 100, 0, 200);
1219  tkDetector_.P = trkDir.make<TH1F>("h_p", "momentum magnitude |p|;|p| [GeV];# tracks", 100, 0, pMax);
1220  tkDetector_.MeanAngle = trkDir.make<TH1F>(
1221  "h_meanAngle", "mean angle on module <#phi_{module}>;<#phi_{module}> [ ^{o}];# tracks", 100, -5, 95);
1222  tkDetector_.HitsGood = trkDir.make<TH1F>("h_hitsGood", "# hits [good];# hits [good];# tracks", 51, -1, 50);
1223 
1224  tkDetector_.MeanAngleVsHits = trkDir.make<TH2F>(
1225  "h2_meanAngleVsHits", "<#phi_{module}> vs. # hits;# hits;<#phi_{module}> [ ^{o}]", 51, -1, 50, 50, -5, 95);
1226  tkDetector_.HitsGoodVsHitsValid =
1227  trkDir.make<TH2F>("h2_hitsGoodVsHitsValid",
1228  "# hits [good] vs. # hits [valid];# hits [valid];# hits [good]",
1229  51,
1230  -1,
1231  50,
1232  51,
1233  -1,
1234  50);
1235  tkDetector_.HitsPixelVsEta =
1236  trkDir.make<TH2F>("h2_hitsPixelVsEta", "# hits [pixel] vs. #eta;#eta;# hits [pixel]", 60, -3, 3, 11, -1, 10);
1237  tkDetector_.HitsPixelVsTheta = trkDir.make<TH2F>(
1238  "h2_hitsPixelVsTheta", "# hits [pixel] vs. #theta;#theta;# hits [pixel]", 100, -10, 190, 11, -1, 10);
1239  tkDetector_.HitsStripVsEta =
1240  trkDir.make<TH2F>("h2_hitsStripVsEta", "# hits [strip] vs. #eta;#eta;# hits [strip]", 60, -3, 3, 31, -1, 40);
1241  tkDetector_.HitsStripVsTheta = trkDir.make<TH2F>(
1242  "h2_hitsStripVsTheta", "# hits [strip] vs. #theta;#theta;# hits [strip]", 100, -10, 190, 31, -1, 40);
1243  tkDetector_.PtVsEta = trkDir.make<TH2F>("h2_ptVsEta", "p_{t} vs. #eta;#eta;p_{t} [GeV]", 60, -3, 3, 100, 0, pMax);
1244  tkDetector_.PtVsTheta =
1245  trkDir.make<TH2F>("h2_ptVsTheta", "p_{t} vs. #theta;#theta;p_{t} [GeV]", 100, -10, 190, 100, 0, pMax);
1246 
1247  tkDetector_.PMeanAngleVsHits = trkDir.make<TProfile>(
1248  "p_meanAngleVsHits", "<#phi_{module}> vs. # hits;# hits;<#phi_{module}> [ ^{o}]", 51, -1, 50);
1249  tkDetector_.PHitsGoodVsHitsValid = trkDir.make<TProfile>(
1250  "p_hitsGoodVsHitsValid", "# hits [good] vs. # hits [valid];# hits [valid];# hits [good]", 51, -1, 50);
1251  tkDetector_.PHitsPixelVsEta =
1252  trkDir.make<TProfile>("p_hitsPixelVsEta", "# hits [pixel] vs. #eta;#eta;# hits [pixel]", 60, -3, 3);
1253  tkDetector_.PHitsPixelVsTheta =
1254  trkDir.make<TProfile>("p_hitsPixelVsTheta", "# hits [pixel] vs. #theta;#theta;# hits [pixel]", 100, -10, 190);
1255  tkDetector_.PHitsStripVsEta =
1256  trkDir.make<TProfile>("p_hitsStripVsEta", "# hits [strip] vs. #eta;#eta;# hits [strip]", 60, -3, 3);
1257  tkDetector_.PHitsStripVsTheta =
1258  trkDir.make<TProfile>("p_hitsStripVsTheta", "# hits [strip] vs. #theta;#theta;# hits [strip]", 100, -10, 190);
1259  tkDetector_.PPtVsEta = trkDir.make<TProfile>("p_ptVsEta", "p_{t} vs. #eta;#eta;p_{t} [GeV]", 60, -3, 3);
1260  tkDetector_.PPtVsTheta = trkDir.make<TProfile>("p_ptVsTheta", "p_{t} vs. #theta;#theta;p_{t} [GeV]", 100, -10, 190);
1261 }
1262 
1263 // -----------------------------------------------------------------------------------------------------------
1264 
1265 TrackStruct::TrackParameterStruct ApeEstimator::fillTrackVariables(const reco::Track& track,
1266  const Trajectory& traj,
1267  const reco::BeamSpot& beamSpot) {
1268  const math::XYZPoint beamPoint(beamSpot.x0(), beamSpot.y0(), beamSpot.z0());
1269  double d0BeamspotErr =
1270  std::sqrt(track.d0Error() * track.d0Error() + 0.5 * beamSpot.BeamWidthX() * beamSpot.BeamWidthX() +
1271  0.5 * beamSpot.BeamWidthY() * beamSpot.BeamWidthY());
1272 
1273  const static TrajectoryStateCombiner tsoscomb;
1274 
1275  const reco::HitPattern& hitPattern(track.hitPattern());
1276 
1277  TrackStruct::TrackParameterStruct trkParams;
1278 
1279  trkParams.hitsSize = track.recHitsSize();
1280  trkParams.hitsValid = track.found(); // invalid is every hit from every single module that expects a hit
1281  trkParams.hitsInvalid = trkParams.hitsSize - trkParams.hitsValid;
1282  trkParams.layersMissed =
1283  track.lost(); // lost hit means, that a crossed layer doesn't contain a hit (can be more than one invalid hit)
1284  trkParams.hitsPixel = hitPattern.numberOfValidPixelHits();
1285  trkParams.hitsStrip = hitPattern.numberOfValidStripHits();
1286  trkParams.charge = track.charge();
1287  trkParams.chi2 = track.chi2();
1288  trkParams.ndof = track.ndof();
1289  trkParams.norChi2 = trkParams.chi2 / trkParams.ndof;
1290  trkParams.prob = TMath::Prob(trkParams.chi2, trkParams.ndof);
1291  trkParams.eta = track.eta();
1292  trkParams.etaErr = track.etaError();
1293  trkParams.theta = track.theta();
1294  trkParams.phi = track.phi();
1295  trkParams.phiErr = track.phiError();
1296  trkParams.d0 = track.d0();
1297  trkParams.d0Beamspot = -1. * track.dxy(beamPoint);
1298  trkParams.d0BeamspotErr = d0BeamspotErr;
1299  trkParams.dz = track.dz();
1300  trkParams.dzErr = track.dzError();
1301  trkParams.dzBeamspot = track.dz(beamPoint);
1302  trkParams.p = track.p();
1303  trkParams.pt = track.pt();
1304  trkParams.ptErr = track.ptError();
1305 
1306  const std::vector<TrajectoryMeasurement>& v_meas = traj.measurements();
1307 
1308  int count2D(0);
1309  float meanPhiSensToNorm(0.F);
1310  for (auto const& i_meas : v_meas) {
1311  const TrajectoryMeasurement& meas = i_meas;
1312  const TransientTrackingRecHit& hit = *meas.recHit();
1313  const TrackingRecHit& recHit = *hit.hit();
1314  if (this->isHit2D(recHit))
1315  ++count2D;
1316 
1317  TrajectoryStateOnSurface tsos = tsoscomb(meas.forwardPredictedState(), meas.backwardPredictedState());
1318  const align::LocalVector mom(tsos.localDirection());
1319  meanPhiSensToNorm += atan(fabs(sqrt(mom.x() * mom.x() + mom.y() * mom.y()) / mom.z()));
1320  }
1321  meanPhiSensToNorm *= (1. / static_cast<float>(trkParams.hitsSize));
1322 
1323  trkParams.hits2D = count2D;
1324  trkParams.meanPhiSensToNorm = meanPhiSensToNorm;
1325 
1326  if (parameterSet_.getParameter<bool>("applyTrackCuts")) {
1327  trackCut_ = false;
1328  if (trkParams.hitsStrip < 11 || trkParams.hits2D < 2 || trkParams.hitsPixel < 2 || //trkParams.hitsInvalid>2 ||
1329  trkParams.hitsStrip > 35 || trkParams.hitsPixel > 7 || trkParams.norChi2 > 5. || trkParams.pt < 25. ||
1330  trkParams.pt > 150. || std::abs(trkParams.d0Beamspot) > 0.02 || std::abs(trkParams.dz) > 15.)
1331  trackCut_ = true;
1332  } else {
1333  trackCut_ = false;
1334  }
1335 
1336  return trkParams;
1337 }
1338 
1339 TrackStruct::HitParameterStruct ApeEstimator::fillHitVariables(const TrajectoryMeasurement& i_meas,
1340  const edm::EventSetup& iSetup) {
1341  TrackStruct::HitParameterStruct hitParams;
1342 
1343  const static TrajectoryStateCombiner tsoscomb;
1344 
1345  const TrajectoryMeasurement& meas = i_meas;
1346  const TransientTrackingRecHit& hit = *meas.recHit();
1347  const TrackingRecHit& recHit = *hit.hit();
1348  const TrajectoryStateOnSurface& tsos = tsoscomb(meas.forwardPredictedState(), meas.backwardPredictedState());
1349 
1350  const DetId& detId(hit.geographicalId());
1351  const DetId::Detector& detector = detId.det();
1352  if (detector != DetId::Tracker) {
1353  hitParams.hitState = TrackStruct::notInTracker;
1354  return hitParams;
1355  }
1356  const uint32_t rawId(detId.rawId());
1357 
1358  for (auto& i_sector : m_tkSector_) {
1359  for (auto const& i_rawId : i_sector.second.v_rawId) {
1360  if (rawId == i_rawId) {
1361  hitParams.v_sector.push_back(i_sector.first);
1362  break;
1363  }
1364  }
1365  }
1366 
1367  const align::LocalVector& mom(tsos.localDirection());
1368  int xMomentum(0), yMomentum(0), zMomentum(0);
1369  xMomentum = mom.x() > 0. ? 1 : -1;
1370  yMomentum = mom.y() > 0. ? 1 : -1;
1371  zMomentum = mom.z() > 0. ? 1 : -1;
1372  float phiSensX =
1373  std::atan(std::fabs(mom.x() / mom.z())) *
1374  static_cast<float>(
1375  m_tkTreeVar_[rawId].vDirection); // check for orientation of E- and B- Field (thoughts for barrel)
1376  float phiSensY = std::atan(std::fabs(mom.y() / mom.z())) * static_cast<float>(m_tkTreeVar_[rawId].vDirection);
1377  hitParams.phiSens = std::atan(std::fabs(std::sqrt(mom.x() * mom.x() + mom.y() * mom.y()) / mom.z()));
1378  hitParams.phiSensX = (xMomentum == zMomentum ? phiSensX : -phiSensX);
1379  hitParams.phiSensY = (yMomentum == zMomentum ? phiSensY : -phiSensY);
1380 
1381  if (!hit.isValid()) {
1382  hitParams.hitState = TrackStruct::invalid;
1383  return hitParams;
1384  }
1385 
1386  // Get local positions and errors of hit and track
1387  const LocalPoint& lPHit = hit.localPosition();
1388  const LocalPoint& lPTrk = tsos.localPosition();
1389 
1390  // use APE also for the hit error, while APE is automatically included in tsos error
1391  //
1392  // no need to add APE to hitError anymore by Ajay 27 Oct 2014
1393  const LocalError& errHitApe = hit.localPositionError(); // now sum of CPE+APE as said by MARCO?
1394  LocalError errorWithoutAPE;
1395 
1396  bool Pixel(false);
1397  bool Strip(false);
1398 
1399  if (m_tkTreeVar_[rawId].subdetId == PixelSubdetector::PixelBarrel ||
1400  m_tkTreeVar_[rawId].subdetId == PixelSubdetector::PixelEndcap) {
1401  Pixel = true;
1402  } else if (m_tkTreeVar_[rawId].subdetId == StripSubdetector::TIB ||
1403  m_tkTreeVar_[rawId].subdetId == StripSubdetector::TOB ||
1404  m_tkTreeVar_[rawId].subdetId == StripSubdetector::TID ||
1405  m_tkTreeVar_[rawId].subdetId == StripSubdetector::TEC) {
1406  Strip = true;
1407  } else {
1408  edm::LogWarning("FillHitVariables") << "cant identify wether hit is from pixel or strip";
1409  hitParams.hitState = TrackStruct::invalid;
1410  return hitParams;
1411  }
1412 
1413  if (!hit.detUnit()) {
1414  hitParams.hitState = TrackStruct::invalid;
1415  return hitParams;
1416  } // is it a single physical module?
1417  const GeomDetUnit& detUnit = *hit.detUnit();
1418 
1419  if (Pixel) {
1420  if (!dynamic_cast<const PixelTopology*>(&detUnit.type().topology())) {
1421  hitParams.hitState = TrackStruct::invalid;
1422  return hitParams;
1423  }
1424  const PixelGeomDetUnit* pixelDet = (const PixelGeomDetUnit*)(&detUnit);
1425  const LocalError& lape = pixelDet->localAlignmentError();
1426  if (lape.valid()) {
1427  errorWithoutAPE = LocalError(errHitApe.xx() - lape.xx(), errHitApe.xy() - lape.xy(), errHitApe.yy() - lape.yy());
1428  }
1429  }
1430  if (Strip) {
1431  if (!dynamic_cast<const StripTopology*>(&detUnit.type().topology())) {
1432  hitParams.hitState = TrackStruct::invalid;
1433  return hitParams;
1434  }
1435  const StripGeomDetUnit* stripDet = (const StripGeomDetUnit*)(&detUnit);
1436  const LocalError& lape = stripDet->localAlignmentError();
1437  if (lape.valid()) {
1438  errorWithoutAPE = LocalError(errHitApe.xx() - lape.xx(), errHitApe.xy() - lape.xy(), errHitApe.yy() - lape.yy());
1439  }
1440  }
1441 
1442  const LocalError& errHitWoApe = errorWithoutAPE;
1443  const LocalError& errTrk = tsos.localError().positionError();
1444 
1445  const StatePositionAndError2 positionAndError2Hit = this->positionAndError2(lPHit, errHitApe, hit);
1446  const StatePositionAndError2 positionAndError2HitWoApe = this->positionAndError2(lPHit, errHitWoApe, hit);
1447  edm::LogInfo("CalculateAPE") << "errHitWoApe " << errHitWoApe << "errHitApe " << errHitApe;
1448 
1449  const StatePositionAndError2 positionAndError2Trk = this->positionAndError2(lPTrk, errTrk, hit);
1450 
1451  const TrackStruct::HitState& stateHit(positionAndError2Hit.first);
1452  const TrackStruct::HitState& stateHitWoApe(positionAndError2HitWoApe.first);
1453  const TrackStruct::HitState& stateTrk(positionAndError2Trk.first);
1454 
1455  if (stateHit == TrackStruct::invalid || stateHitWoApe == TrackStruct::invalid || stateTrk == TrackStruct::invalid) {
1456  hitParams.hitState = TrackStruct::invalid;
1457  return hitParams;
1458  } else if (stateHit == TrackStruct::negativeError || stateHitWoApe == TrackStruct::negativeError ||
1459  stateTrk == TrackStruct::negativeError) {
1460  ++counter1;
1461  // Do not print error message by default
1462  //std::stringstream ss_error;
1463  //ss_error<<"Upper values belong to: ";
1464  //if(stateHit==TrackStruct::negativeError)ss_error<<"Hit without APE, ";
1465  //if(stateHitWoApe==TrackStruct::negativeError)ss_error<<"Hit with APE, ";
1466  //if(stateTrk==TrackStruct::negativeError)ss_error<<"Track,";
1467  //edm::LogError("Negative error Value")<<"@SUB=ApeEstimator::fillHitVariables"<<ss_error.str();
1468  hitParams.hitState = TrackStruct::negativeError;
1469  return hitParams;
1470  }
1471 
1472  // Calculate residuals
1473 
1474  const float xHit = positionAndError2Hit.second.posX;
1475  const float xTrk = positionAndError2Trk.second.posX;
1476  const float yHit = positionAndError2Hit.second.posY;
1477  const float yTrk = positionAndError2Trk.second.posY;
1478 
1479  const float errXHit2(positionAndError2Hit.second.errX2);
1480  const float errXHitWoApe2(positionAndError2HitWoApe.second.errX2);
1481  const float errXTrk2(positionAndError2Trk.second.errX2);
1482  const float errYHit2(positionAndError2Hit.second.errY2);
1483  const float errYHitWoApe2(positionAndError2HitWoApe.second.errY2);
1484  const float errYTrk2(positionAndError2Trk.second.errY2);
1485 
1486  const float errXHit = std::sqrt(positionAndError2Hit.second.errX2);
1487  const float errXHitWoApe = std::sqrt(positionAndError2HitWoApe.second.errX2);
1488  const float errXTrk = std::sqrt(positionAndError2Trk.second.errX2);
1489  const float errYHit = std::sqrt(positionAndError2Hit.second.errY2);
1490  const float errYHitWoApe = std::sqrt(positionAndError2HitWoApe.second.errY2);
1491  const float errYTrk = std::sqrt(positionAndError2Trk.second.errY2);
1492 
1493  const float resX = xTrk - xHit;
1494  const float resY = yTrk - yHit;
1495 
1496  const float errX = std::sqrt(errXHit2 + errXTrk2);
1497  const float errXWoApe2 = errXHitWoApe2 + errXTrk2;
1498  const float errXWoApe = std::sqrt(errXWoApe2);
1499  const float errY = std::sqrt(errYHit2 + errYTrk2);
1500  const float errYWoApe2 = errYHitWoApe2 + errYTrk2;
1501  const float errYWoApe = std::sqrt(errYWoApe2);
1502 
1503  const float norResX = resX / errX;
1504  const float norResY = resY / errY;
1505 
1506  // Take global orientation into account for residuals (sign is not important for errors)
1507 
1508  float resXprime(999.F), resYprime(999.F), norResXprime(999.F), norResYprime(999.F);
1509  if (m_tkTreeVar_[rawId].uDirection == 1) {
1510  resXprime = resX;
1511  norResXprime = norResX;
1512  } else if (m_tkTreeVar_[rawId].uDirection == -1) {
1513  resXprime = -resX;
1514  norResXprime = -norResX;
1515  } else {
1516  edm::LogError("FillHitVariables") << "Incorrect value of uDirection, which gives global module orientation";
1517  hitParams.hitState = TrackStruct::invalid;
1518  return hitParams;
1519  }
1520  if (m_tkTreeVar_[rawId].vDirection == 1) {
1521  resYprime = resY;
1522  norResYprime = norResY;
1523  } else if (m_tkTreeVar_[rawId].vDirection == -1) {
1524  resYprime = -resY;
1525  norResYprime = -norResY;
1526  } else {
1527  edm::LogError("FillHitVariables") << "Incorrect value of vDirection, which gives global module orientation";
1528  hitParams.hitState = TrackStruct::invalid;
1529  return hitParams;
1530  }
1531 
1532  hitParams.xHit = xHit;
1533  hitParams.xTrk = xTrk;
1534 
1535  hitParams.errXHit = errXHit;
1536  hitParams.errXHitWoApe = errXHitWoApe;
1537  hitParams.errXTrk = errXTrk;
1538 
1539  hitParams.errX2 = errX * errX;
1540  hitParams.errX = errX;
1541  hitParams.errXWoApe = errXWoApe;
1542 
1543  hitParams.resX = resXprime;
1544  hitParams.norResX = norResXprime;
1545 
1546  const float norResX2(norResXprime * norResXprime);
1547  hitParams.probX = TMath::Prob(norResX2, 1);
1548 
1549  hitParams.yHit = yHit;
1550  hitParams.yTrk = yTrk;
1551 
1552  hitParams.errYHit = errYHit;
1553  hitParams.errYHitWoApe = errYHitWoApe;
1554  hitParams.errYTrk = errYTrk;
1555 
1556  hitParams.errY2 = errY * errY;
1557  hitParams.errY = errY;
1558  hitParams.errYWoApe = errYWoApe;
1559 
1560  hitParams.resY = resYprime;
1561  hitParams.norResY = norResYprime;
1562 
1563  const float norResY2(norResYprime * norResYprime);
1564  hitParams.probY = TMath::Prob(norResY2, 1);
1565 
1566  // Cluster parameters
1567 
1568  if (m_tkTreeVar_[rawId].subdetId == PixelSubdetector::PixelBarrel ||
1569  m_tkTreeVar_[rawId].subdetId == PixelSubdetector::PixelEndcap) {
1570  const SiPixelRecHit& pixelHit = dynamic_cast<const SiPixelRecHit&>(recHit);
1571  const SiPixelCluster& pixelCluster = *pixelHit.cluster();
1572 
1573  hitParams.chargePixel = pixelCluster.charge();
1574  hitParams.widthX = pixelCluster.sizeX();
1575  hitParams.baryStripX = pixelCluster.x();
1576  hitParams.widthY = pixelCluster.sizeY();
1577  hitParams.baryStripY = pixelCluster.y();
1578 
1579  hitParams.clusterProbabilityXY = pixelHit.clusterProbability(0);
1580  hitParams.clusterProbabilityQ = pixelHit.clusterProbability(2);
1581  hitParams.clusterProbabilityXYQ = pixelHit.clusterProbability(1);
1582  hitParams.logClusterProbability = std::log10(hitParams.clusterProbabilityXY);
1583 
1584  hitParams.isOnEdge = pixelHit.isOnEdge();
1585  hitParams.hasBadPixels = pixelHit.hasBadPixels();
1586  hitParams.spansTwoRoc = pixelHit.spansTwoROCs();
1587  hitParams.qBin = pixelHit.qBin();
1588 
1589  hitParams.isPixelHit = true;
1590  } else if (m_tkTreeVar_[rawId].subdetId == StripSubdetector::TIB ||
1591  m_tkTreeVar_[rawId].subdetId == StripSubdetector::TOB ||
1592  m_tkTreeVar_[rawId].subdetId == StripSubdetector::TID ||
1593  m_tkTreeVar_[rawId].subdetId == StripSubdetector::TEC) {
1594  if (!(dynamic_cast<const SiStripRecHit2D*>(&recHit) || dynamic_cast<const SiStripRecHit1D*>(&recHit))) {
1595  edm::LogError("FillHitVariables")
1596  << "RecHit in Strip is 'Matched' or 'Projected', but here all should be monohits per module";
1597  hitParams.hitState = TrackStruct::invalid;
1598  return hitParams;
1599  }
1600  const SiStripCluster* clusterPtr(nullptr);
1601  if (m_tkTreeVar_[rawId].subdetId == StripSubdetector::TIB ||
1602  m_tkTreeVar_[rawId].subdetId == StripSubdetector::TOB) {
1603  if (dynamic_cast<const SiStripRecHit1D*>(&recHit)) {
1604  const SiStripRecHit1D& stripHit = dynamic_cast<const SiStripRecHit1D&>(recHit);
1605  clusterPtr = &(*stripHit.cluster());
1606  } else if (dynamic_cast<const SiStripRecHit2D*>(&recHit)) {
1607  edm::LogWarning("FillHitVariables") << "Data has TIB/TOB hits as SiStripRecHit2D and not 1D. Probably data is "
1608  "processed with CMSSW<34X. Nevertheless everything should work fine";
1609  const SiStripRecHit2D& stripHit = dynamic_cast<const SiStripRecHit2D&>(recHit);
1610  clusterPtr = &(*stripHit.cluster());
1611  }
1612  } else if (m_tkTreeVar_[rawId].subdetId == StripSubdetector::TID ||
1613  m_tkTreeVar_[rawId].subdetId == StripSubdetector::TEC) {
1614  const SiStripRecHit2D& stripHit = dynamic_cast<const SiStripRecHit2D&>(recHit);
1615  clusterPtr = &(*stripHit.cluster());
1616  }
1617  if (!clusterPtr) {
1618  edm::LogError("FillHitVariables") << "Pointer to cluster not valid!!! This should never happen...";
1619  hitParams.hitState = TrackStruct::invalid;
1620  return hitParams;
1621  }
1622  const SiStripCluster& stripCluster(*clusterPtr);
1623 
1624  siStripClusterInfo_.setCluster(stripCluster, rawId);
1625 
1626  const std::vector<uint8_t>::const_iterator stripChargeL(siStripClusterInfo_.stripCharges().begin());
1627  const std::vector<uint8_t>::const_iterator stripChargeR(--(siStripClusterInfo_.stripCharges().end()));
1628  const std::pair<uint16_t, uint16_t> stripChargeLR = std::make_pair(*stripChargeL, *stripChargeR);
1629 
1630  hitParams.chargeStrip = siStripClusterInfo_.charge();
1631  hitParams.widthX = siStripClusterInfo_.width();
1632  hitParams.baryStripX = siStripClusterInfo_.baryStrip() + 1.;
1633  hitParams.isModuleUsable = siStripClusterInfo_.IsModuleUsable();
1634  hitParams.maxStrip = siStripClusterInfo_.maxStrip() + 1;
1635  hitParams.maxStripInv = m_tkTreeVar_[rawId].nStrips - hitParams.maxStrip + 1;
1636  hitParams.maxCharge = siStripClusterInfo_.maxCharge();
1637  hitParams.maxIndex = siStripClusterInfo_.maxIndex();
1638  hitParams.chargeOnEdges =
1639  static_cast<float>(stripChargeLR.first + stripChargeLR.second) / static_cast<float>(hitParams.chargeStrip);
1640  hitParams.chargeAsymmetry = static_cast<float>(stripChargeLR.first - stripChargeLR.second) /
1641  static_cast<float>(stripChargeLR.first + stripChargeLR.second);
1642  hitParams.chargeLRplus =
1643  static_cast<float>(siStripClusterInfo_.chargeLR().first + siStripClusterInfo_.chargeLR().second) /
1644  static_cast<float>(hitParams.chargeStrip);
1645  hitParams.chargeLRminus =
1646  static_cast<float>(siStripClusterInfo_.chargeLR().first - siStripClusterInfo_.chargeLR().second) /
1647  static_cast<float>(hitParams.chargeStrip);
1648  hitParams.sOverN = siStripClusterInfo_.signalOverNoise();
1649 
1650  // Calculate projection length corrected by drift
1651  if (!hit.detUnit()) {
1652  hitParams.hitState = TrackStruct::invalid;
1653  return hitParams;
1654  } // is it a single physical module?
1655  const GeomDetUnit& detUnit = *hit.detUnit();
1656  if (!dynamic_cast<const StripTopology*>(&detUnit.type().topology())) {
1657  hitParams.hitState = TrackStruct::invalid;
1658  return hitParams;
1659  }
1660 
1661  edm::ESHandle<MagneticField> magFieldHandle;
1662  iSetup.get<IdealMagneticFieldRecord>().get(magFieldHandle);
1663 
1664  edm::ESHandle<SiStripLorentzAngle> lorentzAngleHandle;
1665  iSetup.get<SiStripLorentzAngleDepRcd>().get(lorentzAngleHandle); //MODIFIED BY LOIC QUERTENMONT
1666 
1667  const StripGeomDetUnit* stripDet = (const StripGeomDetUnit*)(&detUnit);
1668  const MagneticField* magField(magFieldHandle.product());
1669  LocalVector bField = (stripDet->surface()).toLocal(magField->inTesla(stripDet->surface().position()));
1670  const SiStripLorentzAngle* lorentzAngle(lorentzAngleHandle.product());
1671  float tanLorentzAnglePerTesla = lorentzAngle->getLorentzAngle(stripDet->geographicalId().rawId());
1672 
1673  float dirX = -tanLorentzAnglePerTesla * bField.y();
1674  float dirY = tanLorentzAnglePerTesla * bField.x();
1675  float dirZ = 1.; // E field always in z direction
1676  LocalVector driftDirection(dirX, dirY, dirZ);
1677 
1678  const Bounds& bounds = stripDet->specificSurface().bounds();
1679  float maxLength = std::sqrt(std::pow(bounds.length(), 2) + std::pow(bounds.width(), 2));
1680  float thickness = bounds.thickness();
1681 
1682  const StripTopology& topol = dynamic_cast<const StripTopology&>(detUnit.type().topology());
1683  LocalVector momentumDir(tsos.localDirection());
1684  LocalPoint momentumPos(tsos.localPosition());
1685  LocalVector scaledMomentumDir(momentumDir);
1686  if (momentumDir.z() > 0.)
1687  scaledMomentumDir *= std::fabs(thickness / momentumDir.z());
1688  else if (momentumDir.z() < 0.)
1689  scaledMomentumDir *= -std::fabs(thickness / momentumDir.z());
1690  else
1691  scaledMomentumDir *= maxLength / momentumDir.mag();
1692 
1693  float projEdge1 = topol.measurementPosition(momentumPos - 0.5 * scaledMomentumDir).x();
1694  if (projEdge1 < 0.)
1695  projEdge1 = 0.;
1696  else if (projEdge1 > m_tkTreeVar_[rawId].nStrips)
1697  projEdge1 = m_tkTreeVar_[rawId].nStrips;
1698  float projEdge2 = topol.measurementPosition(momentumPos + 0.5 * scaledMomentumDir).x();
1699  if (projEdge2 < 0.)
1700  projEdge1 = 0.;
1701  else if (projEdge2 > m_tkTreeVar_[rawId].nStrips)
1702  projEdge1 = m_tkTreeVar_[rawId].nStrips;
1703 
1704  float coveredStrips = std::fabs(projEdge2 - projEdge1);
1705 
1706  hitParams.projWidth = coveredStrips;
1707 
1708  } else {
1709  edm::LogError("FillHitVariables") << "Incorrect subdetector ID, hit not associated to tracker";
1710  hitParams.hitState = TrackStruct::notInTracker;
1711  return hitParams;
1712  }
1713 
1714  if (!hitParams.isModuleUsable) {
1715  hitParams.hitState = TrackStruct::invalid;
1716  return hitParams;
1717  }
1718 
1719  if (hitParams.v_sector.empty()) {
1720  hitParams.hitState = TrackStruct::notAssignedToSectors;
1721  return hitParams;
1722  }
1723 
1724  return hitParams;
1725  //}
1726 }
1727 
1728 ApeEstimator::StatePositionAndError2 ApeEstimator::positionAndError2(const LocalPoint& localPoint,
1729  const LocalError& localError,
1730  const TransientTrackingRecHit& hit) {
1731  StatePositionAndError2 vPE2 = std::make_pair(TrackStruct::invalid, PositionAndError2());
1732 
1733  const DetId& detId(hit.geographicalId());
1734  const uint32_t& rawId(detId.rawId());
1735  const unsigned int& subdetId(m_tkTreeVar_[rawId].subdetId);
1736 
1737  if (localError.xx() < 0. || localError.yy() < 0.) {
1738  // Do not print error message by default
1739  //edm::LogError("Negative error Value")<<"@SUB=ApeEstimator::fillHitVariables"
1740  // <<"One of the squared error methods gives negative result\n"
1741  // <<"\tSubdetector\tlocalError.xx()\tlocalError.yy()\n"
1742  // <<"\t"<<subdetId<<"\t\t"<<localError.xx()<<"\t"<<localError.yy();
1743  vPE2.first = TrackStruct::negativeError;
1744  return vPE2;
1745  }
1746 
1747  if (subdetId == PixelSubdetector::PixelBarrel || subdetId == PixelSubdetector::PixelEndcap ||
1748  subdetId == StripSubdetector::TIB || subdetId == StripSubdetector::TOB) {
1749  // Cartesian coordinates
1750  vPE2 = std::make_pair(TrackStruct::ok, this->rectangularPositionAndError2(localPoint, localError));
1751  } else if (subdetId == StripSubdetector::TID || subdetId == StripSubdetector::TEC) {
1752  // Local x in radial coordinates
1753  if (!hit.detUnit())
1754  return vPE2; // is it a single physical module?
1755  const GeomDetUnit& detUnit = *hit.detUnit();
1756 
1757  if (!dynamic_cast<const RadialStripTopology*>(&detUnit.type().topology()))
1758  return vPE2;
1759  const RadialStripTopology& topol = dynamic_cast<const RadialStripTopology&>(detUnit.type().topology());
1760 
1761  MeasurementError measError = topol.measurementError(localPoint, localError);
1762  if (measError.uu() < 0. || measError.vv() < 0.) {
1763  // Do not print error message by default
1764  //edm::LogError("Negative error Value")<<"@SUB=ApeEstimator::fillHitVariables"
1765  // <<"One of the squared error methods gives negative result\n"
1766  // <<"\tmeasError.uu()\tmeasError.vv()\n"
1767  // <<"\t"<<measError.uu()<<"\t"<<measError.vv()
1768  // <<"\n\nOriginalValues:\n"
1769  // <<localPoint.x()<<" "<<localPoint.y()<<"\n"
1770  // <<localError.xx()<<" "<<localError.yy()<<"\n"
1771  // <<"Subdet: "<<subdetId;
1772  vPE2.first = TrackStruct::negativeError;
1773  return vPE2;
1774  }
1775  vPE2 = std::make_pair(TrackStruct::ok, this->radialPositionAndError2(localPoint, localError, topol));
1776  } else {
1777  edm::LogError("FillHitVariables") << "Incorrect subdetector ID, hit not associated to tracker";
1778  }
1779 
1780  return vPE2;
1781 }
1782 
1783 ApeEstimator::PositionAndError2 ApeEstimator::rectangularPositionAndError2(const LocalPoint& lP, const LocalError& lE) {
1784  const float x(lP.x());
1785  const float y(lP.y());
1786  const float errX2(lE.xx());
1787  const float errY2(lE.yy());
1788 
1789  return PositionAndError2(x, y, errX2, errY2);
1790 }
1791 
1792 ApeEstimator::PositionAndError2 ApeEstimator::radialPositionAndError2(const LocalPoint& lP,
1793  const LocalError& lE,
1794  const RadialStripTopology& topol) {
1795  MeasurementPoint measPos = topol.measurementPosition(lP);
1796  MeasurementError measErr = topol.measurementError(lP, lE);
1797 
1798  const float r_0 = topol.originToIntersection();
1799  const float stripLength = topol.localStripLength(lP);
1800  const float phi = topol.stripAngle(measPos.x());
1801 
1802  float x(-999.F);
1803  float y(-999.F);
1804  float errX2(-999.F);
1805  float errY2(-999.F);
1806 
1807  x = phi * r_0;
1808  // Radial y (not symmetric around 0; radial distance with minimum at middle strip at lower edge [0, yMax])
1809  const float l_0 = r_0 - topol.detHeight() / 2;
1810  const float cosPhi(std::cos(phi));
1811  y = measPos.y() * stripLength - 0.5 * stripLength + l_0 * (1. / cosPhi - 1.);
1812 
1813  const float angularWidth2(topol.angularWidth() * topol.angularWidth());
1814  const float errPhi2(measErr.uu() * angularWidth2);
1815 
1816  errX2 = errPhi2 * r_0 * r_0;
1817  // Radial y (not symmetric around 0, real radial distance from intersection point)
1818  const float cosPhi4(std::pow(cosPhi, 4)), sinPhi2(std::sin(phi) * std::sin(phi));
1819  const float helpSummand = l_0 * l_0 * (sinPhi2 / cosPhi4 * errPhi2);
1820  errY2 = measErr.vv() * stripLength * stripLength + helpSummand;
1821 
1822  return PositionAndError2(x, y, errX2, errY2);
1823 }
1824 
1825 // -----------------------------------------------------------------------------------------------------------
1826 
1827 void ApeEstimator::hitSelection() {
1828  this->setHitSelectionMapUInt("width");
1829  this->setHitSelectionMap("widthProj");
1830  this->setHitSelectionMap("widthDiff");
1831  this->setHitSelectionMap("charge");
1832  this->setHitSelectionMapUInt("edgeStrips");
1833  this->setHitSelectionMap("maxCharge");
1834  this->setHitSelectionMapUInt("maxIndex");
1835  this->setHitSelectionMap("chargeOnEdges");
1836  this->setHitSelectionMap("chargeAsymmetry");
1837  this->setHitSelectionMap("chargeLRplus");
1838  this->setHitSelectionMap("chargeLRminus");
1839  this->setHitSelectionMap("sOverN");
1840 
1841  this->setHitSelectionMap("chargePixel");
1842  this->setHitSelectionMapUInt("widthX");
1843  this->setHitSelectionMapUInt("widthY");
1844 
1845  this->setHitSelectionMap("baryStripX");
1846  this->setHitSelectionMap("baryStripY");
1847  this->setHitSelectionMap("clusterProbabilityXY");
1848  this->setHitSelectionMap("clusterProbabilityQ");
1849  this->setHitSelectionMap("clusterProbabilityXYQ");
1850  this->setHitSelectionMap("logClusterProbability");
1851  this->setHitSelectionMapUInt("isOnEdge");
1852  this->setHitSelectionMapUInt("hasBadPixels");
1853  this->setHitSelectionMapUInt("spansTwoRoc");
1854  this->setHitSelectionMapUInt("qBin");
1855 
1856  this->setHitSelectionMap("phiSens");
1857  this->setHitSelectionMap("phiSensX");
1858  this->setHitSelectionMap("phiSensY");
1859  this->setHitSelectionMap("resX");
1860  this->setHitSelectionMap("norResX");
1861  this->setHitSelectionMap("probX");
1862  this->setHitSelectionMap("errXHit");
1863  this->setHitSelectionMap("errXTrk");
1864  this->setHitSelectionMap("errX");
1865  this->setHitSelectionMap("errX2");
1866 
1867  this->setHitSelectionMap("resY");
1868  this->setHitSelectionMap("norResY");
1869  this->setHitSelectionMap("probY");
1870  this->setHitSelectionMap("errYHit");
1871  this->setHitSelectionMap("errYTrk");
1872  this->setHitSelectionMap("errY");
1873  this->setHitSelectionMap("errY2");
1874 
1875  edm::LogInfo("HitSelector") << "applying hit cuts ...";
1876  bool emptyMap(true);
1877  for (auto& i_hitSelection : m_hitSelection_) {
1878  if (!i_hitSelection.second.empty()) {
1879  int entry(1);
1880  double intervalBegin(999.);
1881  for (std::vector<double>::iterator i_hitInterval = i_hitSelection.second.begin();
1882  i_hitInterval != i_hitSelection.second.end();
1883  ++entry) {
1884  if (entry % 2 == 1) {
1885  intervalBegin = *i_hitInterval;
1886  ++i_hitInterval;
1887  } else {
1888  if (intervalBegin > *i_hitInterval) {
1889  edm::LogError("HitSelector") << "INVALID Interval selected for " << i_hitSelection.first << ":\t"
1890  << intervalBegin << " > " << (*i_hitInterval) << "\n ... delete Selection for "
1891  << i_hitSelection.first;
1892  i_hitSelection.second.clear();
1893  i_hitInterval = i_hitSelection.second.begin(); //emptyMap = true; i_hitSelection = m_hitSelection_.begin();
1894  } else {
1895  edm::LogInfo("HitSelector") << "Interval selected for " << i_hitSelection.first << ":\t" << intervalBegin
1896  << ", " << (*i_hitInterval);
1897  ++i_hitInterval;
1898  }
1899  }
1900  }
1901  if (!i_hitSelection.second.empty())
1902  emptyMap = false;
1903  }
1904  }
1905 
1906  bool emptyMapUInt(true);
1907  for (auto& i_hitSelection : m_hitSelectionUInt_) {
1908  if (!i_hitSelection.second.empty()) {
1909  int entry(1);
1910  unsigned int intervalBegin(999);
1911  for (std::vector<unsigned int>::iterator i_hitInterval = i_hitSelection.second.begin();
1912  i_hitInterval != i_hitSelection.second.end();
1913  ++entry) {
1914  if (entry % 2 == 1) {
1915  intervalBegin = *i_hitInterval;
1916  ++i_hitInterval;
1917  } else {
1918  if (intervalBegin > *i_hitInterval) {
1919  edm::LogError("HitSelector") << "INVALID Interval selected for " << i_hitSelection.first << ":\t"
1920  << intervalBegin << " > " << (*i_hitInterval) << "\n ... delete Selection for "
1921  << i_hitSelection.first;
1922  i_hitSelection.second.clear();
1923  i_hitInterval = i_hitSelection.second.begin(); //emptyMap = true; i_hitSelection = m_hitSelection_.begin();
1924  } else {
1925  edm::LogInfo("HitSelector") << "Interval selected for " << i_hitSelection.first << ":\t" << intervalBegin
1926  << ", " << (*i_hitInterval);
1927  ++i_hitInterval;
1928  }
1929  }
1930  }
1931  if (!i_hitSelection.second.empty())
1932  emptyMapUInt = false;
1933  }
1934  }
1935 
1936  if (emptyMap && emptyMapUInt) {
1937  m_hitSelection_.clear();
1938  m_hitSelectionUInt_.clear();
1939  edm::LogInfo("HitSelector") << "NO hit cuts applied";
1940  }
1941  return;
1942 }
1943 
1944 void ApeEstimator::setHitSelectionMap(const std::string& cutVariable) {
1945  edm::ParameterSet parSet(parameterSet_.getParameter<edm::ParameterSet>("HitSelector"));
1946  std::vector<double> v_cutVariable(parSet.getParameter<std::vector<double> >(cutVariable));
1947  if (v_cutVariable.size() % 2 == 1) {
1948  edm::LogError("HitSelector") << "Invalid Hit Selection for " << cutVariable
1949  << ": need even number of arguments (intervals)"
1950  << "\n ... delete Selection for " << cutVariable;
1951  v_cutVariable.clear();
1952  m_hitSelection_[cutVariable] = v_cutVariable;
1953  return;
1954  }
1955  m_hitSelection_[cutVariable] = v_cutVariable;
1956  return;
1957 }
1958 
1959 void ApeEstimator::setHitSelectionMapUInt(const std::string& cutVariable) {
1960  edm::ParameterSet parSet(parameterSet_.getParameter<edm::ParameterSet>("HitSelector"));
1961  std::vector<unsigned int> v_cutVariable(parSet.getParameter<std::vector<unsigned int> >(cutVariable));
1962  if (v_cutVariable.size() % 2 == 1) {
1963  edm::LogError("HitSelector") << "Invalid Hit Selection for " << cutVariable
1964  << ": need even number of arguments (intervals)"
1965  << "\n ... delete Selection for " << cutVariable;
1966  v_cutVariable.clear();
1967  m_hitSelectionUInt_[cutVariable] = v_cutVariable;
1968  return;
1969  }
1970  m_hitSelectionUInt_[cutVariable] = v_cutVariable;
1971  return;
1972 }
1973 
1974 // -----------------------------------------------------------------------------------------------------------
1975 
1976 bool ApeEstimator::hitSelected(TrackStruct::HitParameterStruct& hitParams) const {
1977  if (hitParams.hitState == TrackStruct::notInTracker)
1978  return false;
1979  if (hitParams.hitState == TrackStruct::invalid || hitParams.hitState == TrackStruct::negativeError)
1980  return false;
1981 
1982  bool isGoodHit(true);
1983  bool isGoodHitX(true);
1984  bool isGoodHitY(true);
1985 
1986  for (auto& i_hitSelection : m_hitSelection_) {
1987  const std::string& hitSelection(i_hitSelection.first);
1988  const std::vector<double>& v_hitSelection(i_hitSelection.second);
1989  if (v_hitSelection.empty())
1990  continue;
1991 
1992  // For pixel and strip sectors in common
1993  if (hitSelection == "phiSens") {
1994  if (!this->inDoubleInterval(v_hitSelection, hitParams.phiSens))
1995  isGoodHit = false;
1996  } else if (hitSelection == "phiSensX") {
1997  if (!this->inDoubleInterval(v_hitSelection, hitParams.phiSensX))
1998  isGoodHit = false;
1999  } else if (hitSelection == "phiSensY") {
2000  if (!this->inDoubleInterval(v_hitSelection, hitParams.phiSensY))
2001  isGoodHit = false;
2002  }
2003 
2004  else if (hitSelection == "resX") {
2005  if (!this->inDoubleInterval(v_hitSelection, hitParams.resX))
2006  isGoodHitX = false;
2007  } else if (hitSelection == "norResX") {
2008  if (!this->inDoubleInterval(v_hitSelection, hitParams.norResX))
2009  isGoodHitX = false;
2010  } else if (hitSelection == "probX") {
2011  if (!this->inDoubleInterval(v_hitSelection, hitParams.probX))
2012  isGoodHitX = false;
2013  } else if (hitSelection == "errXHit") {
2014  if (!this->inDoubleInterval(v_hitSelection, hitParams.errXHit))
2015  isGoodHitX = false;
2016  } else if (hitSelection == "errXTrk") {
2017  if (!this->inDoubleInterval(v_hitSelection, hitParams.errXTrk))
2018  isGoodHitX = false;
2019  } else if (hitSelection == "errX") {
2020  if (!this->inDoubleInterval(v_hitSelection, hitParams.errX))
2021  isGoodHitX = false;
2022  } else if (hitSelection == "errX2") {
2023  if (!this->inDoubleInterval(v_hitSelection, hitParams.errX2))
2024  isGoodHitX = false;
2025  }
2026 
2027  // For pixel only
2028  if (hitParams.isPixelHit) {
2029  if (hitSelection == "chargePixel") {
2030  if (!this->inDoubleInterval(v_hitSelection, hitParams.chargePixel))
2031  isGoodHit = false;
2032  } else if (hitSelection == "clusterProbabilityXY") {
2033  if (!this->inDoubleInterval(v_hitSelection, hitParams.clusterProbabilityXY))
2034  isGoodHit = false;
2035  } else if (hitSelection == "clusterProbabilityQ") {
2036  if (!this->inDoubleInterval(v_hitSelection, hitParams.clusterProbabilityQ))
2037  isGoodHit = false;
2038  } else if (hitSelection == "clusterProbabilityXYQ") {
2039  if (!this->inDoubleInterval(v_hitSelection, hitParams.clusterProbabilityXYQ))
2040  isGoodHit = false;
2041  } else if (hitSelection == "logClusterProbability") {
2042  if (!this->inDoubleInterval(v_hitSelection, hitParams.logClusterProbability))
2043  isGoodHit = false;
2044  }
2045 
2046  else if (hitSelection == "baryStripX") {
2047  if (!this->inDoubleInterval(v_hitSelection, hitParams.baryStripX))
2048  isGoodHitX = false;
2049  } else if (hitSelection == "baryStripY") {
2050  if (!this->inDoubleInterval(v_hitSelection, hitParams.baryStripY))
2051  isGoodHitY = false;
2052  }
2053 
2054  else if (hitSelection == "resY") {
2055  if (!this->inDoubleInterval(v_hitSelection, hitParams.resY))
2056  isGoodHitY = false;
2057  } else if (hitSelection == "norResY") {
2058  if (!this->inDoubleInterval(v_hitSelection, hitParams.norResY))
2059  isGoodHitY = false;
2060  } else if (hitSelection == "probY") {
2061  if (!this->inDoubleInterval(v_hitSelection, hitParams.probY))
2062  isGoodHitY = false;
2063  } else if (hitSelection == "errYHit") {
2064  if (!this->inDoubleInterval(v_hitSelection, hitParams.errYHit))
2065  isGoodHitY = false;
2066  } else if (hitSelection == "errYTrk") {
2067  if (!this->inDoubleInterval(v_hitSelection, hitParams.errYTrk))
2068  isGoodHitY = false;
2069  } else if (hitSelection == "errY") {
2070  if (!this->inDoubleInterval(v_hitSelection, hitParams.errY))
2071  isGoodHitY = false;
2072  } else if (hitSelection == "errY2") {
2073  if (!this->inDoubleInterval(v_hitSelection, hitParams.errY2))
2074  isGoodHitY = false;
2075  }
2076  } else { // For strip only
2077  if (hitSelection == "widthProj") {
2078  if (!this->inDoubleInterval(v_hitSelection, hitParams.projWidth))
2079  isGoodHit = false;
2080  } else if (hitSelection == "widthDiff") {
2081  if (!this->inDoubleInterval(v_hitSelection, hitParams.projWidth - static_cast<float>(hitParams.widthX)))
2082  isGoodHit = false;
2083  } else if (hitSelection == "charge") {
2084  if (!this->inDoubleInterval(v_hitSelection, hitParams.chargeStrip))
2085  isGoodHit = false;
2086  } else if (hitSelection == "maxCharge") {
2087  if (!this->inDoubleInterval(v_hitSelection, hitParams.maxCharge))
2088  isGoodHit = false;
2089  } else if (hitSelection == "chargeOnEdges") {
2090  if (!this->inDoubleInterval(v_hitSelection, hitParams.chargeOnEdges))
2091  isGoodHit = false;
2092  } else if (hitSelection == "chargeAsymmetry") {
2093  if (!this->inDoubleInterval(v_hitSelection, hitParams.chargeAsymmetry))
2094  isGoodHit = false;
2095  } else if (hitSelection == "chargeLRplus") {
2096  if (!this->inDoubleInterval(v_hitSelection, hitParams.chargeLRplus))
2097  isGoodHit = false;
2098  } else if (hitSelection == "chargeLRminus") {
2099  if (!this->inDoubleInterval(v_hitSelection, hitParams.chargeLRminus))
2100  isGoodHit = false;
2101  } else if (hitSelection == "sOverN") {
2102  if (!this->inDoubleInterval(v_hitSelection, hitParams.sOverN))
2103  isGoodHit = false;
2104  }
2105  }
2106  }
2107 
2108  for (auto& i_hitSelection : m_hitSelectionUInt_) {
2109  const std::string& hitSelection(i_hitSelection.first);
2110  const std::vector<unsigned int>& v_hitSelection(i_hitSelection.second);
2111  if (v_hitSelection.empty())
2112  continue;
2113 
2114  // For pixel and strip sectors in common
2115 
2116  // For pixel only
2117  if (hitParams.isPixelHit) {
2118  if (hitSelection == "isOnEdge") {
2119  if (!this->inUintInterval(v_hitSelection, hitParams.isOnEdge))
2120  isGoodHit = false;
2121  } else if (hitSelection == "hasBadPixels") {
2122  if (!this->inUintInterval(v_hitSelection, hitParams.hasBadPixels))
2123  isGoodHit = false;
2124  } else if (hitSelection == "spansTwoRoc") {
2125  if (!this->inUintInterval(v_hitSelection, hitParams.spansTwoRoc))
2126  isGoodHit = false;
2127  } else if (hitSelection == "qBin") {
2128  if (!this->inUintInterval(v_hitSelection, hitParams.qBin))
2129  isGoodHit = false;
2130  }
2131 
2132  else if (hitSelection == "widthX") {
2133  if (!this->inUintInterval(v_hitSelection, hitParams.widthX))
2134  isGoodHitX = false;
2135  } else if (hitSelection == "widthY") {
2136  if (!this->inUintInterval(v_hitSelection, hitParams.widthY))
2137  isGoodHitY = false;
2138  }
2139  } else { // For strip only
2140  if (hitSelection == "width") {
2141  if (!this->inUintInterval(v_hitSelection, hitParams.widthX))
2142  isGoodHit = false;
2143  } else if (hitSelection == "edgeStrips") {
2144  if (!this->inUintInterval(v_hitSelection, hitParams.maxStrip, hitParams.maxStripInv))
2145  isGoodHit = false;
2146  } else if (hitSelection == "maxIndex") {
2147  if (!this->inUintInterval(v_hitSelection, hitParams.maxIndex))
2148  isGoodHit = false;
2149  }
2150  }
2151  }
2152 
2153  if (hitParams.isPixelHit) {
2154  hitParams.goodXMeasurement = isGoodHit && isGoodHitX;
2155  hitParams.goodYMeasurement = isGoodHit && isGoodHitY;
2156  } else {
2157  hitParams.goodXMeasurement = isGoodHit && isGoodHitX;
2158  hitParams.goodYMeasurement = false;
2159  }
2160 
2161  if (!hitParams.goodXMeasurement && !hitParams.goodYMeasurement)
2162  return false;
2163  else
2164  return true;
2165 }
2166 
2167 bool ApeEstimator::inDoubleInterval(const std::vector<double>& v_hitSelection, const float variable) const {
2168  int entry(0);
2169  double intervalBegin(999.);
2170  bool isSelected(false);
2171  for (auto const& i_hitInterval : v_hitSelection) {
2172  ++entry;
2173  if (entry % 2 == 1)
2174  intervalBegin = i_hitInterval;
2175  else if (variable >= intervalBegin && variable < i_hitInterval)
2176  isSelected = true;
2177  }
2178  return isSelected;
2179 }
2180 
2181 bool ApeEstimator::inUintInterval(const std::vector<unsigned int>& v_hitSelection,
2182  const unsigned int variable,
2183  const unsigned int variable2) const {
2184  int entry(0);
2185  unsigned int intervalBegin(999);
2186  bool isSelected(false);
2187  for (auto i_hitInterval : v_hitSelection) {
2188  ++entry;
2189  if (entry % 2 == 1)
2190  intervalBegin = i_hitInterval;
2191  else if (variable >= intervalBegin && variable <= i_hitInterval) {
2192  if (variable2 == 999 || (variable2 >= intervalBegin && variable2 <= i_hitInterval))
2193  isSelected = true;
2194  }
2195  }
2196  return isSelected;
2197 }
2198 
2199 // -----------------------------------------------------------------------------------------------------------
2200 
2201 void ApeEstimator::fillHistsForAnalyzerMode(const TrackStruct& trackStruct) {
2202  unsigned int goodHitsPerTrack(trackStruct.v_hitParams.size());
2203  tkDetector_.HitsGood->Fill(goodHitsPerTrack);
2204  tkDetector_.HitsGoodVsHitsValid->Fill(trackStruct.trkParams.hitsValid, goodHitsPerTrack);
2205  tkDetector_.PHitsGoodVsHitsValid->Fill(trackStruct.trkParams.hitsValid, goodHitsPerTrack);
2206 
2207  if (parameterSet_.getParameter<bool>("applyTrackCuts")) {
2208  // which tracks to take? need min. nr. of selected hits?
2209  if (goodHitsPerTrack < minGoodHitsPerTrack_)
2210  return;
2211  }
2212 
2213  tkDetector_.HitsSize->Fill(trackStruct.trkParams.hitsSize);
2214  tkDetector_.HitsValid->Fill(trackStruct.trkParams.hitsValid);
2215  tkDetector_.HitsInvalid->Fill(trackStruct.trkParams.hitsInvalid);
2216  tkDetector_.Hits2D->Fill(trackStruct.trkParams.hits2D);
2217  tkDetector_.LayersMissed->Fill(trackStruct.trkParams.layersMissed);
2218  tkDetector_.HitsPixel->Fill(trackStruct.trkParams.hitsPixel);
2219  tkDetector_.HitsStrip->Fill(trackStruct.trkParams.hitsStrip);
2220  tkDetector_.Charge->Fill(trackStruct.trkParams.charge);
2221  tkDetector_.Chi2->Fill(trackStruct.trkParams.chi2);
2222  tkDetector_.Ndof->Fill(trackStruct.trkParams.ndof);
2223  tkDetector_.NorChi2->Fill(trackStruct.trkParams.norChi2);
2224  tkDetector_.Prob->Fill(trackStruct.trkParams.prob);
2225  tkDetector_.Eta->Fill(trackStruct.trkParams.eta);
2226  tkDetector_.EtaErr->Fill(trackStruct.trkParams.etaErr);
2227  tkDetector_.EtaSig->Fill(trackStruct.trkParams.eta / trackStruct.trkParams.etaErr);
2228  tkDetector_.Theta->Fill(trackStruct.trkParams.theta * 180. / M_PI);
2229  tkDetector_.Phi->Fill(trackStruct.trkParams.phi * 180. / M_PI);
2230  tkDetector_.PhiErr->Fill(trackStruct.trkParams.phiErr * 180. / M_PI);
2231  tkDetector_.PhiSig->Fill(trackStruct.trkParams.phi / trackStruct.trkParams.phiErr);
2232  tkDetector_.D0Beamspot->Fill(trackStruct.trkParams.d0Beamspot);
2233  tkDetector_.D0BeamspotErr->Fill(trackStruct.trkParams.d0BeamspotErr);
2234  tkDetector_.D0BeamspotSig->Fill(trackStruct.trkParams.d0Beamspot / trackStruct.trkParams.d0BeamspotErr);
2235  tkDetector_.Dz->Fill(trackStruct.trkParams.dz);
2236  tkDetector_.DzErr->Fill(trackStruct.trkParams.dzErr);
2237  tkDetector_.DzSig->Fill(trackStruct.trkParams.dz / trackStruct.trkParams.dzErr);
2238  tkDetector_.P->Fill(trackStruct.trkParams.p);
2239  tkDetector_.Pt->Fill(trackStruct.trkParams.pt);
2240  tkDetector_.PtErr->Fill(trackStruct.trkParams.ptErr);
2241  tkDetector_.PtSig->Fill(trackStruct.trkParams.pt / trackStruct.trkParams.ptErr);
2242  tkDetector_.MeanAngle->Fill(trackStruct.trkParams.meanPhiSensToNorm * 180. / M_PI);
2243 
2244  tkDetector_.MeanAngleVsHits->Fill(trackStruct.trkParams.hitsSize,
2245  trackStruct.trkParams.meanPhiSensToNorm * 180. / M_PI);
2246  tkDetector_.HitsPixelVsEta->Fill(trackStruct.trkParams.eta, trackStruct.trkParams.hitsPixel);
2247  tkDetector_.HitsPixelVsTheta->Fill(trackStruct.trkParams.theta * 180. / M_PI, trackStruct.trkParams.hitsPixel);
2248  tkDetector_.HitsStripVsEta->Fill(trackStruct.trkParams.eta, trackStruct.trkParams.hitsStrip);
2249  tkDetector_.HitsStripVsTheta->Fill(trackStruct.trkParams.theta * 180. / M_PI, trackStruct.trkParams.hitsStrip);
2250  tkDetector_.PtVsEta->Fill(trackStruct.trkParams.eta, trackStruct.trkParams.pt);
2251  tkDetector_.PtVsTheta->Fill(trackStruct.trkParams.theta * 180. / M_PI, trackStruct.trkParams.pt);
2252 
2253  tkDetector_.PMeanAngleVsHits->Fill(trackStruct.trkParams.hitsSize,
2254  trackStruct.trkParams.meanPhiSensToNorm * 180. / M_PI);
2255  tkDetector_.PHitsPixelVsEta->Fill(trackStruct.trkParams.eta, trackStruct.trkParams.hitsPixel);
2256  tkDetector_.PHitsPixelVsTheta->Fill(trackStruct.trkParams.theta * 180. / M_PI, trackStruct.trkParams.hitsPixel);
2257  tkDetector_.PHitsStripVsEta->Fill(trackStruct.trkParams.eta, trackStruct.trkParams.hitsStrip);
2258  tkDetector_.PHitsStripVsTheta->Fill(trackStruct.trkParams.theta * 180. / M_PI, trackStruct.trkParams.hitsStrip);
2259  tkDetector_.PPtVsEta->Fill(trackStruct.trkParams.eta, trackStruct.trkParams.pt);
2260  tkDetector_.PPtVsTheta->Fill(trackStruct.trkParams.theta * 180. / M_PI, trackStruct.trkParams.pt);
2261 
2262  for (auto& i_hit : trackStruct.v_hitParams) {
2263  const TrackStruct::HitParameterStruct& hit(i_hit);
2264  //Put here from earlier method
2265  if (hit.hitState == TrackStruct::notAssignedToSectors)
2266  continue;
2267 
2268  for (auto& i_sector : m_tkSector_) {
2269  bool moduleInSector(false);
2270  for (auto const& i_hitSector : hit.v_sector) {
2271  if (i_sector.first == i_hitSector) {
2272  moduleInSector = true;
2273  break;
2274  }
2275  }
2276  if (!moduleInSector)
2277  continue;
2278  TrackerSectorStruct& sector(i_sector.second);
2279 
2280  if (hit.goodXMeasurement) {
2281  std::map<std::string, TrackerSectorStruct::CorrelationHists>& m_corrHists(sector.m_correlationHistsX);
2282 
2283  // Cluster and Hit Parameters
2284  this->fillHitHistsXForAnalyzerMode(hit, sector);
2285 
2286  // Track Parameters
2287  m_corrHists["HitsValid"].fillCorrHistsX(hit, trackStruct.trkParams.hitsValid);
2288  m_corrHists["HitsGood"].fillCorrHistsX(hit, goodHitsPerTrack);
2289  m_corrHists["HitsInvalid"].fillCorrHistsX(hit, trackStruct.trkParams.hitsInvalid);
2290  m_corrHists["Hits2D"].fillCorrHistsX(hit, trackStruct.trkParams.hits2D);
2291  m_corrHists["LayersMissed"].fillCorrHistsX(hit, trackStruct.trkParams.layersMissed);
2292  m_corrHists["HitsPixel"].fillCorrHistsX(hit, trackStruct.trkParams.hitsPixel);
2293  m_corrHists["HitsStrip"].fillCorrHistsX(hit, trackStruct.trkParams.hitsStrip);
2294  m_corrHists["NorChi2"].fillCorrHistsX(hit, trackStruct.trkParams.norChi2);
2295  m_corrHists["Theta"].fillCorrHistsX(hit, trackStruct.trkParams.theta * 180. / M_PI);
2296  m_corrHists["Phi"].fillCorrHistsX(hit, trackStruct.trkParams.phi * 180. / M_PI);
2297  m_corrHists["D0Beamspot"].fillCorrHistsX(hit, trackStruct.trkParams.d0Beamspot);
2298  m_corrHists["Dz"].fillCorrHistsX(hit, trackStruct.trkParams.dz);
2299  m_corrHists["Pt"].fillCorrHistsX(hit, trackStruct.trkParams.pt);
2300  m_corrHists["P"].fillCorrHistsX(hit, trackStruct.trkParams.p);
2301  m_corrHists["InvP"].fillCorrHistsX(hit, 1. / trackStruct.trkParams.p);
2302  m_corrHists["MeanAngle"].fillCorrHistsX(hit, trackStruct.trkParams.meanPhiSensToNorm * 180. / M_PI);
2303  }
2304 
2305  if (hit.goodYMeasurement) {
2306  std::map<std::string, TrackerSectorStruct::CorrelationHists>& m_corrHists(sector.m_correlationHistsY);
2307 
2308  // Cluster and Hit Parameters
2309  this->fillHitHistsYForAnalyzerMode(hit, sector);
2310 
2311  // Track Parameters
2312  m_corrHists["HitsValid"].fillCorrHistsY(hit, trackStruct.trkParams.hitsValid);
2313  m_corrHists["HitsGood"].fillCorrHistsY(hit, goodHitsPerTrack);
2314  m_corrHists["HitsInvalid"].fillCorrHistsY(hit, trackStruct.trkParams.hitsInvalid);
2315  m_corrHists["Hits2D"].fillCorrHistsY(hit, trackStruct.trkParams.hits2D);
2316  m_corrHists["LayersMissed"].fillCorrHistsY(hit, trackStruct.trkParams.layersMissed);
2317  m_corrHists["HitsPixel"].fillCorrHistsY(hit, trackStruct.trkParams.hitsPixel);
2318  m_corrHists["HitsStrip"].fillCorrHistsY(hit, trackStruct.trkParams.hitsStrip);
2319  m_corrHists["NorChi2"].fillCorrHistsY(hit, trackStruct.trkParams.norChi2);
2320  m_corrHists["Theta"].fillCorrHistsY(hit, trackStruct.trkParams.theta * 180. / M_PI);
2321  m_corrHists["Phi"].fillCorrHistsY(hit, trackStruct.trkParams.phi * 180. / M_PI);
2322  m_corrHists["D0Beamspot"].fillCorrHistsY(hit, trackStruct.trkParams.d0Beamspot);
2323  m_corrHists["Dz"].fillCorrHistsY(hit, trackStruct.trkParams.dz);
2324  m_corrHists["Pt"].fillCorrHistsY(hit, trackStruct.trkParams.pt);
2325  m_corrHists["P"].fillCorrHistsY(hit, trackStruct.trkParams.p);
2326  m_corrHists["InvP"].fillCorrHistsY(hit, 1. / trackStruct.trkParams.p);
2327  m_corrHists["MeanAngle"].fillCorrHistsY(hit, trackStruct.trkParams.meanPhiSensToNorm * 180. / M_PI);
2328  }
2329 
2330  // Special Histograms
2331  for (auto& i_sigmaX : sector.m_sigmaX) {
2332  for (auto& iHist : i_sigmaX.second) {
2333  if (i_sigmaX.first == "sigmaXHit")
2334  iHist->Fill(hit.errXHit * 10000.);
2335  else if (i_sigmaX.first == "sigmaXTrk")
2336  iHist->Fill(hit.errXTrk * 10000.);
2337  else if (i_sigmaX.first == "sigmaX")
2338  iHist->Fill(hit.errX * 10000.);
2339  }
2340  }
2341  for (auto& i_sigmaY : sector.m_sigmaY) {
2342  for (auto& iHist : i_sigmaY.second) {
2343  if (i_sigmaY.first == "sigmaYHit")
2344  iHist->Fill(hit.errYHit * 10000.);
2345  else if (i_sigmaY.first == "sigmaYTrk")
2346  iHist->Fill(hit.errYTrk * 10000.);
2347  else if (i_sigmaY.first == "sigmaY")
2348  iHist->Fill(hit.errY * 10000.);
2349  }
2350  }
2351  }
2352  }
2353 }
2354 
2355 void ApeEstimator::fillHitHistsXForAnalyzerMode(const TrackStruct::HitParameterStruct& hit,
2356  TrackerSectorStruct& sector) {
2357  std::map<std::string, TrackerSectorStruct::CorrelationHists>& m_corrHists(sector.m_correlationHistsX);
2358 
2359  // Cluster Parameters
2360  m_corrHists["WidthX"].fillCorrHistsX(hit, hit.widthX);
2361  m_corrHists["BaryStripX"].fillCorrHistsX(hit, hit.baryStripX);
2362 
2363  if (hit.isPixelHit) {
2364  m_corrHists["ChargePixel"].fillCorrHistsX(hit, hit.chargePixel);
2365  m_corrHists["ClusterProbXY"].fillCorrHistsX(hit, hit.clusterProbabilityXY);
2366  m_corrHists["ClusterProbQ"].fillCorrHistsX(hit, hit.clusterProbabilityQ);
2367  m_corrHists["ClusterProbXYQ"].fillCorrHistsX(hit, hit.clusterProbabilityXYQ);
2368  m_corrHists["LogClusterProb"].fillCorrHistsX(hit, hit.logClusterProbability);
2369  m_corrHists["IsOnEdge"].fillCorrHistsX(hit, hit.isOnEdge);
2370  m_corrHists["HasBadPixels"].fillCorrHistsX(hit, hit.hasBadPixels);
2371  m_corrHists["SpansTwoRoc"].fillCorrHistsX(hit, hit.spansTwoRoc);
2372  m_corrHists["QBin"].fillCorrHistsX(hit, hit.qBin);
2373 
2374  } else {
2375  m_corrHists["ChargeStrip"].fillCorrHistsX(hit, hit.chargeStrip);
2376  m_corrHists["MaxStrip"].fillCorrHistsX(hit, hit.maxStrip);
2377  m_corrHists["MaxCharge"].fillCorrHistsX(hit, hit.maxCharge);
2378  m_corrHists["MaxIndex"].fillCorrHistsX(hit, hit.maxIndex);
2379  m_corrHists["ChargeOnEdges"].fillCorrHistsX(hit, hit.chargeOnEdges);
2380  m_corrHists["ChargeAsymmetry"].fillCorrHistsX(hit, hit.chargeAsymmetry);
2381  m_corrHists["ChargeLRplus"].fillCorrHistsX(hit, hit.chargeLRplus);
2382  m_corrHists["ChargeLRminus"].fillCorrHistsX(hit, hit.chargeLRminus);
2383  m_corrHists["SOverN"].fillCorrHistsX(hit, hit.sOverN);
2384  m_corrHists["WidthProj"].fillCorrHistsX(hit, hit.projWidth);
2385  m_corrHists["WidthDiff"].fillCorrHistsX(hit, hit.projWidth - static_cast<float>(hit.widthX));
2386 
2387  sector.WidthVsWidthProjected->Fill(hit.projWidth, hit.widthX);
2388  sector.PWidthVsWidthProjected->Fill(hit.projWidth, hit.widthX);
2389 
2390  sector.WidthDiffVsMaxStrip->Fill(hit.maxStrip, hit.projWidth - static_cast<float>(hit.widthX));
2391  sector.PWidthDiffVsMaxStrip->Fill(hit.maxStrip, hit.projWidth - static_cast<float>(hit.widthX));
2392 
2393  sector.WidthDiffVsSigmaXHit->Fill(hit.errXHit, hit.projWidth - static_cast<float>(hit.widthX));
2394  sector.PWidthDiffVsSigmaXHit->Fill(hit.errXHit, hit.projWidth - static_cast<float>(hit.widthX));
2395 
2396  sector.WidthVsPhiSensX->Fill(hit.phiSensX * 180. / M_PI, hit.widthX);
2397  sector.PWidthVsPhiSensX->Fill(hit.phiSensX * 180. / M_PI, hit.widthX);
2398  }
2399 
2400  // Hit Parameters
2401  m_corrHists["SigmaXHit"].fillCorrHistsX(hit, hit.errXHit * 10000.);
2402  m_corrHists["SigmaXTrk"].fillCorrHistsX(hit, hit.errXTrk * 10000.);
2403  m_corrHists["SigmaX"].fillCorrHistsX(hit, hit.errX * 10000.);
2404 
2405  m_corrHists["PhiSens"].fillCorrHistsX(hit, hit.phiSens * 180. / M_PI);
2406  m_corrHists["PhiSensX"].fillCorrHistsX(hit, hit.phiSensX * 180. / M_PI);
2407  m_corrHists["PhiSensY"].fillCorrHistsX(hit, hit.phiSensY * 180. / M_PI);
2408 
2409  sector.XHit->Fill(hit.xHit);
2410  sector.XTrk->Fill(hit.xTrk);
2411  sector.SigmaX2->Fill(hit.errX2 * 10000. * 10000.);
2412 
2413  sector.ResX->Fill(hit.resX * 10000.);
2414  sector.NorResX->Fill(hit.norResX);
2415 
2416  sector.ProbX->Fill(hit.probX);
2417 
2418  sector.PhiSensXVsBarycentreX->Fill(hit.baryStripX, hit.phiSensX * 180. / M_PI);
2419  sector.PPhiSensXVsBarycentreX->Fill(hit.baryStripX, hit.phiSensX * 180. / M_PI);
2420 }
2421 
2422 void ApeEstimator::fillHitHistsYForAnalyzerMode(const TrackStruct::HitParameterStruct& hit,
2423  TrackerSectorStruct& sector) {
2424  std::map<std::string, TrackerSectorStruct::CorrelationHists>& m_corrHists(sector.m_correlationHistsY);
2425  // Do not fill anything for strip
2426  if (!hit.isPixelHit)
2427  return;
2428 
2429  // Cluster Parameters
2430  m_corrHists["WidthY"].fillCorrHistsY(hit, hit.widthY);
2431  m_corrHists["BaryStripY"].fillCorrHistsY(hit, hit.baryStripY);
2432 
2433  m_corrHists["ChargePixel"].fillCorrHistsY(hit, hit.chargePixel);
2434  m_corrHists["ClusterProbXY"].fillCorrHistsY(hit, hit.clusterProbabilityXY);
2435  m_corrHists["ClusterProbQ"].fillCorrHistsY(hit, hit.clusterProbabilityQ);
2436  m_corrHists["ClusterProbXYQ"].fillCorrHistsY(hit, hit.clusterProbabilityXYQ);
2437  m_corrHists["LogClusterProb"].fillCorrHistsY(hit, hit.logClusterProbability);
2438  m_corrHists["IsOnEdge"].fillCorrHistsY(hit, hit.isOnEdge);
2439  m_corrHists["HasBadPixels"].fillCorrHistsY(hit, hit.hasBadPixels);
2440  m_corrHists["SpansTwoRoc"].fillCorrHistsY(hit, hit.spansTwoRoc);
2441  m_corrHists["QBin"].fillCorrHistsY(hit, hit.qBin);
2442 
2443  // Hit Parameters
2444  m_corrHists["SigmaYHit"].fillCorrHistsY(hit, hit.errYHit * 10000.);
2445  m_corrHists["SigmaYTrk"].fillCorrHistsY(hit, hit.errYTrk * 10000.);
2446  m_corrHists["SigmaY"].fillCorrHistsY(hit, hit.errY * 10000.);
2447 
2448  m_corrHists["PhiSens"].fillCorrHistsY(hit, hit.phiSens * 180. / M_PI);
2449  m_corrHists["PhiSensX"].fillCorrHistsY(hit, hit.phiSensX * 180. / M_PI);
2450  m_corrHists["PhiSensY"].fillCorrHistsY(hit, hit.phiSensY * 180. / M_PI);
2451 
2452  sector.YHit->Fill(hit.yHit);
2453  sector.YTrk->Fill(hit.yTrk);
2454  sector.SigmaY2->Fill(hit.errY2 * 10000. * 10000.);
2455 
2456  sector.ResY->Fill(hit.resY * 10000.);
2457  sector.NorResY->Fill(hit.norResY);
2458 
2459  sector.ProbY->Fill(hit.probY);
2460 
2461  sector.PhiSensYVsBarycentreY->Fill(hit.baryStripY, hit.phiSensY * 180. / M_PI);
2462  sector.PPhiSensYVsBarycentreY->Fill(hit.baryStripY, hit.phiSensY * 180. / M_PI);
2463 }
2464 
2465 void ApeEstimator::fillHistsForApeCalculation(const TrackStruct& trackStruct) {
2466  unsigned int goodHitsPerTrack(trackStruct.v_hitParams.size());
2467 
2468  if (parameterSet_.getParameter<bool>("applyTrackCuts")) {
2469  // which tracks to take? need min. nr. of selected hits?
2470  if (goodHitsPerTrack < minGoodHitsPerTrack_)
2471  return;
2472  }
2473 
2474  for (auto const& i_hit : trackStruct.v_hitParams) {
2475  // Put here from earlier method
2476  if (i_hit.hitState == TrackStruct::notAssignedToSectors)
2477  continue;
2478 
2479  for (auto& i_sector : m_tkSector_) {
2480  bool moduleInSector(false);
2481  for (auto const& i_hitSector : i_hit.v_sector) {
2482  if (i_sector.first == i_hitSector) {
2483  moduleInSector = true;
2484  break;
2485  }
2486  }
2487  if (!moduleInSector)
2488  continue;
2489 
2490  if (!calculateApe_)
2491  continue;
2492 
2493  if (i_hit.goodXMeasurement) {
2494  for (auto const& i_errBins : m_resErrBins_) {
2495  // Separate the bins for residual resolution w/o APE, to be consistent within iterations where APE will change (have same hit always in same bin)
2496  // So also fill this value in the histogram sigmaX
2497  // But of course use the normalized residual regarding the APE to have its influence in its width
2498  if (i_hit.errXWoApe < i_errBins.second.first || i_hit.errXWoApe >= i_errBins.second.second) {
2499  continue;
2500  }
2501  i_sector.second.m_binnedHists[i_errBins.first]["sigmaX"]->Fill(i_hit.errXWoApe);
2502  i_sector.second.m_binnedHists[i_errBins.first]["norResX"]->Fill(i_hit.norResX);
2503  break;
2504  }
2505  i_sector.second.ResX->Fill(i_hit.resX * 10000.);
2506  i_sector.second.NorResX->Fill(i_hit.norResX);
2507  }
2508 
2509  if (i_hit.goodYMeasurement) {
2510  for (auto const& i_errBins : m_resErrBins_) {
2511  // Separate the bins for residual resolution w/o APE, to be consistent within iterations where APE will change (have same hit always in same bin)
2512  // So also fill this value in the histogram sigmaY
2513  // But of course use the normalized residual regarding the APE to have its influence in its width
2514  if (i_hit.errYWoApe < i_errBins.second.first || i_hit.errYWoApe >= i_errBins.second.second) {
2515  continue;
2516  }
2517  i_sector.second.m_binnedHists[i_errBins.first]["sigmaY"]->Fill(i_hit.errYWoApe);
2518  i_sector.second.m_binnedHists[i_errBins.first]["norResY"]->Fill(i_hit.norResY);
2519  break;
2520  }
2521  i_sector.second.ResY->Fill(i_hit.resY * 10000.);
2522  i_sector.second.NorResY->Fill(i_hit.norResY);
2523  }
2524  }
2525  }
2526 }
2527 
2528 // -----------------------------------------------------------------------------------------------------------
2529 
2530 void ApeEstimator::calculateAPE() {
2531  // Loop over sectors for calculating APE
2532  for (auto& i_sector : m_tkSector_) {
2533  // Loop over residual error bins to calculate APE for every bin
2534  for (auto const& i_errBins : i_sector.second.m_binnedHists) {
2535  std::map<std::string, TH1*> m_Hists = i_errBins.second;
2536 
2537  // Fitting Parameters
2538  double integralX = m_Hists["norResX"]->Integral();
2539  i_sector.second.EntriesX->SetBinContent(i_errBins.first, integralX);
2540 
2541  if (i_sector.second.isPixel) {
2542  double integralY = m_Hists["norResY"]->Integral();
2543  i_sector.second.EntriesY->SetBinContent(i_errBins.first, integralY);
2544  }
2545  }
2546  }
2547 }
2548 
2549 // -----------------------------------------------------------------------------------------------------------
2550 
2551 bool ApeEstimator::isHit2D(const TrackingRecHit& hit) const {
2552  // we count SiStrip stereo modules as 2D if selected via countStereoHitAs2D_
2553  // (since they provide theta information)
2554  // --- NO, here it is always set to true ---
2555  if (!hit.isValid() || (hit.dimension() < 2 && !dynamic_cast<const SiStripRecHit1D*>(&hit))) {
2556  return false; // real RecHit1D - but SiStripRecHit1D depends on countStereoHitAs2D_
2557  } else {
2558  const DetId detId(hit.geographicalId());
2559  if (detId.det() == DetId::Tracker) {
2560  if (detId.subdetId() == PixelSubdetector::PixelBarrel || detId.subdetId() == PixelSubdetector::PixelEndcap) {
2561  return true; // pixel is always 2D
2562  } else { // should be SiStrip now
2563  const SiStripDetId stripId(detId);
2564  if (stripId.stereo())
2565  return true; // stereo modules
2566  else if (dynamic_cast<const SiStripRecHit1D*>(&hit) || dynamic_cast<const SiStripRecHit2D*>(&hit))
2567  return false; // rphi modules hit
2568  //the following two are not used any more since ages...
2569  else if (dynamic_cast<const SiStripMatchedRecHit2D*>(&hit))
2570  return true; // matched is 2D
2571  else if (dynamic_cast<const ProjectedSiStripRecHit2D*>(&hit)) {
2572  const ProjectedSiStripRecHit2D* pH = static_cast<const ProjectedSiStripRecHit2D*>(&hit);
2573  return (this->isHit2D(pH->originalHit())); // depends on original...
2574  } else {
2575  edm::LogError("UnkownType") << "@SUB=AlignmentTrackSelector::isHit2D"
2576  << "Tracker hit not in pixel, neither SiStripRecHit[12]D nor "
2577  << "SiStripMatchedRecHit2D nor ProjectedSiStripRecHit2D.";
2578  return false;
2579  }
2580  }
2581  } else { // not tracker??
2582  edm::LogWarning("DetectorMismatch") << "@SUB=AlignmentTrackSelector::isHit2D"
2583  << "Hit not in tracker with 'official' dimension >=2.";
2584  return true; // dimension() >= 2 so accept that...
2585  }
2586  }
2587  // never reached...
2588 }
2589 
2590 // -----------------------------------------------------------------------------------------------------------
2591 
2592 // ------------ method called to for each event ------------
2593 void ApeEstimator::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) {
2594  reco::BeamSpot beamSpot;
2595  edm::Handle<reco::BeamSpot> beamSpotHandle;
2596  iEvent.getByToken(offlinebeamSpot_, beamSpotHandle);
2597 
2598  if (beamSpotHandle.isValid()) {
2599  beamSpot = *beamSpotHandle;
2600  } else {
2601  edm::LogError("ApeEstimator") << "No beam spot available from EventSetup"
2602  << "\n...skip event";
2603  return;
2604  }
2605 
2606  edm::Handle<TrajTrackAssociationCollection> m_TrajTracksMap;
2607  iEvent.getByToken(tjTagToken_, m_TrajTracksMap);
2608 
2609  siStripClusterInfo_.initEvent(iSetup);
2610 
2611  if (analyzerMode_)
2612  tkDetector_.TrkSize->Fill(m_TrajTracksMap->size());
2613 
2614  if (maxTracksPerEvent_ != 0 && m_TrajTracksMap->size() > maxTracksPerEvent_)
2615  return;
2616 
2617  //Creation of (traj,track)
2618  typedef std::pair<const Trajectory*, const reco::Track*> ConstTrajTrackPair;
2619  typedef std::vector<ConstTrajTrackPair> ConstTrajTrackPairCollection;
2620  ConstTrajTrackPairCollection trajTracks;
2621 
2622  TrajTrackAssociationCollection::const_iterator i_trajTrack;
2623  for (i_trajTrack = m_TrajTracksMap->begin(); i_trajTrack != m_TrajTracksMap->end(); ++i_trajTrack) {
2624  trajTracks.push_back(ConstTrajTrackPair(&(*(*i_trajTrack).key), &(*(*i_trajTrack).val)));
2625  }
2626 
2627  //Loop over Tracks & Hits
2628  unsigned int trackSizeGood(0);
2629  ConstTrajTrackPairCollection::const_iterator iTrack;
2630  for (iTrack = trajTracks.begin(); iTrack != trajTracks.end(); ++iTrack) {
2631  const Trajectory* traj = (*iTrack).first;
2632  const reco::Track* track = (*iTrack).second;
2633 
2634  TrackStruct trackStruct;
2635  trackStruct.trkParams = this->fillTrackVariables(*track, *traj, beamSpot);
2636 
2637  if (trackCut_)
2638  continue;
2639 
2640  const std::vector<TrajectoryMeasurement> v_meas = (*traj).measurements();
2641 
2642  //Loop over Hits
2643  for (std::vector<TrajectoryMeasurement>::const_iterator i_meas = v_meas.begin(); i_meas != v_meas.end(); ++i_meas) {
2644  TrackStruct::HitParameterStruct hitParams = this->fillHitVariables(*i_meas, iSetup);
2645  if (this->hitSelected(hitParams))
2646  trackStruct.v_hitParams.push_back(hitParams);
2647  }
2648 
2649  if (analyzerMode_)
2650  this->fillHistsForAnalyzerMode(trackStruct);
2651  if (calculateApe_)
2652  this->fillHistsForApeCalculation(trackStruct);
2653 
2654  if (!trackStruct.v_hitParams.empty())
2655  ++trackSizeGood;
2656  }
2657  if (analyzerMode_ && trackSizeGood > 0)
2658  tkDetector_.TrkSizeGood->Fill(trackSizeGood);
2659 }
2660 
2661 // ------------ method called once each job just before starting event loop ------------
2662 void ApeEstimator::beginJob() {
2663  this->hitSelection();
2664 
2665  this->sectorBuilder();
2666 
2667  this->residualErrorBinning();
2668 
2669  if (analyzerMode_)
2670  this->bookSectorHistsForAnalyzerMode();
2671 
2672  if (calculateApe_)
2673  this->bookSectorHistsForApeCalculation();
2674 
2675  if (analyzerMode_)
2676  this->bookTrackHists();
2677 }
2678 
2679 // ------------ method called once each job just after ending the event loop ------------
2680 void ApeEstimator::endJob() {
2681  if (calculateApe_)
2682  this->calculateAPE();
2683 
2684  edm::LogInfo("HitSelector") << "\nThere are " << counter1 << " negative Errors calculated\n";
2685 }
2686 
2687 //define this as a plug-in
2688 DEFINE_FWK_MODULE(ApeEstimator);
Vector3DBase
Definition: Vector3DBase.h:8
TrackerDetectorStruct::HitsSize
TH1 * HitsSize
Definition: TrackerDetectorStruct.h:60
TrackStruct::HitParameterStruct::isOnEdge
bool isOnEdge
Definition: EventVariables.h:82
TrajectoryStateCombiner.h
RadialStripTopology
Definition: RadialStripTopology.h:28
SiStripClusterInfo
Definition: SiStripClusterInfo.h:21
edm::ESHandle::product
T const * product() const
Definition: ESHandle.h:86
TrackStruct::TrackParameterStruct::p
float p
Definition: EventVariables.h:129
ApeEstimator::analyze
void analyze(const edm::Event &, const edm::EventSetup &) override
Definition: ApeEstimator.cc:2593
Point2DBase
Definition: Point2DBase.h:9
TrackerDetectorStruct::P
TH1 * P
Definition: TrackerDetectorStruct.h:60
SiStripDependentRecords.h
TFileDirectory::mkdir
TFileDirectory mkdir(const std::string &dir, const std::string &descr="")
create a new subdirectory
Definition: TFileDirectory.cc:112
TrackStruct::HitParameterStruct::maxCharge
unsigned int maxCharge
Definition: EventVariables.h:87
DDAxes::y
TrackStruct::HitParameterStruct::probY
float probY
Definition: EventVariables.h:94
TrajectoryStateOnSurface.h
Handle.h
SiStripRecHit2D::cluster
ClusterRef cluster() const
Definition: SiStripRecHit2D.h:22
EventVariables.h
TrackerDetectorStruct::Theta
TH1 * Theta
Definition: TrackerDetectorStruct.h:60
TrackStruct::TrackParameterStruct::hitsPixel
int hitsPixel
Definition: EventVariables.h:128
electrons_cff.bool
bool
Definition: electrons_cff.py:372
EDAnalyzer.h
TrackerDetectorStruct::HitsStripVsTheta
TH2 * HitsStripVsTheta
Definition: TrackerDetectorStruct.h:64
TrackerDetectorStruct::Prob
TH1 * Prob
Definition: TrackerDetectorStruct.h:60
AlignmentTrackSelector_cfi.d0Max
d0Max
Definition: AlignmentTrackSelector_cfi.py:22
TrackStruct::trkParams
TrackParameterStruct trkParams
Definition: EventVariables.h:133
PixelSubdetector.h
pwdgSkimBPark_cfi.beamSpot
beamSpot
Definition: pwdgSkimBPark_cfi.py:5
SiStripClusterInfo::maxStrip
uint16_t maxStrip() const
Definition: SiStripClusterInfo.h:34
Bounds::width
virtual float width() const =0
StripGeomDetUnit.h
MessageLogger.h
TrackingMonitor_cfi.stripCluster
stripCluster
Definition: TrackingMonitor_cfi.py:20
ApeEstimator::ApeEstimator
ApeEstimator(const edm::ParameterSet &)
Definition: ApeEstimator.cc:220
TrackStruct::invalid
Definition: EventVariables.h:9
SiStripClusterInfo.h
funct::false
false
Definition: Factorize.h:34
PixelSubdetector::PixelEndcap
Definition: PixelSubdetector.h:11
TrackStruct::HitParameterStruct::probX
float probX
Definition: EventVariables.h:93
TrackerDetectorStruct::DzErr
TH1 * DzErr
Definition: TrackerDetectorStruct.h:60
TrackerDetectorStruct::HitsValid
TH1 * HitsValid
Definition: TrackerDetectorStruct.h:60
GeomDet
Definition: GeomDet.h:27
PixelSubdetector::PixelBarrel
Definition: PixelSubdetector.h:11
TrackerDetectorStruct::PtVsTheta
TH2 * PtVsTheta
Definition: TrackerDetectorStruct.h:64
PixelTopology.h
ApeEstimator::~ApeEstimator
~ApeEstimator() override
Definition: ApeEstimator.cc:234
ApeEstimator::fillTrackVariables
TrackStruct::TrackParameterStruct fillTrackVariables(const reco::Track &, const Trajectory &, const reco::BeamSpot &)
Definition: ApeEstimator.cc:1265
ESHandle.h
align::BeamSpot
Definition: StructureType.h:89
LocalTrajectoryError::positionError
LocalError positionError() const
Definition: LocalTrajectoryError.h:81
LocalError::xy
float xy() const
Definition: LocalError.h:23
ReducedTrackerTreeVariables::wDirection
Int_t wDirection
Definition: ReducedTrackerTreeVariables.h:18
fftjetvertexadder_cfi.errY
errY
Definition: fftjetvertexadder_cfi.py:38
TrackerSectorStruct::PhiSensYVsBarycentreY
TH2 * PhiSensYVsBarycentreY
Definition: TrackerSectorStruct.h:87
PV3DBase::x
T x() const
Definition: PV3DBase.h:59
fileService
edm::Service< TFileService > fileService
Definition: HSCPValidator.cc:91
RadialStripTopology.h
TrackerDetectorStruct::D0BeamspotErr
TH1 * D0BeamspotErr
Definition: TrackerDetectorStruct.h:60
GeomDet::type
virtual const GeomDetType & type() const
Definition: GeomDet.cc:69
TrackStruct::HitParameterStruct::phiSensX
float phiSensX
Definition: EventVariables.h:95
TrackerDetectorStruct::PtSig
TH1 * PtSig
Definition: TrackerDetectorStruct.h:60
edm::EDGetTokenT
Definition: EDGetToken.h:33
RadialStripTopology::measurementError
MeasurementError measurementError(const LocalPoint &, const LocalError &) const override=0
TFileDirectory::make
T * make(const Args &... args) const
make new ROOT object
Definition: TFileDirectory.h:53
edm
HLT enums.
Definition: AlignableModifier.h:19
mps_splice.entry
entry
Definition: mps_splice.py:68
TrackStruct::HitParameterStruct::widthX
unsigned int widthX
Definition: EventVariables.h:75
beamspotanalyzer_cfi.sigmaXMin
sigmaXMin
Definition: beamspotanalyzer_cfi.py:10
TrackerSectorStruct::YHit
TH1 * YHit
Definition: TrackerSectorStruct.h:86
ApeEstimator::residualErrorBinning
void residualErrorBinning()
Definition: ApeEstimator.cc:557
MeasurementExtractor.h
ApeEstimator::positionAndError2
StatePositionAndError2 positionAndError2(const LocalPoint &, const LocalError &, const TransientTrackingRecHit &)
Definition: ApeEstimator.cc:1728
TrackStruct::HitParameterStruct::sOverN
float sOverN
Definition: EventVariables.h:89
TrackStruct::HitState
HitState
Definition: EventVariables.h:9
SiPixelCluster.h
SiStripClusterInfo::stripCharges
auto stripCharges() const -> decltype(cluster() ->amplitudes())
Definition: SiStripClusterInfo.h:37
ApeEstimator::trackCut_
bool trackCut_
Definition: ApeEstimator.cc:197
edm::LogInfo
Definition: MessageLogger.h:254
TrackStruct::HitParameterStruct::errYTrk
float errYTrk
Definition: EventVariables.h:94
ApeEstimator::fillHistsForApeCalculation
void fillHistsForApeCalculation(const TrackStruct &)
Definition: ApeEstimator.cc:2465
MeasurementError.h
TrackerDetectorStruct
Definition: TrackerDetectorStruct.h:8
GeomDetType.h
TrackStruct::TrackParameterStruct::ptErr
float ptErr
Definition: EventVariables.h:129
Bounds
Definition: Bounds.h:18
TrackStruct::notInTracker
Definition: EventVariables.h:9
SiStripClusterInfo::maxIndex
uint16_t maxIndex() const
Definition: SiStripClusterInfo.h:45
TrackStruct::HitParameterStruct::widthY
unsigned int widthY
Definition: EventVariables.h:78
SiStripDetId.h
SiStripRecHit2D
Definition: SiStripRecHit2D.h:7
TrajectoryMeasurement.h
TransientTrackingRecHit.h
TrackStruct::HitParameterStruct::errYHitWoApe
float errYHitWoApe
Definition: EventVariables.h:94
ReducedTrackerTreeVariables::uDirection
Int_t uDirection
Definition: ReducedTrackerTreeVariables.h:18
TrackStruct::TrackParameterStruct::ndof
float ndof
Definition: EventVariables.h:129
ApeEstimator::tjTagToken_
edm::EDGetTokenT< TrajTrackAssociationCollection > tjTagToken_
Definition: ApeEstimator.cc:188
TrackStruct::TrackParameterStruct::hitsValid
int hitsValid
Definition: EventVariables.h:128
DDAxes::x
TFileDirectory
Definition: TFileDirectory.h:24
ApeEstimator::fillHitHistsXForAnalyzerMode
void fillHitHistsXForAnalyzerMode(const TrackStruct::HitParameterStruct &, TrackerSectorStruct &)
Definition: ApeEstimator.cc:2355
SiPixelCluster
Pixel cluster – collection of neighboring pixels above threshold.
Definition: SiPixelCluster.h:27
TrackStruct::HitParameterStruct::errYHit
float errYHit
Definition: EventVariables.h:94
TrackStruct::HitParameterStruct::hitState
HitState hitState
Definition: EventVariables.h:68
TrackerDetectorStruct::D0BeamspotSig
TH1 * D0BeamspotSig
Definition: TrackerDetectorStruct.h:60
TrackStruct::TrackParameterStruct::hitsInvalid
int hitsInvalid
Definition: EventVariables.h:128
TrackerDetectorStruct::PPtVsTheta
TProfile * PPtVsTheta
Definition: TrackerDetectorStruct.h:67
reco
fixed size matrix
Definition: AlignmentAlgorithmBase.h:45
edm::one::EDAnalyzer
Definition: EDAnalyzer.h:30
StripTopology.h
TrackerSectorStruct::SigmaY2
TH1 * SigmaY2
Definition: TrackerSectorStruct.h:86
TrackerDetectorStruct::PMeanAngleVsHits
TProfile * PMeanAngleVsHits
Definition: TrackerDetectorStruct.h:67
TrackStruct::HitParameterStruct::clusterProbabilityQ
float clusterProbabilityQ
Definition: EventVariables.h:81
TrackStruct::TrackParameterStruct::pt
float pt
Definition: EventVariables.h:129
TrackerDetectorStruct::PPtVsEta
TProfile * PPtVsEta
Definition: TrackerDetectorStruct.h:67
TrackStruct::HitParameterStruct::goodXMeasurement
bool goodXMeasurement
Definition: EventVariables.h:70
dzMax
constexpr float dzMax
Definition: PhotonIDValueMapProducer.cc:150
TrackStruct::HitParameterStruct::chargeLRplus
float chargeLRplus
Definition: EventVariables.h:88
ApeEstimator::hitSelected
bool hitSelected(TrackStruct::HitParameterStruct &) const
Definition: ApeEstimator.cc:1976
TrackerDetectorStruct::Hits2D
TH1 * Hits2D
Definition: TrackerDetectorStruct.h:60
TrackerSectorStruct::WidthVsPhiSensX
TH2 * WidthVsPhiSensX
Definition: TrackerSectorStruct.h:81
edm::Handle< reco::BeamSpot >
SiPixelRecHit::cluster
ClusterRef cluster() const
Definition: SiPixelRecHit.h:47
ApeEstimator::statistics
void statistics(const TrackerSectorStruct &, const int) const
Definition: ApeEstimator.cc:520
TrackStruct::TrackParameterStruct::prob
float prob
Definition: EventVariables.h:129
TrackStruct::HitParameterStruct::norResX
float norResX
Definition: EventVariables.h:93
ApeEstimator::checkModuleIds
bool checkModuleIds(const unsigned int, const std::vector< unsigned int > &) const
Definition: ApeEstimator.cc:473
TrackStruct::TrackParameterStruct::hits2D
int hits2D
Definition: EventVariables.h:128
TrackStruct::TrackParameterStruct::d0BeamspotErr
float d0BeamspotErr
Definition: EventVariables.h:129
rpcPointValidation_cfi.recHit
recHit
Definition: rpcPointValidation_cfi.py:7
ApeEstimator::offlinebeamSpot_
edm::EDGetTokenT< reco::BeamSpot > offlinebeamSpot_
Definition: ApeEstimator.cc:189
ProjectedSiStripRecHit2D
Definition: ProjectedSiStripRecHit2D.h:8
TrackerDetectorStruct::MeanAngle
TH1 * MeanAngle
Definition: TrackerDetectorStruct.h:60
TrackStruct::HitParameterStruct::spansTwoRoc
bool spansTwoRoc
Definition: EventVariables.h:82
SiPixelRecHit
Our base class.
Definition: SiPixelRecHit.h:23
TrackerSectorStruct::PWidthDiffVsMaxStrip
TProfile * PWidthDiffVsMaxStrip
Definition: TrackerSectorStruct.h:82
ApeEstimator::counter1
unsigned int counter1
Definition: ApeEstimator.cc:206
Bounds::length
virtual float length() const =0
TrackerSectorStruct::PWidthDiffVsSigmaXHit
TProfile * PWidthDiffVsSigmaXHit
Definition: TrackerSectorStruct.h:82
TrackerDetectorStruct::Dz
TH1 * Dz
Definition: TrackerDetectorStruct.h:60
TrackerAlignmentErrorExtendedRcd.h
SiStripClusterInfo::width
uint16_t width() const
Definition: SiStripClusterInfo.h:31
ReducedTrackerTreeVariables::nStrips
UInt_t nStrips
Definition: ReducedTrackerTreeVariables.h:17
TFileDirectory.h
TrackStruct::HitParameterStruct::errX
float errX
Definition: EventVariables.h:93
F
static uInt32 F(BLOWFISH_CTX *ctx, uInt32 x)
Definition: blowfish.cc:163
funct::sin
Sin< T >::type sin(const T &t)
Definition: Sin.h:22
ApeEstimator::m_tkSector_
std::map< unsigned int, TrackerSectorStruct > m_tkSector_
Definition: ApeEstimator.cc:184
TrackStruct::HitParameterStruct::maxStripInv
unsigned int maxStripInv
Definition: EventVariables.h:87
ApeEstimator::beginJob
void beginJob() override
Definition: ApeEstimator.cc:2662
photonAnalyzer_cfi.xMin
xMin
Definition: photonAnalyzer_cfi.py:82
EDMException.h
TrackStruct::HitParameterStruct::qBin
int qBin
Definition: EventVariables.h:83
beamspotanalyzer_cfi.sigmaXMax
sigmaXMax
Definition: beamspotanalyzer_cfi.py:10
TrackerDetectorStruct::DzSig
TH1 * DzSig
Definition: TrackerDetectorStruct.h:60
IdealMagneticFieldRecord
Definition: IdealMagneticFieldRecord.h:11
TrackStruct::TrackParameterStruct::layersMissed
int layersMissed
Definition: EventVariables.h:128
DetId
Definition: DetId.h:17
edm::AssociationMap::end
const_iterator end() const
last iterator over the map (read only)
Definition: AssociationMap.h:171
TrackerDetectorStruct::EtaSig
TH1 * EtaSig
Definition: TrackerDetectorStruct.h:60
GeomDet::surface
const Plane & surface() const
The nominal surface of the GeomDet.
Definition: GeomDet.h:37
TrajectoryStateOnSurface
Definition: TrajectoryStateOnSurface.h:16
MakerMacros.h
TrackerGeomDet::localAlignmentError
LocalError const & localAlignmentError() const
Return local alligment error.
Definition: TrackerGeomDet.h:14
TrackStruct::HitParameterStruct::chargeAsymmetry
float chargeAsymmetry
Definition: EventVariables.h:88
TrackStruct::HitParameterStruct::chargeOnEdges
float chargeOnEdges
Definition: EventVariables.h:88
reco::HitPattern
Definition: HitPattern.h:147
TrackingRecHit.h
SiStripLorentzAngle
Definition: SiStripLorentzAngle.h:26
TrackStruct::HitParameterStruct::errXHitWoApe
float errXHitWoApe
Definition: EventVariables.h:93
funct::cos
Cos< T >::type cos(const T &t)
Definition: Cos.h:22
Track.h
ApeEstimator::minGoodHitsPerTrack_
const unsigned int minGoodHitsPerTrack_
Definition: ApeEstimator.cc:200
edm::EventSetup::get
T get() const
Definition: EventSetup.h:73
TrackerSectorStruct::WidthVsWidthProjected
TH2 * WidthVsWidthProjected
Definition: TrackerSectorStruct.h:81
DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:16
BeamSpot.h
TrackerDetectorStruct::HitsInvalid
TH1 * HitsInvalid
Definition: TrackerDetectorStruct.h:60
AlignmentTrackSelector_cfi.pMax
pMax
Definition: AlignmentTrackSelector_cfi.py:14
TrajectoryMeasurement::backwardPredictedState
TrajectoryStateOnSurface const & backwardPredictedState() const
Access to backward predicted state (from smoother)
Definition: TrajectoryMeasurement.h:179
ApeEstimator::m_hitSelectionUInt_
std::map< std::string, std::vector< unsigned int > > m_hitSelectionUInt_
Definition: ApeEstimator.cc:195
TrackerSectorStruct::PhiSensXVsBarycentreX
TH2 * PhiSensXVsBarycentreX
Definition: TrackerSectorStruct.h:81
TrackerSectorStruct::PPhiSensXVsBarycentreX
TProfile * PPhiSensXVsBarycentreX
Definition: TrackerSectorStruct.h:82
LocalError.h
SiStripClusterInfo::baryStrip
float baryStrip() const
Definition: SiStripClusterInfo.h:33
LocalError::xx
float xx() const
Definition: LocalError.h:22
ApeEstimator::m_resErrBins_
std::map< unsigned int, std::pair< double, double > > m_resErrBins_
Definition: ApeEstimator.cc:191
TrackerDetectorStruct::HitsStripVsEta
TH2 * HitsStripVsEta
Definition: TrackerDetectorStruct.h:64
TrajectoryStateOnSurface::localDirection
LocalVector localDirection() const
Definition: TrajectoryStateOnSurface.h:76
TrackerSectorStruct::ResX
TH1 * ResX
Definition: TrackerSectorStruct.h:80
Calorimetry_cff.thickness
thickness
Definition: Calorimetry_cff.py:114
Service.h
TrackerSectorStruct::PWidthVsPhiSensX
TProfile * PWidthVsPhiSensX
Definition: TrackerSectorStruct.h:82
TrajectoryMeasurement::forwardPredictedState
TrajectoryStateOnSurface const & forwardPredictedState() const
Access to forward predicted state (from fitter or builder)
Definition: TrajectoryMeasurement.h:177
MeasurementError
Definition: MeasurementError.h:8
TrackStruct
Definition: EventVariables.h:6
PixelGeomDetUnit
Definition: PixelGeomDetUnit.h:15
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
ApeEstimator::counter5
unsigned int counter5
Definition: ApeEstimator.cc:206
Surface::bounds
const Bounds & bounds() const
Definition: Surface.h:87
TrackStruct::TrackParameterStruct
Definition: EventVariables.h:98
TrackStruct::HitParameterStruct::resY
float resY
Definition: EventVariables.h:94
ReducedTrackerTreeVariables.h
TrackerDetectorStruct::HitsPixelVsTheta
TH2 * HitsPixelVsTheta
Definition: TrackerDetectorStruct.h:64
reco::BeamSpot
Definition: BeamSpot.h:21
TrackerDetectorStruct::PHitsStripVsTheta
TProfile * PHitsStripVsTheta
Definition: TrackerDetectorStruct.h:67
TrackerDetectorStruct::HitsPixel
TH1 * HitsPixel
Definition: TrackerDetectorStruct.h:60
reco::Track
Definition: Track.h:27
TrackStruct::v_hitParams
std::vector< HitParameterStruct > v_hitParams
Definition: EventVariables.h:134
IdealMagneticFieldRecord.h
ApeEstimator::checkModuleDirections
bool checkModuleDirections(const int, const std::vector< int > &) const
Definition: ApeEstimator.cc:495
edm::ESHandle< MagneticField >
TrackStruct::TrackParameterStruct::meanPhiSensToNorm
float meanPhiSensToNorm
Definition: EventVariables.h:129
TrackStruct::HitParameterStruct::errYWoApe
float errYWoApe
Definition: EventVariables.h:94
ProjectedSiStripRecHit2D::originalHit
SiStripRecHit2D originalHit() const
Definition: ProjectedSiStripRecHit2D.h:56
TrackStruct::HitParameterStruct::chargeStrip
unsigned int chargeStrip
Definition: EventVariables.h:86
TrackerDetectorStruct::LayersMissed
TH1 * LayersMissed
Definition: TrackerDetectorStruct.h:60
StripSubdetector::TIB
static constexpr auto TIB
Definition: StripSubdetector.h:16
RecoTauValidation_cfi.posX
posX
Definition: RecoTauValidation_cfi.py:288
ApeEstimator::rectangularPositionAndError2
PositionAndError2 rectangularPositionAndError2(const LocalPoint &, const LocalError &)
Definition: ApeEstimator.cc:1783
ApeEstimator::m_hitSelection_
std::map< std::string, std::vector< double > > m_hitSelection_
Definition: ApeEstimator.cc:194
Bounds.h
TrackStruct::negativeError
Definition: EventVariables.h:9
Point3DBase< float, LocalTag >
ReducedTrackerTreeVariables
Definition: ReducedTrackerTreeVariables.h:8
SiPixelRecHit::spansTwoROCs
bool spansTwoROCs() const
Definition: SiPixelRecHit.h:101
SiPixelRecHit.h
RadialStripTopology::angularWidth
virtual float angularWidth() const =0
RadialStripTopology::measurementPosition
MeasurementPoint measurementPosition(const LocalPoint &) const override=0
SiStripClusterInfo::chargeLR
std::pair< uint16_t, uint16_t > chargeLR() const
Definition: SiStripClusterInfo.cc:21
EDGetToken.h
TrackStruct::TrackParameterStruct::dzErr
float dzErr
Definition: EventVariables.h:129
TrajTrackAssociation.h
TrackStruct::HitParameterStruct::v_sector
std::vector< unsigned int > v_sector
Definition: EventVariables.h:71
TrackerSectorStruct::ProbX
TH1 * ProbX
Definition: TrackerSectorStruct.h:80
ReducedTrackerTreeVariables::subdetId
UInt_t subdetId
Definition: ReducedTrackerTreeVariables.h:17
TrackerSectorStruct::ResY
TH1 * ResY
Definition: TrackerSectorStruct.h:86
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
TrackStruct::TrackParameterStruct::phi
float phi
Definition: EventVariables.h:129
edm::LogWarning
Definition: MessageLogger.h:141
TFileService.h
ApeEstimator::tkDetector_
TrackerDetectorStruct tkDetector_
Definition: ApeEstimator.cc:185
SiStripClusterInfo::setCluster
void setCluster(const SiStripCluster &cluster, int detId)
Definition: SiStripClusterInfo.cc:16
TFileService::mkdir
TFileDirectory mkdir(const std::string &dir, const std::string &descr="")
create a new subdirectory
Definition: TFileService.h:69
edm::AssociationMap< edm::OneToOne< std::vector< Trajectory >, reco::TrackCollection, unsigned short > >::const_iterator
friend struct const_iterator
Definition: AssociationMap.h:274
SiStripLorentzAngleRcd.h
TrackerDetectorStruct::Ndof
TH1 * Ndof
Definition: TrackerDetectorStruct.h:60
GeomDet::geographicalId
DetId geographicalId() const
The label of this GeomDet.
Definition: GeomDet.h:64
Bounds::thickness
virtual float thickness() const =0
TrajectoryStateCombiner
Definition: TrajectoryStateCombiner.h:13
TrackStruct::HitParameterStruct::logClusterProbability
float logClusterProbability
Definition: EventVariables.h:81
TrajectoryStateOnSurface::localPosition
LocalPoint localPosition() const
Definition: TrajectoryStateOnSurface.h:74
ApeEstimator::StatePositionAndError2
std::pair< TrackStruct::HitState, PositionAndError2 > StatePositionAndError2
Definition: ApeEstimator.cc:139
HLT_2018_cff.InputTag
InputTag
Definition: HLT_2018_cff.py:79016
edm::ParameterSet
Definition: ParameterSet.h:36
math::XYZPoint
XYZPointD XYZPoint
point in space with cartesian internal representation
Definition: Point3D.h:12
edm::LogError
Definition: MessageLogger.h:183
TrackStruct::TrackParameterStruct::phiErr
float phiErr
Definition: EventVariables.h:129
edm::AssociationMap::size
size_type size() const
map size
Definition: AssociationMap.h:162
ApeEstimator::inDoubleInterval
bool inDoubleInterval(const std::vector< double > &, const float) const
Definition: ApeEstimator.cc:2167
DetId::Tracker
Definition: DetId.h:25
SiStripCluster.h
TrackStruct::TrackParameterStruct::dz
float dz
Definition: EventVariables.h:129
TrackStruct::HitParameterStruct::clusterProbabilityXYQ
float clusterProbabilityXYQ
Definition: EventVariables.h:81
TrackerSectorStruct::m_sigmaX
std::map< std::string, std::vector< TH1 * > > m_sigmaX
Definition: TrackerSectorStruct.h:84
ApeEstimator::parameterSet_
const edm::ParameterSet parameterSet_
Definition: ApeEstimator.cc:183
Event.h
TrackStruct::HitParameterStruct::chargePixel
float chargePixel
Definition: EventVariables.h:80
fastTrackerRecHitType::isPixel
bool isPixel(HitType hitType)
Definition: FastTrackerRecHit.h:37
ApeEstimator::counter2
unsigned int counter2
Definition: ApeEstimator.cc:206
LocalError
Definition: LocalError.h:12
edm::AssociationMap< edm::OneToOne< std::vector< Trajectory >, reco::TrackCollection, unsigned short > >
TrackerSectorStruct::XHit
TH1 * XHit
Definition: TrackerSectorStruct.h:80
PV2DBase::y
T y() const
Definition: PV2DBase.h:44
TrackStruct::HitParameterStruct::errXTrk
float errXTrk
Definition: EventVariables.h:93
ApeEstimator::fillHitVariables
TrackStruct::HitParameterStruct fillHitVariables(const TrajectoryMeasurement &, const edm::EventSetup &)
Definition: ApeEstimator.cc:1339
TrackStruct::HitParameterStruct::errY2
float errY2
Definition: EventVariables.h:94
RadialStripTopology::detHeight
virtual float detHeight() const =0
PV2DBase::x
T x() const
Definition: PV2DBase.h:43
TrackerDetectorStruct::PHitsGoodVsHitsValid
TProfile * PHitsGoodVsHitsValid
Definition: TrackerDetectorStruct.h:67
TrackStruct::HitParameterStruct::phiSensY
float phiSensY
Definition: EventVariables.h:95
ApeEstimator::PositionAndError2::errX2
float errX2
Definition: ApeEstimator.cc:136
RadialStripTopology::originToIntersection
virtual float originToIntersection() const =0
Definitions.h
PV3DBase::y
T y() const
Definition: PV3DBase.h:60
edm::Service< TFileService >
TrackerDetectorStruct::PtVsEta
TH2 * PtVsEta
Definition: TrackerDetectorStruct.h:64
createfilelist.int
int
Definition: createfilelist.py:10
TrackerDetectorStruct::Charge
TH1 * Charge
Definition: TrackerDetectorStruct.h:60
iEvent
int iEvent
Definition: GenABIO.cc:224
TrackStruct::TrackParameterStruct::chi2
float chi2
Definition: EventVariables.h:129
TrackStruct::HitParameterStruct::projWidth
float projWidth
Definition: EventVariables.h:90
TrackStruct::HitParameterStruct::errY
float errY
Definition: EventVariables.h:94
TrackStruct::HitParameterStruct::yHit
float yHit
Definition: EventVariables.h:94
muonRecoAnalyzer_cfi.chi2Max
chi2Max
Definition: muonRecoAnalyzer_cfi.py:35
ReducedTrackerTreeVariables::vDirection
Int_t vDirection
Definition: ReducedTrackerTreeVariables.h:18
ApeEstimator::hitSelection
void hitSelection()
Definition: ApeEstimator.cc:1827
TrackStruct::TrackParameterStruct::d0Beamspot
float d0Beamspot
Definition: EventVariables.h:129
TrackStruct::HitParameterStruct
Definition: EventVariables.h:11
M_PI
#define M_PI
Definition: BXVectorInputProducer.cc:50
MeasurementPoint.h
readEcalDQMStatus.interval
interval
Definition: readEcalDQMStatus.py:18
TrackStruct::HitParameterStruct::chargeLRminus
float chargeLRminus
Definition: EventVariables.h:88
TrackerDetectorStruct::Pt
TH1 * Pt
Definition: TrackerDetectorStruct.h:60
SiStripRecHit1D::cluster
ClusterRef cluster() const
Definition: SiStripRecHit1D.h:18
TrackerDetectorStruct::Chi2
TH1 * Chi2
Definition: TrackerDetectorStruct.h:60
LocalError::valid
bool valid() const
Definition: LocalError.h:20
ProjectedSiStripRecHit2D.h
DetId::Detector
Detector
Definition: DetId.h:24
MagneticField.h
edm::EventSetup
Definition: EventSetup.h:57
TrackingMonitor_cfi.pixelCluster
pixelCluster
Definition: TrackingMonitor_cfi.py:21
ApeEstimator::PositionAndError2::posY
float posY
Definition: ApeEstimator.cc:135
Topology::measurementPosition
virtual MeasurementPoint measurementPosition(const LocalPoint &) const =0
SiStripClusterInfo::maxCharge
uint8_t maxCharge() const
Definition: SiStripClusterInfo.h:44
GeomDet::specificSurface
const Plane & specificSurface() const
Same as surface(), kept for backward compatibility.
Definition: GeomDet.h:40
TrackStruct::HitParameterStruct::errX2
float errX2
Definition: EventVariables.h:93
SiStripRecHit1D
Definition: SiStripRecHit1D.h:8
TrackerDetectorStruct::TrkSize
TH1 * TrkSize
Definition: TrackerDetectorStruct.h:60
module
Definition: vlib.h:198
SiStripClusterInfo::charge
uint16_t charge() const
Definition: SiStripClusterInfo.h:43
TrackerSectorStruct::NorResY
TH1 * NorResY
Definition: TrackerSectorStruct.h:86
get
#define get
HitPattern.h
TrackerSectorStruct::m_sigmaY
std::map< std::string, std::vector< TH1 * > > m_sigmaY
Definition: TrackerSectorStruct.h:89
TrackerDetectorStruct::PhiSig
TH1 * PhiSig
Definition: TrackerDetectorStruct.h:60
TrackerDetectorStruct::EtaErr
TH1 * EtaErr
Definition: TrackerDetectorStruct.h:60
TrackerDetectorStruct::Eta
TH1 * Eta
Definition: TrackerDetectorStruct.h:60
SiPixelRecHit::qBin
int qBin() const
Definition: SiPixelRecHit.h:92
ApeEstimator::setHitSelectionMap
void setHitSelectionMap(const std::string &)
Definition: ApeEstimator.cc:1944
ApeEstimator::endJob
void endJob() override
Definition: ApeEstimator.cc:2680
TrackStruct::notAssignedToSectors
Definition: EventVariables.h:9
InputTag.h
Trajectory::measurements
DataContainer const & measurements() const
Definition: Trajectory.h:178
TrackStruct::HitParameterStruct::norResY
float norResY
Definition: EventVariables.h:94
me0TriggerPseudoDigis_cff.nStrips
nStrips
1.2 is to make the matching window safely the two nearest strips 0.35 is the size of an ME0 chamber i...
Definition: me0TriggerPseudoDigis_cff.py:26
TrackingRecHit
Definition: TrackingRecHit.h:21
SiStripRecHit1D.h
TrackerSectorStruct::NorResX
TH1 * NorResX
Definition: TrackerSectorStruct.h:80
TrackerSectorStruct::ProbY
TH1 * ProbY
Definition: TrackerSectorStruct.h:86
ApeEstimator::counter4
unsigned int counter4
Definition: ApeEstimator.cc:206
fftjetvertexadder_cfi.sigmaX
sigmaX
Definition: fftjetvertexadder_cfi.py:30
ApeEstimator::calculateAPE
void calculateAPE()
Definition: ApeEstimator.cc:2530
TrajectoryMeasurement::recHit
ConstRecHitPointer const & recHit() const
Definition: TrajectoryMeasurement.h:190
DDAxes::phi
TrackerDetectorStruct::TrkSizeGood
TH1 * TrkSizeGood
Definition: TrackerDetectorStruct.h:60
ApeEstimator::counter3
unsigned int counter3
Definition: ApeEstimator.cc:206
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
TrackerDetectorStruct::HitsGoodVsHitsValid
TH2 * HitsGoodVsHitsValid
Definition: TrackerDetectorStruct.h:64
SiStripLorentzAngle::getLorentzAngle
float getLorentzAngle(const uint32_t &) const
Definition: SiStripLorentzAngle.cc:15
ApeEstimator::sectorBuilder
void sectorBuilder()
Definition: ApeEstimator.cc:242
ApeEstimator::fillHitHistsYForAnalyzerMode
void fillHitHistsYForAnalyzerMode(const TrackStruct::HitParameterStruct &, TrackerSectorStruct &)
Definition: ApeEstimator.cc:2422
Trajectory.h
GloballyPositioned::position
const PositionType & position() const
Definition: GloballyPositioned.h:36
GeomDet.h
SiStripClusterInfo::initEvent
void initEvent(const edm::EventSetup &iSetup)
Definition: SiStripClusterInfo.cc:10
DependentRecordImplementation.h
ApeEstimator::maxTracksPerEvent_
const unsigned int maxTracksPerEvent_
Definition: ApeEstimator.cc:199
taus_updatedMVAIds_cff.variable
variable
Definition: taus_updatedMVAIds_cff.py:32
std
Definition: JetResolutionObject.h:76
DetId::rawId
constexpr uint32_t rawId() const
get the raw id
Definition: DetId.h:57
TrackStruct::HitParameterStruct::xTrk
float xTrk
Definition: EventVariables.h:93
ApeEstimator::checkIntervalsForSectors
bool checkIntervalsForSectors(const unsigned int sectorCounter, const std::vector< double > &) const
Definition: ApeEstimator.cc:447
fftjetvertexadder_cfi.sigmaY
sigmaY
Definition: fftjetvertexadder_cfi.py:31
TrackerDetectorStruct::NorChi2
TH1 * NorChi2
Definition: TrackerDetectorStruct.h:60
TrackerDetectorStruct::HitsPixelVsEta
TH2 * HitsPixelVsEta
Definition: TrackerDetectorStruct.h:64
TrackerDetectorStruct::D0Beamspot
TH1 * D0Beamspot
Definition: TrackerDetectorStruct.h:60
StripSubdetector::TEC
static constexpr auto TEC
Definition: StripSubdetector.h:19
ApeEstimator::PositionAndError2::errY2
float errY2
Definition: ApeEstimator.cc:137
TrackStruct::TrackParameterStruct::theta
float theta
Definition: EventVariables.h:129
ApeEstimator::setHitSelectionMapUInt
void setHitSelectionMapUInt(const std::string &)
Definition: ApeEstimator.cc:1959
Calorimetry_cff.bField
bField
Definition: Calorimetry_cff.py:292
SiStripClusterInfo::IsModuleUsable
bool IsModuleUsable() const
Definition: SiStripClusterInfo.cc:112
DetId.h
Trajectory
Definition: Trajectory.h:38
Frameworkfwd.h
TrackStruct::HitParameterStruct::maxIndex
unsigned int maxIndex
Definition: EventVariables.h:87
ApeEstimator::bookSectorHistsForApeCalculation
void bookSectorHistsForApeCalculation()
Definition: ApeEstimator.cc:1069
TrackerSectorStruct::v_rawId
std::vector< unsigned int > v_rawId
Definition: TrackerSectorStruct.h:78
ApeEstimator::radialPositionAndError2
PositionAndError2 radialPositionAndError2(const LocalPoint &, const LocalError &, const RadialStripTopology &)
Definition: ApeEstimator.cc:1792
LocalPoint.h
relativeConstraints.empty
bool empty
Definition: relativeConstraints.py:46
ApeEstimator::PositionAndError2::PositionAndError2
PositionAndError2()
Definition: ApeEstimator.cc:132
ApeEstimator::PositionAndError2
Definition: ApeEstimator.cc:131
TrackStruct::HitParameterStruct::resX
float resX
Definition: EventVariables.h:93
Exception
Definition: hltDiff.cc:246
TrackStruct::HitParameterStruct::isPixelHit
bool isPixelHit
Definition: EventVariables.h:69
TrackStruct::HitParameterStruct::maxStrip
unsigned int maxStrip
Definition: EventVariables.h:87
GeomDetType::topology
virtual const Topology & topology() const =0
edm::AssociationMap::begin
const_iterator begin() const
first iterator over the map (read only)
Definition: AssociationMap.h:169
ConstTrajTrackPair
std::pair< const Trajectory *, const reco::Track * > ConstTrajTrackPair
Definition: AlignmentAlgorithmBase.h:51
TrackerSectorStruct.h
SiStripLorentzAngleDepRcd
Definition: SiStripDependentRecords.h:40
align::Strip
Definition: StructureType.h:69
PixelGeomDetUnit.h
ApeEstimator::counter6
unsigned int counter6
Definition: ApeEstimator.cc:206
TrackerSectorStruct::PWidthVsWidthProjected
TProfile * PWidthVsWidthProjected
Definition: TrackerSectorStruct.h:82
relativeConstraints.ring
ring
Definition: relativeConstraints.py:68
TrackerSectorStruct::YTrk
TH1 * YTrk
Definition: TrackerSectorStruct.h:86
toLocal
LocalVector toLocal(const reco::Track::Vector &v, const Surface &s)
Definition: ConversionProducer.h:192
ApeEstimator::inUintInterval
bool inUintInterval(const std::vector< unsigned int > &, const unsigned int, const unsigned int=999) const
Definition: ApeEstimator.cc:2181
TrackerSectorStruct::WidthDiffVsSigmaXHit
TH2 * WidthDiffVsSigmaXHit
Definition: TrackerSectorStruct.h:81
StripSubdetector::TOB
static constexpr auto TOB
Definition: StripSubdetector.h:18
TrackerSectorStruct::XTrk
TH1 * XTrk
Definition: TrackerSectorStruct.h:80
TrackStruct::HitParameterStruct::hasBadPixels
bool hasBadPixels
Definition: EventVariables.h:82
TrackStruct::HitParameterStruct::phiSens
float phiSens
Definition: EventVariables.h:95
Point3D.h
EventSetup.h
multiplicitycorr_cfi.xMax
xMax
Definition: multiplicitycorr_cfi.py:5
ApeEstimator::analyzerMode_
const bool analyzerMode_
Definition: ApeEstimator.cc:202
TrackStruct::ok
Definition: EventVariables.h:9
TrackerDetectorStruct::MeanAngleVsHits
TH2 * MeanAngleVsHits
Definition: TrackerDetectorStruct.h:64
align::Pixel
Definition: StructureType.h:68
TrackStruct::HitParameterStruct::goodYMeasurement
bool goodYMeasurement
Definition: EventVariables.h:70
TrackStruct::HitParameterStruct::isModuleUsable
bool isModuleUsable
Definition: EventVariables.h:85
hgcalTestNeighbor_cfi.detector
detector
Definition: hgcalTestNeighbor_cfi.py:6
RadialStripTopology::stripAngle
float stripAngle(float strip) const override=0
MeasurementError::vv
float vv() const
Definition: MeasurementError.h:16
HLT_2018_cff.track
track
Definition: HLT_2018_cff.py:10352
ApeEstimator::PositionAndError2::posX
float posX
Definition: ApeEstimator.cc:133
funct::pow
Power< A, B >::type pow(const A &a, const B &b)
Definition: Power.h:30
TrackStruct::HitParameterStruct::xHit
float xHit
Definition: EventVariables.h:93
ApeEstimator::m_tkTreeVar_
std::map< unsigned int, ReducedTrackerTreeVariables > m_tkTreeVar_
Definition: ApeEstimator.cc:192
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
ApeEstimator::bookTrackHists
void bookTrackHists()
Definition: ApeEstimator.cc:1164
MeasurementError::uu
float uu() const
Definition: MeasurementError.h:14
TrackerDetectorStruct::PtErr
TH1 * PtErr
Definition: TrackerDetectorStruct.h:60
ApeEstimator::isHit2D
bool isHit2D(const TrackingRecHit &) const
Definition: ApeEstimator.cc:2551
TrackStruct::TrackParameterStruct::norChi2
float norChi2
Definition: EventVariables.h:129
ParameterSet.h
SiStripDetId
Detector identifier class for the strip tracker.
Definition: SiStripDetId.h:18
TrackStruct::TrackParameterStruct::charge
int charge
Definition: EventVariables.h:128
TrackStruct::TrackParameterStruct::etaErr
float etaErr
Definition: EventVariables.h:129
SiStripMatchedRecHit2D.h
RadialStripTopology::localStripLength
float localStripLength(const LocalPoint &) const override=0
TrackStruct::TrackParameterStruct::hitsStrip
int hitsStrip
Definition: EventVariables.h:128
TrackerDetectorStruct::HitsGood
TH1 * HitsGood
Definition: TrackerDetectorStruct.h:60
TrackerDetectorStruct.h
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:70
StripCPE.h
TrackerSectorStruct::m_correlationHistsX
std::map< std::string, CorrelationHists > m_correlationHistsX
Definition: TrackerSectorStruct.h:70
TrackerDetectorStruct::PhiErr
TH1 * PhiErr
Definition: TrackerDetectorStruct.h:60
SiStripLorentzAngle.h
edm::Event
Definition: Event.h:73
TrackStruct::HitParameterStruct::clusterProbabilityXY
float clusterProbabilityXY
Definition: EventVariables.h:81
LocalVector.h
TrackerSectorStruct::PPhiSensYVsBarycentreY
TProfile * PPhiSensYVsBarycentreY
Definition: TrackerSectorStruct.h:88
TrajectoryStateOnSurface::localError
const LocalTrajectoryError & localError() const
Definition: TrajectoryStateOnSurface.h:77
MagneticField
Definition: MagneticField.h:19
TrackerSectorStruct::name
std::string name
Definition: TrackerSectorStruct.h:74
SiStripClusterInfo::signalOverNoise
float signalOverNoise() const
Definition: SiStripClusterInfo.h:53
TrajectoryMeasurement
Definition: TrajectoryMeasurement.h:25
ApeEstimator::checkModulePositions
bool checkModulePositions(const float, const std::vector< double > &) const
Definition: ApeEstimator.cc:505
SiStripCluster
Definition: SiStripCluster.h:9
TrackStruct::TrackParameterStruct::eta
float eta
Definition: EventVariables.h:129
TrackStruct::HitParameterStruct::errXWoApe
float errXWoApe
Definition: EventVariables.h:93
SiStripRecHit2D.h
StripTopology
Definition: StripTopology.h:11
edm::errors::Configuration
Definition: EDMException.h:36
ApeEstimator::siStripClusterInfo_
SiStripClusterInfo siStripClusterInfo_
Definition: ApeEstimator.cc:186
StripSubdetector.h
fftjetvertexadder_cfi.errX
errX
Definition: fftjetvertexadder_cfi.py:37
LocalError::yy
float yy() const
Definition: LocalError.h:24
SiPixelRecHit::clusterProbability
float clusterProbability(unsigned int flags=0) const
Definition: SiPixelRecHit.cc:9
SiPixelRecHit::hasBadPixels
bool hasBadPixels() const
Definition: SiPixelRecHit.h:99
TrackerDetectorStruct::PHitsStripVsEta
TProfile * PHitsStripVsEta
Definition: TrackerDetectorStruct.h:67
ApeEstimator
Definition: ApeEstimator.cc:125
TrackStruct::HitParameterStruct::baryStripY
float baryStripY
Definition: EventVariables.h:79
TrackerSectorStruct::WidthDiffVsMaxStrip
TH2 * WidthDiffVsMaxStrip
Definition: TrackerSectorStruct.h:81
StripSubdetector::TID
static constexpr auto TID
Definition: StripSubdetector.h:17
RecoTauValidation_cfi.posY
posY
Definition: RecoTauValidation_cfi.py:289
TrackerSectorStruct::SigmaX2
TH1 * SigmaX2
Definition: TrackerSectorStruct.h:80
TrackerDetectorStruct::PHitsPixelVsEta
TProfile * PHitsPixelVsEta
Definition: TrackerDetectorStruct.h:67
hit
Definition: SiStripHitEffFromCalibTree.cc:88
TrackerDetectorStruct::HitsStrip
TH1 * HitsStrip
Definition: TrackerDetectorStruct.h:60
TrackerDetectorStruct::PHitsPixelVsTheta
TProfile * PHitsPixelVsTheta
Definition: TrackerDetectorStruct.h:67
TrackStruct::TrackParameterStruct::hitsSize
int hitsSize
Definition: EventVariables.h:128
TrackStruct::HitParameterStruct::errXHit
float errXHit
Definition: EventVariables.h:93
SiStripDetId::stereo
uint32_t stereo() const
Definition: SiStripDetId.h:168
TrackStruct::HitParameterStruct::baryStripX
float baryStripX
Definition: EventVariables.h:76
ApeEstimator::calculateApe_
const bool calculateApe_
Definition: ApeEstimator.cc:204
ApeEstimator::fillHistsForAnalyzerMode
void fillHistsForAnalyzerMode(const TrackStruct &)
Definition: ApeEstimator.cc:2201
StripGeomDetUnit
Definition: StripGeomDetUnit.h:15
TrackerSectorStruct::isPixel
bool isPixel
Definition: TrackerSectorStruct.h:102
TrackerSectorStruct
Definition: TrackerSectorStruct.h:25
ApeEstimator::bookSectorHistsForAnalyzerMode
void bookSectorHistsForAnalyzerMode()
Definition: ApeEstimator.cc:592
TrackStruct::HitParameterStruct::yTrk
float yTrk
Definition: EventVariables.h:94
TrackerDetectorStruct::Phi
TH1 * Phi
Definition: TrackerDetectorStruct.h:60
ApeEstimator::checkModuleBools
bool checkModuleBools(const bool, const std::vector< unsigned int > &) const
Definition: ApeEstimator.cc:483
TrackerSectorStruct::m_correlationHistsY
std::map< std::string, CorrelationHists > m_correlationHistsY
Definition: TrackerSectorStruct.h:71
SiPixelRecHit::isOnEdge
bool isOnEdge() const
Definition: SiPixelRecHit.h:97
Generated for CMSSW Reference Manual by doxygen 1.8.16