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)
 
def GPUCaloTopoClusterCfg (flags, instantiateForTrigger, cellsname, clustersname=None, clustersnapname="CaloTopoClusters", name="HybridClusterProcessor", MonitorTool=None, MonitorCells=False, PlotterTool=None, addAsPrimary=True, ReallyUseGPUTools=True)
 

Function Documentation

◆ AthenaClusterAndMomentsImporterToolCfg()

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

Definition at line 287 of file CaloRecGPUConfig.py.

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

◆ 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 314 of file CaloRecGPUConfig.py.

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

◆ CellsCounterGPUToolCfg()

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

Definition at line 328 of file CaloRecGPUConfig.py.

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

◆ 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 372 of file CaloRecGPUConfig.py.

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

◆ DefaultClusterMomentsCalculatorToolCfg()

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

Definition at line 254 of file CaloRecGPUConfig.py.

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

◆ 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 
)

Definition at line 406 of file CaloRecGPUConfig.py.

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

Definition at line 484 of file CaloRecGPUConfig.py.

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

◆ 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 
239  kwargs.setdefault("WeightingOfNegClusters", flags.CaloRecGPU.ActiveConfig.MomentsUseAbsEnergy)
240 
241  kwargs.setdefault("MaxAxisAngle", flags.CaloRecGPU.ActiveConfig.MomentsMaxAxisAngle)
242 
243  kwargs.setdefault("TwoGaussianNoise", flags.CaloRecGPU.ActiveConfig.doTwoGaussianNoise)
244 
245  kwargs.setdefault("MinBadLArQuality", flags.CaloRecGPU.ActiveConfig.MomentsMinBadLArQuality)
246 
247  kwargs.setdefault("MinRLateral", flags.CaloRecGPU.ActiveConfig.MomentsMinRLateral)
248  kwargs.setdefault("MinLLongitudinal", flags.CaloRecGPU.ActiveConfig.MomentsMinLLongitudinal)
249 
250  GPUTopoMoments = CompFactory.GPUClusterInfoAndMomentsCalculator(name, **kwargs)
251  result.setPrivateTools(GPUTopoMoments)
252  return result
253 

◆ 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 341 of file CaloRecGPUConfig.py.

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

◆ PlotterToolCfg()

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

Definition at line 349 of file CaloRecGPUConfig.py.

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

◆ 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:254
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:372
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:53
CaloRecGPUConfig.GPUCaloTopoClusterCfg
def GPUCaloTopoClusterCfg(flags, instantiateForTrigger, cellsname, clustersname=None, clustersnapname="CaloTopoClusters", name="HybridClusterProcessor", MonitorTool=None, MonitorCells=False, PlotterTool=None, addAsPrimary=True, ReallyUseGPUTools=True)
Definition: CaloRecGPUConfig.py:484
CaloRecGPUConfig.DefaultTopoClusterLocalCalibToolsCfg
def DefaultTopoClusterLocalCalibToolsCfg(flags, instantiateForTrigger)
Definition: CaloRecGPUConfig.py:406
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:314
CaloRecGPUConfig.GPUClusterMomentsCalculatorToolCfg
def GPUClusterMomentsCalculatorToolCfg(flags, name="GPUTopoMoments", **kwargs)
Definition: CaloRecGPUConfig.py:234
CaloRecGPUConfig.CellsCounterGPUToolCfg
def CellsCounterGPUToolCfg(flags, name="GPUCounts", **kwargs)
Definition: CaloRecGPUConfig.py:328
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:127
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:142
CaloRecGPUConfig.PlotterToolCfg
def PlotterToolCfg(flags, cellsname, name="PlotterMonitoring", **kwargs)
Definition: CaloRecGPUConfig.py:349
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.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:287
CaloRecGPUConfig.DefaultTopologicalClusteringToolCfg
def DefaultTopologicalClusteringToolCfg(flags, cellsname, name="TopoClusterMaker", **kwargs)
Definition: CaloRecGPUConfig.py:133
CaloRecGPUConfig.MomentsDumperToolCfg
def MomentsDumperToolCfg(flags, name="MomentsDumper", **kwargs)
Definition: CaloRecGPUConfig.py:341
CaloRecGPUConfig.TopoAutomatonSplitterToolCfg
def TopoAutomatonSplitterToolCfg(flags, name="ClusterSplitter", **kwargs)
Definition: CaloRecGPUConfig.py:184
TileGMConfig.TileGMCfg
def TileGMCfg(flags)
Definition: TileGMConfig.py:7
Generated on Fri Jul 5 2024 22:12:30 for ATLAS Offline Software by   doxygen 1.8.18