ATLAS Offline Software
Functions
CaloRecGPUConfig Namespace Reference

Functions

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

Function Documentation

◆ AthenaClusterAndMomentsImporterToolCfg()

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

Definition at line 288 of file CaloRecGPUConfig.py.

288 def AthenaClusterAndMomentsImporterToolCfg(flags, cellsname, instantiateForTrigger, name = "ClusterAndMomentsImporter", **kwargs):
289  result=ComponentAccumulator()
290  kwargs.setdefault("CellsName", cellsname)
291 
292  kwargs.setdefault("ClusterSize", flags.CaloRecGPU.ActiveConfig.ClusterSize)
293 
294  kwargs.setdefault("MeasureTimes", flags.CaloRecGPU.ActiveConfig.MeasureTimes)
295  kwargs.setdefault("TimeFileOutput", name + "Times.txt")
296 
297  if not flags.Common.isOnline and not instantiateForTrigger:
298  kwargs.setdefault("FillHVMoments", True)
299  if flags.Input.isMC:
300  kwargs.setdefault("HVScaleCorrKey", "LArHVScaleCorr")
301  else:
302  kwargs.setdefault("HVScaleCorrKey", "LArHVScaleCorrRecomputed")
303  else:
304  kwargs.setdefault("FillHVMoments", False)
305 
306  kwargs.setdefault("MomentsNames", flags.CaloRecGPU.ActiveConfig.MomentsToCalculate)
307 
308  if flags.CaloRecGPU.ActiveConfig.FillMissingCells:
309  kwargs.setdefault("MissingCellsToFill", flags.CaloRecGPU.ActiveConfig.MissingCellsToFill)
310 
311  AthenaClusterImporter = CompFactory.GPUToAthenaImporterWithMoments(name, **kwargs)
312  result.setPrivateTools(AthenaClusterImporter)
313  return result
314 

◆ BasicAthenaClusterImporterToolCfg()

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

Definition at line 42 of file CaloRecGPUConfig.py.

42 def BasicAthenaClusterImporterToolCfg(flags, cellsname, name = "ClusterImporter", **kwargs):
43  result=ComponentAccumulator()
44  kwargs.setdefault("MeasureTimes", flags.CaloRecGPU.ActiveConfig.MeasureTimes)
45  kwargs.setdefault("TimeFileOutput", name + "Times.txt")
46  kwargs.setdefault("CellsName", cellsname)
47  kwargs.setdefault("ClusterSize", flags.CaloRecGPU.ActiveConfig.ClusterSize)
48  if flags.CaloRecGPU.ActiveConfig.FillMissingCells:
49  kwargs.setdefault("MissingCellsToFill", flags.CaloRecGPU.ActiveConfig.MissingCellsToFill)
50 
51  AthenaClusterImporter = CompFactory.BasicGPUToAthenaImporter(name, **kwargs)
52  result.setPrivateTools(AthenaClusterImporter)
53  return result
54 

◆ BasicConstantDataExporterToolCfg()

def CaloRecGPUConfig.BasicConstantDataExporterToolCfg (   flags,
  name = "ConstantDataExporter",
**  kwargs 
)

Definition at line 15 of file CaloRecGPUConfig.py.

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

◆ BasicEventDataExporterToolCfg()

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

Definition at line 26 of file CaloRecGPUConfig.py.

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

◆ CellsCounterCPUToolCfg()

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

Definition at line 315 of file CaloRecGPUConfig.py.

315 def CellsCounterCPUToolCfg(flags, cellsname, name = "CPUCounts", **kwargs):
316  result=ComponentAccumulator()
317  kwargs.setdefault("SavePath", "counts")
318  kwargs.setdefault("FilePrefix", "CPU")
319  kwargs.setdefault("CellsName", cellsname)
320 
321  kwargs.setdefault("SeedThresholdOnEorAbsEinSigma", flags.CaloRecGPU.ActiveConfig.SeedThreshold)
322  kwargs.setdefault("NeighborThresholdOnEorAbsEinSigma", flags.CaloRecGPU.ActiveConfig.GrowThreshold)
323  kwargs.setdefault("CellThresholdOnEorAbsEinSigma", flags.CaloRecGPU.ActiveConfig.TermThreshold)
324 
325  CPUCount = CompFactory.CaloCellsCounterCPU(name, **kwargs)
326  result.setPrivateTools(CPUCount)
327  return result
328 

◆ CellsCounterGPUToolCfg()

def CaloRecGPUConfig.CellsCounterGPUToolCfg (   flags,
  name = "GPUCounts",
**  kwargs 
)

Definition at line 329 of file CaloRecGPUConfig.py.

329 def CellsCounterGPUToolCfg(flags, name = "GPUCounts", **kwargs):
330  result=ComponentAccumulator()
331  kwargs.setdefault("SavePath", "counts")
332  kwargs.setdefault("FilePrefix", "GPU")
333 
334  kwargs.setdefault("SeedThresholdOnEorAbsEinSigma", flags.CaloRecGPU.ActiveConfig.SeedThreshold)
335  kwargs.setdefault("NeighborThresholdOnEorAbsEinSigma", flags.CaloRecGPU.ActiveConfig.GrowThreshold)
336  kwargs.setdefault("CellThresholdOnEorAbsEinSigma", flags.CaloRecGPU.ActiveConfig.TermThreshold)
337 
338  GPUCount = CompFactory.CaloCellsCounterGPU(name, **kwargs)
339  result.setPrivateTools(GPUCount)
340  return result
341 

◆ ClusterInfoCalcToolCfg()

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

Definition at line 73 of file CaloRecGPUConfig.py.

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

◆ ComparedToolsToPlot()

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

Definition at line 9 of file CaloRecGPUConfig.py.

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

◆ CPUOutputToolCfg()

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

Definition at line 55 of file CaloRecGPUConfig.py.

55 def CPUOutputToolCfg(flags, cellsname, name = "CPUOutput", **kwargs):
56  result=ComponentAccumulator()
57  kwargs.setdefault("CellsName", cellsname)
58  kwargs.setdefault("SavePath", "output")
59 
60  CPUOutput = CompFactory.CaloCPUOutput(name, **kwargs)
61  result.setPrivateTools(CPUOutput)
62  return result
63 

◆ DefaultCalibMomentsToolCfg()

def CaloRecGPUConfig.DefaultCalibMomentsToolCfg (   flags,
  name = "TopoCalibMoments",
**  kwargs 
)

Definition at line 373 of file CaloRecGPUConfig.py.

