ATLAS Offline Software
Loading...
Searching...
No Matches
Functions
CaloRecGPUConfig Namespace Reference

Functions

 SingleToolToPlot (tool_name, prefix)
 ComparedToolsToPlot (tool_ref, tool_test, prefix, match_in_energy=False, match_without_shared=False, match_perfectly=False)
 MatchingOptions (min_similarity=0.50, terminal_weight=250., grow_weight=500., seed_weight=1000.)
 BasicConstantDataExporterToolCfg (flags, name="ConstantDataExporter", **kwargs)
 BasicEventDataExporterToolCfg (flags, cellsname, name="EventDataExporter", **kwargs)
 BasicAthenaClusterImporterToolCfg (flags, cellsname, name="ClusterImporter", **kwargs)
 CPUOutputToolCfg (flags, cellsname, name="CPUOutput", **kwargs)
 GPUOutputToolCfg (flags, name="GPUOutput", **kwargs)
 ClusterInfoCalcToolCfg (flags, name="GPUClusterInfoCalculator", do_cut=True, **kwargs)
 ClusterSorterToolCfg (flags, name="GPUClusterSorter", do_cut=False, **kwargs)
 TopoAutomatonClusteringToolCfg (flags, name="TopoAutomatonClustering", **kwargs)
 DefaultTopologicalClusteringToolCfg (flags, cellsname, name="TopoClusterMaker", **kwargs)
 TopoAutomatonSplitterToolCfg (flags, name="ClusterSplitter", **kwargs)
 DefaultClusterSplittingToolCfg (flags, name="TopoSplitter", **kwargs)
 GPUClusterMomentsCalculatorToolCfg (flags, name="GPUTopoMoments", **kwargs)
 DefaultClusterMomentsCalculatorToolCfg (flags, instantiateForTrigger, name="TopoMoments", **kwargs)
 AthenaClusterAndMomentsImporterToolCfg (flags, cellsname, instantiateForTrigger, name="ClusterAndMomentsImporter", **kwargs)
 CellsCounterCPUToolCfg (flags, cellsname, name="CPUCounts", **kwargs)
 CellsCounterGPUToolCfg (flags, name="GPUCounts", **kwargs)
 PerformanceInformationOutputToolCfg (flags, cellsname, name="PerfInfoTool", **kwargs)
 MomentsDumperToolCfg (flags, name="MomentsDumper", **kwargs)
 PlotterToolCfg (flags, cellsname, name="PlotterMonitoring", **kwargs)
 DefaultCalibMomentsToolCfg (flags, name="TopoCalibMoments", **kwargs)
 DefaultTopoClusterLocalCalibToolsCfg (flags, instantiateForTrigger, prefix='')
 GPUCaloTopoClusterCfg (flags, instantiateForTrigger, cellsname, clustersname=None, clustersnapname="CaloTopoClusters", name="HybridClusterProcessor", PlotterTool=None, addAsPrimary=True, ReallyUseGPUTools=True)

Function Documentation

◆ AthenaClusterAndMomentsImporterToolCfg()

AthenaClusterAndMomentsImporterToolCfg ( flags,
cellsname,
instantiateForTrigger,
name = "ClusterAndMomentsImporter",
** kwargs )

Definition at line 317 of file CaloRecGPUConfig.py.

317def AthenaClusterAndMomentsImporterToolCfg(flags, cellsname, instantiateForTrigger, name = "ClusterAndMomentsImporter", **kwargs):
318 result=ComponentAccumulator()
319 kwargs.setdefault("CellsName", cellsname)
320
321 kwargs.setdefault("ClusterSize", flags.CaloRecGPU.ActiveConfig.ClusterSize)
322
323 kwargs.setdefault("MeasureTimes", flags.CaloRecGPU.ActiveConfig.MeasureTimes)
324 kwargs.setdefault("TimeFileOutput", name + "Times.txt")
325
326 kwargs.setdefault("StreamTool", result.popToolsAndMerge(StreamToolCfg(flags)))
327
328 if not flags.Common.isOnline and not instantiateForTrigger:
329 kwargs.setdefault("FillHVMoments", True)
330 if flags.Input.isMC:
331 kwargs.setdefault("HVScaleCorrKey", "LArHVScaleCorr")
332 else:
333 kwargs.setdefault("HVScaleCorrKey", "LArHVScaleCorrRecomputed")
334 else:
335 kwargs.setdefault("FillHVMoments", False)
336
337 kwargs.setdefault("MomentsNames", flags.CaloRecGPU.ActiveConfig.MomentsToCalculate)
338
339 if flags.CaloRecGPU.ActiveConfig.FillMissingCells:
340 kwargs.setdefault("MissingCellsToFill", flags.CaloRecGPU.ActiveConfig.MissingCellsToFill)
341
342 AthenaClusterImporter = CompFactory.GPUToAthenaImporterWithMoments(name, **kwargs)
343 result.setPrivateTools(AthenaClusterImporter)
344 return result
345

◆ BasicAthenaClusterImporterToolCfg()

BasicAthenaClusterImporterToolCfg ( flags,
cellsname,
name = "ClusterImporter",
** kwargs )

Definition at line 46 of file CaloRecGPUConfig.py.

46def BasicAthenaClusterImporterToolCfg(flags, cellsname, name = "ClusterImporter", **kwargs):
47 result=ComponentAccumulator()
48 kwargs.setdefault("MeasureTimes", flags.CaloRecGPU.ActiveConfig.MeasureTimes)
49 kwargs.setdefault("TimeFileOutput", name + "Times.txt")
50 kwargs.setdefault("CellsName", cellsname)
51 kwargs.setdefault("ClusterSize", flags.CaloRecGPU.ActiveConfig.ClusterSize)
52 kwargs.setdefault("StreamTool", result.popToolsAndMerge(StreamToolCfg(flags)))
53 if flags.CaloRecGPU.ActiveConfig.FillMissingCells:
54 kwargs.setdefault("MissingCellsToFill", flags.CaloRecGPU.ActiveConfig.MissingCellsToFill)
55
56 AthenaClusterImporter = CompFactory.BasicGPUToAthenaImporter(name, **kwargs)
57 result.setPrivateTools(AthenaClusterImporter)
58 return result
59

◆ BasicConstantDataExporterToolCfg()

BasicConstantDataExporterToolCfg ( flags,
name = "ConstantDataExporter",
** kwargs )

Definition at line 17 of file CaloRecGPUConfig.py.

17def BasicConstantDataExporterToolCfg(flags, name = "ConstantDataExporter", **kwargs):
18 result=ComponentAccumulator()
19
20 kwargs.setdefault("MeasureTimes", flags.CaloRecGPU.ActiveConfig.MeasureTimes)
21 kwargs.setdefault("TimeFileOutput", name + "Times.txt")
22
23 ConstantDataExporter = CompFactory.BasicConstantGPUDataExporter(name, **kwargs)
24
25 result.setPrivateTools(ConstantDataExporter)
26 return result
27

◆ BasicEventDataExporterToolCfg()

BasicEventDataExporterToolCfg ( flags,
cellsname,
name = "EventDataExporter",
** kwargs )

