Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2022-09-14 22:43:12

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(6),
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/6) # L1 TrackFinder phi sector and HGCal sectors shifted by 30deg,
0145     ),
0146     cms.PSet( 
0147         etaBoundaries = cms.vdouble(+1.5, +3.0),
0148         phiSlices     = cms.uint32(3),
0149         phiZero       = cms.double(math.pi/6) # L1 TrackFinder phi sector and HGCal sectors shifted by 30deg,
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         writeBeforeBremRecovery=False,
0259         writeEGSta=True),
0260     tkEgSorterParameters=tkEgSorterParameters.clone(
0261         nObjToSort = 5
0262     ),
0263     caloSectors = _hgcalSectors,
0264     regions = cms.VPSet(
0265         cms.PSet( 
0266             etaBoundaries = cms.vdouble(-2.5, -1.5),
0267             phiSlices     = cms.uint32(9),
0268             etaExtra = cms.double(0.25),
0269             phiExtra = cms.double(0.25),
0270         ),
0271         cms.PSet( 
0272             etaBoundaries = cms.vdouble(+1.5, +2.5),
0273             phiSlices     = cms.uint32(9),
0274             etaExtra = cms.double(0.25),
0275             phiExtra = cms.double(0.25),
0276         )
0277 
0278     ),
0279     boards=cms.VPSet(
0280         cms.PSet(
0281             regions=cms.vuint32(range(0, 9))),
0282         cms.PSet(
0283             regions=cms.vuint32(range(9, 18))),
0284     ),
0285     writeRawHgcalCluster = cms.untracked.bool(True)
0286 )
0287 
0288 
0289 l1tLayer1HGCalNoTK = cms.EDProducer("L1TCorrelatorLayer1Producer",
0290     tracks = cms.InputTag(''),
0291     muons = cms.InputTag('l1tSAMuonsGmt','promptSAMuons'),
0292     emClusters = cms.VInputTag(cms.InputTag('l1tPFClustersFromHGC3DClusters:egamma')), # used only for E/gamma
0293     hadClusters = cms.VInputTag(cms.InputTag('l1tPFClustersFromHGC3DClusters')),
0294     vtxCollection = cms.InputTag("l1tVertexFinderEmulator","l1verticesEmulation"),
0295     vtxCollectionEmulation = cms.bool(True),
0296     nVtx        = cms.int32(1),        
0297     emPtCut  = cms.double(0.5),
0298     hadPtCut = cms.double(1.0),
0299     trkPtCut    = cms.double(2.0),
0300     muonInputConversionAlgo = cms.string("Emulator"),
0301     muonInputConversionParameters = muonInputConversionParameters.clone(),
0302     regionizerAlgo = cms.string("Ideal"),
0303     pfAlgo = cms.string("PFAlgoDummy"),
0304     puAlgo = cms.string("LinearizedPuppi"),
0305     regionizerAlgoParameters = cms.PSet(
0306         useAlsoVtxCoords = cms.bool(True),
0307     ),
0308     pfAlgoParameters = cms.PSet(
0309         nCalo = cms.uint32(12), 
0310         nMu = cms.uint32(4), # unused
0311         debug = cms.untracked.bool(False)
0312     ),
0313     puAlgoParameters = cms.PSet(
0314         nTrack = cms.uint32(0),  # unused
0315         nIn = cms.uint32(12), 
0316         nOut = cms.uint32(12), 
0317         nFinalSort = cms.uint32(12), # to be tuned
0318         finalSortAlgo = cms.string("Hybrid"), 
0319         nVtx = cms.uint32(1),    
0320         dZ     = cms.double(1.33),
0321         dr     = cms.double(0.3),
0322         drMin  = cms.double(0.04),
0323         ptMax  = cms.double(50.),
0324         absEtaCuts         = cms.vdouble( ), # just one bin
0325         ptCut             = cms.vdouble( 4.0 ),
0326         ptSlopes           = cms.vdouble( 0.3 ), # coefficient for pT
0327         ptSlopesPhoton    = cms.vdouble( 0.4 ), #When e/g ID not applied, use: cms.vdouble( 0.3, 0.3, 0.3 ),
0328         ptZeros            = cms.vdouble( 9.0 ), # ballpark pT from PU
0329         ptZerosPhoton     = cms.vdouble( 5.0 ),
0330         alphaSlopes        = cms.vdouble( 2.2 ),
0331         alphaZeros         = cms.vdouble( 9.0 ),
0332         alphaCrop         = cms.vdouble(  4  ), # max. absolute value for alpha term
0333         priors             = cms.vdouble( 7.0 ),
0334         priorsPhoton      = cms.vdouble( 5.0 ), #When e/g ID not applied, use: cms.vdouble( 3.5, 3.5, 7.0 ),
0335         debug = cms.untracked.bool(False)
0336     ),
0337     tkEgAlgoParameters=tkEgAlgoParameters.clone(
0338         nTRACK = 30,
0339         nTRACK_EGIN = 10,
0340         nEMCALO_EGIN = 10, 
0341         nEM_EGOUT = 5,
0342         doBremRecovery=True,
0343         writeBeforeBremRecovery=False,
0344         writeEGSta=True),
0345     tkEgSorterParameters=tkEgSorterParameters.clone(
0346         nObjToSort=5
0347     ),
0348     caloSectors = _hgcalSectors,
0349     regions = cms.VPSet(
0350         cms.PSet( 
0351             etaBoundaries = cms.vdouble(-3.0, -2.5),
0352             phiSlices     = cms.uint32(9),
0353             etaExtra = cms.double(0.25),
0354             phiExtra = cms.double(0.25),
0355         ),
0356         cms.PSet( 
0357             etaBoundaries = cms.vdouble(+2.5, +3.0),
0358             phiSlices     = cms.uint32(9),
0359             etaExtra = cms.double(0.25),
0360             phiExtra = cms.double(0.25),
0361         )
0362 
0363     ),
0364     boards=cms.VPSet(
0365         cms.PSet(
0366             regions=cms.vuint32(range(0,18))),
0367     ),
0368     writeRawHgcalCluster = cms.untracked.bool(True)
0369 )
0370 
0371 l1tLayer1HF = cms.EDProducer("L1TCorrelatorLayer1Producer",
0372     tracks = cms.InputTag(''),
0373     muons = cms.InputTag('l1tSAMuonsGmt','promptSAMuons'),
0374     useStandaloneMuons = cms.bool(False),
0375     useTrackerMuons = cms.bool(False),
0376     emClusters = cms.VInputTag(),
0377     hadClusters = cms.VInputTag(cms.InputTag('l1tPFClustersFromCombinedCaloHF:calibrated')),
0378     vtxCollection = cms.InputTag("l1tVertexFinderEmulator","l1verticesEmulation"),
0379     vtxCollectionEmulation = cms.bool(True),
0380     nVtx        = cms.int32(1),    
0381     emPtCut  = cms.double(0.5),
0382     hadPtCut = cms.double(15.0),
0383     trkPtCut    = cms.double(2.0),
0384     muonInputConversionAlgo = cms.string("Ideal"),
0385     muonInputConversionParameters = muonInputConversionParameters.clone(),
0386     regionizerAlgo = cms.string("Ideal"),
0387     pfAlgo = cms.string("PFAlgoDummy"),
0388     puAlgo = cms.string("LinearizedPuppi"),
0389     regionizerAlgoParameters = cms.PSet(
0390         useAlsoVtxCoords = cms.bool(True),
0391     ),
0392     pfAlgoParameters = cms.PSet(
0393         nCalo = cms.uint32(18), 
0394         nMu = cms.uint32(4), # unused
0395         debug = cms.untracked.bool(False)
0396     ),
0397     puAlgoParameters = cms.PSet(
0398         nTrack = cms.uint32(0), # unused
0399         nIn = cms.uint32(18), 
0400         nOut = cms.uint32(18), 
0401         nVtx = cms.uint32(1),
0402         nFinalSort = cms.uint32(10), # to be tuned
0403         finalSortAlgo = cms.string("Insertion"),
0404         dZ     = cms.double(1.33),
0405         dr     = cms.double(0.3),
0406         drMin  = cms.double(0.1),
0407         ptMax  = cms.double(100.),
0408         absEtaCuts         = cms.vdouble(   ), # just one bin
0409         ptCut             = cms.vdouble( 10.0  ),
0410         ptSlopes           = cms.vdouble(  0.25 ),
0411         ptSlopesPhoton    = cms.vdouble(  0.25 ),
0412         ptZeros            = cms.vdouble( 14.0  ),
0413         ptZerosPhoton     = cms.vdouble( 14.0  ),
0414         alphaSlopes        = cms.vdouble(  0.6  ),
0415         alphaZeros         = cms.vdouble(  9.0  ),
0416         alphaCrop         = cms.vdouble(   4   ),
0417         priors             = cms.vdouble(  6.0  ),
0418         priorsPhoton      = cms.vdouble(  6.0  ),
0419         debug = cms.untracked.bool(False)
0420     ),
0421     tkEgAlgoParameters=tkEgAlgoParameters.clone(
0422         nTRACK = 5,           # to be defined
0423         nTRACK_EGIN = 5,          # to be defined
0424         nEMCALO_EGIN = 5,  # to be defined
0425         nEM_EGOUT = 5,        # to be defined
0426         doBremRecovery=True,
0427         writeEGSta=True),
0428     tkEgSorterParameters=tkEgSorterParameters.clone(),
0429     caloSectors = cms.VPSet(
0430         cms.PSet( 
0431             etaBoundaries = cms.vdouble(-5.5, -3.0),
0432             phiSlices     = cms.uint32(9),
0433             phiZero       = cms.double(0),
0434         ),
0435         cms.PSet( 
0436             etaBoundaries = cms.vdouble(+3.0, +5.5),
0437             phiSlices     = cms.uint32(9),
0438             phiZero       = cms.double(0),
0439         )
0440     ),
0441     regions = cms.VPSet(
0442         cms.PSet( 
0443             etaBoundaries = cms.vdouble(-5.5, -3.0),
0444             phiSlices     = cms.uint32(9),
0445             etaExtra = cms.double(0.25),
0446             phiExtra = cms.double(0.25),
0447         ),
0448         cms.PSet( 
0449             etaBoundaries = cms.vdouble(+3.0, +5.5),
0450             phiSlices     = cms.uint32(9),
0451             etaExtra = cms.double(0.25),
0452             phiExtra = cms.double(0.25),
0453         )
0454     ),
0455     boards=cms.VPSet(),
0456 )
0457 
0458 
0459 l1tLayer1 = cms.EDProducer("L1TPFCandMultiMerger",
0460     pfProducers = cms.VInputTag(
0461         cms.InputTag("l1tLayer1Barrel"),
0462         cms.InputTag("l1tLayer1HGCal"),
0463         cms.InputTag("l1tLayer1HGCalNoTK"),
0464         cms.InputTag("l1tLayer1HF")
0465     ),
0466     labelsToMerge = cms.vstring("PF", "Puppi", "Calo", "TK"),
0467     regionalLabelsToMerge = cms.vstring("Puppi"),
0468 )
0469 
0470 l1tLayer1EG = cms.EDProducer(
0471     "L1TEGMultiMerger",
0472     tkElectrons=cms.VPSet(
0473         cms.PSet(
0474             instance=cms.string("L1TkEleEE"),
0475             pfProducers=cms.VInputTag(
0476                 cms.InputTag("l1tLayer1HGCal", 'L1TkEle')
0477             )
0478         ),
0479         cms.PSet(
0480             instance=cms.string("L1TkEleEB"),
0481             pfProducers=cms.VInputTag(
0482                 cms.InputTag("l1tLayer1Barrel", 'L1TkEle')
0483             )
0484         )
0485     ),
0486     tkEms=cms.VPSet(
0487         cms.PSet(
0488             instance=cms.string("L1TkEmEE"),
0489             pfProducers=cms.VInputTag(
0490                 cms.InputTag("l1tLayer1HGCal", 'L1TkEm'),
0491                 cms.InputTag("l1tLayer1HGCalNoTK", 'L1TkEm')
0492             )
0493         ),
0494         cms.PSet(
0495             instance=cms.string("L1TkEmEB"),
0496             pfProducers=cms.VInputTag(
0497                 cms.InputTag("l1tLayer1Barrel", 'L1TkEm')
0498             )
0499         )
0500     ),
0501     tkEgs=cms.VPSet(
0502         cms.PSet(
0503             instance=cms.string("L1EgEE"),
0504             pfProducers=cms.VInputTag(
0505                 cms.InputTag("l1tLayer1HGCal", 'L1Eg'),
0506                 cms.InputTag("l1tLayer1HGCalNoTK", 'L1Eg')
0507             )
0508         )    
0509     )
0510 )
0511 
0512 L1TLayer1TaskInputsTask = cms.Task(
0513     l1tPFClustersFromL1EGClusters,
0514     l1tPFClustersFromCombinedCaloHCal,
0515     l1tPFClustersFromCombinedCaloHF,
0516     l1tPFClustersFromHGC3DClusters,
0517     l1tPFTracksFromL1Tracks
0518 )
0519 
0520 L1TLayer1Task = cms.Task(
0521      l1tLayer1Barrel,
0522      l1tLayer1HGCal,
0523      l1tLayer1HGCalNoTK,
0524      l1tLayer1HF,
0525      l1tLayer1,
0526      l1tLayer1EG
0527 )