ATLAS Offline Software
Functions | Variables
python.AsgAnalysisAlgorithmsTest Namespace Reference

Functions

def makeOverlapSequence (dataType)
 
def makeEventAlgorithmsSequence (dataType)
 
def makeGeneratorAlgorithmsSequence (dataType)
 
def pileupConfigFiles (dataType)
 
def makePileupSequence ()
 

Variables

bool forceEGammaFullSimConfig = True
 

Function Documentation

◆ makeEventAlgorithmsSequence()

def python.AsgAnalysisAlgorithmsTest.makeEventAlgorithmsSequence (   dataType)

Definition at line 153 of file AsgAnalysisAlgorithmsTest.py.

153 def makeEventAlgorithmsSequence (dataType) :
154 
155  # Config:
156  GRLFiles = ['GoodRunsLists/data16_13TeV/20180129/data16_13TeV.periodAllYear_DetStatus-v89-pro21-01_DQDefects-00-02-04_PHYS_StandardGRL_All_Good_25ns.xml']
157 
158  algSeq = AlgSequence()
159 
160  # Set up the systematics loader/handler service:
161  sysService = createService( 'CP::SystematicsSvc', 'SystematicsSvc', sequence = algSeq )
162  sysService.sigmaRecommended = 1
163  createService( 'CP::SelectionNameSvc', 'SelectionNameSvc', sequence = algSeq )
164 
165  # Include, and then set up the pileup analysis sequence:
166  from AsgAnalysisAlgorithms.EventSelectionAnalysisSequence import \
167  makeEventSelectionAnalysisSequence
168  eventSelectionSequence = \
169  makeEventSelectionAnalysisSequence( dataType, userGRLFiles=GRLFiles )
170  algSeq += eventSelectionSequence
171 
172  # Set up an ntuple to check the job with:
173  treeMaker = createAlgorithm( 'CP::TreeMakerAlg', 'TreeMaker' )
174  treeMaker.TreeName = 'events'
175  algSeq += treeMaker
176  ntupleMaker = createAlgorithm( 'CP::AsgxAODNTupleMakerAlg', 'NTupleMaker' )
177  ntupleMaker.TreeName = 'events'
178  ntupleMaker.Branches = [
179  'EventInfo.runNumber -> runNumber',
180  'EventInfo.eventNumber -> eventNumber',
181  'Electrons.eta -> el_eta',
182  'Electrons.phi -> el_phi',
183  ]
184  algSeq += ntupleMaker
185  treeFiller = createAlgorithm( 'CP::TreeFillerAlg', 'TreeFiller' )
186  treeFiller.TreeName = 'events'
187  algSeq += treeFiller
188 
189  return algSeq
190 
191 

◆ makeGeneratorAlgorithmsSequence()

def python.AsgAnalysisAlgorithmsTest.makeGeneratorAlgorithmsSequence (   dataType)

Definition at line 192 of file AsgAnalysisAlgorithmsTest.py.

192 def makeGeneratorAlgorithmsSequence (dataType) :
193 
194  algSeq = AlgSequence()
195 
196  # Set up the systematics loader/handler service:
197  sysService = createService( 'CP::SystematicsSvc', 'SystematicsSvc', sequence = algSeq )
198  sysService.sigmaRecommended = 1
199  createService( 'CP::SelectionNameSvc', 'SelectionNameSvc', sequence = algSeq )
200 
201  # Include, and then set up the pileup analysis sequence:
202  prwfiles, lumicalcfiles = pileupConfigFiles(dataType)
203 
204  from AsgAnalysisAlgorithms.PileupAnalysisSequence import \
205  makePileupAnalysisSequence
206  pileupSequence = makePileupAnalysisSequence(
207  dataType,
208  userPileupConfigs=prwfiles,
209  userLumicalcFiles=lumicalcfiles,
210  )
211  pileupSequence.configure( inputName = {}, outputName = {} )
212  algSeq += pileupSequence
213 
214  # Include, and then set up the generator analysis sequence:
215  from AsgAnalysisAlgorithms.GeneratorAnalysisSequence import \
216  makeGeneratorAnalysisSequence
217  generatorSequence = makeGeneratorAnalysisSequence( dataType, saveCutBookkeepers=True, runNumber=284500, cutBookkeepersSystematics=True )
218  algSeq += generatorSequence
219 
220  # Set up an ntuple to check the job with:
221  treeMaker = createAlgorithm( 'CP::TreeMakerAlg', 'TreeMaker' )
222  treeMaker.TreeName = 'events'
223  algSeq += treeMaker
224  ntupleMaker = createAlgorithm( 'CP::AsgxAODNTupleMakerAlg', 'NTupleMaker' )
225  ntupleMaker.TreeName = 'events'
226  ntupleMaker.Branches = [
227  'EventInfo.runNumber -> runNumber',
228  'EventInfo.eventNumber -> eventNumber',
229  'EventInfo.generatorWeight_%SYS% -> generatorWeight_%SYS%',
230  ]
231  algSeq += ntupleMaker
232  treeFiller = createAlgorithm( 'CP::TreeFillerAlg', 'TreeFiller' )
233  treeFiller.TreeName = 'events'
234  algSeq += treeFiller
235 
236  return algSeq
237 