Definition at line 28 of file CaloRecGPUConfig.py.

28def BasicEventDataExporterToolCfg(flags, cellsname, name = "EventDataExporter", **kwargs):
29 result=ComponentAccumulator()
30
31 kwargs.setdefault("MeasureTimes", flags.CaloRecGPU.ActiveConfig.MeasureTimes)
32 kwargs.setdefault("TimeFileOutput", name + "Times.txt")
33
34 kwargs.setdefault("CellsName", cellsname)
35
36 kwargs.setdefault("StreamTool", result.popToolsAndMerge(StreamToolCfg(flags)))
37
38 if flags.CaloRecGPU.ActiveConfig.FillMissingCells:
39 kwargs.setdefault("MissingCellsToFill", flags.CaloRecGPU.ActiveConfig.MissingCellsToFill)
40
41 EventDataExporter = CompFactory.BasicEventDataGPUExporter(name, **kwargs)
42
43 result.setPrivateTools(EventDataExporter)
44 return result
45

◆ CellsCounterCPUToolCfg()

CellsCounterCPUToolCfg ( flags,
cellsname,
name = "CPUCounts",
** kwargs )

Definition at line 346 of file CaloRecGPUConfig.py.

346def CellsCounterCPUToolCfg(flags, cellsname, name = "CPUCounts", **kwargs):
347 result=ComponentAccumulator()
348 kwargs.setdefault("SavePath", "counts")
349 kwargs.setdefault("FilePrefix", "CPU")
350 kwargs.setdefault("CellsName", cellsname)
351
352 kwargs.setdefault("SeedThresholdOnEorAbsEinSigma", flags.CaloRecGPU.ActiveConfig.SeedThreshold)
353 kwargs.setdefault("NeighborThresholdOnEorAbsEinSigma", flags.CaloRecGPU.ActiveConfig.GrowThreshold)
354 kwargs.setdefault("CellThresholdOnEorAbsEinSigma", flags.CaloRecGPU.ActiveConfig.TermThreshold)
355
356 CPUCount = CompFactory.CaloCellsCounterCPU(name, **kwargs)
357 result.setPrivateTools(CPUCount)
358 return result
359

◆ CellsCounterGPUToolCfg()

CellsCounterGPUToolCfg ( flags,
name = "GPUCounts",
** kwargs )

Definition at line 360 of file CaloRecGPUConfig.py.

360def CellsCounterGPUToolCfg(flags, name = "GPUCounts", **kwargs):
361 result=ComponentAccumulator()
362 kwargs.setdefault("SavePath", "counts")
363 kwargs.setdefault("FilePrefix", "GPU")
364
365 kwargs.setdefault("SeedThresholdOnEorAbsEinSigma", flags.CaloRecGPU.ActiveConfig.SeedThreshold)
366 kwargs.setdefault("NeighborThresholdOnEorAbsEinSigma", flags.CaloRecGPU.ActiveConfig.GrowThreshold)
367 kwargs.setdefault("CellThresholdOnEorAbsEinSigma", flags.CaloRecGPU.ActiveConfig.TermThreshold)
368
369 GPUCount = CompFactory.CaloCellsCounterGPU(name, **kwargs)
370 result.setPrivateTools(GPUCount)
371 return result
372

◆ ClusterInfoCalcToolCfg()

ClusterInfoCalcToolCfg ( flags,
name = "GPUClusterInfoCalculator",
do_cut = True,
** kwargs )

Definition at line 78 of file CaloRecGPUConfig.py.

78def ClusterInfoCalcToolCfg(flags, name = "GPUClusterInfoCalculator", do_cut = True, **kwargs):
79 result=ComponentAccumulator()
80 kwargs.setdefault("MeasureTimes", flags.CaloRecGPU.ActiveConfig.MeasureTimes)
81 kwargs.setdefault("TimeFileOutput", name + "Times.txt")
82 kwargs.setdefault("StreamTool", result.popToolsAndMerge(StreamToolCfg(flags)))
83 if do_cut:
84 kwargs.setdefault("ClusterCutsInAbsEt", flags.CaloRecGPU.ActiveConfig.PostGrowingClusterCutClustersInAbsEt)
85 kwargs.setdefault("ClusterEtorAbsEtCut", flags.CaloRecGPU.ActiveConfig.PostGrowingClusterEnergyCut)
86 else:
87 kwargs.setdefault("ClusterCutsInAbsEt", True)
88 kwargs.setdefault("ClusterEtorAbsEtCut", -1)
89 #Cutting on absolute value with a negative value => not cutting at all.
90
91 CalcTool = CompFactory.BasicGPUClusterInfoCalculator(name, **kwargs)
92 result.setPrivateTools(CalcTool)
93 return result
94

◆ ClusterSorterToolCfg()

ClusterSorterToolCfg ( flags,
name = "GPUClusterSorter",
do_cut = False,
** kwargs )

Definition at line 95 of file CaloRecGPUConfig.py.

95def ClusterSorterToolCfg(flags, name = "GPUClusterSorter", do_cut = False, **kwargs):
96 result=ComponentAccumulator()
97 kwargs.setdefault("MeasureTimes", flags.CaloRecGPU.ActiveConfig.MeasureTimes)
98 kwargs.setdefault("TimeFileOutput", name + "Times.txt")
99 kwargs.setdefault("StreamTool", result.popToolsAndMerge(StreamToolCfg(flags)))
100 if do_cut:
101 kwargs.setdefault("ClusterCutsInAbsEt", flags.CaloRecGPU.ActiveConfig.PostGrowingClusterCutClustersInAbsEt)
102 kwargs.setdefault("ClusterEtorAbsEtCut", flags.CaloRecGPU.ActiveConfig.PostGrowingClusterEnergyCut)
103 else:
104 kwargs.setdefault("ClusterCutsInAbsEt", True)
105 kwargs.setdefault("ClusterEtorAbsEtCut", -1)
106 #Cutting on absolute value with a negative value => not cutting at all.
107
108 SorTool = CompFactory.GPUClusterSorter(name, **kwargs)
109 result.setPrivateTools(SorTool)
110 return result
111

◆ ComparedToolsToPlot()

ComparedToolsToPlot ( tool_ref,
tool_test,
prefix,
match_in_energy = False,
match_without_shared = False,
match_perfectly = False )

Definition at line 11 of file CaloRecGPUConfig.py.

11def ComparedToolsToPlot(tool_ref, tool_test, prefix, match_in_energy = False, match_without_shared = False, match_perfectly = False):
12 return (tool_ref, tool_test, prefix, match_in_energy, match_without_shared, match_perfectly)
13

◆ CPUOutputToolCfg()

CPUOutputToolCfg ( flags,
cellsname,
name = "CPUOutput",
** kwargs )

Definition at line 60 of file CaloRecGPUConfig.py.

60def CPUOutputToolCfg(flags, cellsname, name = "CPUOutput", **kwargs):
61 result=ComponentAccumulator()
62 kwargs.setdefault("CellsName", cellsname)
63 kwargs.setdefault("SavePath", "output")
64
65 CPUOutput = CompFactory.CaloCPUOutput(name, **kwargs)
66 result.setPrivateTools(CPUOutput)
67 return result
68

