Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
PFCfg.py
Go to the documentation of this file.
1 # Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
2 from AthenaConfiguration.ComponentFactory import CompFactory
3 from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
4 from AthenaConfiguration.Enums import LHCPeriod
5 
6 def PFTrackSelectorAlgCfg(inputFlags,algName,useCaching=True):
7  PFTrackSelectorFactory=CompFactory.PFTrackSelector
8  PFTrackSelector=PFTrackSelectorFactory(algName)
9 
10  result = ComponentAccumulator()
11 
12  from TrackToCalo.TrackToCaloConfig import ParticleCaloExtensionToolCfg
13  pcExtensionTool = result.popToolsAndMerge(ParticleCaloExtensionToolCfg(inputFlags))
14 
15  eflowTrackCaloExtensionTool=CompFactory.eflowTrackCaloExtensionTool
16  TrackCaloExtensionTool=eflowTrackCaloExtensionTool(TrackCaloExtensionTool=pcExtensionTool)
17  if (not useCaching):
18  TrackCaloExtensionTool.PFParticleCache = ""
19 
20  PFTrackSelector.trackExtrapolatorTool = TrackCaloExtensionTool
21 
22  from InDetConfig.InDetTrackSelectionToolConfig import PFTrackSelectionToolCfg
23  PFTrackSelector.trackSelectionTool = result.popToolsAndMerge(PFTrackSelectionToolCfg(inputFlags))
24 
25  # P->T conversion extra dependencies
26  if inputFlags.Detector.GeometryITk:
27  PFTrackSelector.ExtraInputs = {
28  ("InDetDD::SiDetectorElementCollection", "ConditionStore+ITkPixelDetectorElementCollection"),
29  ("InDetDD::SiDetectorElementCollection", "ConditionStore+ITkStripDetectorElementCollection"),
30  }
31  else:
32  PFTrackSelector.ExtraInputs = {
33  ("InDetDD::SiDetectorElementCollection", "ConditionStore+PixelDetectorElementCollection"),
34  ("InDetDD::SiDetectorElementCollection", "ConditionStore+SCT_DetectorElementCollection"),
35  ("InDetDD::TRT_DetElementContainer", "ConditionStore+TRT_DetElementContainer"),
36  }
37 
38  result.addEventAlgo (PFTrackSelector, primary=True)
39 
40  return result
41 
42 def getPFClusterSelectorTool(inputFlags,clustersin,calclustersin,algName):
43 
44  PFClusterSelectorToolFactory = CompFactory.PFClusterSelectorTool
45  PFClusterSelectorTool = PFClusterSelectorToolFactory(algName)
46  if clustersin is not None:
47  PFClusterSelectorTool.clustersName = clustersin
48  if calclustersin is not None:
49  PFClusterSelectorTool.calClustersName = calclustersin
50 
51  if inputFlags.PF.useTruthCheating:
52  if inputFlags.PF.useTrackClusterTruthMatching:
53  PFClusterSelectorTool.CaloClusterReadDecorHandleKey_NLeadingTruthParticles = "CaloTopoClusters." + inputFlags.Calo.TopoCluster.CalibrationHitDecorationName
54 
55  if inputFlags.PF.useTopoTowers:
56  PFClusterSelectorTool.clustersName="CaloTopoSignal"
57  PFClusterSelectorTool.calClustersName="CaloCalTopoSignal"
58 
59  return PFClusterSelectorTool
60 
61 def getPFTrackClusterMatchingTool(inputFlags,matchCut,distanceType,clusterPositionType,name):
62  PFTrackClusterMatchingTool = CompFactory.PFTrackClusterMatchingTool
63  MatchingTool = PFTrackClusterMatchingTool(name)
64  MatchingTool.ClusterPositionType = clusterPositionType
65  MatchingTool.DistanceType = distanceType
66  MatchingTool.MatchCut = matchCut*matchCut
67  return MatchingTool
68 
69 
70 def getPFCellLevelSubtractionTool(inputFlags,toolName):
71  PFCellLevelSubtractionToolFactory = CompFactory.PFSubtractionTool
72  PFCellLevelSubtractionTool = PFCellLevelSubtractionToolFactory(toolName,useNNEnergy = inputFlags.PF.useMLEOverP)
73 
74  if inputFlags.GeoModel.Run <= LHCPeriod.Run3:
75  eflowCellEOverPTool_Run2_mc20_JetETMiss = CompFactory.eflowCellEOverPTool_Run2_mc20_JetETMiss
76  PFCellLevelSubtractionTool.eflowCellEOverPTool = eflowCellEOverPTool_Run2_mc20_JetETMiss()
77  else:
78  if inputFlags.PF.useLegacyEOverPRun4:
79  eflowCellEOverPTool_mc12_HLLHC = CompFactory.eflowCellEOverPTool_mc12_HLLHC
80  PFCellLevelSubtractionTool.eflowCellEOverPTool = eflowCellEOverPTool_mc12_HLLHC ()
81  else:
82  PFCellEOverPTool = CompFactory.PFCellEOverPTool
83  PFCellLevelSubtractionTool.eflowCellEOverPTool = PFCellEOverPTool("PFCellEOverPTool", referenceFileLocation = inputFlags.PF.EOverP_CellOrdering_ReferenceLocation)
84  #this should always be false for any reference derived, except eflowCellEOverPTool_mc12_HLLHC.h or eflowCellEOverPTool_Run2_mc20_JetETMiss.h
85  PFCellLevelSubtractionTool.useLegacyEBinIndex=False
86 
87  if(inputFlags.PF.EOverPMode):
88  PFCellLevelSubtractionTool.CalcEOverP = True
89  PFCellLevelSubtractionTool.nClusterMatchesToUse = -1
90  else:
91  PFCellLevelSubtractionTool.nClusterMatchesToUse = 1
92 
93  if(inputFlags.PF.EOverPMode):
94  PFCellLevelSubtractionTool.PFTrackClusterMatchingTool = getPFTrackClusterMatchingTool(inputFlags,0.2,"EtaPhiSquareDistance","PlainEtaPhi","CalObjBldMatchingTool")
95  else:
96  PFCellLevelSubtractionTool.PFTrackClusterMatchingTool = getPFTrackClusterMatchingTool(inputFlags,1.64,"EtaPhiSquareSignificance","GeomCenterEtaPhi","CalObjBldMatchingTool")
97 
98  PFCellLevelSubtractionTool.PFTrackClusterMatchingTool_015 = getPFTrackClusterMatchingTool(inputFlags,0.15,"EtaPhiSquareDistance","PlainEtaPhi","MatchingTool_Pull_015")
99  PFCellLevelSubtractionTool.PFTrackClusterMatchingTool_02 = getPFTrackClusterMatchingTool(inputFlags,0.2,"EtaPhiSquareDistance","PlainEtaPhi","MatchingTool_Pull_02")
100 
101  if inputFlags.PF.useMLEOverP:
102  PFEnergyPredictorTool = CompFactory.PFEnergyPredictorTool("PFCellLevelEnergyPredcictorTool",ModelPath = inputFlags.PF.EOverP_NN_Model)
103  PFCellLevelSubtractionTool.NNEnergyPredictorTool = PFEnergyPredictorTool
104  PFCellLevelSubtractionTool.addCPData = inputFlags.PF.addCPData
105 
106  if inputFlags.PF.useTruthCheating:
107  if inputFlags.PF.useTrackClusterTruthMatching:
108  PFCellLevelSubtractionTool.CaloClusterReadDecorHandleKey_NLeadingTruthParticles = "CaloTopoClusters." + inputFlags.Calo.TopoCluster.CalibrationHitDecorationName
109  PFCellLevelSubtractionTool.useTrackClusterTruthMatching=True
110 
111  if inputFlags.PF.useTruthForChargedShowerSubtraction:
112  PFCellLevelSubtractionTool.useTruthForChargedShowerSubtraction = True
113  PFCellLevelSubtractionTool.PFSimulateTruthShowerTool = CompFactory.PFSimulateTruthShowerTool("PFSimulateTruthShowerTool")
114 
115  return PFCellLevelSubtractionTool
116 
117 def getPFRecoverSplitShowersTool(inputFlags,toolName):
118  PFRecoverSplitShowersToolFactory = CompFactory.PFSubtractionTool
119  PFRecoverSplitShowersTool = PFRecoverSplitShowersToolFactory(toolName,useNNEnergy = inputFlags.PF.useMLEOverP)
120 
121  if inputFlags.GeoModel.Run <= LHCPeriod.Run3:
122  eflowCellEOverPTool_Run2_mc20_JetETMiss = CompFactory.eflowCellEOverPTool_Run2_mc20_JetETMiss
123  PFRecoverSplitShowersTool.eflowCellEOverPTool = eflowCellEOverPTool_Run2_mc20_JetETMiss("eflowCellEOverPTool_Run2_mc20_JetETMiss_Recover")
124  else:
125  if inputFlags.PF.useLegacyEOverPRun4:
126  eflowCellEOverPTool_mc12_HLLHC = CompFactory.eflowCellEOverPTool_mc12_HLLHC
127  PFRecoverSplitShowersTool.eflowCellEOverPTool = eflowCellEOverPTool_mc12_HLLHC ()
128  else:
129  PFCellEOverPTool = CompFactory.PFCellEOverPTool
130  PFRecoverSplitShowersTool.eflowCellEOverPTool = PFCellEOverPTool("PFCellEOverPTool_Recover", referenceFileLocation = inputFlags.PF.EOverP_CellOrdering_ReferenceLocation)
131  #this should always be false for any reference derived, except eflowCellEOverPTool_mc12_HLLHC.h or eflowCellEOverPTool_Run2_mc20_JetETMiss.h
132  PFRecoverSplitShowersTool.useLegacyEBinIndex=False
133 
134  PFRecoverSplitShowersTool.RecoverSplitShowers = True
135 
136  if inputFlags.PF.useMLEOverP:
137  PFEnergyPredictorTool = CompFactory.PFEnergyPredictorTool("PFRecoverSplitShowersEnergyPredcictorTool",ModelPath = inputFlags.PF.EOverP_NN_Model)
138  PFRecoverSplitShowersTool.NNEnergyPredictorTool = PFEnergyPredictorTool
139 
140  return PFRecoverSplitShowersTool
141 
142 def getPFMomentCalculatorTool(inputFlags, momentsToCalculateList):
143  result=ComponentAccumulator()
144  PFMomentCalculatorToolFactory = CompFactory.PFMomentCalculatorTool
145  PFMomentCalculatorTool = PFMomentCalculatorToolFactory("PFMomentCalculatorTool")
146 
147  from CaloRec.CaloTopoClusterConfig import getTopoMoments
148  PFClusterMomentsMaker = result.popToolsAndMerge(getTopoMoments(inputFlags))
149  if (len(momentsToCalculateList) > 0):
150  PFClusterMomentsMaker.MomentsNames = momentsToCalculateList
151  PFMomentCalculatorTool.CaloClusterMomentsMaker = PFClusterMomentsMaker
152 
153  PFClusterCollectionTool = CompFactory.PFClusterCollectionTool
154  PFMomentCalculatorTool.PFClusterCollectionTool = PFClusterCollectionTool("PFClusterCollectionTool")
155 
156  if(inputFlags.PF.useCalibHitTruthClusterMoments):
157  PFMomentCalculatorTool.UseCalibHitTruth=True
158  from CaloRec.CaloTopoClusterConfig import getTopoCalibMoments
159  PFMomentCalculatorTool.CaloCalibClusterMomentsMaker2 = getTopoCalibMoments(inputFlags)
160 
161  result.setPrivateTools(PFMomentCalculatorTool)
162  return result
163 
164 def getPFLCCalibTool(inputFlags):
165  PFLCCalibTool = CompFactory.PFLCCalibTool
166  PFLCCalibTool = PFLCCalibTool("PFLCCalibTool")
167 
168  PFClusterCollectionTool = CompFactory.PFClusterCollectionTool
169  PFLCCalibTool.eflowRecClusterCollectionTool = PFClusterCollectionTool("PFClusterCollectionTool_LCCalib")
170  PFLCCalibTool.UseLocalWeight = False
171 
172  from CaloRec.CaloTopoClusterConfig import getTopoClusterLocalCalibTools
173  lcCalibToolList = getTopoClusterLocalCalibTools(inputFlags)
174 
175  PFLCCalibTool.CaloClusterLocalCalib=lcCalibToolList[0]
176  PFLCCalibTool.CaloClusterLocalCalibOOCC=lcCalibToolList[1]
177  PFLCCalibTool.CaloClusterLocalCalibOOCCPi0=lcCalibToolList[2]
178  PFLCCalibTool.CaloClusterLocalCalibDM=lcCalibToolList[3]
179 
180  return PFLCCalibTool
181 
182 def getChargedFlowElementCreatorAlgorithm(inputFlags,chargedFlowElementOutputName,nameSuffix="",eflowCaloObjectContainerName="eflowCaloObjects"):
183  FlowElementChargedCreatorAlgorithmFactory = CompFactory.PFChargedFlowElementCreatorAlgorithm
184  FlowElementChargedCreatorAlgorithm = FlowElementChargedCreatorAlgorithmFactory("PFChargedFlowElementCreatorAlgorithm"+nameSuffix)
185  FlowElementChargedCreatorAlgorithm.eflowCaloObjectContainerName = eflowCaloObjectContainerName
186  if chargedFlowElementOutputName:
187  FlowElementChargedCreatorAlgorithm.FlowElementOutputName=chargedFlowElementOutputName
188  if(inputFlags.PF.EOverPMode):
189  FlowElementChargedCreatorAlgorithm.FlowElementOutputName="EOverPChargedParticleFlowObjects"
190  FlowElementChargedCreatorAlgorithm.EOverPMode = True
191  if inputFlags.PF.addCPData:
192  FlowElementChargedCreatorAlgorithm.addCPData = True
193 
194  return FlowElementChargedCreatorAlgorithm
195 
196 def getNeutralFlowElementCreatorAlgorithm(inputFlags,neutralFlowElementOutputName,nameSuffix="",eflowCaloObjectContainerName="eflowCaloObjects"):
197  FlowElementNeutralCreatorAlgorithmFactory = CompFactory.PFNeutralFlowElementCreatorAlgorithm
198  FlowElementNeutralCreatorAlgorithm = FlowElementNeutralCreatorAlgorithmFactory("PFNeutralFlowElementCreatorAlgorithm"+nameSuffix)
199  FlowElementNeutralCreatorAlgorithm.eflowCaloObjectContainerName = eflowCaloObjectContainerName
200  if neutralFlowElementOutputName:
201  FlowElementNeutralCreatorAlgorithm.FlowElementOutputName=neutralFlowElementOutputName
202  if(inputFlags.PF.EOverPMode):
203  FlowElementNeutralCreatorAlgorithm.FlowElementOutputName="EOverPNeutralParticleFlowObjects"
204  if(inputFlags.PF.useCalibHitTruthClusterMoments and inputFlags.PF.addClusterMoments):
205  FlowElementNeutralCreatorAlgorithm.UseCalibHitTruth=True
206  if inputFlags.PF.addCPData:
207  FlowElementNeutralCreatorAlgorithm.addCPData = True
208 
209  return FlowElementNeutralCreatorAlgorithm
210 
211 def getLCNeutralFlowElementCreatorAlgorithm(inputFlags,neutralFlowElementOutputName):
212  LCFlowElementNeutralCreatorAlgorithmFactory = CompFactory.PFLCNeutralFlowElementCreatorAlgorithm
213  LCFlowElementNeutralCreatorAlgorithm = LCFlowElementNeutralCreatorAlgorithmFactory("PFLCNeutralFlowElementCreatorAlgorithm")
214  if neutralFlowElementOutputName:
215  LCFlowElementNeutralCreatorAlgorithm.FELCOutputName=neutralFlowElementOutputName
216  if(inputFlags.PF.EOverPMode):
217  LCFlowElementNeutralCreatorAlgorithm.FEInputContainerName="EOverPNeutralParticleFlowObjects"
218  LCFlowElementNeutralCreatorAlgorithm.FELCOutputName="EOverPLCNeutralParticleFlowObjects"
219 
220  return LCFlowElementNeutralCreatorAlgorithm
221 
222 def getEGamFlowElementAssocAlgorithm(inputFlags, algName="", **kwargs):
223 
224  kwargs.setdefault("neutral_FE_cont_name", "")
225  kwargs.setdefault("charged_FE_cont_name", "")
226  kwargs.setdefault("doTCC", False)
227  kwargs.setdefault("useGlobal", False)
228 
229  PFEGamFlowElementLinkerAlgorithmFactory=CompFactory.PFEGamFlowElementAssoc
230  if not algName:
231  algName = "PFEGamFlowElementAssoc"
232  PFEGamFlowElementLinkerAlgorithm=PFEGamFlowElementLinkerAlgorithmFactory(algName)
233 
234  #set an an alternate name if needed
235  #this uses some gaudi core magic, namely that you can change the name of the handle as it is a callable attribute, despite the attribute not being explicitly listed in the header
236  #for a key of type SG::WriteDecorHandle<xAOD::SomeCont>someKey{this,"SpecificContainerName","myContainerName","other-labels"}
237  #setting algorithm.SpecificContainerName="myNewContainerName" changes parameter "myContainerName"
238  #(also applies to ReadHandles)
239  if kwargs['neutral_FE_cont_name']:
240  PFEGamFlowElementLinkerAlgorithm.JetEtMissNeutralFlowElementContainer = kwargs['neutral_FE_cont_name']
241 
242  if kwargs['charged_FE_cont_name']:
243  PFEGamFlowElementLinkerAlgorithm.JetEtMissChargedFlowElementContainer = kwargs['charged_FE_cont_name']
244 
245  if kwargs['doTCC']:
246  # ReadHandles to change
247  PFEGamFlowElementLinkerAlgorithm.JetEtMissNeutralFlowElementContainer="TrackCaloClustersNeutral"
248  PFEGamFlowElementLinkerAlgorithm.JetEtMissChargedFlowElementContainer="TrackCaloClustersCharged"
249 
250  #Now to change the writeHandles
251  # first the Electron -> FE links
252  EL_NFE_Link=str(PFEGamFlowElementLinkerAlgorithm.ElectronNeutralFEDecorKey)
253  PFEGamFlowElementLinkerAlgorithm.ElectronNeutralFEDecorKey=EL_NFE_Link.replace("FELinks","TCCLinks")
254  EL_CFE_Link=str(PFEGamFlowElementLinkerAlgorithm.ElectronChargedFEDecorKey)
255  PFEGamFlowElementLinkerAlgorithm.ElectronChargedFEDecorKey=EL_CFE_Link.replace("FELinks","TCCLinks")
256  #then the converse case (FE -> Electron)
257 
258  PFEGamFlowElementLinkerAlgorithm.ChargedFEElectronDecorKey="TrackCaloClustersCharged.TCC_ElectronLinks"
259  PFEGamFlowElementLinkerAlgorithm.NeutralFEElectronDecorKey="TrackCaloClustersNeutral.TCC_ElectronLinks"
260 
261 
262  # first the Photon -> FE links
263  PH_NFE_Link=str(PFEGamFlowElementLinkerAlgorithm.PhotonNeutralFEDecorKey)
264  PFEGamFlowElementLinkerAlgorithm.PhotonNeutralFEDecorKey=PH_NFE_Link.replace("FELinks","TCCLinks")
265  PH_CFE_Link=str(PFEGamFlowElementLinkerAlgorithm.PhotonChargedFEDecorKey)
266  PFEGamFlowElementLinkerAlgorithm.PhotonChargedFEDecorKey=PH_CFE_Link.replace("FELinks","TCCLinks")
267  #then the converse case (FE -> Photons)
268 
269  PFEGamFlowElementLinkerAlgorithm.ChargedFEPhotonDecorKey="TrackCaloClustersCharged.TCC_PhotonLinks"
270  PFEGamFlowElementLinkerAlgorithm.NeutralFEPhotonDecorKey="TrackCaloClustersNeutral.TCC_PhotonLinks"
271 
272  if kwargs['useGlobal']:
273  # ReadHandles to change
274  PFEGamFlowElementLinkerAlgorithm.JetEtMissNeutralFlowElementContainer="GlobalNeutralParticleFlowObjects"
275  PFEGamFlowElementLinkerAlgorithm.JetEtMissChargedFlowElementContainer="GlobalChargedParticleFlowObjects"
276 
277  #Now to change the writeHandles
278  # first the Electron -> FE links
279  EL_NFE_Link=str(PFEGamFlowElementLinkerAlgorithm.ElectronNeutralFEDecorKey)
280  PFEGamFlowElementLinkerAlgorithm.ElectronNeutralFEDecorKey=EL_NFE_Link.replace("FELinks","GlobalFELinks")
281  EL_CFE_Link=str(PFEGamFlowElementLinkerAlgorithm.ElectronChargedFEDecorKey)
282  PFEGamFlowElementLinkerAlgorithm.ElectronChargedFEDecorKey=EL_CFE_Link.replace("FELinks","GlobalFELinks")
283  #then the converse case (FE -> Electron)
284 
285  PFEGamFlowElementLinkerAlgorithm.ChargedFEElectronDecorKey="GlobalChargedParticleFlowObjects.GlobalFE_ElectronLinks"
286  PFEGamFlowElementLinkerAlgorithm.NeutralFEElectronDecorKey="GlobalNeutralParticleFlowObjects.GLobalFE_ElectronLinks"
287 
288 
289  # first the Photon -> FE links
290  PH_NFE_Link=str(PFEGamFlowElementLinkerAlgorithm.PhotonNeutralFEDecorKey)
291  PFEGamFlowElementLinkerAlgorithm.PhotonNeutralFEDecorKey=PH_NFE_Link.replace("FELinks","GlobalFELinks")
292  PH_CFE_Link=str(PFEGamFlowElementLinkerAlgorithm.PhotonChargedFEDecorKey)
293  PFEGamFlowElementLinkerAlgorithm.PhotonChargedFEDecorKey=PH_CFE_Link.replace("FELinks","GlobalFELinks")
294  #then the converse case (FE -> Photons)
295 
296  PFEGamFlowElementLinkerAlgorithm.ChargedFEPhotonDecorKey="GlobalChargedParticleFlowObjects.TCC_PhotonLinks"
297  PFEGamFlowElementLinkerAlgorithm.NeutralFEPhotonDecorKey="GlobalNeutralParticleFlowObjects.TCC_PhotonLinks"
298 
299 
300 
301  return PFEGamFlowElementLinkerAlgorithm
302 
303 def getMuonFlowElementAssocAlgorithm(inputFlags, algName="", **kwargs):
304 
305  kwargs.setdefault("neutral_FE_cont_name", "")
306  kwargs.setdefault("charged_FE_cont_name", "")
307  kwargs.setdefault("LinkNeutralFEClusters", True)
308  kwargs.setdefault("doTCC", False)
309  kwargs.setdefault("useGlobal", False)
310 
311  useMuonTopoClusters = False
312  from AthenaConfiguration.Enums import ProductionStep
313  # set 'useMuonTopoClusters=True' if running on AOD, as do not have calorimeter cells for CaloCalTopoCluster
314  # Assumes that in production workflows this only happens in "Derivation" or if DQ environment is AOD
315  if inputFlags.Common.ProductionStep in [ProductionStep.Derivation] or inputFlags.DQ.Environment == "AOD":
316  useMuonTopoClusters = True
317 
318 
319  PFMuonFlowElementLinkerAlgorithmFactory=CompFactory.PFMuonFlowElementAssoc
320  if not algName:
321  algName="PFMuonFlowElementAssoc"
322  PFMuonFlowElementLinkerAlgorithm=PFMuonFlowElementLinkerAlgorithmFactory(algName)
323 
324  #set an an alternate name if needed
325  #this uses some gaudi core magic, namely that you can change the name of the handle as it is a callable attribute, despite the attribute not being explicitly listed in the header as such
326  #for a key of type SG::WriteDecorHandle<xAOD::SomeCont>someKey{this,"SpecificContainerName","myContainerName","other-labels"}
327  #setting algorithm.SpecificContainerName="myNewContainerName" changes parameter "myContainerName" to "myNewContainerName"
328  if kwargs['neutral_FE_cont_name']:
329  #update the readhandle
330  PFMuonFlowElementLinkerAlgorithm.JetEtMissNeutralFlowElementContainer = kwargs['neutral_FE_cont_name']
331  #update the write handle for the link
332 
333  if kwargs['charged_FE_cont_name']:
334  PFMuonFlowElementLinkerAlgorithm.JetEtMissChargedFlowElementContainer = kwargs['charged_FE_cont_name']
335 
336  PFMuonFlowElementLinkerAlgorithm.LinkNeutralFEClusters = kwargs['LinkNeutralFEClusters']
337  PFMuonFlowElementLinkerAlgorithm.useMuonTopoClusters = useMuonTopoClusters
338 
339  #prototype on AOD with the linkers already defined - so need to rename the output links to something besides their default name.
340 
341  #Track Calo cluster (TCC) specific configuration. Input is differently named FE container, and in the AOD step specifically
342  if kwargs['doTCC']:
343  #input containers are TrackCaloClustersCharged and TrackCaloClustersNeutral, so rename them
344  #service_key="StoreGateSvc+"
345  service_key=""
346  PFMuonFlowElementLinkerAlgorithm.JetEtMissChargedFlowElementContainer=service_key+"TrackCaloClustersCharged"
347  PFMuonFlowElementLinkerAlgorithm.JetEtMissNeutralFlowElementContainer=service_key+"TrackCaloClustersNeutral"
348 
349  #Output
350  #rename the FE_MuonLinks as TCC_MuonLinks
351  #rename output containers
352  PFMuonFlowElementLinkerAlgorithm.MuonContainer_chargedFELinks=service_key+"Muons.chargedTCCLinks"
353  PFMuonFlowElementLinkerAlgorithm.MuonContainer_neutralFELinks=service_key+"Muons.neutralTCCLinks"
354  PFMuonFlowElementLinkerAlgorithm.JetETMissNeutralFlowElementContainer_FE_MuonLinks=service_key+"TrackCaloClustersNeutral.TCC_MuonLinks"
355  PFMuonFlowElementLinkerAlgorithm.JetETMissChargedFlowElements_FE_MuonLinks=service_key+"TrackCaloClustersCharged.TCC_MuonLinks"
356  PFMuonFlowElementLinkerAlgorithm.FlowElementContainer_ChargedFE_ennergy_matched_muon="TrackCaloClustersCharged.TCC_efrac_matched_muon"
357  # several variables relating to Neutral Flow Elements/TCCs to Muons for debug. perhaps at some point these should be removed by default
358  PFMuonFlowElementLinkerAlgorithm.FlowElementContainer_nMatchedMuons="TrackCaloClustersNeutral.TCC_nMatchedMuons"
359  PFMuonFlowElementLinkerAlgorithm.FlowElementContainer_FE_efrac_matched_muon="TrackCaloClustersNeutral.TCC_efrac_matched_muon"
360 
361  PFMuonFlowElementLinkerAlgorithm.MuonContainer_muon_efrac_matched_FE="Muons.muon_efrac_matched_TCC"
362  # this is because the algorithm adds this debug container which we don't need
363  PFMuonFlowElementLinkerAlgorithm.MuonContainer_ClusterInfo_deltaR="Muons.deltaR_muon_clus_TCCalg"
364 
365  if kwargs['useGlobal']:
366  PFMuonFlowElementLinkerAlgorithm.JetEtMissChargedFlowElementContainer="GlobalChargedParticleFlowObjects"
367  PFMuonFlowElementLinkerAlgorithm.JetEtMissNeutralFlowElementContainer="GlobalNeutralParticleFlowObjects"
368 
369  PFMuonFlowElementLinkerAlgorithm.MuonContainer_chargedFELinks="Muons.chargedGlobalFELinks"
370  PFMuonFlowElementLinkerAlgorithm.MuonContainer_neutralFELinks="Muons.neutralGlobalFELinks"
371 
372  PFMuonFlowElementLinkerAlgorithm.JetETMissNeutralFlowElementContainer_FE_MuonLinks="GlobalNeutralParticleFlowObjects.GlobalFE_MuonLinks"
373  PFMuonFlowElementLinkerAlgorithm.JetETMissChargedFlowElements_FE_MuonLinks="GlobalChargedParticleFlowObjects.GlobalFE_MuonLinks"
374  PFMuonFlowElementLinkerAlgorithm.FlowElementContainer_ChargedFE_ennergy_matched_muon="GlobalChargedParticleFlowObjects.GlobalFE_efrac_matched_muon"
375 
376  PFMuonFlowElementLinkerAlgorithm.FlowElementContainer_nMatchedMuons="GlobalNeutralParticleFlowObjects.GlobalFE_nMatchedMuons"
377  PFMuonFlowElementLinkerAlgorithm.FlowElementContainer_FE_efrac_matched_muon="GlobalNeutralParticleFlowObjects.GlobalFE_efrac_matched_muon"
378 
379  PFMuonFlowElementLinkerAlgorithm.MuonContainer_muon_efrac_matched_FE="Muons.muon_efrac_matched_GlobalFE"
380  # this is because the algorithm adds this debug container which we don't need
381  PFMuonFlowElementLinkerAlgorithm.MuonContainer_ClusterInfo_deltaR="Muons.deltaR_muon_clus_GlobalFEalg"
382 
383  if kwargs['LinkNeutralFEClusters'] and not useMuonTopoClusters:
384  # We dereference links to cells, so make sure we have the
385  # dependency.
386  PFMuonFlowElementLinkerAlgorithm.ExtraInputs.add(('CaloCellContainer', inputFlags.Egamma.Keys.Input.CaloCells))
387 
388  if kwargs['LinkNeutralFEClusters']:
389  if kwargs['doTCC']:
390  # since the cells are deleted on AOD, if you try to run the link between NFE and Muon on AOD, it will crash. Terminate to catch this.
391  # This is a known bug to rectify soon
392  from AthenaCommon.Logging import logging
393  msg=logging.getLogger("PFCfg.py::getMuonFlowElementAssocAlgorithm")
394  msg.error("Neutral FE from AOD configured to be linked with Muon. This link will fail due to missing CaloCells in the AOD")
395  msg.info("Terminating job")
396  exit(0)
397 
398 
399  return PFMuonFlowElementLinkerAlgorithm
400 
401 def getTauFlowElementAssocAlgorithm(inputFlags, algName="", **kwargs):
402 
403  kwargs.setdefault("neutral_FE_cont_name", "")
404  kwargs.setdefault("charged_FE_cont_name", "")
405  kwargs.setdefault("doTCC", False)
406  kwargs.setdefault("useGlobal", False)
407 
408  PFTauFlowElementLinkerAlgorithmFactory=CompFactory.PFTauFlowElementAssoc
409  if not algName:
410  algName = "PFTauFlowElementAssoc"
411 
412  PFTauFlowElementLinkerAlgorithm=PFTauFlowElementLinkerAlgorithmFactory(algName)
413 
414  #set an an alternate name if needed
415  #this uses some gaudi core magic, namely that you can change the name of the handle as it is a callable attribute, despite the attribute not being explicitly listed in the header
416  #for a key of type SG::WriteDecorHandle<xAOD::SomeCont>someKey{this,"SpecificContainerName","myContainerName","other-labels"}
417  #setting algorithm.SpecificContainerName="myNewContainerName" changes parameter "myContainerName"
418  #(also applies to ReadHandles)
419  if kwargs['neutral_FE_cont_name']:
420  PFTauFlowElementLinkerAlgorithm.JetETMissNeutralFlowElementContainer = kwargs['neutral_FE_cont_name']
421 
422  if kwargs['charged_FE_cont_name']:
423  PFTauFlowElementLinkerAlgorithm.JetETMissChargedFlowElementContainer = kwargs['charged_FE_cont_name']
424 
425  if kwargs['doTCC']:
426  PFTauFlowElementLinkerAlgorithm.JetETMissNeutralFlowElementContainer="TrackCaloClustersNeutral"
427  PFTauFlowElementLinkerAlgorithm.JetETMissChargedFlowElementContainer="TrackCaloClustersCharged"
428 
429  PFTauFlowElementLinkerAlgorithm.TauNeutralFEDecorKey="TauJets.neutralTCCLinks"
430  PFTauFlowElementLinkerAlgorithm.TauChargedFEDecorKey="TauJets.chargedTCCLinks"
431 
432  PFTauFlowElementLinkerAlgorithm.NeutralFETauDecorKey="TrackCaloClustersNeutral.TCC_TauLinks"
433  PFTauFlowElementLinkerAlgorithm.ChargedFETauDecorKey="TrackCaloClustersCharged.TCC_TauLinks"
434 
435  #This allows to set the links on the global particle flow containers created by JetPFlowSelectionAlg in JetRecTools
436  if kwargs['useGlobal']:
437  PFTauFlowElementLinkerAlgorithm.JetETMissNeutralFlowElementContainer="GlobalNeutralParticleFlowObjects"
438  PFTauFlowElementLinkerAlgorithm.JetETMissChargedFlowElementContainer="GlobalChargedParticleFlowObjects"
439 
440  PFTauFlowElementLinkerAlgorithm.TauNeutralFEDecorKey="TauJets.neutralGlobalFELinks"
441  PFTauFlowElementLinkerAlgorithm.TauChargedFEDecorKey="TauJets.chargedGlobalFELinks"
442 
443  PFTauFlowElementLinkerAlgorithm.NeutralFETauDecorKey="GlobalNeutralParticleFlowObjects.GlobalFE_TauLinks"
444  PFTauFlowElementLinkerAlgorithm.ChargedFETauDecorKey="GlobalChargedParticleFlowObjects.GlobalFE_TauLinks"
445 
446  return PFTauFlowElementLinkerAlgorithm
447 
448 def getOfflinePFAlgorithm(inputFlags):
449  result=ComponentAccumulator()
450 
451  PFAlgorithm=CompFactory.PFAlgorithm
452  PFAlgorithm = PFAlgorithm("PFAlgorithm")
453 
454 
455  if inputFlags.HeavyIon.Egamma.doSubtractedClusters:
456  PFAlgorithm.PFClusterSelectorTool = getPFClusterSelectorTool(inputFlags,inputFlags.HeavyIon.Egamma.UncalibCaloTopoCluster,inputFlags.HeavyIon.Egamma.CaloTopoCluster,"PFClusterSelectorTool")
457  else:
458  topoClustersName="CaloTopoClusters"
459  PFAlgorithm.PFClusterSelectorTool = getPFClusterSelectorTool(inputFlags,topoClustersName,"CaloCalTopoClusters","PFClusterSelectorTool")
460 
461  PFAlgorithm.SubtractionToolList = [getPFCellLevelSubtractionTool(inputFlags,"PFCellLevelSubtractionTool")]
462 
463  if(False is inputFlags.PF.EOverPMode and False is inputFlags.PF.useTruthCheating):
464  PFAlgorithm.SubtractionToolList += [getPFRecoverSplitShowersTool(inputFlags,"PFRecoverSplitShowersTool")]
465 
466  PFMomentCalculatorTools=result.popToolsAndMerge(getPFMomentCalculatorTool(inputFlags,[]))
467  PFAlgorithm.BaseToolList = [PFMomentCalculatorTools]
468  PFAlgorithm.BaseToolList += [getPFLCCalibTool(inputFlags)]
469  result.addEventAlgo(PFAlgorithm)
470  return result
471 
472 def PFGlobalFlowElementLinkingCfg(inputFlags, **kwargs):
473  result=ComponentAccumulator()
474 
475  kwargs.setdefault("useGlobal", True)
476 
477  result.addEventAlgo(getTauFlowElementAssocAlgorithm(inputFlags, algName="PFTauGlobalFlowElementAssoc", **kwargs))
478  result.addEventAlgo(getMuonFlowElementAssocAlgorithm(inputFlags, algName="PFMuonGlobalFlowElementAssoc", **kwargs))
479  result.addEventAlgo(getEGamFlowElementAssocAlgorithm(inputFlags, algName="PFEGamGlobalFlowElementAssoc", **kwargs))
480  return result
PFCfg.getOfflinePFAlgorithm
def getOfflinePFAlgorithm(inputFlags)
Definition: PFCfg.py:448
PFAlgorithm
Definition: PFAlgorithm.h:22
python.CaloTopoClusterConfig.getTopoClusterLocalCalibTools
def getTopoClusterLocalCalibTools(flags)
Definition: CaloTopoClusterConfig.py:29
PFCfg.getPFLCCalibTool
def getPFLCCalibTool(inputFlags)
Definition: PFCfg.py:164
python.InDetTrackSelectionToolConfig.PFTrackSelectionToolCfg
def PFTrackSelectionToolCfg(flags, name="PFTrackSelectionTool", **kwargs)
Definition: InDetTrackSelectionToolConfig.py:83
eflowTrackCaloExtensionTool
Inherits from eflowTrackExtrapolatorBaseAlgTool and AthAlgTool.
Definition: eflowTrackCaloExtensionTool.h:38
python.JetAnalysisCommon.ComponentAccumulator
ComponentAccumulator
Definition: JetAnalysisCommon.py:302
PFCfg.getPFClusterSelectorTool
def getPFClusterSelectorTool(inputFlags, clustersin, calclustersin, algName)
Definition: PFCfg.py:42
PFTrackClusterMatchingTool
This is the tool, which inherits from AthAlgTool, which clients can use for track-cluster matching.
Definition: PFTrackClusterMatchingTool.h:32
python.CaloTopoClusterConfig.getTopoCalibMoments
def getTopoCalibMoments(flags)
Definition: CaloTopoClusterConfig.py:200
PFLCCalibTool
This tool can either use a series of CaloClusterProcessor to calibrate the modified xAOD::CaloCluster...
Definition: PFLCCalibTool.h:22
PFCfg.getNeutralFlowElementCreatorAlgorithm
def getNeutralFlowElementCreatorAlgorithm(inputFlags, neutralFlowElementOutputName, nameSuffix="", eflowCaloObjectContainerName="eflowCaloObjects")
Definition: PFCfg.py:196
PFCfg.getPFRecoverSplitShowersTool
def getPFRecoverSplitShowersTool(inputFlags, toolName)
Definition: PFCfg.py:117
PFClusterCollectionTool
Inherits from IPFClusterCollectionTool and AthAlgTool.
Definition: PFClusterCollectionTool.h:14
PFCellEOverPTool
Class to store reference e/p mean and widths, as well as reference energy density radial profile fit ...
Definition: PFCellEOverPTool.h:15
PFCfg.PFTrackSelectorAlgCfg
def PFTrackSelectorAlgCfg(inputFlags, algName, useCaching=True)
Definition: PFCfg.py:6
PFCfg.getPFMomentCalculatorTool
def getPFMomentCalculatorTool(inputFlags, momentsToCalculateList)
Definition: PFCfg.py:142
PFCfg.getChargedFlowElementCreatorAlgorithm
def getChargedFlowElementCreatorAlgorithm(inputFlags, chargedFlowElementOutputName, nameSuffix="", eflowCaloObjectContainerName="eflowCaloObjects")
Definition: PFCfg.py:182
PFCfg.getEGamFlowElementAssocAlgorithm
def getEGamFlowElementAssocAlgorithm(inputFlags, algName="", **kwargs)
Definition: PFCfg.py:222
calibdata.exit
exit
Definition: calibdata.py:236
PFCfg.getMuonFlowElementAssocAlgorithm
def getMuonFlowElementAssocAlgorithm(inputFlags, algName="", **kwargs)
Definition: PFCfg.py:303
PFCfg.getPFCellLevelSubtractionTool
def getPFCellLevelSubtractionTool(inputFlags, toolName)
Definition: PFCfg.py:70
PFCfg.getLCNeutralFlowElementCreatorAlgorithm
def getLCNeutralFlowElementCreatorAlgorithm(inputFlags, neutralFlowElementOutputName)
Definition: PFCfg.py:211
PFCfg.getTauFlowElementAssocAlgorithm
def getTauFlowElementAssocAlgorithm(inputFlags, algName="", **kwargs)
Definition: PFCfg.py:401
python.CaloTopoClusterConfig.getTopoMoments
def getTopoMoments(flags)
Definition: CaloTopoClusterConfig.py:96
if
if(febId1==febId2)
Definition: LArRodBlockPhysicsV0.cxx:567
eflowCellEOverPTool_Run2_mc20_JetETMiss
Class to store reference e/p mean and widths, as well as reference energy density radial profile fit ...
Definition: eflowCellEOverPTool_Run2_mc20_JetETMiss.h:24
str
Definition: BTagTrackIpAccessor.cxx:11
PFCfg.getPFTrackClusterMatchingTool
def getPFTrackClusterMatchingTool(inputFlags, matchCut, distanceType, clusterPositionType, name)
Definition: PFCfg.py:61
TrackToCaloConfig.ParticleCaloExtensionToolCfg
def ParticleCaloExtensionToolCfg(flags, name='ParticleCaloExtensionTool', **kwargs)
Definition: TrackToCaloConfig.py:10
PFCfg.PFGlobalFlowElementLinkingCfg
def PFGlobalFlowElementLinkingCfg(inputFlags, **kwargs)
Definition: PFCfg.py:472
Generated on Fri Mar 14 2025 21:16:32 for ATLAS Offline Software by   doxygen 1.8.18