5 from AnaAlgorithm.AlgSequence
import AlgSequence
6 from AnaAlgorithm.DualUseConfig
import createAlgorithm, addPrivateTool
7 from AsgAnalysisAlgorithms.AsgAnalysisAlgorithmsTest
import pileupConfigFiles
8 from AnalysisAlgorithmsConfig.ConfigSequence
import ConfigSequence
9 from AnalysisAlgorithmsConfig.ConfigAccumulator
import ConfigAccumulator, DataType
12 triggerChainsPerYear = {
13 '2015': [
'HLT_e24_lhmedium_L1EM20VH || HLT_e60_lhmedium || HLT_e120_lhloose',
'HLT_mu20_iloose_L1MU15 || HLT_mu40',
'HLT_2g20_tight'],
14 '2016': [
'HLT_e26_lhtight_nod0_ivarloose || HLT_e60_lhmedium_nod0 || HLT_e140_lhloose_nod0',
'HLT_mu26_ivarmedium || HLT_mu50',
'HLT_g35_loose_g25_loose'],
15 '2017': [
'HLT_e26_lhtight_nod0_ivarloose || HLT_e60_lhmedium_nod0 || HLT_e140_lhloose_nod0',
'HLT_2g22_tight_L12EM15VHI',
'HLT_mu50'],
16 '2018': [
'HLT_e26_lhtight_nod0_ivarloose || HLT_e60_lhmedium_nod0 || HLT_e140_lhloose_nod0',
'HLT_g35_medium_g25_medium_L12EM20VH',
'HLT_mu26_ivarmedium',
'HLT_2mu14'],
17 '2022': [
'HLT_e26_lhtight_ivarloose_L1EM22VHI || HLT_e60_lhmedium_L1EM22VHI || HLT_e140_lhloose_L1EM22VHI'],
22 'HLT_2e17_lhvloose_nod0'
24 tauTriggerChainsSF = {
25 '2015': [
'HLT_tau25_medium1_tracktwo',
'HLT_tau35_medium1_tracktwo'],
26 '2016': [
'HLT_tau25_medium1_tracktwo',
'HLT_tau35_medium1_tracktwo'],
27 '2017': [
'HLT_tau25_medium1_tracktwo',
'HLT_tau35_medium1_tracktwo'],
28 '2018': [
'HLT_tau25_medium1_tracktwoEF_OR_mediumRNN_tracktwoMVA',
'HLT_tau35_medium1_tracktwoEF_OR_mediumRNN_tracktwoMVA'],
32 exampleSelectionCuts = {
68 """add a uniformly filtered set of deep copies based on the
69 systematics dependent selection"""
71 if postfix[0] !=
'_' :
72 postfix =
'_' + postfix
75 unionalg =
createAlgorithm(
'CP::AsgUnionSelectionAlg',
'UnionSelectionAlg' + postfix)
76 unionalg.preselection = selection
77 unionalg.particles = inputContainer
78 unionalg.selectionDecoration =
'outputSelect'
80 ca.addEventAlgo(unionalg, algSeq.name
if algSeq
else None)
84 copyalg =
createAlgorithm(
'CP::AsgViewFromSelectionAlg',
'DeepCopyAlg' + postfix )
85 copyalg.input = inputContainer
86 copyalg.output = outputContainer
88 copyalg.selection = [
'outputSelect']
90 copyalg.selection = []
91 copyalg.deepCopy =
False
93 ca.addEventAlgo(copyalg, algSeq.name
if algSeq
else None)
98 def makeSequenceOld (dataType, algSeq, forCompare, isPhyslite, noSystematics, forceEGammaFullSimConfig=False) :
100 if isinstance(dataType, DataType):
102 DataType.Data:
'data',
103 DataType.FullSim:
'mc',
104 DataType.FastSim:
'afii',
110 from AnaAlgorithm.DualUseConfig
import isAthena, useComponentAccumulator
111 if isAthena
and useComponentAccumulator:
112 from AthenaConfiguration.ComponentAccumulator
import ComponentAccumulator
116 ca.addSequence(algSeq)
121 from AsgAnalysisAlgorithms.CommonServiceSequence
import makeCommonServiceSequence
122 makeCommonServiceSequence (algSeq, runSystematics =
not noSystematics, ca=ca)
126 campaign, files, prwfiles, lumicalcfiles =
None,
None,
None,
None
127 useDefaultConfig =
False
130 prwfiles, lumicalcfiles =
pileupConfigFiles( {
'data': DataType.Data,
'mc': DataType.FullSim,
'afii': DataType.FastSim}.
get(dataType,
None) )
132 from AsgAnalysisAlgorithms.PileupAnalysisSequence
import \
133 makePileupAnalysisSequence
138 useDefaultConfig=useDefaultConfig,
139 userPileupConfigs=prwfiles,
140 userLumicalcFiles=lumicalcfiles,
142 pileupSequence.configure( inputName = {}, outputName = {} )
146 for element
in pileupSequence.getGaudiConfig2Algorithms():
147 ca.addEventAlgo(element, caSeq)
149 algSeq += pileupSequence
152 vars += [
'EventInfo.runNumber -> runNumber',
153 'EventInfo.eventNumber -> eventNumber', ]
154 if dataType !=
'data':
155 vars += [
'EventInfo.mcChannelNumber -> mcChannelNumber' ]
156 if not isPhyslite
and dataType
in [
'mc']:
157 vars += [
'EventInfo.PileupWeight_%SYS% -> weight_pileup_%SYS%' ]
158 if not isPhyslite
and dataType
in [
'mc',
'afii']:
159 vars += [
'EventInfo.beamSpotWeight -> weight_beamspot' ]
163 from AsgAnalysisAlgorithms.EventSelectionAnalysisSequence
import makeEventSelectionAnalysisSequence
166 runPrimaryVertexSelection=
True,
167 runEventCleaning=
True,
169 eventCleaningSequence.configure( inputName = {}, outputName = {} )
171 for element
in eventCleaningSequence.getGaudiConfig2Algorithms():
172 ca.addEventAlgo(element, caSeq)
174 algSeq += eventCleaningSequence
178 from JetAnalysisAlgorithms.JetAnalysisSequence
import makeJetAnalysisSequence
179 jetContainer =
'AntiKt4EMPFlowJets'
181 input =
'AnalysisJets'
185 runJvtUpdate =
False, runNNJvtUpdate =
True,
186 enableCutflow=
True, enableKinematicHistograms=
True, shallowViewOutput =
False,
187 runGhostMuonAssociation =
not isPhyslite)
189 from FTagAnalysisAlgorithms.FTagAnalysisSequence
import makeFTagAnalysisSequence
191 btagWP =
"FixedCutBEff_60"
193 enableCutflow=
True, btagger = btagger, btagWP = btagWP, kinematicSelection =
False )
195 'OutJets_NOSYS.ftag_select_' + btagger +
'_' + btagWP +
' -> jet_ftag_select',
197 if dataType !=
'data' and not forCompare:
199 'OutJets_%SYS%.ftag_effSF_' + btagger +
'_' + btagWP +
'_%SYS% -> jet_ftag_eff_%SYS%'
202 jetSequence.configure( inputName = input, outputName =
'AnaJets_%SYS%' )
206 for element
in jetSequence.getGaudiConfig2Algorithms():
207 ca.addEventAlgo(element, caSeq)
209 algSeq += jetSequence
210 vars += [
'OutJets_%SYS%.pt -> jet_pt_%SYS%',
211 'OutJets_NOSYS.phi -> jet_phi',
212 'OutJets_NOSYS.eta -> jet_eta'
215 vars += [
'OutJets_%SYS%.jvt_selection -> jet_select_jvt_%SYS%']
218 from MuonAnalysisAlgorithms.MuonAnalysisSequence
import makeMuonAnalysisSequence
220 input =
'AnalysisMuons'
225 workingPoint =
'Medium.Loose_VarRad', postfix =
'medium',
226 enableCutflow=
True, enableKinematicHistograms=
True, ptSelectionOutput =
True )
227 muonSequenceMedium.configure( inputName = input,
228 outputName =
'AnaMuons_%SYS%' )
230 for element
in muonSequenceMedium.getGaudiConfig2Algorithms():
231 ca.addEventAlgo(element, caSeq)
233 algSeq += muonSequenceMedium
251 vars += [
'OutMuons_NOSYS.eta -> mu_eta',
252 'OutMuons_NOSYS.phi -> mu_phi',
253 'OutMuons_%SYS%.pt -> mu_pt_%SYS%',
254 'OutMuons_NOSYS.charge -> mu_charge',]
256 vars += [
'OutMuons_%SYS%.baselineSelection_medium -> mu_select_medium_%SYS%', ]
258 if dataType !=
'data':
259 vars += [
'OutMuons_%SYS%.muon_effSF_medium_%SYS% -> mu_reco_effSF_medium_%SYS%', ]
263 from EgammaAnalysisAlgorithms.ElectronAnalysisSequence
import \
264 makeElectronAnalysisSequence
266 input =
'AnalysisElectrons'
270 recomputeLikelihood=
False
272 workingpoint =
'LooseBLayerLHElectron.Loose_VarRad'
274 workingpoint =
'LooseDNNElectron.Loose_VarRad'
276 dataType, workingpoint, postfix =
'loose',
277 recomputeLikelihood=recomputeLikelihood, enableCutflow=
True,
278 enableKinematicHistograms=
True, shallowViewOutput =
False,
279 forceFullSimConfig=forceEGammaFullSimConfig)
280 electronSequence.configure( inputName = input,
281 outputName =
'AnaElectrons_%SYS%' )
283 for element
in electronSequence.getGaudiConfig2Algorithms():
284 ca.addEventAlgo(element, caSeq)
286 algSeq += electronSequence
288 if not(forceEGammaFullSimConfig
and dataType==
'afii' and forCompare):
289 vars += [
'OutElectrons_%SYS%.pt -> el_pt_%SYS%',
290 'OutElectrons_NOSYS.phi -> el_phi',
291 'OutElectrons_NOSYS.eta -> el_eta',
292 'OutElectrons_NOSYS.charge -> el_charge', ]
294 vars += [
'OutElectrons_%SYS%.baselineSelection_loose -> el_select_loose_%SYS%', ]
295 if dataType !=
'data' and not forCompare:
296 vars += [
'OutElectrons_%SYS%.effSF_loose_%SYS% -> el_effSF_loose_%SYS%',]
300 from EgammaAnalysisAlgorithms.PhotonAnalysisSequence
import \
301 makePhotonAnalysisSequence
303 input =
'AnalysisPhotons'
307 dataType,
'Tight.FixedCutTight', postfix =
'tight',
308 recomputeIsEM=
False, enableCutflow=
True,
309 enableKinematicHistograms=
True, shallowViewOutput =
False,
310 forceFullSimConfig=forceEGammaFullSimConfig)
311 photonSequence.configure( inputName = input,
312 outputName =
'AnaPhotons_%SYS%' )
314 for element
in photonSequence.getGaudiConfig2Algorithms():
315 ca.addEventAlgo(element, caSeq)
317 algSeq += photonSequence
318 vars += [
'OutPhotons_%SYS%.pt -> ph_pt_%SYS%',
319 'OutPhotons_NOSYS.phi -> ph_phi',
320 'OutPhotons_NOSYS.eta -> ph_eta', ]
322 vars += [
'OutPhotons_%SYS%.baselineSelection_tight -> ph_select_tight_%SYS%', ]
323 if dataType !=
'data' and not forCompare:
324 vars += [
'OutPhotons_%SYS%.ph_effSF_tight_%SYS% -> ph_effSF_tight_%SYS%', ]
328 from TauAnalysisAlgorithms.TauAnalysisSequence
import makeTauAnalysisSequence
330 input =
'AnalysisTauJets'
334 enableCutflow=
True, enableKinematicHistograms=
True, shallowViewOutput =
False )
335 tauSequence.configure( inputName = input, outputName =
'AnaTauJets_%SYS%' )
339 for element
in tauSequence.getGaudiConfig2PublicTools():
340 ca.addPublicTool(element)
341 for element
in tauSequence.getGaudiConfig2Algorithms():
342 ca.addEventAlgo(element, caSeq)
344 algSeq += tauSequence
345 vars += [
'OutTauJets_%SYS%.pt -> tau_pt_%SYS%',
346 'OutTauJets_NOSYS.phi -> tau_phi',
347 'OutTauJets_NOSYS.eta -> tau_eta',
348 'OutTauJets_NOSYS.charge -> tau_charge',
349 'OutTauJets_NOSYS.NNDecayMode -> tau_NNDecayMode',
352 vars += [
'OutTauJets_%SYS%.baselineSelection_tight -> tau_select_tight_%SYS%', ]
353 if dataType !=
'data':
354 vars += [
'OutTauJets_%SYS%.tau_effSF_tight_%SYS% -> tau_effSF_tight_%SYS%', ]
373 selalg =
createAlgorithm(
'CP::AsgSelectionAlg',
'UserElectronsSelectionAlg' )
374 addPrivateTool( selalg,
'selectionTool',
'CP::AsgPtEtaSelectionTool' )
375 if electronMinPt
is not None :
376 selalg.selectionTool.minPt = electronMinPt
377 if electronMaxEta
is not None :
378 selalg.selectionTool.maxEta = electronMaxEta
379 selalg.selectionDecoration =
'selectPtEta'
380 selalg.particles =
'AnaElectrons_%SYS%'
382 ca.addEventAlgo(selalg, caSeq)
386 selalg =
createAlgorithm(
'CP::AsgSelectionAlg',
'UserPhotonsSelectionAlg' )
387 addPrivateTool( selalg,
'selectionTool',
'CP::AsgPtEtaSelectionTool' )
388 if photonMinPt
is not None :
389 selalg.selectionTool.minPt = photonMinPt
390 if photonMaxEta
is not None :
391 selalg.selectionTool.maxEta = photonMaxEta
392 selalg.selectionDecoration =
'selectPtEta'
393 selalg.particles =
'AnaPhotons_%SYS%'
395 ca.addEventAlgo(selalg, caSeq)
399 selalg =
createAlgorithm(
'CP::AsgSelectionAlg',
'UserMuonsSelectionAlg' )
400 addPrivateTool( selalg,
'selectionTool',
'CP::AsgPtEtaSelectionTool' )
401 if muonMinPt
is not None :
402 selalg.selectionTool.minPt = muonMinPt
403 if muonMaxEta
is not None :
404 selalg.selectionTool.maxEta = muonMaxEta
405 selalg.selectionDecoration =
'selectPtEta'
406 selalg.particles =
'AnaMuons_%SYS%'
408 ca.addEventAlgo(selalg, caSeq)
412 selalg =
createAlgorithm(
'CP::AsgSelectionAlg',
'UserTauJetsSelectionAlg' )
413 addPrivateTool( selalg,
'selectionTool',
'CP::AsgPtEtaSelectionTool' )
414 if tauMinPt
is not None :
415 selalg.selectionTool.minPt = tauMinPt
416 if tauMaxEta
is not None :
417 selalg.selectionTool.maxEta = tauMaxEta
418 selalg.selectionDecoration =
'selectPtEta'
419 selalg.particles =
'AnaTauJets_%SYS%'
421 ca.addEventAlgo(selalg, caSeq)
425 selalg =
createAlgorithm(
'CP::AsgSelectionAlg',
'UserJetsSelectionAlg' )
426 addPrivateTool( selalg,
'selectionTool',
'CP::AsgPtEtaSelectionTool' )
427 if jetMinPt
is not None :
428 selalg.selectionTool.minPt = jetMinPt
429 if jetMaxEta
is not None :
430 selalg.selectionTool.maxEta = jetMaxEta
431 selalg.selectionDecoration =
'selectPtEta'
432 selalg.particles =
'AnaJets_%SYS%'
434 ca.addEventAlgo(selalg, caSeq)
441 metInputs = {
'jets' :
'AnaJets_%SYS%',
442 'taus' :
'AnaTauJets_%SYS%',
443 'muons' :
'AnaMuons_%SYS%',
444 'electrons' :
'AnaElectrons_%SYS%',
445 'photons' :
'AnaPhotons_%SYS%' }
447 from MetAnalysisAlgorithms.MetAnalysisSequence
import makeMetAnalysisSequence
449 metSuffix =
'AnalysisMET'
451 metSuffix = jetContainer[:-4]
455 electronsSelection =
"selectPtEta && baselineSelection_loose,as_char",
456 photonsSelection =
"selectPtEta && baselineSelection_tight,as_char",
457 muonsSelection =
"selectPtEta && baselineSelection_medium,as_char",
458 tausSelection =
"selectPtEta && baselineSelection_tight,as_char" )
459 metSequence.configure( inputName = metInputs,
460 outputName =
'AnaMET_%SYS%' )
464 for element
in metSequence.getGaudiConfig2Algorithms():
465 ca.addEventAlgo(element, caSeq)
467 algSeq += metSequence
469 'AnaMET_%SYS%.met -> met_met_%SYS%',
470 'AnaMET_%SYS%.phi -> met_phi_%SYS%',
471 'AnaMET_%SYS%.sumet -> met_sumet_%SYS%',
477 'photons' :
'AnaPhotons_%SYS%',
478 'muons' :
'AnaMuons_%SYS%',
479 'jets' :
'AnaJets_%SYS%',
480 'taus' :
'AnaTauJets_%SYS%'
483 selectalg =
createAlgorithm(
'CP::AsgSelectionAlg',
'ORElectronsSelectAlg' )
484 selectalg.preselection =
'selectPtEta&&baselineSelection_loose,as_char'
485 selectalg.particles =
'AnaElectrons_%SYS%'
486 selectalg.selectionDecoration =
'preselectOR,as_char'
488 ca.addEventAlgo(selectalg, caSeq)
491 orInputs[
'electrons'] =
'AnaElectrons_%SYS%'
493 selectalg =
createAlgorithm(
'CP::AsgSelectionAlg',
'ORPhotonsSelectAlg' )
494 selectalg.preselection =
'selectPtEta&&baselineSelection_tight,as_char'
495 selectalg.particles =
'AnaPhotons_%SYS%'
496 selectalg.selectionDecoration =
'preselectOR,as_char'
498 ca.addEventAlgo(selectalg, caSeq)
502 selectalg =
createAlgorithm(
'CP::AsgSelectionAlg',
'ORMuonsSelectAlg' )
503 selectalg.preselection =
'selectPtEta&&baselineSelection_medium,as_char'
504 selectalg.particles =
'AnaMuons_%SYS%'
505 selectalg.selectionDecoration =
'preselectOR,as_char'
507 ca.addEventAlgo(selectalg, caSeq)
511 selectalg =
createAlgorithm(
'CP::AsgSelectionAlg',
'ORTauJetsSelectAlg' )
512 selectalg.preselection =
'selectPtEta&&baselineSelection_tight,as_char'
513 selectalg.particles =
'AnaTauJets_%SYS%'
514 selectalg.selectionDecoration =
'preselectOR,as_char'
516 ca.addEventAlgo(selectalg, caSeq)
521 selectalg.preselection =
'selectPtEta'
522 selectalg.particles =
'AnaJets_%SYS%'
523 selectalg.selectionDecoration =
'preselectOR,as_char'
525 ca.addEventAlgo(selectalg, caSeq)
531 from AsgAnalysisAlgorithms.OverlapAnalysisSequence
import \
532 makeOverlapAnalysisSequence
533 overlapSequence =
makeOverlapAnalysisSequence( dataType, doTaus=
True, enableCutflow=
True, shallowViewOutput =
False, inputLabel =
'preselectOR', outputLabel =
'passesOR' )
534 overlapSequence.configure(
536 'electrons' :
'AnaElectrons_%SYS%',
537 'photons' :
'AnaPhotons_%SYS%',
538 'muons' :
'AnaMuons_%SYS%',
539 'jets' :
'AnaJets_%SYS%',
540 'taus' :
'AnaTauJets_%SYS%'
545 for element
in overlapSequence.getGaudiConfig2Algorithms():
546 ca.addEventAlgo(element, caSeq)
548 algSeq += overlapSequence
550 'OutJets_%SYS%.passesOR_%SYS% -> jet_select_or_%SYS%',
551 'OutPhotons_%SYS%.passesOR_%SYS% -> ph_select_or_%SYS%',
552 'OutMuons_%SYS%.passesOR_%SYS% -> mu_select_or_%SYS%',
553 'OutTauJets_%SYS%.passesOR_%SYS% -> tau_select_or_%SYS%',
555 if not(forceEGammaFullSimConfig
and dataType==
'afii' and forCompare):
556 vars += [
'OutElectrons_%SYS%.passesOR_%SYS% -> el_select_or_%SYS%']
558 if dataType !=
'data' :
560 from AsgAnalysisAlgorithms.GeneratorAnalysisSequence
import \
561 makeGeneratorAnalysisSequence
564 for element
in generatorSequence.getGaudiConfig2Algorithms():
565 ca.addEventAlgo(element, caSeq)
567 algSeq += generatorSequence
568 vars += [
'EventInfo.generatorWeight_%SYS% -> weight_mc_%SYS%', ]
575 from TriggerAnalysisAlgorithms.TriggerAnalysisSequence
import \
576 makeTriggerAnalysisSequence
579 for element
in triggerSequence.getGaudiConfig2Algorithms():
580 ca.addEventAlgo(element, caSeq)
582 algSeq += triggerSequence
583 vars += [
'EventInfo.trigPassed_' + t +
' -> trigPassed_' + t
for t
in triggerChains]
589 addOutputCopyAlgorithms (algSeq, ca,
'Electrons',
'AnaElectrons_%SYS%',
'OutElectrons_%SYS%',
590 'selectPtEta&&baselineSelection_loose,as_char&&passesOR_%SYS%,as_char')
591 addOutputCopyAlgorithms (algSeq, ca,
'Photons',
'AnaPhotons_%SYS%',
'OutPhotons_%SYS%',
592 'selectPtEta&&baselineSelection_tight,as_char&&passesOR_%SYS%,as_char')
593 addOutputCopyAlgorithms (algSeq, ca,
'Muons',
'AnaMuons_%SYS%',
'OutMuons_%SYS%',
594 'selectPtEta&&baselineSelection_medium,as_char&&passesOR_%SYS%,as_char')
595 addOutputCopyAlgorithms (algSeq, ca,
'TauJets',
'AnaTauJets_%SYS%',
'OutTauJets_%SYS%',
596 'selectPtEta&&baselineSelection_tight,as_char&&passesOR_%SYS%,as_char')
597 addOutputCopyAlgorithms (algSeq, ca,
'Jets',
'AnaJets_%SYS%',
'OutJets_%SYS%',
598 'selectPtEta&&passesOR_%SYS%,as_char')
601 from JetAnalysisAlgorithms.JetJvtAnalysisSequence
import makeJetJvtAnalysisSequence
603 preselection=
'selectPtEta&&passesOR_%SYS%,as_char' )
604 jvtSequence.configure( inputName = {
'jets' :
'OutJets_%SYS%' },
609 for element
in jvtSequence.getGaudiConfig2Algorithms():
610 ca.addEventAlgo(element, caSeq)
612 algSeq += jvtSequence
614 if dataType !=
'data' :
615 vars += [
'OutJets_%SYS%.jvt_effSF_%SYS% -> jet_jvtEfficiency_%SYS%', ]
617 'EventInfo.jvt_effSF_%SYS% -> weight_jvt_effSF_%SYS%',
624 treeMaker.TreeName =
'analysis'
628 ca.addEventAlgo(treeMaker, caSeq)
631 ntupleMaker =
createAlgorithm(
'CP::AsgxAODNTupleMakerAlg',
'NTupleMaker' )
632 ntupleMaker.TreeName =
'analysis'
633 ntupleMaker.Branches = vars
636 ca.addEventAlgo(ntupleMaker, caSeq)
638 algSeq += ntupleMaker
639 if len (metVars) > 0:
640 ntupleMaker =
createAlgorithm(
'CP::AsgxAODMetNTupleMakerAlg',
'MetNTupleMaker' )
641 ntupleMaker.TreeName =
'analysis'
642 ntupleMaker.Branches = metVars
645 ca.addEventAlgo(ntupleMaker, caSeq)
647 algSeq += ntupleMaker
649 treeFiller.TreeName =
'analysis'
651 ca.addEventAlgo(treeFiller, caSeq)
659 geometry=None, autoconfigFromFlags=None, noSystematics=None,
660 onlyNominalOR=False, forceEGammaFullSimConfig=False,
661 returnConfigSeq=False) :
669 trackJets =
not isPhyslite
and not forCompare
671 if autoconfigFromFlags
is not None:
673 geometry = autoconfigFromFlags.GeoModel.Run
675 configSeq = ConfigSequence ()
677 outputContainers = {
'mu_' :
'OutMuons',
678 'ph_' :
'OutPhotons',
679 'tau_':
'OutTauJets',
683 if not(forceEGammaFullSimConfig
and dataType
is DataType.FastSim
and forCompare):
684 outputContainers[
'el_'] =
'OutElectrons'
687 from AnalysisAlgorithmsConfig.ConfigFactory
import ConfigFactory
688 config = ConfigFactory()
690 configSeq += config.makeConfig(
'CommonServices')
691 configSeq.setOptionValue(
'.systematicsHistogram',
'systematicsList')
693 configSeq.setOptionValue(
'.filterSystematics',
"^(?:(?!PseudoData).)*$")
698 configSeq += config.makeConfig(
'PileupReweighting')
699 if dataType
is DataType.FastSim
and forCompare:
701 configSeq.setOptionValue(
'.userPileupConfigs', prwfiles)
702 configSeq.setOptionValue(
'.userLumicalcFiles', lumicalcfiles)
703 configSeq.setOptionValue(
'.useDefaultConfig',
False)
707 vars += [
'EventInfo.runNumber -> runNumber',
708 'EventInfo.eventNumber -> eventNumber',
709 'EventInfo.mcChannelNumber -> mcChannelNumber']
714 configSeq += config.makeConfig (
'EventCleaning')
715 configSeq.setOptionValue (
'.runEventCleaning',
True)
718 configSeq += config.makeConfig(
'Jets',
719 containerName=
'AnaJets',
720 jetCollection=
'AntiKt4EMPFlowJets')
721 configSeq.setOptionValue (
'.runJvtUpdate',
False )
722 configSeq.setOptionValue (
'.runNNJvtUpdate',
True )
724 configSeq.setOptionValue (
'.recalibratePhyslite',
False)
726 configSeq += config.makeConfig(
'Jets.JVT',
727 containerName=
'AnaJets' )
730 btagWP =
"FixedCutBEff_60"
731 configSeq += config.makeConfig(
'Jets.FlavourTagging',
732 containerName=
'AnaJets',
733 selectionName=
'ftag' )
734 configSeq.setOptionValue (
'.noEffSF', forCompare)
735 configSeq.setOptionValue (
'.btagger', btagger)
736 configSeq.setOptionValue (
'.btagWP', btagWP)
737 configSeq.setOptionValue (
'.saveScores',
'All')
740 configSeq += config.makeConfig(
'Jets.FlavourTaggingEventSF',
741 containerName=
'AnaJets.baselineJvt',
742 selectionName=
'ftag')
743 configSeq.setOptionValue (
'.btagger', btagger)
744 configSeq.setOptionValue (
'.btagWP', btagWP)
747 configSeq += config.makeConfig(
'Jets',
748 containerName=
'AnaLargeRJets',
749 jetCollection=
'AntiKt10UFOCSSKSoftDropBeta100Zcut10Jets' )
750 configSeq.setOptionValue (
'.postfix',
'largeR_jets' )
751 outputContainers[
'larger_jet_'] =
'OutLargeRJets'
753 configSeq.setOptionValue (
'.recalibratePhyslite',
False)
756 configSeq += config.makeConfig(
'Jets',
757 containerName=
'AnaTrackJets',
758 jetCollection=
'AntiKtVR30Rmax4Rmin02PV0TrackJets' )
759 configSeq.setOptionValue (
'.postfix',
'track_jets' )
760 outputContainers[
'track_jet_'] =
'OutTrackJets'
762 configSeq += config.makeConfig (
'Jets.PtEtaSelection',
763 containerName=
'AnaJets')
764 configSeq.setOptionValue (
'.selectionDecoration',
'selectPtEta')
765 configSeq.setOptionValue (
'.minPt', jetMinPt)
766 configSeq.setOptionValue (
'.maxEta', jetMaxEta)
768 configSeq += config.makeConfig (
'Jets.PtEtaSelection',
769 containerName=
'AnaLargeRJets')
770 configSeq.setOptionValue (
'.selectionDecoration',
'selectPtEta')
771 configSeq.setOptionValue (
'.minPt', jetMinPt)
772 configSeq.setOptionValue (
'.maxEta', jetMaxEta)
774 configSeq += config.makeConfig (
'Jets.PtEtaSelection',
775 containerName=
'AnaTrackJets')
776 configSeq.setOptionValue (
'.selectionDecoration',
'selectPtEta')
777 configSeq.setOptionValue (
'.minPt', jetMinPt)
778 configSeq.setOptionValue (
'.maxEta', jetMaxEta)
783 recomputeLikelihood=
False
784 configSeq += config.makeConfig (
'Electrons',
785 containerName=
'AnaElectrons' )
786 configSeq.setOptionValue (
'.forceFullSimConfig', forceEGammaFullSimConfig)
788 configSeq.setOptionValue (
'.recalibratePhyslite',
False)
789 configSeq += config.makeConfig (
'Electrons.WorkingPoint',
790 containerName=
'AnaElectrons',
791 selectionName=
'loose')
792 configSeq.setOptionValue (
'.forceFullSimConfig', forceEGammaFullSimConfig)
794 configSeq.setOptionValue (
'.noEffSF',
True)
796 configSeq.setOptionValue (
'.likelihoodWP',
'LooseBLayerLH')
798 configSeq.setOptionValue (
'.likelihoodWP',
'LooseDNN')
799 configSeq.setOptionValue (
'.isolationWP',
'Loose_VarRad')
800 configSeq.setOptionValue (
'.recomputeLikelihood', recomputeLikelihood)
801 configSeq.setOptionValue (
'.writeTrackD0Z0',
True)
803 configSeq += config.makeConfig (
'Electrons.PtEtaSelection',
804 containerName=
'AnaElectrons')
805 configSeq.setOptionValue (
'.selectionDecoration',
'selectPtEta')
806 configSeq.setOptionValue (
'.minPt', electronMinPt)
807 configSeq.setOptionValue (
'.maxEta', electronMaxEta)
811 configSeq += config.makeConfig (
'Photons',
812 containerName=
'AnaPhotons' )
813 configSeq.setOptionValue (
'.forceFullSimConfig', forceEGammaFullSimConfig)
814 configSeq.setOptionValue (
'.recomputeIsEM',
False)
816 configSeq.setOptionValue (
'.recalibratePhyslite',
False)
817 configSeq += config.makeConfig (
'Photons.WorkingPoint',
818 containerName=
'AnaPhotons',
819 selectionName=
'tight')
820 configSeq.setOptionValue (
'.forceFullSimConfig', forceEGammaFullSimConfig)
822 configSeq.setOptionValue (
'.noEffSF',
True)
823 configSeq.setOptionValue (
'.qualityWP',
'Tight')
824 configSeq.setOptionValue (
'.isolationWP',
'FixedCutTight')
825 configSeq.setOptionValue (
'.recomputeIsEM',
False)
827 configSeq += config.makeConfig (
'Photons.PtEtaSelection',
828 containerName=
'AnaPhotons')
829 configSeq.setOptionValue (
'.selectionDecoration',
'selectPtEta')
830 configSeq.setOptionValue (
'.minPt', photonMinPt)
831 configSeq.setOptionValue (
'.maxEta', photonMaxEta)
835 configSeq += config.makeConfig (
'Muons',
836 containerName=
'AnaMuons')
838 configSeq.setOptionValue (
'.recalibratePhyslite',
False)
839 configSeq += config.makeConfig (
'Muons.WorkingPoint',
840 containerName=
'AnaMuons',
841 selectionName=
'medium')
842 configSeq.setOptionValue (
'.quality',
'Medium')
843 configSeq.setOptionValue (
'.isolation',
'Loose_VarRad')
845 configSeq.setOptionValue (
'.onlyRecoEffSF',
True)
846 configSeq.setOptionValue (
'.writeTrackD0Z0',
True)
853 configSeq += config.makeConfig (
'Muons.PtEtaSelection',
854 containerName=
'AnaMuons')
855 configSeq.setOptionValue (
'.selectionDecoration',
'selectPtEta')
856 configSeq.setOptionValue (
'.minPt', muonMinPt)
857 configSeq.setOptionValue (
'.maxEta', muonMaxEta)
860 configSeq += config.makeConfig (
'TauJets',
861 containerName=
'AnaTauJets')
862 configSeq += config.makeConfig (
'TauJets.WorkingPoint',
863 containerName=
'AnaTauJets',
864 selectionName=
'tight')
865 configSeq.setOptionValue (
'.quality',
'Tight')
868 configSeq += config.makeConfig(
'TauJets.TriggerSF')
869 configSeq.setOptionValue(
'.containerName',
'AnaTauJets')
870 configSeq.setOptionValue(
'.tauID',
'Tight')
871 configSeq.setOptionValue(
'.triggerChainsPerYear', tauTriggerChainsSF)
873 configSeq += config.makeConfig (
'TauJets.PtEtaSelection',
874 containerName=
'AnaTauJets')
875 configSeq.setOptionValue (
'.selectionDecoration',
'selectPtEta')
876 configSeq.setOptionValue (
'.minPt', tauMinPt)
877 configSeq.setOptionValue (
'.maxEta', tauMaxEta)
881 configSeq += config.makeConfig(
'SystObjectLink', containerName=
'AnaJets')
883 configSeq += config.makeConfig(
'SystObjectLink', containerName=
'AnaLargeRJets')
885 configSeq += config.makeConfig(
'SystObjectLink', containerName=
'AnaTrackJets')
886 configSeq += config.makeConfig(
'SystObjectLink', containerName=
'AnaElectrons')
887 configSeq += config.makeConfig(
'SystObjectLink', containerName=
'AnaPhotons')
888 configSeq += config.makeConfig(
'SystObjectLink', containerName=
'AnaMuons')
889 configSeq += config.makeConfig(
'SystObjectLink', containerName=
'AnaTauJets')
892 if dataType
is not DataType.Data :
894 configSeq += config.makeConfig(
'GeneratorLevelAnalysis')
895 configSeq.setOptionValue (
'.saveCutBookkeepers',
True)
896 configSeq.setOptionValue (
'.runNumber', 284500)
897 configSeq.setOptionValue (
'.cutBookkeepersSystematics',
True)
901 configSeq += config.makeConfig (
'MissingET',
902 containerName=
'AnaMET')
903 configSeq.setOptionValue (
'.jets',
'AnaJets')
904 configSeq.setOptionValue (
'.taus',
'AnaTauJets.tight')
905 configSeq.setOptionValue (
'.electrons',
'AnaElectrons.loose')
906 configSeq.setOptionValue (
'.photons',
'AnaPhotons.tight')
915 configSeq.setOptionValue (
'.muons',
'AnaMuons.medium')
919 configSeq += config.makeConfig(
'OverlapRemoval' )
920 configSeq.setOptionValue (
'.electrons',
'AnaElectrons.loose')
921 configSeq.setOptionValue (
'.photons',
'AnaPhotons.tight')
924 configSeq.setOptionValue (
'.muons',
'AnaMuons.medium')
925 configSeq.setOptionValue (
'.jets',
'AnaJets')
926 configSeq.setOptionValue (
'.taus',
'AnaTauJets.tight')
927 configSeq.setOptionValue (
'.inputLabel',
'preselectOR')
928 configSeq.setOptionValue (
'.outputLabel',
'passesOR' )
929 configSeq.setOptionValue (
'.nominalOnly', onlyNominalOR )
933 configSeq.setOptionValue (
'.addToAllSelections',
True)
934 configSeq.setOptionValue (
'.addPreselection',
True)
944 from EventSelectionAlgorithms.EventSelectionConfig
import makeMultipleEventSelectionConfigs
946 met =
'AnaMET', btagDecoration =
'ftag_select_ftag',
947 selectionCutsDict = exampleSelectionCuts, noFilter =
True)
951 configSeq += config.makeConfig (
'ObjectCutFlow',
952 containerName=
'AnaJets',
954 configSeq += config.makeConfig (
'ObjectCutFlow',
955 containerName=
'AnaElectrons',
956 selectionName=
'loose')
957 configSeq += config.makeConfig (
'ObjectCutFlow',
958 containerName=
'AnaPhotons',
959 selectionName=
'tight')
960 configSeq += config.makeConfig (
'ObjectCutFlow',
961 containerName=
'AnaMuons',
962 selectionName=
'medium')
963 configSeq += config.makeConfig (
'ObjectCutFlow',
964 containerName=
'AnaTauJets',
965 selectionName=
'tight')
969 configSeq += config.makeConfig (
'Thinning',
970 containerName=
'AnaElectrons')
971 configSeq.setOptionValue (
'.selectionName',
'loose')
972 configSeq.setOptionValue (
'.outputName',
'OutElectrons')
973 configSeq += config.makeConfig (
'Thinning',
974 containerName=
'AnaPhotons')
975 configSeq.setOptionValue (
'.selectionName',
'tight')
976 configSeq.setOptionValue (
'.outputName',
'OutPhotons')
977 configSeq += config.makeConfig (
'Thinning',
978 containerName=
'AnaMuons')
979 configSeq.setOptionValue (
'.selectionName',
'medium')
980 configSeq.setOptionValue (
'.outputName',
'OutMuons')
981 configSeq += config.makeConfig (
'Thinning',
982 containerName=
'AnaTauJets')
983 configSeq.setOptionValue (
'.selectionName',
'tight')
984 configSeq.setOptionValue (
'.outputName',
'OutTauJets')
985 configSeq += config.makeConfig (
'Thinning',
986 containerName=
'AnaJets')
987 configSeq.setOptionValue (
'.outputName',
'OutJets')
989 configSeq += config.makeConfig (
'Thinning',
990 containerName=
'AnaLargeRJets')
991 configSeq.setOptionValue (
'.outputName',
'OutLargeRJets')
993 configSeq += config.makeConfig (
'Thinning',
994 containerName=
'AnaTrackJets')
995 configSeq.setOptionValue (
'.outputName',
'OutTrackJets')
1001 configSeq += config.makeConfig(
'Trigger' )
1002 configSeq.setOptionValue (
'.triggerChainsPerYear', triggerChainsPerYear )
1003 configSeq.setOptionValue (
'.noFilter',
True )
1004 configSeq.setOptionValue (
'.electronID',
'Tight' )
1005 configSeq.setOptionValue (
'.electronIsol',
'Tight_VarRad')
1006 configSeq.setOptionValue (
'.photonIsol',
'TightCaloOnly')
1007 configSeq.setOptionValue (
'.muonID',
'Tight')
1008 configSeq.setOptionValue (
'.electrons',
'AnaElectrons' )
1009 configSeq.setOptionValue (
'.photons',
'AnaPhotons' )
1010 configSeq.setOptionValue (
'.muons',
'AnaMuons' )
1013 configSeq += config.makeConfig (
'Bootstraps')
1014 configSeq.setOptionValue (
'.nReplicas', 2000 )
1015 configSeq.setOptionValue (
'.runOnMC',
True )
1017 configSeq += config.makeConfig (
'Output')
1018 configSeq.setOptionValue (
'.treeName',
'analysis')
1019 configSeq.setOptionValue (
'.vars', vars)
1020 configSeq.setOptionValue (
'.metVars', metVars)
1021 configSeq.setOptionValue (
'.containers', outputContainers)
1022 disable_commands = []
1024 disable_commands += [
1025 'disable jet_select_baselineJvt.*',
1026 'disable mu_select_medium.*',
1027 'disable ph_select_tight.*',
1028 'disable tau_select_tight.*',
1030 if not (dataType
is DataType.FastSim
and forceEGammaFullSimConfig):
1031 disable_commands.append(
'disable el_select_loose.*')
1032 configSeq.setOptionValue (
'.commands', disable_commands)
1038 configAccumulator = ConfigAccumulator (algSeq, dataType, isPhyslite, geometry, autoconfigFromFlags=autoconfigFromFlags, noSystematics=noSystematics)
1039 configSeq.fullConfigure (configAccumulator)
1042 configSeq.printOptions()
1044 from AnaAlgorithm.DualUseConfig
import isAthena, useComponentAccumulator
1045 if isAthena
and useComponentAccumulator:
1046 return configAccumulator.CA
1053 """print the algorithms in the sequence without the sequence structure
1055 This is mostly meant for easy comparison of different sequences
1056 during configuration, particularly the sequences resulting from
1057 the old sequence configuration and the new block configuration.
1058 Those have different sequence structures in the output, but the
1059 algorithms should essentially be configured the same way."""
1060 if isinstance (sequence, AlgSequence) :
1061 for alg
in sequence :
1062 printSequenceAlgs (alg)
1069 noSystematics, hardCuts = False, isPhyslite = False, geometry = None,
1070 autoconfigFromFlags = None, onlyNominalOR = False,
1071 forceEGammaFullSimConfig = False) :
1076 global electronMinPt
1077 electronMinPt = 27e3
1091 ca = makeSequenceBlocks (dataType, algSeq, forCompare=forCompare,
1092 isPhyslite=isPhyslite,
1093 geometry=geometry, onlyNominalOR=onlyNominalOR,
1094 autoconfigFromFlags=autoconfigFromFlags,
1095 noSystematics=noSystematics,
1096 forceEGammaFullSimConfig=forceEGammaFullSimConfig)
1098 from AnalysisAlgorithmsConfig.ConfigText
import makeSequence
as makeSequenceText
1099 ca = makeSequenceText(yamlPath, dataType, algSeq, geometry=geometry,
1100 isPhyslite=isPhyslite,
1101 autoconfigFromFlags=autoconfigFromFlags,
1102 noSystematics=noSystematics)
1104 ca = makeSequenceOld (dataType, algSeq, forCompare=forCompare,
1105 isPhyslite=isPhyslite,
1106 noSystematics=noSystematics,
1107 forceEGammaFullSimConfig=forceEGammaFullSimConfig)