◆ DefaultCalibMomentsToolCfg()

DefaultCalibMomentsToolCfg ( flags,
name = "TopoCalibMoments",
** kwargs )

Definition at line 433 of file CaloRecGPUConfig.py.

433def DefaultCalibMomentsToolCfg(flags, name = "TopoCalibMoments", **kwargs):
434 result=ComponentAccumulator()
435
436 kwargs.setdefault("MomentsNames", ["ENG_CALIB_TOT"
437 ,"ENG_CALIB_OUT_L"
438 ,"ENG_CALIB_OUT_T"
439 ,"ENG_CALIB_EMB0"
440 ,"ENG_CALIB_EME0"
441 ,"ENG_CALIB_TILEG3"
442 ,"ENG_CALIB_DEAD_TOT"
443 ,"ENG_CALIB_DEAD_EMB0"
444 ,"ENG_CALIB_DEAD_TILE0"
445 ,"ENG_CALIB_DEAD_TILEG3"
446 ,"ENG_CALIB_DEAD_EME0"
447 ,"ENG_CALIB_DEAD_HEC0"
448 ,"ENG_CALIB_DEAD_FCAL"
449 ,"ENG_CALIB_DEAD_LEAKAGE"
450 ,"ENG_CALIB_DEAD_UNCLASS"
451 ,"ENG_CALIB_FRAC_EM"
452 ,"ENG_CALIB_FRAC_HAD"
453 ,"ENG_CALIB_FRAC_REST"])
454
455 kwargs.setdefault("CalibrationHitContainerNames", ["LArCalibrationHitInactive"
456 ,"LArCalibrationHitActive"
457 ,"TileCalibHitActiveCell"
458 ,"TileCalibHitInactiveCell"])
459
460 kwargs.setdefault("DMCalibrationHitContainerNames", ["LArCalibrationHitDeadMaterial"
461 ,"TileCalibHitDeadMaterial"])
462
463 TopoCalibMoments = CompFactory.CaloCalibClusterMomentsMaker2(name, **kwargs)
464 result.setPrivateTools(TopoCalibMoments)
465 return result
466

◆ DefaultClusterMomentsCalculatorToolCfg()

DefaultClusterMomentsCalculatorToolCfg ( flags,
instantiateForTrigger,
name = "TopoMoments",
** kwargs )

Definition at line 284 of file CaloRecGPUConfig.py.

284def DefaultClusterMomentsCalculatorToolCfg(flags, instantiateForTrigger, name = "TopoMoments", **kwargs):
285 result=ComponentAccumulator()
286
287 kwargs.setdefault("WeightingOfNegClusters", flags.CaloRecGPU.ActiveConfig.MomentsUseAbsEnergy)
288
289 kwargs.setdefault("MaxAxisAngle", flags.CaloRecGPU.ActiveConfig.MomentsMaxAxisAngle)
290
291 kwargs.setdefault("TwoGaussianNoise", flags.CaloRecGPU.ActiveConfig.doTwoGaussianNoise)
292
293 kwargs.setdefault("MinBadLArQuality", flags.CaloRecGPU.ActiveConfig.MomentsMinBadLArQuality)
294
295 kwargs.setdefault("MomentsNames", flags.CaloRecGPU.ActiveConfig.MomentsToCalculate)
296
297 kwargs.setdefault("MinRLateral", flags.CaloRecGPU.ActiveConfig.MomentsMinRLateral)
298 kwargs.setdefault("MinLLongitudinal", flags.CaloRecGPU.ActiveConfig.MomentsMinLLongitudinal)
299
300 kwargs.setdefault("UseGPUCriteria", not flags.CaloRecGPU.ActiveConfig.UseOriginalCriteria)
301
302 TopoMoments = CompFactory.CaloClusterMomentsMaker(name, **kwargs)
303
304 if not flags.Common.isOnline and not instantiateForTrigger and "LArHVFraction" not in kwargs:
305 #If it's already in kwargs, don't override
306 #(extra flexibility for the user, not that it's needed...)
307 from LArConfiguration.LArElecCalibDBConfig import LArElecCalibDBCfg
308 result.merge(LArElecCalibDBCfg(flags,["HVScaleCorr"]))
309 if flags.Input.isMC:
310 TopoMoments.LArHVFraction=CompFactory.LArHVFraction(HVScaleCorrKey="LArHVScaleCorr")
311 else:
312 TopoMoments.LArHVFraction=CompFactory.LArHVFraction(HVScaleCorrKey="LArHVScaleCorrRecomputed")
313
314 result.setPrivateTools(TopoMoments)
315 return result
316

◆ DefaultClusterSplittingToolCfg()

DefaultClusterSplittingToolCfg ( flags,
name = "TopoSplitter",
** kwargs )

Definition at line 236 of file CaloRecGPUConfig.py.

236def DefaultClusterSplittingToolCfg(flags, name = "TopoSplitter", **kwargs):
237 result=ComponentAccumulator()
238
239 kwargs.setdefault("NeighborOption", flags.CaloRecGPU.ActiveConfig.SplittingNeighborOption)
240 kwargs.setdefault("RestrictHECIWandFCalNeighbors", flags.CaloRecGPU.ActiveConfig.SplittingRestrictHECIWandFCalNeighbors)
241
242 kwargs.setdefault("NumberOfCellsCut", flags.CaloRecGPU.ActiveConfig.SplittingNumberOfCellsCut)
243 kwargs.setdefault("EnergyCut", flags.CaloRecGPU.ActiveConfig.SplittingEnergyCut)
244
245 kwargs.setdefault("SamplingNames", flags.CaloRecGPU.ActiveConfig.SplittingSamplingNames)
246 kwargs.setdefault("SecondarySamplingNames", flags.CaloRecGPU.ActiveConfig.SplittingSecondarySamplingNames)
247
248 kwargs.setdefault("ShareBorderCells", flags.CaloRecGPU.ActiveConfig.SplittingShareBorderCells)
249 kwargs.setdefault("EMShowerScale", flags.CaloRecGPU.ActiveConfig.SplittingEMShowerScale)
250
251 kwargs.setdefault("TreatL1PredictedCellsAsGood", flags.CaloRecGPU.ActiveConfig.SplittingTreatL1PredictedCellsAsGood)
252
253 kwargs.setdefault("WeightingOfNegClusters", flags.CaloRecGPU.ActiveConfig.SplittingUseNegativeClusters)
254
255 kwargs.setdefault("UseGPUCriteria", not flags.CaloRecGPU.ActiveConfig.UseOriginalCriteria)
256
257 TopoSplitter = CompFactory.CaloTopoClusterSplitter(name, **kwargs)
258 result.setPrivateTools(TopoSplitter)
259 return result
260

◆ DefaultTopoClusterLocalCalibToolsCfg()

DefaultTopoClusterLocalCalibToolsCfg ( flags,
instantiateForTrigger,
prefix = '' )

Definition at line 467 of file CaloRecGPUConfig.py.

