CMS 3D CMS Logo

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
TMTrackProducer_Defaults_cfi.py
Go to the documentation of this file.
1 import FWCore.ParameterSet.Config as cms
2 
3 #---------------------------------------------------------------------------------------------------------
4 # This describes the full TMTT track reconstruction chain with 3 GeV threshold, where:
5 # the GP divides the tracker into 18 eta sectors (each sub-divided into 2 virtual eta subsectors);
6 # the HT uses a 32x18 array followed by 2x2 mini-HT array, with transverese HT readout & multiplexing,
7 # followed by the KF (or optionally SF+SLR) track fit; duplicate track removal (Algo50) is run.
8 #---------------------------------------------------------------------------------------------------------
9 
10 TMTrackProducer_params = cms.PSet(
11 
12  # Tags for ES products
13  magneticFieldInputTag = cms.ESInputTag( "VolumeBasedMagneticFieldESProducer", "" ),
14  trackerGeometryInputTag = cms.ESInputTag( "trackerGeometry", "" ),
15  trackerTopologyInputTag = cms.ESInputTag( "trackerTopology", "" ),
16  ttStubAlgoInputTag = cms.ESInputTag( "TTStubAlgorithm_official_Phase2TrackerDigi_", "" ),
17 
18  # Tags for ED products
19  tpInputTag = cms.InputTag("mix", "MergedTrackTruth"),
20  stubInputTag = cms.InputTag("TTStubsFromPhase2TrackerDigis", "StubAccepted"),
21  stubTruthInputTag = cms.InputTag("TTStubAssociatorFromPixelDigis", "StubAccepted"),
22  clusterTruthInputTag = cms.InputTag("TTClusterAssociatorFromPixelDigis", "ClusterAccepted"),
23  genJetInputTag = cms.InputTag("ak4GenJets", ""),
24 
25  # Enable output of TTTracks from part-way through tracking chain (after HT & RZ).
26  EnableOutputIntermediateTTTracks = cms.bool(False),
27 
28  # Enable all use of MC truth info (disable to save CPU)
29  EnableMCtruth = cms.bool(False),
30  # Enable output histograms & job tracking performance summary (disable to save CPU)
31  EnableHistos = cms.bool(False),
32 
33  #=== Cuts on MC truth particles (i.e., tracking particles) used for tracking efficiency measurements.
34 
35  GenCuts = cms.PSet(
36  GenMinPt = cms.double(3.0),
37  GenMaxAbsEta = cms.double(2.4),
38  GenMaxVertR = cms.double(1.0), # Max distance of particle production vertex from centre of CMS.
39  GenMaxVertZ = cms.double(30.0),
40  GenMaxD0 = cms.double(5.0), # Max transverse impact parameter.
41  GenMaxZ0 = cms.double(999.0), # Max transverse impact parameter.
42  GenPdgIds = cms.vuint32(), # Only particles with these PDG codes used for efficiency measurement.
43 
44  # Cut on MC truth tracks used for algorithmic tracking efficiency measurements.
45  GenMinStubLayers = cms.uint32(4)
46  ),
47 
48  #=== Cuts applied to stubs before arriving in L1 track finding board.
49 
50  StubCuts = cms.PSet(
51  # Reduce number of bits used by front-end chips to store stub bend info?
52  # = 0 (no); = 1 (yes using official recipe); = 2 (yes using TMTT method)
53  DegradeBendRes = cms.uint32(2),
54  # Don't use stubs with eta beyond this cut, since the tracker geometry makes it impossible to reconstruct tracks with them.
55  MaxStubEta = cms.double(2.4),
56  # Don't use stubs whose measured Pt from bend info is significantly below HTArraySpec.HoughMinPt, where "significantly" means allowing for resolution in q/Pt derived from stub bend resolution specified below.
57  KillLowPtStubs = cms.bool(True),
58  # Print FE stub window sizes recommended by this code (in python cfg format used by CMSSW).
59  PrintStubWindows = cms.bool(False),
60  # Bend resolution assumed by bend filter in units of strip pitch. Also used when assigning stubs to sectors if EtaPhiSectors.CalcPhiTrkRes=True. And by the bend filter if HTFillingRphi.UseBendFilter=True.
61  # Suggested value: 1.19 if DegradeBendRes = 0, or 1.249 if it > 0.
62  # N.B. Avoid 1/4-integer values due to rounding error issues.
63  BendCut = cms.double(1.249),
64  # Additional contribution to bend resolution from its encoding into a reduced number of bits.
65  # This number is the assumed resolution relative to the naive guess of its value.
66  # It is ignored in DegradeBendRes = 0.
67  BendCutExtra = cms.double(0.0),
68  # Order stubs by bend in DTC, such that highest Pt stubs are transmitted first.
69  OrderStubsByBend = cms.bool(True)
70  ),
71 
72  #=== Optional Stub digitization.
73 
74  StubDigitize = cms.PSet(
75  EnableDigitize = cms.bool(True), # Digitize stub coords? If not, use floating point coords.
76  #
77  #--- Parameters available in MP board. (And in case of Hybrid used internally in KF)
78  #
79  PhiSectorBits = cms.uint32(6), # Bits used to store phi sector number -- NOT USED
80  PhiSBits = cms.uint32(14), # Bits used to store phiS coord. (13 enough?)
81  PhiSRange = cms.double(0.698131700), # Range phiS coord. covers in radians.
82  RtBits = cms.uint32(12), # Bits used to store Rt coord.
83  RtRange = cms.double(91.652837), # Range Rt coord. covers in units of cm.
84  ZBits = cms.uint32(14), # Bits used to store z coord.
85  ZRange = cms.double(733.2227), # Range z coord. covers in units of cm.
86  #
87  #--- Parameters available in GP board (excluding any in common with MP specified above).
88  #
89  PhiNBits = cms.uint32(15), # Bits used to store PhiO parameter.
90  PhiNRange = cms.double(1.3962634), # Range PhiO parameter covers.
91  BendBits = cms.uint32(6) # Bits used to store stub bend.
92  ),
93 
94  #=== Configuration of tracker module type. Only provides test data for firmware.
95 
96  TrackerModuleType = cms.PSet(
97  # Modules matching these criteria are type 0, 1, 2, 3 ...
98  PitchVsType = cms.vdouble(0.0099, 0.0099, 0.0099, 0.0099, 0.0089, 0.0099, 0.0089, 0.0089),
99  SpaceVsType = cms.vdouble(0.26 , 0.26 , 0.16 , 0.4 , 0.18 , 0.4 , 0.18 , 0.4 ),
100  # (Type vbool not implemented, so use vuint32 instead ...)
101  BarrelVsType = cms.vuint32( 1 , 1 , 1 , 1 , 1 , 0 , 0 , 0 ),
102  PSVsType = cms.vuint32( 1 , 1 , 1 , 1 , 0 , 1 , 0 , 0 ),
103  TiltedVsType = cms.vuint32( 0 , 1 , 0 , 1 , 0 , 0 , 0 , 0 )
104  ),
105 
106  #=== Configuration of Geometric Processor.
107 
108  GeometricProc = cms.PSet(
109  # Use an FPGA-friendly approximation to determine track angle dphi from bend in GP?
110  UseApproxB = cms.bool(True), # Use approximation for B
111  # Params of approximation if used.
112  BApprox_gradient = cms.double(0.886454), # Gradient term of linear equation for approximating B
113  BApprox_intercept = cms.double(0.504148) # Intercept term of linear equation for approximating B
114  ),
115 
116  #=== Division of Tracker into phi sectors.
117 
118  PhiSectors = cms.PSet(
119  NumPhiNonants = cms.uint32(9), # Divisions of Tracker at DTC
120  NumPhiSectors = cms.uint32(18), # Divisions of Tracker at GP.
121  ChosenRofPhi = cms.double(67.240), # Use phi of track at this radius for assignment of stubs to phi sectors & also for one of the axes of the r-phi HT. If ChosenRofPhi=0, then use track phi0. - Should be an integer multiple of the stub r digitisation granularity.
122  #--- You can set one or both the following parameters to True.
123  UseStubPhi = cms.bool(True), # Require stub phi to be consistent with track of Pt > HTArraySpec.HoughMinPt that crosses HT phi axis?
124  UseStubPhiTrk = cms.bool(True), # Require stub phi0 (or phi65 etc.) as estimated from stub bend, to lie within HT phi axis, allowing tolerance(s) specified below?
125  AssumedPhiTrkRes = cms.double(0.5), # Tolerance in stub phi0 (or phi65) assumed to be this fraction of phi sector width. (N.B. If > 0.5, then stubs can be shared by more than 2 phi sectors).
126  CalcPhiTrkRes = cms.bool(True) # If true, tolerance in stub phi0 (or phi65 etc.) will be reduced below AssumedPhiTrkRes if stub bend resolution specified in StubCuts.BendCut suggests it is safe to do so.
127  ),
128 
129  #=== Division of Tracker into eta sectors
130 
131  EtaSectors = cms.PSet(
132 # Eta boundaries for 18 eta regions
133 # EtaRegions = cms.vdouble(-2.4,-2.16,-1.95,-1.7,-1.43,-1.16,-0.89,-0.61,-0.31,0.0,0.31,0.61,0.89,1.16,1.43,1.7,1.95,2.16,2.4),
134 # Eta boundaries for 16 eta regions
135  EtaRegions = cms.vdouble(-2.4,-2.08,-1.68,-1.26,-0.90,-0.62,-0.41,-0.20,0.0,0.20,0.41,0.62,0.90,1.26,1.68,2.08,2.4),
136  ChosenRofZ = cms.double(50.), # Use z of track at this radius for assignment of tracks to eta sectors & also for one of the axes of the r-z HT. Do not set to zero!
137  BeamWindowZ = cms.double(15), # Half-width of window assumed to contain beam-spot in z.
138  AllowOver2EtaSecs = cms.bool(True) # If True, the code will not throw an error if a stub is assigned to 3 or more eta sectors.
139  ),
140 
141  #=== r-phi Hough transform array specifications.
142 
143  HTArraySpecRphi = cms.PSet(
144  HoughMinPt = cms.double(3.0), # Min track Pt that Hough Transform must find. Also used by StubCuts.KillLowPtStubs and by EtaPhiSectors.UseStubPhi.
145  # If MiniHTstage = True, these refers to mini cells in whole HT array.
146  HoughNbinsPt = cms.uint32(32), # HT array dimension in track q/Pt. (If MiniHTstage = True, this refers to mini cells in whole HT array).
147  HoughNbinsPhi = cms.uint32(64), # HT array dimension in track phi0 (or phi65 or any other track phi angle. (If MiniHTstage = True, this refers to mini cells in whole HT array).
148  EnableMerge2x2 = cms.bool(False), # Groups of neighbouring 2x2 cells in HT will be treated as if they are a single large cell? N.B. You can only enable this option if your HT array has even numbers of bins in both dimensions. And this cfg param ignored if MiniHTstage = True. HISTORIC OPTION. SUGGEST NOT USING!
149  MaxPtToMerge2x2 = cms.double(3.5), # but only cells with pt < MaxPtToMerge2x2 will be merged in this way (irrelevant if EnableMerge2x2 = false).
150  NumSubSecsEta = cms.uint32(2), # Subdivide each sector into this number of subsectors in eta within r-phi HT.
151  Shape = cms.uint32(0), # cell shape: 0 for square, 1 for diamond, 2 hexagon (with vertical sides), 3 square with alternate rows shifted by 0.5*cell_width.
152  MiniHTstage = cms.bool(True), # Run 2nd stage HT with mini cells inside each 1st stage normal HT cell..
153  MiniHoughNbinsPt = cms.uint32(2), # Number of mini cells along q/Pt axis inside each normal HT cell.
154  MiniHoughNbinsPhi = cms.uint32(2), # Number of mini cells along phi axis inside each normal HT cell.
155  MiniHoughMinPt = cms.double(3.0), # Below this Pt threshold, the mini HT will not be used, to reduce sensitivity to scattering, with instead tracks found by 1st stage coarse HT sent to output. (HT cell numbering remains as if mini HT were in use everywhere).
156  MiniHoughDontKill = cms.bool(False), # If true, allows tracks found by 1st stage coarse HT to be output if 2nd stage mini HT finds no tracks.
157  MiniHoughDontKillMinPt = cms.double(8.0), # If MiniHoughDontKill=True, this option restricts it to keep 1st stage HT tracks only if their Pt is exceeds this cut. (Used to improve electron tracking above this threshold).
158  MiniHoughLoadBalance = cms.uint32(2) # Load balancing disabled = 0; static load balancing of output links = 1; dynamic load balancing of output links = 2.
159  ),
160 
161  #=== Rules governing how stubs are filled into the r-phi Hough Transform array.
162 
163  HTFillingRphi = cms.PSet(
164  # Take all cells in r-phi HT array crossed by line corresponding to each stub (= 0) or take only some to reduce rate at cost
165  # of efficiency ( > 0). If this option is > 0, it can be 1 or 2, corresponding to different algorithms for rejecting
166  # some of the cells. "1" is an algorithm invented by Ian, whereas "2" corresponds to Thomas' 1st firmware implementation which only handled 1 cell per HT column.
167  # Suggest setting KillSomeHTCellsRphi=1 (=0) if HTArraySpec.ChosenRofPhi=0 (>0)
168  KillSomeHTCellsRphi = cms.uint32(0),
169  # Use filter in each r-phi HT cell, filling it only with stubs that have consistent bend information?
170  # The assumed bend resolution is specified in StubCuts.BendCut.
171  UseBendFilter = cms.bool(True),
172  # Use filter in each HT cell, preventing more than the specified number of stubs being stored in the cell. (Reflecting memory limit of hardware). N.B. Results depend on assumed order of stubs.
173  # N.B. If mini-HT is in use, then this cut applies to coarse-HT.
174  #MaxStubsInCell = cms.uint32(99999), # Setting this to anything more than 999 disables this option
175  MaxStubsInCell = cms.uint32(32), # set it equal to value used in hardware.
176  MaxStubsInCellMiniHough = cms.uint32(16), # Same type of cut for mini-HT (if in use)
177  # If BusySectorKill = True, and more than BusySectorNumStubs stubs are assigned to tracks by an r-phi HT array, then the excess tracks are killed, with lowest Pt ones killed first. This is because HT hardware has finite readout time.
178  BusySectorKill = cms.bool(True),
179  BusySectorNumStubs = cms.uint32(162), # Or 144 if only 320 MHz FW.
180  # If BusySectorMbinRanges is not empty, then the BusySectorNumStubs cut is instead applied to the subset of tracks appearing in the following m bin (q/Pt) ranges of the HT array. The sum of the entries in the vector should equal the number of m bins in the HT. (N.B. If EnableMerge2x2 or MiniHTstage = True, then the m bin ranges here correspond to the bins before merging. Also in these cases, the odd m-bin numbers don't correspond to HT outputs, so should be all grouped together on a single imaginary link).
181  # If BusySectorMbinOrder is not empty, then the m-bins are grouped in the specified order, instead of sequentially.
182  # (Histos NumStubsPerLink, NumStubsVsLink & MeanStubsPerLink useful for optimising this option).
183  #
184  # Choice for 16x32 coarse HT array followed by 2x2 mini-HT array with 3 GeV Pt threshold.
185  BusySectorMbinRanges = cms.vuint32(1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 16),
186  BusySectorMbinOrder = cms.vuint32(0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30, 1,3,5,7,9,11,13,15,17,19,21,23,25,27,29,31),
187  # Choice for 24x32 coarse HT array followed by 2x2 mini-HT array with 2 GeV Pt threshold.
188  #BusySectorMbinRanges = cms.vuint32(1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 24),
189  #BusySectorMbinOrder = cms.vuint32(0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,38,40,42,44,46, 1,3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33,35,37,39,41,43,45,47),
190  #
191  # If BusyInputSectorKill = True, and more than BusyInputSectorNumStubs are input to the HT array from the GP, then
192  # the excess stubs are killed. This is because HT hardware has finite readin time.
193  # Results unreliable as depend on assumed order of stubs.
194  BusyInputSectorKill = cms.bool(True),
195  BusyInputSectorNumStubs = cms.uint32(162), # Or 144 if only 320 MHz FW
196  # Multiplex the outputs from several HTs onto a single pair of output optical links?
197  # Options: 0 = disable Mux; 1 = Sept 2019 Mux (transerse HT readout by m-bin), with single m bin in entire nonant going to each link.
198  MuxOutputsHT = cms.uint32(1),
199  # If this is non-empty, then only the specified eta sectors are enabled, to study them individually.
200  EtaRegWhitelist = cms.vuint32()
201  ),
202 
203  #=== Options controlling r-z track filters (or any other track filters run after the Hough transform, as opposed to inside it).
204  #=== (Irrelevant for track fitters that don't require any r-z filter run before them).
205 
206  RZfilterOpts = cms.PSet(
207  # Specify preferred r-z filter (from those available inside TrkRZfilter.cc) - currently only "SeedFilter".
208  RZFilterName = cms.string("SeedFilter"),
209  #--- Options relevant for Seed filter, (so only relevant if rzFilterName="SeedFilter").
210  # Cut at this many standard deviations on seed resolution.
211  SeedResCut = cms.double(1.732),
212  # Store stubs compatible with all possible good seed.
213  KeepAllSeed = cms.bool(False),
214  # Maximum number of seed combinations to bother checking per track candidate.
215  #MaxSeedCombinations = cms.uint32(999),
216  MaxSeedCombinations = cms.uint32(15),
217  # Maximum number of seed combinations consistent with (z0,eta) sector constraints to bother checking per track candidate.
218  #MaxGoodSeedCombinations = cms.uint32(13),
219  MaxGoodSeedCombinations = cms.uint32(10),
220  # Maximum number of seeds that a single stub can be included in.
221  MaxSeedsPerStub = cms.uint32(4),
222  # Reject tracks whose estimated rapidity from seed filter is inconsistent range of with eta sector. (Kills some duplicate tracks).
223  zTrkSectorCheck = cms.bool(True),
224  # Min. number of layers in rz track that must have stubs for track to be declared found by seed filter.
225  MinFilterLayers = cms.uint32(4)
226  ),
227 
228  #=== Rules for deciding when the (HT) track finding has found an L1 track candidate
229 
230  L1TrackDef = cms.PSet(
231  # Min. number of layers the track must have stubs in.
232  MinStubLayers = cms.uint32(5),
233  # Change min. number of layers cut to (MinStubLayers - 1) for tracks with Pt exceeding this cut.
234  # If this is set to a -ve number, this option is disabled.
235  MinPtToReduceLayers = cms.double(-99999.),
236  # Change min. number of layers cut to (MinStubLayers - 1) for tracks in these rapidity sectors.
237  # (Histogram "AlgEffVsEtaSec" will help you identify which sectors to declare).
238  #EtaSecsReduceLayers = cms.vuint32(),
239  EtaSecsReduceLayers = cms.vuint32(5,12),
240  # Reduce this layer ID, so that it takes no more than 8 different values in any eta region (simplifies firmware).
241  ReducedLayerID = cms.bool(True)
242  ),
243 
244  #=== Specification of algorithm to eliminate duplicate tracks.
245 
246  DupTrkRemoval = cms.PSet(
247  # Algorithm run on tracks after the track helix fit has been done.
248  # (Disable dup removal = 0; two alternative algos = 1 or 2).
249  DupTrkAlgFit = cms.uint32(1)
250  ),
251 
252  #=== Rules for deciding when a reconstructed L1 track matches a MC truth particle (i.e. tracking particle).
253 
254  TrackMatchDef = cms.PSet(
255  #--- Three different ways to define if a tracking particle matches a reco track candidate. (Usually, set two of them to ultra loose).
256  # Min. fraction of matched stubs relative to number of stubs on reco track.
257  MinFracMatchStubsOnReco = cms.double(-99.),
258  # Min. fraction of matched stubs relative to number of stubs on tracking particle.
259  MinFracMatchStubsOnTP = cms.double(-99.),
260  # Min. number of matched layers.
261  MinNumMatchLayers = cms.uint32(4),
262  # Min. number of matched PS layers.
263  MinNumMatchPSLayers = cms.uint32(0),
264  # Associate stub to TP only if the TP contributed to both its clusters? (If False, then associate even if only one cluster was made by TP).
265  StubMatchStrict = cms.bool(False)
266  ),
267 
268  #=== Track Fitting Algorithm Settings.
269 
270  TrackFitSettings = cms.PSet(
271  #
272  #--- Options applicable to all track fitters ---
273  #
274  # Track Fitting algortihms to use. You can run several in parallel.
275  # TrackFitLinearAlgo & ChiSquared* are chi2 fits, KF* is a Kalman filter fit,
276  # & SimpleLR4 is a linear regression fit that neglects the hit uncertainties.
277  # The number 4 or 5 in the name indicates if 4 or 5 helix parameters are fitted.
278  # Options KF4ParamsComb, KF5ParamsComb or SimpleLR4 are the best ones.
279  # KF*ParamsCombHLS is the HLS version of the code, which only works if linked with Vivado libraries.
280  TrackFitters = cms.vstring(
281  # "ChiSquaredFit4",
282  # "SimpleLR4",
283  # "KF4ParamsCombHLS",
284  # "KF5ParamsCombHLS",
285  "KF5ParamsComb",
286  "KF4ParamsComb"
287  ),
288  # Indicate subset of fitters wanting r-z track filter to be run before them. (Irrelevant for those not specified in "TrackFitters").
289  # Typically, Chi2 & LR fits work best with r-z filter & KF works best without it.
290  UseRZfilter = cms.vstring(
291  "ChiSquaredFit4",
292  "SimpleLR4"
293  ),
294  # Print detailed summary of track fit performance at end of job (as opposed to a brief one).
295  DetailedFitOutput = cms.bool(False),
296  #
297  # Use MC truth to eliminate all fake tracks & all incorrect stubs assigned to tracks before doing fit.
298  TrackFitCheat = cms.bool(False),
299  #
300  #--- Options for chi2 track fitter ---
301  #
302  # Number of fitting iterations to undertake. (15 is not realistic in hardware, but is necessary to kill bad hits)
303  NumTrackFitIterations = cms.uint32(15),
304  # Optionally kill hit with biggest residuals in track fit (occurs after the first fit, so three iterations would have two killings).
305  KillTrackFitWorstHit = cms.bool(True),
306  # Cuts in standard deviations used to kill hits with big residuals during fit. If the residual exceeds the "General" cut, the hit is killed providing it leaves the track with enough hits to survive. If the residual exceeds the "Killing" cut, the hit is killed even if that kills the track.
307  GeneralResidualCut = cms.double(3.0),
308  KillingResidualCut = cms.double(20.0),
309  #
310  #--- Additional options for Thomas Schuh's Linear Regression track fitter ---
311  #
312  # Maximum allowed number of iterations of LR fitter.
313  MaxIterationsLR = cms.uint32( 8 ),
314  # If False: residual of a stub is the max of its r-phi & r-z residuals.
315  # If True: the residual is the mean of these residuals.
316  CombineResiduals = cms.bool( True ),
317  # Correct stub phi coordinate for higher orders in circle expansion, so that a trajectory is straight in r-phi.
318  LineariseStubPosition = cms.bool( True ),
319  # Checks if the fitted track is consistent with the sector, if not it will be not accepted.
320  CheckSectorConsistency = cms.bool( False ),
321  # Checks if the fitted track r phi parameter are consistent with the HT candidate parameter within in range of +- 2 cells.
322  CheckHTCellConsistency = cms.bool( False ),
323  # Tracks must have stubs in at least this number of PS layers.
324  MinPSLayers = cms.uint32( 2 ),
325  # Digitization
326  DigitizeLR = cms.bool( False ),
327  PhiPrecision = cms.double( 0.009 / 108. ),
328  RPrecision = cms.double( 0.14 ),
329  ZPrecision = cms.double( 0.28 ),
330  ZSlopeWidth = cms.uint32( 11 ),
331  ZInterceptWidth = cms.uint32( 11 ),
332  #
333  #--- Additional options for Davide Cieri's Simple Linear Regression track fitter ---
334  #
335  # Digitize Simple Linear Regression variables and calculation. (Disabled if EnableDigitize=False).
336  DigitizeSLR = cms.bool(False), # Disable, as was never retuned for nonants
337  # Number of bits to be used in hardware to compute the division needed to calculate the helix params
338  DividerBitsHelix = cms.uint32(23),
339  DividerBitsHelixZ = cms.uint32(23),
340  # Number of bits to reduce the rphi helix parameter calculation weight
341  ShiftingBitsDenRPhi = cms.uint32(14),
342  # Number of bits to reduce the rphi helix parameter calculation weight
343  ShiftingBitsDenRZ = cms.uint32(14),
344  # Number of bits to reduce the phi0 parameter calculation weight
345  ShiftingBitsPhi = cms.uint32(10),
346  # Number of bits to reduce the qOverPt parameter calculation weight
347  ShiftingBitsPt = cms.uint32(3),
348  # Number of bits to reduce the tanLambda parameter calculation weight
349  ShiftingBitsLambda = cms.uint32(1),
350  # Number of bits to reduce the z0 parameter calculation weight
351  ShiftingBitsZ0 = cms.uint32(16),
352  # Fit ChiSquare Cut (tightening reduces fake track rate at cost of efficiency)
353  SLR_chi2cut = cms.double(300.),
354  # Cut on Rphi Residuals (radians) - stubs killed until only 4 left or all have residuals below this cut.
355  ResidualCut = cms.double(0.0),
356  #ResidualCut = cms.double(0.0005), # This allows more than 4 stubs per track.
357  #
358  #--- Options for Kalman filter track fitters ---
359  #
360  # Larger number has more debug printout. "1" is useful for understanding why tracks are lost, best combined with TrackFitCheat=True.
361  KalmanDebugLevel = cms.uint32(0),
362  # Fit will reject fitted tracks unless it can assign at least this number of stubs to them.
363  KalmanMinNumStubs = cms.uint32(4),
364  # Fit will attempt to add up to this nummber of stubs to each fitted tracks, but won't bother adding more.
365  KalmanMaxNumStubs = cms.uint32(4),
366  # For 5-param helix fits, calculate also beam-constrained helix params after fit is complete, & use them for duplicate removal if DupTrkAlgFit=1.
367  KalmanAddBeamConstr = cms.bool(True),
368  # Remove requirement of at least 2 PS layers per track.
369  KalmanRemove2PScut = cms.bool(False),
370  # Allow the KF to skip this many layers in total per track.
371  KalmanMaxSkipLayersHard = cms.uint32(1), # For HT tracks with many stubs
372  KalmanMaxSkipLayersEasy = cms.uint32(2), # For HT tracks with few stubs
373  KalmanMaxStubsEasy = cms.uint32(10), # Max stubs an HT track can have to be "easy".
374  KFUseMaybeLayers = cms.bool(False), # Disable "maybe layer" to match with firmware
375  #--- Cuts applied to KF states as a function of the last KF tracker layer they had a stub in.
376  # (If "4" or "5" in name, cut only applies to 4 or 5 param helix fit).
377  KFLayerVsPtToler = cms.vdouble(999., 999., 0.1 , 0.1 , 0.05, 0.05, 0.05),
378  # d0 cut only applied to 5 param helix fit.
379  KFLayerVsD0Cut5 = cms.vdouble(999., 999., 999., 10. , 10. , 10. ,10. ),
380  KFLayerVsZ0Cut5 = cms.vdouble(999., 999., 25.5, 25.5, 25.5, 25.5,25.5 ),
381  KFLayerVsZ0Cut4 = cms.vdouble(999., 999. ,15. , 15. , 15. , 15. ,15. ),
382  # Chi2 cuts should be retuned if KalmanMultiScattTerm value changed.
383  KFLayerVsChiSq5 = cms.vdouble(999., 999., 10. , 30. , 80. , 120., 160.),
384  KFLayerVsChiSq4 = cms.vdouble(999., 999., 10. , 30. , 80. , 120., 160.),
385  # KF will consider at most this #stubs per layer to save time.
386  KalmanMaxStubsPerLayer = cms.uint32(4),
387  # Multiple scattering term - inflate hit phi errors by this divided by Pt
388  # (0.00075 gives best helix resolution & 0.00450 gives best chi2 distribution).
389  KalmanMultiScattTerm = cms.double(0.00075),
390  # Scale down chi2 in r-phi plane by this factor to improve electron performance (should be power of 2)
391  KalmanChi2RphiScale = cms.uint32(8),
392  # N.B. KF track fit chi2 cut is not cfg param, but instead is hard-wired in KF4ParamsComb::isGoodState(...).
393  #--- Enable Higher order corrections
394  # Treat z uncertainty in tilted barrel modules correctly.
395  KalmanHOtilted = cms.bool(False),
396  # Higher order circle explansion terms for low Pt.
397  KalmanHOhelixExp = cms.bool(False),
398  # Alpha correction for non-radial 2S endcap strips. (0=disable correction, 1=correct with offset, 2=correct with non-diagonal stub covariance matrix). -- Option 1 is easier in FPGA, but only works if fit adds PS stubs before 2S ones.
399  KalmanHOalpha = cms.uint32(0),
400  # Projection from (r,phi) to (z,phi) for endcap 2S modules. (0=disable correction, 1=correct with offset, 2=correct with non-diagonal stub covariance matrix). -- Option 1 is easier in FPGA, but only works if fit adds PS stubs before 2S ones.
401  KalmanHOprojZcorr = cms.uint32(0),
402  # Use approx calc to account for non-radial endcap 2S modules corresponding to current FW, with no special treatment for tilted modules.
403  KalmanHOfw = cms.bool(True)
404  ),
405 
406  #=== Treatment of dead modules.
407 
408  DeadModuleOpts = cms.PSet(
409  # Emulate dead/inefficient modules using the StubKiller code, with stubs killed according to the scenarios of the Stress Test group.
410  # (0=Don't kill any stubs; 1-5 = Scenarios described in StubKiller.cc)
411  KillScenario = cms.uint32(0),
412  # Modify TMTT tracking to try to recover tracking efficiency in presence of dead modules. (Does nothing if KillScenario = 0).
413  KillRecover = cms.bool (True)
414  ),
415 
416  #=== Fitted track digitisation.
417 
418  TrackDigi=cms.PSet(
419  # For firmware reasons, can't use common digitisation cfg for all fitters.
420 
421  #======= SimpleLR4 digi parameters ========
422  SLR_skipTrackDigi = cms.bool( False ), # Optionally skip track digitisation if done internally inside fitting code.
423  SLR_oneOver2rBits = cms.uint32(13),
424  SLR_oneOver2rRange = cms.double(0.01354135),
425  SLR_d0Bits = cms.uint32(12), # Made up by Ian as never yet discussed.
426  SLR_d0Range = cms.double(10.),
427  SLR_phi0Bits = cms.uint32(18),
428  SLR_phi0Range = cms.double(1.3962636), # phi0 is actually only digitised relative to centre of sector.
429  SLR_z0Bits = cms.uint32(12),
430  SLR_z0Range = cms.double(51.555509),
431  SLR_tanlambdaBits = cms.uint32(15),
432  SLR_tanlambdaRange = cms.double(32.0),
433  SLR_chisquaredBits = cms.uint32(10),
434  SLR_chisquaredRange = cms.double(512.),
435 
436  #====== Kalman Filter digi parameters ========
437  KF_skipTrackDigi = cms.bool( False ), # Optionally skip track digitisation if done internally inside fitting code.
438  KF_oneOver2rBits = cms.uint32(15),
439  KF_oneOver2rRange = cms.double(0.0076171313), # pT > 1.5 GeV
440  KF_d0Bits = cms.uint32(12),
441  KF_d0Range = cms.double(31.992876),
442  KF_phi0Bits = cms.uint32(12),
443  KF_phi0Range = cms.double(0.6981317), # phi0 digitised relative to centre of sector. (Required range 2pi/18 + 2*overlap; overlap = 0.19206rads*(2GeV/ptCut)*(chosenR/67.24). MUST DOUBLE TO GO TO 2 GEV.
444  KF_z0Bits = cms.uint32(12),
445  KF_z0Range = cms.double(45.826419),
446  KF_tanlambdaBits = cms.uint32(16),
447  KF_tanlambdaRange = cms.double(16.),
448  KF_chisquaredBits = cms.uint32(15), # N.B. 17 bits are used internally inside KF.
449  KF_chisquaredRange = cms.double(1024.),
450  KF_chisquaredBinEdges = cms.vdouble(0, 0.5, 1, 2, 3, 5, 7, 10, 20, 40, 100, 200, 500, 1000, 3000 ), # Additional bin for >3000
451  KF_bendchisquaredBinEdges = cms.vdouble(0, 0.5, 1, 2, 3, 5, 10, 50 ), # Additional bin for >50
452 
453  #====== Other track fitter Digi params.
454  # Currently equal to those for KF, although you can skip track digitisation for them with following.
455  Other_skipTrackDigi = cms.bool( True )
456  ),
457 
458  #===== Use HYBRID TRACKING (Tracklet pattern reco + TMTT KF -- requires tracklet C++ too) =====
459 
460  Hybrid = cms.bool( False),
461 
462  #===== Debug plot options
463  # When making helix parameter resolution plots, only use particles from the physics event (True)
464  # or also use particles from pileup (False) ?
465  ResPlotOpt = cms.bool (True)
466 )