Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2021-02-14 13:30:42

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 )