467def DefaultTopoClusterLocalCalibToolsCfg(flags, instantiateForTrigger, prefix = ''):
468 result=ComponentAccumulator()
469
470 CaloClusterLocalCalib=CompFactory.CaloClusterLocalCalib
471
472 # Local cell weights
473 LCClassify = CompFactory.CaloLCClassificationTool(prefix + "LCClassify")
474 LCClassify.ClassificationKey = "EMFracClassify"
475 LCClassify.UseSpread = False
476 LCClassify.MaxProbability = 0.85 if flags.GeoModel.AtlasVersion.startswith("Rome") and instantiateForTrigger else 0.5
477 LCClassify.StoreClassificationProbabilityInAOD = True
478 if instantiateForTrigger:
479 LCClassify.UseNormalizedEnergyDensity = not flags.GeoModel.AtlasVersion.startswith("Rome")
480 if not instantiateForTrigger:
481 LCClassify.WeightingOfNegClusters = flags.CaloRecGPU.ActiveConfig.CalibrationUseAbsEnergy
482
483 LCWeight = CompFactory.CaloLCWeightTool(prefix + "LCWeight")
484 LCWeight.CorrectionKey = "H1ClusterCellWeights"
485 LCWeight.SignalOverNoiseCut = 2.0
486 LCWeight.UseHadProbability = True
487
488 LocalCalib = CaloClusterLocalCalib (prefix + "LocalCalib")
489 LocalCalib.ClusterClassificationTool = [LCClassify]
490 LocalCalib.ClusterRecoStatus = [1,2]
491 LocalCalib.LocalCalibTools = [LCWeight]
492 if not instantiateForTrigger:
493 LocalCalib.WeightingOfNegClusters = flags.CaloRecGPU.ActiveConfig.CalibrationUseAbsEnergy
494
495 # Out-of-cluster corrections
496 LCOut = CompFactory.CaloLCOutOfClusterTool(prefix + "LCOut")
497 LCOut.CorrectionKey = "OOCCorrection"
498 LCOut.UseEmProbability = False
499 LCOut.UseHadProbability = True
500
501 OOCCalib = CaloClusterLocalCalib (prefix + "OOCCalib")
502 OOCCalib.ClusterRecoStatus = [1,2]
503 OOCCalib.LocalCalibTools = [LCOut]
504 if not instantiateForTrigger:
505 OOCCalib.WeightingOfNegClusters = flags.CaloRecGPU.ActiveConfig.CalibrationUseAbsEnergy
506
507 LCOutPi0 = CompFactory.CaloLCOutOfClusterTool(prefix + "LCOutPi0")
508 LCOutPi0.CorrectionKey = "OOCPi0Correction"
509 LCOutPi0.UseEmProbability = True
510 LCOutPi0.UseHadProbability = False
511
512 OOCPi0Calib = CaloClusterLocalCalib (prefix + "OOCPi0Calib")
513 OOCPi0Calib.ClusterRecoStatus = [1,2]
514 OOCPi0Calib.LocalCalibTools = [LCOutPi0]
515 if not instantiateForTrigger:
516 OOCPi0Calib.WeightingOfNegClusters = flags.CaloRecGPU.ActiveConfig.CalibrationUseAbsEnergy
517
518 # Dead material corrections
519 LCDeadMaterial = CompFactory.CaloLCDeadMaterialTool(prefix + "LCDeadMaterial")
520 LCDeadMaterial.HadDMCoeffKey = "HadDMCoeff2"
521 LCDeadMaterial.ClusterRecoStatus = 0
522 LCDeadMaterial.WeightModeDM = 2
523 LCDeadMaterial.UseHadProbability = True
524 if not instantiateForTrigger:
525 LCDeadMaterial.WeightingOfNegClusters = flags.CaloRecGPU.ActiveConfig.CalibrationUseAbsEnergy
526
527 DMCalib = CaloClusterLocalCalib (prefix + "DMCalib")
528 DMCalib.ClusterRecoStatus = [1,2]
529 DMCalib.LocalCalibTools = [LCDeadMaterial]
530 if not instantiateForTrigger:
531 DMCalib.WeightingOfNegClusters = flags.CaloRecGPU.ActiveConfig.CalibrationUseAbsEnergy
532
533 lccalibtools = [
534 LocalCalib,
535 OOCCalib,
536 OOCPi0Calib,
537 DMCalib]
538
539 result.setPrivateTools(lccalibtools)
540
541 return result
542
543#Depending on ReallyUseGPUTools,
544#instantiates GPU or CPU tools with consistent options...

◆ DefaultTopologicalClusteringToolCfg()

DefaultTopologicalClusteringToolCfg ( flags,
cellsname,
name = "TopoClusterMaker",
** kwargs )

Definition at line 158 of file CaloRecGPUConfig.py.

158def DefaultTopologicalClusteringToolCfg(flags, cellsname, name = "TopoClusterMaker", **kwargs):
159 result=ComponentAccumulator()
160
161 kwargs.setdefault("CellsName", cellsname)
162
163 kwargs.setdefault("CalorimeterNames", flags.CaloRecGPU.ActiveConfig.GrowingCalorimeterNames)
164 kwargs.setdefault("SeedSamplingNames", flags.CaloRecGPU.ActiveConfig.GrowingSeedSamplingNames)
165
166 kwargs.setdefault("NeighborOption", flags.CaloRecGPU.ActiveConfig.GrowingNeighborOption)
167 kwargs.setdefault("RestrictHECIWandFCalNeighbors", flags.CaloRecGPU.ActiveConfig.GrowingRestrictHECIWandFCalNeighbors)
168 kwargs.setdefault("RestrictPSNeighbors", flags.CaloRecGPU.ActiveConfig.GrowingRestrictPSNeighbors)
169
170 kwargs.setdefault("SeedThresholdOnEorAbsEinSigma", flags.CaloRecGPU.ActiveConfig.SeedThreshold)
171 kwargs.setdefault("NeighborThresholdOnEorAbsEinSigma", flags.CaloRecGPU.ActiveConfig.GrowThreshold)
172 kwargs.setdefault("CellThresholdOnEorAbsEinSigma", flags.CaloRecGPU.ActiveConfig.TermThreshold)
173
174 kwargs.setdefault("SeedCutsInAbsE", flags.CaloRecGPU.ActiveConfig.UseAbsSeedThreshold)
175 kwargs.setdefault("NeighborCutsInAbsE", flags.CaloRecGPU.ActiveConfig.UseAbsGrowThreshold)
176 kwargs.setdefault("CellCutsInAbsE", flags.CaloRecGPU.ActiveConfig.UseAbsTermThreshold)
177
178 kwargs.setdefault("SeedCutsInT", flags.CaloRecGPU.ActiveConfig.doTimeCut)
179 kwargs.setdefault("CutOOTseed", flags.CaloRecGPU.ActiveConfig.doTimeCut and flags.CaloRecGPU.ActiveConfig.extendTimeCut)
180 kwargs.setdefault("UseTimeCutUpperLimit", flags.CaloRecGPU.ActiveConfig.useUpperLimitForTimeCut)
181 kwargs.setdefault("TimeCutUpperLimit", flags.CaloRecGPU.ActiveConfig.timeCutUpperLimit)
182 kwargs.setdefault("XTalkEM2", flags.CaloRecGPU.ActiveConfig.xtalkEM2)
183 kwargs.setdefault("XTalkEM2D", flags.CaloRecGPU.ActiveConfig.xtalkEM2D)
184 kwargs.setdefault("XTalkEM2n", flags.CaloRecGPU.ActiveConfig.xtalkEM2n)
185 kwargs.setdefault("XTalkEM3", flags.CaloRecGPU.ActiveConfig.xtalkEM3)
186 kwargs.setdefault("XTalkEMEta", flags.CaloRecGPU.ActiveConfig.xtalkEMEta)
187 kwargs.setdefault("XTalkDeltaT", flags.CaloRecGPU.ActiveConfig.xtalkDeltaT)
188 kwargs.setdefault("XTalk2Eratio1", flags.CaloRecGPU.ActiveConfig.xtalk2Eratio1)
189 kwargs.setdefault("XTalk2Eratio2", flags.CaloRecGPU.ActiveConfig.xtalk2Eratio2)
190 kwargs.setdefault("XTalk3Eratio", flags.CaloRecGPU.ActiveConfig.xtalk3Eratio)
191 kwargs.setdefault("XTalkEtaEratio", flags.CaloRecGPU.ActiveConfig.xtalkEtaEratio)
192 kwargs.setdefault("XTalk2DEratio", flags.CaloRecGPU.ActiveConfig.xtalk2DEratio)
193
194 kwargs.setdefault("ClusterCutsInAbsEt", flags.CaloRecGPU.ActiveConfig.PostGrowingClusterCutClustersInAbsEt)
195 kwargs.setdefault("ClusterEtorAbsEtCut", flags.CaloRecGPU.ActiveConfig.PostGrowingClusterEnergyCut)
196
197 kwargs.setdefault("TwoGaussianNoise", flags.CaloRecGPU.ActiveConfig.doTwoGaussianNoise)
198
199 kwargs.setdefault("SeedThresholdOnTAbs", flags.CaloRecGPU.ActiveConfig.GrowingTimeCutSeedThreshold)
200
201 kwargs.setdefault("TreatL1PredictedCellsAsGood", flags.CaloRecGPU.ActiveConfig.GrowingTreatL1PredictedCellsAsGood)
202
203 kwargs.setdefault("UseGPUCriteria", not flags.CaloRecGPU.ActiveConfig.UseOriginalCriteria)
204
205 TopoMaker = CompFactory.CaloTopoClusterMaker(name, **kwargs)
206 result.setPrivateTools(TopoMaker)
207 return result
208

