Phase2L1ParticleFlow/python/l1ctLayer1_cff.py

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