CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
TrackerDpgAnalysis.cc
Go to the documentation of this file.
1 // -*- C++ -*-
2 //
3 // Package: DPGAnalysis
4 // Class: TrackerDpgAnalysis
5 //
13 //
14 // Original Author: Christophe DELAERE
15 // Created: Tue Sep 23 02:11:44 CEST 2008
16 // Revised: Thu Nov 26 10:00:00 CEST 2009
17 // part of the code was inspired by http://cmssw.cvs.cern.ch/cgi-bin/cmssw.cgi/UserCode/YGao/LhcTrackAnalyzer/
18 // part of the code was inspired by
19 // other inputs from Andrea Giammanco, Gaelle Boudoul, Andrea Venturi, Steven Lowette, Gavril Giurgiu
20 // $Id: TrackerDpgAnalysis.cc,v 1.8 2010/07/27 15:14:31 delaer Exp $
21 //
22 //
23 
24 // system include files
25 #include <memory>
26 #include <iostream>
27 #include <limits>
28 #include <utility>
29 #include <vector>
30 #include <algorithm>
31 #include <functional>
32 #include <string.h>
33 #include <sstream>
34 #include <fstream>
35 
36 // root include files
37 #include "TTree.h"
38 #include "TFile.h"
39 
40 // user include files
41 #include "FWCore/Framework/interface/Frameworkfwd.h"
42 #include "FWCore/Framework/interface/EDAnalyzer.h"
43 #include "FWCore/Framework/interface/Event.h"
44 #include "FWCore/Framework/interface/MakerMacros.h"
45 #include "FWCore/Framework/interface/ESHandle.h"
46 #include "FWCore/Utilities/interface/InputTag.h"
47 #include "FWCore/ParameterSet/interface/ParameterSet.h"
48 #include "FWCore/ServiceRegistry/interface/Service.h"
49 #include "CommonTools/UtilAlgos/interface/TFileService.h"
50 #include "CommonTools/TrackerMap/interface/TrackerMap.h"
51 #include <CondFormats/SiStripObjects/interface/FedChannelConnection.h>
52 #include <CondFormats/SiStripObjects/interface/SiStripFedCabling.h>
53 #include <CondFormats/DataRecord/interface/SiStripFedCablingRcd.h>
54 #include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h"
55 #include "Geometry/Records/interface/TrackerDigiGeometryRecord.h"
56 #include "Geometry/CommonDetUnit/interface/GeomDetType.h"
57 #include "Geometry/CommonDetUnit/interface/GeomDetUnit.h"
58 #include <Geometry/CommonTopologies/interface/Topology.h>
59 #include <Geometry/CommonTopologies/interface/StripTopology.h>
60 #include <Geometry/TrackerGeometryBuilder/interface/PixelGeomDetUnit.h>
61 #include <Geometry/CommonTopologies/interface/PixelTopology.h>
62 #include "DataFormats/Common/interface/Ref.h"
63 #include "DataFormats/Common/interface/EDProduct.h"
64 #include "DataFormats/DetId/interface/DetId.h"
65 #include "DataFormats/SiStripCluster/interface/SiStripCluster.h"
66 #include "DataFormats/TrackerRecHit2D/interface/SiStripRecHit2DCollection.h"
67 #include "DataFormats/TrackerRecHit2D/interface/SiStripMatchedRecHit2DCollection.h"
68 #include "DataFormats/GeometryVector/interface/LocalVector.h"
69 #include "DataFormats/SiStripCommon/interface/SiStripEventSummary.h"
70 #include <DataFormats/TrackerRecHit2D/interface/SiPixelRecHit.h>
71 #include <DataFormats/SiStripDetId/interface/SiStripDetId.h>
72 #include <DataFormats/SiStripDetId/interface/TIBDetId.h>
73 #include <DataFormats/SiStripDetId/interface/TIDDetId.h>
74 #include <DataFormats/SiStripDetId/interface/TOBDetId.h>
75 #include <DataFormats/SiStripDetId/interface/TECDetId.h>
76 #include <DataFormats/SiPixelCluster/interface/SiPixelCluster.h>
77 #include <DataFormats/TrackReco/interface/TrackFwd.h>
78 #include <DataFormats/TrackReco/interface/Track.h>
79 #include "DataFormats/TrackReco/interface/DeDxData.h"
80 #include <DataFormats/TrackerRecHit2D/interface/SiTrackerMultiRecHit.h>
81 #include <DataFormats/TrackerRecHit2D/interface/SiStripRecHit2D.h>
82 #include <DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerReadoutRecord.h>
83 #include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerReadoutSetupFwd.h"
84 #include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerReadoutSetup.h"
85 #include <DataFormats/L1GlobalTrigger/interface/L1GtFdlWord.h>
86 #include <DataFormats/Common/interface/TriggerResults.h>
87 #include "DataFormats/VertexReco/interface/Vertex.h"
88 #include "DataFormats/VertexReco/interface/VertexFwd.h"
89 #include "DataFormats/BeamSpot/interface/BeamSpot.h"
90 #include "HLTrigger/HLTcore/interface/HLTConfigProvider.h"
91 #include <MagneticField/Engine/interface/MagneticField.h>
92 #include <MagneticField/Records/interface/IdealMagneticFieldRecord.h>
93 #include <RecoTracker/TransientTrackingRecHit/interface/TSiStripRecHit2DLocalPos.h>
94 #include <RecoTracker/TransientTrackingRecHit/interface/TSiTrackerMultiRecHit.h>
95 #include <RecoTracker/TransientTrackingRecHit/interface/TSiPixelRecHit.h>
96 #include <RecoTracker/TransientTrackingRecHit/interface/TSiStripRecHit1D.h>
97 #include "RecoVertex/VertexPrimitives/interface/TransientVertex.h"
98 #include <TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHit.h>
99 #include <TrackingTools/PatternTools/interface/Trajectory.h>
100 #include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h"
101 #include "TrackingTools/PatternTools/interface/TrajTrackAssociation.h"
102 #include <RecoLocalTracker/SiStripClusterizer/interface/SiStripClusterInfo.h>
103 
104 // topology
105 #include "DPGAnalysis/SiStripTools/interface/EventShape.h"
106 
107 //
108 // class decleration
109 //
110 typedef math::XYZPoint Point;
111 
112 class TrackerDpgAnalysis : public edm::EDAnalyzer {
113  public:
114  explicit TrackerDpgAnalysis(const edm::ParameterSet&);
115  ~TrackerDpgAnalysis();
116 
117  protected:
118  std::vector<double> onTrackAngles(edm::Handle<edmNew::DetSetVector<SiStripCluster> >&,const std::vector<Trajectory>& );
119  void insertMeasurement(std::multimap<const uint32_t,std::pair<LocalPoint,double> >&, const TransientTrackingRecHit*,double);
120  std::vector<int> onTrack(edm::Handle<edmNew::DetSetVector<SiStripCluster> >&,const reco::TrackCollection&, uint32_t );
121  void insertMeasurement(std::multimap<const uint32_t,std::pair<int,int> >&, const TrackingRecHit*,int);
122  std::map<size_t,int> inVertex(const reco::TrackCollection&, const reco::VertexCollection&, uint32_t);
123  std::vector<std::pair<double,double> > onTrackAngles(edm::Handle<edmNew::DetSetVector<SiPixelCluster> >&,const std::vector<Trajectory>& );
124  void insertMeasurement(std::multimap<const uint32_t,std::pair<LocalPoint,std::pair<double,double> > >&, const TransientTrackingRecHit*,double,double);
125  std::vector<int> onTrack(edm::Handle<edmNew::DetSetVector<SiPixelCluster> >&,const reco::TrackCollection&, uint32_t );
126  void insertMeasurement(std::multimap<const uint32_t,std::pair<std::pair<float, float>,int> >&, const TrackingRecHit*,int);
127  std::string toStringName(uint32_t);
128  std::string toStringId(uint32_t);
129  double sumPtSquared(const reco::Vertex&);
130  float delay(const SiStripEventSummary&);
131  std::map<uint32_t,float> delay(const std::vector<std::string>&);
132 
133  private:
134  virtual void beginRun(const edm::Run&, const edm::EventSetup&);
135  virtual void analyze(const edm::Event&, const edm::EventSetup&);
136  virtual void endJob() ;
137 
138  // ----------member data ---------------------------
139  static const int nMaxPVs_ = 50;
140  edm::InputTag clusterLabel_, pixelclusterLabel_, dedx1Label_, dedx2Label_, dedx3Label_, pixelVertexLabel_,
141  vertexLabel_, bsLabel_, L1Label_, HLTLabel_;
142  std::vector<edm::InputTag> trackLabel_;
143  edm::ESHandle<SiStripFedCabling> cabling_;
144  edm::ESHandle<TrackerGeometry> tracker_;
145  std::multimap<const uint32_t,const FedChannelConnection*> connections_;
146  bool functionality_offtrackClusters_, functionality_ontrackClusters_, functionality_pixclusters_, functionality_pixvertices_,
147  functionality_missingHits_, functionality_tracks_, functionality_vertices_, functionality_events_;
148  TTree* clusters_;
149  TTree* pixclusters_;
150  std::vector<TTree*> tracks_;
151  std::vector<TTree*> missingHits_;
152  TTree* vertices_;
153  TTree* pixelVertices_;
154  TTree* event_;
155  TTree* psumap_;
156  TTree* readoutmap_;
157  bool onTrack_;
158  uint32_t vertexid_, eventid_, runid_;
159  uint32_t globalvertexid_;
160  uint32_t *globaltrackid_, *trackid_;
161  float globalX_, globalY_, globalZ_;
162  float measX_, measY_, errorX_, errorY_;
163  float angle_, maxCharge_;
164  float clCorrectedCharge_, clCorrectedSignalOverNoise_;
165  float clNormalizedCharge_, clNormalizedNoise_, clSignalOverNoise_;
166  float clBareNoise_, clBareCharge_;
167  float clWidth_, clPosition_, thickness_, stripLength_, distance_;
168  float eta_, phi_, chi2_;
169  float dedx1_, dedx2_, dedx3_;
170  uint32_t detid_, dcuId_, type_;
171  uint16_t fecCrate_, fecSlot_, fecRing_, ccuAdd_, ccuChan_, lldChannel_, fedId_, fedCh_, fiberLength_;
172  uint32_t nclusters_, npixClusters_, nclustersOntrack_, npixClustersOntrack_, dedxNoM_, quality_, foundhits_, lostHits_, ndof_;
173  uint32_t *ntracks_, *ntrajs_;
174  float *lowPixelProbabilityFraction_;
175  uint32_t nVertices_, nPixelVertices_, nLayers_,foundhitsStrips_,foundhitsPixels_,losthitsStrips_,losthitsPixels_;
176  uint32_t nTracks_pvtx_;
177  uint32_t clSize_, clSizeX_, clSizeY_;
178  float fBz_, clPositionX_, clPositionY_, alpha_, beta_, chargeCorr_;
179  float recx_pvtx_, recy_pvtx_, recz_pvtx_,
180  recx_err_pvtx_, recy_err_pvtx_, recz_err_pvtx_, sumptsq_pvtx_;
181  float pterr_, etaerr_, phierr_;
182  float dz_, dzerr_, dzCorr_, dxy_, dxyerr_, dxyCorr_;
183  float qoverp_, xPCA_, yPCA_, zPCA_, trkWeightpvtx_;
184  bool isValid_pvtx_, isFake_pvtx_;
185  float charge_, p_, pt_;
186  float bsX0_, bsY0_, bsZ0_, bsSigmaZ_, bsDxdz_, bsDydz_;
187  float thrustValue_, thrustX_, thrustY_, thrustZ_, sphericity_, planarity_, aplanarity_, delay_;
188  bool L1DecisionBits_[192], L1TechnicalBits_[64], HLTDecisionBits_[256];
189  uint32_t orbit_, orbitL1_, bx_, store_, time_;
190  uint16_t lumiSegment_, physicsDeclared_;
191  char *moduleName_, *moduleId_, *PSUname_;
192  std::string cablingFileName_;
193  std::vector<std::string> delayFileNames_;
194  edm::ParameterSet pset_;
195  std::vector<std::string> hlNames_; // name of each HLT algorithm
196  HLTConfigProvider hltConfig_; // to get configuration for L1s/Pre
197 
198 };
199 
200 //
201 // constructors and destructor
202 //
203 TrackerDpgAnalysis::TrackerDpgAnalysis(const edm::ParameterSet& iConfig):hltConfig_()
204 {
205  // members
206  moduleName_ = new char[256];
207  moduleId_ = new char[256];
208  PSUname_ = new char[256];
209  pset_ = iConfig;
210 
211  // enable/disable functionalities
212  functionality_offtrackClusters_ = iConfig.getUntrackedParameter<bool>("keepOfftrackClusters",true);
213  functionality_ontrackClusters_ = iConfig.getUntrackedParameter<bool>("keepOntrackClusters",true);
214  functionality_pixclusters_ = iConfig.getUntrackedParameter<bool>("keepPixelClusters",true);
215  functionality_pixvertices_ = iConfig.getUntrackedParameter<bool>("keepPixelVertices",true);
216  functionality_missingHits_ = iConfig.getUntrackedParameter<bool>("keepMissingHits",true);
217  functionality_tracks_ = iConfig.getUntrackedParameter<bool>("keepTracks",true);
218  functionality_vertices_ = iConfig.getUntrackedParameter<bool>("keepVertices",true);
219  functionality_events_ = iConfig.getUntrackedParameter<bool>("keepEvents",true);
220 
221  // parameters
222  clusterLabel_ = iConfig.getParameter<edm::InputTag>("ClustersLabel");
223  pixelclusterLabel_ = iConfig.getParameter<edm::InputTag>("PixelClustersLabel");
224  trackLabel_ = iConfig.getParameter<std::vector<edm::InputTag> >("TracksLabel");
225  dedx1Label_ = iConfig.getParameter<edm::InputTag>("DeDx1Label");
226  dedx2Label_ = iConfig.getParameter<edm::InputTag>("DeDx2Label");
227  dedx3Label_ = iConfig.getParameter<edm::InputTag>("DeDx3Label");
228  vertexLabel_ = iConfig.getParameter<edm::InputTag>("vertexLabel");
229  pixelVertexLabel_ = iConfig.getParameter<edm::InputTag>("pixelVertexLabel");
230  bsLabel_ = iConfig.getParameter<edm::InputTag>("beamSpotLabel");
231  L1Label_ = iConfig.getParameter<edm::InputTag>("L1Label");
232  HLTLabel_ = iConfig.getParameter<edm::InputTag>("HLTLabel");
233 
234  // initialize arrays
235  ntracks_ = new uint32_t[trackLabel_.size()];
236  ntrajs_ = new uint32_t[trackLabel_.size()];
237  globaltrackid_ = new uint32_t[trackLabel_.size()];
238  trackid_ = new uint32_t[trackLabel_.size()];
239  lowPixelProbabilityFraction_ = new float[trackLabel_.size()];
240  globalvertexid_ = iConfig.getParameter<uint32_t>("InitalCounter");
241  for(size_t i = 0; i<trackLabel_.size();++i) {
242  ntracks_[i]=0;
243  ntrajs_[i]=0;
244  globaltrackid_[i]=iConfig.getParameter<uint32_t>("InitalCounter");
245  trackid_[i]=0;
246  lowPixelProbabilityFraction_[i]=0;
247  }
248 
249  // create output
250  edm::Service<TFileService> fileService;
251  TFileDirectory* dir = new TFileDirectory(fileService->mkdir("trackerDPG"));
252 
253  // create a TTree for clusters
254  clusters_ = dir->make<TTree>("clusters","cluster information");
255  clusters_->Branch("eventid",&eventid_,"eventid/i");
256  clusters_->Branch("runid",&runid_,"runid/i");
257  for(size_t i = 0; i<trackLabel_.size(); ++i) {
258  char buffer1[256];
259  char buffer2[256];
260  sprintf(buffer1,"trackid%lu",(unsigned long)i);
261  sprintf(buffer2,"trackid%lu/i",(unsigned long)i);
262  clusters_->Branch(buffer1,trackid_+i,buffer2);
263  }
264  clusters_->Branch("onTrack",&onTrack_,"onTrack/O");
265  clusters_->Branch("clWidth",&clWidth_,"clWidth/F");
266  clusters_->Branch("clPosition",&clPosition_,"clPosition/F");
267  clusters_->Branch("clglobalX",&globalX_,"clglobalX/F");
268  clusters_->Branch("clglobalY",&globalY_,"clglobalY/F");
269  clusters_->Branch("clglobalZ",&globalZ_,"clglobalZ/F");
270  clusters_->Branch("angle",&angle_,"angle/F");
271  clusters_->Branch("thickness",&thickness_,"thickness/F");
272  clusters_->Branch("maxCharge",&maxCharge_,"maxCharge/F");
273  clusters_->Branch("clNormalizedCharge",&clNormalizedCharge_,"clNormalizedCharge/F");
274  clusters_->Branch("clNormalizedNoise",&clNormalizedNoise_,"clNormalizedNoise/F");
275  clusters_->Branch("clSignalOverNoise",&clSignalOverNoise_,"clSignalOverNoise/F");
276  clusters_->Branch("clCorrectedCharge",&clCorrectedCharge_,"clCorrectedCharge/F");
277  clusters_->Branch("clCorrectedSignalOverNoise",&clCorrectedSignalOverNoise_,"clCorrectedSignalOverNoise/F");
278  clusters_->Branch("clBareCharge",&clBareCharge_,"clBareCharge/F");
279  clusters_->Branch("clBareNoise",&clBareNoise_,"clBareNoise/F");
280  clusters_->Branch("stripLength",&stripLength_,"stripLength/F");
281  clusters_->Branch("detid",&detid_,"detid/i");
282  clusters_->Branch("lldChannel",&lldChannel_,"lldChannel/s");
283 
284  // create a TTree for pixel clusters
285  pixclusters_ = dir->make<TTree>("pixclusters","pixel cluster information");
286  pixclusters_->Branch("eventid",&eventid_,"eventid/i");
287  pixclusters_->Branch("runid",&runid_,"runid/i");
288  for(size_t i = 0; i<trackLabel_.size(); ++i) {
289  char buffer1[256];
290  char buffer2[256];
291  sprintf(buffer1,"trackid%lu",(unsigned long)i);
292  sprintf(buffer2,"trackid%lu/i",(unsigned long)i);
293  pixclusters_->Branch(buffer1,trackid_+i,buffer2);
294  }
295  pixclusters_->Branch("onTrack",&onTrack_,"onTrack/O");
296  pixclusters_->Branch("clPositionX",&clPositionX_,"clPositionX/F");
297  pixclusters_->Branch("clPositionY",&clPositionY_,"clPositionY/F");
298  pixclusters_->Branch("clSize",&clSize_,"clSize/i");
299  pixclusters_->Branch("clSizeX",&clSizeX_,"clSizeX/i");
300  pixclusters_->Branch("clSizeY",&clSizeY_,"clSizeY/i");
301  pixclusters_->Branch("alpha",&alpha_,"alpha/F");
302  pixclusters_->Branch("beta",&beta_,"beta/F");
303  pixclusters_->Branch("charge",&charge_,"charge/F");
304  pixclusters_->Branch("chargeCorr",&chargeCorr_,"chargeCorr/F");
305  pixclusters_->Branch("clglobalX",&globalX_,"clglobalX/F");
306  pixclusters_->Branch("clglobalY",&globalY_,"clglobalY/F");
307  pixclusters_->Branch("clglobalZ",&globalZ_,"clglobalZ/F");
308  pixclusters_->Branch("detid",&detid_,"detid/i");
309 
310  // create a tree for tracks
311  for(size_t i = 0; i<trackLabel_.size(); ++i) {
312  char buffer1[256];
313  char buffer2[256];
314  sprintf(buffer1,"tracks%lu",(unsigned long)i);
315  sprintf(buffer2,"track%lu information",(unsigned long)i);
316  TTree* thetracks_ = dir->make<TTree>(buffer1,buffer2);
317  sprintf(buffer1,"trackid%lu",(unsigned long)i);
318  sprintf(buffer2,"trackid%lu/i",(unsigned long)i);
319  thetracks_->Branch(buffer1,globaltrackid_+i,buffer2);
320  thetracks_->Branch("eventid",&eventid_,"eventid/i");
321  thetracks_->Branch("runid",&runid_,"runid/i");
322  thetracks_->Branch("chi2",&chi2_,"chi2/F");
323  thetracks_->Branch("eta",&eta_,"eta/F");
324  thetracks_->Branch("etaerr",&etaerr_,"etaerr/F");
325  thetracks_->Branch("phi",&phi_,"phi/F");
326  thetracks_->Branch("phierr",&phierr_,"phierr/F");
327  thetracks_->Branch("dedx1",&dedx1_,"dedx1/F");
328  thetracks_->Branch("dedx2",&dedx2_,"dedx2/F");
329  thetracks_->Branch("dedx3",&dedx3_,"dedx3/F");
330  thetracks_->Branch("dedxNoM",&dedxNoM_,"dedxNoM/i");
331  thetracks_->Branch("charge",&charge_,"charge/F");
332  thetracks_->Branch("quality",&quality_,"quality/i");
333  thetracks_->Branch("foundhits",&foundhits_,"foundhits/i");
334  thetracks_->Branch("lostHits",&lostHits_,"lostHits/i");
335  thetracks_->Branch("foundhitsStrips",&foundhitsStrips_,"foundhitsStrips/i");
336  thetracks_->Branch("foundhitsPixels",&foundhitsPixels_,"foundhitsPixels/i");
337  thetracks_->Branch("losthitsStrips",&losthitsStrips_,"losthitsStrips/i");
338  thetracks_->Branch("losthitsPixels",&losthitsPixels_,"losthitsPixels/i");
339  thetracks_->Branch("p",&p_,"p/F");
340  thetracks_->Branch("pt",&pt_,"pt/F");
341  thetracks_->Branch("pterr",&pterr_,"pterr/F");
342  thetracks_->Branch("ndof",&ndof_,"ndof/i");
343  thetracks_->Branch("dz",&dz_,"dz/F");
344  thetracks_->Branch("dzerr",&dzerr_,"dzerr/F");
345  thetracks_->Branch("dzCorr",&dzCorr_,"dzCorr/F");
346  thetracks_->Branch("dxy",&dxy_,"dxy/F");
347  thetracks_->Branch("dxyerr",&dxyerr_,"dxyerr/F");
348  thetracks_->Branch("dxyCorr",&dxyCorr_,"dxyCorr/F");
349  thetracks_->Branch("qoverp",&qoverp_,"qoverp/F");
350  thetracks_->Branch("xPCA",&xPCA_,"xPCA/F");
351  thetracks_->Branch("yPCA",&yPCA_,"yPCA/F");
352  thetracks_->Branch("zPCA",&zPCA_,"zPCA/F");
353  thetracks_->Branch("nLayers",&nLayers_,"nLayers/i");
354  thetracks_->Branch("trkWeightpvtx",&trkWeightpvtx_,"trkWeightpvtx/F");
355  thetracks_->Branch("vertexid",&vertexid_,"vertexid/i");
356  tracks_.push_back(thetracks_);
357  }
358 
359  // create a tree for missing hits
360  for(size_t i = 0; i<trackLabel_.size(); ++i) {
361  char buffer1[256];
362  char buffer2[256];
363  sprintf(buffer1,"misingHits%lu",(unsigned long)i);
364  sprintf(buffer2,"missing hits from track collection %lu",(unsigned long)i);
365  TTree* themissingHits_ = dir->make<TTree>(buffer1,buffer2);
366  sprintf(buffer1,"trackid%lu",(unsigned long)i);
367  sprintf(buffer2,"trackid%lu/i",(unsigned long)i);
368  themissingHits_->Branch(buffer1,globaltrackid_+i,buffer2);
369  themissingHits_->Branch("eventid",&eventid_,"eventid/i");
370  themissingHits_->Branch("runid",&runid_,"runid/i");
371  themissingHits_->Branch("detid",&detid_,"detid/i");
372  themissingHits_->Branch("type",&type_,"type/i");
373  themissingHits_->Branch("localX",&clPositionX_,"localX/F");
374  themissingHits_->Branch("localY",&clPositionY_,"localY/F");
375  themissingHits_->Branch("globalX",&globalX_,"globalX/F");
376  themissingHits_->Branch("globalY",&globalY_,"globalY/F");
377  themissingHits_->Branch("globalZ",&globalZ_,"globalZ/F");
378  themissingHits_->Branch("measX",&measX_,"measX/F");
379  themissingHits_->Branch("measY",&measY_,"measY/F");
380  themissingHits_->Branch("errorX",&errorX_,"errorX/F");
381  themissingHits_->Branch("errorY",&errorY_,"errorY/F");
382  missingHits_.push_back(themissingHits_);
383  }
384 
385  // create a tree for the vertices
386  vertices_ = dir->make<TTree>("vertices","vertex information");
387  vertices_->Branch("vertexid",&globalvertexid_,"vertexid/i");
388  vertices_->Branch("eventid",&eventid_,"eventid/i");
389  vertices_->Branch("runid",&runid_,"runid/i");
390  vertices_->Branch("nTracks",&nTracks_pvtx_,"nTracks/i");
391  vertices_->Branch("sumptsq",&sumptsq_pvtx_,"sumptsq/F");
392  vertices_->Branch("isValid",&isValid_pvtx_,"isValid/O");
393  vertices_->Branch("isFake",&isFake_pvtx_,"isFake/O");
394  vertices_->Branch("recx",&recx_pvtx_,"recx/F");
395  vertices_->Branch("recy",&recy_pvtx_,"recy/F");
396  vertices_->Branch("recz",&recz_pvtx_,"recz/F");
397  vertices_->Branch("recx_err",&recx_err_pvtx_,"recx_err/F");
398  vertices_->Branch("recy_err",&recy_err_pvtx_,"recy_err/F");
399  vertices_->Branch("recz_err",&recz_err_pvtx_,"recz_err/F");
400 
401  // create a tree for the vertices
402  pixelVertices_ = dir->make<TTree>("pixelVertices","pixel vertex information");
403  pixelVertices_->Branch("eventid",&eventid_,"eventid/i");
404  pixelVertices_->Branch("runid",&runid_,"runid/i");
405  pixelVertices_->Branch("nTracks",&nTracks_pvtx_,"nTracks/i");
406  pixelVertices_->Branch("sumptsq",&sumptsq_pvtx_,"sumptsq/F");
407  pixelVertices_->Branch("isValid",&isValid_pvtx_,"isValid/O");
408  pixelVertices_->Branch("isFake",&isFake_pvtx_,"isFake/O");
409  pixelVertices_->Branch("recx",&recx_pvtx_,"recx/F");
410  pixelVertices_->Branch("recy",&recy_pvtx_,"recy/F");
411  pixelVertices_->Branch("recz",&recz_pvtx_,"recz/F");
412  pixelVertices_->Branch("recx_err",&recx_err_pvtx_,"recx_err/F");
413  pixelVertices_->Branch("recy_err",&recy_err_pvtx_,"recy_err/F");
414  pixelVertices_->Branch("recz_err",&recz_err_pvtx_,"recz_err/F");
415 
416  // create a tree for the events
417  event_ = dir->make<TTree>("events","event information");
418  event_->Branch("eventid",&eventid_,"eventid/i");
419  event_->Branch("runid",&runid_,"runid/i");
420  event_->Branch("L1DecisionBits",L1DecisionBits_,"L1DecisionBits[192]/O");
421  event_->Branch("L1TechnicalBits",L1TechnicalBits_,"L1TechnicalBits[64]/O");
422  event_->Branch("orbit",&orbit_,"orbit/i");
423  event_->Branch("orbitL1",&orbitL1_,"orbitL1/i");
424  event_->Branch("bx",&bx_,"bx/i");
425  event_->Branch("store",&store_,"store/i");
426  event_->Branch("time",&time_,"time/i");
427  event_->Branch("delay",&delay_,"delay/F");
428  event_->Branch("lumiSegment",&lumiSegment_,"lumiSegment/s");
429  event_->Branch("physicsDeclared",&physicsDeclared_,"physicsDeclared/s");
430  event_->Branch("HLTDecisionBits",HLTDecisionBits_,"HLTDecisionBits[256]/O");
431  char buffer[256];
432  sprintf(buffer,"ntracks[%lu]/i",(unsigned long)trackLabel_.size());
433  event_->Branch("ntracks",ntracks_,buffer);
434  sprintf(buffer,"ntrajs[%lu]/i",(unsigned long)trackLabel_.size());
435  event_->Branch("ntrajs",ntrajs_,buffer);
436  sprintf(buffer,"lowPixelProbabilityFraction[%lu]/F",(unsigned long)trackLabel_.size());
437  event_->Branch("lowPixelProbabilityFraction",lowPixelProbabilityFraction_,buffer);
438  event_->Branch("nclusters",&nclusters_,"nclusters/i");
439  event_->Branch("npixClusters",&npixClusters_,"npixClusters/i");
440  event_->Branch("nclustersOntrack",&nclustersOntrack_,"nclustersOntrack/i");
441  event_->Branch("npixClustersOntrack",&npixClustersOntrack_,"npixClustersOntrack/i");
442  event_->Branch("bsX0",&bsX0_,"bsX0/F");
443  event_->Branch("bsY0",&bsY0_,"bsY0/F");
444  event_->Branch("bsZ0",&bsZ0_,"bsZ0/F");
445  event_->Branch("bsSigmaZ",&bsSigmaZ_,"bsSigmaZ/F");
446  event_->Branch("bsDxdz",&bsDxdz_,"bsDxdz/F");
447  event_->Branch("bsDydz",&bsDydz_,"bsDydz/F");
448  event_->Branch("nVertices",&nVertices_,"nVertices/i");
449  event_->Branch("thrustValue",&thrustValue_,"thrustValue/F");
450  event_->Branch("thrustX",&thrustX_,"thrustX/F");
451  event_->Branch("thrustY",&thrustY_,"thrustY/F");
452  event_->Branch("thrustZ",&thrustZ_,"thrustZ/F");
453  event_->Branch("sphericity",&sphericity_,"sphericity/F");
454  event_->Branch("planarity",&planarity_,"planarity/F");
455  event_->Branch("aplanarity",&aplanarity_,"aplanarity/F");
456  event_->Branch("MagneticField",&fBz_,"MagneticField/F");
457 
458  // cabling
459  cablingFileName_ = iConfig.getUntrackedParameter<std::string>("PSUFileName","PSUmapping.csv");
460  delayFileNames_ = iConfig.getUntrackedParameter<std::vector<std::string> >("DelayFileNames",std::vector<std::string>(0));
461  psumap_ = dir->make<TTree>("psumap","PSU map");
462  psumap_->Branch("PSUname",PSUname_,"PSUname/C");
463  psumap_->Branch("dcuId",&dcuId_,"dcuId/i");
464  readoutmap_ = dir->make<TTree>("readoutMap","cabling map");
465  readoutmap_->Branch("detid",&detid_,"detid/i");
466  readoutmap_->Branch("dcuId",&dcuId_,"dcuId/i");
467  readoutmap_->Branch("fecCrate",&fecCrate_,"fecCrate/s");
468  readoutmap_->Branch("fecSlot",&fecSlot_,"fecSlot/s");
469  readoutmap_->Branch("fecRing",&fecRing_,"fecRing/s");
470  readoutmap_->Branch("ccuAdd",&ccuAdd_,"ccuAdd/s");
471  readoutmap_->Branch("ccuChan",&ccuChan_,"ccuChan/s");
472  readoutmap_->Branch("lldChannel",&lldChannel_,"lldChannel/s");
473  readoutmap_->Branch("fedId",&fedId_,"fedId/s");
474  readoutmap_->Branch("fedCh",&fedCh_,"fedCh/s");
475  readoutmap_->Branch("fiberLength",&fiberLength_,"fiberLength/s");
476  readoutmap_->Branch("moduleName",moduleName_,"moduleName/C");
477  readoutmap_->Branch("moduleId",moduleId_,"moduleId/C");
478  readoutmap_->Branch("delay",&delay_,"delay/F");
479  readoutmap_->Branch("globalX",&globalX_,"globalX/F");
480  readoutmap_->Branch("globalY",&globalY_,"globalY/F");
481  readoutmap_->Branch("globalZ",&globalZ_,"globalZ/F");
482 }
483 
484 TrackerDpgAnalysis::~TrackerDpgAnalysis()
485 {
486  delete[] moduleName_;
487  delete[] moduleId_;
488 }
489 
490 //
491 // member functions
492 //
493 
494 // ------------ method called to for each event ------------
495 void
496 TrackerDpgAnalysis::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup)
497 {
498  using namespace edm;
499  using namespace reco;
500  using namespace std;
501  using reco::TrackCollection;
502 
503  // load event info
504  eventid_ = iEvent.id().event();
505  runid_ = iEvent.id().run();
506  bx_ = iEvent.eventAuxiliary().bunchCrossing();
507  orbit_ = iEvent.eventAuxiliary().orbitNumber();
508  store_ = iEvent.eventAuxiliary().storeNumber();
509  time_ = iEvent.eventAuxiliary().time().value();
510  lumiSegment_ = iEvent.eventAuxiliary().luminosityBlock();
511 
512  // Retrieve commissioning information from "event summary", when available (for standard fine delay)
513  edm::Handle<SiStripEventSummary> summary;
514  iEvent.getByLabel( "siStripDigis", summary );
515  if(summary.isValid())
516  delay_ = delay(*summary.product());
517  else
518  delay_ = 0.;
519 
520  // -- Magnetic field
521  ESHandle<MagneticField> MF;
522  iSetup.get<IdealMagneticFieldRecord>().get(MF);
523  const MagneticField* theMagneticField = MF.product();
524  fBz_ = fabs(theMagneticField->inTesla(GlobalPoint(0,0,0)).z());
525 
526  // load trigger info
527  edm::Handle<L1GlobalTriggerReadoutRecord> gtrr_handle;
528  iEvent.getByLabel(L1Label_, gtrr_handle);
529  L1GlobalTriggerReadoutRecord const* gtrr = gtrr_handle.product();
530  L1GtFdlWord fdlWord = gtrr->gtFdlWord();
531  DecisionWord L1decision = fdlWord.gtDecisionWord();
532  for(int bit=0;bit<128;++bit) {
533  L1DecisionBits_[bit] = L1decision[bit];
534  }
535  DecisionWordExtended L1decisionE = fdlWord.gtDecisionWordExtended();
536  for(int bit=0;bit<64;++bit) {
537  L1DecisionBits_[bit+128] = L1decisionE[bit];
538  }
539  TechnicalTriggerWord L1technical = fdlWord.gtTechnicalTriggerWord();
540  for(int bit=0;bit<64;++bit) {
541  L1TechnicalBits_[bit] = L1technical[bit];
542  }
543  orbitL1_ = fdlWord.orbitNr();
544  physicsDeclared_ = fdlWord.physicsDeclared();
545  edm::Handle<edm::TriggerResults> trh;
546  iEvent.getByLabel(HLTLabel_, trh);
547  size_t ntrh = trh->size();
548  for(size_t bit=0;bit<256;++bit)
549  HLTDecisionBits_[bit] = bit<ntrh ? (bool)(trh->accept(bit)): false;
550 
551  // load beamspot
552  edm::Handle<reco::BeamSpot> recoBeamSpotHandle;
553  iEvent.getByLabel(bsLabel_,recoBeamSpotHandle);
554  reco::BeamSpot bs = *recoBeamSpotHandle;
555  const Point beamSpot = recoBeamSpotHandle.isValid() ?
556  Point(recoBeamSpotHandle->x0(), recoBeamSpotHandle->y0(), recoBeamSpotHandle->z0()) :
557  Point(0, 0, 0);
558  if(recoBeamSpotHandle.isValid()) {
559  bsX0_ = bs.x0();
560  bsY0_ = bs.y0();
561  bsZ0_ = bs.z0();
562  bsSigmaZ_ = bs.sigmaZ();
563  bsDxdz_ = bs.dxdz();
564  bsDydz_ = bs.dydz();
565  } else {
566  bsX0_ = 0.;
567  bsY0_ = 0.;
568  bsZ0_ = 0.;
569  bsSigmaZ_ = 0.;
570  bsDxdz_ = 0.;
571  bsDydz_ = 0.;
572  }
573 
574  // load primary vertex
575  static const reco::VertexCollection s_empty_vertexColl;
576  edm::Handle<reco::VertexCollection> vertexCollectionHandle;
577  iEvent.getByLabel(vertexLabel_,vertexCollectionHandle);
578  const reco::VertexCollection vertexColl = *(vertexCollectionHandle.product());
579  nVertices_ = 0;
580  for(reco::VertexCollection::const_iterator v=vertexColl.begin();
581  v!=vertexColl.end(); ++v) {
582  if(v->isValid() && !v->isFake()) ++nVertices_;
583  }
584 
585  // load pixel vertices
586  // Pixel vertices are handled as primary vertices, but not linked to tracks.
587  edm::Handle<reco::VertexCollection> pixelVertexCollectionHandle;
588  iEvent.getByLabel(pixelVertexLabel_, pixelVertexCollectionHandle);
589  const reco::VertexCollection pixelVertexColl = *(pixelVertexCollectionHandle.product());
590  nPixelVertices_ = pixelVertexColl.size();
591 
592  // load the clusters
593  edm::Handle<edmNew::DetSetVector<SiStripCluster> > clusters;
594  iEvent.getByLabel(clusterLabel_,clusters);
595  edm::Handle<edmNew::DetSetVector<SiPixelCluster> > pixelclusters;
596  iEvent.getByLabel(pixelclusterLabel_,pixelclusters );
597 
598  // load dedx info
599  Handle<ValueMap<DeDxData> > dEdx1Handle;
600  Handle<ValueMap<DeDxData> > dEdx2Handle;
601  Handle<ValueMap<DeDxData> > dEdx3Handle;
602  try {iEvent.getByLabel(dedx1Label_, dEdx1Handle);} catch (...) {;}
603  try {iEvent.getByLabel(dedx2Label_, dEdx2Handle);} catch (...) {;}
604  try {iEvent.getByLabel(dedx3Label_, dEdx3Handle);} catch (...) {;}
605  const ValueMap<DeDxData> dEdxTrack1 = *dEdx1Handle.product();
606  const ValueMap<DeDxData> dEdxTrack2 = *dEdx2Handle.product();
607  const ValueMap<DeDxData> dEdxTrack3 = *dEdx3Handle.product();
608 
609  // load track collections
610  std::vector<reco::TrackCollection> trackCollection;
611  std::vector<edm::Handle<reco::TrackCollection> > trackCollectionHandle;
612  trackCollectionHandle.resize(trackLabel_.size());
613  size_t index = 0;
614  for(std::vector<edm::InputTag>::const_iterator label = trackLabel_.begin();label!=trackLabel_.end();++label,++index) {
615  try {iEvent.getByLabel(*label,trackCollectionHandle[index]);} catch (...) {;}
616  trackCollection.push_back(*trackCollectionHandle[index].product());
617  ntracks_[index] = trackCollection[index].size();
618  }
619 
620  // load the trajectory collections
621  std::vector<std::vector<Trajectory> > trajectoryCollection;
622  std::vector<edm::Handle<std::vector<Trajectory> > > trajectoryCollectionHandle;
623  trajectoryCollectionHandle.resize(trackLabel_.size());
624  index = 0;
625  for(std::vector<edm::InputTag>::const_iterator label = trackLabel_.begin();label!=trackLabel_.end();++label,++index) {
626  try {iEvent.getByLabel(*label,trajectoryCollectionHandle[index]);} catch (...) {;}
627  trajectoryCollection.push_back(*trajectoryCollectionHandle[index].product());
628  ntrajs_[index] = trajectoryCollection[index].size();
629  }
630 
631  // load the tracks/traj association maps
632  std::vector<TrajTrackAssociationCollection> TrajToTrackMap;
633  Handle<TrajTrackAssociationCollection> trajTrackAssociationHandle;
634  for(std::vector<edm::InputTag>::const_iterator label = trackLabel_.begin();label!=trackLabel_.end();++label) {
635  try {iEvent.getByLabel(*label,trajTrackAssociationHandle);} catch (...) {;}
636  TrajToTrackMap.push_back(*trajTrackAssociationHandle.product());
637  }
638 
639  // sanity check
640  if(!(trackCollection.size()>0 && trajectoryCollection.size()>0)) return;
641 
642  // build the reverse map tracks -> vertex
643  std::vector<std::map<size_t,int> > trackVertices;
644  for(size_t i=0;i<trackLabel_.size();++i) {
645  trackVertices.push_back(inVertex(trackCollection[0], vertexColl, globalvertexid_+1));
646  }
647 
648  // iterate over vertices
649  if(functionality_vertices_) {
650  for(reco::VertexCollection::const_iterator v=vertexColl.begin();
651  v!=vertexColl.end(); ++v) {
652  nTracks_pvtx_ = v->tracksSize();
653  sumptsq_pvtx_ = sumPtSquared(*v);
654  isValid_pvtx_ = int(v->isValid());
655  isFake_pvtx_ = int(v->isFake());
656  recx_pvtx_ = v->x();
657  recy_pvtx_ = v->y();
658  recz_pvtx_ = v->z();
659  recx_err_pvtx_ = v->xError();
660  recy_err_pvtx_ = v->yError();
661  recz_err_pvtx_ = v->zError();
662  globalvertexid_++;
663  vertices_->Fill();
664  }
665  }
666 
667  // iterate over pixel vertices
668  if(functionality_pixvertices_) {
669  for(reco::VertexCollection::const_iterator v=pixelVertexColl.begin();
670  v!=pixelVertexColl.end(); ++v) {
671  nTracks_pvtx_ = v->tracksSize();
672  sumptsq_pvtx_ = sumPtSquared(*v);
673  isValid_pvtx_ = int(v->isValid());
674  isFake_pvtx_ = int(v->isFake());
675  recx_pvtx_ = v->x();
676  recy_pvtx_ = v->y();
677  recz_pvtx_ = v->z();
678  recx_err_pvtx_ = v->xError();
679  recy_err_pvtx_ = v->yError();
680  recz_err_pvtx_ = v->zError();
681  pixelVertices_->Fill();
682  }
683  }
684 
685  // determine if each cluster is on a track or not, and record the local angle
686  // to do this, we use the first track/traj collection
687  std::vector<double> clusterOntrackAngles = onTrackAngles(clusters,trajectoryCollection[0]);
688  std::vector<std::pair<double,double> > pixclusterOntrackAngles = onTrackAngles(pixelclusters,trajectoryCollection[0]);
689 
690 /*
691  // iterate over trajectories
692  // note: when iterating over trajectories, it might be simpler to use the tracks/trajectories association map
693  for(std::vector<Trajectory>::const_iterator traj = trajVec.begin(); traj< trajVec.end(); ++traj) {
694  }
695  // loop over all rechits from trajectories
696  //iterate over trajectories
697  for(std::vector<Trajectory>::const_iterator traj = trajVec.begin(); traj< trajVec.end(); ++traj) {
698  Trajectory::DataContainer measurements = traj->measurements();
699  // iterate over measurements
700  for(Trajectory::DataContainer::iterator meas = measurements.begin(); meas!= measurements.end(); ++meas) {
701  }
702  }
703 */
704 
705  // determine if each cluster is on a track or not, and record the trackid
706  std::vector< std::vector<int> > stripClusterOntrackIndices;
707  for(size_t i = 0; i<trackLabel_.size(); ++i) {
708  stripClusterOntrackIndices.push_back(onTrack(clusters,trackCollection[i],globaltrackid_[i]+1));
709  }
710  std::vector< std::vector<int> > pixelClusterOntrackIndices;
711  for(size_t i = 0; i<trackLabel_.size(); ++i) {
712  pixelClusterOntrackIndices.push_back(onTrack(pixelclusters,trackCollection[i],globaltrackid_[i]+1));
713  }
714  nclustersOntrack_ = count_if(stripClusterOntrackIndices[0].begin(),stripClusterOntrackIndices[0].end(),bind2nd(not_equal_to<int>(), -1));
715  npixClustersOntrack_ = count_if(pixelClusterOntrackIndices[0].begin(),pixelClusterOntrackIndices[0].end(),bind2nd(not_equal_to<int>(), -1));
716 
717  // iterate over tracks
718  for (size_t coll = 0; coll<trackCollection.size(); ++coll) {
719  uint32_t n_hits_barrel=0;
720  uint32_t n_hits_lowprob=0;
721  for(TrajTrackAssociationCollection::const_iterator it = TrajToTrackMap[coll].begin(); it!=TrajToTrackMap[coll].end(); ++it) {
722  reco::TrackRef itTrack = it->val;
723  edm::Ref<std::vector<Trajectory> > traj = it->key; // bug to find type of the key
724  eta_ = itTrack->eta();
725  phi_ = itTrack->phi();
726  try { // not all track collections have the dedx info... indeed at best one.
727  dedxNoM_ = dEdxTrack1[itTrack].numberOfMeasurements();
728  dedx1_ = dEdxTrack1[itTrack].dEdx();
729  dedx2_ = dEdxTrack2[itTrack].dEdx();
730  dedx3_ = dEdxTrack3[itTrack].dEdx();
731  } catch (...) {
732  dedxNoM_ = 0;
733  dedx1_ = 0.;
734  dedx2_ = 0.;
735  dedx3_ = 0.;
736  }
737  charge_ = itTrack->charge();
738  quality_ = itTrack->qualityMask();
739  foundhits_ = itTrack->found();
740  lostHits_ = itTrack->lost();
741  foundhitsStrips_ = itTrack->hitPattern().numberOfValidStripHits();
742  foundhitsPixels_ = itTrack->hitPattern().numberOfValidPixelHits();
743  losthitsStrips_ = itTrack->hitPattern().numberOfLostStripHits();
744  losthitsPixels_ = itTrack->hitPattern().numberOfLostPixelHits();
745  p_ = itTrack->p();
746  pt_ = itTrack->pt();
747  chi2_ = itTrack->chi2();
748  ndof_ = (uint32_t)itTrack->ndof();
749  dz_ = itTrack->dz();
750  dzerr_ = itTrack->dzError();
751  dzCorr_ = itTrack->dz(beamSpot);
752  dxy_ = itTrack->dxy();
753  dxyerr_ = itTrack->dxyError();
754  dxyCorr_ = itTrack->dxy(beamSpot);
755  pterr_ = itTrack->ptError();
756  etaerr_ = itTrack->etaError();
757  phierr_ = itTrack->phiError();
758  qoverp_ = itTrack->qoverp();
759  xPCA_ = itTrack->vertex().x();
760  yPCA_ = itTrack->vertex().y();
761  zPCA_ = itTrack->vertex().z();
762  nLayers_ = uint32_t(itTrack->hitPattern().trackerLayersWithMeasurement());
763  try { // only one track collection (at best) is connected to the main vertex
764  if(vertexColl.size()>0 && !vertexColl.begin()->isFake()) {
765  trkWeightpvtx_ = vertexColl.begin()->trackWeight(itTrack);
766  } else
767  trkWeightpvtx_ = 0.;
768  } catch (...) {
769  trkWeightpvtx_ = 0.;
770  }
771  globaltrackid_[coll]++;
772  std::map<size_t,int>::const_iterator theV = trackVertices[coll].find(itTrack.key());
773  vertexid_ = (theV!=trackVertices[coll].end()) ? theV->second : 0;
774  // add missing hits (separate tree, common strip + pixel)
775  Trajectory::DataContainer const & measurements = traj->measurements();
776  if(functionality_missingHits_) {
777  for(Trajectory::DataContainer::const_iterator it = measurements.begin(); it!=measurements.end(); ++it) {
778  TrajectoryMeasurement::ConstRecHitPointer rechit = it->recHit();
779  if(!rechit->isValid()) {
780  // detid
781  detid_ = rechit->geographicalId();
782  // status
783  type_ = rechit->getType();
784  // position
785  LocalPoint local = it->predictedState().localPosition();
786  clPositionX_ = local.x();
787  clPositionY_ = local.y();
788  // global position
789  GlobalPoint global = it->predictedState().globalPosition();
790  globalX_ = global.x();
791  globalY_ = global.y();
792  globalZ_ = global.z();
793  // position in the measurement frame
794  measX_ = 0;
795  measY_ = 0;
796  if(type_ != TrackingRecHit::inactive ) {
797  const GeomDetUnit* gdu = static_cast<const GeomDetUnit*>(tracker_->idToDetUnit(detid_));
798  if(gdu && gdu->type().isTracker()) {
799  const Topology& topo = gdu->topology();
800  MeasurementPoint meas = topo.measurementPosition(local);
801  measX_ = meas.x();
802  measY_ = meas.y();
803  }
804  }
805  // local error
806  LocalError error = it->predictedState().localError().positionError();
807  errorX_ = error.xx();
808  errorY_ = error.yy();
809  // fill
810  missingHits_[coll]->Fill();
811  }
812  }
813  }
814  // compute the fraction of low probability pixels... will be added to the event tree
815  for(trackingRecHit_iterator it = itTrack->recHitsBegin(); it!=itTrack->recHitsEnd(); ++it) {
816  const TrackingRecHit* hit = &(**it);
817  const SiPixelRecHit* pixhit = dynamic_cast<const SiPixelRecHit*>(hit);
818  if(pixhit) {
819  DetId detId = pixhit->geographicalId();
820  if(detId.subdetId()==PixelSubdetector::PixelBarrel) {
821  ++n_hits_barrel;
822  double proba = pixhit->clusterProbability(0);
823  if(proba<=0.0) ++n_hits_lowprob;
824  }
825  }
826  }
827  // fill the track tree
828  if(functionality_tracks_) tracks_[coll]->Fill();
829  }
830  lowPixelProbabilityFraction_[coll] = n_hits_barrel>0 ? (float)n_hits_lowprob/n_hits_barrel : -1.;
831  }
832 
833  // iterate over clusters
834  nclusters_ = 0;
835  std::vector<double>::const_iterator angleIt = clusterOntrackAngles.begin();
836  uint32_t localCounter = 0;
837  for (edmNew::DetSetVector<SiStripCluster>::const_iterator DSViter=clusters->begin(); DSViter!=clusters->end();DSViter++ ) {
838  edmNew::DetSet<SiStripCluster>::const_iterator begin=DSViter->begin();
839  edmNew::DetSet<SiStripCluster>::const_iterator end =DSViter->end();
840  uint32_t detid = DSViter->id();
841  nclusters_ += DSViter->size();
842  if(functionality_offtrackClusters_||functionality_ontrackClusters_) {
843  for(edmNew::DetSet<SiStripCluster>::const_iterator iter=begin;iter!=end;++iter,++angleIt,++localCounter) {
844  SiStripClusterInfo* siStripClusterInfo = new SiStripClusterInfo(*iter,iSetup,std::string("")); //string = quality label
845  // general quantities
846  for(size_t i=0; i< trackLabel_.size(); ++i) {
847  trackid_[i] = stripClusterOntrackIndices[i][localCounter];
848  }
849  onTrack_ = (trackid_[0] != (uint32_t)-1);
850  clWidth_ = siStripClusterInfo->width();
851  clPosition_ = siStripClusterInfo->baryStrip();
852  angle_ = *angleIt;
853  thickness_ = ((((DSViter->id()>>25)&0x7f)==0xd) ||
854  ((((DSViter->id()>>25)&0x7f)==0xe) && (((DSViter->id()>>5)&0x7)>4))) ? 500 : 300;
855  stripLength_ = static_cast<const StripGeomDetUnit*>(tracker_->idToDet(iter->geographicalId()))->specificTopology().stripLength();
856  int nstrips = static_cast<const StripGeomDetUnit*>(tracker_->idToDet(detid))->specificTopology().nstrips();
857  maxCharge_ = siStripClusterInfo->maxCharge();
858  // signal and noise with gain corrections
859  clNormalizedCharge_ = siStripClusterInfo->charge() ;
860  clNormalizedNoise_ = siStripClusterInfo->noiseRescaledByGain() ;
861  clSignalOverNoise_ = siStripClusterInfo->signalOverNoise() ;
862  // signal and noise with gain corrections and angle corrections
863  clCorrectedCharge_ = clNormalizedCharge_ * fabs(cos(angle_)); // corrected for track angle
864  clCorrectedSignalOverNoise_ = clSignalOverNoise_ * fabs(cos(angle_)); // corrected for track angle
865  // signal and noise without gain corrections
866  clBareNoise_ = siStripClusterInfo->noise();
867  clBareCharge_ = clSignalOverNoise_*clBareNoise_;
868  // global position
869  const StripGeomDetUnit* sgdu = static_cast<const StripGeomDetUnit*>(tracker_->idToDet(detid));
870  Surface::GlobalPoint gp = sgdu->surface().toGlobal(sgdu->specificTopology().localPosition(MeasurementPoint(clPosition_,0)));
871  globalX_ = gp.x();
872  globalY_ = gp.y();
873  globalZ_ = gp.z();
874  // cabling
875  detid_ = detid;
876  lldChannel_ = 1+(int(floor(iter->barycenter()))/256);
877  if(lldChannel_==2 && nstrips==512) lldChannel_=3;
878  if((functionality_offtrackClusters_&&!onTrack_)||(functionality_ontrackClusters_&&onTrack_)) clusters_->Fill();
879  delete siStripClusterInfo;
880  }
881  }
882  }
883 
884  // iterate over pixel clusters
885  npixClusters_ = 0;
886  std::vector<std::pair<double,double> >::const_iterator pixAngleIt = pixclusterOntrackAngles.begin();
887  localCounter = 0;
888  for (edmNew::DetSetVector<SiPixelCluster>::const_iterator DSViter=pixelclusters->begin(); DSViter!=pixelclusters->end();DSViter++ ) {
889  edmNew::DetSet<SiPixelCluster>::const_iterator begin=DSViter->begin();
890  edmNew::DetSet<SiPixelCluster>::const_iterator end =DSViter->end();
891  uint32_t detid = DSViter->id();
892  npixClusters_ += DSViter->size();
893  if(functionality_pixclusters_) {
894  for(edmNew::DetSet<SiPixelCluster>::const_iterator iter=begin;iter!=end;++iter,++pixAngleIt,++localCounter) {
895  // general quantities
896  for(size_t i=0; i< trackLabel_.size(); ++i) {
897  trackid_[i] = pixelClusterOntrackIndices[i][localCounter];
898  }
899  onTrack_ = (trackid_[0] != (uint32_t)-1);
900  clPositionX_ = iter->x();
901  clPositionY_ = iter->y();
902  clSize_ = iter->size();
903  clSizeX_ = iter->sizeX();
904  clSizeY_ = iter->sizeY();
905  alpha_ = pixAngleIt->first;
906  beta_ = pixAngleIt->second;
907  charge_ = (iter->charge())/1000.;
908  chargeCorr_ = charge_ * sqrt( 1.0 / ( 1.0/pow( tan(alpha_), 2 ) + 1.0/pow( tan(beta_), 2 ) + 1.0 ))/1000.;
909  // global position
910  const PixelGeomDetUnit* pgdu = static_cast<const PixelGeomDetUnit*>(tracker_->idToDet(detid));
911  Surface::GlobalPoint gp = pgdu->surface().toGlobal(pgdu->specificTopology().localPosition(MeasurementPoint(clPositionX_,clPositionY_)));
912  globalX_ = gp.x();
913  globalY_ = gp.y();
914  globalZ_ = gp.z();
915  // cabling
916  detid_ = detid;
917  // fill
918  pixclusters_->Fill();
919  }
920  }
921  }
922 
923  // topological quantities - uses the first track collection
924  EventShape shape(trackCollection[0]);
925  math::XYZTLorentzVectorF thrust = shape.thrust();
926  thrustValue_ = thrust.t();
927  thrustX_ = thrust.x();
928  thrustY_ = thrust.y();
929  thrustZ_ = thrust.z();
930  sphericity_ = shape.sphericity();
931  planarity_ = shape.planarity();
932  aplanarity_ = shape.aplanarity();
933 
934  // fill event tree
935  if(functionality_events_) event_->Fill();
936 
937 }
938 
939 // ------------ method called once each job just before starting event loop ------------
940 void
941 TrackerDpgAnalysis::beginRun(const edm::Run& iRun, const edm::EventSetup& iSetup)
942 {
943 
944  //geometry
945  iSetup.get<TrackerDigiGeometryRecord>().get(tracker_);
946 
947  //HLT names
948  bool changed (true);
949  if (hltConfig_.init(iRun,iSetup,HLTLabel_.process(),changed)) {
950  if (changed) {
951  hlNames_=hltConfig_.triggerNames();
952  }
953  }
954  int i=0;
955  for(std::vector<std::string>::const_iterator it = hlNames_.begin(); it<hlNames_.end();++it) {
956  std::cout << (i++) << " = " << (*it) << std::endl;
957  }
958 
959  // read the delay offsets for each device from input files
960  // this is only for the so-called "random delay" run
961  std::map<uint32_t,float> delayMap = delay(delayFileNames_);
962  TrackerMap tmap("Delays");
963 
964  // cabling I (readout)
965  iSetup.get<SiStripFedCablingRcd>().get( cabling_ );
966  const std::vector< uint16_t > & feds = cabling_->feds() ;
967  for(std::vector< uint16_t >::const_iterator fedid = feds.begin();fedid<feds.end();++fedid) {
968  const std::vector< FedChannelConnection > & connections = cabling_->connections(*fedid);
969  for(std::vector< FedChannelConnection >::const_iterator conn=connections.begin();conn<connections.end();++conn) {
970  // Fill the "old" map to be used for lookup during analysis
971  if(conn->isConnected())
972  connections_.insert(std::make_pair(conn->detId(),new FedChannelConnection(*conn)));
973  // Fill the standalone tree (once for all)
974  if(conn->isConnected()) {
975  detid_ = conn->detId();
976  strncpy(moduleName_,toStringName(detid_).c_str(),256);
977  strncpy(moduleId_,toStringId(detid_).c_str(),256);
978  lldChannel_ = conn->lldChannel();
979  dcuId_ = conn->dcuId();
980  fecCrate_ = conn->fecCrate();
981  fecSlot_ = conn->fecSlot();
982  fecRing_ = conn->fecRing();
983  ccuAdd_ = conn->ccuAddr();
984  ccuChan_ = conn->ccuChan();
985  fedId_ = conn->fedId();
986  fedCh_ = conn->fedCh();
987  fiberLength_ = conn->fiberLength();
988  delay_ = delayMap[dcuId_];
989  const StripGeomDetUnit* sgdu = static_cast<const StripGeomDetUnit*>(tracker_->idToDet(detid_));
990  Surface::GlobalPoint gp = sgdu->surface().toGlobal(LocalPoint(0,0));
991  globalX_ = gp.x();
992  globalY_ = gp.y();
993  globalZ_ = gp.z();
994  readoutmap_->Fill();
995  tmap.fill_current_val(detid_,delay_);
996  }
997  }
998  }
999  if(delayMap.size()) tmap.save(true, 0, 0, "delaymap.png");
1000 
1001  // cabling II (DCU map)
1002  ifstream cablingFile(cablingFileName_.c_str());
1003  if(cablingFile.is_open()) {
1004  char buffer[1024];
1005  cablingFile.getline(buffer,1024);
1006  while(!cablingFile.eof()) {
1007  std::istringstream line(buffer);
1008  std::string name;
1009  // one line contains the PSU name + all dcuids connected to it.
1010  line >> name;
1011  strncpy(PSUname_,name.c_str(),256);
1012  while(!line.eof()) {
1013  line >> dcuId_;
1014  psumap_->Fill();
1015  }
1016  cablingFile.getline(buffer,1024);
1017  }
1018  } else {
1019  edm::LogWarning("BadConfig") << " The PSU file does not exist. The psumap tree will not be filled."
1020  << std::endl << " Looking for " << cablingFileName_.c_str() << "."
1021  << std::endl << " Please specify a valid filename through the PSUFileName untracked parameter.";
1022  }
1023 }
1024 
1025 // ------------ method called once each job just after ending the event loop ------------
1026 void
1027 TrackerDpgAnalysis::endJob() {
1028  for(size_t i = 0; i<tracks_.size();++i) {
1029  char buffer[256];
1030  sprintf(buffer,"trackid%lu",(unsigned long)i);
1031  if(tracks_[i]->GetEntries()) tracks_[i]->BuildIndex(buffer,"eventid");
1032  }
1033  /* not needed: missing hits is a high-level quantity
1034  for(size_t i = 0; i<missingHits_.size();++i) {
1035  char buffer[256];
1036  sprintf(buffer,"trackid%lu",(unsigned long)i);
1037  if(missingHits_[i]->GetEntries()) missingHits_[i]->BuildIndex(buffer);
1038  }
1039  */
1040  if(vertices_->GetEntries()) vertices_->BuildIndex("vertexid","eventid");
1041  if(event_->GetEntries()) event_->BuildIndex("runid","eventid");
1042  if(psumap_->GetEntries()) psumap_->BuildIndex("dcuId");
1043  if(readoutmap_->GetEntries()) readoutmap_->BuildIndex("detid","lldChannel");
1044 }
1045 
1046 std::vector<double> TrackerDpgAnalysis::onTrackAngles(edm::Handle<edmNew::DetSetVector<SiStripCluster> >& clusters,
1047  const std::vector<Trajectory>& trajVec )
1048 {
1049  std::vector<double> result;
1050  // first, build a list of positions and angles on trajectories
1051  std::multimap<const uint32_t,std::pair<LocalPoint,double> > onTrackPositions;
1052  for(std::vector<Trajectory>::const_iterator traj = trajVec.begin(); traj< trajVec.end(); ++traj) {
1053  Trajectory::DataContainer measurements = traj->measurements();
1054  for(Trajectory::DataContainer::iterator meas = measurements.begin(); meas!= measurements.end(); ++meas) {
1055  double tla = meas->updatedState().localDirection().theta();
1056  insertMeasurement(onTrackPositions,&(*(meas->recHit())),tla);
1057  }
1058  }
1059  // then loop over the clusters to check
1060  double angle = 0.;
1061  for (edmNew::DetSetVector<SiStripCluster>::const_iterator DSViter=clusters->begin(); DSViter!=clusters->end();DSViter++ ) {
1062  edmNew::DetSet<SiStripCluster>::const_iterator begin=DSViter->begin();
1063  edmNew::DetSet<SiStripCluster>::const_iterator end =DSViter->end();
1064  for(edmNew::DetSet<SiStripCluster>::const_iterator iter=begin;iter!=end;++iter) {
1065  angle = 0.;
1066  std::pair< std::multimap<uint32_t,std::pair<LocalPoint,double> >::const_iterator,
1067  std::multimap<uint32_t,std::pair<LocalPoint,double> >::const_iterator> range =
1068  onTrackPositions.equal_range(iter->geographicalId());
1069  const GeomDetUnit* gdu = static_cast<const GeomDetUnit*>(tracker_->idToDet(iter->geographicalId()));
1070  for(std::multimap<uint32_t,std::pair<LocalPoint,double> >::const_iterator cl = range.first; cl!= range.second; ++cl) {
1071  if(fabs(gdu->topology().measurementPosition(cl->second.first).x()-iter->barycenter())<2) {
1072  angle = cl->second.second;
1073  }
1074  }
1075  result.push_back(angle);
1076  }
1077  }
1078  return result;
1079 }
1080 
1081 void TrackerDpgAnalysis::insertMeasurement(std::multimap<const uint32_t,std::pair<LocalPoint,double> >& collection,const TransientTrackingRecHit* hit , double tla)
1082 {
1083  if(!hit) return;
1084  const TSiTrackerMultiRecHit* multihit=dynamic_cast<const TSiTrackerMultiRecHit*>(hit);
1085  const TSiStripRecHit2DLocalPos* singlehit=dynamic_cast<const TSiStripRecHit2DLocalPos*>(hit);
1086  const TSiStripRecHit1D* hit1d=dynamic_cast<const TSiStripRecHit1D*>(hit);
1087  if(hit1d) { //...->33X
1088  collection.insert(std::make_pair(hit1d->geographicalId().rawId(),std::make_pair(hit1d->localPosition(),tla)));
1089  } else if(singlehit) { // 41X->...
1090  collection.insert(std::make_pair(singlehit->geographicalId().rawId(),std::make_pair(singlehit->localPosition(),tla)));
1091  }
1092  else if(multihit){
1093  std::vector< const TrackingRecHit * > childs = multihit->recHits();
1094  for(std::vector<const TrackingRecHit*>::const_iterator it=childs.begin();it!=childs.end();++it) {
1095  insertMeasurement(collection,dynamic_cast<const TransientTrackingRecHit*>(*it),tla);
1096  }
1097  }
1098 }
1099 
1100 std::vector<int> TrackerDpgAnalysis::onTrack(edm::Handle<edmNew::DetSetVector<SiStripCluster> >& clusters,
1101  const reco::TrackCollection& trackVec, uint32_t firstTrack )
1102 {
1103  std::vector<int> result;
1104  // first, build a list of positions and trackid on tracks
1105  std::multimap<const uint32_t,std::pair<int,int> > onTrackPositions;
1106  uint32_t trackid = firstTrack;
1107  for(reco::TrackCollection::const_iterator itTrack = trackVec.begin(); itTrack!=trackVec.end();++itTrack,++trackid) {
1108  for(trackingRecHit_iterator it = itTrack->recHitsBegin(); it!=itTrack->recHitsEnd(); ++it) {
1109  const TrackingRecHit* hit = &(**it);
1110  insertMeasurement(onTrackPositions,hit,trackid);
1111  }
1112  }
1113  // then loop over the clusters to check
1114  int thetrackid = -1;
1115  for (edmNew::DetSetVector<SiStripCluster>::const_iterator DSViter=clusters->begin(); DSViter!=clusters->end();DSViter++ ) {
1116  edmNew::DetSet<SiStripCluster>::const_iterator begin=DSViter->begin();
1117  edmNew::DetSet<SiStripCluster>::const_iterator end =DSViter->end();
1118  for(edmNew::DetSet<SiStripCluster>::const_iterator iter=begin;iter!=end;++iter) {
1119  thetrackid = -1;
1120  std::pair< std::multimap<uint32_t,std::pair<int,int> >::const_iterator,
1121  std::multimap<uint32_t,std::pair<int,int> >::const_iterator> range =
1122  onTrackPositions.equal_range(iter->geographicalId());
1123  for(std::multimap<uint32_t,std::pair<int,int> >::const_iterator cl = range.first; cl!= range.second; ++cl) {
1124  if(fabs(cl->second.first-iter->barycenter())<2) {
1125  thetrackid = cl->second.second;
1126  }
1127  }
1128  result.push_back(thetrackid);
1129  }
1130  }
1131  return result;
1132 }
1133 
1134 void TrackerDpgAnalysis::insertMeasurement(std::multimap<const uint32_t,std::pair<int, int> >& collection,const TrackingRecHit* hit , int trackid)
1135 {
1136  if(!hit) return;
1137  const SiTrackerMultiRecHit* multihit=dynamic_cast<const SiTrackerMultiRecHit*>(hit);
1138  const SiStripRecHit2D* singlehit=dynamic_cast<const SiStripRecHit2D*>(hit);
1139  const SiStripRecHit1D* hit1d=dynamic_cast<const SiStripRecHit1D*>(hit);
1140  if(hit1d) { // 41X->...
1141  collection.insert(std::make_pair(hit1d->geographicalId().rawId(),std::make_pair(int(hit1d->cluster()->barycenter()),trackid)));
1142  } else if(singlehit) { //...->33X
1143  collection.insert(std::make_pair(singlehit->geographicalId().rawId(),std::make_pair(int(singlehit->cluster()->barycenter()),trackid)));
1144  }
1145  else if(multihit){
1146  std::vector< const TrackingRecHit * > childs = multihit->recHits();
1147  for(std::vector<const TrackingRecHit*>::const_iterator it=childs.begin();it!=childs.end();++it) {
1148  insertMeasurement(collection,*it,trackid);
1149  }
1150  }
1151 }
1152 
1153 std::map<size_t,int> TrackerDpgAnalysis::inVertex(const reco::TrackCollection& tracks, const reco::VertexCollection& vertices, uint32_t firstVertex)
1154 {
1155  // build reverse map track -> vertex
1156  std::map<size_t,int> output;
1157  uint32_t vertexid = firstVertex;
1158  for(reco::VertexCollection::const_iterator v = vertices.begin(); v!=vertices.end(); ++v,++vertexid) {
1159  reco::Vertex::trackRef_iterator it = v->tracks_begin();
1160  reco::Vertex::trackRef_iterator lastTrack = v->tracks_end();
1161  for(;it!=lastTrack;++it) {
1162  output[it->key()] = vertexid;
1163  }
1164  }
1165  return output;
1166 }
1167 
1168 std::vector<std::pair<double,double> > TrackerDpgAnalysis::onTrackAngles(edm::Handle<edmNew::DetSetVector<SiPixelCluster> >& clusters,
1169  const std::vector<Trajectory>& trajVec )
1170 {
1171  std::vector<std::pair<double,double> > result;
1172  // first, build a list of positions and angles on trajectories
1173  std::multimap<const uint32_t,std::pair<LocalPoint,std::pair<double,double> > > onTrackPositions;
1174  for(std::vector<Trajectory>::const_iterator traj = trajVec.begin(); traj< trajVec.end(); ++traj) {
1175  Trajectory::DataContainer measurements = traj->measurements();
1176  for(Trajectory::DataContainer::iterator meas = measurements.begin(); meas!= measurements.end(); ++meas) {
1177  LocalVector localDir = meas->updatedState().localDirection();
1178  double alpha = atan2(localDir.z(), localDir.x());
1179  double beta = atan2(localDir.z(), localDir.y());
1180  insertMeasurement(onTrackPositions,&(*(meas->recHit())),alpha,beta);
1181  }
1182  }
1183  // then loop over the clusters to check
1184  double alpha = 0.;
1185  double beta = 0.;
1186  for (edmNew::DetSetVector<SiPixelCluster>::const_iterator DSViter=clusters->begin(); DSViter!=clusters->end();DSViter++ ) {
1187  edmNew::DetSet<SiPixelCluster>::const_iterator begin=DSViter->begin();
1188  edmNew::DetSet<SiPixelCluster>::const_iterator end =DSViter->end();
1189  for(edmNew::DetSet<SiPixelCluster>::const_iterator iter=begin;iter!=end;++iter) {
1190  alpha = 0.;
1191  beta = 0.;
1192  std::pair< std::multimap<uint32_t,std::pair<LocalPoint,std::pair<double, double> > >::const_iterator,
1193  std::multimap<uint32_t,std::pair<LocalPoint,std::pair<double, double> > >::const_iterator> range =
1194  onTrackPositions.equal_range(DSViter->id());
1195  const GeomDetUnit* gdu = static_cast<const GeomDetUnit*>(tracker_->idToDet(DSViter->id()));
1196  for(std::multimap<uint32_t,std::pair<LocalPoint,std::pair<double, double> > >::const_iterator cl = range.first; cl!= range.second; ++cl) {
1197  if(fabs(gdu->topology().measurementPosition(cl->second.first).x()-iter->x())<2 &&
1198  fabs(gdu->topology().measurementPosition(cl->second.first).y()-iter->y())<2 ) {
1199  alpha = cl->second.second.first;
1200  beta = cl->second.second.second;
1201  }
1202  }
1203  result.push_back(std::make_pair(alpha,beta));
1204  }
1205  }
1206  return result;
1207 }
1208 
1209 void TrackerDpgAnalysis::insertMeasurement(std::multimap<const uint32_t,std::pair<LocalPoint,std::pair<double,double> > >& collection,const TransientTrackingRecHit* hit , double alpha, double beta)
1210 {
1211  if(!hit) return;
1212  const TSiPixelRecHit* pixhit = dynamic_cast<const TSiPixelRecHit*>(hit);
1213  if(pixhit) {
1214  collection.insert(std::make_pair(pixhit->geographicalId().rawId(),std::make_pair(pixhit->localPosition(),std::make_pair(alpha,beta))));
1215  }
1216 }
1217 
1218 std::vector<int> TrackerDpgAnalysis::onTrack(edm::Handle<edmNew::DetSetVector<SiPixelCluster> >& clusters,
1219  const reco::TrackCollection& trackVec, uint32_t firstTrack )
1220 {
1221  std::vector<int> result;
1222  // first, build a list of positions and trackid on tracks
1223  std::multimap<const uint32_t,std::pair<std::pair<float, float>,int> > onTrackPositions;
1224  uint32_t trackid = firstTrack;
1225  for(reco::TrackCollection::const_iterator itTrack = trackVec.begin(); itTrack!=trackVec.end();++itTrack,++trackid) {
1226  for(trackingRecHit_iterator it = itTrack->recHitsBegin(); it!=itTrack->recHitsEnd(); ++it) {
1227  const TrackingRecHit* hit = &(**it);
1228  insertMeasurement(onTrackPositions,hit,trackid);
1229  }
1230  }
1231  // then loop over the clusters to check
1232  int thetrackid = -1;
1233  for (edmNew::DetSetVector<SiPixelCluster>::const_iterator DSViter=clusters->begin(); DSViter!=clusters->end();DSViter++ ) {
1234  edmNew::DetSet<SiPixelCluster>::const_iterator begin=DSViter->begin();
1235  edmNew::DetSet<SiPixelCluster>::const_iterator end =DSViter->end();
1236  for(edmNew::DetSet<SiPixelCluster>::const_iterator iter=begin;iter!=end;++iter) {
1237  thetrackid = -1;
1238  std::pair< std::multimap<uint32_t,std::pair<std::pair<float, float>,int> >::const_iterator,
1239  std::multimap<uint32_t,std::pair<std::pair<float, float>,int> >::const_iterator> range =
1240  onTrackPositions.equal_range(DSViter->id());
1241  for(std::multimap<uint32_t,std::pair<std::pair<float, float>,int> >::const_iterator cl = range.first; cl!= range.second; ++cl) {
1242  if((fabs(cl->second.first.first-iter->x())<2)&&(fabs(cl->second.first.second-iter->y())<2)) {
1243  thetrackid = cl->second.second;
1244  }
1245  }
1246  result.push_back(thetrackid);
1247  }
1248  }
1249  return result;
1250 }
1251 
1252 void TrackerDpgAnalysis::insertMeasurement(std::multimap<const uint32_t,std::pair<std::pair<float, float>, int> >& collection,const TrackingRecHit* hit , int trackid)
1253 {
1254  if(!hit) return;
1255  const SiPixelRecHit* pixhit = dynamic_cast<const SiPixelRecHit*>(hit);
1256  if(pixhit) {
1257  collection.insert(std::make_pair(pixhit->geographicalId().rawId(),std::make_pair(std::make_pair(pixhit->cluster()->x(),pixhit->cluster()->y()),trackid)));
1258  }
1259 }
1260 
1261 std::string TrackerDpgAnalysis::toStringName(uint32_t rawid) {
1262  SiStripDetId detid(rawid);
1263  std::string out;
1264  std::stringstream output;
1265  switch(detid.subDetector()) {
1266  case 3:
1267  {
1268  output << "TIB";
1269  TIBDetId tib(rawid);
1270  output << (tib.isZPlusSide() ? "+" : "-");
1271  output << " layer ";
1272  output << tib.layerNumber();
1273  output << ", string ";
1274  output << tib.stringNumber();
1275  output << (tib.isExternalString() ? " external" : " internal");
1276  output << ", module ";
1277  output << tib.moduleNumber();
1278  if(tib.isDoubleSide()) {
1279  output << " (double)";
1280  } else {
1281  output << (tib.isRPhi() ? " (rphi)" : " (stereo)");
1282  }
1283  break;
1284  }
1285  case 4:
1286  {
1287  output << "TID";
1288  TIDDetId tid(rawid);
1289  output << (tid.isZPlusSide() ? "+" : "-");
1290  output << " disk ";
1291  output << tid.diskNumber();
1292  output << ", ring ";
1293  output << tid.ringNumber();
1294  output << (tid.isFrontRing() ? " front" : " back");
1295  output << ", module ";
1296  output << tid.moduleNumber();
1297  if(tid.isDoubleSide()) {
1298  output << " (double)";
1299  } else {
1300  output << (tid.isRPhi() ? " (rphi)" : " (stereo)");
1301  }
1302  break;
1303  }
1304  case 5:
1305  {
1306  output << "TOB";
1307  TOBDetId tob(rawid);
1308  output << (tob.isZPlusSide() ? "+" : "-");
1309  output << " layer ";
1310  output << tob.layerNumber();
1311  output << ", rod ";
1312  output << tob.rodNumber();
1313  output << ", module ";
1314  output << tob.moduleNumber();
1315  if(tob.isDoubleSide()) {
1316  output << " (double)";
1317  } else {
1318  output << (tob.isRPhi() ? " (rphi)" : " (stereo)");
1319  }
1320  break;
1321  }
1322  case 6:
1323  {
1324  output << "TEC";
1325  TECDetId tec(rawid);
1326  output << (tec.isZPlusSide() ? "+" : "-");
1327  output << " disk ";
1328  output << tec.wheelNumber();
1329  output << " sector ";
1330  output << tec.petalNumber();
1331  output << (tec.isFrontPetal() ? " Front Petal" : " Back Petal");
1332  output << ", module ";
1333  output << tec.ringNumber();
1334  output << tec.moduleNumber();
1335  if(tec.isDoubleSide()) {
1336  output << " (double)";
1337  } else {
1338  output << (tec.isRPhi() ? " (rphi)" : " (stereo)");
1339  }
1340  break;
1341  }
1342  default:
1343  {
1344  output << "UNKNOWN";
1345  }
1346  }
1347  out = output.str();
1348  return out;
1349 }
1350 
1351 std::string TrackerDpgAnalysis::toStringId(uint32_t rawid) {
1352  std::string out;
1353  std::stringstream output;
1354  output << rawid << " (0x" << std::hex << rawid << std::dec << ")";
1355  out = output.str();
1356  return out;
1357 }
1358 
1359 double TrackerDpgAnalysis::sumPtSquared(const reco::Vertex & v) {
1360  double sum = 0.;
1361  double pT;
1362  for (reco::Vertex::trackRef_iterator it = v.tracks_begin(); it != v.tracks_end(); it++) {
1363  pT = (**it).pt();
1364  sum += pT*pT;
1365  }
1366  return sum;
1367 }
1368 
1369 float TrackerDpgAnalysis::delay(const SiStripEventSummary& summary) {
1370  float delay = const_cast<SiStripEventSummary&>(summary).ttcrx();
1371  uint32_t latencyCode = (const_cast<SiStripEventSummary&>(summary).layerScanned()>>24)&0xff;
1372  int latencyShift = latencyCode & 0x3f; // number of bunch crossings between current value and start of scan... must be positive
1373  if(latencyShift>32) latencyShift -=64; // allow negative values: we cover [-32,32].. should not be needed.
1374  if((latencyCode>>6)==2) latencyShift -= 3; // layer in deconv, rest in peak
1375  if((latencyCode>>6)==1) latencyShift += 3; // layer in peak, rest in deconv
1376  float correctedDelay = delay - (latencyShift*25.); // shifts the delay so that 0 corresponds to the current settings.
1377  return correctedDelay;
1378 }
1379 
1380 std::map<uint32_t,float> TrackerDpgAnalysis::delay(const std::vector<std::string>& files) {
1381  // prepare output
1382  uint32_t dcuid;
1383  float delay;
1384  std::map<uint32_t,float> delayMap;
1385  //iterator over input files
1386  for(std::vector<std::string>::const_iterator file=files.begin();file<files.end();++file){
1387  // open the file
1388  std::ifstream cablingFile(file->c_str());
1389  if(cablingFile.is_open()) {
1390  char buffer[1024];
1391  // read one line
1392  cablingFile.getline(buffer,1024);
1393  while(!cablingFile.eof()) {
1394  std::string line(buffer);
1395  size_t pos = line.find("dcuid");
1396  // one line containing dcuid
1397  if(pos != std::string::npos) {
1398  // decode dcuid
1399  std::string dcuids = line.substr(pos+7,line.find(" ",pos)-pos-8);
1400  std::istringstream dcuidstr(dcuids);
1401  dcuidstr >> std::hex >> dcuid;
1402  // decode delay
1403  pos = line.find("difpll");
1404  std::string diffs = line.substr(pos+8,line.find(" ",pos)-pos-9);
1405  std::istringstream diffstr(diffs);
1406  diffstr >> delay;
1407  // fill the map
1408  delayMap[dcuid] = delay;
1409  }
1410  // iterate
1411  cablingFile.getline(buffer,1024);
1412  }
1413  } else {
1414  edm::LogWarning("BadConfig") << " The delay file does not exist. The delay map will not be filled properly."
1415  << std::endl << " Looking for " << file->c_str() << "."
1416  << std::endl << " Please specify valid filenames through the DelayFileNames untracked parameter.";
1417  }
1418  }
1419  return delayMap;
1420 }
1421 
1422 //define this as a plug-in
1423 DEFINE_FWK_MODULE(TrackerDpgAnalysis);
edm::EventID::run
RunNumber_t run() const
Definition: EventID.h:42
beta
const double beta
Definition: CosmicMuonParameters.h:69
SiStripClusterInfo::maxCharge
uint8_t maxCharge() const
Definition: SiStripClusterInfo.h:38
TSiStripRecHit2DLocalPos::localPosition
virtual LocalPoint localPosition() const
Definition: TSiStripRecHit2DLocalPos.h:35
TOBDetId::rodNumber
unsigned int rodNumber() const
Definition: TOBDetId.h:77
Surface::toGlobal
GlobalPoint toGlobal(const Point2DBase< Scalar, LocalTag > lp) const
Definition: Surface.h:78
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
edm::EventID::event
EventNumber_t event() const
Definition: EventID.h:44
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
TECDetId::isDoubleSide
bool isDoubleSide() const
Definition: TECDetId.cc:14
TrackerDpgAnalysis::tracks_
std::vector< TTree * > tracks_
Definition: TrackerDpgAnalysis.cc:150
i
int i
Definition: DBlmapReader.cc:9
LocalError::xx
float xx() const
Definition: LocalError.h:19
TrackerDpgAnalysis::trackLabel_
std::vector< edm::InputTag > trackLabel_
Definition: TrackerDpgAnalysis.cc:142
alpha
float alpha
Definition: AMPTWrapper.h:95
edmNew::DetSetVector::const_iterator
boost::transform_iterator< IterHelp, const_IdIter > const_iterator
Definition: DetSetVectorNew.h:104
TECDetId::petalNumber
unsigned int petalNumber() const
Definition: TECDetId.h:94
TrackerDpgAnalysis::pixelclusterLabel_
edm::InputTag pixelclusterLabel_
Definition: TrackerDpgAnalysis.cc:140
TIBDetId::stringNumber
unsigned int stringNumber() const
Definition: TIBDetId.h:87
SiPixelRecHit::clusterProbability
float clusterProbability(unsigned int flags=0) const
Definition: SiPixelRecHit.cc:29
PV2DBase::y
T y() const
Definition: PV2DBase.h:40
TrackerDpgAnalysis::toStringName
std::string toStringName(uint32_t)
Definition: TrackerDpgAnalysis.cc:1261
TrackerDpgAnalysis::pset_
edm::ParameterSet pset_
Definition: TrackerDpgAnalysis.cc:194
label
const std::string & label
Definition: MVAComputer.cc:186
ExpressReco_HICollisions_FallBack.trackCollection
tuple trackCollection
Definition: ExpressReco_HICollisions_FallBack.py:7877
Topology::localPosition
virtual LocalPoint localPosition(const MeasurementPoint &) const =0
reco::Vertex::tracks_end
trackRef_iterator tracks_end() const
last iterator over tracks
Definition: Vertex.cc:45
TrackerDpgAnalysis::onTrack
std::vector< int > onTrack(edm::Handle< edmNew::DetSetVector< SiStripCluster > > &, const reco::TrackCollection &, uint32_t)
Definition: TrackerDpgAnalysis.cc:1100
SiStripClusterInfo::noise
float noise() const
Definition: SiStripClusterInfo.h:42
TrackerDpgAnalysis::sumPtSquared
double sumPtSquared(const reco::Vertex &)
Definition: TrackerDpgAnalysis.cc:1359
EventShape::planarity
static float planarity(const reco::TrackCollection &)
Definition: EventShape.cc:273
SiStripClusterInfo::noiseRescaledByGain
float noiseRescaledByGain() const
Definition: SiStripClusterInfo.h:43
TIBDetId::isDoubleSide
bool isDoubleSide() const
Definition: TIBDetId.cc:10
GeomDetType::isTracker
bool isTracker() const
Definition: GeomDetType.cc:35
DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:17
dbtoweb.file
list file
Definition: dbtoweb.py:253
edm::AssociationMap::const_iterator
const iterator
Definition: AssociationMap.h:46
HLTConfigProvider::triggerNames
const std::vector< std::string > & triggerNames() const
names of trigger paths
Definition: HLTConfigProvider.h:85
SiStripClusterInfo::baryStrip
float baryStrip() const
Definition: SiStripClusterInfo.h:27
reco::TrackCollection
std::vector< Track > TrackCollection
collection of Tracks
Definition: TrackFwd.h:10
edm::EventAuxiliary::time
Timestamp const & time() const
Definition: EventAuxiliary.h:62
PV3DBase::y
T y() const
Definition: PV3DBase.h:57
TIDDetId::ringNumber
unsigned int ringNumber() const
Definition: TIDDetId.h:97
reco::VertexCollection
std::vector< Vertex > VertexCollection
collection of Vertex objects
Definition: VertexFwd.h:9
TECDetId::wheelNumber
unsigned int wheelNumber() const
Definition: TECDetId.h:90
edmNew::DetSet::const_iterator
data_type const * const_iterator
Definition: DetSetNew.h:25
TrackerDpgAnalysis::pixelVertexLabel_
edm::InputTag pixelVertexLabel_
Definition: TrackerDpgAnalysis.cc:140
EventShape::thrust
static math::XYZTLorentzVectorF thrust(const reco::TrackCollection &)
Definition: EventShape.cc:124
TrackerDpgAnalysis::toStringId
std::string toStringId(uint32_t)
Definition: TrackerDpgAnalysis.cc:1351
StripGeomDetUnit::specificTopology
virtual const StripTopology & specificTopology() const
Returns a reference to the strip proxy topology.
Definition: StripGeomDetUnit.cc:19
pftools::Point
std::pair< double, double > Point
Definition: CaloEllipse.h:18
TrackerDpgAnalysis::tracker_
edm::ESHandle< TrackerGeometry > tracker_
Definition: TrackerDpgAnalysis.cc:144
edm::EventAuxiliary::bunchCrossing
int bunchCrossing() const
Definition: EventAuxiliary.h:70
AlCaRecoCosmics_cfg.name
tuple name
Definition: AlCaRecoCosmics_cfg.py:24
edm::EventAuxiliary::luminosityBlock
LuminosityBlockNumber_t luminosityBlock() const
Definition: EventAuxiliary.h:63
TIBDetId::layerNumber
unsigned int layerNumber() const
Definition: TIBDetId.h:83
EventShape::sphericity
static float sphericity(const reco::TrackCollection &)
Definition: EventShape.cc:213
DetId::rawId
uint32_t rawId() const
get the raw id
Definition: DetId.h:45
TIBDetId::isExternalString
bool isExternalString() const
Definition: TIBDetId.h:99
GeomDetUnit::topology
virtual const Topology & topology() const =0
DecisionWordExtended
std::vector< bool > DecisionWordExtended
Definition: L1GlobalTriggerReadoutSetupFwd.h:36
SiStripClusterInfo::signalOverNoise
float signalOverNoise() const
Definition: SiStripClusterInfo.h:45
linker.files
tuple files
Definition: linker.py:146
StripTopology::stripLength
virtual float stripLength() const =0
MeasurementPoint
Measurement2DPoint MeasurementPoint
Measurement points are two-dimensional by default.
Definition: MeasurementPoint.h:12
iEvent
int iEvent
Definition: GenABIO.cc:243
Trajectory::DataContainer
std::vector< TrajectoryMeasurement > DataContainer
Definition: Trajectory.h:42
SiTrackerMultiRecHit::recHits
virtual std::vector< const TrackingRecHit * > recHits() const
Access to component RecHits (if any)
Definition: SiTrackerMultiRecHit.cc:60
edm::EventAuxiliary::storeNumber
int storeNumber() const
Definition: EventAuxiliary.h:72
SiStripClusterInfo::charge
uint16_t charge() const
Definition: SiStripClusterInfo.h:37
TOBDetId::layerNumber
unsigned int layerNumber() const
Definition: TOBDetId.h:73
TrackerDpgAnalysis::delayFileNames_
std::vector< std::string > delayFileNames_
Definition: TrackerDpgAnalysis.cc:193
TrackerDpgAnalysis::clusterLabel_
edm::InputTag clusterLabel_
Definition: TrackerDpgAnalysis.cc:140
LocalError::yy
float yy() const
Definition: LocalError.h:21
dt_offlineAnalysis_common_cff.reco
tuple reco
Definition: dt_offlineAnalysis_common_cff.py:54
FedChannelConnection
Class containning control, module, detector and connection information, at the level of a FED channel...
Definition: FedChannelConnection.h:24
edm::EventAuxiliary::orbitNumber
int orbitNumber() const
Definition: EventAuxiliary.h:71
TrackerDpgAnalysis::cabling_
edm::ESHandle< SiStripFedCabling > cabling_
Definition: TrackerDpgAnalysis.cc:143
DecisionWord
std::vector< bool > DecisionWord
typedefs
Definition: L1GlobalTriggerReadoutSetupFwd.h:32
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:28
TrackerMap::save
void save(bool print_total=true, float minval=0., float maxval=0., std::string s="svgmap.svg", int width=1500, int height=800)
Definition: TrackerMap.cc:632
PV3DBase::z
T z() const
Definition: PV3DBase.h:58
TrackerDpgAnalysis::nMaxPVs_
static const int nMaxPVs_
Definition: TrackerDpgAnalysis.cc:139
TIBDetId::isZPlusSide
bool isZPlusSide() const
Definition: TIBDetId.h:75
TIBDetId::moduleNumber
unsigned int moduleNumber() const
Definition: TIBDetId.h:91
query.result
tuple result
Definition: query.py:137
funct::cos
Cos< T >::type cos(const T &t)
Definition: Cos.h:22
TSiPixelRecHit::localPosition
virtual LocalPoint localPosition() const
Definition: TSiPixelRecHit.h:32
Point
math::XYZPoint Point
Definition: TrackerDpgAnalysis.cc:110
ExpressReco_HICollisions_FallBack.beamSpot
tuple beamSpot
Definition: ExpressReco_HICollisions_FallBack.py:592
SiStripClusterInfo::width
uint16_t width() const
Definition: SiStripClusterInfo.h:25
funct::tan
Tan< T >::type tan(const T &t)
Definition: Tan.h:22
ExpressReco_HICollisions_FallBack.vertices
tuple vertices
Definition: ExpressReco_HICollisions_FallBack.py:4343
EventShape::aplanarity
static float aplanarity(const reco::TrackCollection &)
Definition: EventShape.cc:244
TechnicalTriggerWord
std::vector< bool > TechnicalTriggerWord
technical trigger bits (64 bits)
Definition: L1GlobalTriggerReadoutSetupFwd.h:39
TIDDetId::isRPhi
bool isRPhi()
Definition: TIDDetId.h:105
TSiTrackerMultiRecHit::recHits
virtual std::vector< const TrackingRecHit * > recHits() const
Access to component RecHits (if any)
Definition: TSiTrackerMultiRecHit.h:39
Topology::measurementPosition
virtual MeasurementPoint measurementPosition(const LocalPoint &) const =0
end
#define end
Definition: vmac.h:38
GeomDetUnit::type
virtual const GeomDetType & type() const =0
TrackerDpgAnalysis::onTrackAngles
std::vector< double > onTrackAngles(edm::Handle< edmNew::DetSetVector< SiStripCluster > > &, const std::vector< Trajectory > &)
Definition: TrackerDpgAnalysis.cc:1046
TECDetId::isZPlusSide
bool isZPlusSide() const
Definition: TECDetId.h:82
DetId::subdetId
int subdetId() const
get the contents of the subdetector field (not cast into any detector&#39;s numbering enum) ...
Definition: DetId.h:39
edm::Event::getByLabel
bool getByLabel(InputTag const &tag, Handle< PROD > &result) const
Definition: Event.h:359
TSiStripRecHit1D::localPosition
virtual LocalPoint localPosition() const
Definition: TSiStripRecHit1D.h:40
TrackerDpgAnalysis::hltConfig_
HLTConfigProvider hltConfig_
Definition: TrackerDpgAnalysis.cc:196
TrackerDpgAnalysis::connections_
std::multimap< const uint32_t, const FedChannelConnection * > connections_
Definition: TrackerDpgAnalysis.cc:145
dbtoconf.out
tuple out
Definition: dbtoconf.py:99
TECDetId::moduleNumber
unsigned int moduleNumber() const
Definition: TECDetId.h:102
TrackerDpgAnalysis::insertMeasurement
void insertMeasurement(std::multimap< const uint32_t, std::pair< LocalPoint, double > > &, const TransientTrackingRecHit *, double)
Definition: TrackerDpgAnalysis.cc:1081
SiStripDetId
Detector identifier class for the strip tracker.
Definition: SiStripDetId.h:17
edm::Event::eventAuxiliary
EventAuxiliary const & eventAuxiliary() const
Definition: Event.h:55
edm::Timestamp::value
TimeValue_t value() const
Definition: Timestamp.cc:72
SiStripDetId::subDetector
SubDetector subDetector() const
Definition: SiStripDetId.h:102
DetId
Definition: DetId.h:20
convertSQLitetoXML_cfg.output
tuple output
Definition: convertSQLitetoXML_cfg.py:31
coll
JetCorrectorParametersCollection coll
Definition: classes.h:14
TrackerDpgAnalysis::TrackerDpgAnalysis
TrackerDpgAnalysis(const edm::ParameterSet &)
Definition: TrackerDpgAnalysis.cc:203
fileService
edm::Service< TFileService > fileService
Definition: HSCPValidator.cc:92
TFileDirectory::mkdir
TFileDirectory mkdir(const std::string &dir, const std::string &descr="")
create a new subdirectory
Definition: TFileDirectory.cc:178
testEve_cfg.tracks
tuple tracks
Definition: testEve_cfg.py:39
math::XYZPoint
XYZPointD XYZPoint
point in space with cartesian internal representation
Definition: Point3D.h:13
HLTConfigProvider::init
bool init(const edm::Run &iRun, const edm::EventSetup &iSetup, const std::string &processName, bool &changed)
Definition: HLTConfigProvider.cc:40
edm::EventSetup::get
const T & get() const
Definition: EventSetup.h:55
SiStripRecHit2D::cluster
ClusterRef const & cluster() const
Definition: SiStripRecHit2D.h:32
PixelGeomDetUnit::specificTopology
virtual const PixelTopology & specificTopology() const
Returns a reference to the pixel proxy topology.
Definition: PixelGeomDetUnit.cc:19
edm::Ref::key
key_type key() const
Accessor for product key.
Definition: Ref.h:264
L1GtFdlWord::gtDecisionWord
const DecisionWord & gtDecisionWord() const
get/set/print algorithms bits (decision word)
Definition: L1GtFdlWord.h:173
TrackerDpgAnalysis::inVertex
std::map< size_t, int > inVertex(const reco::TrackCollection &, const reco::VertexCollection &, uint32_t)
Definition: TrackerDpgAnalysis.cc:1153
TrackerDpgAnalysis::vertexLabel_
edm::InputTag vertexLabel_
Definition: TrackerDpgAnalysis.cc:140
TECDetId::ringNumber
unsigned int ringNumber() const
Definition: TECDetId.h:98
edm::InputTag::process
std::string const & process() const
Definition: InputTag.h:29
edm::EventBase::id
edm::EventID id() const
Definition: EventBase.h:56
TrackerDpgAnalysis::delay
float delay(const SiStripEventSummary &)
Definition: TrackerDpgAnalysis.cc:1369
begin
#define begin
Definition: vmac.h:31
TrackerDpgAnalysis::missingHits_
std::vector< TTree * > missingHits_
Definition: TrackerDpgAnalysis.cc:151
TIDDetId::isZPlusSide
bool isZPlusSide() const
Definition: TIDDetId.h:77
reco::Vertex::trackRef_iterator
std::vector< TrackBaseRef >::const_iterator trackRef_iterator
The iteratator for the vector&lt;TrackRef&gt;
Definition: Vertex.h:38
TFileDirectory::make
T * make() const
make new ROOT object
Definition: TFileDirectory.h:59
LocalPoint
Local3DPoint LocalPoint
Definition: LocalPoint.h:11
TOBDetId::isDoubleSide
bool isDoubleSide() const
Definition: TOBDetId.cc:10
TrackerDpgAnalysis::analyze
virtual void analyze(const edm::Event &, const edm::EventSetup &)
Definition: TrackerDpgAnalysis.cc:496
StripTopology::localPosition
virtual LocalPoint localPosition(float strip) const =0
TrackerMap::fill_current_val
void fill_current_val(int idmod, float current_val)
Definition: TrackerMap.cc:2521
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:41
TECDetId::isFrontPetal
bool isFrontPetal() const
Definition: TECDetId.h:110
TOBDetId::isZPlusSide
bool isZPlusSide() const
Definition: TOBDetId.h:65
SiStripRecHit1D::cluster
ClusterRef const & cluster() const
Definition: SiStripRecHit1D.h:38
TrackerDpgAnalysis::beginRun
virtual void beginRun(const edm::Run &, const edm::EventSetup &)
Definition: TrackerDpgAnalysis.cc:941
TOBDetId::isRPhi
bool isRPhi()
Definition: TOBDetId.h:85
TrackingRecHit::geographicalId
DetId geographicalId() const
Definition: TrackingRecHit.h:53
dir
dbl *** dir
Definition: mlp_gen.cc:35
reco::Vertex::tracks_begin
trackRef_iterator tracks_begin() const
first iterator over tracks
Definition: Vertex.cc:40
math::XYZTLorentzVectorF
ROOT::Math::LorentzVector< ROOT::Math::PxPyPzE4D< float > > XYZTLorentzVectorF
Lorentz vector with cylindrical internal representation using pseudorapidity.
Definition: LorentzVector.h:23
TIBDetId::isRPhi
bool isRPhi()
Definition: TIBDetId.h:103
PV2DBase::x
T x() const
Definition: PV2DBase.h:39
PV3DBase::x
T x() const
Definition: PV3DBase.h:56
SiPixelRecHit::cluster
ClusterRef const & cluster() const
Definition: SiPixelRecHit.h:42
TIDDetId::moduleNumber
unsigned int moduleNumber() const
Definition: TIDDetId.h:101
GeomDet::surface
virtual const BoundPlane & surface() const
The nominal surface of the GeomDet.
Definition: GeomDet.h:37
v
mathSSE::Vec4< T > v
Definition: newBasic3DVector.h:210
funct::pow
Power< A, B >::type pow(const A &a, const B &b)
Definition: Power.h:40
TIDDetId::isFrontRing
bool isFrontRing() const
Definition: TIDDetId.h:89
TrackerDpgAnalysis::hlNames_
std::vector< std::string > hlNames_
Definition: TrackerDpgAnalysis.cc:195
TIDDetId::isDoubleSide
bool isDoubleSide() const
Definition: TIDDetId.cc:10
TECDetId::isRPhi
bool isRPhi()
Definition: TECDetId.h:114
edm::Run
Definition: Run.h:31
TOBDetId::moduleNumber
unsigned int moduleNumber() const
Definition: TOBDetId.h:81
SiPixelRecHit
Our base class.
Definition: SiPixelRecHit.h:27
TIDDetId::diskNumber
unsigned int diskNumber() const
Definition: TIDDetId.h:93
angle
T angle(T x1, T y1, T z1, T x2, T y2, T z2)
Definition: angle.h:11
Generated for CMSSW Reference Manual by doxygen 1.8.5