◆ GPUCaloTopoClusterCfg()

GPUCaloTopoClusterCfg ( flags,
instantiateForTrigger,
cellsname,
clustersname = None,
clustersnapname = "CaloTopoClusters",
name = "HybridClusterProcessor",
PlotterTool = None,
addAsPrimary = True,
ReallyUseGPUTools = True )

Definition at line 545 of file CaloRecGPUConfig.py.

547 PlotterTool = None, addAsPrimary = True, ReallyUseGPUTools = True):
548
549 doLCCalib = flags.CaloRecGPU.ActiveConfig.doTopoClusterLocalCalib
550
551 if clustersname is None:
552 clustersname = "CaloCalTopoClusters" if doLCCalib else "CaloTopoClusters"
553
554 if clustersname == "CaloTopoClusters" and doLCCalib:
555 raise RuntimeError("Inconsistent arguments: clustersname must not be 'CaloTopoClusters' if doTopoClusterLocalCalib is True")
556
557 clustersname_final = clustersname
558 if flags.CaloRecGPU.ActiveConfig.applyClusterTimingCut:
559 clustersname = f"{clustersname}BeforeTimingCut"
560
561 result = ComponentAccumulator()
562
563 if not instantiateForTrigger:
564
565 from LArGeoAlgsNV.LArGMConfig import LArGMCfg
566 from TileGeoModel.TileGMConfig import TileGMCfg
567 from CaloTools.CaloNoiseCondAlgConfig import CaloNoiseCondAlgCfg
568
569 result.merge(CaloNoiseCondAlgCfg(flags,"totalNoise"))
570 result.merge(CaloNoiseCondAlgCfg(flags,"electronicNoise"))
571
572 result.merge(LArGMCfg(flags))
573 result.merge(TileGMCfg(flags))
574
575
576 HybridClusterProcessor = CompFactory.CaloGPUHybridClusterProcessor(name)
577 HybridClusterProcessor.ClustersOutputName = clustersname
578
579 HybridClusterProcessor.WriteTriggerSpecificInfo = instantiateForTrigger
580
581 HybridClusterProcessor.MeasureTimes = flags.CaloRecGPU.ActiveConfig.MeasureTimes
582
583 HybridClusterProcessor.TimeFileOutput = "GlobalTimes.txt"
584
585 HybridClusterProcessor.DeferConstantDataPreparationToFirstEvent = True
586 HybridClusterProcessor.DoPlots = PlotterTool is not None
587 HybridClusterProcessor.PlotterTool = PlotterTool
588
589 HybridClusterProcessor.NumPreAllocatedDataHolders = flags.CaloRecGPU.ActiveConfig.NumPreAllocatedDataHolders
590
591 if ReallyUseGPUTools:
592
593 HybridClusterProcessor.ConstantDataToGPUTool = result.popToolsAndMerge( BasicConstantDataExporterToolCfg(flags) )
594 HybridClusterProcessor.EventDataToGPUTool = result.popToolsAndMerge( BasicEventDataExporterToolCfg(flags, cellsname) )
595 HybridClusterProcessor.GPUToEventDataTool = result.popToolsAndMerge( AthenaClusterAndMomentsImporterToolCfg(flags, cellsname, instantiateForTrigger) )
596
597
598 HybridClusterProcessor.BeforeGPUTools = []
599
600 HybridClusterProcessor.GPUTools = []
601
602 HybridClusterProcessor.GPUTools += [result.popToolsAndMerge( TopoAutomatonClusteringToolCfg(flags,"GPUGrowing"))]
603
604 HybridClusterProcessor.GPUTools += [result.popToolsAndMerge( ClusterInfoCalcToolCfg(flags,"PostGPUGrowingClusterPropertiesCalculator", True))]
605
606 HybridClusterProcessor.GPUTools += [result.popToolsAndMerge( TopoAutomatonSplitterToolCfg(flags,"GPUSplitting") )]
607
608 HybridClusterProcessor.GPUTools += [result.popToolsAndMerge( ClusterSorterToolCfg(flags, "GPUClusterSorting", False) )]
609
610 HybridClusterProcessor.GPUTools += [result.popToolsAndMerge( GPUClusterMomentsCalculatorToolCfg(flags,"GPUTopoMoments") )]
611
612 else:
613
614 HybridClusterProcessor.ConstantDataToGPUTool = None
615 HybridClusterProcessor.EventDataToGPUTool = None
616 HybridClusterProcessor.GPUToEventDataTool = None
617 HybridClusterProcessor.SkipConversions = True
618
619 HybridClusterProcessor.GPUTools = []
620
621 HybridClusterProcessor.BeforeGPUTools = []
622
623 HybridClusterProcessor.BeforeGPUTools += [result.popToolsAndMerge( DefaultTopologicalClusteringToolCfg(flags, cellsname,"CPUGrowing"))]
624
625 HybridClusterProcessor.BeforeGPUTools += [result.popToolsAndMerge( DefaultClusterSplittingToolCfg(flags,"CPUSplitting") )]
626
627 HybridClusterProcessor.BeforeGPUTools += [result.popToolsAndMerge( DefaultClusterMomentsCalculatorToolCfg(flags, instantiateForTrigger, "CPUTopoMoments") )]
628
629 HybridClusterProcessor.BeforeGPUTools += [ CompFactory.CaloClusterStoreRawProperties("RawPropertiesStorer") ]
630
631
632
633 HybridClusterProcessor.AfterGPUTools = []
634
635 if not instantiateForTrigger:
636 from CaloBadChannelTool.CaloBadChanToolConfig import CaloBadChanToolCfg
637 caloBadChanTool = result.popToolsAndMerge( CaloBadChanToolCfg(flags) )
638 HybridClusterProcessor.AfterGPUTools += [CompFactory.CaloClusterBadChannelList(badChannelTool = caloBadChanTool)]
639
640 if not instantiateForTrigger and flags.CaloRecGPU.ActiveConfig.doCalibHitMoments:
641
642 calibHitsMomentsMaker = result.popToolsAndMerge(DefaultCalibMomentsToolCfg(flags))
643 HybridClusterProcessor.AfterGPUTools += [calibHitsMomentsMaker]
644
645 if doLCCalib:
646 if not instantiateForTrigger:
647 HybridClusterProcessor.AfterGPUTools += [CompFactory.CaloClusterSnapshot(OutputName=clustersnapname,
648 SetCrossLinks=True,
649 FinalClusterContainerName=clustersname)]
650 else:
651 from CaloTools.CaloNoiseCondAlgConfig import CaloNoiseCondAlgCfg
652 from CaloRec.CaloTopoClusterConfig import caloTopoCoolFolderCfg
653 result.merge(CaloNoiseCondAlgCfg(flags, noisetype="electronicNoise"))
654 result.merge(caloTopoCoolFolderCfg(flags))
655
656 calibTools = result.popToolsAndMerge(DefaultTopoClusterLocalCalibToolsCfg(flags, instantiateForTrigger, 'Trig' if instantiateForTrigger else ''))
657
658 HybridClusterProcessor.AfterGPUTools += calibTools
659 #This is already a tool array.
660
661 if not instantiateForTrigger:
662 from CaloRec.CaloTopoClusterConfig import caloTopoCoolFolderCfg
663 result.merge(caloTopoCoolFolderCfg(flags))
664
665 if instantiateForTrigger:
666 from CaloTools.CaloNoiseCondAlgConfig import CaloNoiseCondAlgCfg
667 result.merge(CaloNoiseCondAlgCfg(flags))
668
669 result.addEventAlgo(HybridClusterProcessor, primary=addAsPrimary)
670
671 if flags.CaloRecGPU.ActiveConfig.applyClusterTimingCut:
672 from CaloRec.CaloTopoClusterConfig import CaloClusterTimingFilterCfg
673 result.merge(CaloClusterTimingFilterCfg(flags, name = f"{clustersname}Filter", InputClusters = clustersname, OutputClusters = clustersname_final))
674
675 if instantiateForTrigger or clustersname_final in flags.CaloRecGPU.ActiveConfig.skipWriteList:
676 # don't add these clusters to ESD and AOD
677 return result
678
679 #Output config:
680 AODMoments=[ "SECOND_R"
681 ,"SECOND_LAMBDA"
682 ,"CENTER_MAG"
683 ,"CENTER_LAMBDA"
684 ,"FIRST_ENG_DENS"
685 ,"ENG_FRAC_MAX"
686 ,"ISOLATION"
687 ,"ENG_BAD_CELLS"
688 ,"N_BAD_CELLS"
689 ,"BADLARQ_FRAC"
690 ,"ENG_POS"
691 ,"SIGNIFICANCE"
692 ,"AVG_LAR_Q"
693 ,"AVG_TILE_Q"
694 ,"EM_PROBABILITY"
695 ,"BadChannelList"
696 ,"SECOND_TIME"
697 ,"NCELL_SAMPLING"]
698
699 if flags.CaloRecGPU.ActiveConfig.writeExtendedClusterMoments:
700 AODMoments += ["LATERAL"
701 ,"LONGITUDINAL"
702 ,"CELL_SIGNIFICANCE"
703 ,"PTD"
704 ,"MASS"]
705
706 if flags.Reco.EnableHI:
707 AODMoments += ["CELL_SIG_SAMPLING"]
708
709 if flags.CaloRecGPU.ActiveConfig.writeCalibHitClusterMoments:
710 AODMoments += ["ENG_CALIB_TOT"
711 ,"ENG_CALIB_OUT_L"
712 ,"ENG_CALIB_OUT_T"
713 ,"ENG_CALIB_EMB0"
714 ,"ENG_CALIB_EME0"
715 ,"ENG_CALIB_TILEG3"
716 ,"ENG_CALIB_DEAD_TOT"
717 ,"ENG_CALIB_DEAD_EMB0"
718 ,"ENG_CALIB_DEAD_TILE0"
719 ,"ENG_CALIB_DEAD_TILEG3"
720 ,"ENG_CALIB_DEAD_EME0"
721 ,"ENG_CALIB_DEAD_HEC0"
722 ,"ENG_CALIB_DEAD_FCAL"
723 ,"ENG_CALIB_DEAD_LEAKAGE"
724 ,"ENG_CALIB_DEAD_UNCLASS"
725 ,"ENG_CALIB_FRAC_EM"
726 ,"ENG_CALIB_FRAC_HAD"
727 ,"ENG_CALIB_FRAC_REST"]
728
729
730 from OutputStreamAthenaPool.OutputStreamConfig import addToAOD, addToESD
731 toESD = [f"xAOD::CaloClusterContainer#{clustersname_final}",
732 f"xAOD::CaloClusterAuxContainer#{clustersname_final}Aux.",
733 f"CaloClusterCellLinkContainer#{clustersname_final}_links"]
734 toAOD = [f"xAOD::CaloClusterContainer#{clustersname_final}",
735 f"CaloClusterCellLinkContainer#{clustersname_final}_links"]
736
737 AODMoments.append("CellLink") #Add data-link to cell-link container
738 if flags.CaloRecGPU.ActiveConfig.addCalibrationHitDecoration: #Add calib hit deco if requried
739 AODMoments.append(flags.CaloRecGPU.ActiveConfig.CalibrationHitDecorationName)
740
741 if flags.CaloRecGPU.ActiveConfig.addCPData:
742 AODMoments += ["ClusterWidthEta","ClusterWidthPhi"]
743
744 auxItems = f"xAOD::CaloClusterAuxContainer#{clustersname_final}Aux."
745 auxItems+= ".".join(AODMoments)
746
747 toAOD.append(auxItems)
748
749 result.merge(addToESD(flags, toESD))
750 result.merge(addToAOD(flags, toAOD))
751
752
753 return result