373 def DefaultCalibMomentsToolCfg(flags, name = "TopoCalibMoments", **kwargs):
374  result=ComponentAccumulator()
375 
376  kwargs.setdefault("MomentsNames", ["ENG_CALIB_TOT"
377  ,"ENG_CALIB_OUT_L"
378  ,"ENG_CALIB_OUT_T"
379  ,"ENG_CALIB_EMB0"
380  ,"ENG_CALIB_EME0"
381  ,"ENG_CALIB_TILEG3"
382  ,"ENG_CALIB_DEAD_TOT"
383  ,"ENG_CALIB_DEAD_EMB0"
384  ,"ENG_CALIB_DEAD_TILE0"
385  ,"ENG_CALIB_DEAD_TILEG3"
386  ,"ENG_CALIB_DEAD_EME0"
387  ,"ENG_CALIB_DEAD_HEC0"
388  ,"ENG_CALIB_DEAD_FCAL"
389  ,"ENG_CALIB_DEAD_LEAKAGE"
390  ,"ENG_CALIB_DEAD_UNCLASS"
391  ,"ENG_CALIB_FRAC_EM"
392  ,"ENG_CALIB_FRAC_HAD"
393  ,"ENG_CALIB_FRAC_REST"])
394 
395  kwargs.setdefault("CalibrationHitContainerNames", ["LArCalibrationHitInactive"
396  ,"LArCalibrationHitActive"
397  ,"TileCalibHitActiveCell"
398  ,"TileCalibHitInactiveCell"])
399 
400  kwargs.setdefault("DMCalibrationHitContainerNames", ["LArCalibrationHitDeadMaterial"
401  ,"TileCalibHitDeadMaterial"])
402 
403  TopoCalibMoments = CompFactory.CaloCalibClusterMomentsMaker2(name, **kwargs)
404  result.setPrivateTools(TopoCalibMoments)
405  return result
406 

◆ DefaultClusterMomentsCalculatorToolCfg()

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

Definition at line 255 of file CaloRecGPUConfig.py.

255 def DefaultClusterMomentsCalculatorToolCfg(flags, instantiateForTrigger, name = "TopoMoments", **kwargs):
256  result=ComponentAccumulator()
257 
258  kwargs.setdefault("WeightingOfNegClusters", flags.CaloRecGPU.ActiveConfig.MomentsUseAbsEnergy)
259 
260  kwargs.setdefault("MaxAxisAngle", flags.CaloRecGPU.ActiveConfig.MomentsMaxAxisAngle)
261 
262  kwargs.setdefault("TwoGaussianNoise", flags.CaloRecGPU.ActiveConfig.doTwoGaussianNoise)
263 
264  kwargs.setdefault("MinBadLArQuality", flags.CaloRecGPU.ActiveConfig.MomentsMinBadLArQuality)
265 
266  kwargs.setdefault("MomentsNames", flags.CaloRecGPU.ActiveConfig.MomentsToCalculate)
267 
268  kwargs.setdefault("MinRLateral", flags.CaloRecGPU.ActiveConfig.MomentsMinRLateral)
269  kwargs.setdefault("MinLLongitudinal", flags.CaloRecGPU.ActiveConfig.MomentsMinLLongitudinal)
270 
271  kwargs.setdefault("UseGPUCriteria", not flags.CaloRecGPU.ActiveConfig.UseOriginalCriteria)
272 
273  TopoMoments = CompFactory.CaloClusterMomentsMaker(name, **kwargs)
274 
275  if not flags.Common.isOnline and not instantiateForTrigger and "LArHVFraction" not in kwargs:
276  #If it's already in kwargs, don't override
277  #(extra flexibility for the user, not that it's needed...)
278  from LArConfiguration.LArElecCalibDBConfig import LArElecCalibDBCfg
279  result.merge(LArElecCalibDBCfg(flags,["HVScaleCorr"]))
280  if flags.Input.isMC:
281  TopoMoments.LArHVFraction=CompFactory.LArHVFraction(HVScaleCorrKey="LArHVScaleCorr")
282  else:
283  TopoMoments.LArHVFraction=CompFactory.LArHVFraction(HVScaleCorrKey="LArHVScaleCorrRecomputed")
284 
285  result.setPrivateTools(TopoMoments)
286  return result
287 

◆ DefaultClusterSplittingToolCfg()

def CaloRecGPUConfig.DefaultClusterSplittingToolCfg (   flags,
  name = "TopoSplitter",
**  kwargs 
)

Definition at line 209 of file CaloRecGPUConfig.py.

209 def DefaultClusterSplittingToolCfg(flags, name = "TopoSplitter", **kwargs):
210  result=ComponentAccumulator()
211 
212  kwargs.setdefault("NeighborOption", flags.CaloRecGPU.ActiveConfig.SplittingNeighborOption)
213  kwargs.setdefault("RestrictHECIWandFCalNeighbors", flags.CaloRecGPU.ActiveConfig.SplittingRestrictHECIWandFCalNeighbors)
214 
215  kwargs.setdefault("NumberOfCellsCut", flags.CaloRecGPU.ActiveConfig.SplittingNumberOfCellsCut)
216  kwargs.setdefault("EnergyCut", flags.CaloRecGPU.ActiveConfig.SplittingEnergyCut)
217 
218  kwargs.setdefault("SamplingNames", flags.CaloRecGPU.ActiveConfig.SplittingSamplingNames)
219  kwargs.setdefault("SecondarySamplingNames", flags.CaloRecGPU.ActiveConfig.SplittingSecondarySamplingNames)
220 
221  kwargs.setdefault("ShareBorderCells", flags.CaloRecGPU.ActiveConfig.SplittingShareBorderCells)
222  kwargs.setdefault("EMShowerScale", flags.CaloRecGPU.ActiveConfig.SplittingEMShowerScale)
223 
224  kwargs.setdefault("TreatL1PredictedCellsAsGood", flags.CaloRecGPU.ActiveConfig.SplittingTreatL1PredictedCellsAsGood)
225 
226  kwargs.setdefault("WeightingOfNegClusters", flags.CaloRecGPU.ActiveConfig.SplittingUseNegativeClusters)
227 
228  kwargs.setdefault("UseGPUCriteria", not flags.CaloRecGPU.ActiveConfig.UseOriginalCriteria)
229 
230  TopoSplitter = CompFactory.CaloTopoClusterSplitter(name, **kwargs)
231  result.setPrivateTools(TopoSplitter)
232  return result
233 

◆ DefaultTopoClusterLocalCalibToolsCfg()