◆ makeOverlapSequence()

def python.AsgAnalysisAlgorithmsTest.makeOverlapSequence (   dataType)

Definition at line 13 of file AsgAnalysisAlgorithmsTest.py.

13 def makeOverlapSequence (dataType) :
14  algSeq = AlgSequence()
15 
16  # Skip events with no primary vertex:
17  algSeq += createAlgorithm( 'CP::VertexSelectionAlg',
18  'PrimaryVertexSelectorAlg' )
19  algSeq.PrimaryVertexSelectorAlg.VertexContainer = 'PrimaryVertices'
20  algSeq.PrimaryVertexSelectorAlg.MinVertices = 1
21 
22  # Set up the systematics loader/handler service:
23  sysService = createService( 'CP::SystematicsSvc', 'SystematicsSvc', sequence = algSeq )
24  sysService.sigmaRecommended = 1
25  createService( 'CP::SelectionNameSvc', 'SelectionNameSvc', sequence = algSeq )
26 
27  # Include, and then set up the pileup analysis sequence:
28  prwfiles, lumicalcfiles = pileupConfigFiles(dataType)
29 
30  from AsgAnalysisAlgorithms.PileupAnalysisSequence import \
31  makePileupAnalysisSequence
32  pileupSequence = makePileupAnalysisSequence(
33  dataType,
34  userPileupConfigs=prwfiles,
35  userLumicalcFiles=lumicalcfiles,
36  )
37  pileupSequence.configure( inputName = {}, outputName = {} )
38  algSeq += pileupSequence
39 
40  # Include, and then set up the electron analysis sequence:
41  from EgammaAnalysisAlgorithms.ElectronAnalysisSequence import \
42  makeElectronAnalysisSequence
43  electronSequence = makeElectronAnalysisSequence(
44  dataType, 'LooseLHElectron.Loose_VarRad',
45  recomputeLikelihood = True,
46  forceFullSimConfig = forceEGammaFullSimConfig)
47  electronSequence.configure( inputName = 'Electrons',
48  outputName = 'AnalysisElectrons_%SYS%' )
49  algSeq += electronSequence
50 
51  # Include, and then set up the photon analysis sequence:
52  from EgammaAnalysisAlgorithms.PhotonAnalysisSequence import \
53  makePhotonAnalysisSequence
54  photonSequence = makePhotonAnalysisSequence(
55  dataType, 'Tight.FixedCutTight',
56  forceFullSimConfig = forceEGammaFullSimConfig)
57  photonSequence.configure( inputName = 'Photons',
58  outputName = 'AnalysisPhotons_%SYS%' )
59  algSeq += photonSequence
60 
61  # Include, and then set up the muon analysis algorithm sequence:
62  from MuonAnalysisAlgorithms.MuonAnalysisSequence import makeMuonAnalysisSequence
63  muonSequence = makeMuonAnalysisSequence( dataType, 'Tight.Loose_VarRad' )
64  muonSequence.configure( inputName = 'Muons',
65  outputName = 'AnalysisMuons_%SYS%' )
66  algSeq += muonSequence
67 
68  # Include, and then set up the jet analysis algorithm sequence:
69  jetContainer = 'AntiKt4EMPFlowJets'
70  from JetAnalysisAlgorithms.JetAnalysisSequence import makeJetAnalysisSequence
71  jetSequence = makeJetAnalysisSequence( dataType, jetContainer )
72  jetSequence.configure( inputName = jetContainer,
73  outputName = 'AnalysisJets_%SYS%' )
74  algSeq += jetSequence
75 
76  # TODO: disabled for now
77  # Include, and then set up the tau analysis algorithm sequence:
78  # from TauAnalysisAlgorithms.TauAnalysisSequence import makeTauAnalysisSequence
79  # tauSequence = makeTauAnalysisSequence( dataType, 'Tight' )
80  # tauSequence.configure( inputName = 'TauJets',
81  # outputName = 'AnalysisTauJets_%SYS%' )
82  # algSeq += tauSequence
83 
84  # Include, and then set up the overlap analysis algorithm sequence:
85  from AsgAnalysisAlgorithms.OverlapAnalysisSequence import \
86  makeOverlapAnalysisSequence
87  overlapSequence = makeOverlapAnalysisSequence( dataType, doTaus=False, enableCutflow=True )
88  overlapSequence.configure(
89  inputName = {
90  'electrons' : 'AnalysisElectrons_%SYS%',
91  'photons' : 'AnalysisPhotons_%SYS%',
92  'muons' : 'AnalysisMuons_%SYS%',
93  'jets' : 'AnalysisJets_%SYS%',
94  # 'taus' : 'AnalysisTauJets_%SYS%'
95  },
96  outputName = {
97  'electrons' : 'AnalysisElectronsOR_%SYS%',
98  'photons' : 'AnalysisPhotonsOR_%SYS%',
99  'muons' : 'AnalysisMuonsOR_%SYS%',
100  'jets' : 'AnalysisJetsOR_%SYS%',
101  # 'taus' : 'AnalysisTauJetsOR_%SYS%'
102  } )
103  algSeq += overlapSequence
104 
105  # Set up an ntuple to check the job with:
106  treeMaker = createAlgorithm( 'CP::TreeMakerAlg', 'TreeMaker' )
107  treeMaker.TreeName = 'particles'
108  algSeq += treeMaker
109  ntupleMaker = createAlgorithm( 'CP::AsgxAODNTupleMakerAlg', 'NTupleMaker' )
110  ntupleMaker.TreeName = 'particles'
111  ntupleMaker.Branches = [
112  'EventInfo.runNumber -> runNumber',
113  'EventInfo.eventNumber -> eventNumber',
114  'AnalysisElectrons_%SYS%.eta -> el_%SYS%_eta',
115  'AnalysisElectrons_%SYS%.phi -> el_%SYS%_phi',
116  'AnalysisElectrons_%SYS%.pt -> el_%SYS%_pt',
117  'AnalysisElectronsOR_%SYS%.eta -> el_OR_%SYS%_eta',
118  'AnalysisElectronsOR_%SYS%.phi -> el_OR_%SYS%_phi',
119  'AnalysisElectronsOR_%SYS%.pt -> el_OR_%SYS%_pt',
120  'AnalysisPhotons_%SYS%.eta -> ph_%SYS%_eta',
121  'AnalysisPhotons_%SYS%.phi -> ph_%SYS%_phi',
122  'AnalysisPhotons_%SYS%.pt -> ph_%SYS%_pt',
123  'AnalysisPhotonsOR_%SYS%.eta -> ph_OR_%SYS%_eta',
124  'AnalysisPhotonsOR_%SYS%.phi -> ph_OR_%SYS%_phi',
125  'AnalysisPhotonsOR_%SYS%.pt -> ph_OR_%SYS%_pt',
126  'AnalysisMuons_%SYS%.eta -> mu_%SYS%_eta',
127  'AnalysisMuons_%SYS%.phi -> mu_%SYS%_phi',
128  'AnalysisMuons_%SYS%.pt -> mu_%SYS%_pt',
129  'AnalysisMuonsOR_%SYS%.eta -> mu_OR_%SYS%_eta',
130  'AnalysisMuonsOR_%SYS%.phi -> mu_OR_%SYS%_phi',
131  'AnalysisMuonsOR_%SYS%.pt -> mu_OR_%SYS%_pt',
132  'AnalysisJets_%SYS%.eta -> jet_%SYS%_eta',
133  'AnalysisJets_%SYS%.phi -> jet_%SYS%_phi',
134  'AnalysisJets_%SYS%.pt -> jet_%SYS%_pt',
135  'AnalysisJetsOR_%SYS%.eta -> jet_OR_%SYS%_eta',
136  'AnalysisJetsOR_%SYS%.phi -> jet_OR_%SYS%_phi',
137  'AnalysisJetsOR_%SYS%.pt -> jet_OR_%SYS%_pt',
138  # 'AnalysisTauJets_%SYS%.eta -> tau_%SYS%_eta',
139  # 'AnalysisTauJets_%SYS%.phi -> tau_%SYS%_phi',
140  # 'AnalysisTauJets_%SYS%.pt -> tau_%SYS%_pt',
141  # 'AnalysisTauJetsOR_%SYS%.eta -> tau_OR_%SYS%_eta',
142  # 'AnalysisTauJetsOR_%SYS%.phi -> tau_OR_%SYS%_phi',
143  # 'AnalysisTauJetsOR_%SYS%.pt -> tau_OR_%SYS%_pt'
144  ]
145  algSeq += ntupleMaker
146  treeFiller = createAlgorithm( 'CP::TreeFillerAlg', 'TreeFiller' )
147  treeFiller.TreeName = 'particles'
148  algSeq += treeFiller
149 
150  return algSeq
151 
152 