◆ GPUClusterMomentsCalculatorToolCfg()

GPUClusterMomentsCalculatorToolCfg ( flags,
name = "GPUTopoMoments",
** kwargs )

Definition at line 261 of file CaloRecGPUConfig.py.

261def GPUClusterMomentsCalculatorToolCfg(flags, name = "GPUTopoMoments", **kwargs):
262 result=ComponentAccumulator()
263
264 kwargs.setdefault("MeasureTimes", flags.CaloRecGPU.ActiveConfig.MeasureTimes)
265 kwargs.setdefault("TimeFileOutput", name + "Times.txt")
266
267 kwargs.setdefault("WeightingOfNegClusters", flags.CaloRecGPU.ActiveConfig.MomentsUseAbsEnergy)
268
269 kwargs.setdefault("MaxAxisAngle", flags.CaloRecGPU.ActiveConfig.MomentsMaxAxisAngle)
270
271 kwargs.setdefault("TwoGaussianNoise", flags.CaloRecGPU.ActiveConfig.doTwoGaussianNoise)
272
273 kwargs.setdefault("MinBadLArQuality", flags.CaloRecGPU.ActiveConfig.MomentsMinBadLArQuality)
274
275 kwargs.setdefault("MinRLateral", flags.CaloRecGPU.ActiveConfig.MomentsMinRLateral)
276 kwargs.setdefault("MinLLongitudinal", flags.CaloRecGPU.ActiveConfig.MomentsMinLLongitudinal)
277
278 kwargs.setdefault("StreamTool", result.popToolsAndMerge(StreamToolCfg(flags)))
279
280 GPUTopoMoments = CompFactory.GPUClusterInfoAndMomentsCalculator(name, **kwargs)
281 result.setPrivateTools(GPUTopoMoments)
282 return result
283