def CaloRecGPUConfig.DefaultTopoClusterLocalCalibToolsCfg (   flags,
  instantiateForTrigger,
  prefix = '' 
)

Definition at line 407 of file CaloRecGPUConfig.py.

407 def DefaultTopoClusterLocalCalibToolsCfg(flags, instantiateForTrigger, prefix = ''):
408  result=ComponentAccumulator()
409 
410  CaloClusterLocalCalib=CompFactory.CaloClusterLocalCalib
411 
412  # Local cell weights
413  LCClassify = CompFactory.CaloLCClassificationTool(prefix + "LCClassify")
414  LCClassify.ClassificationKey = "EMFracClassify"
415  LCClassify.UseSpread = False
416  LCClassify.MaxProbability = 0.85 if flags.GeoModel.AtlasVersion.startswith("Rome") and instantiateForTrigger else 0.5
417  LCClassify.StoreClassificationProbabilityInAOD = True
418  if instantiateForTrigger:
419  LCClassify.UseNormalizedEnergyDensity = not flags.GeoModel.AtlasVersion.startswith("Rome")
420  if not instantiateForTrigger:
421  LCClassify.WeightingOfNegClusters = flags.CaloRecGPU.ActiveConfig.CalibrationUseAbsEnergy
422 
423  LCWeight = CompFactory.CaloLCWeightTool(prefix + "LCWeight")
424  LCWeight.CorrectionKey = "H1ClusterCellWeights"
425  LCWeight.SignalOverNoiseCut = 2.0
426  LCWeight.UseHadProbability = True
427 
428  LocalCalib = CaloClusterLocalCalib (prefix + "LocalCalib")
429  LocalCalib.ClusterClassificationTool = [LCClassify]
430  LocalCalib.ClusterRecoStatus = [1,2]
431  LocalCalib.LocalCalibTools = [LCWeight]
432  if not instantiateForTrigger:
433  LocalCalib.WeightingOfNegClusters = flags.CaloRecGPU.ActiveConfig.CalibrationUseAbsEnergy
434 
435  # Out-of-cluster corrections
436  LCOut = CompFactory.CaloLCOutOfClusterTool(prefix + "LCOut")
437  LCOut.CorrectionKey = "OOCCorrection"
438  LCOut.UseEmProbability = False
439  LCOut.UseHadProbability = True
440 
441  OOCCalib = CaloClusterLocalCalib (prefix + "OOCCalib")
442  OOCCalib.ClusterRecoStatus = [1,2]
443  OOCCalib.LocalCalibTools = [LCOut]
444  if not instantiateForTrigger:
445  OOCCalib.WeightingOfNegClusters = flags.CaloRecGPU.ActiveConfig.CalibrationUseAbsEnergy
446 
447  LCOutPi0 = CompFactory.CaloLCOutOfClusterTool(prefix + "LCOutPi0")
448  LCOutPi0.CorrectionKey = "OOCPi0Correction"
449  LCOutPi0.UseEmProbability = True
450  LCOutPi0.UseHadProbability = False
451 
452  OOCPi0Calib = CaloClusterLocalCalib (prefix + "OOCPi0Calib")
453  OOCPi0Calib.ClusterRecoStatus = [1,2]
454  OOCPi0Calib.LocalCalibTools = [LCOutPi0]
455  if not instantiateForTrigger:
456  OOCPi0Calib.WeightingOfNegClusters = flags.CaloRecGPU.ActiveConfig.CalibrationUseAbsEnergy
457 
458  # Dead material corrections
459  LCDeadMaterial = CompFactory.CaloLCDeadMaterialTool(prefix + "LCDeadMaterial")
460  LCDeadMaterial.HadDMCoeffKey = "HadDMCoeff2"
461  LCDeadMaterial.ClusterRecoStatus = 0
462  LCDeadMaterial.WeightModeDM = 2
463  LCDeadMaterial.UseHadProbability = True
464  if not instantiateForTrigger:
465  LCDeadMaterial.WeightingOfNegClusters = flags.CaloRecGPU.ActiveConfig.CalibrationUseAbsEnergy
466 
467  DMCalib = CaloClusterLocalCalib (prefix + "DMCalib")
468  DMCalib.ClusterRecoStatus = [1,2]
469  DMCalib.LocalCalibTools = [LCDeadMaterial]
470  if not instantiateForTrigger:
471  DMCalib.WeightingOfNegClusters = flags.CaloRecGPU.ActiveConfig.CalibrationUseAbsEnergy
472 
473  lccalibtools = [
474  LocalCalib,
475  OOCCalib,
476  OOCPi0Calib,
477  DMCalib]
478 
479  result.setPrivateTools(lccalibtools)
480 
481  return result
482 
483 #Depending on ReallyUseGPUTools,
484 #instantiates GPU or CPU tools with consistent options...

◆ DefaultTopologicalClusteringToolCfg()

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

Definition at line 133 of file CaloRecGPUConfig.py.

