Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2023-10-25 09:55:57

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