Phase2L1ParticleFlow/python/l1ctLayer1_patternWriters_cff.py

0001 import FWCore.ParameterSet.Config as cms
0002
0003 _eventsPerFile = 12
0004 _gttLatency = 156+120
0005 _gttNumberOfPVs = 10
0006
0007 #####################################################################################################################
0008 ## Barrel configurations: 54 regions, 6 puppi output links, only write out the layer 1 outputs for now
0009 _barrelWriterOutputOnly = cms.PSet(
0010     partition = cms.string("Barrel"),
0011     tmuxFactor = cms.uint32(6),
0012     outputLinksPuppi = cms.vuint32(*range(6)),
0013     outputLinkEgamma = cms.int32(6),
0014     nEgammaObjectsOut = cms.uint32(16),
0015     nInputFramesPerBX = cms.uint32(9),
0016     nOutputFramesPerBX = cms.uint32(9),
0017     fileFormat = cms.string("EMPv2"),
0018     inputFileExtension = cms.string("txt.gz"),
0019     outputFileExtension = cms.string("txt.gz"),
0020     maxLinesPerInputFile = cms.uint32(1024),
0021     maxLinesPerOutputFile = cms.uint32(1024),
0022     eventsPerFile = cms.uint32(_eventsPerFile),
0023     tfTimeSlices = cms.VPSet(),
0024     gmtTimeSlices = cms.VPSet(),
0025     gmtNumberOfMuons = cms.uint32(12),
0026     gttLink = cms.int32(-1),
0027     gttLatency = cms.uint32(156+10),
0028     gttNumberOfPVs = cms.uint32(_gttNumberOfPVs),
0029     gctEmSectors = cms.VPSet(),
0030     gctHadSectors = cms.VPSet(),
0031     tfNumberOfTracks = cms.uint32(108),
0032     gctNumberOfEMs = cms.uint32(32),
0033     gctNumberOfHads = cms.uint32(48),
0034 )
0035 ## Barrel (54) split in 3 phi slices (EMP format)
0036 barrelWriterOutputOnlyPhiConfigs = [
0037     _barrelWriterOutputOnly.clone(
0038         outputRegions = cms.vuint32(*[3*ip+9*ie+i for ie in range(6) for i in range(3) ]),
0039         outputBoard = cms.int32(ip),
0040         outputFileName = cms.string("l1BarrelPhi%d-outputs" % (ip+1))
0041     ) for ip in range(3)
0042 ]
0043
0044 def _sortApxRegions(etaPhiSortedRegions):
0045     """Returns the APx output order for a tuple/list of regions (ints)
0046     """
0047     apxOrder = (0, 4, 2, 6, 5, 8, 7, 10, 9, 12, 11, 14, 13, 16, 15, 1, 17, 3)
0048     if len(etaPhiSortedRegions) != len(apxOrder):
0049         raise RuntimeError(f"Unexptected number of regions passed: {len(etaPhiSortedRegions)}")
0050     return [etaPhiSortedRegions[apxOrder[i]] for i in range(len(apxOrder))]
0051
0052 ## Barrel (54) split in 3 phi slices (APx format)
0053 barrelWriterOutputOnlyPhiConfigsAPx = [
0054     _barrelWriterOutputOnly.clone(
0055         fileFormat = cms.string("APx"),
0056         outputRegions = cms.vuint32(*_sortApxRegions([3*ip+9*ie+i for ie in range(6) for i in range(3) ])),
0057         outputBoard = cms.int32(ip),
0058         outputFileName = cms.string("l1BarrelApxPhi%d-outputs" % (ip+1))
0059     ) for ip in range(3)
0060 ]
0061
0062 barrelWriterDebugPFInConfigsAPx = [
0063     _barrelWriterOutputOnly.clone(
0064         fileFormat = cms.string("APx"),
0065         outputRegions = cms.vuint32(*_sortApxRegions([3*ip+9*ie+i for ie in range(6) for i in range(3) ])),
0066         outputBoard = cms.int32(ip),
0067         nPFInTrack = cms.uint32(22),
0068         nPFInEmCalo = cms.uint32(12),
0069         nPFInHadCalo = cms.uint32(15),
0070         nPFInMuon = cms.uint32(2),
0071         debugFileName = cms.string("l1BarrelApxPhi%d-pfin" % (ip+1))
0072     ) for ip in range(3)
0073 ]
0074
0075 barrelWriterDebugPFOutConfigsAPx = [
0076     _barrelWriterOutputOnly.clone(
0077         fileFormat = cms.string("APx"),
0078         outputRegions = cms.vuint32(*_sortApxRegions([3*ip+9*ie+i for ie in range(6) for i in range(3) ])),
0079         outputBoard = cms.int32(ip),
0080         nPFOutCharged = cms.uint32(22),
0081         nPFOutPhoton = cms.uint32(12),
0082         nPFOutNeutral = cms.uint32(15),
0083         nPFOutMuon = cms.uint32(2),
0084         debugFileName = cms.string("l1BarrelApxPhi%d-pfout" % (ip+1))
0085     ) for ip in range(3)
0086 ]
0087
0088 barrelSerenityPhi1Config = barrelWriterOutputOnlyPhiConfigs[0].clone(
0089     tfTimeSlices = cms.VPSet(*[cms.PSet(tfSectors = cms.VPSet(*[ cms.PSet(tfLink = cms.int32(-1)) for s in range(18) ])) for t in range(3)]),
0090     gctEmSectors = cms.VPSet(*[ cms.PSet(gctEmLink = cms.int32(-1)) for s in range(12) ]),
0091     gctHadSectors = cms.VPSet(*[ cms.PSet(gctHadLink = cms.int32(-1)) for s in range(12) ]),
0092     gmtTimeSlices = cms.VPSet(*[cms.PSet(gmtLink = cms.int32(4*17+t)) for t in range(3)]),
0093 )
0094 barrelSerenityVU9PPhi1Config = barrelSerenityPhi1Config.clone(
0095     gttLink = cms.int32(4*28+3),
0096     inputFileName = cms.string("l1BarrelPhi1Serenity-inputs-vu9p"),
0097     outputFileName = cms.string("l1BarrelPhi1Serenity-outputs")
0098 )
0099 barrelSerenityVU13PPhi1Config = barrelSerenityPhi1Config.clone(
0100     gttLink = cms.int32(4*25+3),
0101     gmtTimeSlices = cms.VPSet(*[cms.PSet(gmtLink = cms.int32(4*18+t)) for t in range(3)]),
0102     inputFileName = cms.string("l1BarrelPhi1Serenity-inputs-vu13p"),
0103 )
0104
0105 # This includes muon and GTT sector mapping. There is only one GTT fiber, with a logical firmware link of 123.
0106 # The muons, being TM18, have three time slices, to map the emulated data to logical firmware links of 10, 48, and 107
0107 # Only placeholders are entered for the GCT and TF link numbers here, which are filled in the loops below
0108 barrelApxWriterConfig = [
0109     _barrelWriterOutputOnly.clone(
0110         fileFormat = cms.string("APx"),
0111         gttLink = cms.int32(123),
0112         gmtTimeSlices = cms.VPSet(*[cms.PSet(gmtLink = cms.int32(38*t+10)) for t in range(3)]),
0113         gctEmSectors = cms.VPSet(*[ cms.PSet(gctEmLink = cms.int32(-1)) for s in range(12) ]),
0114         gctHadSectors = cms.VPSet(*[ cms.PSet(gctHadLink = cms.int32(-1)) for s in range(12) ]),
0115         inputFileName = cms.string("l1BarrelApxPhi%d-inputs" % (ip+1)),
0116         tfTimeSlices = cms.VPSet(*[cms.PSet(tfSectors = cms.VPSet(*[ cms.PSet(tfLink = cms.int32(-1)) for s in range(18) ])) for t in range(3)]),
0117     ) for ip in range(3)
0118 ]
0119
0120 # Set GCT link numbers. 115-122 are the logical fiber numbers in the firmware.
0121 # This maps the emulated sector indices to the firmware logical numbers
0122 # Note, since both the GCT and CL1 are TM6 in this case, there are no time slices
0123 for iBigRegion, ilink in enumerate((0, 1, 2)):
0124     barrelApxWriterConfig[iBigRegion].gctEmSectors[ilink].gctEmLink = 119
0125     barrelApxWriterConfig[iBigRegion].gctEmSectors[ilink+6].gctEmLink = 120
0126     barrelApxWriterConfig[iBigRegion].gctEmSectors[ilink+3].gctEmLink = 121
0127     barrelApxWriterConfig[iBigRegion].gctEmSectors[ilink+9].gctEmLink = 122
0128     barrelApxWriterConfig[iBigRegion].gctHadSectors[ilink].gctHadLink = 115
0129     barrelApxWriterConfig[iBigRegion].gctHadSectors[ilink+6].gctHadLink = 116
0130     barrelApxWriterConfig[iBigRegion].gctHadSectors[ilink+3].gctHadLink = 117
0131     barrelApxWriterConfig[iBigRegion].gctHadSectors[ilink+9].gctHadLink = 118
0132
0133 # Set tracking link numbers. The tracks are logically 0-9, 38-47, and 76-85 for TM groups 0, 1, and 2 in the firmware
0134 # This maps the emulated sector indices to the firmware logical numbers
0135 for timeSlice in range(3):
0136     for iBigRegion, ilink in enumerate((8, 2, 5)):
0137         barrelApxWriterConfig[iBigRegion].tfTimeSlices[timeSlice].tfSectors[ilink].tfLink = 0 + timeSlice * 38
0138         barrelApxWriterConfig[iBigRegion].tfTimeSlices[timeSlice].tfSectors[(ilink+1)%9].tfLink = 1 + timeSlice * 38
0139         barrelApxWriterConfig[iBigRegion].tfTimeSlices[timeSlice].tfSectors[(ilink+2)%9].tfLink = 2 + timeSlice * 38
0140         barrelApxWriterConfig[iBigRegion].tfTimeSlices[timeSlice].tfSectors[(ilink+3)%9].tfLink = 3 + timeSlice * 38
0141         barrelApxWriterConfig[iBigRegion].tfTimeSlices[timeSlice].tfSectors[(ilink+4)%9].tfLink = 4 + timeSlice * 38
0142         barrelApxWriterConfig[iBigRegion].tfTimeSlices[timeSlice].tfSectors[9 + ilink].tfLink = 5 + timeSlice * 38
0143         barrelApxWriterConfig[iBigRegion].tfTimeSlices[timeSlice].tfSectors[9 + (ilink+1)%9].tfLink = 6 + timeSlice * 38
0144         barrelApxWriterConfig[iBigRegion].tfTimeSlices[timeSlice].tfSectors[9 + (ilink+2)%9].tfLink = 7 + timeSlice * 38
0145         barrelApxWriterConfig[iBigRegion].tfTimeSlices[timeSlice].tfSectors[9 + (ilink+3)%9].tfLink = 8 + timeSlice * 38
0146         barrelApxWriterConfig[iBigRegion].tfTimeSlices[timeSlice].tfSectors[9 + (ilink+4)%9].tfLink = 9 + timeSlice * 38
0147
0148 # Similar mapping for the barrel Serenity setup
0149 for t in range(3):
0150    for ie in range(2):
0151     for i,s in enumerate([8, 0, 1, 2, 3]):
0152         loglink = 3*(i+5*ie)+t
0153         physlink = loglink+4*1 if loglink < 15 else (loglink-15)+4*25
0154         barrelSerenityVU9PPhi1Config.tfTimeSlices[t].tfSectors[s+9*ie].tfLink = physlink
0155         physlink = loglink+4*0 if loglink < 15 else (loglink-15)+4*28
0156         barrelSerenityVU13PPhi1Config.tfTimeSlices[t].tfSectors[s+9*ie].tfLink = physlink
0157
0158 barrelWriterConfigs =  barrelWriterOutputOnlyPhiConfigs
0159 barrelOutputWriterConfigsAPx =  barrelWriterOutputOnlyPhiConfigsAPx
0160 barrelInputWriterConfigsAPx =  barrelApxWriterConfig
0161
0162 #####################################################################################################################
0163 ## HGcal configuration: write out both inputs and outputs
0164 _hgcalWriterConfig = cms.PSet(
0165     partition = cms.string("HGCal"),
0166     tmuxFactor = cms.uint32(6),
0167     nEgammaObjectsOut = cms.uint32(16),
0168     nInputFramesPerBX = cms.uint32(9),
0169     nOutputFramesPerBX = cms.uint32(9),
0170     fileFormat = cms.string("EMPv2"),
0171     inputFileExtension = cms.string("txt.gz"),
0172     outputFileExtension = cms.string("txt.gz"),
0173     maxLinesPerInputFile = cms.uint32(1024),
0174     maxLinesPerOutputFile = cms.uint32(1024),
0175     eventsPerFile = cms.uint32(_eventsPerFile),
0176     tfTimeSlices = cms.VPSet(*[cms.PSet(tfSectors = cms.VPSet()) for i in range(3)]),
0177     hgcTimeSlices = cms.VPSet(*[cms.PSet(hgcSectors = cms.VPSet()) for i in range(3)]),
0178     gmtTimeSlices = cms.VPSet(*[cms.PSet(gmtLink = cms.int32(-1)) for i in range(3)]),
0179     gmtNumberOfMuons = cms.uint32(12),
0180     gttLink = cms.int32(-1),
0181     gttLatency = cms.uint32(_gttLatency),
0182     gttNumberOfPVs = cms.uint32(_gttNumberOfPVs),
0183     outputLinksPuppi = cms.vuint32(*range(3)),
0184     outputLinkEgamma = cms.int32(3),
0185 )
0186 ## Ideal configuration: 27 input links from tf, 36 from hgc, 3 from gmt, 1 from gtt, in this order; output 3 puppi + 1 e/gamma
0187 _hgcalPosWriterConfig = _hgcalWriterConfig.clone(
0188     outputRegions = cms.vuint32(*[i+9 for i in range(9)]),
0189     outputBoard = cms.int32(1),
0190 )
0191 _hgcalNegWriterConfig = _hgcalPosWriterConfig.clone(
0192     outputRegions = [i for i in range(9)],
0193     outputBoard = 0,
0194 )
0195 hgcalPosOutputWriterConfig = _hgcalPosWriterConfig.clone(
0196    outputFileName = cms.string("l1HGCalPos-outputs")
0197 )
0198 hgcalNegOutputWriterConfig = _hgcalNegWriterConfig.clone(
0199    outputFileName = cms.string("l1HGCalNeg-outputs")
0200 )
0201 ## Current configurations for VU9P
0202 hgcalPosVU9PWriterConfig = _hgcalPosWriterConfig.clone()
0203 hgcalNegVU9PWriterConfig = _hgcalNegWriterConfig.clone()
0204 for t in range(3):
0205     hgcalPosVU9PWriterConfig.tfTimeSlices[t].tfSectors += [ cms.PSet(tfLink = cms.int32(-1))         for i in range(9) ] # neg
0206     hgcalPosVU9PWriterConfig.tfTimeSlices[t].tfSectors += [ cms.PSet(tfLink = cms.int32(3*i+t+4*1))  for i in range(4) ] # pos, left quads
0207     hgcalPosVU9PWriterConfig.tfTimeSlices[t].tfSectors += [ cms.PSet(tfLink = cms.int32(3*i+t+4*26)) for i in range(5) ] # pos, right quads
0208     hgcalNegVU9PWriterConfig.tfTimeSlices[t].tfSectors += [ cms.PSet(tfLink = cms.int32(3*i+t+4*1))  for i in range(4) ] # neg, left quads
0209     hgcalNegVU9PWriterConfig.tfTimeSlices[t].tfSectors += [ cms.PSet(tfLink = cms.int32(3*i+t+4*26)) for i in range(5) ] # neg, right quads
0210     hgcalNegVU9PWriterConfig.tfTimeSlices[t].tfSectors += [ cms.PSet(tfLink = cms.int32(-1))         for i in range(9) ] # pos
0211     hgcQuads =  [list(range(4*i,4*i+4)) for i in [10,11,12,13]]
0212     hgcQuads += [[4*14+1,4*14+2,4*14+3,4*15+3]] # mixed quad
0213     hgcQuads += [list(range(4*i,4*i+4)) for i in [16,17,18,19]]
0214     hgcalPosVU9PWriterConfig.hgcTimeSlices[t].hgcSectors += [ cms.PSet(hgcLinks = cms.vint32(-1,-1,-1,-1))      for i in range(3) ] # neg
0215     hgcalPosVU9PWriterConfig.hgcTimeSlices[t].hgcSectors += [ cms.PSet(hgcLinks = cms.vint32(*hgcQuads[3*i+t])) for i in range(3) ] # pos
0216     hgcalNegVU9PWriterConfig.hgcTimeSlices[t].hgcSectors += [ cms.PSet(hgcLinks = cms.vint32(*hgcQuads[3*i+t])) for i in range(3) ] # neg
0217     hgcalNegVU9PWriterConfig.hgcTimeSlices[t].hgcSectors += [ cms.PSet(hgcLinks = cms.vint32(-1,-1,-1,-1))      for i in range(3) ] # pos
0218     hgcalPosVU9PWriterConfig.gmtTimeSlices[t].gmtLink = cms.int32(4*15+((t+2)%3))
0219     hgcalNegVU9PWriterConfig.gmtTimeSlices[t].gmtLink = cms.int32(4*15+((t+2)%3))
0220 hgcalPosVU9PWriterConfig.gttLink = 4*14+0
0221 hgcalNegVU9PWriterConfig.gttLink = 4*14+0
0222 hgcalPosVU9PWriterConfig.inputFileName = cms.string("l1HGCalPos-inputs-vu9p")
0223 hgcalNegVU9PWriterConfig.inputFileName = cms.string("l1HGCalNeg-inputs-vu9p")
0224 ## Current configurations for VU13P
0225 hgcalPosVU13PWriterConfig = _hgcalPosWriterConfig.clone()
0226 hgcalNegVU13PWriterConfig = _hgcalNegWriterConfig.clone()
0227 for t in range(3):
0228     hgcalPosVU13PWriterConfig.tfTimeSlices[t].tfSectors += [ cms.PSet(tfLink = cms.int32(-1))         for i in range(9) ] # neg
0229     hgcalPosVU13PWriterConfig.tfTimeSlices[t].tfSectors += [ cms.PSet(tfLink = cms.int32(3*i+t+4*0))  for i in range(5) ] # pos, left quads
0230     hgcalPosVU13PWriterConfig.tfTimeSlices[t].tfSectors += [ cms.PSet(tfLink = cms.int32(3*i+t+4*28)) for i in range(4) ] # pos, right quads
0231     hgcalNegVU13PWriterConfig.tfTimeSlices[t].tfSectors += [ cms.PSet(tfLink = cms.int32(3*i+t+4*0))  for i in range(5) ] # neg, left quads
0232     hgcalNegVU13PWriterConfig.tfTimeSlices[t].tfSectors += [ cms.PSet(tfLink = cms.int32(3*i+t+4*28)) for i in range(4) ] # neg, right quads
0233     hgcalNegVU13PWriterConfig.tfTimeSlices[t].tfSectors += [ cms.PSet(tfLink = cms.int32(-1))         for i in range(9) ] # pos
0234     hgcQuads =  [list(range(4*i,4*i+4)) for i in [12,13,14,  16,17,  19,20,21,22]]
0235     hgcalPosVU13PWriterConfig.hgcTimeSlices[t].hgcSectors += [ cms.PSet(hgcLinks = cms.vint32(-1,-1,-1,-1)) for i in range(3) ] # neg
0236     hgcalPosVU13PWriterConfig.hgcTimeSlices[t].hgcSectors += [ cms.PSet(hgcLinks = cms.vint32(*hgcQuads[3*i+t])) for i in range(3) ] # pos
0237     hgcalNegVU13PWriterConfig.hgcTimeSlices[t].hgcSectors += [ cms.PSet(hgcLinks = cms.vint32(*hgcQuads[3*i+t])) for i in range(3) ] # neg
0238     hgcalNegVU13PWriterConfig.hgcTimeSlices[t].hgcSectors += [ cms.PSet(hgcLinks = cms.vint32(-1,-1,-1,-1)) for i in range(3) ] # pos
0239     hgcalPosVU13PWriterConfig.gmtTimeSlices[t].gmtLink = cms.int32(4*18+t)
0240     hgcalNegVU13PWriterConfig.gmtTimeSlices[t].gmtLink = cms.int32(4*18+t)
0241 hgcalPosVU13PWriterConfig.gttLink = 4*25+3
0242 hgcalNegVU13PWriterConfig.gttLink = 4*25+3
0243 hgcalPosVU13PWriterConfig.inputFileName = cms.string("l1HGCalPos-inputs-vu13p")
0244 hgcalNegVU13PWriterConfig.inputFileName = cms.string("l1HGCalNeg-inputs-vu13p")
0245
0246 ## Enable outputs and both boards
0247 hgcalWriterConfigs = [
0248     hgcalPosOutputWriterConfig,
0249     hgcalNegOutputWriterConfig,
0250     hgcalPosVU9PWriterConfig,
0251     hgcalNegVU9PWriterConfig,
0252     hgcalPosVU13PWriterConfig,
0253     hgcalNegVU13PWriterConfig
0254 ]
0255
0256 #####################################################################################################################
0257 ## Forward HGCal configuration: only outputs for now, 18 regions, 12 candidates x region, 4 output fibers
0258 _hgcalNoTKWriterConfig = cms.PSet(
0259     partition = cms.string("HGCalNoTk"),
0260     tmuxFactor = cms.uint32(6),
0261     outputRegions = cms.vuint32(*range(18)),
0262     nInputFramesPerBX = cms.uint32(9),
0263     nOutputFramesPerBX = cms.uint32(9),
0264     fileFormat = cms.string("EMPv2"),
0265     inputFileExtension = cms.string("txt.gz"),
0266     outputFileExtension = cms.string("txt.gz"),
0267     maxLinesPerInputFile = cms.uint32(1024),
0268     maxLinesPerOutputFile = cms.uint32(1024),
0269     eventsPerFile = cms.uint32(_eventsPerFile),
0270     hgcTimeSlices = cms.VPSet(*[cms.PSet(hgcSectors = cms.VPSet()) for i in range(3)]),
0271     gmtTimeSlices = cms.VPSet(*[cms.PSet(gmtLink = cms.int32(-1)) for  i in range(3)]),
0272     gmtNumberOfMuons = cms.uint32(12),
0273 )
0274 hgcalNoTKOutputWriterConfig = _hgcalNoTKWriterConfig.clone(
0275     outputLinksPuppi = cms.vuint32(*range(4)),
0276     outputFileName = cms.string("l1HGCalNoTK-outputs")
0277 )
0278 hgcalNoTKVU13PWriterConfig = _hgcalNoTKWriterConfig.clone()
0279 for t in range(3):
0280     for isec in range(6):
0281         q0 = 3*isec + (6 if isec < 3 else 8)
0282         hgcalNoTKVU13PWriterConfig.hgcTimeSlices[t].hgcSectors += [ cms.PSet(hgcLinks = cms.vint32(*[4*q0+4*t+j for j in range(4)])) ]
0283 hgcalNoTKVU13PWriterConfig.inputFileName = cms.string("l1HGCalNoTK-inputs-vu13p") # vu9p uses the same cabling for now
0284
0285 hgcalNoTKWriterConfigs = [
0286     hgcalNoTKOutputWriterConfig,
0287     hgcalNoTKVU13PWriterConfig
0288 ]
0289
0290 #####################################################################################################################
0291 ## TM18 configuration
0292 _barrelSerenityTM18 = _barrelWriterOutputOnly.clone(
0293     tmuxFactor = cms.uint32(18),
0294     tfTimeSlices = None,
0295     tfSectors = cms.VPSet(*[cms.PSet(tfLink = cms.int32(-1)) for i in range(18)]),
0296     gmtTimeSlices = None,
0297     gmtLink = cms.int32(4*18+0),
0298     gttLink = 4*28+3,
0299     eventsPerFile = 4,
0300 )
0301 barrelSerenityOutputTM18WriterConfig = _barrelSerenityTM18.clone(
0302     outputRegions = cms.vuint32(*range(54)),
0303     outputBoard = cms.int32(0),
0304     outputFileName = cms.string("l1BarrelSerenityTM18-outputs")
0305 )
0306 barrelSerenityVU13PTM18WriterConfig = _barrelSerenityTM18.clone(
0307     inputFileName = cms.string("l1BarrelSerenityTM18-inputs-vu13p"),
0308     gttLatency = cms.uint32(167), # shorter, to fit 6 events in 1024 lines
0309     maxLinesPerInputFile = cms.uint32(1024+167), # anything beyond 986 will be nulls
0310 )
0311 for ie in range(2):
0312     for iphi in range(9):
0313         isec = 9*ie+iphi
0314         barrelSerenityVU13PTM18WriterConfig.tfSectors[isec].tfLink = (isec if isec < 12 else (4*30+(isec-12)))
0315
0316 barrelSerenityTM18WriterConfigs = [
0317     barrelSerenityOutputTM18WriterConfig,
0318     barrelSerenityVU13PTM18WriterConfig
0319 ]
0320
0321 _hgcalWriterTM18 = _hgcalWriterConfig.clone(
0322     tmuxFactor = cms.uint32(18),
0323     tfTimeSlices = None,
0324     tfSectors = cms.VPSet(*[cms.PSet(tfLink = cms.int32(-1)) for i in range(18)]),
0325     hgcTimeSlices = None,
0326     hgcSectors = cms.VPSet(*[cms.PSet(hgcLinks = cms.vint32()) for i in range(6)]),
0327     gmtTimeSlices = None,
0328     gmtLink = cms.int32(4*27+0),
0329     gttLink = 4*27+3,
0330     eventsPerFile = 4,
0331 )
0332 hgcalWriterOutputTM18WriterConfig = _hgcalWriterTM18.clone(
0333    outputFileName = cms.string("l1HGCalTM18-outputs"),
0334    outputRegions = cms.vuint32(*range(18)),
0335    outputLinksPuppi = cms.vuint32(*range(2)),
0336    outputLinkEgamma = cms.int32(2),
0337 )
0338 hgcalWriterVU9PTM18WriterConfig = _hgcalWriterTM18.clone(
0339    inputFileName = cms.string("l1HGCalTM18-inputs-vu9p"),
0340    gttLatency = cms.uint32(167), # shorter, to fit 6 events in 1024 lines
0341    maxLinesPerInputFile = cms.uint32(1024+167), # anything beyond 986 will be nulls
0342    gmtLink = 4*15+2,
0343    gttLink = 0,
0344 )
0345 hgcalWriterVU13PTM18WriterConfig = hgcalWriterVU9PTM18WriterConfig.clone(
0346    inputFileName = cms.string("l1HGCalTM18-inputs-vu13p"),
0347    gmtLink = 4*18+0,
0348    gttLink = 4*28+3,
0349 )
0350 for ie in range(2):
0351     for iphi in range(9):
0352         isec, ilink = 9*ie+iphi, 2*iphi+ie
0353         hgcalWriterVU9PTM18WriterConfig.tfSectors[isec].tfLink = (ilink+2 if ilink < 10 else (4*28+(ilink-10)))
0354         hgcalWriterVU13PTM18WriterConfig.tfSectors[isec].tfLink = (ilink if ilink < 12 else (4*30+(ilink-12)))
0355     for iphi in range(3):
0356         isec, ilink = 3*ie+iphi, 2*iphi+ie
0357         if ilink < 2:
0358             hgcalWriterVU9PTM18WriterConfig.hgcSectors[isec].hgcLinks += range(4*(12+ilink),4*(12+ilink)+4)
0359         else:
0360             hgcalWriterVU9PTM18WriterConfig.hgcSectors[isec].hgcLinks += range(4*(14+ilink),4*(14+ilink)+4)
0361         if ilink < 3:
0362             hgcalWriterVU13PTM18WriterConfig.hgcSectors[isec].hgcLinks += range(4*(12+ilink),4*(12+ilink)+4)
0363         elif ilink < 5:
0364             hgcalWriterVU13PTM18WriterConfig.hgcSectors[isec].hgcLinks += range(4*(13+ilink),4*(13+ilink)+4)
0365         else:
0366             hgcalWriterVU13PTM18WriterConfig.hgcSectors[isec].hgcLinks += range(4*(14+ilink),4*(14+ilink)+4)
0367
0368 hgcalTM18WriterConfigs = [
0369     hgcalWriterOutputTM18WriterConfig,
0370     hgcalWriterVU9PTM18WriterConfig,
0371     hgcalWriterVU13PTM18WriterConfig
0372 ]
0373 hgcalNoTKOutputTM18WriterConfig = _hgcalWriterTM18.clone(
0374    outputFileName = cms.string("l1HGCalTM18-outputs-fwd"),
0375    outputRegions = cms.vuint32(*range(18)),
0376    outputBoard = cms.int32(-1),#0,1),
0377    outputLinksPuppi = cms.vuint32(*range(2)),
0378    outputLinkEgamma = cms.int32(-1),
0379 )
0380
0381 #####################################################################################################################
0382 ## HF configuration (to be better defined later)
0383 #####################################################################################################################
0384 ## HF configuration not realistic, 3 links per endcap, write out the layer 1 outputs for now
0385 _hfWriterOutputOnly = cms.PSet(
0386     partition = cms.string("HF"),
0387     tmuxFactor = cms.uint32(6),
0388     outputLinksPuppi = cms.vuint32(*range(3)),
0389     nOutputFramesPerBX = cms.uint32(9),
0390     fileFormat = cms.string("EMPv2"),
0391     outputFileExtension = cms.string("txt.gz"),
0392     maxLinesPerOutputFile = cms.uint32(1024),
0393     eventsPerFile = cms.uint32(_eventsPerFile),
0394 )
0395 hfWriterConfigs = [
0396     _hfWriterOutputOnly.clone(
0397         outputRegions = cms.vuint32(*[9*ie+i for i in range(9)]),
0398         outputFileName = cms.string("l1HF%s-outputs" % ("Pos" if ie else "Neg")),
0399     ) for ie in range(2)
0400 ]
0401
0402