133 def DefaultTopologicalClusteringToolCfg(flags, cellsname, name = "TopoClusterMaker", **kwargs):
134  result=ComponentAccumulator()
135 
136  kwargs.setdefault("CellsName", cellsname)
137 
138  kwargs.setdefault("CalorimeterNames", flags.CaloRecGPU.ActiveConfig.GrowingCalorimeterNames)
139  kwargs.setdefault("SeedSamplingNames", flags.CaloRecGPU.ActiveConfig.GrowingSeedSamplingNames)
140 
141  kwargs.setdefault("NeighborOption", flags.CaloRecGPU.ActiveConfig.GrowingNeighborOption)
142  kwargs.setdefault("RestrictHECIWandFCalNeighbors", flags.CaloRecGPU.ActiveConfig.GrowingRestrictHECIWandFCalNeighbors)
143  kwargs.setdefault("RestrictPSNeighbors", flags.CaloRecGPU.ActiveConfig.GrowingRestrictPSNeighbors)
144 
145  kwargs.setdefault("SeedThresholdOnEorAbsEinSigma", flags.CaloRecGPU.ActiveConfig.SeedThreshold)
146  kwargs.setdefault("NeighborThresholdOnEorAbsEinSigma", flags.CaloRecGPU.ActiveConfig.GrowThreshold)
147  kwargs.setdefault("CellThresholdOnEorAbsEinSigma", flags.CaloRecGPU.ActiveConfig.TermThreshold)
148 
149  kwargs.setdefault("SeedCutsInAbsE", flags.CaloRecGPU.ActiveConfig.UseAbsSeedThreshold)
150  kwargs.setdefault("NeighborCutsInAbsE", flags.CaloRecGPU.ActiveConfig.UseAbsGrowThreshold)
151  kwargs.setdefault("CellCutsInAbsE", flags.CaloRecGPU.ActiveConfig.UseAbsTermThreshold)
152 
153  kwargs.setdefault("SeedCutsInT", flags.CaloRecGPU.ActiveConfig.doTimeCut)
154  kwargs.setdefault("CutOOTseed", flags.CaloRecGPU.ActiveConfig.doTimeCut and flags.CaloRecGPU.ActiveConfig.extendTimeCut)
155  kwargs.setdefault("UseTimeCutUpperLimit", flags.CaloRecGPU.ActiveConfig.useUpperLimitForTimeCut)
156  kwargs.setdefault("TimeCutUpperLimit", flags.CaloRecGPU.ActiveConfig.timeCutUpperLimit)
157  kwargs.setdefault("XTalkEM2", flags.CaloRecGPU.ActiveConfig.xtalkEM2)
158  kwargs.setdefault("XTalkEM2D", flags.CaloRecGPU.ActiveConfig.xtalkEM2D)
159  kwargs.setdefault("XTalkEM2n", flags.CaloRecGPU.ActiveConfig.xtalkEM2n)
160  kwargs.setdefault("XTalkEM3", flags.CaloRecGPU.ActiveConfig.xtalkEM3)
161  kwargs.setdefault("XTalkEMEta", flags.CaloRecGPU.ActiveConfig.xtalkEMEta)
162  kwargs.setdefault("XTalkDeltaT", flags.CaloRecGPU.ActiveConfig.xtalkDeltaT)
163  kwargs.setdefault("XTalk2Eratio1", flags.CaloRecGPU.ActiveConfig.xtalk2Eratio1)
164  kwargs.setdefault("XTalk2Eratio2", flags.CaloRecGPU.ActiveConfig.xtalk2Eratio2)
165  kwargs.setdefault("XTalk3Eratio", flags.CaloRecGPU.ActiveConfig.xtalk3Eratio)
166  kwargs.setdefault("XTalkEtaEratio", flags.CaloRecGPU.ActiveConfig.xtalkEtaEratio)
167  kwargs.setdefault("XTalk2DEratio", flags.CaloRecGPU.ActiveConfig.xtalk2DEratio)
168 
169  kwargs.setdefault("ClusterCutsInAbsEt", flags.CaloRecGPU.ActiveConfig.PostGrowingClusterCutClustersInAbsEt)
170  kwargs.setdefault("ClusterEtorAbsEtCut", flags.CaloRecGPU.ActiveConfig.PostGrowingClusterEnergyCut)
171 
172  kwargs.setdefault("TwoGaussianNoise", flags.CaloRecGPU.ActiveConfig.doTwoGaussianNoise)
173 
174  kwargs.setdefault("SeedThresholdOnTAbs", flags.CaloRecGPU.ActiveConfig.GrowingTimeCutSeedThreshold)
175 
176  kwargs.setdefault("TreatL1PredictedCellsAsGood", flags.CaloRecGPU.ActiveConfig.GrowingTreatL1PredictedCellsAsGood)
177 
178  kwargs.setdefault("UseGPUCriteria", not flags.CaloRecGPU.ActiveConfig.UseOriginalCriteria)
179 
180  TopoMaker = CompFactory.CaloTopoClusterMaker(name, **kwargs)
181  result.setPrivateTools(TopoMaker)
182  return result
183 

◆ GPUCaloTopoClusterCfg()

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

Definition at line 485 of file CaloRecGPUConfig.py.