◆ GPUOutputToolCfg()

GPUOutputToolCfg ( flags,
name = "GPUOutput",
** kwargs )

Definition at line 69 of file CaloRecGPUConfig.py.

69def GPUOutputToolCfg(flags, name = "GPUOutput", **kwargs):
70 result=ComponentAccumulator()
71 kwargs.setdefault("UseSortedAndCutClusters", True)
72 kwargs.setdefault("SavePath", "output")
73
74 GPUOutput = CompFactory.CaloGPUOutput(name, **kwargs)
75 result.setPrivateTools(GPUOutput)
76 return result
77

◆ MatchingOptions()

MatchingOptions ( min_similarity = 0.50,
terminal_weight = 250.,
grow_weight = 500.,
seed_weight = 1000. )

Definition at line 14 of file CaloRecGPUConfig.py.

14def MatchingOptions(min_similarity = 0.50, terminal_weight = 250., grow_weight = 500., seed_weight = 1000.):
15 return (min_similarity, terminal_weight, grow_weight, seed_weight)
16

◆ MomentsDumperToolCfg()

MomentsDumperToolCfg ( flags,
name = "MomentsDumper",
** kwargs )

Definition at line 399 of file CaloRecGPUConfig.py.

399def MomentsDumperToolCfg(flags, name = "MomentsDumper", **kwargs):
400 result=ComponentAccumulator()
401 kwargs.setdefault("SavePath", "moments")
402
403 MomentsDumper = CompFactory.CaloMomentsDumper(name, **kwargs)
404 result.setPrivateTools(MomentsDumper)
405 return result
406

◆ PerformanceInformationOutputToolCfg()

PerformanceInformationOutputToolCfg ( flags,
cellsname,
name = "PerfInfoTool",
** kwargs )

Definition at line 373 of file CaloRecGPUConfig.py.

373def PerformanceInformationOutputToolCfg(flags, cellsname, name = "PerfInfoTool", **kwargs):
374 result=ComponentAccumulator()
375 kwargs.setdefault("FileName", "event_info.txt")
376 kwargs.setdefault("CellsName", cellsname)
377
378 kwargs.setdefault("SeedThresholdOnEorAbsEinSigma", flags.CaloRecGPU.ActiveConfig.SeedThreshold)
379 kwargs.setdefault("NeighborThresholdOnEorAbsEinSigma", flags.CaloRecGPU.ActiveConfig.GrowThreshold)
380 kwargs.setdefault("CellThresholdOnEorAbsEinSigma", flags.CaloRecGPU.ActiveConfig.TermThreshold)
381
382 kwargs.setdefault("GrowingNeighborOption", flags.CaloRecGPU.ActiveConfig.GrowingNeighborOption)
383 kwargs.setdefault("GrowingRestrictHECIWandFCalNeighbors", flags.CaloRecGPU.ActiveConfig.GrowingRestrictHECIWandFCalNeighbors)
384 kwargs.setdefault("GrowingRestrictPSNeighbors", flags.CaloRecGPU.ActiveConfig.GrowingRestrictPSNeighbors)
385
386
387 kwargs.setdefault("SplittingNeighborOption", flags.CaloRecGPU.ActiveConfig.SplittingNeighborOption)
388 kwargs.setdefault("SplittingRestrictHECIWandFCalNeighbors", flags.CaloRecGPU.ActiveConfig.SplittingRestrictHECIWandFCalNeighbors)
389 kwargs.setdefault("SplittingRestrictPSNeighbors", flags.CaloRecGPU.ActiveConfig.GPUSplittingRestrictPSNeighbors)
390
391 kwargs.setdefault("SeedCutsInAbsE", flags.CaloRecGPU.ActiveConfig.UseAbsSeedThreshold)
392 kwargs.setdefault("NeighborCutsInAbsE", flags.CaloRecGPU.ActiveConfig.UseAbsGrowThreshold)
393 kwargs.setdefault("CellCutsInAbsE", flags.CaloRecGPU.ActiveConfig.UseAbsTermThreshold)
394
395 GPUCount = CompFactory.CaloPerformancePropertiesOutput(name, **kwargs)
396 result.setPrivateTools(GPUCount)
397 return result
398

◆ PlotterToolCfg()

PlotterToolCfg ( flags,
cellsname,
name = "PlotterMonitoring",
** kwargs )

Definition at line 407 of file CaloRecGPUConfig.py.

407def PlotterToolCfg(flags, cellsname, name = "PlotterMonitoring", **kwargs):
408 result=ComponentAccumulator()
409
410 kwargs.setdefault("SeedThreshold", flags.CaloRecGPU.ActiveConfig.SeedThreshold)
411 kwargs.setdefault("NeighborThreshold", flags.CaloRecGPU.ActiveConfig.GrowThreshold)
412 kwargs.setdefault("CellThreshold", flags.CaloRecGPU.ActiveConfig.TermThreshold)
413
414 kwargs.setdefault("CellsName", cellsname)
415
416 kwargs.setdefault("ClusterMatchingParameters", MatchingOptions())
417
418 if flags.CaloRecGPU.ActiveConfig.FillMissingCells:
419 kwargs.setdefault("MissingCellsToFill", flags.CaloRecGPU.ActiveConfig.MissingCellsToFill)
420
421 #Tools and Combinations to plot
422 #should be set by the end user.
423
424 PloTool = CompFactory.CaloGPUClusterAndCellDataMonitor(name, **kwargs)
425
426 if "MonitoringTool" not in kwargs:
427 from AthenaMonitoringKernel.GenericMonitoringTool import GenericMonitoringTool
428 PloTool.MonitoringTool = GenericMonitoringTool(flags, "PlotterMonitoringTool")
429
430 result.setPrivateTools(PloTool)
431 return result
432