◆ makePileupSequence()

def python.AsgAnalysisAlgorithmsTest.makePileupSequence ( )

Definition at line 268 of file AsgAnalysisAlgorithmsTest.py.

268 def makePileupSequence () :
269  # NB: test only run for MC
270 
271  algSeq = AlgSequence()
272 
273  # Set up the systematics loader/handler service:
274  sysService = createService( 'CP::SystematicsSvc', 'SystematicsSvc', sequence = algSeq )
275  sysService.sigmaRecommended = 1
276  createService( 'CP::SelectionNameSvc', 'SelectionNameSvc', sequence = algSeq )
277 
278  # Include, and then set up the pileup analysis sequence:
279  prwfiles, lumicalcfiles = pileupConfigFiles("mc")
280 
281  from AsgAnalysisAlgorithms.PileupAnalysisSequence import \
282  makePileupAnalysisSequence
283  pileupSequence = makePileupAnalysisSequence(
284  "mc",
285  userPileupConfigs=prwfiles,
286  userLumicalcFiles=lumicalcfiles,
287  )
288  pileupSequence.configure( inputName = {}, outputName = {} )
289  algSeq += pileupSequence
290 
291 
292  # Set up an ntuple to check the job with:
293  treeMaker = createAlgorithm( 'CP::TreeMakerAlg', 'TreeMaker' )
294  treeMaker.TreeName = 'events'
295  algSeq += treeMaker
296  ntupleMaker = createAlgorithm( 'CP::AsgxAODNTupleMakerAlg', 'NTupleMaker' )
297  ntupleMaker.TreeName = 'events'
298  ntupleMaker.Branches = [
299  'EventInfo.runNumber -> runNumber',
300  'EventInfo.eventNumber -> eventNumber',
301  # we currently don't have any pileup calib files for this test
302  # 'EventInfo.PileupWeight_%SYS% -> pileupWeight_%SYS%',
303  ]
304  algSeq += ntupleMaker
305  treeFiller = createAlgorithm( 'CP::TreeFillerAlg', 'TreeFiller' )
306  treeFiller.TreeName = 'events'
307  algSeq += treeFiller
308 
309  return algSeq