485 def GPUCaloTopoClusterCfg(flags, instantiateForTrigger, cellsname,
486  clustersname = None, clustersnapname="CaloTopoClusters", name="HybridClusterProcessor",
487  PlotterTool = None, addAsPrimary = True, ReallyUseGPUTools = True):
488 
489  doLCCalib = flags.CaloRecGPU.ActiveConfig.doTopoClusterLocalCalib
490 
491  if clustersname is None:
492  clustersname = "CaloCalTopoClusters" if doLCCalib else "CaloTopoClusters"
493 
494  if clustersname == "CaloTopoClusters" and doLCCalib:
495  raise RuntimeError("Inconsistent arguments: clustersname must not be 'CaloTopoClusters' if doTopoClusterLocalCalib is True")
496 
497  result = ComponentAccumulator()
498 
499  if not instantiateForTrigger:
500 
501  from LArGeoAlgsNV.LArGMConfig import LArGMCfg
502  from TileGeoModel.TileGMConfig import TileGMCfg
503  from CaloTools.CaloNoiseCondAlgConfig import CaloNoiseCondAlgCfg
504 
505  result.merge(CaloNoiseCondAlgCfg(flags,"totalNoise"))
506  result.merge(CaloNoiseCondAlgCfg(flags,"electronicNoise"))
507 
508  result.merge(LArGMCfg(flags))
509  result.merge(TileGMCfg(flags))
510 
511 
512  HybridClusterProcessor = CompFactory.CaloGPUHybridClusterProcessor(name)
513  HybridClusterProcessor.ClustersOutputName = clustersname
514 
515  HybridClusterProcessor.WriteTriggerSpecificInfo = instantiateForTrigger
516 
517  HybridClusterProcessor.MeasureTimes = flags.CaloRecGPU.ActiveConfig.MeasureTimes
518 
519  HybridClusterProcessor.TimeFileOutput = "GlobalTimes.txt"
520 
521  HybridClusterProcessor.DeferConstantDataPreparationToFirstEvent = True
522  HybridClusterProcessor.DoPlots = PlotterTool is not None
523  HybridClusterProcessor.PlotterTool = PlotterTool
524 
525  HybridClusterProcessor.NumPreAllocatedDataHolders = flags.CaloRecGPU.ActiveConfig.NumPreAllocatedDataHolders
526 
527  if ReallyUseGPUTools:
528 
529  HybridClusterProcessor.ConstantDataToGPUTool = result.popToolsAndMerge( BasicConstantDataExporterToolCfg(flags) )
530  HybridClusterProcessor.EventDataToGPUTool = result.popToolsAndMerge( BasicEventDataExporterToolCfg(flags, cellsname) )
531  HybridClusterProcessor.GPUToEventDataTool = result.popToolsAndMerge( AthenaClusterAndMomentsImporterToolCfg(flags, cellsname, instantiateForTrigger) )
532 
533 
534  HybridClusterProcessor.BeforeGPUTools = []
535 
536  HybridClusterProcessor.GPUTools = []
537 
538  HybridClusterProcessor.GPUTools += [result.popToolsAndMerge( TopoAutomatonClusteringToolCfg(flags,"GPUGrowing"))]
539 
540  HybridClusterProcessor.GPUTools += [result.popToolsAndMerge( ClusterInfoCalcToolCfg(flags,"PostGPUGrowingClusterPropertiesCalculator", True))]
541 
542  HybridClusterProcessor.GPUTools += [result.popToolsAndMerge( TopoAutomatonSplitterToolCfg(flags,"GPUSplitting") )]
543 
544  HybridClusterProcessor.GPUTools += [result.popToolsAndMerge( GPUClusterMomentsCalculatorToolCfg(flags,"GPUTopoMoments") )]
545 
546  else:
547 
548  HybridClusterProcessor.ConstantDataToGPUTool = None
549  HybridClusterProcessor.EventDataToGPUTool = None
550  HybridClusterProcessor.GPUToEventDataTool = None
551  HybridClusterProcessor.SkipConversions = True
552 
553  HybridClusterProcessor.GPUTools = []
554 
555  HybridClusterProcessor.BeforeGPUTools = []
556 
557  HybridClusterProcessor.BeforeGPUTools += [result.popToolsAndMerge( DefaultTopologicalClusteringToolCfg(flags, cellsname,"CPUGrowing"))]
558 
559  HybridClusterProcessor.BeforeGPUTools += [result.popToolsAndMerge( DefaultClusterSplittingToolCfg(flags,"CPUSplitting") )]
560 
561  HybridClusterProcessor.BeforeGPUTools += [result.popToolsAndMerge( DefaultClusterMomentsCalculatorToolCfg(flags, instantiateForTrigger, "CPUTopoMoments") )]
562 
563  HybridClusterProcessor.BeforeGPUTools += [ CompFactory.CaloClusterStoreRawProperties("RawPropertiesStorer") ]
564 
565 
566 
567  HybridClusterProcessor.AfterGPUTools = []
568 
569  if not instantiateForTrigger:
570  from CaloBadChannelTool.CaloBadChanToolConfig import CaloBadChanToolCfg
571  caloBadChanTool = result.popToolsAndMerge( CaloBadChanToolCfg(flags) )
572  HybridClusterProcessor.AfterGPUTools += [CompFactory.CaloClusterBadChannelList(badChannelTool = caloBadChanTool)]
573 
574  if not instantiateForTrigger and flags.CaloRecGPU.ActiveConfig.doCalibHitMoments:
575 
576  calibHitsMomentsMaker = result.popToolsAndMerge(DefaultCalibMomentsToolCfg(flags))
577  HybridClusterProcessor.AfterGPUTools += [calibHitsMomentsMaker]
578 
579  if doLCCalib:
580  if not instantiateForTrigger:
581  HybridClusterProcessor.AfterGPUTools += [CompFactory.CaloClusterSnapshot(OutputName=clustersnapname,
582  SetCrossLinks=True,
583  FinalClusterContainerName=clustersname)]
584  else:
585  from CaloTools.CaloNoiseCondAlgConfig import CaloNoiseCondAlgCfg
586  from CaloRec.CaloTopoClusterConfig import caloTopoCoolFolderCfg
587  result.merge(CaloNoiseCondAlgCfg(flags, noisetype="electronicNoise"))
588  result.merge(caloTopoCoolFolderCfg(flags))
589 
590  calibTools = result.popToolsAndMerge(DefaultTopoClusterLocalCalibToolsCfg(flags, instantiateForTrigger, 'Trig' if instantiateForTrigger else ''))
591 
592  HybridClusterProcessor.AfterGPUTools += calibTools
593  #This is already a tool array.
594 
595  if not instantiateForTrigger:
596  from CaloRec.CaloTopoClusterConfig import caloTopoCoolFolderCfg
597  result.merge(caloTopoCoolFolderCfg(flags))
598 
599  if instantiateForTrigger:
600  from CaloTools.CaloNoiseCondAlgConfig import CaloNoiseCondAlgCfg
601  result.merge(CaloNoiseCondAlgCfg(flags))
602 
603  result.addEventAlgo(HybridClusterProcessor, primary=addAsPrimary)
604 
605  if instantiateForTrigger or clustersname in flags.CaloRecGPU.ActiveConfig.skipWriteList:
606  # don't add these clusters to ESD and AOD
607  return result
608 
609  #Output config:
610  AODMoments=[ "SECOND_R"
611  ,"SECOND_LAMBDA"
612  ,"CENTER_MAG"
613  ,"CENTER_LAMBDA"
614  ,"FIRST_ENG_DENS"
615  ,"ENG_FRAC_MAX"
616  ,"ISOLATION"
617  ,"ENG_BAD_CELLS"
618  ,"N_BAD_CELLS"
619  ,"BADLARQ_FRAC"
620  ,"ENG_POS"
621  ,"SIGNIFICANCE"
622  ,"AVG_LAR_Q"
623  ,"AVG_TILE_Q"
624  ,"EM_PROBABILITY"
625  ,"BadChannelList"
626  ,"SECOND_TIME"
627  ,"NCELL_SAMPLING"]
628 
629  if flags.CaloRecGPU.ActiveConfig.writeExtendedClusterMoments:
630  AODMoments += ["LATERAL"
631  ,"LONGITUDINAL"
632  ,"CELL_SIGNIFICANCE"
633  ,"PTD"
634  ,"MASS"]
635 
636  if flags.Reco.EnableHI:
637  AODMoments += ["CELL_SIG_SAMPLING"]
638 
639  if flags.CaloRecGPU.ActiveConfig.writeCalibHitClusterMoments:
640  AODMoments += ["ENG_CALIB_TOT"
641  ,"ENG_CALIB_OUT_L"
642  ,"ENG_CALIB_OUT_T"
643  ,"ENG_CALIB_EMB0"
644  ,"ENG_CALIB_EME0"
645  ,"ENG_CALIB_TILEG3"
646  ,"ENG_CALIB_DEAD_TOT"
647  ,"ENG_CALIB_DEAD_EMB0"
648  ,"ENG_CALIB_DEAD_TILE0"
649  ,"ENG_CALIB_DEAD_TILEG3"
650  ,"ENG_CALIB_DEAD_EME0"
651  ,"ENG_CALIB_DEAD_HEC0"
652  ,"ENG_CALIB_DEAD_FCAL"
653  ,"ENG_CALIB_DEAD_LEAKAGE"
654  ,"ENG_CALIB_DEAD_UNCLASS"
655  ,"ENG_CALIB_FRAC_EM"
656  ,"ENG_CALIB_FRAC_HAD"
657  ,"ENG_CALIB_FRAC_REST"]
658 
659 
660  from OutputStreamAthenaPool.OutputStreamConfig import addToAOD, addToESD
661  toESD = [f"xAOD::CaloClusterContainer#{clustersname}",
662  f"xAOD::CaloClusterAuxContainer#{clustersname}Aux.",
663  f"CaloClusterCellLinkContainer#{clustersname}_links"]
664  toAOD = [f"xAOD::CaloClusterContainer#{clustersname}",
665  f"CaloClusterCellLinkContainer#{clustersname}_links"]
666 
667  AODMoments.append("CellLink") #Add data-link to cell-link container
668  if flags.CaloRecGPU.ActiveConfig.addCalibrationHitDecoration: #Add calib hit deco if requried
669  AODMoments.append(flags.CaloRecGPU.ActiveConfig.CalibrationHitDecorationName)
670 
671  if flags.CaloRecGPU.ActiveConfig.addCPData:
672  AODMoments += ["ClusterWidthEta","ClusterWidthPhi"]
673 
674  auxItems = f"xAOD::CaloClusterAuxContainer#{clustersname}Aux."
675  auxItems+= ".".join(AODMoments)
676 
677  toAOD.append(auxItems)
678 
679  result.merge(addToESD(flags, toESD))
680  result.merge(addToAOD(flags, toAOD))
681 
682 
683  return result
684 