◆ SingleToolToPlot()

SingleToolToPlot ( tool_name,
prefix )

Definition at line 8 of file CaloRecGPUConfig.py.

8def SingleToolToPlot(tool_name, prefix):
9 return (tool_name, prefix)
10

◆ TopoAutomatonClusteringToolCfg()

TopoAutomatonClusteringToolCfg ( flags,
name = "TopoAutomatonClustering",
** kwargs )

Definition at line 112 of file CaloRecGPUConfig.py.

112def TopoAutomatonClusteringToolCfg(flags, name = "TopoAutomatonClustering", **kwargs):
113 result=ComponentAccumulator()
114
115 kwargs.setdefault("MeasureTimes", flags.CaloRecGPU.ActiveConfig.MeasureTimes)
116 kwargs.setdefault("TimeFileOutput", name + "Times.txt")
117
118 kwargs.setdefault("CalorimeterNames", flags.CaloRecGPU.ActiveConfig.GrowingCalorimeterNames)
119
120 kwargs.setdefault("SeedSamplingNames", flags.CaloRecGPU.ActiveConfig.GrowingSeedSamplingNames)
121
122 kwargs.setdefault("SeedThresholdOnEorAbsEinSigma", flags.CaloRecGPU.ActiveConfig.SeedThreshold)
123 kwargs.setdefault("NeighborThresholdOnEorAbsEinSigma", flags.CaloRecGPU.ActiveConfig.GrowThreshold)
124 kwargs.setdefault("CellThresholdOnEorAbsEinSigma", flags.CaloRecGPU.ActiveConfig.TermThreshold)
125
126 kwargs.setdefault("SeedCutsInAbsE", flags.CaloRecGPU.ActiveConfig.UseAbsSeedThreshold)
127 kwargs.setdefault("NeighborCutsInAbsE", flags.CaloRecGPU.ActiveConfig.UseAbsGrowThreshold)
128 kwargs.setdefault("CellCutsInAbsE", flags.CaloRecGPU.ActiveConfig.UseAbsTermThreshold)
129
130 kwargs.setdefault("TwoGaussianNoise", flags.CaloRecGPU.ActiveConfig.doTwoGaussianNoise)
131
132 kwargs.setdefault("SeedCutsInT", flags.CaloRecGPU.ActiveConfig.doTimeCut)
133 kwargs.setdefault("CutOOTseed", flags.CaloRecGPU.ActiveConfig.doTimeCut and flags.CaloRecGPU.ActiveConfig.extendTimeCut)
134 kwargs.setdefault("UseTimeCutUpperLimit", flags.CaloRecGPU.ActiveConfig.useUpperLimitForTimeCut)
135 kwargs.setdefault("TimeCutUpperLimit", flags.CaloRecGPU.ActiveConfig.timeCutUpperLimit)
136
137 kwargs.setdefault("SeedThresholdOnTAbs", flags.CaloRecGPU.ActiveConfig.GrowingTimeCutSeedThreshold)
138
139 kwargs.setdefault("TreatL1PredictedCellsAsGood", flags.CaloRecGPU.ActiveConfig.GrowingTreatL1PredictedCellsAsGood)
140
141 kwargs.setdefault("XTalkEM2", flags.CaloRecGPU.ActiveConfig.xtalkEM2)
142 kwargs.setdefault("XTalkDeltaT", flags.CaloRecGPU.ActiveConfig.xtalkDeltaT)
143
144 #The other cross-talk options are not supported yet.
145
146 kwargs.setdefault("NeighborOption", flags.CaloRecGPU.ActiveConfig.GrowingNeighborOption)
147
148 kwargs.setdefault("RestrictHECIWandFCalNeighbors", flags.CaloRecGPU.ActiveConfig.GrowingRestrictHECIWandFCalNeighbors)
149
150 kwargs.setdefault("RestrictPSNeighbors", flags.CaloRecGPU.ActiveConfig.GrowingRestrictPSNeighbors)
151
152 kwargs.setdefault("StreamTool", result.popToolsAndMerge(StreamToolCfg(flags)))
153
154 TAClusterMaker = CompFactory.TopoAutomatonClustering(name, **kwargs)
155 result.setPrivateTools(TAClusterMaker)
156 return result
157

◆ TopoAutomatonSplitterToolCfg()

TopoAutomatonSplitterToolCfg ( flags,
name = "ClusterSplitter",
** kwargs )

Definition at line 209 of file CaloRecGPUConfig.py.

209def TopoAutomatonSplitterToolCfg(flags, name = "ClusterSplitter", **kwargs):
210 result=ComponentAccumulator()
211
212 kwargs.setdefault("MeasureTimes", flags.CaloRecGPU.ActiveConfig.MeasureTimes)
213 kwargs.setdefault("TimeFileOutput", name + "Times.txt")
214
215 kwargs.setdefault("NumberOfCellsCut", flags.CaloRecGPU.ActiveConfig.SplittingNumberOfCellsCut)
216 kwargs.setdefault("EnergyCut", flags.CaloRecGPU.ActiveConfig.SplittingEnergyCut)
217 kwargs.setdefault("SamplingNames", flags.CaloRecGPU.ActiveConfig.SplittingSamplingNames)
218 kwargs.setdefault("SecondarySamplingNames", flags.CaloRecGPU.ActiveConfig.SplittingSecondarySamplingNames)
219 kwargs.setdefault("ShareBorderCells", flags.CaloRecGPU.ActiveConfig.SplittingShareBorderCells)
220 kwargs.setdefault("EMShowerScale", flags.CaloRecGPU.ActiveConfig.SplittingEMShowerScale)
221 kwargs.setdefault("WeightingOfNegClusters", flags.CaloRecGPU.ActiveConfig.SplittingUseNegativeClusters)
222
223 kwargs.setdefault("TreatL1PredictedCellsAsGood", flags.CaloRecGPU.ActiveConfig.SplittingTreatL1PredictedCellsAsGood)
224
225 kwargs.setdefault("NeighborOption", flags.CaloRecGPU.ActiveConfig.SplittingNeighborOption)
226 kwargs.setdefault("RestrictHECIWandFCalNeighbors", flags.CaloRecGPU.ActiveConfig.SplittingRestrictHECIWandFCalNeighbors)
227 kwargs.setdefault("RestrictPSNeighbors", flags.CaloRecGPU.ActiveConfig.GPUSplittingRestrictPSNeighbors)
228 #Since the CPU version does not restrict this!
229
230 kwargs.setdefault("StreamTool", result.popToolsAndMerge(StreamToolCfg(flags)))
231
232 Splitter = CompFactory.TopoAutomatonSplitting(name, **kwargs)
233 result.setPrivateTools(Splitter)
234 return result
235
Generated on for ATLAS Offline Software by doxygen 1.17.0