![]() |
|
|||
File indexing completed on 2024-04-06 12:21:49
0001 import FWCore.ParameterSet.Config as cms 0002 0003 #--------------------------------------------------------------------------------------------------------- 0004 # This describes the full TMTT track reconstruction chain with 3 GeV threshold, where: 0005 # the GP divides the tracker into 18 eta sectors (each sub-divided into 2 virtual eta subsectors); 0006 # the HT uses a 32x18 array followed by 2x2 mini-HT array, with transverese HT readout & multiplexing, 0007 # followed by the KF (or optionally SF+SLR) track fit; duplicate track removal (Algo50) is run. 0008 #--------------------------------------------------------------------------------------------------------- 0009 0010 TMTrackProducer_params = cms.PSet( 0011 0012 # Tags for ES products 0013 magneticFieldInputTag = cms.ESInputTag( "VolumeBasedMagneticFieldESProducer", "" ), 0014 trackerGeometryInputTag = cms.ESInputTag( "trackerGeometry", "" ), 0015 trackerTopologyInputTag = cms.ESInputTag( "trackerTopology", "" ), 0016 ttStubAlgoInputTag = cms.ESInputTag( "TTStubAlgorithm_official_Phase2TrackerDigi_", "" ), 0017 0018 # Tags for ED products 0019 tpInputTag = cms.InputTag("mix", "MergedTrackTruth"), 0020 stubInputTag = cms.InputTag("TTStubsFromPhase2TrackerDigis", "StubAccepted"), 0021 stubTruthInputTag = cms.InputTag("TTStubAssociatorFromPixelDigis", "StubAccepted"), 0022 clusterTruthInputTag = cms.InputTag("TTClusterAssociatorFromPixelDigis", "ClusterAccepted"), 0023 genJetInputTag = cms.InputTag("ak4GenJets", ""), 0024 0025 # Enable output of TTTracks from part-way through tracking chain (after HT & RZ). 0026 EnableOutputIntermediateTTTracks = cms.bool(False), 0027 0028 # Enable all use of MC truth info (disable to save CPU) 0029 EnableMCtruth = cms.bool(False), 0030 # Enable output histograms & job tracking performance summary (disable to save CPU) 0031 EnableHistos = cms.bool(False), 0032 0033 #=== Cuts on MC truth particles (i.e., tracking particles) used for tracking efficiency measurements. 0034 0035 GenCuts = cms.PSet( 0036 GenMinPt = cms.double(3.0), 0037 GenMaxAbsEta = cms.double(2.4), 0038 GenMaxVertR = cms.double(1.0), # Max distance of particle production vertex from centre of CMS. 0039 GenMaxVertZ = cms.double(30.0), 0040 GenMaxD0 = cms.double(5.0), # Max transverse impact parameter. 0041 GenMaxZ0 = cms.double(999.0), # Max transverse impact parameter. 0042 GenPdgIds = cms.vuint32(), # Only particles with these PDG codes used for efficiency measurement. 0043 0044 # Cut on MC truth tracks used for algorithmic tracking efficiency measurements. 0045 GenMinStubLayers = cms.uint32(4) 0046 ), 0047 0048 #=== Cuts applied to stubs before arriving in L1 track finding board. 0049 0050 StubCuts = cms.PSet( 0051 # Reduce number of bits used by front-end chips to store stub bend info? 0052 # = 0 (no); = 1 (yes using official recipe); = 2 (yes using TMTT method) 0053 DegradeBendRes = cms.uint32(2), 0054 # Don't use stubs with eta beyond this cut, since the tracker geometry makes it impossible to reconstruct tracks with them. 0055 MaxStubEta = cms.double(2.4), 0056 # 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. 0057 KillLowPtStubs = cms.bool(True), 0058 # Print FE stub window sizes recommended by this code (in python cfg format used by CMSSW). 0059 PrintStubWindows = cms.bool(False), 0060 # 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. 0061 # Suggested value: 1.19 if DegradeBendRes = 0, or 1.249 if it > 0. 0062 # N.B. Avoid 1/4-integer values due to rounding error issues. 0063 BendCut = cms.double(1.249), 0064 # Additional contribution to bend resolution from its encoding into a reduced number of bits. 0065 # This number is the assumed resolution relative to the naive guess of its value. 0066 # It is ignored in DegradeBendRes = 0. 0067 BendCutExtra = cms.double(0.0), 0068 # Order stubs by bend in DTC, such that highest Pt stubs are transmitted first. 0069 OrderStubsByBend = cms.bool(True) 0070 ), 0071 0072 #=== Optional Stub digitization. 0073 0074 StubDigitize = cms.PSet( 0075 EnableDigitize = cms.bool(True), # Digitize stub coords? If not, use floating point coords. 0076 # 0077 #--- Parameters available in MP board. (And in case of Hybrid used internally in KF) 0078 # 0079 PhiSectorBits = cms.uint32(6), # Bits used to store phi sector number -- NOT USED 0080 PhiSBits = cms.uint32(14), # Bits used to store phiS coord. (13 enough?) 0081 PhiSRange = cms.double(0.698131700), # Range phiS coord. covers in radians. 0082 RtBits = cms.uint32(12), # Bits used to store Rt coord. 0083 RtRange = cms.double(91.652837), # Range Rt coord. covers in units of cm. 0084 ZBits = cms.uint32(14), # Bits used to store z coord. 0085 ZRange = cms.double(733.2227), # Range z coord. covers in units of cm. 0086 # 0087 #--- Parameters available in GP board (excluding any in common with MP specified above). 0088 # 0089 PhiNBits = cms.uint32(15), # Bits used to store PhiO parameter. 0090 PhiNRange = cms.double(1.3962634), # Range PhiO parameter covers. 0091 BendBits = cms.uint32(6) # Bits used to store stub bend. 0092 ), 0093 0094 #=== Configuration of tracker module type. Only provides test data for firmware. 0095 0096 TrackerModuleType = cms.PSet( 0097 # Modules matching these criteria are type 0, 1, 2, 3 ... 0098 PitchVsType = cms.vdouble(0.0099, 0.0099, 0.0099, 0.0099, 0.0089, 0.0099, 0.0089, 0.0089), 0099 SpaceVsType = cms.vdouble(0.26 , 0.26 , 0.16 , 0.4 , 0.18 , 0.4 , 0.18 , 0.4 ), 0100 # (Type vbool not implemented, so use vuint32 instead ...) 0101 BarrelVsType = cms.vuint32( 1 , 1 , 1 , 1 , 1 , 0 , 0 , 0 ), 0102 PSVsType = cms.vuint32( 1 , 1 , 1 , 1 , 0 , 1 , 0 , 0 ), 0103 TiltedVsType = cms.vuint32( 0 , 1 , 0 , 1 , 0 , 0 , 0 , 0 ) 0104 ), 0105 0106 #=== Configuration of Geometric Processor. 0107 0108 GeometricProc = cms.PSet( 0109 # Use an FPGA-friendly approximation to determine track angle dphi from bend in GP? 0110 UseApproxB = cms.bool(True), # Use approximation for B 0111 # Params of approximation if used. 0112 BApprox_gradient = cms.double(0.886454), # Gradient term of linear equation for approximating B 0113 BApprox_intercept = cms.double(0.504148) # Intercept term of linear equation for approximating B 0114 ), 0115 0116 #=== Division of Tracker into phi sectors. 0117 0118 PhiSectors = cms.PSet( 0119 NumPhiNonants = cms.uint32(9), # Divisions of Tracker at DTC 0120 NumPhiSectors = cms.uint32(18), # Divisions of Tracker at GP. 0121 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. 0122 #--- You can set one or both the following parameters to True. 0123 UseStubPhi = cms.bool(True), # Require stub phi to be consistent with track of Pt > HTArraySpec.HoughMinPt that crosses HT phi axis? 0124 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? 0125 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). 0126 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. 0127 ), 0128 0129 #=== Division of Tracker into eta sectors 0130 0131 EtaSectors = cms.PSet( 0132 # Eta boundaries for 18 eta regions 0133 # 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), 0134 # Eta boundaries for 16 eta regions 0135 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), 0136 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! 0137 BeamWindowZ = cms.double(15), # Half-width of window assumed to contain beam-spot in z. 0138 AllowOver2EtaSecs = cms.bool(True) # If True, the code will not throw an error if a stub is assigned to 3 or more eta sectors. 0139 ), 0140 0141 #=== r-phi Hough transform array specifications. 0142 0143 HTArraySpecRphi = cms.PSet( 0144 HoughMinPt = cms.double(3.0), # Min track Pt that Hough Transform must find. Also used by StubCuts.KillLowPtStubs and by EtaPhiSectors.UseStubPhi. 0145 # If MiniHTstage = True, these refers to mini cells in whole HT array. 0146 HoughNbinsPt = cms.uint32(32), # HT array dimension in track q/Pt. (If MiniHTstage = True, this refers to mini cells in whole HT array). 0147 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). 0148 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! 0149 MaxPtToMerge2x2 = cms.double(3.5), # but only cells with pt < MaxPtToMerge2x2 will be merged in this way (irrelevant if EnableMerge2x2 = false). 0150 NumSubSecsEta = cms.uint32(2), # Subdivide each sector into this number of subsectors in eta within r-phi HT. 0151 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. 0152 MiniHTstage = cms.bool(True), # Run 2nd stage HT with mini cells inside each 1st stage normal HT cell.. 0153 MiniHoughNbinsPt = cms.uint32(2), # Number of mini cells along q/Pt axis inside each normal HT cell. 0154 MiniHoughNbinsPhi = cms.uint32(2), # Number of mini cells along phi axis inside each normal HT cell. 0155 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). 0156 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. 0157 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). 0158 MiniHoughLoadBalance = cms.uint32(2) # Load balancing disabled = 0; static load balancing of output links = 1; dynamic load balancing of output links = 2. 0159 ), 0160 0161 #=== Rules governing how stubs are filled into the r-phi Hough Transform array. 0162 0163 HTFillingRphi = cms.PSet( 0164 # 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 0165 # of efficiency ( > 0). If this option is > 0, it can be 1 or 2, corresponding to different algorithms for rejecting 0166 # 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. 0167 # Suggest setting KillSomeHTCellsRphi=1 (=0) if HTArraySpec.ChosenRofPhi=0 (>0) 0168 KillSomeHTCellsRphi = cms.uint32(0), 0169 # Use filter in each r-phi HT cell, filling it only with stubs that have consistent bend information? 0170 # The assumed bend resolution is specified in StubCuts.BendCut. 0171 UseBendFilter = cms.bool(True), 0172 # 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. 0173 # N.B. If mini-HT is in use, then this cut applies to coarse-HT. 0174 #MaxStubsInCell = cms.uint32(99999), # Setting this to anything more than 999 disables this option 0175 MaxStubsInCell = cms.uint32(32), # set it equal to value used in hardware. 0176 MaxStubsInCellMiniHough = cms.uint32(16), # Same type of cut for mini-HT (if in use) 0177 # 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. 0178 BusySectorKill = cms.bool(True), 0179 BusySectorNumStubs = cms.uint32(162), # Or 144 if only 320 MHz FW. 0180 # 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). 0181 # If BusySectorMbinOrder is not empty, then the m-bins are grouped in the specified order, instead of sequentially. 0182 # (Histos NumStubsPerLink, NumStubsVsLink & MeanStubsPerLink useful for optimising this option). 0183 # 0184 # Choice for 16x32 coarse HT array followed by 2x2 mini-HT array with 3 GeV Pt threshold. 0185 BusySectorMbinRanges = cms.vuint32(1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 16), 0186 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), 0187 # Choice for 24x32 coarse HT array followed by 2x2 mini-HT array with 2 GeV Pt threshold. 0188 #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), 0189 #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), 0190 # 0191 # If BusyInputSectorKill = True, and more than BusyInputSectorNumStubs are input to the HT array from the GP, then 0192 # the excess stubs are killed. This is because HT hardware has finite readin time. 0193 # Results unreliable as depend on assumed order of stubs. 0194 BusyInputSectorKill = cms.bool(True), 0195 BusyInputSectorNumStubs = cms.uint32(162), # Or 144 if only 320 MHz FW 0196 # Multiplex the outputs from several HTs onto a single pair of output optical links? 0197 # 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. 0198 MuxOutputsHT = cms.uint32(1), 0199 # If this is non-empty, then only the specified eta sectors are enabled, to study them individually. 0200 EtaRegWhitelist = cms.vuint32() 0201 ), 0202 0203 #=== Options controlling r-z track filters (or any other track filters run after the Hough transform, as opposed to inside it). 0204 #=== (Irrelevant for track fitters that don't require any r-z filter run before them). 0205 0206 RZfilterOpts = cms.PSet( 0207 # Specify preferred r-z filter (from those available inside TrkRZfilter.cc) - currently only "SeedFilter". 0208 RZFilterName = cms.string("SeedFilter"), 0209 #--- Options relevant for Seed filter, (so only relevant if rzFilterName="SeedFilter"). 0210 # Cut at this many standard deviations on seed resolution. 0211 SeedResCut = cms.double(1.732), 0212 # Store stubs compatible with all possible good seed. 0213 KeepAllSeed = cms.bool(False), 0214 # Maximum number of seed combinations to bother checking per track candidate. 0215 #MaxSeedCombinations = cms.uint32(999), 0216 MaxSeedCombinations = cms.uint32(15), 0217 # Maximum number of seed combinations consistent with (z0,eta) sector constraints to bother checking per track candidate. 0218 #MaxGoodSeedCombinations = cms.uint32(13), 0219 MaxGoodSeedCombinations = cms.uint32(10), 0220 # Maximum number of seeds that a single stub can be included in. 0221 MaxSeedsPerStub = cms.uint32(4), 0222 # Reject tracks whose estimated rapidity from seed filter is inconsistent range of with eta sector. (Kills some duplicate tracks). 0223 zTrkSectorCheck = cms.bool(True), 0224 # Min. number of layers in rz track that must have stubs for track to be declared found by seed filter. 0225 MinFilterLayers = cms.uint32(4) 0226 ), 0227 0228 #=== Rules for deciding when the (HT) track finding has found an L1 track candidate 0229 0230 L1TrackDef = cms.PSet( 0231 # Min. number of layers the track must have stubs in. 0232 MinStubLayers = cms.uint32(5), 0233 # Change min. number of layers cut to (MinStubLayers - 1) for tracks with Pt exceeding this cut. 0234 # If this is set to a -ve number, this option is disabled. 0235 MinPtToReduceLayers = cms.double(-99999.), 0236 # Change min. number of layers cut to (MinStubLayers - 1) for tracks in these rapidity sectors. 0237 # (Histogram "AlgEffVsEtaSec" will help you identify which sectors to declare). 0238 #EtaSecsReduceLayers = cms.vuint32(), 0239 EtaSecsReduceLayers = cms.vuint32(5,12), 0240 # Reduce this layer ID, so that it takes no more than 8 different values in any eta region (simplifies firmware). 0241 ReducedLayerID = cms.bool(True) 0242 ), 0243 0244 #=== Specification of algorithm to eliminate duplicate tracks. 0245 0246 DupTrkRemoval = cms.PSet( 0247 # Algorithm run on tracks after the track helix fit has been done. 0248 # (Disable dup removal = 0; two alternative algos = 1 or 2). 0249 DupTrkAlgFit = cms.uint32(1) 0250 ), 0251 0252 #=== Rules for deciding when a reconstructed L1 track matches a MC truth particle (i.e. tracking particle). 0253 0254 TrackMatchDef = cms.PSet( 0255 #--- Three different ways to define if a tracking particle matches a reco track candidate. (Usually, set two of them to ultra loose). 0256 # Min. fraction of matched stubs relative to number of stubs on reco track. 0257 MinFracMatchStubsOnReco = cms.double(-99.), 0258 # Min. fraction of matched stubs relative to number of stubs on tracking particle. 0259 MinFracMatchStubsOnTP = cms.double(-99.), 0260 # Min. number of matched layers. 0261 MinNumMatchLayers = cms.uint32(4), 0262 # Min. number of matched PS layers. 0263 MinNumMatchPSLayers = cms.uint32(0), 0264 # 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). 0265 StubMatchStrict = cms.bool(False) 0266 ), 0267 0268 #=== Track Fitting Algorithm Settings. 0269 0270 TrackFitSettings = cms.PSet( 0271 # 0272 #--- Options applicable to all track fitters --- 0273 # 0274 # Track Fitting algortihms to use. You can run several in parallel. 0275 # TrackFitLinearAlgo & ChiSquared* are chi2 fits, KF* is a Kalman filter fit, 0276 # & SimpleLR4 is a linear regression fit that neglects the hit uncertainties. 0277 # The number 4 or 5 in the name indicates if 4 or 5 helix parameters are fitted. 0278 # Options KF4ParamsComb, KF5ParamsComb or SimpleLR4 are the best ones. 0279 # KF*ParamsCombHLS is the HLS version of the code, which only works if linked with Vivado libraries. 0280 TrackFitters = cms.vstring( 0281 # "ChiSquaredFit4", 0282 # "SimpleLR4", 0283 # "KF4ParamsCombHLS", 0284 # "KF5ParamsCombHLS", 0285 "KF5ParamsComb", 0286 "KF4ParamsComb" 0287 ), 0288 # Indicate subset of fitters wanting r-z track filter to be run before them. (Irrelevant for those not specified in "TrackFitters"). 0289 # Typically, Chi2 & LR fits work best with r-z filter & KF works best without it. 0290 UseRZfilter = cms.vstring( 0291 "ChiSquaredFit4", 0292 "SimpleLR4" 0293 ), 0294 # Print detailed summary of track fit performance at end of job (as opposed to a brief one). 0295 DetailedFitOutput = cms.bool(False), 0296 # 0297 # Use MC truth to eliminate all fake tracks & all incorrect stubs assigned to tracks before doing fit. 0298 TrackFitCheat = cms.bool(False), 0299 # 0300 #--- Options for chi2 track fitter --- 0301 # 0302 # Number of fitting iterations to undertake. (15 is not realistic in hardware, but is necessary to kill bad hits) 0303 NumTrackFitIterations = cms.uint32(15), 0304 # Optionally kill hit with biggest residuals in track fit (occurs after the first fit, so three iterations would have two killings). 0305 KillTrackFitWorstHit = cms.bool(True), 0306 # 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. 0307 GeneralResidualCut = cms.double(3.0), 0308 KillingResidualCut = cms.double(20.0), 0309 # 0310 #--- Additional options for Thomas Schuh's Linear Regression track fitter --- 0311 # 0312 # Maximum allowed number of iterations of LR fitter. 0313 MaxIterationsLR = cms.uint32( 8 ), 0314 # If False: residual of a stub is the max of its r-phi & r-z residuals. 0315 # If True: the residual is the mean of these residuals. 0316 CombineResiduals = cms.bool( True ), 0317 # Correct stub phi coordinate for higher orders in circle expansion, so that a trajectory is straight in r-phi. 0318 LineariseStubPosition = cms.bool( True ), 0319 # Checks if the fitted track is consistent with the sector, if not it will be not accepted. 0320 CheckSectorConsistency = cms.bool( False ), 0321 # Checks if the fitted track r phi parameter are consistent with the HT candidate parameter within in range of +- 2 cells. 0322 CheckHTCellConsistency = cms.bool( False ), 0323 # Tracks must have stubs in at least this number of PS layers. 0324 MinPSLayers = cms.uint32( 2 ), 0325 # Digitization 0326 DigitizeLR = cms.bool( False ), 0327 PhiPrecision = cms.double( 0.009 / 108. ), 0328 RPrecision = cms.double( 0.14 ), 0329 ZPrecision = cms.double( 0.28 ), 0330 ZSlopeWidth = cms.uint32( 11 ), 0331 ZInterceptWidth = cms.uint32( 11 ), 0332 # 0333 #--- Additional options for Davide Cieri's Simple Linear Regression track fitter --- 0334 # 0335 # Digitize Simple Linear Regression variables and calculation. (Disabled if EnableDigitize=False). 0336 DigitizeSLR = cms.bool(False), # Disable, as was never retuned for nonants 0337 # Number of bits to be used in hardware to compute the division needed to calculate the helix params 0338 DividerBitsHelix = cms.uint32(23), 0339 DividerBitsHelixZ = cms.uint32(23), 0340 # Number of bits to reduce the rphi helix parameter calculation weight 0341 ShiftingBitsDenRPhi = cms.uint32(14), 0342 # Number of bits to reduce the rphi helix parameter calculation weight 0343 ShiftingBitsDenRZ = cms.uint32(14), 0344 # Number of bits to reduce the phi0 parameter calculation weight 0345 ShiftingBitsPhi = cms.uint32(10), 0346 # Number of bits to reduce the qOverPt parameter calculation weight 0347 ShiftingBitsPt = cms.uint32(3), 0348 # Number of bits to reduce the tanLambda parameter calculation weight 0349 ShiftingBitsLambda = cms.uint32(1), 0350 # Number of bits to reduce the z0 parameter calculation weight 0351 ShiftingBitsZ0 = cms.uint32(16), 0352 # Fit ChiSquare Cut (tightening reduces fake track rate at cost of efficiency) 0353 SLR_chi2cut = cms.double(300.), 0354 # Cut on Rphi Residuals (radians) - stubs killed until only 4 left or all have residuals below this cut. 0355 ResidualCut = cms.double(0.0), 0356 #ResidualCut = cms.double(0.0005), # This allows more than 4 stubs per track. 0357 # 0358 #--- Options for Kalman filter track fitters --- 0359 # 0360 # Larger number has more debug printout. "1" is useful for understanding why tracks are lost, best combined with TrackFitCheat=True. 0361 KalmanDebugLevel = cms.uint32(0), 0362 # Fit will reject fitted tracks unless it can assign at least this number of stubs to them. 0363 KalmanMinNumStubs = cms.uint32(4), 0364 # Fit will attempt to add up to this nummber of stubs to each fitted tracks, but won't bother adding more. 0365 KalmanMaxNumStubs = cms.uint32(4), 0366 # For 5-param helix fits, calculate also beam-constrained helix params after fit is complete, & use them for duplicate removal if DupTrkAlgFit=1. 0367 KalmanAddBeamConstr = cms.bool(True), 0368 # Remove requirement of at least 2 PS layers per track. 0369 KalmanRemove2PScut = cms.bool(False), 0370 # Allow the KF to skip this many layers in total per track. 0371 KalmanMaxSkipLayersHard = cms.uint32(1), # For HT tracks with many stubs 0372 KalmanMaxSkipLayersEasy = cms.uint32(2), # For HT tracks with few stubs 0373 KalmanMaxStubsEasy = cms.uint32(10), # Max stubs an HT track can have to be "easy". 0374 KFUseMaybeLayers = cms.bool(False), # Disable "maybe layer" to match with firmware 0375 #--- Cuts applied to KF states as a function of the last KF tracker layer they had a stub in. 0376 # (If "4" or "5" in name, cut only applies to 4 or 5 param helix fit). 0377 KFLayerVsPtToler = cms.vdouble(999., 999., 0.1 , 0.1 , 0.05, 0.05, 0.05), 0378 # d0 cut only applied to 5 param helix fit. 0379 KFLayerVsD0Cut5 = cms.vdouble(999., 999., 999., 10. , 10. , 10. ,10. ), 0380 KFLayerVsZ0Cut5 = cms.vdouble(999., 999., 25.5, 25.5, 25.5, 25.5,25.5 ), 0381 KFLayerVsZ0Cut4 = cms.vdouble(999., 999. ,15. , 15. , 15. , 15. ,15. ), 0382 # Chi2 cuts should be retuned if KalmanMultiScattTerm value changed. 0383 KFLayerVsChiSq5 = cms.vdouble(999., 999., 10. , 30. , 80. , 120., 160.), 0384 KFLayerVsChiSq4 = cms.vdouble(999., 999., 10. , 30. , 80. , 120., 160.), 0385 # KF will consider at most this #stubs per layer to save time. 0386 KalmanMaxStubsPerLayer = cms.uint32(4), 0387 # Multiple scattering term - inflate hit phi errors by this divided by Pt 0388 # (0.00075 gives best helix resolution & 0.00450 gives best chi2 distribution). 0389 KalmanMultiScattTerm = cms.double(0.00075), 0390 # Scale down chi2 in r-phi plane by this factor to improve electron performance (should be power of 2) 0391 KalmanChi2RphiScale = cms.uint32(8), 0392 # N.B. KF track fit chi2 cut is not cfg param, but instead is hard-wired in KF4ParamsComb::isGoodState(...). 0393 #--- Enable Higher order corrections 0394 # Treat z uncertainty in tilted barrel modules correctly. 0395 KalmanHOtilted = cms.bool(False), 0396 # Higher order circle explansion terms for low Pt. 0397 KalmanHOhelixExp = cms.bool(False), 0398 # 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. 0399 KalmanHOalpha = cms.uint32(0), 0400 # 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. 0401 KalmanHOprojZcorr = cms.uint32(0), 0402 # Use approx calc to account for non-radial endcap 2S modules corresponding to current FW, with no special treatment for tilted modules. 0403 KalmanHOfw = cms.bool(True) 0404 ), 0405 0406 #=== Treatment of dead modules. 0407 0408 DeadModuleOpts = cms.PSet( 0409 # Emulate dead/inefficient modules using the StubKiller code, with stubs killed according to the scenarios of the Stress Test group. 0410 # (0=Don't kill any stubs; 1-5 = Scenarios described in StubKiller.cc) 0411 KillScenario = cms.uint32(0), 0412 # Modify TMTT tracking to try to recover tracking efficiency in presence of dead modules. (Does nothing if KillScenario = 0). 0413 KillRecover = cms.bool (True) 0414 ), 0415 0416 #=== Fitted track digitisation. 0417 0418 TrackDigi=cms.PSet( 0419 # For firmware reasons, can't use common digitisation cfg for all fitters. 0420 0421 #======= SimpleLR4 digi parameters ======== 0422 SLR_skipTrackDigi = cms.bool( False ), # Optionally skip track digitisation if done internally inside fitting code. 0423 SLR_oneOver2rBits = cms.uint32(13), 0424 SLR_oneOver2rRange = cms.double(0.01354135), 0425 SLR_d0Bits = cms.uint32(12), # Made up by Ian as never yet discussed. 0426 SLR_d0Range = cms.double(10.), 0427 SLR_phi0Bits = cms.uint32(18), 0428 SLR_phi0Range = cms.double(1.3962636), # phi0 is actually only digitised relative to centre of sector. 0429 SLR_z0Bits = cms.uint32(12), 0430 SLR_z0Range = cms.double(51.555509), 0431 SLR_tanlambdaBits = cms.uint32(15), 0432 SLR_tanlambdaRange = cms.double(32.0), 0433 SLR_chisquaredBits = cms.uint32(10), 0434 SLR_chisquaredRange = cms.double(512.), 0435 0436 #====== Kalman Filter digi parameters ======== 0437 KF_skipTrackDigi = cms.bool( False ), # Optionally skip track digitisation if done internally inside fitting code. 0438 KF_oneOver2rBits = cms.uint32(15), 0439 KF_oneOver2rRange = cms.double(0.0076171313), # pT > 1.5 GeV 0440 KF_d0Bits = cms.uint32(12), 0441 KF_d0Range = cms.double(31.992876), 0442 KF_phi0Bits = cms.uint32(12), 0443 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. 0444 KF_z0Bits = cms.uint32(12), 0445 KF_z0Range = cms.double(45.826419), 0446 KF_tanlambdaBits = cms.uint32(16), 0447 KF_tanlambdaRange = cms.double(16.), 0448 KF_chisquaredBits = cms.uint32(15), # N.B. 17 bits are used internally inside KF. 0449 KF_chisquaredRange = cms.double(1024.), 0450 KF_chisquaredBinEdges = cms.vdouble(0, 0.5, 1, 2, 3, 5, 7, 10, 20, 40, 100, 200, 500, 1000, 3000 ), # Additional bin for >3000 0451 KF_bendchisquaredBinEdges = cms.vdouble(0, 0.5, 1, 2, 3, 5, 10, 50 ), # Additional bin for >50 0452 0453 #====== Other track fitter Digi params. 0454 # Currently equal to those for KF, although you can skip track digitisation for them with following. 0455 Other_skipTrackDigi = cms.bool( True ) 0456 ), 0457 0458 #===== Use HYBRID TRACKING (Tracklet pattern reco + TMTT KF -- requires tracklet C++ too) ===== 0459 0460 Hybrid = cms.bool( False), 0461 0462 #===== Debug plot options 0463 # When making helix parameter resolution plots, only use particles from the physics event (True) 0464 # or also use particles from pileup (False) ? 0465 ResPlotOpt = cms.bool (True) 0466 )
[ Source navigation ] | [ Diff markup ] | [ Identifier search ] | [ general search ] |
This page was automatically generated by the 2.2.1 LXR engine. The LXR team |
![]() ![]() |