◆ GPUClusterMomentsCalculatorToolCfg()

def CaloRecGPUConfig.GPUClusterMomentsCalculatorToolCfg (   flags,
  name = "GPUTopoMoments",
**  kwargs 
)

Definition at line 234 of file CaloRecGPUConfig.py.

234 def GPUClusterMomentsCalculatorToolCfg(flags, name = "GPUTopoMoments", **kwargs):
235  result=ComponentAccumulator()
236 
237  kwargs.setdefault("MeasureTimes", flags.CaloRecGPU.ActiveConfig.MeasureTimes)
238  kwargs.setdefault("TimeFileOutput", name + "Times.txt")
239 
240  kwargs.setdefault("WeightingOfNegClusters", flags.CaloRecGPU.ActiveConfig.MomentsUseAbsEnergy)
241 
242  kwargs.setdefault("MaxAxisAngle", flags.CaloRecGPU.ActiveConfig.MomentsMaxAxisAngle)
243 
244  kwargs.setdefault("TwoGaussianNoise", flags.CaloRecGPU.ActiveConfig.doTwoGaussianNoise)
245 
246  kwargs.setdefault("MinBadLArQuality", flags.CaloRecGPU.ActiveConfig.MomentsMinBadLArQuality)
247 
248  kwargs.setdefault("MinRLateral", flags.CaloRecGPU.ActiveConfig.MomentsMinRLateral)
249  kwargs.setdefault("MinLLongitudinal", flags.CaloRecGPU.ActiveConfig.MomentsMinLLongitudinal)
250 
251  GPUTopoMoments = CompFactory.GPUClusterInfoAndMomentsCalculator(name, **kwargs)
252  result.setPrivateTools(GPUTopoMoments)
253  return result
254 

◆ GPUOutputToolCfg()

def CaloRecGPUConfig.GPUOutputToolCfg (   flags,
  name = "GPUOutput",
**  kwargs 
)

Definition at line 64 of file CaloRecGPUConfig.py.

64 def GPUOutputToolCfg(flags, name = "GPUOutput", **kwargs):
65  result=ComponentAccumulator()
66  kwargs.setdefault("UseSortedAndCutClusters", True)
67  kwargs.setdefault("SavePath", "output")
68 
69  GPUOutput = CompFactory.CaloGPUOutput(name, **kwargs)
70  result.setPrivateTools(GPUOutput)
71  return result
72 

◆ MatchingOptions()

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

Definition at line 12 of file CaloRecGPUConfig.py.

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

◆ MomentsDumperToolCfg()

def CaloRecGPUConfig.MomentsDumperToolCfg (   flags,
  name = "MomentsDumper",
**  kwargs 
)

Definition at line 342 of file CaloRecGPUConfig.py.

342 def MomentsDumperToolCfg(flags, name = "MomentsDumper", **kwargs):
343  result=ComponentAccumulator()
344  kwargs.setdefault("SavePath", "moments")
345 
346  MomentsDumper = CompFactory.CaloMomentsDumper(name, **kwargs)
347  result.setPrivateTools(MomentsDumper)
348  return result
349 

◆ PlotterToolCfg()

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

Definition at line 350 of file CaloRecGPUConfig.py.

350 def PlotterToolCfg(flags, cellsname, name = "PlotterMonitoring", **kwargs):
351  result=ComponentAccumulator()
352 
353  kwargs.setdefault("SeedThreshold", flags.CaloRecGPU.ActiveConfig.SeedThreshold)
354  kwargs.setdefault("NeighborThreshold", flags.CaloRecGPU.ActiveConfig.GrowThreshold)
355  kwargs.setdefault("CellThreshold", flags.CaloRecGPU.ActiveConfig.TermThreshold)
356 
357  kwargs.setdefault("CellsName", cellsname)
358 
359  kwargs.setdefault("ClusterMatchingParameters", MatchingOptions())
360 
361  #Tools and Combinations to plot
362  #should be set by the end user.
363 
364  PloTool = CompFactory.CaloGPUClusterAndCellDataMonitor(name, **kwargs)
365 
366  if "MonitoringTool" not in kwargs:
367  from AthenaMonitoringKernel.GenericMonitoringTool import GenericMonitoringTool
368  PloTool.MonitoringTool = GenericMonitoringTool(flags, "PlotterMonitoringTool")
369 
370  result.setPrivateTools(PloTool)
371  return result
372 

◆ SingleToolToPlot()

def CaloRecGPUConfig.SingleToolToPlot (   tool_name,
  prefix 
)

Definition at line 6 of file CaloRecGPUConfig.py.

6 def SingleToolToPlot(tool_name, prefix):
7  return (tool_name, prefix)
8 

◆ TopoAutomatonClusteringToolCfg()

def CaloRecGPUConfig.TopoAutomatonClusteringToolCfg (   flags,
  name = "TopoAutomatonClustering",
**  kwargs 
)

Definition at line 89 of file CaloRecGPUConfig.py.