◆ pileupConfigFiles()

def python.AsgAnalysisAlgorithmsTest.pileupConfigFiles (   dataType) 
Return the PRW config files and lumicalc files for tests

Definition at line 238 of file AsgAnalysisAlgorithmsTest.py.

238 def pileupConfigFiles(dataType):
239  """Return the PRW config files and lumicalc files for tests"""
240  if isinstance(dataType, str):
241  if dataType == "mc":
242  dataType = DataType.FullSim
243  elif dataType == "afii":
244  dataType = DataType.FastSim
245  else:
246  dataType = DataType(dataType)
247 
248  if dataType is DataType.Data:
249  prwfiles = []
250  lumicalcfiles = []
251  else:
252  if dataType is DataType.FullSim:
253  lumicalcfiles = [
254  "GoodRunsLists/data15_13TeV/20170619/PHYS_StandardGRL_All_Good_25ns_276262-284484_OflLumi-13TeV-008.root",
255  "GoodRunsLists/data16_13TeV/20180129/PHYS_StandardGRL_All_Good_25ns_297730-311481_OflLumi-13TeV-009.root",
256  ]
257  prwfiles = [
258  "PileupReweighting/mc20_common/mc20a.284500.physlite.prw.v1.root"
259  ]
260  else:
261  lumicalcfiles = [
262  "GoodRunsLists/data18_13TeV/20190318/ilumicalc_histograms_None_348885-364292_OflLumi-13TeV-010.root",
263  ]
264  # use fast sim case to test running without PRW
265  prwfiles = []
266  return prwfiles, lumicalcfiles
267 

Variable Documentation

◆ forceEGammaFullSimConfig

bool python.AsgAnalysisAlgorithmsTest.forceEGammaFullSimConfig = True

Definition at line 11 of file AsgAnalysisAlgorithmsTest.py.

