CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
SiTrackerGaussianSmearingRecHitConverter.cc
Go to the documentation of this file.
1 
8 //PAT
9 //FastTrackerCluster
10 #include "FastSimDataFormats/External/interface/FastTrackerCluster.h"
11 
12 // SiTracker Gaussian Smearing
13 #include "FastSimulation/TrackingRecHitProducer/interface/SiTrackerGaussianSmearingRecHitConverter.h"
14 
15 // SiPixel Gaussian Smearing
16 #include "FastSimulation/TrackingRecHitProducer/interface/SiPixelGaussianSmearingRecHitConverterAlgorithm.h"
17 
18 // SiStripGaussianSmearing
19 #include "FastSimulation/TrackingRecHitProducer/interface/SiStripGaussianSmearingRecHitConverterAlgorithm.h"
20 
21 // Geometry and magnetic field
22 #include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h"
23 #include "Geometry/Records/interface/TrackerDigiGeometryRecord.h"
24 #include "Geometry/CommonDetUnit/interface/GeomDetUnit.h"
25 #include "Geometry/TrackerGeometryBuilder/interface/GluedGeomDet.h"
26 #include "Geometry/TrackerGeometryBuilder/interface/StripGeomDetUnit.h"
27 #include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
28 #include "MagneticField/Engine/interface/MagneticField.h"
29 
30 // Data Formats
31 #include "DataFormats/Common/interface/Handle.h"
32 #include "SimDataFormats/CrossingFrame/interface/CrossingFrame.h"
33 
34 // Framework
35 #include "FWCore/Framework/interface/ESHandle.h"
36 #include "FWCore/Framework/interface/Event.h"
37 #include "FWCore/Framework/interface/EventSetup.h"
38 #include "FWCore/ParameterSet/interface/ParameterSet.h"
39 #include "FWCore/MessageLogger/interface/MessageLogger.h"
40 #include "FWCore/ServiceRegistry/interface/Service.h"
41 #include "FWCore/Utilities/interface/RandomNumberGenerator.h"
42 #include "FWCore/Utilities/interface/Exception.h"
43 
44 // Numbering scheme
45 #include "DataFormats/SiPixelDetId/interface/PXBDetId.h"
46 #include "DataFormats/SiPixelDetId/interface/PXFDetId.h"
47 #include "DataFormats/SiStripDetId/interface/TIBDetId.h"
48 #include "DataFormats/SiStripDetId/interface/TIDDetId.h"
49 #include "DataFormats/SiStripDetId/interface/TOBDetId.h"
50 #include "DataFormats/SiStripDetId/interface/TECDetId.h"
51 #include "DataFormats/GeometryCommonDetAlgo/interface/ErrorFrameTransformer.h"
52 #include "DataFormats/TrackingRecHit/interface/AlignmentPositionError.h"
53 
54 //For Pileup events
55 #include "SimDataFormats/EncodedEventId/interface/EncodedEventId.h"
56 
57 // Random engine
58 #include "FastSimulation/Utilities/interface/RandomEngine.h"
59 
60 // topology
61 
62 // the rec hit matcher
63 #include "FastSimulation/TrackingRecHitProducer/interface/GSRecHitMatcher.h"
64 
65 // STL
66 #include <memory>
67 
68 // ROOT
69 #include <TFile.h>
70 #include <TH1F.h>
71 
72 
73 //#define FAMOS_DEBUG
74 
75 SiTrackerGaussianSmearingRecHitConverter::SiTrackerGaussianSmearingRecHitConverter(
76  edm::ParameterSet const& conf)
77  : pset_(conf)
78 {
79  thePixelDataFile = 0;
80  thePixelBarrelResolutionFile = 0;
81  thePixelForwardResolutionFile = 0;
82  thePixelBarrelParametrization = 0;
83  thePixelEndcapParametrization = 0;
84  theSiStripErrorParametrization = 0;
85  numberOfDisabledModules = 0;
86 
87  random = 0;
88 
89 
90 #ifdef FAMOS_DEBUG
91  std::cout << "SiTrackerGaussianSmearingRecHitConverter instantiated" << std::endl;
92 #endif
93 
94  // Initialize the random number generator service
95  edm::Service<edm::RandomNumberGenerator> rng;
96  if ( ! rng.isAvailable() ) {
97  throw cms::Exception("Configuration")
98  << "SiTrackerGaussianSmearingRecHitConverter requires the RandomGeneratorService\n"
99  "which is not present in the configuration file.\n"
100  "You must add the service in the configuration file\n"
101  "or remove the module that requires it";
102  }
103 
104  random = new RandomEngine(&(*rng));
105  //PAT
106  produces<FastTrackerClusterCollection>("TrackerClusters");
107 
108  produces<SiTrackerGSRecHit2DCollection>("TrackerGSRecHits");
109  produces<SiTrackerGSMatchedRecHit2DCollection>("TrackerGSMatchedRecHits");
110 
111  //--- PSimHit Containers
112  trackerContainers.clear();
113  trackerContainers = conf.getParameter<std::vector<edm::InputTag> >("ROUList");
114  //--- delta rays p cut [GeV/c] to filter PSimHits with p>
115  deltaRaysPCut = conf.getParameter<double>("DeltaRaysMomentumCut");
116 
117  //--- switch to have RecHit == PSimHit
118  trackingPSimHits = conf.getParameter<bool>("trackingPSimHits");
119  if(trackingPSimHits) std::cout << "### trackingPSimHits chosen " << trackingPSimHits << std::endl;
120 
121  // switch on/off matching
122  doMatching = conf.getParameter<bool>("doRecHitMatching");
123 
124  // disable/enable dead channels
125  doDisableChannels = conf.getParameter<bool>("killDeadChannels");
126 
127  // Switch between old (ORCA) and new (CMSSW) pixel parameterization
128  useCMSSWPixelParameterization = conf.getParameter<bool>("UseCMSSWPixelParametrization");
129 #ifdef FAMOS_DEBUG
130  std::cout << (useCMSSWPixelParameterization? "CMSSW" : "ORCA") << " pixel parametrization chosen in config file." << std::endl;
131 #endif
132 
133  //Clusters
134  GevPerElectron = conf.getParameter<double>("GevPerElectron");
135  ElectronsPerADC = conf.getParameter<double>("ElectronsPerADC");
136 
137  //
138  // TIB
139  localPositionResolution_TIB1x = conf.getParameter<double>("TIB1x");
140  localPositionResolution_TIB1y = conf.getParameter<double>("TIB1y");
141  localPositionResolution_TIB2x = conf.getParameter<double>("TIB2x");
142  localPositionResolution_TIB2y = conf.getParameter<double>("TIB2y");
143  localPositionResolution_TIB3x = conf.getParameter<double>("TIB3x");
144  localPositionResolution_TIB3y = conf.getParameter<double>("TIB3y");
145  localPositionResolution_TIB4x = conf.getParameter<double>("TIB4x");
146  localPositionResolution_TIB4y = conf.getParameter<double>("TIB4y");
147  //
148  // TID
149  localPositionResolution_TID1x = conf.getParameter<double>("TID1x");
150  localPositionResolution_TID1y = conf.getParameter<double>("TID1y");
151  localPositionResolution_TID2x = conf.getParameter<double>("TID2x");
152  localPositionResolution_TID2y = conf.getParameter<double>("TID2y");
153  localPositionResolution_TID3x = conf.getParameter<double>("TID3x");
154  localPositionResolution_TID3y = conf.getParameter<double>("TID3y");
155  //
156  // TOB
157  localPositionResolution_TOB1x = conf.getParameter<double>("TOB1x");
158  localPositionResolution_TOB1y = conf.getParameter<double>("TOB1y");
159  localPositionResolution_TOB2x = conf.getParameter<double>("TOB2x");
160  localPositionResolution_TOB2y = conf.getParameter<double>("TOB2y");
161  localPositionResolution_TOB3x = conf.getParameter<double>("TOB3x");
162  localPositionResolution_TOB3y = conf.getParameter<double>("TOB3y");
163  localPositionResolution_TOB4x = conf.getParameter<double>("TOB4x");
164  localPositionResolution_TOB4y = conf.getParameter<double>("TOB4y");
165  localPositionResolution_TOB5x = conf.getParameter<double>("TOB5x");
166  localPositionResolution_TOB5y = conf.getParameter<double>("TOB5y");
167  localPositionResolution_TOB6x = conf.getParameter<double>("TOB6x");
168  localPositionResolution_TOB6y = conf.getParameter<double>("TOB6y");
169  //
170  // TEC
171  localPositionResolution_TEC1x = conf.getParameter<double>("TEC1x");
172  localPositionResolution_TEC1y = conf.getParameter<double>("TEC1y");
173  localPositionResolution_TEC2x = conf.getParameter<double>("TEC2x");
174  localPositionResolution_TEC2y = conf.getParameter<double>("TEC2y");
175  localPositionResolution_TEC3x = conf.getParameter<double>("TEC3x");
176  localPositionResolution_TEC3y = conf.getParameter<double>("TEC3y");
177  localPositionResolution_TEC4x = conf.getParameter<double>("TEC4x");
178  localPositionResolution_TEC4y = conf.getParameter<double>("TEC4y");
179  localPositionResolution_TEC5x = conf.getParameter<double>("TEC5x");
180  localPositionResolution_TEC5y = conf.getParameter<double>("TEC5y");
181  localPositionResolution_TEC6x = conf.getParameter<double>("TEC6x");
182  localPositionResolution_TEC6y = conf.getParameter<double>("TEC6y");
183  localPositionResolution_TEC7x = conf.getParameter<double>("TEC7x");
184  localPositionResolution_TEC7y = conf.getParameter<double>("TEC7y");
185  //
186  localPositionResolution_z = 0.0001; // not to be changed, set to minimum (1 um), Kalman Filter will crash if errors are exactly 0, setting 1 um means 0
187  //
188 #ifdef FAMOS_DEBUG
189  std::cout << "RecHit local position error set to" << "\n"
190  << "\tTIB1\tx = " << localPositionResolution_TIB1x
191  << " cm\ty = " << localPositionResolution_TIB1y << " cm" << "\n"
192  << "\tTIB2\tx = " << localPositionResolution_TIB2x
193  << " cm\ty = " << localPositionResolution_TIB2y << " cm" << "\n"
194  << "\tTIB3\tx = " << localPositionResolution_TIB3x
195  << " cm\ty = " << localPositionResolution_TIB3y << " cm" << "\n"
196  << "\tTIB4\tx = " << localPositionResolution_TIB4x
197  << " cm\ty = " << localPositionResolution_TIB4y << " cm" << "\n"
198  << "\tTID1\tx = " << localPositionResolution_TID1x
199  << " cm\ty = " << localPositionResolution_TID1y << " cm" << "\n"
200  << "\tTID2\tx = " << localPositionResolution_TID2x
201  << " cm\ty = " << localPositionResolution_TID2y << " cm" << "\n"
202  << "\tTID3\tx = " << localPositionResolution_TID3x
203  << " cm\ty = " << localPositionResolution_TID3y << " cm" << "\n"
204  << "\tTOB1\tx = " << localPositionResolution_TOB1x
205  << " cm\ty = " << localPositionResolution_TOB1y << " cm" << "\n"
206  << "\tTOB2\tx = " << localPositionResolution_TOB2x
207  << " cm\ty = " << localPositionResolution_TOB2y << " cm" << "\n"
208  << "\tTOB3\tx = " << localPositionResolution_TOB3x
209  << " cm\ty = " << localPositionResolution_TOB3y << " cm" << "\n"
210  << "\tTOB4\tx = " << localPositionResolution_TOB4x
211  << " cm\ty = " << localPositionResolution_TOB4y << " cm" << "\n"
212  << "\tTOB5\tx = " << localPositionResolution_TOB5x
213  << " cm\ty = " << localPositionResolution_TOB5y << " cm" << "\n"
214  << "\tTOB6\tx = " << localPositionResolution_TOB6x
215  << " cm\ty = " << localPositionResolution_TOB6y << " cm" << "\n"
216  << "\tTEC1\tx = " << localPositionResolution_TEC1x
217  << " cm\ty = " << localPositionResolution_TEC1y << " cm" << "\n"
218  << "\tTEC2\tx = " << localPositionResolution_TEC2x
219  << " cm\ty = " << localPositionResolution_TEC2y << " cm" << "\n"
220  << "\tTEC3\tx = " << localPositionResolution_TEC3x
221  << " cm\ty = " << localPositionResolution_TEC3y << " cm" << "\n"
222  << "\tTEC4\tx = " << localPositionResolution_TEC4x
223  << " cm\ty = " << localPositionResolution_TEC4y << " cm" << "\n"
224  << "\tTEC5\tx = " << localPositionResolution_TEC5x
225  << " cm\ty = " << localPositionResolution_TEC5y << " cm" << "\n"
226  << "\tTEC6\tx = " << localPositionResolution_TEC6x
227  << " cm\ty = " << localPositionResolution_TEC6y << " cm" << "\n"
228  << "\tTEC7\tx = " << localPositionResolution_TEC7x
229  << " cm\ty = " << localPositionResolution_TEC7y << " cm" << "\n"
230  << "\tAll:\tz = " << localPositionResolution_z << " cm"
231  << std::endl;
232 #endif
233 
234  //--- Number of histograms for alpha/beta barrel/forward multiplicity
235  if(useCMSSWPixelParameterization) {
236  nAlphaBarrel = conf.getParameter<int>("AlphaBarrelMultiplicityNew");
237  nBetaBarrel = conf.getParameter<int>("BetaBarrelMultiplicityNew");
238  nAlphaForward = conf.getParameter<int>("AlphaForwardMultiplicityNew");
239  nBetaForward = conf.getParameter<int>("BetaForwardMultiplicityNew");
240  } else {
241  nAlphaBarrel = conf.getParameter<int>("AlphaBarrelMultiplicity");
242  nBetaBarrel = conf.getParameter<int>("BetaBarrelMultiplicity");
243  nAlphaForward = conf.getParameter<int>("AlphaForwardMultiplicity");
244  nBetaForward = conf.getParameter<int>("BetaForwardMultiplicity");
245  }
246 #ifdef FAMOS_DEBUG
247  std::cout << "Pixel maximum multiplicity set to "
248  << "\nBarrel" << "\talpha " << nAlphaBarrel
249  << "\tbeta " << nBetaBarrel
250  << "\nForward" << "\talpha " << nAlphaForward
251  << "\tbeta " << nBetaForward
252  << std::endl;
253 #endif
254 
255  // Resolution Barrel
256  if(useCMSSWPixelParameterization) {
257  resAlphaBarrel_binMin = conf.getParameter<double>("AlphaBarrel_BinMinNew" );
258  resAlphaBarrel_binWidth = conf.getParameter<double>("AlphaBarrel_BinWidthNew");
259  resAlphaBarrel_binN = conf.getParameter<int>( "AlphaBarrel_BinNNew" );
260  resBetaBarrel_binMin = conf.getParameter<double>("BetaBarrel_BinMinNew" );
261  resBetaBarrel_binWidth = conf.getParameter<double>("BetaBarrel_BinWidthNew" );
262  resBetaBarrel_binN = conf.getParameter<int>( "BetaBarrel_BinNNew" );
263  } else {
264  resAlphaBarrel_binMin = conf.getParameter<double>("AlphaBarrel_BinMin" );
265  resAlphaBarrel_binWidth = conf.getParameter<double>("AlphaBarrel_BinWidth");
266  resAlphaBarrel_binN = conf.getParameter<int>( "AlphaBarrel_BinN" );
267  resBetaBarrel_binMin = conf.getParameter<double>("BetaBarrel_BinMin" );
268  resBetaBarrel_binWidth = conf.getParameter<double>("BetaBarrel_BinWidth" );
269  resBetaBarrel_binN = conf.getParameter<int>( "BetaBarrel_BinN" );
270  }
271 
272  // Resolution Forward
273  if(useCMSSWPixelParameterization) {
274  resAlphaForward_binMin = conf.getParameter<double>("AlphaForward_BinMinNew" );
275  resAlphaForward_binWidth = conf.getParameter<double>("AlphaForward_BinWidthNew" );
276  resAlphaForward_binN = conf.getParameter<int>( "AlphaForward_BinNNew" );
277  resBetaForward_binMin = conf.getParameter<double>("BetaForward_BinMinNew" );
278  resBetaForward_binWidth = conf.getParameter<double>("BetaForward_BinWidthNew" );
279  resBetaForward_binN = conf.getParameter<int>( "BetaForward_BinNNew" );
280  } else {
281  resAlphaForward_binMin = conf.getParameter<double>("AlphaForward_BinMin" );
282  resAlphaForward_binWidth = conf.getParameter<double>("AlphaForward_BinWidth" );
283  resAlphaForward_binN = conf.getParameter<int>( "AlphaForward_BinN" );
284  resBetaForward_binMin = conf.getParameter<double>("BetaForward_BinMin" );
285  resBetaForward_binWidth = conf.getParameter<double>("BetaForward_BinWidth" );
286  resBetaForward_binN = conf.getParameter<int>( "BetaForward_BinN" );
287  }
288 
289  // Hit Finding Probability
290  theHitFindingProbability_PXB = conf.getParameter<double>("HitFindingProbability_PXB" );
291  theHitFindingProbability_PXF = conf.getParameter<double>("HitFindingProbability_PXF" );
292  theHitFindingProbability_TIB1 = conf.getParameter<double>("HitFindingProbability_TIB1");
293  theHitFindingProbability_TIB2 = conf.getParameter<double>("HitFindingProbability_TIB2");
294  theHitFindingProbability_TIB3 = conf.getParameter<double>("HitFindingProbability_TIB3");
295  theHitFindingProbability_TIB4 = conf.getParameter<double>("HitFindingProbability_TIB4");
296  theHitFindingProbability_TID1 = conf.getParameter<double>("HitFindingProbability_TID1");
297  theHitFindingProbability_TID2 = conf.getParameter<double>("HitFindingProbability_TID2");
298  theHitFindingProbability_TID3 = conf.getParameter<double>("HitFindingProbability_TID3");
299  theHitFindingProbability_TOB1 = conf.getParameter<double>("HitFindingProbability_TOB1");
300  theHitFindingProbability_TOB2 = conf.getParameter<double>("HitFindingProbability_TOB2");
301  theHitFindingProbability_TOB3 = conf.getParameter<double>("HitFindingProbability_TOB3");
302  theHitFindingProbability_TOB4 = conf.getParameter<double>("HitFindingProbability_TOB4");
303  theHitFindingProbability_TOB5 = conf.getParameter<double>("HitFindingProbability_TOB5");
304  theHitFindingProbability_TOB6 = conf.getParameter<double>("HitFindingProbability_TOB6");
305  theHitFindingProbability_TEC1 = conf.getParameter<double>("HitFindingProbability_TEC1");
306  theHitFindingProbability_TEC2 = conf.getParameter<double>("HitFindingProbability_TEC2");
307  theHitFindingProbability_TEC3 = conf.getParameter<double>("HitFindingProbability_TEC3");
308  theHitFindingProbability_TEC4 = conf.getParameter<double>("HitFindingProbability_TEC4");
309  theHitFindingProbability_TEC5 = conf.getParameter<double>("HitFindingProbability_TEC5");
310  theHitFindingProbability_TEC6 = conf.getParameter<double>("HitFindingProbability_TEC6");
311  theHitFindingProbability_TEC7 = conf.getParameter<double>("HitFindingProbability_TEC7");
312  //
313 #ifdef FAMOS_DEBUG
314  std::cout << "RecHit finding probability set to" << "\n"
315  << "\tPXB = " << theHitFindingProbability_PXB << "\n"
316  << "\tPXF = " << theHitFindingProbability_PXF << "\n"
317  << "\tTIB1 = " << theHitFindingProbability_TIB1 << "\n"
318  << "\tTIB2 = " << theHitFindingProbability_TIB2 << "\n"
319  << "\tTIB3 = " << theHitFindingProbability_TIB3 << "\n"
320  << "\tTIB4 = " << theHitFindingProbability_TIB4 << "\n"
321  << "\tTID1 = " << theHitFindingProbability_TID1 << "\n"
322  << "\tTID2 = " << theHitFindingProbability_TID2 << "\n"
323  << "\tTID3 = " << theHitFindingProbability_TID3 << "\n"
324  << "\tTOB1 = " << theHitFindingProbability_TOB1 << "\n"
325  << "\tTOB2 = " << theHitFindingProbability_TOB2 << "\n"
326  << "\tTOB3 = " << theHitFindingProbability_TOB3 << "\n"
327  << "\tTOB4 = " << theHitFindingProbability_TOB4 << "\n"
328  << "\tTOB5 = " << theHitFindingProbability_TOB5 << "\n"
329  << "\tTOB6 = " << theHitFindingProbability_TOB6 << "\n"
330  << "\tTEC1 = " << theHitFindingProbability_TEC1 << "\n"
331  << "\tTEC2 = " << theHitFindingProbability_TEC2 << "\n"
332  << "\tTEC3 = " << theHitFindingProbability_TEC3 << "\n"
333  << "\tTEC4 = " << theHitFindingProbability_TEC4 << "\n"
334  << "\tTEC5 = " << theHitFindingProbability_TEC5 << "\n"
335  << "\tTEC6 = " << theHitFindingProbability_TEC6 << "\n"
336  << "\tTEC7 = " << theHitFindingProbability_TEC7 << "\n"
337  << std::endl;
338 #endif
339 
340  // Initialize the si strip error parametrization
341  theSiStripErrorParametrization =
342  new SiStripGaussianSmearingRecHitConverterAlgorithm(random);
343 
344  // Initialization of pixel parameterization posponed to beginRun(), since it depends on the magnetic field
345 
346 }
347 
348 
349 void SiTrackerGaussianSmearingRecHitConverter::loadPixelData() {
350  // load multiplicity cumulative probabilities
351  // root files
352  thePixelDataFile = new TFile ( edm::FileInPath( thePixelMultiplicityFileName ).fullPath().c_str() , "READ" );
353  thePixelBarrelResolutionFile = new TFile ( edm::FileInPath( thePixelBarrelResolutionFileName ).fullPath().c_str() , "READ" );
354  thePixelForwardResolutionFile = new TFile ( edm::FileInPath( thePixelForwardResolutionFileName ).fullPath().c_str() , "READ" );
355  //
356 
357  // alpha barrel
358  loadPixelData( thePixelDataFile,
359  nAlphaBarrel ,
360  std::string("hist_alpha_barrel") ,
361  theBarrelMultiplicityAlphaCumulativeProbabilities );
362  //
363  // beta barrel
364  loadPixelData( thePixelDataFile,
365  nBetaBarrel ,
366  std::string("hist_beta_barrel") ,
367  theBarrelMultiplicityBetaCumulativeProbabilities );
368  //
369  // alpha forward
370  loadPixelData( thePixelDataFile,
371  nAlphaForward ,
372  std::string("hist_alpha_forward") ,
373  theForwardMultiplicityAlphaCumulativeProbabilities );
374  //
375  // beta forward
376  loadPixelData( thePixelDataFile,
377  nBetaForward ,
378  std::string("hist_beta_forward") ,
379  theForwardMultiplicityBetaCumulativeProbabilities );
380 
381  // Load also big pixel data if CMSSW parametrization is on
382  // They are pushed back into the vectors after the normal pixels data:
383  // [0, ..., (size/2)-1] -> Normal pixels
384  // [size/2, ..., size-1] -> Big pixels
385  if(useCMSSWPixelParameterization) {
386  // alpha barrel
387  loadPixelData( thePixelDataFile,
388  nAlphaBarrel ,
389  std::string("hist_alpha_barrel_big") ,
390  theBarrelMultiplicityAlphaCumulativeProbabilities,
391  true );
392  //
393  // beta barrel
394  loadPixelData( thePixelDataFile,
395  nBetaBarrel ,
396  std::string("hist_beta_barrel_big") ,
397  theBarrelMultiplicityBetaCumulativeProbabilities,
398  true );
399  //
400  // alpha forward
401  loadPixelData( thePixelDataFile,
402  nAlphaForward ,
403  std::string("hist_alpha_forward_big") ,
404  theForwardMultiplicityAlphaCumulativeProbabilities,
405  true );
406  //
407  // beta forward
408  loadPixelData( thePixelDataFile,
409  nBetaForward ,
410  std::string("hist_beta_forward_big") ,
411  theForwardMultiplicityBetaCumulativeProbabilities,
412  true );
413  }
414  //
415 }
416 
417 void SiTrackerGaussianSmearingRecHitConverter::loadPixelData(
418  TFile* pixelDataFile,
419  unsigned int nMultiplicity,
420  std::string histName,
421  std::vector<TH1F*>& theMultiplicityCumulativeProbabilities,
422  bool bigPixels)
423 {
424 
425  std::string histName_i = histName + "_%u"; // needed to open histograms with a for
426  if(!bigPixels)
427  theMultiplicityCumulativeProbabilities.clear();
428  //
429  // What's this vector? Not needed - MG
430 // std::vector<double> mult; // vector with fixed multiplicity
431  for(unsigned int i = 0; i<nMultiplicity; ++i) {
432  TH1F addHist = *((TH1F*) pixelDataFile->Get( Form( histName_i.c_str() ,i+1 )));
433  if(i==0) {
434  theMultiplicityCumulativeProbabilities.push_back( new TH1F(addHist) );
435  } else {
436  TH1F sumHist;
437  if(bigPixels)
438  sumHist = *(theMultiplicityCumulativeProbabilities[nMultiplicity+i-1]);
439  else
440  sumHist = *(theMultiplicityCumulativeProbabilities[i-1]);
441  sumHist.Add(&addHist);
442  theMultiplicityCumulativeProbabilities.push_back( new TH1F(sumHist) );
443  }
444  }
445 
446  // Logger
447 #ifdef FAMOS_DEBUG
448  const unsigned int maxMult = theMultiplicityCumulativeProbabilities.size();
449  unsigned int iMult, multSize;
450  if(useCMSSWPixelParameterization) {
451  if(bigPixels) {
452  iMult = maxMult / 2;
453  multSize = maxMult ;
454  } else {
455  iMult = 0;
456  multSize = maxMult;
457  }
458  } else {
459  iMult = 0;
460  multSize = maxMult ;
461  }
462  std::cout << " Multiplicity cumulated probability " << histName << std::endl;
463  for(/* void */; iMult<multSize; ++iMult) {
464  for(int iBin = 1; iBin<=theMultiplicityCumulativeProbabilities[iMult]->GetNbinsX(); ++iBin) {
465  std::cout
466  << " Multiplicity " << iMult+1
467  << " bin " << iBin
468  << " low edge = "
469  << theMultiplicityCumulativeProbabilities[iMult]->GetBinLowEdge(iBin)
470  << " prob = "
471  << (theMultiplicityCumulativeProbabilities[iMult])->GetBinContent(iBin)
472  // remember in ROOT bin starts from 1 (0 underflow, nBin+1 overflow)
473  << std::endl;
474  }
475  }
476 #endif
477 
478 }
479 
480 // Destructor
481 SiTrackerGaussianSmearingRecHitConverter::~SiTrackerGaussianSmearingRecHitConverter() {
482  theBarrelMultiplicityAlphaCumulativeProbabilities.clear();
483  theBarrelMultiplicityBetaCumulativeProbabilities.clear();
484  theForwardMultiplicityAlphaCumulativeProbabilities.clear();
485  theForwardMultiplicityBetaCumulativeProbabilities.clear();
486 
487  if(thePixelDataFile) delete thePixelDataFile;
488  if(thePixelBarrelResolutionFile) delete thePixelBarrelResolutionFile;
489  if(thePixelForwardResolutionFile) delete thePixelForwardResolutionFile;
490  if(thePixelBarrelParametrization) delete thePixelBarrelParametrization;
491  if(thePixelEndcapParametrization) delete thePixelEndcapParametrization;
492  if(theSiStripErrorParametrization) delete theSiStripErrorParametrization;
493 
494  if (numberOfDisabledModules>0) delete disabledModules;
495 
496  if(random) delete random;
497 
498 }
499 
500 void
501 SiTrackerGaussianSmearingRecHitConverter::beginRun(edm::Run & run, const edm::EventSetup & es)
502 {
503 
504  // Initialize the Tracker Geometry
505  edm::ESHandle<TrackerGeometry> theGeometry;
506  es.get<TrackerDigiGeometryRecord> ().get (theGeometry);
507  geometry = &(*theGeometry);
508 
509  edm::ESHandle<TrackerGeometry> theMisAlignedGeometry;
510  es.get<TrackerDigiGeometryRecord>().get("MisAligned",theMisAlignedGeometry);
511  misAlignedGeometry = &(*theMisAlignedGeometry);
512 
513  const MagneticField* magfield;
514  edm::ESHandle<MagneticField> magField;
515  es.get<IdealMagneticFieldRecord>().get(magField);
516  magfield=&(*magField);
517  GlobalPoint center(0.0, 0.0, 0.0);
518  double magFieldAtCenter = magfield->inTesla(center).mag();
519 
520  // For new parameterization: select multiplicity and resolution files according to magnetic field
521  if(useCMSSWPixelParameterization) {
522  if(magFieldAtCenter > 3.9) {
523  thePixelMultiplicityFileName = pset_.getParameter<std::string>( "PixelMultiplicityFile40T");
524  thePixelBarrelResolutionFileName = pset_.getParameter<std::string>( "PixelBarrelResolutionFile40T");
525  thePixelForwardResolutionFileName = pset_.getParameter<std::string>( "PixelForwardResolutionFile40T");
526  } else {
527  thePixelMultiplicityFileName = pset_.getParameter<std::string>( "PixelMultiplicityFile38T");
528  thePixelBarrelResolutionFileName = pset_.getParameter<std::string>( "PixelBarrelResolutionFile38T");
529  thePixelForwardResolutionFileName = pset_.getParameter<std::string>( "PixelForwardResolutionFile38T");
530  }
531  } else {
532  thePixelMultiplicityFileName = pset_.getParameter<std::string>( "PixelMultiplicityFile" );
533  thePixelBarrelResolutionFileName = pset_.getParameter<std::string>( "PixelBarrelResolutionFile");
534  thePixelForwardResolutionFileName = pset_.getParameter<std::string>( "PixelForwardResolutionFile");
535  }
536 
537 
538  // Reading the list of dead pixel modules from DB:
539  edm::ESHandle<SiPixelQuality> siPixelBadModule;
540  es.get<SiPixelQualityRcd>().get(siPixelBadModule);
541  numberOfDisabledModules = 0;
542  if (doDisableChannels) {
543  disabledModules = new std::vector<SiPixelQuality::disabledModuleType> ( siPixelBadModule->getBadComponentList() );
544  numberOfDisabledModules = disabledModules->size();
545  size_t numberOfRecoverableModules = 0;
546  for (size_t id=0;id<numberOfDisabledModules;id++) {
548  // errortype "whole" = int 0 in DB //
549  // errortype "tbmA" = int 1 in DB //
550  // errortype "tbmB" = int 2 in DB //
551  // errortype "none" = int 3 in DB //
553  if ( (*disabledModules)[id-numberOfRecoverableModules].errorType != 0 ){
554  // Disable only the modules totally in error:
555  disabledModules->erase(disabledModules->begin()+id-numberOfRecoverableModules);
556  numberOfRecoverableModules++;
557  }
558  }
559  numberOfDisabledModules = disabledModules->size();
560  }
561 
562 
563 
564 #ifdef FAMOS_DEBUG
565  std::cout << "Pixel multiplicity data are taken from file " << thePixelMultiplicityFileName << std::endl;
566 
567  std::cout << "Pixel maximum multiplicity set to "
568  << "\nBarrel" << "\talpha " << nAlphaBarrel
569  << "\tbeta " << nBetaBarrel
570  << "\nForward" << "\talpha " << nAlphaForward
571  << "\tbeta " << nBetaForward
572  << std::endl;
573 
574  std::cout << "Barrel Pixel resolution data are taken from file "
575  << thePixelBarrelResolutionFileName << "\n"
576  << "Alpha bin min = " << resAlphaBarrel_binMin
577  << "\twidth = " << resAlphaBarrel_binWidth
578  << "\tbins = " << resAlphaBarrel_binN
579  << "\n"
580  << " Beta bin min = " << resBetaBarrel_binMin
581  << "\twidth = " << resBetaBarrel_binWidth
582  << "\tbins = " << resBetaBarrel_binN
583  << std::endl;
584 
585  std::cout << "Forward Pixel resolution data are taken from file "
586  << thePixelForwardResolutionFileName << "\n"
587  << "Alpha bin min = " << resAlphaForward_binMin
588  << "\twidth = " << resAlphaForward_binWidth
589  << "\tbins = " << resAlphaForward_binN
590  << "\n"
591  << " Beta bin min = " << resBetaForward_binMin
592  << "\twidth = " << resBetaForward_binWidth
593  << "\tbins = " << resBetaForward_binN
594  << std::endl;
595 #endif
596  //
597 
598  //
599  // load pixel data
600  loadPixelData();
601  //
602 
603  // Initialize and open relevant files for the pixel barrel error parametrization
604  thePixelBarrelParametrization =
605  new SiPixelGaussianSmearingRecHitConverterAlgorithm(
606  pset_,
607  GeomDetEnumerators::PixelBarrel,
608  random);
609  // Initialize and open relevant files for the pixel forward error parametrization
610  thePixelEndcapParametrization =
611  new SiPixelGaussianSmearingRecHitConverterAlgorithm(
612  pset_,
613  GeomDetEnumerators::PixelEndcap,
614  random);
615 }
616 
617 void SiTrackerGaussianSmearingRecHitConverter::produce(edm::Event& e, const edm::EventSetup& es)
618 {
619 
620 
621  // Step 0: Declare Ref and RefProd
622  FastTrackerClusterRefProd = e.getRefBeforePut<FastTrackerClusterCollection>("TrackerClusters");
623 
624  // Step A: Get Inputs (PSimHit's)
625  edm::Handle<CrossingFrame<PSimHit> > cf_simhit;
626  std::vector<const CrossingFrame<PSimHit> *> cf_simhitvec;
627  for(uint32_t i=0; i<trackerContainers.size(); i++){
628  e.getByLabel(trackerContainers[i], cf_simhit);
629  cf_simhitvec.push_back(cf_simhit.product());
630  }
631  std::auto_ptr<MixCollection<PSimHit> > allTrackerHits(new MixCollection<PSimHit>(cf_simhitvec));
632 
633  // Step B: create temporary RecHit collection and fill it with Gaussian smeared RecHit's
634 
635  //NEW!!!CREATE CLUSTERS AT THE SAME TIME
636  std::map<unsigned, edm::OwnVector<SiTrackerGSRecHit2D> > temporaryRecHits;
637  std::map<unsigned, edm::OwnVector<FastTrackerCluster> > theClusters ;
638 
639  smearHits( *allTrackerHits, temporaryRecHits, theClusters);
640 
641  // Step C: match rechits on stereo layers
642  std::map<unsigned, edm::OwnVector<SiTrackerGSMatchedRecHit2D> > temporaryMatchedRecHits ;
643  if(doMatching) matchHits( temporaryRecHits, temporaryMatchedRecHits, *allTrackerHits);
644 
645  // Step D: from the temporary RecHit collection, create the real one.
646  std::auto_ptr<SiTrackerGSRecHit2DCollection> recHitCollection(new SiTrackerGSRecHit2DCollection);
647  std::auto_ptr<SiTrackerGSMatchedRecHit2DCollection> recHitCollectionMatched(new SiTrackerGSMatchedRecHit2DCollection);
648  if(doMatching){
649  loadMatchedRecHits(temporaryMatchedRecHits, *recHitCollectionMatched);
650  loadRecHits(temporaryRecHits, *recHitCollection);
651  }
652  else {
653  //might need to have a "matched" hit collection containing the simple hits
654  loadRecHits(temporaryRecHits, *recHitCollection);
655  }
656 
657 
658 
659  //std::cout << "****** TrackerGSRecHits hits are =\t" << (*recHitCollection).size()<<std::endl;
660  //std::cout << "****** TrackerGSRecHitsMatched hits are =\t" << (*recHitCollectionMatched).size()<< std::endl;
661 
662 
663 
664  // Step E: write output to file
665  e.put(recHitCollection,"TrackerGSRecHits");
666  e.put(recHitCollectionMatched,"TrackerGSMatchedRecHits");
667 
668  //STEP F: write clusters
669  std::auto_ptr<FastTrackerClusterCollection> clusterCollection(new FastTrackerClusterCollection);
670  loadClusters(theClusters, *clusterCollection);
671  e.put(clusterCollection,"TrackerClusters");
672 }
673 
674 
675 
676 void SiTrackerGaussianSmearingRecHitConverter::smearHits(MixCollection<PSimHit>& input,
677  std::map<unsigned, edm::OwnVector<SiTrackerGSRecHit2D> >& temporaryRecHits,
678  std::map<unsigned, edm::OwnVector<FastTrackerCluster> >& theClusters)
679 {
680 
681  int numberOfPSimHits = 0;
682 
683  // edm::PSimHitContainer::const_iterator isim;
684  MixCollection<PSimHit>::iterator isim = input.begin();
685  MixCollection<PSimHit>::iterator lastSimHit = input.end();
686  correspondingSimHit.resize(input.size());
687  Local3DPoint position;
688  LocalError error;
689  LocalError inflatedError;
690 
691  int simHitCounter = -1;
692  int recHitCounter = 0;
693 
694  // loop on PSimHits
695 
696  for ( ; isim != lastSimHit; ++isim ) {
697  ++simHitCounter;
698 
699  DetId det((*isim).detUnitId());
700  unsigned trackID = (*isim).trackId();
701  uint32_t eeID = (*isim).eventId().rawId(); //get the rawId of the eeid for pileup treatment
702 
703 
704 
705 
707 
708  // unsigned int subdetId = det.subdetId();
709  // unsigned int disk = PXFDetId(det).disk();
710  // unsigned int side = PXFDetId(det).side();
711  // std::cout<< " Pixel Forward Disk Number : "<< disk << " Side : "<<side<<std::endl;
712  // if(subdetId==1 || subdetId==2) std::cout<<" Pixel GSRecHits "<<std::endl;
713  // else if(subdetId==3|| subdetId==4 || subdetId==5 || subdetId == 6) std::cout<<" Strip GSRecHits "<<std::endl;
714 
715  bool isBad = false;
716  unsigned int geoId = det.rawId();
717  for (size_t id=0;id<numberOfDisabledModules;id++) {
718  if(geoId==(*disabledModules)[id].DetID){
719  // Already selected in the beginRun() the ones with errorType = 0
720  // if((*disabledModules)[id].errorType == 0) isBad = true;
721  isBad = true;
722  break;
723  }
724  }
725  if(isBad) continue;
726 
727 
728  /*
729  const GeomDet* theDet = geometry->idToDet(det);
730  std::cout << "SimHit Track/z/r as simulated : "
731  << trackID << " "
732  << theDet->surface().toGlobal((*isim).localPosition()).z() << " "
733  << theDet->surface().toGlobal((*isim).localPosition()).perp() << std::endl;
734  const GeomDet* theMADet = misAlignedGeometry->idToDet(det);
735  std::cout << "SimHit Track/z/r as reconstructed : "
736  << trackID << " "
737  << theMADet->surface().toGlobal((*isim).localPosition()).z() << " "
738  << theMADet->surface().toGlobal((*isim).localPosition()).perp() << std::endl;
739  */
740 
741  ++numberOfPSimHits;
742  // gaussian smearing
743  unsigned int alphaMult = 0;
744  unsigned int betaMult = 0;
745  bool isCreated = gaussianSmearing(*isim, position, error, alphaMult, betaMult);
746  // std::cout << "Error as simulated " << error.xx() << " " << error.xy() << " " << error.yy() << std::endl;
747  //
748  unsigned int subdet = det.subdetId();
749 
750  //
751  if(isCreated) {
752  // double dist = theDet->surface().toGlobal((*isim).localPosition()).mag2();
753  // create RecHit
754  // Fill the temporary RecHit on the current DetId collection
755  // temporaryRecHits[trackID].push_back(
756 
757  // Fix by P.Azzi, A.Schmidt:
758  // if this hit is on a glued detector with radial topology,
759  // the x-coordinate needs to be translated correctly to y=0.
760  // this is necessary as intermediate step for the matching of hits
761 
762  // do it only if we do rec hit matching
763 // if(doMatching){
764 // StripSubdetector specDetId=StripSubdetector(det);
765 
766 // if(specDetId.glued()) if(subdet==6 || subdet==4){ // check if on double layer in TEC or TID
767 
768 // const GeomDetUnit* theDetUnit = geometry->idToDetUnit(det);
769 // const StripTopology& topol=(const StripTopology&)theDetUnit->type().topology();
770 
771 // // check if radial topology
772 // if(dynamic_cast <const RadialStripTopology*>(&topol)){
773 
774 // const RadialStripTopology *rtopol = dynamic_cast <const RadialStripTopology*>(&topol);
775 
776 // // translate to measurement coordinates
777 // MeasurementPoint mpoint=rtopol->measurementPosition(position);
778 // // set y=0
779 // MeasurementPoint mpoint0=MeasurementPoint(mpoint.x(),0.);
780 // // translate back to local coordinates with y=0
781 // LocalPoint lpoint0 = rtopol->localPosition(mpoint0);
782 // position = Local3DPoint(lpoint0.x(),0.,0.);
783 
784 // }
785 // } // end if( specDetId.glued()...
786 // } // end if(doMatching)
787 
788  // set y=0 in single-sided strip detectors
789  if(doMatching && (subdet>2)){
790  StripSubdetector specDetId=StripSubdetector(det);
791  if( !specDetId.glued() ){ // this is a single-sided module
792  position = Local3DPoint(position.x(),0.,0.); // set y to 0 on single-sided modules
793  }
794  }
795  else{ if(subdet>2) position = Local3DPoint(position.x(),0.,0.); } // no matching, set y=0 on strips
796 
797  // Inflate errors in case of geometry misalignment
798  const GeomDet* theMADet = misAlignedGeometry->idToDet(det);
799  if ( theMADet->alignmentPositionError() != 0 ) {
800  LocalError lape =
801  ErrorFrameTransformer().transform ( theMADet->alignmentPositionError()->globalError(),
802  theMADet->surface() );
803  error = LocalError ( error.xx()+lape.xx(),
804  error.xy()+lape.xy(),
805  error.yy()+lape.yy() );
806  }
807 
808  float chargeADC = (*isim).energyLoss()/(GevPerElectron * ElectronsPerADC);
809 
810  //create cluster
811  if(subdet > 2) theClusters[trackID].push_back(
812  new FastTrackerCluster(LocalPoint(position.x(), 0.0, 0.0), error, det,
813  simHitCounter, trackID,
814  eeID,
815  //(*isim).energyLoss())
816  chargeADC)
817  );
818  else theClusters[trackID].push_back(
819  new FastTrackerCluster(position, error, det,
820  simHitCounter, trackID,
821  eeID,
822  //(*isim).energyLoss())
823  chargeADC)
824  );
825 
826  // std::cout << "CLUSTER for simhit " << simHitCounter << "\t energy loss = " <<chargeADC << std::endl;
827 
828  // std::cout << "Error as reconstructed " << error.xx() << " " << error.xy() << " " << error.yy() << std::endl;
829 
830  // create rechit
831  temporaryRecHits[trackID].push_back(
832  new SiTrackerGSRecHit2D(position, error, det,
833  simHitCounter, trackID,
834  eeID,
835  ClusterRef(FastTrackerClusterRefProd, simHitCounter),
836  alphaMult, betaMult)
837  );
838 
839  // This a correpondence map between RecHits and SimHits
840  // (for later use in matchHits)
841  correspondingSimHit[recHitCounter++] = isim;
842 
843 
844  } // end if(isCreated)
845 
846  } // end loop on PSimHits
847 
848 }
849 
850 bool SiTrackerGaussianSmearingRecHitConverter::gaussianSmearing(const PSimHit& simHit,
851  Local3DPoint& position ,
852  LocalError& error,
853  unsigned& alphaMult,
854  unsigned& betaMult)
855 {
856 
857  // A few caracteritics of the module which the SimHit belongs to.
858  unsigned int subdet = DetId(simHit.detUnitId()).subdetId();
859  unsigned int detid = DetId(simHit.detUnitId()).rawId();
860  const GeomDetUnit* theDetUnit = geometry->idToDetUnit((DetId)simHit.detUnitId());
861  const BoundPlane& theDetPlane = theDetUnit->surface();
862  const Bounds& theBounds = theDetPlane.bounds();
863  double boundX = theBounds.width()/2.;
864  double boundY = theBounds.length()/2.;
865 
866 #ifdef FAMOS_DEBUG
867  std::cout << "\tSubdetector " << subdet
868  << " rawid " << detid
869  << std::endl;
870 #endif
871  if(trackingPSimHits) {
872  // z is fixed for all detectors, in case of errors resolution is fixed also for x and y to 1 um (zero)
873  // The Matrix is the Covariance Matrix, sigma^2 on diagonal!!!
874  error = LocalError( localPositionResolution_z * localPositionResolution_z ,
875  0.0 ,
876  localPositionResolution_z * localPositionResolution_z );
877  //
878  // starting from PSimHit local position
879  position = simHit.localPosition();
880 #ifdef FAMOS_DEBUG
881  std::cout << " Tracking PSimHit position set to " << position;
882 #endif
883  return true; // RecHit == PSimHit with 100% hit finding efficiency
884  }
885  //
886 
887  // hit finding probability --> RecHit will be created if and only if hitFindingProbability <= theHitFindingProbability_###
888  double hitFindingProbability = random->flatShoot();
889 #ifdef FAMOS_DEBUG
890  std::cout << " Hit finding probability draw: " << hitFindingProbability << std::endl;;
891 #endif
892 
893  switch (subdet) {
894  // Pixel Barrel
895  case 1:
896  {
897 #ifdef FAMOS_DEBUG
898  PXBDetId module(detid);
899  unsigned int theLayer = module.layer();
900  std::cout << "\tPixel Barrel Layer " << theLayer << std::endl;
901 #endif
902  if( hitFindingProbability > theHitFindingProbability_PXB ) return false;
903  // Hit smearing
904  const PixelGeomDetUnit* pixelDetUnit = dynamic_cast<const PixelGeomDetUnit*>(theDetUnit);
905  thePixelBarrelParametrization->smearHit(simHit, pixelDetUnit, boundX, boundY);
906  position = thePixelBarrelParametrization->getPosition();
907  error = thePixelBarrelParametrization->getError();
908  alphaMult = thePixelBarrelParametrization->getPixelMultiplicityAlpha();
909  betaMult = thePixelBarrelParametrization->getPixelMultiplicityBeta();
910  return true;
911  break;
912  }
913  // Pixel Forward
914  case 2:
915  {
916 #ifdef FAMOS_DEBUG
917  PXFDetId module(detid);
918  unsigned int theDisk = module.disk();
919  std::cout << "\tPixel Forward Disk " << theDisk << std::endl;
920 #endif
921  if( hitFindingProbability > theHitFindingProbability_PXF ) return false;
922  // Hit smearing
923  const PixelGeomDetUnit* pixelDetUnit = dynamic_cast<const PixelGeomDetUnit*>(theDetUnit);
924  thePixelEndcapParametrization->smearHit(simHit, pixelDetUnit, boundX, boundY);
925  position = thePixelEndcapParametrization->getPosition();
926  error = thePixelEndcapParametrization->getError();
927  alphaMult = thePixelEndcapParametrization->getPixelMultiplicityAlpha();
928  betaMult = thePixelEndcapParametrization->getPixelMultiplicityBeta();
929  return true;
930  break;
931  }
932  // TIB
933  case 3:
934  {
935  TIBDetId module(detid);
936  unsigned int theLayer = module.layer();
937 #ifdef FAMOS_DEBUG
938  std::cout << "\tTIB Layer " << theLayer << std::endl;
939 #endif
940  //
941  double resolutionX, resolutionY, resolutionZ;
942  resolutionZ = localPositionResolution_z;
943 
944  switch (theLayer) {
945  case 1:
946  {
947  resolutionX = localPositionResolution_TIB1x;
948  resolutionY = localPositionResolution_TIB1y;
949  if( hitFindingProbability > theHitFindingProbability_TIB1 ) return false;
950  break;
951  }
952  case 2:
953  {
954  resolutionX = localPositionResolution_TIB2x;
955  resolutionY = localPositionResolution_TIB2y;
956  if( hitFindingProbability > theHitFindingProbability_TIB2 ) return false;
957  break;
958  }
959  case 3:
960  {
961  resolutionX = localPositionResolution_TIB3x;
962  resolutionY = localPositionResolution_TIB3y;
963  if( hitFindingProbability > theHitFindingProbability_TIB3 ) return false;
964  break;
965  }
966  case 4:
967  {
968  resolutionX = localPositionResolution_TIB4x;
969  resolutionY = localPositionResolution_TIB4y;
970  if( hitFindingProbability > theHitFindingProbability_TIB4 ) return false;
971  break;
972  }
973  default:
974  {
975  edm::LogError ("SiTrackerGaussianSmearingRecHits")
976  << "\tTIB Layer not valid " << theLayer << std::endl;
977  return false;
978  break;
979  }
980  }
981 
982  // Gaussian smearing
983  theSiStripErrorParametrization->smearHit(simHit, resolutionX, resolutionY, resolutionZ, boundX, boundY);
984  position = theSiStripErrorParametrization->getPosition();
985  error = theSiStripErrorParametrization->getError();
986  alphaMult = 0;
987  betaMult = 0;
988  return true;
989  break;
990  } // TIB
991 
992  // TID
993  case 4:
994  {
995  TIDDetId module(detid);
996  unsigned int theRing = module.ring();
997  double resolutionFactorY =
998  1. - simHit.localPosition().y() / theDetPlane.position().perp();
999 
1000 #ifdef FAMOS_DEBUG
1001  std::cout << "\tTID Ring " << theRing << std::endl;
1002 #endif
1003  double resolutionX, resolutionY, resolutionZ;
1004  resolutionZ = localPositionResolution_z;
1005 
1006  switch (theRing) {
1007  case 1:
1008  {
1009  resolutionX = localPositionResolution_TID1x * resolutionFactorY;
1010  resolutionY = localPositionResolution_TID1y;
1011  if( hitFindingProbability > theHitFindingProbability_TID1 ) return false;
1012  break;
1013  }
1014  case 2:
1015  {
1016  resolutionX = localPositionResolution_TID2x * resolutionFactorY;
1017  resolutionY = localPositionResolution_TID2y;
1018  if( hitFindingProbability > theHitFindingProbability_TID2 ) return false;
1019  break;
1020  }
1021  case 3:
1022  {
1023  resolutionX = localPositionResolution_TID3x * resolutionFactorY;
1024  resolutionY = localPositionResolution_TID3y;
1025  if( hitFindingProbability > theHitFindingProbability_TID3 ) return false;
1026  break;
1027  }
1028  default:
1029  {
1030  edm::LogError ("SiTrackerGaussianSmearingRecHits")
1031  << "\tTID Ring not valid " << theRing << std::endl;
1032  return false;
1033  break;
1034  }
1035  }
1036 
1037  boundX *= resolutionFactorY;
1038 
1039  theSiStripErrorParametrization->smearHit(simHit, resolutionX, resolutionY, resolutionZ, boundX, boundY);
1040  position = theSiStripErrorParametrization->getPosition();
1041  error = theSiStripErrorParametrization->getError();
1042  alphaMult = 0;
1043  betaMult = 0;
1044  return true;
1045  break;
1046  } // TID
1047 
1048  // TOB
1049  case 5:
1050  {
1051  TOBDetId module(detid);
1052  unsigned int theLayer = module.layer();
1053 #ifdef FAMOS_DEBUG
1054  std::cout << "\tTOB Layer " << theLayer << std::endl;
1055 #endif
1056  double resolutionX, resolutionY, resolutionZ;
1057  resolutionZ = localPositionResolution_z;
1058 
1059  switch (theLayer) {
1060  case 1:
1061  {
1062  resolutionX = localPositionResolution_TOB1x;
1063  resolutionY = localPositionResolution_TOB1y;
1064  if( hitFindingProbability > theHitFindingProbability_TOB1 ) return false;
1065  break;
1066  }
1067  case 2:
1068  {
1069  resolutionX = localPositionResolution_TOB2x;
1070  resolutionY = localPositionResolution_TOB2y;
1071  if( hitFindingProbability > theHitFindingProbability_TOB2 ) return false;
1072  break;
1073  }
1074  case 3:
1075  {
1076  resolutionX = localPositionResolution_TOB3x;
1077  resolutionY = localPositionResolution_TOB3y;
1078  if( hitFindingProbability > theHitFindingProbability_TOB3 ) return false;
1079  break;
1080  }
1081  case 4:
1082  {
1083  resolutionX = localPositionResolution_TOB4x;
1084  resolutionY = localPositionResolution_TOB4y;
1085  if( hitFindingProbability > theHitFindingProbability_TOB4 ) return false;
1086  break;
1087  }
1088  case 5:
1089  {
1090  resolutionX = localPositionResolution_TOB5x;
1091  resolutionY = localPositionResolution_TOB5y;
1092  if( hitFindingProbability > theHitFindingProbability_TOB5 ) return false;
1093  break;
1094  }
1095  case 6:
1096  {
1097  resolutionX = localPositionResolution_TOB6x;
1098  resolutionY = localPositionResolution_TOB6y;
1099  if( hitFindingProbability > theHitFindingProbability_TOB6 ) return false;
1100  break;
1101  }
1102  default:
1103  {
1104  edm::LogError ("SiTrackerGaussianSmearingRecHits")
1105  << "\tTOB Layer not valid " << theLayer << std::endl;
1106  return false;
1107  break;
1108  }
1109  }
1110  theSiStripErrorParametrization->smearHit(simHit, resolutionX, resolutionY, resolutionZ, boundX, boundY);
1111  position = theSiStripErrorParametrization->getPosition();
1112  error = theSiStripErrorParametrization->getError();
1113  alphaMult = 0;
1114  betaMult = 0;
1115  return true;
1116  break;
1117  } // TOB
1118 
1119  // TEC
1120  case 6:
1121  {
1122  TECDetId module(detid);
1123  unsigned int theRing = module.ring();
1124  double resolutionFactorY =
1125  1. - simHit.localPosition().y() / theDetPlane.position().perp();
1126 
1127 #ifdef FAMOS_DEBUG
1128  std::cout << "\tTEC Ring " << theRing << std::endl;
1129 #endif
1130  double resolutionX, resolutionY, resolutionZ;
1131  resolutionZ = localPositionResolution_z * localPositionResolution_z;
1132 
1133  switch (theRing) {
1134  case 1:
1135  {
1136  resolutionX = localPositionResolution_TEC1x * resolutionFactorY;
1137  resolutionY = localPositionResolution_TEC1y;
1138  if( hitFindingProbability > theHitFindingProbability_TEC1 ) return false;
1139  break;
1140  }
1141  case 2:
1142  {
1143  resolutionX = localPositionResolution_TEC2x * resolutionFactorY;
1144  resolutionY = localPositionResolution_TEC2y;
1145  if( hitFindingProbability > theHitFindingProbability_TEC2 ) return false;
1146  break;
1147  }
1148  case 3:
1149  {
1150  resolutionX = localPositionResolution_TEC3x * resolutionFactorY;
1151  resolutionY = localPositionResolution_TEC3y;
1152  if( hitFindingProbability > theHitFindingProbability_TEC3 ) return false;
1153  break;
1154  }
1155  case 4:
1156  {
1157  resolutionX = localPositionResolution_TEC4x * resolutionFactorY;
1158  resolutionY = localPositionResolution_TEC4y;
1159  if( hitFindingProbability > theHitFindingProbability_TEC4 ) return false;
1160  break;
1161  }
1162  case 5:
1163  {
1164  resolutionX = localPositionResolution_TEC5x * resolutionFactorY;
1165  resolutionY = localPositionResolution_TEC5y;
1166  if( hitFindingProbability > theHitFindingProbability_TEC5 ) return false;
1167  break;
1168  }
1169  case 6:
1170  {
1171  resolutionX = localPositionResolution_TEC6x * resolutionFactorY;
1172  resolutionY = localPositionResolution_TEC6y;
1173  if( hitFindingProbability > theHitFindingProbability_TEC6 ) return false;
1174  break;
1175  }
1176  case 7:
1177  {
1178  resolutionX = localPositionResolution_TEC7x * resolutionFactorY;
1179  resolutionY = localPositionResolution_TEC7y;
1180  if( hitFindingProbability > theHitFindingProbability_TEC7 ) return false;
1181  break;
1182  }
1183  default:
1184  {
1185  edm::LogError ("SiTrackerGaussianSmearingRecHits")
1186  << "\tTEC Ring not valid " << theRing << std::endl;
1187  return false;
1188  break;
1189  }
1190  }
1191 
1192  boundX *= resolutionFactorY;
1193  theSiStripErrorParametrization->smearHit(simHit, resolutionX, resolutionY, resolutionZ, boundX, boundY);
1194  position = theSiStripErrorParametrization->getPosition();
1195  error = theSiStripErrorParametrization->getError();
1196  alphaMult = 0;
1197  betaMult = 0;
1198  return true;
1199  break;
1200  } // TEC
1201 
1202  default:
1203  {
1204  edm::LogError ("SiTrackerGaussianSmearingRecHits") << "\tTracker subdetector not valid " << subdet << std::endl;
1205  return false;
1206  break;
1207  }
1208 
1209  } // subdetector case
1210  //
1211 }
1212 
1213 
1214 
1215 void
1216  SiTrackerGaussianSmearingRecHitConverter::loadClusters(
1217  std::map<unsigned,edm::OwnVector<FastTrackerCluster> >& theClusterMap,
1218  FastTrackerClusterCollection& theClusterCollection) const
1219 {
1220  std::map<unsigned,edm::OwnVector<FastTrackerCluster> >::const_iterator
1221  it = theClusterMap.begin();
1222  std::map<unsigned,edm::OwnVector<FastTrackerCluster> >::const_iterator
1223  lastCluster = theClusterMap.end();
1224 
1225  for( ; it != lastCluster ; ++it ) {
1226  theClusterCollection.put(it->first,(it->second).begin(),(it->second).end());
1227  }
1228 }
1229 
1230 
1231 
1232 void
1233 SiTrackerGaussianSmearingRecHitConverter::loadRecHits(
1234  std::map<unsigned,edm::OwnVector<SiTrackerGSRecHit2D> >& theRecHits,
1235  SiTrackerGSRecHit2DCollection& theRecHitCollection) const
1236 {
1237  std::map<unsigned,edm::OwnVector<SiTrackerGSRecHit2D> >::const_iterator
1238  it = theRecHits.begin();
1239  std::map<unsigned,edm::OwnVector<SiTrackerGSRecHit2D> >::const_iterator
1240  lastRecHit = theRecHits.end();
1241 
1242  for( ; it != lastRecHit ; ++it ) {
1243  theRecHitCollection.put(it->first,(it->second).begin(),(it->second).end());
1244  }
1245 
1246 }
1247 
1248 void
1249 SiTrackerGaussianSmearingRecHitConverter::loadMatchedRecHits(
1250  std::map<unsigned,edm::OwnVector<SiTrackerGSMatchedRecHit2D> >& theRecHits,
1251  SiTrackerGSMatchedRecHit2DCollection& theRecHitCollection) const
1252 {
1253  std::map<unsigned,edm::OwnVector<SiTrackerGSMatchedRecHit2D> >::const_iterator
1254  it = theRecHits.begin();
1255  std::map<unsigned,edm::OwnVector<SiTrackerGSMatchedRecHit2D> >::const_iterator
1256  lastRecHit = theRecHits.end();
1257 
1258  for( ; it != lastRecHit ; ++it ) {
1259  theRecHitCollection.put(it->first,(it->second).begin(),(it->second).end());
1260  }
1261 
1262 }
1263 
1264 
1265 void
1266 SiTrackerGaussianSmearingRecHitConverter::matchHits(
1267  std::map<unsigned, edm::OwnVector<SiTrackerGSRecHit2D> >& theRecHits,
1268  std::map<unsigned, edm::OwnVector<SiTrackerGSMatchedRecHit2D> >& matchedMap,
1269  MixCollection<PSimHit>& simhits ) {
1270 
1271  std::map<unsigned, edm::OwnVector<SiTrackerGSRecHit2D> >::iterator it = theRecHits.begin();
1272  std::map<unsigned, edm::OwnVector<SiTrackerGSRecHit2D> >::iterator lastTrack = theRecHits.end();
1273 
1274 
1275  int recHitCounter = 0;
1276 
1277  //loop over single sided tracker RecHit
1278  for( ; it != lastTrack; ++it ) {
1279 
1280  edm::OwnVector<SiTrackerGSRecHit2D>::const_iterator rit = it->second.begin();
1281  edm::OwnVector<SiTrackerGSRecHit2D>::const_iterator firstRecHit = it->second.begin();
1282  edm::OwnVector<SiTrackerGSRecHit2D>::const_iterator lastRecHit = it->second.end();
1283 
1284  //loop over rechits in track
1285  for ( ; rit != lastRecHit; ++rit,++recHitCounter){
1286 
1287  DetId detid = rit->geographicalId();
1288  unsigned int subdet = detid.subdetId();
1289  // if in the strip (subdet>2)
1290  if(subdet>2){
1291 
1292  StripSubdetector specDetId=StripSubdetector(detid);
1293 
1294  // if this is on a glued, then place only one hit in vector
1295  if(specDetId.glued()){
1296 
1297  // get the track direction from the simhit
1298  LocalVector simtrackdir = correspondingSimHit[recHitCounter]->localDirection();
1299 
1300  const GluedGeomDet* gluedDet = (const GluedGeomDet*)geometry->idToDet(DetId(specDetId.glued()));
1301  const StripGeomDetUnit* stripdet =(StripGeomDetUnit*) gluedDet->stereoDet();
1302 
1303  // global direction of track
1304  GlobalVector globaldir= stripdet->surface().toGlobal(simtrackdir);
1305  LocalVector gluedsimtrackdir=gluedDet->surface().toLocal(globaldir);
1306 
1307  // get partner layer, it is the next one or previous one in the vector
1308  edm::OwnVector<SiTrackerGSRecHit2D>::const_iterator partner = rit;
1309  edm::OwnVector<SiTrackerGSRecHit2D>::const_iterator partnerNext = rit;
1310  edm::OwnVector<SiTrackerGSRecHit2D>::const_iterator partnerPrev = rit;
1311  partnerNext++; partnerPrev--;
1312 
1313  // check if this hit is on a stereo layer (== the second layer of a double sided module)
1314  if( specDetId.stereo() ) {
1315 
1316  int partnersFound = 0;
1317  // check next one in vector
1318  // safety check first
1319  if(partnerNext != it->second.end() )
1320  if( StripSubdetector( partnerNext->geographicalId() ).partnerDetId() == detid.rawId() ) {
1321  partner= partnerNext;
1322  partnersFound++;
1323  }
1324  // check prevoius one in vector
1325  if( rit != it->second.begin())
1326  if( StripSubdetector( partnerPrev->geographicalId() ).partnerDetId() == detid.rawId() ) {
1327  partnersFound++;
1328  partner= partnerPrev;
1329  }
1330 
1331 
1332  // in case partner has not been found this way, need to loop over all rechits in track to be sure
1333  // (rare cases fortunately)
1334  if(partnersFound==0){
1335  for(edm::OwnVector<SiTrackerGSRecHit2D>::const_iterator iter = firstRecHit; iter != lastRecHit; ++iter ){
1336  if( StripSubdetector( iter->geographicalId() ).partnerDetId() == detid.rawId()){
1337  partnersFound++;
1338  partner = iter;
1339  }
1340  }
1341  }
1342 
1343  if(partnersFound == 1) {
1344  SiTrackerGSMatchedRecHit2D * theMatchedHit =GSRecHitMatcher().match( &(*partner), &(*rit), gluedDet , gluedsimtrackdir );
1345 
1346 
1347  // std::cout << "Matched hit: isMatched =\t" << theMatchedHit->isMatched() << ", "
1348  // << theMatchedHit->monoHit() << ", " << theMatchedHit->stereoHit() << std::endl;
1349 
1350  matchedMap[it->first].push_back( theMatchedHit );
1351  }
1352  else{
1353  // no partner to match, place projected one in map
1354  SiTrackerGSMatchedRecHit2D * theProjectedHit = GSRecHitMatcher().projectOnly( &(*rit), geometry->idToDet(detid),gluedDet, gluedsimtrackdir );
1355  matchedMap[it->first].push_back( theProjectedHit );
1356  //there is no partner here
1357  }
1358  } // end if stereo
1359  else { // we are on a mono layer
1360  // usually this hit is already matched, but not if stereo hit is missing (rare cases)
1361  // check if stereo hit is missing
1362  int partnersFound = 0;
1363  // check next one in vector
1364  // safety check first
1365  if(partnerNext != it->second.end() )
1366  if( StripSubdetector( partnerNext->geographicalId() ).partnerDetId() == detid.rawId() ) {
1367  partnersFound++;
1368  }
1369  // check prevoius one in vector
1370  if( rit != it->second.begin())
1371  if( StripSubdetector( partnerPrev->geographicalId() ).partnerDetId() == detid.rawId() ) {
1372  partnersFound++;
1373  }
1374 
1375  if(partnersFound==0){ // no partner hit found this way, need to iterate over all hits to be sure (rare cases)
1376  for(edm::OwnVector<SiTrackerGSRecHit2D>::const_iterator iter = firstRecHit; iter != lastRecHit; ++iter ){
1377  if( StripSubdetector( iter->geographicalId() ).partnerDetId() == detid.rawId()){
1378  partnersFound++;
1379  }
1380  }
1381  }
1382 
1383 
1384  if(partnersFound==0){ // no partner hit found
1385  // no partner to match, place projected one one in map
1386  SiTrackerGSMatchedRecHit2D * theProjectedHit =
1387  GSRecHitMatcher().projectOnly( &(*rit), geometry->idToDet(detid),gluedDet, gluedsimtrackdir );
1388 
1389  //std::cout << "Projected hit: isMatched =\t" << theProjectedHit->isMatched() << ", "
1390  // << theProjectedHit->monoHit() << ", " << theProjectedHit->stereoHit() << std::endl;
1391 
1392  matchedMap[it->first].push_back( theProjectedHit );
1393  }
1394  } // end we are on a a mono layer
1395  } // end if glued
1396  // else matchedMap[it->first].push_back( rit->clone() ); // if not glued place the original one in vector
1397  else{ //need to copy the original in a "matched" type rechit
1398 
1399  SiTrackerGSMatchedRecHit2D* rit_copy = new SiTrackerGSMatchedRecHit2D(rit->localPosition(), rit->localPositionError(),
1400  rit->geographicalId(),
1401  rit->simhitId(), rit->simtrackId(), rit->eeId(),
1402  rit->cluster(),
1403  rit->simMultX(), rit->simMultY());
1404  //std::cout << "Simple hit hit: isMatched =\t" << rit_copy->isMatched() << ", "
1405  // << rit_copy->monoHit() << ", " << rit_copy->stereoHit() << std::endl;
1406 
1407  matchedMap[it->first].push_back( rit_copy ); // if not strip place the original one in vector (making it into a matched)
1408  }
1409 
1410  }// end if strip
1411  // else matchedMap[it->first].push_back( rit->clone() ); // if not strip place the original one in vector
1412  else { //need to copy the original in a "matched" type rechit
1413 
1414  SiTrackerGSMatchedRecHit2D* rit_copy = new SiTrackerGSMatchedRecHit2D(rit->localPosition(), rit->localPositionError(),
1415  rit->geographicalId(),
1416  rit->simhitId(), rit->simtrackId(), rit->eeId(),
1417  rit->cluster(),
1418  rit->simMultX(), rit->simMultY());
1419 
1420  //std::cout << "Simple hit hit: isMatched =\t" << rit_copy->isMatched() << ", "
1421  // << rit_copy->monoHit() << ", " << rit_copy->stereoHit() << std::endl;
1422  matchedMap[it->first].push_back( rit_copy ); // if not strip place the original one in vector (makining it into a matched)
1423  }
1424 
1425  } // end loop over rechits
1426 
1427  }// end loop over tracks
1428 
1429 
1430 }
Surface::toGlobal
GlobalPoint toGlobal(const Point2DBase< Scalar, LocalTag > lp) const
Definition: Surface.h:78
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
ErrorFrameTransformer::transform
static GlobalError transform(const LocalError &le, const Surface &surf)
Definition: ErrorFrameTransformer.h:12
i
int i
Definition: DBlmapReader.cc:9
LocalError::xx
float xx() const
Definition: LocalError.h:24
SiTrackerGaussianSmearingRecHitConverter::loadRecHits
void loadRecHits(std::map< unsigned, edm::OwnVector< SiTrackerGSRecHit2D > > &theRecHits, SiTrackerGSRecHit2DCollection &theRecHitCollection) const
Definition: SiTrackerGaussianSmearingRecHitConverter.cc:1233
SiTrackerGaussianSmearingRecHitConverter::theSiStripErrorParametrization
SiStripGaussianSmearingRecHitConverterAlgorithm * theSiStripErrorParametrization
Definition: SiTrackerGaussianSmearingRecHitConverter.h:229
Bounds::length
virtual float length() const =0
SiTrackerGaussianSmearingRecHitConverter::smearHits
void smearHits(MixCollection< PSimHit > &input, std::map< unsigned, edm::OwnVector< SiTrackerGSRecHit2D > > &theRecHits, std::map< unsigned, edm::OwnVector< FastTrackerCluster > > &theClusters)
Definition: SiTrackerGaussianSmearingRecHitConverter.cc:676
PV3DBase::perp
T perp() const
Definition: PV3DBase.h:71
TOBDetId::layer
unsigned int layer() const
layer id
Definition: TOBDetId.h:39
SiTrackerGaussianSmearingRecHitConverter::thePixelEndcapParametrization
SiPixelGaussianSmearingRecHitConverterAlgorithm * thePixelEndcapParametrization
Definition: SiTrackerGaussianSmearingRecHitConverter.h:227
SiStripGaussianSmearingRecHitConverterAlgorithm::smearHit
void smearHit(const PSimHit &simHit, double localPositionResolutionX, double localPositionResolutionY, double localPositionResolutionZ, double boundX, double boundY)
Definition: SiStripGaussianSmearingRecHitConverterAlgorithm.cc:25
GSRecHitMatcher::match
SiTrackerGSMatchedRecHit2D * match(const SiTrackerGSRecHit2D *monoRH, const SiTrackerGSRecHit2D *stereoRH, const GluedGeomDet *gluedDet, LocalVector &trackdirection) const
Definition: GSRecHitMatcher.cc:9
MagneticField::inTesla
virtual GlobalVector inTesla(const GlobalPoint &gp) const =0
Field value ad specified global point, in Tesla.
LaserDQM_cfg.input
tuple input
Definition: LaserDQM_cfg.py:38
HLT_ES_cff.magfield
tuple magfield
Definition: HLT_ES_cff.py:2311
PV3DBase::y
T y() const
Definition: PV3DBase.h:62
SiTrackerGaussianSmearingRecHitConverter::produce
virtual void produce(edm::Event &e, const edm::EventSetup &c)
Definition: SiTrackerGaussianSmearingRecHitConverter.cc:617
SiTrackerGaussianSmearingRecHitConverter::loadClusters
void loadClusters(std::map< unsigned, edm::OwnVector< FastTrackerCluster > > &theClusterMap, FastTrackerClusterCollection &theClusterCollection) const
Definition: SiTrackerGaussianSmearingRecHitConverter.cc:1216
position
static int position[TOTALCHAMBERS][3]
Definition: ReadPGInfo.cc:509
MixCollection::size
int size() const
Definition: MixCollection.h:23
PXBDetId::layer
unsigned int layer() const
layer id
Definition: PXBDetId.h:35
Association.map
dictionary map
Definition: Association.py:205
DetId::rawId
uint32_t rawId() const
get the raw id
Definition: DetId.h:45
MixCollection::end
iterator end()
Definition: MixCollection.h:275
LocalError::xy
float xy() const
Definition: LocalError.h:25
StripSubdetector::glued
unsigned int glued() const
glued
Definition: StripSubdetector.h:27
PV3DBase::mag
T mag() const
Definition: PV3DBase.h:66
LocalError::yy
float yy() const
Definition: LocalError.h:26
PSimHit::localPosition
Local3DPoint localPosition() const
Definition: PSimHit.h:44
edm::Event::put
OrphanHandle< PROD > put(std::auto_ptr< PROD > product)
Put a new product.
Definition: Event.h:85
GloballyPositioned::toLocal
LocalPoint toLocal(const GlobalPoint &gp) const
Definition: GloballyPositioned.h:118
SiTrackerGaussianSmearingRecHitConverter::loadMatchedRecHits
void loadMatchedRecHits(std::map< unsigned, edm::OwnVector< SiTrackerGSMatchedRecHit2D > > &theRecHits, SiTrackerGSMatchedRecHit2DCollection &theRecHitCollection) const
Definition: SiTrackerGaussianSmearingRecHitConverter.cc:1249
TIDDetId::ring
unsigned int ring() const
ring id
Definition: TIDDetId.h:55
edm::Service::isAvailable
bool isAvailable() const
Definition: Service.h:47
SiTrackerGaussianSmearingRecHitConverter::gaussianSmearing
bool gaussianSmearing(const PSimHit &simHit, Local3DPoint &position, LocalError &error, unsigned &alphaMult, unsigned &betaMult)
Definition: SiTrackerGaussianSmearingRecHitConverter.cc:850
end
#define end
Definition: vmac.h:38
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
SiTrackerGaussianSmearingRecHitConverter::thePixelBarrelParametrization
SiPixelGaussianSmearingRecHitConverterAlgorithm * thePixelBarrelParametrization
Definition: SiTrackerGaussianSmearingRecHitConverter.h:225
SiTrackerGaussianSmearingRecHitConverter::disabledModules
std::vector< SiPixelQuality::disabledModuleType > * disabledModules
Definition: SiTrackerGaussianSmearingRecHitConverter.h:106
TrackerGeometry::idToDet
virtual const GeomDet * idToDet(DetId) const
Definition: TrackerGeometry.cc:137
edm::Event::getByLabel
bool getByLabel(InputTag const &tag, Handle< PROD > &result) const
Definition: Event.h:356
PXFDetId::disk
unsigned int disk() const
disk id
Definition: PXFDetId.h:43
edm::Event::getRefBeforePut
RefProd< PROD > getRefBeforePut()
Definition: Event.h:97
dbtoconf.conf
tuple conf
Definition: dbtoconf.py:185
edm::RangeMap::put
void put(ID id, CI begin, CI end)
insert an object range with specified identifier
Definition: RangeMap.h:119
Local3DPoint
Point3DBase< float, LocalTag > Local3DPoint
Definition: LocalPoint.h:9
DetId
Definition: DetId.h:20
StripSubdetector::stereo
unsigned int stereo() const
stereo
Definition: StripSubdetector.h:43
BoundSurface::bounds
const Bounds & bounds() const
Definition: BoundSurface.h:89
MixCollection::begin
iterator begin()
Definition: MixCollection.h:270
edm::EventSetup::get
const T & get() const
Definition: EventSetup.h:55
GSRecHitMatcher::projectOnly
SiTrackerGSMatchedRecHit2D * projectOnly(const SiTrackerGSRecHit2D *monoRH, const GeomDet *monoDet, const GluedGeomDet *gluedDet, LocalVector &ldir) const
Definition: GSRecHitMatcher.cc:167
GeomDet::alignmentPositionError
AlignmentPositionError * alignmentPositionError() const
Return pointer to alignment errors.
Definition: GeomDet.h:88
AlignmentPositionError::globalError
const GlobalError & globalError() const
Definition: AlignmentPositionError.h:27
RandomEngine::flatShoot
double flatShoot(double xmin=0.0, double xmax=1.0) const
Definition: RandomEngine.h:30
TIBDetId::layer
unsigned int layer() const
layer id
Definition: TIBDetId.h:41
TrackerGeometry::idToDetUnit
virtual const GeomDetUnit * idToDetUnit(DetId) const
Return the pointer to the GeomDetUnit corresponding to a given DetId.
Definition: TrackerGeometry.cc:126
GeomDet::surface
const BoundPlane & surface() const
The nominal surface of the GeomDet.
Definition: GeomDet.h:35
edm::OwnVector::const_iterator
Definition: OwnVector.h:42
TECDetId::ring
unsigned int ring() const
ring id
Definition: TECDetId.h:71
LocalPoint
Local3DPoint LocalPoint
Definition: LocalPoint.h:11
SiPixelGaussianSmearingRecHitConverterAlgorithm::smearHit
void smearHit(const PSimHit &simHit, const PixelGeomDetUnit *detUnit, const double boundX, const double boundY)
Definition: SiPixelGaussianSmearingRecHitConverterAlgorithm.cc:104
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:121
Bounds
Definition: Bounds.h:18
SiTrackerGaussianSmearingRecHitConverter::matchHits
void matchHits(std::map< unsigned, edm::OwnVector< SiTrackerGSRecHit2D > > &theRecHits, std::map< unsigned, edm::OwnVector< SiTrackerGSMatchedRecHit2D > > &matchedMap, MixCollection< PSimHit > &simhits)
Definition: SiTrackerGaussianSmearingRecHitConverter.cc:1266
SiTrackerGaussianSmearingRecHitConverter::beginRun
virtual void beginRun(edm::Run &run, const edm::EventSetup &es)
Definition: SiTrackerGaussianSmearingRecHitConverter.cc:501
PV3DBase::x
T x() const
Definition: PV3DBase.h:61
Bounds::width
virtual float width() const =0
GloballyPositioned::position
const PositionType & position() const
Definition: GloballyPositioned.h:41
GluedGeomDet::stereoDet
const GeomDetUnit * stereoDet() const
Definition: GluedGeomDet.h:21
PSimHit::detUnitId
unsigned int detUnitId() const
Definition: PSimHit.h:93
edm::Run
Definition: Run.h:33
Generated for CMSSW Reference Manual by doxygen 1.8.5