Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2022-10-01 01:02:13

0001 import FWCore.ParameterSet.Config as cms
0002 
0003 import math
0004 
0005 from L1Trigger.Phase2L1ParticleFlow.l1tPFTracksFromL1Tracks_cfi import l1tPFTracksFromL1Tracks
0006 from L1Trigger.Phase2L1ParticleFlow.l1tPFClustersFromL1EGClusters_cfi import l1tPFClustersFromL1EGClusters
0007 from L1Trigger.Phase2L1ParticleFlow.pfClustersFromCombinedCalo_cff import l1tPFClustersFromCombinedCaloHCal, l1tPFClustersFromCombinedCaloHF
0008 from L1Trigger.Phase2L1ParticleFlow.l1tPFClustersFromHGC3DClusters_cfi import l1tPFClustersFromHGC3DClusters
0009 
0010 from L1Trigger.Phase2L1ParticleFlow.l1TkEgAlgoEmulator_cfi import tkEgAlgoParameters,tkEgSorterParameters
0011 
0012 muonInputConversionParameters = cms.PSet(
0013     z0Scale = cms.double(1.875),
0014     dxyScale = cms.double(3.85)
0015 )
0016 
0017 l1tLayer1Barrel = cms.EDProducer("L1TCorrelatorLayer1Producer",
0018     tracks = cms.InputTag('l1tPFTracksFromL1Tracks'),
0019     muons = cms.InputTag('l1tSAMuonsGmt','promptSAMuons'),
0020     emClusters = cms.VInputTag(cms.InputTag('l1tPFClustersFromL1EGClusters')),
0021     hadClusters = cms.VInputTag(cms.InputTag('l1tPFClustersFromCombinedCaloHCal:calibrated')),
0022     vtxCollection = cms.InputTag("l1tVertexFinderEmulator","l1verticesEmulation"),
0023     vtxCollectionEmulation = cms.bool(True),
0024     emPtCut  = cms.double(0.5),
0025     hadPtCut = cms.double(1.0),
0026     trkPtCut    = cms.double(2.0),
0027     trackInputConversionAlgo = cms.string("Emulator"),
0028     trackInputConversionParameters = cms.PSet(
0029         region = cms.string("barrel"),
0030         trackWordEncoding = cms.string("biased"),
0031         bitwiseAccurate = cms.bool(True),
0032         ptLUTBits = cms.uint32(11),
0033         etaLUTBits = cms.uint32(10),
0034         etaPreOffs = cms.int32(0),
0035         etaShift = cms.uint32(15-10),
0036         etaPostOffs = cms.int32(0),
0037         etaSigned = cms.bool(True),
0038         phiBits = cms.uint32(10),
0039         z0Bits = cms.uint32(12),
0040         dEtaBarrelBits = cms.uint32(8),
0041         dEtaBarrelZ0PreShift = cms.uint32(2),
0042         dEtaBarrelZ0PostShift = cms.uint32(2),
0043         dEtaBarrelFloatOffs = cms.double(0.0),
0044         dPhiBarrelBits = cms.uint32(4),
0045         dPhiBarrelRInvPreShift = cms.uint32(4),
0046         dPhiBarrelRInvPostShift = cms.uint32(4),
0047         dPhiBarrelFloatOffs = cms.double(0.0)
0048         ),
0049     muonInputConversionAlgo = cms.string("Emulator"),
0050     muonInputConversionParameters = muonInputConversionParameters.clone(),
0051     regionizerAlgo = cms.string("Ideal"),
0052     pfAlgo = cms.string("PFAlgo3"),
0053     puAlgo = cms.string("LinearizedPuppi"),
0054     nVtx        = cms.int32(1),    
0055     regionizerAlgoParameters = cms.PSet(
0056         useAlsoVtxCoords = cms.bool(True),
0057     ),
0058     pfAlgoParameters = cms.PSet(
0059         nTrack = cms.uint32(25), 
0060         nCalo = cms.uint32(18), 
0061         nMu = cms.uint32(2), 
0062         nSelCalo = cms.uint32(18), 
0063         nEmCalo = cms.uint32(12), 
0064         nPhoton = cms.uint32(12), 
0065         nAllNeutral = cms.uint32(25), 
0066         trackMuDR    = cms.double(0.2), # accounts for poor resolution of standalone, and missing propagations
0067         trackEmDR   = cms.double(0.04), # 1 Ecal crystal size is 0.02, and ~2 cm in HGCal is ~0.007
0068         emCaloDR    = cms.double(0.10),    # 1 Hcal tower size is ~0.09
0069         trackCaloDR = cms.double(0.15),
0070         maxInvisiblePt = cms.double(10.0), # max allowed pt of a track with no calo energy
0071         tightTrackMaxInvisiblePt = cms.double(20),
0072         caloResolution = cms.PSet(
0073             etaBins = cms.vdouble( 0.700,  1.200,  1.600),
0074             offset  = cms.vdouble( 2.909,  2.864,  0.294),
0075             scale   = cms.vdouble( 0.119,  0.127,  0.442),
0076         ),
0077         debug = cms.untracked.bool(False)
0078     ),
0079     puAlgoParameters = cms.PSet(
0080         nTrack = cms.uint32(22), 
0081         nIn = cms.uint32(25), 
0082         nOut = cms.uint32(25), 
0083         nVtx = cms.uint32(1),
0084         nFinalSort = cms.uint32(18), 
0085         finalSortAlgo = cms.string("Insertion"),
0086         dZ     = cms.double(0.5),
0087         dr     = cms.double(0.3),
0088         drMin  = cms.double(0.07),
0089         ptMax  = cms.double(50.),
0090         absEtaCuts         = cms.vdouble( ), # just one bin, so no edge needd
0091         ptCut             = cms.vdouble( 1.0 ),
0092         ptSlopes           = cms.vdouble( 0.3 ), # coefficient for pT
0093         ptSlopesPhoton    = cms.vdouble( 0.3 ),
0094         ptZeros            = cms.vdouble( 4.0 ), # ballpark pT from PU
0095         ptZerosPhoton     = cms.vdouble( 2.5 ),
0096         alphaSlopes        = cms.vdouble( 0.7 ), # coefficient for alpha
0097         alphaZeros         = cms.vdouble( 6.0 ), # ballpark alpha from PU
0098         alphaCrop         = cms.vdouble(  4  ), # max. absolute value for alpha term
0099         priors             = cms.vdouble( 5.0 ),
0100         priorsPhoton      = cms.vdouble( 1.0 ),
0101         debug = cms.untracked.bool(False)
0102     ),
0103     tkEgAlgoParameters=tkEgAlgoParameters.clone(
0104         nTRACK = 25,
0105         nTRACK_EGIN = 13,
0106         nEMCALO_EGIN = 10,
0107         nEM_EGOUT = 10,
0108     ),
0109     tkEgSorterParameters=tkEgSorterParameters.clone(
0110         nObjToSort = 10
0111     ),
0112     caloSectors = cms.VPSet(
0113         cms.PSet( 
0114             etaBoundaries = cms.vdouble(-1.5, 1.5),
0115             phiSlices     = cms.uint32(3),
0116             phiZero       = cms.double(0),
0117         )
0118     ),
0119     regions = cms.VPSet(
0120         cms.PSet( 
0121             etaBoundaries = cms.vdouble(-1.5, -1.0, -0.5, 0.0, 0.5, 1.0, 1.5),
0122             phiSlices     = cms.uint32(9),
0123             etaExtra = cms.double(0.25),
0124             phiExtra = cms.double(0.25),
0125         ),
0126     ),
0127     boards=cms.VPSet(
0128         cms.PSet(
0129               regions=cms.vuint32(*[0+9*ie+i for ie in range(6) for i in range(3)])), # phi splitting
0130             # regions=cms.vuint32(range(0, 18))), # eta splitting
0131         cms.PSet(
0132               regions=cms.vuint32(*[3+9*ie+i for ie in range(6) for i in range(3)])), # phi splitting
0133             # regions=cms.vuint32(range(18, 36))), # eta splitting
0134         cms.PSet(
0135               regions=cms.vuint32(*[6+9*ie+i for ie in range(6) for i in range(3)])), # phi splitting
0136             # regions=cms.vuint32(range(36, 54))), # eta splitting
0137     )
0138 )
0139 
0140 _hgcalSectors = cms.VPSet(
0141     cms.PSet( 
0142         etaBoundaries = cms.vdouble(-3.0, -1.5),
0143         phiSlices     = cms.uint32(3),
0144         phiZero       = cms.double(math.pi/2) # The edge of the 0th HGCal sectors is at 30 deg, the center at 30+120/2=90 = pi/2
0145     ),
0146     cms.PSet( 
0147         etaBoundaries = cms.vdouble(+1.5, +3.0),
0148         phiSlices     = cms.uint32(3),
0149         phiZero       = cms.double(math.pi/2) # As above
0150     )
0151 
0152 )
0153 
0154 l1tLayer1HGCal = cms.EDProducer("L1TCorrelatorLayer1Producer",
0155     tracks = cms.InputTag('l1tPFTracksFromL1Tracks'),
0156     muons = cms.InputTag('l1tSAMuonsGmt','promptSAMuons'),
0157     emClusters = cms.VInputTag(cms.InputTag('l1tPFClustersFromHGC3DClusters:egamma')), # used only for E/gamma
0158     hadClusters = cms.VInputTag(cms.InputTag('l1tPFClustersFromHGC3DClusters')),
0159     vtxCollection = cms.InputTag("l1tVertexFinderEmulator","l1verticesEmulation"),
0160     vtxCollectionEmulation = cms.bool(True),
0161     nVtx        = cms.int32(1),    
0162     emPtCut  = cms.double(0.5),
0163     hadPtCut = cms.double(1.0),
0164     trkPtCut    = cms.double(2.0),
0165     trackInputConversionAlgo = cms.string("Emulator"),
0166     trackInputConversionParameters = cms.PSet(
0167         region = cms.string("endcap"),
0168         trackWordEncoding = cms.string("biased"),
0169         bitwiseAccurate = cms.bool(True),
0170         ptLUTBits = cms.uint32(11),
0171         etaLUTBits = cms.uint32(11),
0172         etaPreOffs = cms.int32(0),
0173         etaShift = cms.uint32(15-11),
0174         etaPostOffs = cms.int32(150),
0175         etaSigned = cms.bool(True),
0176         phiBits = cms.uint32(10),
0177         z0Bits = cms.uint32(12),
0178         dEtaHGCalBits = cms.uint32(10),
0179         dEtaHGCalZ0PreShift = cms.uint32(2),
0180         dEtaHGCalRInvPreShift = cms.uint32(6),
0181         dEtaHGCalLUTBits = cms.uint32(10),
0182         dEtaHGCalLUTShift = cms.uint32(2),
0183         dEtaHGCalFloatOffs = cms.double(0.0),
0184         dPhiHGCalBits = cms.uint32(4),
0185         dPhiHGCalZ0PreShift = cms.uint32(4),
0186         dPhiHGCalZ0PostShift = cms.uint32(6),
0187         dPhiHGCalRInvShift = cms.uint32(4),
0188         dPhiHGCalTanlInvShift = cms.uint32(22),
0189         dPhiHGCalTanlLUTBits = cms.uint32(10),
0190         dPhiHGCalFloatOffs = cms.double(0.0)
0191         ),
0192     muonInputConversionAlgo = cms.string("Emulator"),
0193     muonInputConversionParameters = muonInputConversionParameters.clone(),
0194     regionizerAlgo = cms.string("Multififo"),
0195     regionizerAlgoParameters = cms.PSet(
0196         useAlsoVtxCoords = cms.bool(True),
0197         nEndcaps = cms.uint32(2),
0198         nClocks = cms.uint32(54),
0199         nTrack = cms.uint32(30),
0200         nCalo = cms.uint32(20),
0201         nEmCalo = cms.uint32(10),
0202         nMu = cms.uint32(4),
0203         egInterceptMode = cms.PSet(
0204             afterFifo = cms.bool(True),
0205             emIDMask = cms.uint32(0x1E),
0206             nHADCALO_IN = cms.uint32(20),
0207             nEMCALO_OUT = cms.uint32(10),
0208             )
0209         ),
0210     pfAlgo = cms.string("PFAlgo2HGC"),
0211     pfAlgoParameters = cms.PSet(
0212         nTrack = cms.uint32(30),
0213         nCalo = cms.uint32(20),
0214         nMu = cms.uint32(4),
0215         nSelCalo = cms.uint32(20),
0216         trackMuDR    = cms.double(0.2), # accounts for poor resolution of standalone, and missing propagations
0217         trackCaloDR = cms.double(0.1),
0218         maxInvisiblePt = cms.double(10.0), # max allowed pt of a track with no calo energy
0219         tightTrackMaxInvisiblePt = cms.double(20),
0220         caloResolution = cms.PSet(
0221             etaBins = cms.vdouble( 1.700,  1.900,  2.200,  2.500,  2.800,  2.900),
0222             offset  = cms.vdouble( 1.793,  1.827,  2.363,  2.538,  2.812,  2.642),
0223             scale   = cms.vdouble( 0.138,  0.137,  0.124,  0.115,  0.106,  0.121),
0224         ),
0225         debug = cms.untracked.bool(False)
0226     ),
0227     puAlgo = cms.string("LinearizedPuppi"),
0228     puAlgoParameters = cms.PSet(
0229         nTrack = cms.uint32(30),
0230         nIn = cms.uint32(20),
0231         nOut = cms.uint32(20),
0232         nVtx        = cms.uint32(1),    
0233         nFinalSort = cms.uint32(18), 
0234         finalSortAlgo = cms.string("FoldedHybrid"),
0235         dZ     = cms.double(1.33),
0236         dr     = cms.double(0.3),
0237         drMin  = cms.double(0.04),
0238         ptMax  = cms.double(50.),
0239         absEtaCuts         = cms.vdouble( 2.0 ), # two bins in the tracker (different eta); give only the one boundary between them 
0240         ptCut             = cms.vdouble( 1.0, 2.0 ),
0241         ptSlopes           = cms.vdouble( 0.3, 0.3 ), # coefficient for pT
0242         ptSlopesPhoton    = cms.vdouble( 0.4, 0.4 ), #When e/g ID not applied, use: cms.vdouble( 0.3, 0.3, 0.3 ),
0243         ptZeros            = cms.vdouble( 5.0, 7.0 ), # ballpark pT from PU
0244         ptZerosPhoton     = cms.vdouble( 3.0, 4.0 ),
0245         alphaSlopes        = cms.vdouble( 1.5, 1.5 ),
0246         alphaZeros         = cms.vdouble( 6.0, 6.0 ),
0247         alphaCrop         = cms.vdouble(  3 ,  3  ), # max. absolute value for alpha term
0248         priors             = cms.vdouble( 5.0, 5.0 ),
0249         priorsPhoton      = cms.vdouble( 1.5, 1.5 ), #When e/g ID not applied, use: cms.vdouble( 3.5, 3.5, 7.0 ),
0250         debug = cms.untracked.bool(False)
0251     ),
0252     tkEgAlgoParameters=tkEgAlgoParameters.clone(
0253         nTRACK = 30,
0254         nTRACK_EGIN = 10,
0255         nEMCALO_EGIN = 10, 
0256         nEM_EGOUT = 5,
0257         doBremRecovery=True,
0258         doEndcapHwQual=True,
0259         writeBeforeBremRecovery=False,
0260         writeEGSta=True),
0261     tkEgSorterParameters=tkEgSorterParameters.clone(
0262         nObjToSort = 5
0263     ),
0264     caloSectors = _hgcalSectors,
0265     regions = cms.VPSet(
0266         cms.PSet( 
0267             etaBoundaries = cms.vdouble(-2.5, -1.5),
0268             phiSlices     = cms.uint32(9),
0269             etaExtra = cms.double(0.25),
0270             phiExtra = cms.double(0.25),
0271         ),
0272         cms.PSet( 
0273             etaBoundaries = cms.vdouble(+1.5, +2.5),
0274             phiSlices     = cms.uint32(9),
0275             etaExtra = cms.double(0.25),
0276             phiExtra = cms.double(0.25),
0277         )
0278 
0279     ),
0280     boards=cms.VPSet(
0281         cms.PSet(
0282             regions=cms.vuint32(range(0, 9))),
0283         cms.PSet(
0284             regions=cms.vuint32(range(9, 18))),
0285     ),
0286     writeRawHgcalCluster = cms.untracked.bool(True)
0287 )
0288 
0289 
0290 l1tLayer1HGCalNoTK = cms.EDProducer("L1TCorrelatorLayer1Producer",
0291     tracks = cms.InputTag(''),
0292     muons = cms.InputTag('l1tSAMuonsGmt','promptSAMuons'),
0293     emClusters = cms.VInputTag(cms.InputTag('l1tPFClustersFromHGC3DClusters:egamma')), # used only for E/gamma
0294     hadClusters = cms.VInputTag(cms.InputTag('l1tPFClustersFromHGC3DClusters')),
0295     vtxCollection = cms.InputTag("l1tVertexFinderEmulator","l1verticesEmulation"),
0296     vtxCollectionEmulation = cms.bool(True),
0297     nVtx        = cms.int32(1),        
0298     emPtCut  = cms.double(0.5),
0299     hadPtCut = cms.double(1.0),
0300     trkPtCut    = cms.double(2.0),
0301     muonInputConversionAlgo = cms.string("Emulator"),
0302     muonInputConversionParameters = muonInputConversionParameters.clone(),
0303     regionizerAlgo = cms.string("Ideal"),
0304     pfAlgo = cms.string("PFAlgoDummy"),
0305     puAlgo = cms.string("LinearizedPuppi"),
0306     regionizerAlgoParameters = cms.PSet(
0307         useAlsoVtxCoords = cms.bool(True),
0308     ),
0309     pfAlgoParameters = cms.PSet(
0310         nCalo = cms.uint32(12), 
0311         nMu = cms.uint32(4), # unused
0312         debug = cms.untracked.bool(False)
0313     ),
0314     puAlgoParameters = cms.PSet(
0315         nTrack = cms.uint32(0),  # unused
0316         nIn = cms.uint32(12), 
0317         nOut = cms.uint32(12), 
0318         nFinalSort = cms.uint32(12), # to be tuned
0319         finalSortAlgo = cms.string("Hybrid"), 
0320         nVtx = cms.uint32(1),    
0321         dZ     = cms.double(1.33),
0322         dr     = cms.double(0.3),
0323         drMin  = cms.double(0.04),
0324         ptMax  = cms.double(50.),
0325         absEtaCuts         = cms.vdouble( ), # just one bin
0326         ptCut             = cms.vdouble( 4.0 ),
0327         ptSlopes           = cms.vdouble( 0.3 ), # coefficient for pT
0328         ptSlopesPhoton    = cms.vdouble( 0.4 ), #When e/g ID not applied, use: cms.vdouble( 0.3, 0.3, 0.3 ),
0329         ptZeros            = cms.vdouble( 9.0 ), # ballpark pT from PU
0330         ptZerosPhoton     = cms.vdouble( 5.0 ),
0331         alphaSlopes        = cms.vdouble( 2.2 ),
0332         alphaZeros         = cms.vdouble( 9.0 ),
0333         alphaCrop         = cms.vdouble(  4  ), # max. absolute value for alpha term
0334         priors             = cms.vdouble( 7.0 ),
0335         priorsPhoton      = cms.vdouble( 5.0 ), #When e/g ID not applied, use: cms.vdouble( 3.5, 3.5, 7.0 ),
0336         debug = cms.untracked.bool(False)
0337     ),
0338     tkEgAlgoParameters=tkEgAlgoParameters.clone(
0339         nTRACK = 30,
0340         nTRACK_EGIN = 10,
0341         nEMCALO_EGIN = 10, 
0342         nEM_EGOUT = 5,
0343         doBremRecovery=True,
0344         doEndcapHwQual=True,
0345         writeBeforeBremRecovery=False,
0346         writeEGSta=True),
0347     tkEgSorterParameters=tkEgSorterParameters.clone(
0348         nObjToSort=5
0349     ),
0350     caloSectors = _hgcalSectors,
0351     regions = cms.VPSet(
0352         cms.PSet( 
0353             etaBoundaries = cms.vdouble(-3.0, -2.5),
0354             phiSlices     = cms.uint32(9),
0355             etaExtra = cms.double(0.25),
0356             phiExtra = cms.double(0.25),
0357         ),
0358         cms.PSet( 
0359             etaBoundaries = cms.vdouble(+2.5, +3.0),
0360             phiSlices     = cms.uint32(9),
0361             etaExtra = cms.double(0.25),
0362             phiExtra = cms.double(0.25),
0363         )
0364 
0365     ),
0366     boards=cms.VPSet(
0367         cms.PSet(
0368             regions=cms.vuint32(range(0,18))),
0369     ),
0370     writeRawHgcalCluster = cms.untracked.bool(True)
0371 )
0372 
0373 l1tLayer1HF = cms.EDProducer("L1TCorrelatorLayer1Producer",
0374     tracks = cms.InputTag(''),
0375     muons = cms.InputTag('l1tSAMuonsGmt','promptSAMuons'),
0376     useStandaloneMuons = cms.bool(False),
0377     useTrackerMuons = cms.bool(False),
0378     emClusters = cms.VInputTag(),
0379     hadClusters = cms.VInputTag(cms.InputTag('l1tPFClustersFromCombinedCaloHF:calibrated')),
0380     vtxCollection = cms.InputTag("l1tVertexFinderEmulator","l1verticesEmulation"),
0381     vtxCollectionEmulation = cms.bool(True),
0382     nVtx        = cms.int32(1),    
0383     emPtCut  = cms.double(0.5),
0384     hadPtCut = cms.double(15.0),
0385     trkPtCut    = cms.double(2.0),
0386     muonInputConversionAlgo = cms.string("Ideal"),
0387     muonInputConversionParameters = muonInputConversionParameters.clone(),
0388     regionizerAlgo = cms.string("Ideal"),
0389     pfAlgo = cms.string("PFAlgoDummy"),
0390     puAlgo = cms.string("LinearizedPuppi"),
0391     regionizerAlgoParameters = cms.PSet(
0392         useAlsoVtxCoords = cms.bool(True),
0393     ),
0394     pfAlgoParameters = cms.PSet(
0395         nCalo = cms.uint32(18), 
0396         nMu = cms.uint32(4), # unused
0397         debug = cms.untracked.bool(False)
0398     ),
0399     puAlgoParameters = cms.PSet(
0400         nTrack = cms.uint32(0), # unused
0401         nIn = cms.uint32(18), 
0402         nOut = cms.uint32(18), 
0403         nVtx = cms.uint32(1),
0404         nFinalSort = cms.uint32(10), # to be tuned
0405         finalSortAlgo = cms.string("Insertion"),
0406         dZ     = cms.double(1.33),
0407         dr     = cms.double(0.3),
0408         drMin  = cms.double(0.1),
0409         ptMax  = cms.double(100.),
0410         absEtaCuts         = cms.vdouble(   ), # just one bin
0411         ptCut             = cms.vdouble( 10.0  ),
0412         ptSlopes           = cms.vdouble(  0.25 ),
0413         ptSlopesPhoton    = cms.vdouble(  0.25 ),
0414         ptZeros            = cms.vdouble( 14.0  ),
0415         ptZerosPhoton     = cms.vdouble( 14.0  ),
0416         alphaSlopes        = cms.vdouble(  0.6  ),
0417         alphaZeros         = cms.vdouble(  9.0  ),
0418         alphaCrop         = cms.vdouble(   4   ),
0419         priors             = cms.vdouble(  6.0  ),
0420         priorsPhoton      = cms.vdouble(  6.0  ),
0421         debug = cms.untracked.bool(False)
0422     ),
0423     tkEgAlgoParameters=tkEgAlgoParameters.clone(
0424         nTRACK = 5,           # to be defined
0425         nTRACK_EGIN = 5,          # to be defined
0426         nEMCALO_EGIN = 5,  # to be defined
0427         nEM_EGOUT = 5,        # to be defined
0428         doBremRecovery=True,
0429         writeEGSta=True),
0430     tkEgSorterParameters=tkEgSorterParameters.clone(),
0431     caloSectors = cms.VPSet(
0432         cms.PSet( 
0433             etaBoundaries = cms.vdouble(-5.5, -3.0),
0434             phiSlices     = cms.uint32(9),
0435             phiZero       = cms.double(0),
0436         ),
0437         cms.PSet( 
0438             etaBoundaries = cms.vdouble(+3.0, +5.5),
0439             phiSlices     = cms.uint32(9),
0440             phiZero       = cms.double(0),
0441         )
0442     ),
0443     regions = cms.VPSet(
0444         cms.PSet( 
0445             etaBoundaries = cms.vdouble(-5.5, -3.0),
0446             phiSlices     = cms.uint32(9),
0447             etaExtra = cms.double(0.25),
0448             phiExtra = cms.double(0.25),
0449         ),
0450         cms.PSet( 
0451             etaBoundaries = cms.vdouble(+3.0, +5.5),
0452             phiSlices     = cms.uint32(9),
0453             etaExtra = cms.double(0.25),
0454             phiExtra = cms.double(0.25),
0455         )
0456     ),
0457     boards=cms.VPSet(),
0458 )
0459 
0460 
0461 l1tLayer1 = cms.EDProducer("L1TPFCandMultiMerger",
0462     pfProducers = cms.VInputTag(
0463         cms.InputTag("l1tLayer1Barrel"),
0464         cms.InputTag("l1tLayer1HGCal"),
0465         cms.InputTag("l1tLayer1HGCalNoTK"),
0466         cms.InputTag("l1tLayer1HF")
0467     ),
0468     labelsToMerge = cms.vstring("PF", "Puppi", "Calo", "TK"),
0469     regionalLabelsToMerge = cms.vstring("Puppi"),
0470 )
0471 
0472 l1tLayer1EG = cms.EDProducer(
0473     "L1TEGMultiMerger",
0474     tkElectrons=cms.VPSet(
0475         cms.PSet(
0476             instance=cms.string("L1TkEleEE"),
0477             pfProducers=cms.VInputTag(
0478                 cms.InputTag("l1tLayer1HGCal", 'L1TkEle')
0479             )
0480         ),
0481         cms.PSet(
0482             instance=cms.string("L1TkEleEB"),
0483             pfProducers=cms.VInputTag(
0484                 cms.InputTag("l1tLayer1Barrel", 'L1TkEle')
0485             )
0486         )
0487     ),
0488     tkEms=cms.VPSet(
0489         cms.PSet(
0490             instance=cms.string("L1TkEmEE"),
0491             pfProducers=cms.VInputTag(
0492                 cms.InputTag("l1tLayer1HGCal", 'L1TkEm'),
0493                 cms.InputTag("l1tLayer1HGCalNoTK", 'L1TkEm')
0494             )
0495         ),
0496         cms.PSet(
0497             instance=cms.string("L1TkEmEB"),
0498             pfProducers=cms.VInputTag(
0499                 cms.InputTag("l1tLayer1Barrel", 'L1TkEm')
0500             )
0501         )
0502     ),
0503     tkEgs=cms.VPSet(
0504         cms.PSet(
0505             instance=cms.string("L1EgEE"),
0506             pfProducers=cms.VInputTag(
0507                 cms.InputTag("l1tLayer1HGCal", 'L1Eg'),
0508                 cms.InputTag("l1tLayer1HGCalNoTK", 'L1Eg')
0509             )
0510         )    
0511     )
0512 )
0513 
0514 L1TLayer1TaskInputsTask = cms.Task(
0515     l1tPFClustersFromL1EGClusters,
0516     l1tPFClustersFromCombinedCaloHCal,
0517     l1tPFClustersFromCombinedCaloHF,
0518     l1tPFClustersFromHGC3DClusters,
0519     l1tPFTracksFromL1Tracks
0520 )
0521 
0522 L1TLayer1Task = cms.Task(
0523      l1tLayer1Barrel,
0524      l1tLayer1HGCal,
0525      l1tLayer1HGCalNoTK,
0526      l1tLayer1HF,
0527      l1tLayer1,
0528      l1tLayer1EG
0529 )