89 def TopoAutomatonClusteringToolCfg(flags, name = "TopoAutomatonClustering", **kwargs):
90  result=ComponentAccumulator()
91 
92  kwargs.setdefault("MeasureTimes", flags.CaloRecGPU.ActiveConfig.MeasureTimes)
93  kwargs.setdefault("TimeFileOutput", name + "Times.txt")
94 
95  kwargs.setdefault("CalorimeterNames", flags.CaloRecGPU.ActiveConfig.GrowingCalorimeterNames)
96 
97  kwargs.setdefault("SeedSamplingNames", flags.CaloRecGPU.ActiveConfig.GrowingSeedSamplingNames)
98 
99  kwargs.setdefault("SeedThresholdOnEorAbsEinSigma", flags.CaloRecGPU.ActiveConfig.SeedThreshold)
100  kwargs.setdefault("NeighborThresholdOnEorAbsEinSigma", flags.CaloRecGPU.ActiveConfig.GrowThreshold)
101  kwargs.setdefault("CellThresholdOnEorAbsEinSigma", flags.CaloRecGPU.ActiveConfig.TermThreshold)
102 
103  kwargs.setdefault("SeedCutsInAbsE", flags.CaloRecGPU.ActiveConfig.UseAbsSeedThreshold)
104  kwargs.setdefault("NeighborCutsInAbsE", flags.CaloRecGPU.ActiveConfig.UseAbsGrowThreshold)
105  kwargs.setdefault("CellCutsInAbsE", flags.CaloRecGPU.ActiveConfig.UseAbsTermThreshold)
106 
107  kwargs.setdefault("TwoGaussianNoise", flags.CaloRecGPU.ActiveConfig.doTwoGaussianNoise)
108 
109  kwargs.setdefault("SeedCutsInT", flags.CaloRecGPU.ActiveConfig.doTimeCut)
110  kwargs.setdefault("CutOOTseed", flags.CaloRecGPU.ActiveConfig.doTimeCut and flags.CaloRecGPU.ActiveConfig.extendTimeCut)
111  kwargs.setdefault("UseTimeCutUpperLimit", flags.CaloRecGPU.ActiveConfig.useUpperLimitForTimeCut)
112  kwargs.setdefault("TimeCutUpperLimit", flags.CaloRecGPU.ActiveConfig.timeCutUpperLimit)
113 
114  kwargs.setdefault("SeedThresholdOnTAbs", flags.CaloRecGPU.ActiveConfig.GrowingTimeCutSeedThreshold)
115 
116  kwargs.setdefault("TreatL1PredictedCellsAsGood", flags.CaloRecGPU.ActiveConfig.GrowingTreatL1PredictedCellsAsGood)
117 
118  kwargs.setdefault("XTalkEM2", flags.CaloRecGPU.ActiveConfig.xtalkEM2)
119  kwargs.setdefault("XTalkDeltaT", flags.CaloRecGPU.ActiveConfig.xtalkDeltaT)
120 
121  #The other cross-talk options are not supported yet.
122 
123  kwargs.setdefault("NeighborOption", flags.CaloRecGPU.ActiveConfig.GrowingNeighborOption)
124 
125  kwargs.setdefault("RestrictHECIWandFCalNeighbors", flags.CaloRecGPU.ActiveConfig.GrowingRestrictHECIWandFCalNeighbors)
126 
127  kwargs.setdefault("RestrictPSNeighbors", flags.CaloRecGPU.ActiveConfig.GrowingRestrictPSNeighbors)
128 
129  TAClusterMaker = CompFactory.TopoAutomatonClustering(name, **kwargs)
130  result.setPrivateTools(TAClusterMaker)
131  return result
132 

◆ TopoAutomatonSplitterToolCfg()

def CaloRecGPUConfig.TopoAutomatonSplitterToolCfg (   flags,
  name = "ClusterSplitter",
**  kwargs 
)

Definition at line 184 of file CaloRecGPUConfig.py.