python.PhotonAnalysisSequence.makePhotonAnalysisSequence
def makePhotonAnalysisSequence(dataType, workingPoint, deepCopyOutput=False, shallowViewOutput=True, postfix='', crackVeto=False, enableCleaning=True, cleaningAllowLate=False, recomputeIsEM=False, ptSelectionOutput=False, enableCutflow=False, enableKinematicHistograms=False, defineSystObjectLinks=False, forceFullSimConfig=False)
Definition: PhotonAnalysisSequence.py:16
python.GeneratorAnalysisSequence.makeGeneratorAnalysisSequence
def makeGeneratorAnalysisSequence(dataType, saveCutBookkeepers=False, runNumber=0, cutBookkeepersSystematics=False)
Definition: GeneratorAnalysisSequence.py:7
python.AsgAnalysisAlgorithmsTest.makeEventAlgorithmsSequence
def makeEventAlgorithmsSequence(dataType)
Definition: AsgAnalysisAlgorithmsTest.py:153
python.AlgSequence.AlgSequence
AlgSequence
Definition: PhysicsAnalysis/D3PDTools/AnaAlgorithm/python/AlgSequence.py:7
python.EventSelectionAnalysisSequence.makeEventSelectionAnalysisSequence
def makeEventSelectionAnalysisSequence(dataType, runPrimaryVertexSelection=True, runEventCleaning=False, minTracksPerVertex=2, userGRLFiles=[], userSelectionFlags=['DFCommonJets_eventClean_LooseBad'], userInvertFlags=[0])
Definition: EventSelectionAnalysisSequence.py:10
python.AsgAnalysisAlgorithmsTest.makeOverlapSequence
def makeOverlapSequence(dataType)
Definition: AsgAnalysisAlgorithmsTest.py:13
python.JetAnalysisSequence.makeJetAnalysisSequence
def makeJetAnalysisSequence(dataType, jetCollection, postfix='', deepCopyOutput=False, shallowViewOutput=True, runGhostMuonAssociation=True, enableCutflow=False, enableKinematicHistograms=False, defineSystObjectLinks=False, **kwargs)
Definition: JetAnalysisSequence.py:21
python.DualUseConfig.createService
def createService(typeName, serviceName, sequence=None)
Definition: DualUseConfig.py:127
python.DualUseConfig.createAlgorithm
def createAlgorithm(typeName, instanceName)
Definition: DualUseConfig.py:56
python.AsgAnalysisAlgorithmsTest.makeGeneratorAlgorithmsSequence
def makeGeneratorAlgorithmsSequence(dataType)
Definition: AsgAnalysisAlgorithmsTest.py:192
python.AsgAnalysisAlgorithmsTest.makePileupSequence
def makePileupSequence()
Definition: AsgAnalysisAlgorithmsTest.py:268
python.AsgAnalysisAlgorithmsTest.pileupConfigFiles
def pileupConfigFiles(dataType)
Definition: AsgAnalysisAlgorithmsTest.py:238
python.MuonAnalysisSequence.makeMuonAnalysisSequence
def makeMuonAnalysisSequence(dataType, workingPoint, deepCopyOutput=False, shallowViewOutput=True, postfix='', ptSelectionOutput=False, trackSelection=True, maxEta=2.7, qualitySelectionOutput=True, enableCutflow=False, enableKinematicHistograms=False, isRun3Geo=False, defineSystObjectLinks=False)
Definition: MuonAnalysisSequence.py:8
python.OverlapAnalysisSequence.makeOverlapAnalysisSequence
def makeOverlapAnalysisSequence(dataType, inputLabel='', outputLabel='passesOR', linkOverlapObjects=False, doEleEleOR=False, doElectrons=True, doMuons=True, doJets=True, doTaus=True, doTauAntiTauJetOR=False, doPhotons=True, doFatJets=False, enableUserPriority=False, bJetLabel='', antiTauIDTauLabel='', antiTauLabel='', antiTauBJetLabel='', boostedLeptons=False, postfix='', shallowViewOutput=True, enableCutflow=False)
Definition: OverlapAnalysisSequence.py:7
python.PileupAnalysisSequence.makePileupAnalysisSequence
def makePileupAnalysisSequence(dataType, campaign=None, files=None, useDefaultConfig=False, userLumicalcFiles=None, userPileupConfigs=None)
Definition: PileupAnalysisSequence.py:12
python.ElectronAnalysisSequence.makeElectronAnalysisSequence
def makeElectronAnalysisSequence(dataType, workingPoint, deepCopyOutput=False, shallowViewOutput=True, postfix='', recomputeLikelihood=False, chargeIDSelection=False, isolationCorrection=False, crackVeto=False, ptSelectionOutput=False, trackSelection=True, enableCutflow=False, enableKinematicHistograms=False, defineSystObjectLinks=False, forceFullSimConfig=False)
Definition: ElectronAnalysisSequence.py:13
Generated on Mon Jul 8 2024 22:24:37 for ATLAS Offline Software by   doxygen 1.8.18