184 def TopoAutomatonSplitterToolCfg(flags, name = "ClusterSplitter", **kwargs):
185  result=ComponentAccumulator()
186 
187  kwargs.setdefault("MeasureTimes", flags.CaloRecGPU.ActiveConfig.MeasureTimes)
188  kwargs.setdefault("TimeFileOutput", name + "Times.txt")
189 
190  kwargs.setdefault("NumberOfCellsCut", flags.CaloRecGPU.ActiveConfig.SplittingNumberOfCellsCut)
191  kwargs.setdefault("EnergyCut", flags.CaloRecGPU.ActiveConfig.SplittingEnergyCut)
192  kwargs.setdefault("SamplingNames", flags.CaloRecGPU.ActiveConfig.SplittingSamplingNames)
193  kwargs.setdefault("SecondarySamplingNames", flags.CaloRecGPU.ActiveConfig.SplittingSecondarySamplingNames)
194  kwargs.setdefault("ShareBorderCells", flags.CaloRecGPU.ActiveConfig.SplittingShareBorderCells)
195  kwargs.setdefault("EMShowerScale", flags.CaloRecGPU.ActiveConfig.SplittingEMShowerScale)
196  kwargs.setdefault("WeightingOfNegClusters", flags.CaloRecGPU.ActiveConfig.SplittingUseNegativeClusters)
197 
198  kwargs.setdefault("TreatL1PredictedCellsAsGood", flags.CaloRecGPU.ActiveConfig.SplittingTreatL1PredictedCellsAsGood)
199 
200  kwargs.setdefault("NeighborOption", flags.CaloRecGPU.ActiveConfig.SplittingNeighborOption)
201  kwargs.setdefault("RestrictHECIWandFCalNeighbors", flags.CaloRecGPU.ActiveConfig.SplittingRestrictHECIWandFCalNeighbors)
202  kwargs.setdefault("RestrictPSNeighbors", flags.CaloRecGPU.ActiveConfig.GPUSplittingRestrictPSNeighbors)
203  #Since the CPU version does not restrict this!
204 
205  Splitter = CompFactory.TopoAutomatonSplitting(name, **kwargs)
206  result.setPrivateTools(Splitter)
207  return result
208 
python.LArElecCalibDBConfig.LArElecCalibDBCfg
def LArElecCalibDBCfg(flags, condObjs)
Definition: LArElecCalibDBConfig.py:47
CaloRecGPUConfig.DefaultClusterMomentsCalculatorToolCfg
def DefaultClusterMomentsCalculatorToolCfg(flags, instantiateForTrigger, name="TopoMoments", **kwargs)
Definition: CaloRecGPUConfig.py:255
python.CaloTopoClusterConfig.caloTopoCoolFolderCfg
def caloTopoCoolFolderCfg(flags)
Definition: CaloTopoClusterConfig.py:7
CaloRecGPUConfig.DefaultClusterSplittingToolCfg
def DefaultClusterSplittingToolCfg(flags, name="TopoSplitter", **kwargs)
Definition: CaloRecGPUConfig.py:209
python.JetAnalysisCommon.ComponentAccumulator
ComponentAccumulator
Definition: JetAnalysisCommon.py:302
CaloRecGPUConfig.ComparedToolsToPlot
def ComparedToolsToPlot(tool_ref, tool_test, prefix, match_in_energy=False, match_without_shared=False, match_perfectly=False)
Definition: CaloRecGPUConfig.py:9
CaloRecGPUConfig.DefaultCalibMomentsToolCfg
def DefaultCalibMomentsToolCfg(flags, name="TopoCalibMoments", **kwargs)
Definition: CaloRecGPUConfig.py:373
CaloRecGPUConfig.MatchingOptions
def MatchingOptions(min_similarity=0.50, terminal_weight=250., grow_weight=500., seed_weight=1000.)
Definition: CaloRecGPUConfig.py:12
GenericMonitoringTool
Definition: GenericMonitoringTool.h:51
CaloRecGPUConfig.GPUCaloTopoClusterCfg
def GPUCaloTopoClusterCfg(flags, instantiateForTrigger, cellsname, clustersname=None, clustersnapname="CaloTopoClusters", name="HybridClusterProcessor", PlotterTool=None, addAsPrimary=True, ReallyUseGPUTools=True)
Definition: CaloRecGPUConfig.py:485
CaloRecGPUConfig.TopoAutomatonClusteringToolCfg
def TopoAutomatonClusteringToolCfg(flags, name="TopoAutomatonClustering", **kwargs)
Definition: CaloRecGPUConfig.py:89
python.CaloNoiseCondAlgConfig.CaloNoiseCondAlgCfg
def CaloNoiseCondAlgCfg(flags, noisetype="totalNoise")
Definition: CaloNoiseCondAlgConfig.py:11
CaloBadChanToolConfig.CaloBadChanToolCfg
def CaloBadChanToolCfg(flags, **kwargs)
Definition: CaloBadChanToolConfig.py:8
CaloRecGPUConfig.CellsCounterCPUToolCfg
def CellsCounterCPUToolCfg(flags, cellsname, name="CPUCounts", **kwargs)
Definition: CaloRecGPUConfig.py:315
CaloRecGPUConfig.GPUClusterMomentsCalculatorToolCfg
def GPUClusterMomentsCalculatorToolCfg(flags, name="GPUTopoMoments", **kwargs)
Definition: CaloRecGPUConfig.py:234
CaloRecGPUConfig.CellsCounterGPUToolCfg
def CellsCounterGPUToolCfg(flags, name="GPUCounts", **kwargs)
Definition: CaloRecGPUConfig.py:329
CaloRecGPUConfig.BasicConstantDataExporterToolCfg
def BasicConstantDataExporterToolCfg(flags, name="ConstantDataExporter", **kwargs)
Definition: CaloRecGPUConfig.py:15
CaloRecGPUConfig.ClusterInfoCalcToolCfg
def ClusterInfoCalcToolCfg(flags, name="GPUClusterInfoCalculator", do_cut=True, **kwargs)
Definition: CaloRecGPUConfig.py:73
LArGMConfig.LArGMCfg
def LArGMCfg(flags)
Definition: LArGMConfig.py:8
python.OutputStreamConfig.addToESD
def addToESD(flags, itemOrList, **kwargs)
Definition: OutputStreamConfig.py:173
TCS::join
std::string join(const std::vector< std::string > &v, const char c=',')
Definition: Trigger/TrigT1/L1Topo/L1TopoCommon/Root/StringUtils.cxx:10
CaloRecGPUConfig.BasicAthenaClusterImporterToolCfg
def BasicAthenaClusterImporterToolCfg(flags, cellsname, name="ClusterImporter", **kwargs)
Definition: CaloRecGPUConfig.py:42
CaloRecGPUConfig.GPUOutputToolCfg
def GPUOutputToolCfg(flags, name="GPUOutput", **kwargs)
Definition: CaloRecGPUConfig.py:64
MatchingOptions
Definition: CaloGPUClusterAndCellDataMonitorOptions.h:355
python.OutputStreamConfig.addToAOD
def addToAOD(flags, itemOrList, **kwargs)
Definition: OutputStreamConfig.py:188
CaloRecGPUConfig.PlotterToolCfg
def PlotterToolCfg(flags, cellsname, name="PlotterMonitoring", **kwargs)
Definition: CaloRecGPUConfig.py:350
CaloRecGPUConfig.SingleToolToPlot
def SingleToolToPlot(tool_name, prefix)
Definition: CaloRecGPUConfig.py:6
CaloRecGPUConfig.CPUOutputToolCfg
def CPUOutputToolCfg(flags, cellsname, name="CPUOutput", **kwargs)
Definition: CaloRecGPUConfig.py:55
CaloRecGPUConfig.DefaultTopoClusterLocalCalibToolsCfg
def DefaultTopoClusterLocalCalibToolsCfg(flags, instantiateForTrigger, prefix='')
Definition: CaloRecGPUConfig.py:407
CaloRecGPUConfig.BasicEventDataExporterToolCfg
def BasicEventDataExporterToolCfg(flags, cellsname, name="EventDataExporter", **kwargs)
Definition: CaloRecGPUConfig.py:26
CaloRecGPUConfig.AthenaClusterAndMomentsImporterToolCfg
def AthenaClusterAndMomentsImporterToolCfg(flags, cellsname, instantiateForTrigger, name="ClusterAndMomentsImporter", **kwargs)
Definition: CaloRecGPUConfig.py:288
CaloRecGPUConfig.DefaultTopologicalClusteringToolCfg
def DefaultTopologicalClusteringToolCfg(flags, cellsname, name="TopoClusterMaker", **kwargs)
Definition: CaloRecGPUConfig.py:133
CaloRecGPUConfig.MomentsDumperToolCfg
def MomentsDumperToolCfg(flags, name="MomentsDumper", **kwargs)
Definition: CaloRecGPUConfig.py:342
CaloRecGPUConfig.TopoAutomatonSplitterToolCfg
def TopoAutomatonSplitterToolCfg(flags, name="ClusterSplitter", **kwargs)
Definition: CaloRecGPUConfig.py:184
TileGMConfig.TileGMCfg
def TileGMCfg(flags)
Definition: TileGMConfig.py:7
Generated on Mon Sep 29 2025 22:00:17 for ATLAS Offline Software by   doxygen 1.8.18