ATLAS Offline Software
Loading...
Searching...
No Matches
Public Member Functions | Public Attributes | Static Public Attributes | Protected Attributes | Private Attributes | List of all members
python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder Class Reference
Collaboration diagram for python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder:

Public Member Functions

 __init__ (self, helper, runflag, moniAccess, emulator=None, onlyHLT=False, derivation=False, detailedHistograms=False, basePath='HLT/EgammaMon', ComputeEffLH=False, ComputeEffDNN=False)
 configureMode (self)
 configure (self)
 get_monitoring_mode (self)
 setProperties (self)
 setDefaultProperties (self)
 configureMonitor (self)
 configureHistograms (self)
 addGroup (self, monAlg, name, path)
 addHistogram (self, monGroup, hist)
 bookExpertHistograms (self, monAlg, triggers)
 bookEvent (self, monAlg, analysis, tap=False)
 bookL1CaloDistributions (self, monAlg, trigger)
 bookL2CaloDistributions (self, monAlg, trigger)
 bookL2ElectronDistributions (self, monAlg, trigger)
 bookL2PhotonDistributions (self, monAlg, trigger)
 bookEFCaloDistributions (self, monAlg, trigger)
 bookShowerShapesDistributions (self, monAlg, trigger, level, online=True)
 bookTrackingDistributions (self, monAlg, trigger, online=True)
 bookEfficiencies (self, monAlg, trigger, level, subgroup=None, doEmulation=False)
 bookInefficiencies (self, monAlg, trigger)
 bookL1CaloResolutions (self, monAlg, trigger)
 bookL1CaloAbsResolutions (self, monAlg, trigger)
 bookL2CaloResolutions (self, monAlg, trigger)
 bookHLTResolutions (self, monAlg, trigger, level)
 bookHLTElectronResolutions (self, monAlg, trigger, isolated=False)
 bookHLTPhotonResolutions (self, monAlg, trigger, isolated=False)
 bookTopoHistograms (self, monAlg, trigger_configs)
 setBinning (self, doJpsiee=False)
 getTrigInfo (self, trigger)

Public Attributes

str runFlag = runflag
 helper = helper
 derivation = derivation
# turn on emulator emulator = emulator
str basePath = basePath
 detailedHistograms = detailedHistograms
 moniAccess = moniAccess
 onlyHLT = onlyHLT
 computeEffLH = ComputeEffLH
 computeEffDNN = ComputeEffDNN
 tpZeegTagList
 tpZeegProbeList
 tpMatchingMap
 bootstrapMap = mongroups['monitoring_bootstrap']
 topoList = mongroups['monitoring_topo']
 zeeMonAlg = self.helper.addAlgorithm( CompFactory.TrigEgammaMonitorTagAndProbeAlgorithm, "TrigEgammaMonitorTagAndProbeAlgorithm_Zee_LH" )
 zeeMonAlg_dnn = self.helper.addAlgorithm( CompFactory.TrigEgammaMonitorTagAndProbeAlgorithm, "TrigEgammaMonitorTagAndProbeAlgorithm_Zee_DNN" )
 zeegMonAlg = self.helper.addAlgorithm( CompFactory.TrigEgammaMonitorTagAndProbeAlgorithmZeeg, "TrigEgammaMonitorTagAndProbeZeeg" )
 jpsieeMonAlg = self.helper.addAlgorithm( CompFactory.TrigEgammaMonitorTagAndProbeAlgorithm, "TrigEgammaMonitorTagAndProbeAlgorithm_Jpsiee" )
 elMonAlg = self.helper.addAlgorithm( CompFactory.TrigEgammaMonitorElectronAlgorithm, "TrigEgammaMonitorElectronAlgorithm" )
 phMonAlg = self.helper.addAlgorithm( CompFactory.TrigEgammaMonitorPhotonAlgorithm, "TrigEgammaMonitorPhotonAlgorithm" )
 topoMonAlg = self.helper.addAlgorithm( CompFactory.TrigEgammaMonitorTopoAlgorithm, "TrigEgammaMonitorTopoAlgorithm" )

Static Public Attributes

str data_type = ''
bool pp_mode = False
bool pPb_mode = False
bool HI_mode = False
bool cosmic_mode = False
bool mc_mode = False
bool activate_electron = False
bool activate_photon = False
bool activate_zee = False
bool activate_zeeg = False
bool activate_jpsiee = False
bool activate_topo = False
bool activate_onlineMonHypos = False
list tagItems = []
list jpsitagItems = []
list electronList = []
list photonList = []
list tpList = []
list jpsiList = []
list isemnames = ["tight", "medium", "loose"]
list lhnames = ["lhtight", "lhmedium", "lhloose","lhvloose"]
list dnnnames = ["dnntight", "dnnmedium", "dnnloose"]

Protected Attributes

int _nEtabins
 _etabins
int _nEtbins
 _etbins
int _ndefaultEtbins = 13
int _ndefaultEtabins = 20
int _ncoarseEtbins = 6
int _ncoarseEtabins = 8
 _defaultEtbins = default_et_bins[0:self._ndefaultEtbins+1]
 _defaultEtabins = default_eta_bins[0:self._ndefaultEtabins+1]
 _coarseEtbins = coarse_et_bins[0:self._ncoarseEtbins+1]
 _coarseEtabins = coarse_eta_bins[0:self._ncoarseEtabins+1]

Private Attributes

 __logger = logging.getLogger( 'TrigEgammaMonAlgBuilder' )
 __chain = trigger
 __legs = HLTChainInfo(trigger)
dict __sigs = {leg.signature for leg in self.__legs}

Detailed Description

Definition at line 31 of file TrigEgammaMonitoringConfig.py.

Constructor & Destructor Documentation

◆ __init__()

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.__init__ ( self,
helper,
runflag,
moniAccess,
emulator = None,
onlyHLT = False,
derivation = False,
detailedHistograms = False,
basePath = 'HLT/EgammaMon',
ComputeEffLH = False,
ComputeEffDNN = False )

Definition at line 60 of file TrigEgammaMonitoringConfig.py.

64 basePath = 'HLT/EgammaMon', ComputeEffLH = False, ComputeEffDNN = False):
65
66 from AthenaCommon.Logging import logging
67 self.__logger = logging.getLogger( 'TrigEgammaMonAlgBuilder' )
68 self.runFlag = runflag
69 self.helper = helper
70 self.derivation = derivation
71 self.emulator = emulator
72 self.basePath = basePath
73 self.detailedHistograms = detailedHistograms
74 self.moniAccess = moniAccess
75 self.onlyHLT = onlyHLT
76 self.computeEffLH = ComputeEffLH
77 self.computeEffDNN = ComputeEffDNN
78 self.configureMode()
79
80
81

Member Function Documentation

◆ addGroup()

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.addGroup ( self,
monAlg,
name,
path )

Definition at line 571 of file TrigEgammaMonitoringConfig.py.

571 def addGroup( self, monAlg, name, path ):
572 return self.helper.addGroup( monAlg, name, path )
573

◆ addHistogram()

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.addHistogram ( self,
monGroup,
hist )

Definition at line 574 of file TrigEgammaMonitoringConfig.py.

574 def addHistogram(self, monGroup, hist):
575 if monGroup is None:
576 self.__logger.error("monGroup is None for hist %s", hist.name)
577 return
578 self.__logger.debug("BOOKING HIST %s in group %s",
579 hist.name, monGroup.name)
580 self.__logger.debug("kwargs = %s", hist.kwargs)
581 monGroup.defineHistogram(hist.name, **hist.kwargs)
582
583
debug
const bool debug
Definition MakeUncertaintyPlots.cxx:53

◆ bookEFCaloDistributions()

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.bookEFCaloDistributions ( self,
monAlg,
trigger )

Definition at line 754 of file TrigEgammaMonitoringConfig.py.

754 def bookEFCaloDistributions( self, monAlg, trigger ):
755
756 from TrigEgammaMonitoring.TrigEgammaMonitorHelper import TH1F
757 monGroup = self.addGroup( monAlg, trigger+'_Distributions_EFCalo', self.basePath+'/Shifter/'+trigger+'/Distributions/PrecisionCalo' )
758
759 self.addHistogram(monGroup, TH1F("et", "ET; ET [GeV] ; Count", 100, 0., 100.))
760 self.addHistogram(monGroup, TH1F("eta", "eta; eta ; Count", self._nEtabins, self._etabins))
761 self.addHistogram(monGroup, TH1F("phi", "phi; phi ; Count", 20, -3.2, 3.2))
762 self.addHistogram(monGroup, TH1F("energy", "Cluster Energy; E [GeV] ; Count", 50, 0., 100.))
763 self.addHistogram(monGroup, TH1F("highet", "Cluster Energy; E [GeV] ; Count", 100, 0., 800.))
764 self.addHistogram(monGroup, TH1F("eta_calo", "eta_calo; eta_calo ; Count", 50, -2.47, 2.47))
765 self.addHistogram(monGroup, TH1F("phi_calo", "phi_calo; phi_calo ; Count", 50, -3.14, 3.14))
766
767 if self.mc_mode:
768 self.addHistogram(monGroup, TH1F("energyBE0", "Cluster Energy BE0; E [GeV] ; Count", 50, 0., 100.))
769 self.addHistogram(monGroup, TH1F("energyBE1", "Cluster Energy BE1; E [GeV] ; Count", 50, 0., 100.))
770 self.addHistogram(monGroup, TH1F("energyBE2", "Cluster Energy BE2; E [GeV] ; Count", 50, 0., 100.))
771 self.addHistogram(monGroup, TH1F("energyBE3", "Cluster Energy BE3; E [GeV] ; Count", 50, 0., 100.))
772
773

◆ bookEfficiencies()

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.bookEfficiencies ( self,
monAlg,
trigger,
level,
subgroup = None,
doEmulation = False )

Definition at line 856 of file TrigEgammaMonitoringConfig.py.

856 def bookEfficiencies(self, monAlg, trigger, level, subgroup=None, doEmulation=False ):
857 self.__logger.debug("booking trigger named = %s", trigger)
858 self.__logger.debug("booking in dir named = %s", self.basePath)
859 from TrigEgammaMonitoring.TrigEgammaMonitorHelper import TH1F, TH2F, TProfile
860
861 dirname = 'Emulation' if doEmulation else 'Efficiency'
862 self.__logger.debug("Histogram path = %s", self.basePath+'/Shifter/'+trigger+'/'+dirname+'/'+level)
863 if subgroup:
864 monGroup = self.addGroup( monAlg, trigger+'_'+dirname+'_'+level+'_'+subgroup, self.basePath+'/Shifter/'+trigger+'/'+dirname+'/'+level+'/'+subgroup )
865 else:
866 monGroup = self.addGroup( monAlg, trigger+'_'+dirname+'_'+level, self.basePath+'/Shifter/'+trigger+'/'+dirname+'/'+level )
867
868 self.__logger.debug("Created monGroup = %s", monGroup)
869 # Numerator
870 self.addHistogram(monGroup, TH1F("match_pt", "Trigger Matched Offline p_{T}; p_{T} [GeV] ; Count", self._nEtbins, self._etbins))
871 self.addHistogram(monGroup, TH1F("match_et", "Trigger Matched Offline E_{T}; E_{T} [GeV]; Count", self._nEtbins, self._etbins))
872 self.addHistogram(monGroup, TH1F("match_highet", "Trigger Matched Offline E_{T}; E_{T} [GeV]; Count", 40, 0., 500.))
873 self.addHistogram(monGroup, TH1F("match_eta", "Trigger Matched Offline #eta; #eta ; Count", self._nEtabins, self._etabins))
874 self.addHistogram(monGroup, TH1F("match_phi", "Trigger Matched #phi; #phi ; Count", 20, -3.2, 3.2))
875 self.addHistogram(monGroup, TH1F("match_avgmu", "Trigger Matched <#mu>; <#mu> ; Count", 16, 0, 80))
876 self.addHistogram(monGroup, TH1F("match_ptvarcone20rel", "Trigger Matched ptvarcone20rel; ptvarcone20rel ; Count", 50, 0, 0.2))
877 self.addHistogram(monGroup, TH1F("match_ptvarcone30rel", "Trigger Matched ptvarcone30rel; ptvarcone30rel ; Count", 50, 0, 0.2))
878 self.addHistogram(monGroup, TH1F("match_z0", "Trigger Matched z0; z0 ; Count", 50, -200,200))
879 self.addHistogram(monGroup, TH1F("match_d0", "Trigger Matched d0; d0 ; Count", 50, -0.8,0.8))
880
881 # Denominator
882 self.addHistogram(monGroup, TH1F("pt", "Offline p_{T}; p_{T} [GeV] ; Count", self._nEtbins, self._etbins))
883 self.addHistogram(monGroup, TH1F("et", "Offline E_{T}; E_{T} [GeV] ; Count", self._nEtbins, self._etbins))
884 self.addHistogram(monGroup, TH1F("highet", "Offline E_{T}; E_{T} [GeV] ; Count", 50, 0., 800.))
885 self.addHistogram(monGroup, TH1F("eta", "Offline #eta; #eta ; Count", self._nEtabins, self._etabins))
886 self.addHistogram(monGroup, TH1F("phi", "Offline #phi; #phi ; Count", 20, -3.2, 3.2))
887 self.addHistogram(monGroup, TH1F("avgmu", "<#mu>; <#mu> ; Count", 16, 0, 80))
888 self.addHistogram(monGroup, TH1F("ptvarcone20rel", "ptvarcone20rel; ptvarcone20rel ; Count", 50, 0, 0.2))
889 self.addHistogram(monGroup, TH1F("ptvarcone30rel", "ptvarcone30rel; ptvarcone30rel ; Count", 50, 0, 0.2))
890 self.addHistogram(monGroup, TH1F("z0", "z0; z0 ; Count", 50, -200, 200))
891 self.addHistogram(monGroup, TH1F("d0", "d0; d0 ; Count", 50, -0.8, 0.8))
892
893
894 # Efficiency
895 self.addHistogram(monGroup, TProfile("pt,pt_passed", "#epsilon(p_T); p_{T} ; Efficiency", self._nEtbins, self._etbins))
896 self.addHistogram(monGroup, TProfile("et,et_passed", "#epsilon(E_T); E_{T} [GeV] ; Efficiency", self._nEtbins, self._etbins))
897 self.addHistogram(monGroup, TProfile("highet,highet_passed", "#epsilon(E_T); E_{T} [GeV] ; Efficiency", 50, 0., 800.))
898 self.addHistogram(monGroup, TProfile("eta,eta_passed", "#epsilon(#eta); #eta ; Efficiency", self._nEtabins, self._etabins))
899 self.addHistogram(monGroup, TProfile("phi,phi_passed", "#epsilon(#phi); #phi ; Efficiency", 20, -3.2, 3.2))
900 self.addHistogram(monGroup, TProfile("avgmu,avgmu_passed", "#epsilon(<#mu>); <#mu> ; Efficiency", 16, 0, 80))
901 self.addHistogram(monGroup, TProfile("ptvarcone20rel,ptvarcone20rel_passed", "#epsilon(ptvarcone20rel); ptvarcone20rel ; Efficiency", 50, 0, 0.2))
902 self.addHistogram(monGroup, TProfile("ptvarcone30rel,ptvarcone30rel_passed", "#epsilon(ptvarcone30rel); ptvarcone30rel ; Efficiency", 50, 0, 0.2))
903 self.addHistogram(monGroup, TProfile("z0,z0_passed", "#epsilon(z0); z0 ; Efficiency", 50, -200, 200))
904 self.addHistogram(monGroup, TProfile("d0,d0_passed", "#epsilon(d0); d0 ; Efficiency", 50, -0.8, 0.8))
905
906 #2D plots
907 self.addHistogram(monGroup, TH2F("match_avgmu,match_ptvarcone20rel", "Matched ptvarcone20/pt as function of avg #mu; #mu; ptvarcone20/pt; Count",50, 0, 80,50, 0, 0.2))
908 self.addHistogram(monGroup, TH2F("match_avgmu,match_ptvarcone30rel", "Matched ptvarcone30/pt as function of avg #mu; #mu; ptvarcone30/pt; Count",50, 0, 80,50, 0, 0.2))
909
910
911
912 if self.mc_mode:
913 self.addHistogram(monGroup, TH1F("match_npvtx", "Trigger Matched npvtx; npvtx ; Count", 16, 0, 80))
914 self.addHistogram(monGroup, TH1F("npvtx", "npvtx; npvtx ; Count", 16, 0, 80))
915 self.addHistogram(monGroup, TProfile("npvtx,npvtx_passed", "#epsilon(npvtx); npvtx ; Efficiency", 16, 0, 80))
916 self.addHistogram(monGroup, TH2F("match_z0,match_ptvarcone20rel", "Matched ptvarcone20/pt as function of z0; z0; ptvarcone20/pt; Count",50, -200, 200,50, 0, 0.12))
917 self.addHistogram(monGroup, TH2F("match_d0,match_ptvarcone20rel", "Matched ptvarcone20/pt as function of d0; d0; ptvarcone20/pt; Count",50, -0.5, 0.5,50, 0, 0.12))
918
919 # Inefficiency
920 self.addHistogram(monGroup, TProfile("et,et_failed", "#epsilon(E_T); E_{T} [GeV] ; Inefficiency", self._nEtbins, self._etbins))
921 self.addHistogram(monGroup, TProfile("highet,highet_failed", "#epsilon(E_T); E_{T} [GeV] ; Inefficiency", 50, 0., 800.))
922 self.addHistogram(monGroup, TProfile("eta,eta_failed", "#epsilon(#eta); #eta ; Inefficiency", self._nEtabins, self._etabins))
923
924 # Efficiency ET in eta slices
925
926 self.addHistogram(monGroup, TProfile("et_slice0,et_slice0_passed", "#epsilon(E_T) in [|#eta| <= 0.8]; E_{T} [GeV] ; Efficiency", self._nEtbins, self._etbins))
927 self.addHistogram(monGroup, TProfile("et_slice1,et_slice1_passed", "#epsilon(E_T) in [0.8 < |#eta| <= 1.37]; E_{T} [GeV] ; Efficiency", self._nEtbins, self._etbins))
928 self.addHistogram(monGroup, TProfile("et_slice2,et_slice2_passed", "#epsilon(E_T) in [1.37 < |#eta| <= 1.54]; E_{T} [GeV] ; Efficiency", self._nEtbins, self._etbins))
929 self.addHistogram(monGroup, TProfile("et_slice3,et_slice3_passed", "#epsilon(E_T) in [1.54 < |#eta| <= 2.50]; E_{T} [GeV] ; Efficiency", self._nEtbins, self._etbins))
930
931

◆ bookEvent()

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.bookEvent ( self,
monAlg,
analysis,
tap = False )

Definition at line 672 of file TrigEgammaMonitoringConfig.py.

672 def bookEvent(self, monAlg, analysis, tap=False):
673
674 # Create mon group. The group name should be the path name for map
675 monGroup = self.addGroup( monAlg, analysis, self.basePath+'/Expert/Event/'+analysis )
676
677 if tap:
678 cutLabels = ["Events","LAr","RetrieveElectrons","TwoElectrons","PassMinimalTrigger", "PassFullTrigger"]
679 tagLabels=["Electrons","NotTag","OS","SS","ZMass","HasTrack","HasCluster","Eta","Et","IsGoodOQ","GoodPid","NearbyJet","Isolated","GoodProbe","PassTrigger","MatchTrigger"]
680 probeLabels=["Photons","HasCluster","EtCut","Eta","IsGoodOQ","NearbyJet","ZMass","GoodProbe","","PassTrigger","Et22","Et25","Et35","Et50"]
681 #We need to add in the photons for the probe
682 #We also need to add in the photon selection (Is it a good photon)
683
684 monGroup.defineHistogram("CutCounter", type='TH1I', path='', title="Event Selection; Cut ; Count",
685 xbins=len(cutLabels), xmin=0, xmax=len(cutLabels), xlabels=cutLabels)
686 monGroup.defineHistogram("TagCutCounter", type='TH1F', path='', title="Number of Tags; Cut ; Count",
687 xbins=len(tagLabels), xmin=0, xmax=len(tagLabels), xlabels=tagLabels)
688 monGroup.defineHistogram("ProbeCutCounter", type='TH1F', path='', title="Number of Probes; Cut ; Count",
689 xbins=len(probeLabels), xmin=0, xmax=len(probeLabels), xlabels=probeLabels)
690 monGroup.defineHistogram("Mee", type='TH1F', path='', title="Offline M(ee); m_ee [GeV] ; Count",xbins=50,
691 xmin=monAlg.ZeeLowerMass, xmax=monAlg.ZeeUpperMass)
692
693

◆ bookExpertHistograms()

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.bookExpertHistograms ( self,
monAlg,
triggers )

Definition at line 587 of file TrigEgammaMonitoringConfig.py.

587 def bookExpertHistograms( self, monAlg, triggers ):
588
589 self.__logger.info( "Booking all histograms for alg: %s", monAlg.name )
590
591
592 for trigger in triggers:
593
594 info = self.getTrigInfo(trigger)
595 self.__logger.info( "Trigger info: %s", info )
596
597 #Booking histograms
598 #
599 # Distributions
600 #
601 self.bookL1CaloDistributions( monAlg, trigger )
602 self.bookL2CaloDistributions( monAlg, trigger )
603 self.bookEFCaloDistributions( monAlg, trigger )
604
605 self.bookL1CaloResolutions( monAlg, trigger )
606 self.bookL1CaloAbsResolutions( monAlg, trigger )
607 self.bookL2CaloResolutions( monAlg, trigger )
608
609 # Checking the trigger (tag)
610 if info.isTagAndProbeZeeg():
611 self.bookL2PhotonDistributions( monAlg, trigger )
612 self.bookShowerShapesDistributions( monAlg, trigger, "HLT", online=True )
613 self.bookShowerShapesDistributions( monAlg, trigger, "HLT", online=False)
614 self.bookHLTPhotonResolutions( monAlg, trigger, info.isIsolated() )
615
616 if info.isElectron():
617 self.bookL2ElectronDistributions( monAlg, trigger )
618 # Offline and HLT
619 self.bookShowerShapesDistributions( monAlg, trigger, "HLT" ,online=True)
620 self.bookShowerShapesDistributions( monAlg, trigger, "HLT" ,online=False)
621 self.bookTrackingDistributions( monAlg, trigger, online=True )
622 self.bookTrackingDistributions( monAlg, trigger, online=False )
623 self.bookHLTResolutions( monAlg, trigger,"HLT" )
624 self.bookHLTElectronResolutions( monAlg, trigger, info.isIsolated() )
625
626 elif info.isPhoton():
627 self.bookL2PhotonDistributions( monAlg, trigger )
628 self.bookShowerShapesDistributions( monAlg, trigger, "HLT", online=True )
629 self.bookShowerShapesDistributions( monAlg, trigger, "HLT", online=False)
630 self.bookHLTPhotonResolutions( monAlg, trigger, info.isIsolated() )
631
632
633 #
634 # Efficiencies
635 #
636
637 self.bookEfficiencies( monAlg, trigger, "L1Calo" )
638 self.bookEfficiencies( monAlg, trigger, "FastCalo" )
639 if info.isTagAndProbeZeeg():
640 self.bookEfficiencies( monAlg, trigger, "FastPhoton")
641 if info.isPhoton():
642 self.bookEfficiencies( monAlg, trigger, "FastPhoton")
643 if info.isElectron():
644 self.bookEfficiencies( monAlg, trigger, "FastElectron")
645
646 self.bookEfficiencies( monAlg, trigger, "PrecisionCalo" )
647 self.bookEfficiencies( monAlg, trigger, "HLT")
648 if self.detailedHistograms:
649 for pid in self.isemnames + self.lhnames:
650 self.bookEfficiencies( monAlg, trigger, "HLT", pid )
651 self.bookEfficiencies( monAlg, trigger, "HLT", pid+"Iso" )
652
653 #
654 # Emulation
655 #
656 if self.emulator:
657 self.bookEfficiencies( monAlg, trigger, "L1Calo" , doEmulation=True)
658 self.bookEfficiencies( monAlg, trigger, "FastCalo" , doEmulation=True)
659 self.bookEfficiencies( monAlg, trigger, "PrecisionCalo" , doEmulation=True)
660 if info.isTagAndProbeZeeg():
661 self.bookEfficiencies( monAlg, trigger, "FastPhoton")
662 if info.isPhoton():
663 self.bookEfficiencies( monAlg, trigger, "FastPhoton")
664 if info.isElectron():
665 self.bookEfficiencies( monAlg, trigger, "FastElectron")
666 self.bookEfficiencies( monAlg, trigger, "HLT" , doEmulation=True)
667
668 # Inefficiencies
669 self.bookInefficiencies(monAlg, trigger)
670
671

◆ bookHLTElectronResolutions()

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.bookHLTElectronResolutions ( self,
monAlg,
trigger,
isolated = False )

Definition at line 1084 of file TrigEgammaMonitoringConfig.py.

1084 def bookHLTElectronResolutions(self, monAlg, trigger, isolated=False):
1085
1086 from TrigEgammaMonitoring.TrigEgammaMonitorHelper import TH1F, TH2F
1087 monGroup = self.addGroup( monAlg, trigger+'_Resolutions_HLT', self.basePath+'/Shifter/'+trigger+'/Resolutions/HLT')
1088
1089 self.addHistogram(monGroup, TH1F("res_pt", "p_{T} resolution; (p_{T}(on)-p_{T}(off))/p_{T}(off) ; Count", 120, -1.5, 1.5))
1090 self.addHistogram(monGroup, TH1F("res_deta1", "deta1; deta1 ; (deta1(on)-deta1(off))/deta1(off)", 100, -1., 1.))
1091 self.addHistogram(monGroup, TH1F("res_deta2", "deta2; deta2 ; (deta2(on)-deta2(off))/deta2(off)", 100, -1., 1.))
1092 self.addHistogram(monGroup, TH1F("res_dphi2", "dphi2; dphi2 ; (dphi2(on)-dphi2(off))/dphi2(off)", 100, -1., 1.))
1093 self.addHistogram(monGroup, TH1F("res_z0", "resolution z0; (z0(on)-z0(off)) ; Count", 100, -0.5, 0.5))
1094 self.addHistogram(monGroup, TH1F("res_d0", "resolution d0; (d0(on)-d0(off)) ; Count", 100, -0.5, 0.5))
1095 self.addHistogram(monGroup, TH1F("res_d0sig", "resolution d0sig; (d0sig(on)-d0sig(off)) ; Count", 50, -10, 10))
1096
1097 if self.mc_mode:
1098 self.addHistogram(monGroup, TH1F("pt", "online p_{T}; p_{T}; Count", 50, 0., 100.))
1099 self.addHistogram(monGroup, TH1F("res_nscthits","resolution nSCTHit; (nSCTHits(on)-nSCTHits(off); Count",20, -10, 10))
1100 self.addHistogram(monGroup, TH1F("res_npixhits","resolution nPixHit; (nPixHits(on)-nPixHits(off)); Count",10, -5, 5))
1101 self.addHistogram(monGroup, TH2F("pt,res_eprobht", "eProbHT resolution as function of p_{T}; p_{T} [GeV]; (eprobHT(on)-eprobHT(off)); Count",50, 0., 100.,50, -1., 1.))
1102 self.addHistogram(monGroup, TH1F("res_dphiresc", "dphiresc; (dphires(on)-dphires(off))/dphires(off) ; Count", 100, -1., 1.))
1103 self.addHistogram(monGroup, TH1F("res_eprobht","resolution eProbHT; (eProbHT(on)-eProbHT(off)); Count",50, -1, 1))
1104
1105 if isolated:
1106 self.addHistogram(monGroup, TH1F("res_ptcone20", "resolution ptcone20; ptcone20 (on-off)/off; Count", 200, -0.1, 0.1))
1107 self.addHistogram(monGroup, TH1F("res_ptcone20_rel", "resolution ptcone20/pt; ptcone20/pt (on-off)/off; Count", 100, -0.1, 0.1))
1108 self.addHistogram(monGroup, TH2F("eta,res_ptcone20_rel", "HLT ptcone20/pt resolution as function of #eta; #eta; (on-off)/off; Count",
1109 50, -2.47, 2.47,
1110 100, -0.1, 0.1))
1111 self.addHistogram(monGroup, TH2F("et,res_ptcone20_rel", "HLT ptcone20/pt resolution as function of E_{T}; E_{T} [GeV]; (on-off)/off; Count",
1112 50, 0., 100.,
1113 100, -0.1, 0.1))
1114 self.addHistogram(monGroup, TH2F("mu,res_ptcone20", "HLT ptcone20 resolution as function of avg #mu; #mu; (on-off)/off; Count",
1115 50, 0, 100,
1116 100, -0.1, 0.1))
1117 self.addHistogram(monGroup, TH2F("mu,res_ptcone20_rel", "HLT ptcone20/pt resolution as function of avg #mu; #mu; (on-off)/off; Count",
1118 50, 0, 100,
1119 100, -0.1, 0.1))
1120
1121 self.addHistogram(monGroup, TH1F("res_ptvarcone20", "resolution ptvarcone20; ptvarcone20 (on-off)/off; Count", 200, -0.1, 0.1))
1122 self.addHistogram(monGroup, TH1F("res_ptvarcone20_rel", "resolution ptvarcone20/pt; ptvarcone20/pt (on-off)/off; Count", 100, -0.1, 0.1))
1123 self.addHistogram(monGroup, TH2F("eta,res_ptvarcone20_rel", "HLT ptvarcone20/pt resolution as function of #eta; #eta; (on-off)/off; Count",
1124 50, -2.47, 2.47,
1125 100, -0.1, 0.1))
1126 self.addHistogram(monGroup, TH2F("et,res_ptvarcone20_rel", "HLT ptvarcone20/pt resolution as function of E_{T}; E_{T} [GeV]; (on-off)/off; Count",
1127 50, 0., 100.,
1128 100, -0.1, 0.1))
1129 self.addHistogram(monGroup, TH2F("mu,res_ptvarcone20", "HLT ptvarcone20 resolution as function of avg #mu; #mu; (on-off)/off; Count",
1130 50, 0, 100,
1131 100, -0.1, 0.1))
1132 self.addHistogram(monGroup, TH2F("mu,res_ptvarcone20_rel", "HLT ptvarcone20/pt resolution as function of avg #mu; #mu; (on-off)/off; Count",
1133 50, 0, 100,
1134 100, -0.1, 0.1))
1135
1136

◆ bookHLTPhotonResolutions()

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.bookHLTPhotonResolutions ( self,
monAlg,
trigger,
isolated = False )

Definition at line 1137 of file TrigEgammaMonitoringConfig.py.

1137 def bookHLTPhotonResolutions(self, monAlg, trigger, isolated=False):
1138
1139
1140 from TrigEgammaMonitoring.TrigEgammaMonitorHelper import TH1F, TH2F
1141 monGroup = self.addGroup( monAlg, trigger+'_Resolutions_HLT', self.basePath+'/Shifter/'+trigger+'/Resolutions/HLT' )
1142
1143 self.addHistogram(monGroup, TH1F("res_et_cnv", "HLT E_{T} resolution for converted Photons; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 200, -0.1, 0.1))
1144 self.addHistogram(monGroup, TH1F("res_et_uncnv", "HLT E_{T} resolution for unconverted Photons; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 200, -0.1, 0.1))
1145
1146 if self.data_type is DQDataType.MC:
1147 self.addHistogram(monGroup, TH2F("eta,res_cnv_et",
1148 "HLT E_{T} resolution as function of #eta for converted Photons; #eta; (E_{T}(on)-E_{T}(off))/E_{T}(off); Count",
1149 50, -2.47, 2.47,
1150 200, -0.1, 0.1))
1151 self.addHistogram(monGroup, TH2F("et,res_cnv_et",
1152 "HLT E_{T} resolution as function of E_{T} for converted Photons; E_{T} [GeV]; (E_{T}(on)-E_{T}(off))/E_{T}(off); Count",
1153 50, 0., 100.,
1154 200, -0.1, 0.1))
1155 self.addHistogram(monGroup, TH2F("eta,res_uncnv_et",
1156 "HLT E_{T} resolution as function of #eta for unconverted Photons; #eta; (E_{T}(on)-E_{T}(off))/E_{T}(off); Count",
1157 50, -2.47, 2.47,
1158 200, -0.1, 0.1))
1159 self.addHistogram(monGroup, TH2F("et,res_uncnv_et",
1160 "HLT E_{T} resolution as function of E_{T} for unconverted Photons; E_{T} [GeV]; (E_{T}(on)-E_{T}(off))/E_{T}(off); Count",
1161 50, 0., 100.,
1162 200, -0.1, 0.1))
1163 self.addHistogram(monGroup, TH1F("res_cnv_etInEta0", "HLT E_{T} resolution in #eta = [0#div1.37]; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 200, -0.1, 0.1))
1164 self.addHistogram(monGroup, TH1F("res_cnv_etInEta1", "HLT E_{T} resolution in #eta = [1.37#div1.52]; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 200, -0.1, 0.1))
1165 self.addHistogram(monGroup, TH1F("res_cnv_etInEta2", "HLT E_{T} resolution in #eta = [1.55#div1.8]; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 200, -0.1, 0.1))
1166 self.addHistogram(monGroup, TH1F("res_cnv_etInEta3", "HLT E_{T} resolution in #eta = [1.8#div2.45]; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 200, -0.1, 0.1))
1167 self.addHistogram(monGroup, TH1F("res_uncnv_etInEta0", "HLT E_{T} resolution in #eta = [0#div1.37]; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 200, -0.1, 0.1))
1168 self.addHistogram(monGroup, TH1F("res_uncnv_etInEta1", "HLT E_{T} resolution in #eta = [1.37#div1.52]; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 200, -0.1, 0.1))
1169 self.addHistogram(monGroup, TH1F("res_uncnv_etInEta2", "HLT E_{T} resolution in #eta = [1.55#div1.8]; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 200, -0.1, 0.1))
1170 self.addHistogram(monGroup, TH1F("res_uncnv_etInEta3", "HLT E_{T} resolution in #eta = [1.8#div2.45]; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 200, -0.1, 0.1))
1171
1172
1173 if isolated:
1174
1175 self.addHistogram(monGroup, TH1F("res_topoetcone20", "resolution topoetcone20; ptcone20 (on-off)/off; Count", 200, -0.1, 0.1))
1176 self.addHistogram(monGroup, TH1F("res_topoetcone20_rel", "resolution topoetcone20/pt; ptcone20/pt (on-off)/off; Count", 100, -0.1, 0.1))
1177
1178 if self.detailedHistograms:
1179 self.addHistogram(monGroup, TH2F("eta,res_topoetcone20_rel", "HLT topoetcone20/pt resolution as function of #eta; #eta; (on-off)/off; Count",
1180 50, -2.47, 2.47,
1181 100, -0.1, 0.1))
1182 self.addHistogram(monGroup, TH2F("et,res_topoetcone20_rel", "HLT topoetcone20/pt resolution as function of E_{T}; E_{T} [GeV]; (on-off)/off; Count",
1183 50, 0., 100.,
1184 100, -0.1, 0.1))
1185 self.addHistogram(monGroup, TH2F("mu,res_topoetcone20", "HLT topoetcone20 resolution as function of avg #mu; #mu; (on-off)/off; Count",
1186 50, 0, 100,
1187 100, -0.1, 0.1))
1188 self.addHistogram(monGroup, TH2F("mu,res_topoetcone20_rel", "HLT topoetcone20/pt resolution as function of avg #mu; #mu; (on-off)/off; Count",
1189 50, 0, 100,
1190 100, -0.1, 0.1))
1191
1192
1193

◆ bookHLTResolutions()

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.bookHLTResolutions ( self,
monAlg,
trigger,
level )

Definition at line 1047 of file TrigEgammaMonitoringConfig.py.

1047 def bookHLTResolutions(self, monAlg, trigger,level):
1048
1049 from TrigEgammaMonitoring.TrigEgammaMonitorHelper import TH1F, TH2F
1050 monGroup = self.addGroup( monAlg, trigger+'_Resolutions_HLT', self.basePath+'/Shifter/'+trigger+'/Resolutions/'+level )
1051 self.__logger.debug("inside the bookHLTResolutions def = %s", monGroup)
1052
1053 # online values used to fill all 2d histograms
1054 self.addHistogram(monGroup, TH1F("et", "E_{T}; E_{T}[GeV] ; Count", 50, 0.0, 100.))
1055 self.addHistogram(monGroup, TH1F("eta", "#eta; #eta ; Count", 50, -2.47, 2.47))
1056 self.addHistogram(monGroup, TH1F("mu", "#mu; #mu ; Count", 50, 0, 100))
1057
1058 self.addHistogram(monGroup, TH1F("res_et", "E_{T} resolution; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 100, -0.1, 0.1))
1059 self.addHistogram(monGroup, TH1F("res_eta", "#eta resolution; (#eta(on)-#eta(off))/#eta(off) ; Count", 40, -0.001, 0.001))
1060 self.addHistogram(monGroup, TH1F("res_phi", "#phi resolution; (#phi(on)-#phi(off))/#phi(off) ; Count", 40, -0.001, 0.001))
1061 self.addHistogram(monGroup, TH1F("res_ethad", "ethad resolution; (ethad(on)-ethad(off))/ethad(off) ; Count", 20, -5, 5))
1062 self.addHistogram(monGroup, TH1F("res_Rhad", "Rhad resolution; (Rhad(on)-Rhad(off))/Rhad(off) ; Count", 20, -10., 10.))
1063 self.addHistogram(monGroup, TH1F("res_Reta", "Reta resolution; (Reta(on)-Reta(off))/Reta(off) ; Count", 20, -0.01, 0.01))
1064 self.addHistogram(monGroup, TH1F("res_Rphi", "Rphi resolution; (Rphi(on)-Rphi(off))/Rphi(off) ; Count", 20, -0.01, 0.01))
1065 self.addHistogram(monGroup, TH1F("res_weta2", "weta2 resolution; (weta2(on)-weta2(off))/weta2(off) ; Count", 20, -0.05, 0.05))
1066 self.addHistogram(monGroup, TH1F("res_eratio", "eratio resolution; (eratio(on)-eratio(off))/eratio(off) ; Count", 20, -0.001, 0.001))
1067
1068
1069 if self.mc_mode:
1070 self.addHistogram(monGroup, TH1F("res_weta1", "weta1 resolution; (weta1(on)-weta1(off))/weta1(off) ; Count", 20, -0.05, 0.05))
1071 self.addHistogram(monGroup, TH1F("res_ethad1", "ethad1 resolution; (ethad1(on)-ethad1(off))/ethad1(off) ; Count", 20, -5, 5))
1072 self.addHistogram(monGroup, TH1F("res_Rhad1", "Rhad1; Rhad1 resolution; (Rhad1(on)-Rhad1(off))/Rhad1(off)", 20, -10., 10.))
1073 self.addHistogram(monGroup, TH2F("eta,res_et", "E_{T} resolution as function of #eta; #eta; (E_{T}(on)-E_{T}(off))/E_{T}(off); Count",50, -2.47, 2.47,100, -0.1, 0.1))
1074 self.addHistogram(monGroup, TH2F("et,res_et", "E_{T} resolution as function of E_{T}; E_{T} [GeV]; (E_{T}(on)-E_{T}(off))/E_{T}(off); Count",50, 0., 100.,100, -0.1, 0.1))
1075 self.addHistogram(monGroup, TH1F("res_etInEta0", "HLT E_{T} resolution in #eta = [0#div1.37]; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 200, -0.1, 0.1))
1076 self.addHistogram(monGroup, TH1F("res_etInEta1", "HLT E_{T} resolution in #eta = [1.37#div1.52]; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 200, -0.1, 0.1))
1077 self.addHistogram(monGroup, TH1F("res_etInEta2", "HLT E_{T} resolution in #eta = [1.55#div1.8]; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 200, -0.1, 0.1))
1078 self.addHistogram(monGroup, TH1F("res_etInEta3", "HLT E_{T} resolution in #eta = [1.8#div2.45]; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 200, -0.1, 0.1))
1079 self.addHistogram(monGroup, TH1F("res_f1", "f1 resolution; (f1(on)-f1(off))/f1(off) ; Count", 20, -0.05, 0.05))
1080 self.addHistogram(monGroup, TH1F("res_f3", "f3 resolution; (f3(on)-f3(off))/f3(off) ; Count", 20, -0.05, 0.05))
1081
1082
1083

◆ bookInefficiencies()

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.bookInefficiencies ( self,
monAlg,
trigger )

Definition at line 932 of file TrigEgammaMonitoringConfig.py.

932 def bookInefficiencies(self, monAlg, trigger):
933
934 monGroup = self.addGroup( monAlg, trigger+'_Inefficiency', self.basePath+'/Expert/Inefficiency/'+trigger)
935 levelLabels = ["L1Calo","L2Calo","L2","EFCalo","HLT"]
936 monGroup.defineHistogram("InefficiencyCounts", type='TH1F', path='', title="Inefficiency; Steps ; Count",xbins=len(levelLabels), xmin=0, xmax=len(levelLabels), xlabels=levelLabels)
937
938

◆ bookL1CaloAbsResolutions()

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.bookL1CaloAbsResolutions ( self,
monAlg,
trigger )

Definition at line 950 of file TrigEgammaMonitoringConfig.py.

950 def bookL1CaloAbsResolutions(self, monAlg, trigger):
951
952 from TrigEgammaMonitoring.TrigEgammaMonitorHelper import TH1F, TH2F
953 monGroup = self.addGroup( monAlg, trigger+'_AbsResolutions_L1Calo', self.basePath+'/Shifter/'+trigger+'/AbsResolutions/L1Calo' )
954 self.addHistogram(monGroup, TH1F("res_et", "E_{T} resolution; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 100, -0.1, 0.1))
955 self.addHistogram(monGroup, TH1F("eta", "#eta; #eta ; Count", 50, -2.47, 2.47))
956
957 if self.mc_mode:
958 self.addHistogram(monGroup, TH2F("eta,res_et", "E_{T} resolution as function of #eta; #eta; (E_{T}(on)-E_{T}(off))/E_{T}(off); Count",50, -2.47, 2.47,50, -0.1, 0.1))
959
960

◆ bookL1CaloDistributions()

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.bookL1CaloDistributions ( self,
monAlg,
trigger )

Definition at line 697 of file TrigEgammaMonitoringConfig.py.

697 def bookL1CaloDistributions( self , monAlg, trigger ):
698
699 from TrigEgammaMonitoring.TrigEgammaMonitorHelper import TH1F
700 monGroup = self.addGroup( monAlg, trigger+'_Distributions_L1Calo', self.basePath+'/Shifter/'+trigger+'/Distributions/L1Calo' )
701
702 #if 'L1eEM' in trigger:
703
704 self.addHistogram(monGroup, TH1F("et" , "Et; Et [GeV] ; Count", 100, 0., 800.))
705 self.addHistogram(monGroup, TH1F("eta" , "eta; eta ; Count" , 50, -2.5, 2.5))
706 self.addHistogram(monGroup, TH1F("phi" , "phi; phi ; Count" , 20, -3.2, 3.2))
707 self.addHistogram(monGroup, TH1F("Rhad" , "Rhad; Rhad ; Count" , 40, 0, 1))
708 self.addHistogram(monGroup, TH1F("Reta" , "Reta; Reta ; Count" , 40, 0, 1 ))
709 self.addHistogram(monGroup, TH1F("Wstot" , "Wstot; Wstot ; Count", 40, 0, 4 ))
710

◆ bookL1CaloResolutions()

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.bookL1CaloResolutions ( self,
monAlg,
trigger )

Definition at line 939 of file TrigEgammaMonitoringConfig.py.

939 def bookL1CaloResolutions(self, monAlg, trigger):
940
941 from TrigEgammaMonitoring.TrigEgammaMonitorHelper import TH1F, TH2F
942 monGroup = self.addGroup( monAlg, trigger+'_Resolutions_L1Calo', self.basePath+'/Shifter/'+trigger+'/Resolutions/L1Calo' )
943 self.addHistogram(monGroup, TH1F("res_et", "E_{T} resolution; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 100, -0.1, 0.1))
944
945 if self.mc_mode:
946 self.addHistogram(monGroup, TH2F("eta,res_et", "E_{T} resolution as function of #eta; #eta; (E_{T}(on)-E_{T}(off))/E_{T}(off); Count",50, -2.47, 2.47,50, -0.1, 0.1))
947 self.addHistogram(monGroup, TH1F("eta", "eta; eta ; Count", 50, -2.47, 2.47))
948
949

◆ bookL2CaloDistributions()

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.bookL2CaloDistributions ( self,
monAlg,
trigger )

Definition at line 714 of file TrigEgammaMonitoringConfig.py.

714 def bookL2CaloDistributions( self , monAlg, trigger ):
715
716 from TrigEgammaMonitoring.TrigEgammaMonitorHelper import TH1F
717 monGroup = self.addGroup( monAlg, trigger+'_Distributions_L2Calo', self.basePath+'/Shifter/'+trigger+'/Distributions/FastCalo' )
718
719 self.addHistogram(monGroup, TH1F("et", "ET; ET [GeV] ; Count", 100, 0., 100.))
720 self.addHistogram(monGroup, TH1F("highet", "ET; ET [GeV] ; Count", 100, 0., 800.))
721 self.addHistogram(monGroup, TH1F("eta", "eta; eta ; Count", self._nEtabins, self._etabins))
722 self.addHistogram(monGroup, TH1F("phi", "phi; phi ; Count", 20, -3.2, 3.2))
723
724

◆ bookL2CaloResolutions()

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.bookL2CaloResolutions ( self,
monAlg,
trigger )

Definition at line 961 of file TrigEgammaMonitoringConfig.py.

961 def bookL2CaloResolutions(self, monAlg, trigger):
962
963 from TrigEgammaMonitoring.TrigEgammaMonitorHelper import TH1F, TH2F
964 monGroup = self.addGroup( monAlg, trigger+'_Resolutions_L2Calo', self.basePath+'/Shifter/'+trigger+'/Resolutions/FastCalo' )
965
966 # online values used to fill all 2d histograms
967
968 self.addHistogram(monGroup, TH1F("res_Rhad", "Rhad resolution; (Rhad(on)-Rhad(off))/Rhad(off) ; Count", 20, -10., 10.))
969 self.addHistogram(monGroup, TH1F("res_et", "E_{T} resolution; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 100, -0.1, 0.1))
970 self.addHistogram(monGroup, TH1F("res_eta", "#eta resolution; (#eta(on)-#eta(off))/#eta(off) ; Count", 40, -0.001, 0.001))
971 self.addHistogram(monGroup, TH1F("res_phi", "#phi resolution; (#phi(on)-#phi(off))/#phi(off) ; Count", 40, -0.001, 0.001))
972 self.addHistogram(monGroup, TH1F("res_ethad", "ethad resolution; (ethad(on)-ethad(off))/ethad(off) ; Count", 20, -5, 5))
973 self.addHistogram(monGroup, TH1F("res_weta2", "weta2 resolution; (weta2(on)-weta2(off))/weta2(off) ; Count", 20, -0.05, 0.05))
974 self.addHistogram(monGroup, TH1F("res_Reta", "Reta resolution; (Reta(on)-Reta(off))/Reta(off) ; Count", 20, -0.01, 0.01))
975 self.addHistogram(monGroup, TH1F("res_Rphi", "Rphi resolution; (Rphi(on)-Rphi(off))/Rphi(off) ; Count", 20, -0.01, 0.01))
976 self.addHistogram(monGroup, TH1F("res_eratio", "eratio resolution; (eratio(on)-eratio(off))/eratio(off) ; Count", 20, -0.001, 0.001))
977
978 if self.mc_mode:
979 self.addHistogram(monGroup, TH1F("res_ethad1", "ethad1 resolution; (ethad1(on)-ethad1(off))/ethad1(off) ; Count", 20, -5, 5))
980 self.addHistogram(monGroup, TH1F("res_Rhad1", "Rhad1; Rhad1 resolution; (Rhad1(on)-Rhad1(off))/Rhad1(off)", 20, -10., 10.))
981 self.addHistogram(monGroup, TH1F("res_f1", "f1 resolution; (f1(on)-f1(off))/f1(off) ; Count", 20, -0.05, 0.05))
982 self.addHistogram(monGroup, TH1F("res_f3", "f3 resolution; (f3(on)-f3(off))/f3(off) ; Count", 20, -0.05, 0.05))
983
984 # Book all 2D histograms
985 self.addHistogram(monGroup, TH2F("et,res_etVsEt", "E_{T} resolution as function of E_{T}; E_{T} [GeV]; (E_{T}(on)-E_{T}(off))/E_{T}(off); Count",
986 50, 0., 100.,
987 100, -0.1, 0.1))
988 self.addHistogram(monGroup, TH2F("eta,res_et", "E_{T} resolution as function of #eta; #eta; (E_{T}(on)-E_{T}(off))/E_{T}(off); Count",
989 50, -2.47, 2.47,
990 100, -0.1, 0.1))
991 self.addHistogram(monGroup, TH2F("eta,res_f3", "L2Calo f3 resolution as function of #eta; #eta; (f3(on)-f3(off))/f3(off); Count",
992 50, -2.47, 2.47,
993 20, -0.05, 0.05))
994 self.addHistogram(monGroup, TH2F("et,res_f3", "L2Calo f3 resolution as function of E_{T}; E_{T} [GeV]; (f3(on)-f3(off))/f3(off); Count",
995 50, 0., 100.,
996 20, -0.05, 0.05))
997 self.addHistogram(monGroup, TH2F("eta,res_f1", "L2Calo f1 resolution as function of #eta; #eta; (f1(on)-f1(off))/f1(off); Count",
998 50, -2.47, 2.47,
999 20, -0.05, 0.05))
1000 self.addHistogram(monGroup, TH2F("et,res_f1", "L2Calo f1 resolution as function of E_{T}; E_{T} [GeV]; (f1(on)-f1(off))/f1(off); Count",
1001 50, 0., 100.,
1002 20, -0.05, 0.05))
1003 self.addHistogram(monGroup, TH2F("eta,res_weta2", "L2Calo weta2 resolution as function of #eta; #eta; (weta2(on)-weta2(off))/weta2(off); Count",
1004 50, -2.47, 2.47,
1005 20, -0.05, 0.05))
1006 self.addHistogram(monGroup, TH2F("et,res_weta2", "L2Calo weta2 resolution as function of E_{T}; E_{T} [GeV]; (weta2(on)-weta2(off))/weta2(off); Count",
1007 50, 0., 100.,
1008 20, -0.05, 0.05))
1009 self.addHistogram(monGroup, TH2F("eta,res_Reta", "L2Calo Reta resolution as function of #eta; #eta; (Reta(on)-Reta(off))/Reta(off); Count",
1010 50, -2.47, 2.47,
1011 20, -0.05, 0.05))
1012 self.addHistogram(monGroup, TH2F("et,res_Reta", "L2Calo Reta resolution as function of E_{T}; E_{T} [GeV]; (Reta(on)-Reta(off))/Reta(off); Count",
1013 50, 0., 100.,
1014 20, -0.05, 0.05))
1015 self.addHistogram(monGroup, TH2F("eta,res_Rhad1", "L2Calo E_{T} Rhad1 resolution as function of #eta; #eta; (Rhad1(on)-Rhad1(off))/Rhad1(off); Count",
1016 50, -2.47, 2.47,
1017 20, -10, 10))
1018 self.addHistogram(monGroup, TH2F("et,res_Rhad1", "L2Calo E_{T} RHad1 resolution as function of E_{T}; E_{T} [GeV]; (Rhad1(on)-Rhad1(off))/Rhad1(off); Count",
1019 50, 0., 100.,
1020 20, -10, 10))
1021 self.addHistogram(monGroup, TH2F("eta,res_Rhad", "L2Calo E_{T} Rhad resolution as function of #eta; #eta; (Rhad(on)-Rhad(off))/Rhad(off); Count",
1022 50, -2.47, 2.47,
1023 20, -10, 10))
1024 self.addHistogram(monGroup, TH2F("et,res_Rhad", "L2Calo E_{T} RHad resolution as function of E_{T}; E_{T} [GeV]; (Rhad(on)-Rhad(off))/Rhad(off); Count",
1025 50, 0., 100.,
1026 20, -10, 10))
1027 self.addHistogram(monGroup, TH2F("eta,res_ethad1", "L2Calo E_{T} Had1 resolution as function of #eta; #eta; (ethad1(on)-ethad1(off))/ethad1(off); Count",
1028 50, -2.47, 2.47,
1029 20, -0.5, 0.5))
1030 self.addHistogram(monGroup, TH2F("et,res_ethad1", "L2Calo E_{T} Had1 resolution as function of E_{T}; E_{T} [GeV]; (ethad1(on)-ethad1(off))/ethad1(off); Count",
1031 50, 0., 100.,
1032 20, -0.5, 0.5))
1033 self.addHistogram(monGroup, TH2F("eta,res_ethad", "L2Calo E_{T} Had resolution as function of #eta; #eta; (ethad(on)-ethad(off))/ethad(off); Count",
1034 50, -2.47, 2.47,
1035 20, -0.5, 0.5))
1036 self.addHistogram(monGroup, TH2F("et,res_ethad", "L2Calo E_{T} Had resolution as function of E_{T}; E_{T} [GeV]; (ethad(on)-ethad(off))/ethad(off); Count",
1037 50, 0., 100.,
1038 20, -0.5, 0.5))
1039 self.addHistogram(monGroup, TH2F("eta,res_eratio", "L2Calo eratio resolution as function of #eta; #eta; (eratio(on)-eratio(off))/eratio(off); Count",
1040 50, -2.47, 2.47,
1041 20, -0.001, 0.001))
1042 self.addHistogram(monGroup, TH2F("et,res_eratio", "L2Calo eratio resolution as function of E_{T}; E_{T} [GeV]; (eratio(on)-eratio(off))/eratio(off); Count",
1043 50, 0., 100.,
1044 50, -0.001, 0.001))
1045
1046

◆ bookL2ElectronDistributions()

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.bookL2ElectronDistributions ( self,
monAlg,
trigger )

Definition at line 728 of file TrigEgammaMonitoringConfig.py.

728 def bookL2ElectronDistributions( self, monAlg, trigger ):
729
730 from TrigEgammaMonitoring.TrigEgammaMonitorHelper import TH1F
731 monGroup = self.addGroup( monAlg, trigger+'_Distributions_L2Electron', self.basePath+'/Shifter/'+trigger+'/Distributions/FastElectron' )
732
733 self.addHistogram(monGroup, TH1F("et", "ET; ET [GeV] ; Count", 100, 0., 100.))
734 self.addHistogram(monGroup, TH1F("highet", "ET; ET [GeV] ; Count", 100, 0., 800.))
735 self.addHistogram(monGroup, TH1F("eta", "eta; eta ; Count", self._nEtabins, self._etabins))
736 self.addHistogram(monGroup, TH1F("phi", "phi; phi ; Count", 20, -3.2, 3.2))
737

◆ bookL2PhotonDistributions()

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.bookL2PhotonDistributions ( self,
monAlg,
trigger )

Definition at line 742 of file TrigEgammaMonitoringConfig.py.

742 def bookL2PhotonDistributions( self, monAlg, trigger ):
743
744 from TrigEgammaMonitoring.TrigEgammaMonitorHelper import TH1F
745 monGroup = self.addGroup( monAlg, trigger+'_Distributions_L2Photon', self.basePath+'/Shifter/'+trigger+'/Distributions/FastPhoton' )
746
747 self.addHistogram(monGroup, TH1F("et", "ET; ET [GeV] ; Count", 100, 0., 100.))
748 self.addHistogram(monGroup, TH1F("highet", "ET; ET [GeV] ; Count", 100, 0., 800.))
749 self.addHistogram(monGroup, TH1F("eta", "eta; eta ; Count", self._nEtabins, self._etabins))
750 self.addHistogram(monGroup, TH1F("phi", "phi; phi ; Count", 20, -3.2, 3.2))

◆ bookShowerShapesDistributions()

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.bookShowerShapesDistributions ( self,
monAlg,
trigger,
level,
online = True )

Definition at line 777 of file TrigEgammaMonitoringConfig.py.

777 def bookShowerShapesDistributions( self, monAlg, trigger, level, online=True):
778
779 from TrigEgammaMonitoring.TrigEgammaMonitorHelper import TH1F
780
781 monGroup = self.addGroup( monAlg, trigger+'_Distributions_' + ("HLT" if online else "Offline"),
782 self.basePath+'/Shifter/'+trigger+'/Distributions/' + (level if online else "Offline") )
783
784 info = self.getTrigInfo(trigger)
785
786 self.addHistogram(monGroup, TH1F("Rhad", "Rhad; Rhad ; Count", 35, -0.3, 0.3))
787 self.addHistogram(monGroup, TH1F("Reta", "Reta; Reta ; Count", 15, 0.4, 1.2))
788 self.addHistogram(monGroup, TH1F("Rphi", "Rphi; Rphi ; Count", 15, 0.4, 1.2))
789 self.addHistogram(monGroup, TH1F("weta2", "weta2; weta2 ; Count", 20, 0., 0.02))
790 self.addHistogram(monGroup, TH1F("f1", "f1; f1 ; Count", 11, 0, 1.))
791 self.addHistogram(monGroup, TH1F("f3", "f3; f3 ; Count", 21, -0.05, 0.1))
792 self.addHistogram(monGroup, TH1F("eratio","eratio; eratio; Count",20, 0, 2))
793 self.addHistogram(monGroup, TH1F("et", "ET; ET [GeV] ; Count", 100, 0., 100.))
794 self.addHistogram(monGroup, TH1F("highet", "Offline E_{T}; E_{T} [GeV] ; Count", 100, 0., 800.))
795 self.addHistogram(monGroup, TH1F("eta", "eta; eta ; Count", self._nEtabins, self._etabins))
796 self.addHistogram(monGroup, TH1F("phi", "phi; phi ; Count", 20, -3.2, 3.2))
797
798 if not info.isElectron():
799 self.addHistogram(monGroup, TH1F("topoetcone20", "topoetcone20; topoetcone20 [GeV] ; Count", 100, -10.0, 10.0))
800 self.addHistogram(monGroup, TH1F("topoetcone20_rel", "topoetcone20/pt; topoetcone20/pt ; Count", 100, -0.5, 0.5))
801 self.addHistogram(monGroup, TH1F("topoetcone40_shift", "topoetcone40-2.45 GeV; topoetcone40-2.45 GeV [GeV] ; Count", 100, -10.0, 10.0))
802 self.addHistogram(monGroup, TH1F("topoetcone40_shift_rel", "(topoetcone40-2.45 GeV)/pt; (topoetcone40-2.45 GeV)/pt ; Count", 100, -0.5, 0.5))
803
804 if self.mc_mode:
805 self.addHistogram(monGroup, TH1F("Rhad1", "Rhad1; Rhad1 ; Count", 30, -0.3, 0.3))
806 self.addHistogram(monGroup, TH1F("weta1", "weta1; weta1 ; Count", 12, 0.4, 1.))

◆ bookTopoHistograms()

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.bookTopoHistograms ( self,
monAlg,
trigger_configs )

Definition at line 1194 of file TrigEgammaMonitoringConfig.py.

1194 def bookTopoHistograms(self, monAlg, trigger_configs ):
1195
1196 from TrigEgammaMonitoring.TrigEgammaMonitorHelper import TH1F, TProfile
1197 from TrigEgammaMonitoring.TrigEgammaMonitCategory import topo_config
1198
1199
1200 for d in trigger_configs:
1201
1202 trigger = d['trigger_num']
1203
1204 if not d['topo'] in topo_config.keys():
1205 self.__logger.fatal("Mon combo tool only support Zee, Jpsiee, Heg trigger. Current chain is %s", trigger)
1206
1207 monGroup_on = self.addGroup( monAlg, trigger+'_Efficiency_HLT', self.basePath+'/Expert/'+trigger+'/Efficiency/HLT' )
1208 monGroup_off = self.addGroup( monAlg, trigger+'_Efficiency_Offline', self.basePath+'/Expert/'+trigger+'/Efficiency/Offline' )
1209
1210 xmin = topo_config[d['topo']]['mass'][0]
1211 xmax = topo_config[d['topo']]['mass'][1]
1212 self.addHistogram(monGroup_on, TH1F("mass", "Online M(ee); m_ee [GeV] ; Count", 50, xmin, xmax))
1213 self.addHistogram(monGroup_on, TH1F("match_mass", "Online M(ee); m_ee [GeV] ; Count", 50, xmin, xmax))
1214 self.addHistogram(monGroup_on, TProfile("mass,match_mass", "Online #epsilon(M(ee)); m_ee; #epsilon(M(ee))", 50, xmin, xmax))
1215 self.addHistogram(monGroup_off, TH1F("mass", "Offline M(ee); m_ee [GeV] ; Count", 50, xmin, xmax))
1216 self.addHistogram(monGroup_off, TH1F("match_mass", "Offline M(ee); m_ee [GeV] ; Count", 50, xmin, xmax))
1217 self.addHistogram(monGroup_off, TProfile("mass,match_mass", "Offline #epsilon(M(ee)); p_{T} ; #epsilon(M(ee))", 50, xmin, xmax))
1218
1219 xmin = topo_config[d['topo']]['dphi'][0]
1220 xmax = topo_config[d['topo']]['dphi'][1]
1221 self.addHistogram(monGroup_on, TH1F("dphi", "Online #Delta#phi; #Delte#phi; Count", 50, xmin, xmax))
1222 self.addHistogram(monGroup_on, TH1F("match_dphi", "Online #Delta#phi; #Delte#phi; Count", 50, xmin, xmax))
1223 self.addHistogram(monGroup_on, TProfile("dphi,match_dphi", "Online #epsilon(#Delta#phi); #Delta#phi; #epsilon(#Delta#phi)", 50, xmin, xmax))
1224 self.addHistogram(monGroup_off, TH1F("dphi", "Offline #Delta#phi; #Delte#phi; Count", 50, xmin, xmax))
1225 self.addHistogram(monGroup_off, TH1F("match_dphi", "Offline #Delta#phi; #Delte#phi; Count", 50, xmin, xmax))
1226 self.addHistogram(monGroup_off, TProfile("dphi,match_dphi", "Offline #epsilon(#Delta#phi); #Delta#phi; #epsilon(#Delta#phi)", 50, xmin, xmax))
1227
1228

◆ bookTrackingDistributions()

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.bookTrackingDistributions ( self,
monAlg,
trigger,
online = True )

Definition at line 810 of file TrigEgammaMonitoringConfig.py.

810 def bookTrackingDistributions( self, monAlg, trigger,online=True ):
811
812
813 from TrigEgammaMonitoring.TrigEgammaMonitorHelper import TH1F, TH2F
814
815 monGroup = self.addGroup( monAlg, trigger+'_Distributions_' + ("HLT" if online else "Offline"),
816 self.basePath+'/Shifter/'+trigger+'/Distributions/' + ("HLT" if online else "Offline") )
817
818 # Tracking quantities
819 self.addHistogram(monGroup, TH1F("deta2", "deta2; deta2 ; Count", 40, -0.01, 0.01))
820 self.addHistogram(monGroup, TH1F("dphi2", "dphi2; dphi2 ; Count", 40, -0.1, 0.1))
821 self.addHistogram(monGroup, TH1F("eprobht","eProbHT; eProbHT; Count",20, 0, 1.))
822 self.addHistogram(monGroup, TH1F("npixhits","nPixHit; nPixHits; Count",10, 0, 10))
823 self.addHistogram(monGroup, TH1F("nscthits","nSCTHit; nSCTHits; Count",20, 0, 20))
824 self.addHistogram(monGroup, TH1F("pt", "p_{T}; p_{T} [GeV] ; Count", 50,0.,200.))
825 self.addHistogram(monGroup, TH1F("pt_track", "p_{T} tracks; p_{T} [GeV] ; Count", 100,0.,200.))
826 self.addHistogram(monGroup, TH1F("ptcone20", "ptcone20; ptcone20; Count", 50, 0.0, 5.0))
827 self.addHistogram(monGroup, TH1F("ptvarcone20", "ptvarcone20; ptvarcone20; Count", 50, 0.0, 5.0))
828 self.addHistogram(monGroup, TH1F("ptcone20_rel", "ptcone20/pt; ptcone20/pt; Count", 50, 0.0, 1.0))
829 self.addHistogram(monGroup, TH1F("ptcone30_rel", "ptcone30/pt; ptcone30/pt; Count", 50, 0.0, 1.0))
830 self.addHistogram(monGroup, TH1F("ptvarcone20_rel", "ptvarcone20/pt; ptvarcone20/pt; Count", 50, 0.0, 0.2))
831 self.addHistogram(monGroup, TH1F("ptvarcone30_rel", "ptvarcone30/pt; ptvarcone30/pt; Count", 50, 0.0, 0.2))
832 self.addHistogram(monGroup, TH1F("z0", "z0; z0 ; Count", 50, -200, 200))
833 self.addHistogram(monGroup, TH1F("d0", "d0; d0 ; Count", 40, -1, 1))
834 self.addHistogram(monGroup, TH1F("d0sig", "d0sig; d0sig ; Count", 40, -10, 10))
835
836 self.addHistogram(monGroup, TH2F("mu,ptvarcone20_rel", "HLT ptvarcone20/pt as function of avg #mu; #mu; ptvarcone20/pt; Count",50, 0, 80,50, 0, 0.12))
837 self.addHistogram(monGroup, TH2F("eta,ptvarcone20_rel", "HLT ptvarcone20/pt as function of #eta; #eta; ptvarcone20/pt; Count",50, -3, 3,50, 0, 0.12))
838
839 self.addHistogram(monGroup, TH2F("pt,ptvarcone20_rel", "HLT ptvarcone20/pt as function of pt; pt [GeV]; ptvarcone20/pt; Count",50, 0, 200,50, 0, 0.12))
840 self.addHistogram(monGroup, TH2F("pt_track,ptvarcone20_rel", "HLT ptvarcone20/pt as function of pt_track; pt [GeV]; ptvarcone20/pt; Count",50, 0, 200,50, 0, 0.12))
841
842 if self.mc_mode:
843 self.addHistogram(monGroup, TH1F("deta1_EMECA", "deta1 EMEC-A; deta1 ; Count", 40, -0.01, 0.01))
844 self.addHistogram(monGroup, TH1F("deta1_EMECC", "deta1 EMEC-C; deta1 ; Count", 40, -0.01, 0.01))
845 self.addHistogram(monGroup, TH1F("deta1_EMEBA", "deta1 EMEB-A; deta1 ; Count", 40, -0.01, 0.01))
846 self.addHistogram(monGroup, TH1F("deta1_EMEBC", "deta1 EMEB-A; deta1 ; Count", 40, -0.01, 0.01))
847 self.addHistogram(monGroup, TH1F("deta1", "deta1; deta1 ; Count", 40, -0.01, 0.01))
848 self.addHistogram(monGroup, TH1F("charge","charge; charge; Count", 4,-2,2))
849 self.addHistogram(monGroup, TH1F("dphiresc", "dphiresc; dphiresc ; Count", 40, -0.1, 0.1))
850 self.addHistogram(monGroup, TH2F("z0,ptvarcone20_rel", "HLT ptvarcone20/pt as function of z0; z0; ptvarcone20/pt; Count",50, -200, 200,50, 0, 0.12))
851
852

◆ configure()

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.configure ( self)

Definition at line 120 of file TrigEgammaMonitoringConfig.py.

120 def configure(self):
121 self.setProperties()
122 self.configureMonitor()
123 self.configureHistograms()
124
125
configure
bool configure(asg::AnaToolHandle< ITrigGlobalEfficiencyCorrectionTool > &tool, ToolHandleArray< IAsgElectronEfficiencyCorrectionTool > &electronEffToolsHandles, ToolHandleArray< IAsgElectronEfficiencyCorrectionTool > &electronSFToolsHandles, ToolHandleArray< CP::IMuonTriggerScaleFactors > &muonToolsHandles, ToolHandleArray< IAsgPhotonEfficiencyCorrectionTool > &photonEffToolsHandles, ToolHandleArray< IAsgPhotonEfficiencyCorrectionTool > &photonSFToolsHandles, const std::string &triggers, const std::map< std::string, std::string > &legsPerTool, unsigned long nToys, bool debug)
Definition TrigGlobEffCorrValidation.cxx:514

◆ configureHistograms()

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.configureHistograms ( self)

Definition at line 524 of file TrigEgammaMonitoringConfig.py.

524 def configureHistograms(self):
525 self.setBinning()
526
527 if self.activate_zee:
528
529 # LH plots
530 self.bookEvent( self.zeeMonAlg, self.zeeMonAlg.Analysis , True)
531 triggers = self.zeeMonAlg.TriggerList; triggers.extend( self.zeeMonAlg.TagTriggerList )
532 self.bookExpertHistograms( self.zeeMonAlg, triggers )
533
534 # dnn plots
535 self.bookEvent( self.zeeMonAlg_dnn, self.zeeMonAlg_dnn.Analysis , True)
536 triggers = self.zeeMonAlg_dnn.TriggerList; triggers.extend( self.zeeMonAlg_dnn.TagTriggerList )
537 self.bookExpertHistograms( self.zeeMonAlg_dnn, triggers )
538
539 if self.activate_jpsiee:
540 self.setBinning(True)
541 self.bookEvent( self.jpsieeMonAlg, self.jpsieeMonAlg.Analysis, True )
542 triggers = self.jpsieeMonAlg.TriggerList; triggers.extend( self.jpsieeMonAlg.TagTriggerList )
543 self.bookExpertHistograms( self.jpsieeMonAlg, triggers )
544
545 # back to default bin configuration
546 self.setBinning()
547
548 if self.activate_zeeg:
549 self.__logger.debug("ZEEG TriggerList = %s", self.zeegMonAlg.ProbeTriggerList)
550 self.__logger.debug("ZEEG TagTriggerList = %s", self.zeegMonAlg.TagTriggerList)
551 self.bookEvent( self.zeegMonAlg, self.zeegMonAlg.Analysis , True)
552
553 triggers = self.zeegMonAlg.ProbeTriggerList[:]
554 triggers.extend( self.zeegMonAlg.TagTriggerList )
555
556 self.bookExpertHistograms( self.zeegMonAlg, triggers )
557
558 if self.activate_electron:
559 self.bookExpertHistograms( self.elMonAlg, self.elMonAlg.TriggerList )
560 if self.activate_photon:
561 self.bookExpertHistograms( self.phMonAlg, self.phMonAlg.TriggerList )
562
563
564 # configure topo chains
565 if self.activate_topo:
566 self.bookTopoHistograms( self.topoMonAlg, self.topoMonAlg.TriggerListConfig )
567
568

◆ configureMode()

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.configureMode ( self)

Definition at line 82 of file TrigEgammaMonitoringConfig.py.

82 def configureMode(self):
83
84 self.__logger.info("TrigEgammaMonAlgBuilder.configureMode()")
85 self.activate_onlineMonHypos = True
86
87 if not self.get_monitoring_mode():
88 self.__logger.warning("Error getting monitoring mode, default monitoring lists will be used.")
89 else:
90 self.__logger.info("TrigEgammaMonitoring: Configuring for %s", self.data_type)
91
92 # Since we load the tools by name below
93 # Need to ensure the correct tools are configured
94 # for each monitoring mode
95 if self.mc_mode or self.pp_mode:
96 if(self.derivation):
97 self.activate_zee = True
98 self.activate_zeeg = True
99 else:
100 self.activate_zee=True
101 self.activate_zeeg=True
102 self.activate_jpsiee=True
103 self.activate_electron=True
104 self.activate_photon=True
105 self.activate_topo= False
106 elif self.HI_mode or self.pPb_mode or self.cosmic_mode:
107 self.activate_zee=True
108 self.activate_electron=True
109 self.activate_photon=True
110 else:
111 self.activate_zee=True
112 self.activate_jpsiee=True
113 self.activate_electron=True
114 self.activate_photon=True
115
if
if(pathvar)
Definition SealSharedLib.cxx:168

◆ configureMonitor()

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.configureMonitor ( self)

Definition at line 228 of file TrigEgammaMonitoringConfig.py.

228 def configureMonitor( self ):
229
230 acc = self.helper.resobj
231 EgammaMatchTool = CompFactory.TrigEgammaMatchingToolMT()
232 EgammaMatchTool.DeltaR=0.4
233 acc.addPublicTool(EgammaMatchTool)
234 cppyy.load_library('libElectronPhotonSelectorToolsDict')
235 # Following loads the online selectors
236
237 # Offline selectors -- taken from latest conf
238 LooseElectronSelector = CompFactory.AsgElectronIsEMSelector("T0HLTLooseElectronSelector")
239 MediumElectronSelector = CompFactory.AsgElectronIsEMSelector("T0HLTMediumElectronSelector")
240 TightElectronSelector = CompFactory.AsgElectronIsEMSelector("T0HLTTightElectronSelector")
241 LooseLHSelector = CompFactory.AsgElectronLikelihoodTool("T0HLTLooseLHSelector")
242 MediumLHSelector = CompFactory.AsgElectronLikelihoodTool("T0HLTMediumLHSelector")
243 TightLHSelector = CompFactory.AsgElectronLikelihoodTool("T0HLTTightLHSelector")
244 VeryLooseLHSelector = CompFactory.AsgElectronLikelihoodTool("T0HLTVeryLooseLHSelector")
245
246 # DNN selectors
247 LooseDNNElectronSelector = CompFactory.AsgElectronSelectorTool("T0HLTLooseElectronDNNSelector")
248 MediumDNNElectronSelector = CompFactory.AsgElectronSelectorTool("T0HLTMediumElectronDNNSelector")
249 TightDNNElectronSelector = CompFactory.AsgElectronSelectorTool("T0HLTTightElectronDNNSelector")
250
251 LoosePhotonSelector = CompFactory.AsgPhotonIsEMSelector( "T0HLTLoosePhotonSelector" )
252 MediumPhotonSelector = CompFactory.AsgPhotonIsEMSelector( "T0HLTMediumPhotonSelector" )
253 TightPhotonSelector = CompFactory.AsgPhotonIsEMSelector( "T0HLTTightPhotonSelector" )
254
255 LoosePhotonSelector.ForceConvertedPhotonPID = True
256 LoosePhotonSelector.isEMMask = SelectionDefPhoton.PhotonLoose
257 MediumPhotonSelector.ForceConvertedPhotonPID = True
258 MediumPhotonSelector.isEMMask = SelectionDefPhoton.PhotonMedium
259 TightPhotonSelector.ForceConvertedPhotonPID = True
260 TightPhotonSelector.isEMMask = SelectionDefPhoton.PhotonTight
261
262
263 acc.addPublicTool(LooseElectronSelector)
264 acc.addPublicTool(MediumElectronSelector)
265 acc.addPublicTool(TightElectronSelector)
266 acc.addPublicTool(LooseLHSelector)
267 acc.addPublicTool(MediumLHSelector)
268 acc.addPublicTool(TightLHSelector)
269 acc.addPublicTool(VeryLooseLHSelector)
270 acc.addPublicTool(LooseDNNElectronSelector)
271 acc.addPublicTool(MediumDNNElectronSelector)
272 acc.addPublicTool(TightDNNElectronSelector)
273
274 if self.runFlag == '2022':
275 raise RuntimeError( '2022 (Run 3) configuration not available yet' )
276
277
278 elif self.runFlag == '2018':
279 # cut based
280 LooseElectronSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc15_20150712/ElectronIsEMLooseSelectorCutDefs.conf"
281 MediumElectronSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc15_20150712/ElectronIsEMMediumSelectorCutDefs.conf"
282 TightElectronSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc15_20150712/ElectronIsEMTightSelectorCutDefs.conf"
283 # 2018 (vtest)
284 LooseLHSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc20_20210514/ElectronLikelihoodLooseOfflineConfig2017_CutBL_Smooth.conf"
285 MediumLHSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc20_20210514/ElectronLikelihoodMediumOfflineConfig2017_Smooth.conf"
286 TightLHSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc20_20210514/ElectronLikelihoodTightOfflineConfig2017_Smooth.conf"
287 VeryLooseLHSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc20_20210514/ElectronLikelihoodVeryLooseOfflineConfig2017_Smooth.conf"
288 # DNN
289 LooseDNNElectronSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc20_20240628/ElectronDNNMulticlassLoose.conf"
290 MediumDNNElectronSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc20_20240628/ElectronDNNMulticlassMedium.conf"
291 TightDNNElectronSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc20_20240628/ElectronDNNMulticlassTight.conf"
292 # cutbased for photons
293 TightPhotonSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc15_20150712/PhotonIsEMTightSelectorCutDefs.conf"
294 MediumPhotonSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc15_20150712/PhotonIsEMMediumSelectorCutDefs.conf"
295 LoosePhotonSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc15_20150712/PhotonIsEMLooseSelectorCutDefs.conf"
296
297 elif self.runFlag == '2017':
298 # cut based
299 LooseElectronSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc15_20150712/ElectronIsEMLooseSelectorCutDefs.conf"
300 MediumElectronSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc15_20150712/ElectronIsEMMediumSelectorCutDefs.conf"
301 TightElectronSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc15_20150712/ElectronIsEMTightSelectorCutDefs.conf"
302 # 2017 (v11)
303 LooseLHSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc15_20160512/ElectronLikelihoodLooseOfflineConfig2016_CutBL_Smooth.conf"
304 MediumLHSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc15_20160512/ElectronLikelihoodMediumOfflineConfig2016_Smooth.conf"
305 TightLHSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc15_20160512/ElectronLikelihoodTightOfflineConfig2016_Smooth.conf"
306 VeryLooseLHSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc15_20160512/ElectronLikelihoodVeryLooseOfflineConfig2016_Smooth.conf"
307 # DNN
308 LooseDNNElectronSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc16_20210430/ElectronDNNMulticlassLoose.conf"
309 MediumDNNElectronSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc16_20210430/ElectronDNNMulticlassMedium.conf"
310 TightDNNElectronSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc16_20210430/ElectronDNNMulticlassTight.conf"
311 # cut based for photons
312 TightPhotonSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc15_20150712/PhotonIsEMTightSelectorCutDefs.conf"
313 MediumPhotonSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc15_20150712/PhotonIsEMMediumSelectorCutDefs.conf"
314 LoosePhotonSelector.ConfigFile = "ElectronPhotonSelectorTools/offline/mc15_20150712/PhotonIsEMLooseSelectorCutDefs.conf"
315
316 else:
317 # raise since the configuration its not defined
318 raise RuntimeError( 'Wrong run flag configuration' )
319
320
321
322 if self.activate_zee:
323 tpList = treat_list_of_chains_by_name(self.tpList, 'lh') # Only LH chains
324 tagItems = treat_list_of_chains_by_name(self.tagItems, 'lh') # Only LH chains
325 self.__logger.info( "Creating the Zee monitor algorithm LH only...")
326 self.zeeMonAlg = self.helper.addAlgorithm( CompFactory.TrigEgammaMonitorTagAndProbeAlgorithm, "TrigEgammaMonitorTagAndProbeAlgorithm_Zee_LH" )
327 self.zeeMonAlg.Analysis='Zee'
328 self.zeeMonAlg.MatchTool = EgammaMatchTool
329 self.zeeMonAlg.TPTrigger=False
330 self.zeeMonAlg.ElectronKey = 'Electrons'
331 self.zeeMonAlg.isEMResultNames=self.isemnames
332 self.zeeMonAlg.LHResultNames=self.lhnames
333 self.zeeMonAlg.DNNResultNames=self.dnnnames
334 self.zeeMonAlg.ElectronIsEMSelector =[TightElectronSelector,MediumElectronSelector,LooseElectronSelector]
335 self.zeeMonAlg.ElectronLikelihoodTool =[TightLHSelector,MediumLHSelector,LooseLHSelector,VeryLooseLHSelector]
336 self.zeeMonAlg.ElectronDNNSelectorTool =[TightDNNElectronSelector,MediumDNNElectronSelector,LooseDNNElectronSelector]
337 self.zeeMonAlg.ZeeLowerMass=80
338 self.zeeMonAlg.ZeeUpperMass=100
339 self.zeeMonAlg.OfflineTagMinEt=25
340 self.zeeMonAlg.OfflineTagSelector='lhtight'
341 self.zeeMonAlg.OfflineProbeSelector='lhloose'
342 self.zeeMonAlg.OppositeCharge=True
343 self.zeeMonAlg.RemoveCrack=False
344 self.zeeMonAlg.TagTriggerList=tagItems
345 self.zeeMonAlg.TriggerList=tpList
346 self.zeeMonAlg.DetailedHistograms=self.detailedHistograms
347 self.zeeMonAlg.DoEmulation = False
348 self.zeeMonAlg.ApplyJetNearProbeSelection = False
349
350
351 # Separated TaP tool configuration
352 tpList = treat_list_of_chains_by_name(self.tpList, 'dnn') # get only dnn chains
353 tagItems = treat_list_of_chains_by_name(self.tagItems, 'dnn')
354 self.__logger.info( "Creating the Zee monitor algorithm DNN only...")
355 self.zeeMonAlg_dnn = self.helper.addAlgorithm( CompFactory.TrigEgammaMonitorTagAndProbeAlgorithm, "TrigEgammaMonitorTagAndProbeAlgorithm_Zee_DNN" )
356 self.zeeMonAlg_dnn.Analysis='Zee_DNN'
357 self.zeeMonAlg_dnn.MatchTool = EgammaMatchTool
358 self.zeeMonAlg_dnn.TPTrigger=False
359 self.zeeMonAlg_dnn.ElectronKey = 'Electrons'
360 self.zeeMonAlg_dnn.isEMResultNames=self.isemnames
361 self.zeeMonAlg_dnn.LHResultNames=self.lhnames
362 self.zeeMonAlg_dnn.DNNResultNames=self.dnnnames
363 self.zeeMonAlg_dnn.ElectronIsEMSelector =[TightElectronSelector,MediumElectronSelector,LooseElectronSelector]
364 self.zeeMonAlg_dnn.ElectronLikelihoodTool =[TightLHSelector,MediumLHSelector,LooseLHSelector,VeryLooseLHSelector]
365 self.zeeMonAlg_dnn.ElectronDNNSelectorTool =[TightDNNElectronSelector,MediumDNNElectronSelector,LooseDNNElectronSelector]
366 self.zeeMonAlg_dnn.ZeeLowerMass=80
367 self.zeeMonAlg_dnn.ZeeUpperMass=100
368 self.zeeMonAlg_dnn.OfflineTagMinEt=25
369 self.zeeMonAlg_dnn.OfflineTagSelector='dnntight'
370 self.zeeMonAlg_dnn.OfflineProbeSelector='dnnloose'
371 self.zeeMonAlg_dnn.OppositeCharge=True
372 self.zeeMonAlg_dnn.RemoveCrack=False
373 self.zeeMonAlg_dnn.TagTriggerList=tagItems
374 self.zeeMonAlg_dnn.TriggerList=tpList
375 self.zeeMonAlg_dnn.DetailedHistograms=self.detailedHistograms
376 self.zeeMonAlg_dnn.DoEmulation = False
377 self.zeeMonAlg_dnn.ApplyJetNearProbeSelection = False
378
379 if self.emulator: # turn on emulator
380 self.emulator.TriggerList += self.tpList
381 self.zeeMonAlg.DoEmulation = True
382 self.zeeMonAlg.EmulationTool = self.emulator.core()
383 self.zeeMonAlg_dnn.DoEmulation = True
384 self.zeeMonAlg_dnn.EmulationTool = self.emulator.core()
385
386 if self.activate_zeeg:
387 probeList= treat_list_of_chains_by_name(self.tpZeegProbeList,)
388 tagList= treat_list_of_chains_by_name(self.tpZeegTagList,)
389 self.__logger.info( "Creating the Zeegamma monitor algorithm")
390 self.zeegMonAlg = self.helper.addAlgorithm( CompFactory.TrigEgammaMonitorTagAndProbeAlgorithmZeeg, "TrigEgammaMonitorTagAndProbeZeeg" )
391 self.zeegMonAlg.Analysis='Zeeg'
392 self.zeegMonAlg.MatchTool = EgammaMatchTool
393 self.zeegMonAlg.TPTrigger=False
394 self.zeegMonAlg.ElectronKey = 'Electrons'
395 self.zeegMonAlg.PhotonKey = 'Photons'
396 self.zeegMonAlg.PhotonIsolationKeys = ["Photons.topoetcone20", "Photons.topoetcone40"]
397
398 self.zeegMonAlg.isEMResultNames=self.isemnames
399 self.zeegMonAlg.LHResultNames=self.lhnames
400 self.zeegMonAlg.DNNResultNames=self.dnnnames
401 self.zeegMonAlg.PhotonIsEMSelector =[TightPhotonSelector,MediumPhotonSelector,LoosePhotonSelector]
402 self.zeegMonAlg.ElectronIsEMSelector =[TightElectronSelector,MediumElectronSelector,LooseElectronSelector]
403 self.zeegMonAlg.ElectronLikelihoodTool =[TightLHSelector,MediumLHSelector,LooseLHSelector,VeryLooseLHSelector]
404 self.zeegMonAlg.ElectronDNNSelectorTool =[TightDNNElectronSelector,MediumDNNElectronSelector,LooseDNNElectronSelector]
405 self.zeegMonAlg.ZeeLowerMass=80
406 self.zeegMonAlg.ZeeUpperMass=100
407 self.zeegMonAlg.OfflineTagMinEt=25
408 self.zeegMonAlg.OfflineTagSelector='lhvloose'
409 self.zeegMonAlg.OfflineProbeSelector='loose'
410 self.zeegMonAlg.OppositeCharge=True
411 self.zeegMonAlg.RemoveCrack=False
412 self.zeegMonAlg.TPMatchingMap = self.tpMatchingMap
413 self.zeegMonAlg.TagTriggerList=tagList # Tag triggers
414 self.zeegMonAlg.ProbeTriggerList=probeList #Probe Triggers
415 self.zeegMonAlg.DetailedHistograms=self.detailedHistograms
416 self.zeegMonAlg.DoEmulation = False
417 self.zeegMonAlg.ApplyJetNearProbeSelection = False
418
419 if self.emulator: # turn on emulator
420 self.emulator.TriggerList += tpList
421 self.zeegMonAlg.DoEmulation = True
422 self.zeegMonAlg.EmulationTool = self.emulator.core()
423 self.zeegMonAlg.DoEmulation = True
424 self.zeegMonAlg.EmulationTool = self.emulator.core()
425
426
427 if self.activate_jpsiee:
428
429 self.__logger.info( "Creating the Jpsiee monitor algorithm...")
430 self.jpsieeMonAlg = self.helper.addAlgorithm( CompFactory.TrigEgammaMonitorTagAndProbeAlgorithm, "TrigEgammaMonitorTagAndProbeAlgorithm_Jpsiee" )
431 self.jpsieeMonAlg.DoJpsiee=True
432 self.jpsieeMonAlg.Analysis='Jpsiee'
433 self.jpsieeMonAlg.MatchTool = EgammaMatchTool
434 self.jpsieeMonAlg.TPTrigger=False
435 self.jpsieeMonAlg.ElectronKey = 'Electrons'
436 self.jpsieeMonAlg.isEMResultNames=self.isemnames
437 self.jpsieeMonAlg.LHResultNames=self.lhnames
438 self.jpsieeMonAlg.DNNResultNames=self.dnnnames
439 self.jpsieeMonAlg.ElectronIsEMSelector =[TightElectronSelector,MediumElectronSelector,LooseElectronSelector]
440 self.jpsieeMonAlg.ElectronLikelihoodTool =[TightLHSelector,MediumLHSelector,LooseLHSelector,VeryLooseLHSelector]
441 self.jpsieeMonAlg.ElectronDNNSelectorTool =[TightDNNElectronSelector,MediumDNNElectronSelector,LooseDNNElectronSelector]
442 self.jpsieeMonAlg.ZeeLowerMass=2
443 self.jpsieeMonAlg.ZeeUpperMass=5
444 self.jpsieeMonAlg.OfflineTagMinEt=5
445 self.jpsieeMonAlg.OfflineTagSelector='lhtight'
446 self.jpsieeMonAlg.OfflineProbeSelector='lhloose'
447 self.jpsieeMonAlg.OppositeCharge=True
448 self.jpsieeMonAlg.RemoveCrack=False
449 self.jpsieeMonAlg.TagTriggerList=self.jpsitagItems
450 self.jpsieeMonAlg.TriggerList=self.jpsiList
451 self.jpsieeMonAlg.DetailedHistograms=self.detailedHistograms
452 self.jpsieeMonAlg.DoEmulation = False
453 self.jpsieeMonAlg.ApplyJetNearProbeSelection = False
454
455 if self.activate_electron:
456
457 self.__logger.info( "Creating the Electron monitor algorithm...")
458 self.elMonAlg = self.helper.addAlgorithm( CompFactory.TrigEgammaMonitorElectronAlgorithm, "TrigEgammaMonitorElectronAlgorithm" )
459 self.elMonAlg.MatchTool = EgammaMatchTool
460 self.elMonAlg.Analysis = "Electrons"
461 self.elMonAlg.ElectronKey = 'Electrons'
462 self.elMonAlg.isEMResultNames=self.isemnames
463 self.elMonAlg.LHResultNames=self.lhnames
464 self.elMonAlg.DNNResultNames=self.dnnnames
465 self.elMonAlg.ElectronIsEMSelector =[TightElectronSelector,MediumElectronSelector,LooseElectronSelector]
466 self.elMonAlg.ElectronLikelihoodTool =[TightLHSelector,MediumLHSelector,LooseLHSelector,VeryLooseLHSelector]
467 self.elMonAlg.ForcePidSelection=True
468 self.elMonAlg.ForceProbeIsolation=False
469 self.elMonAlg.ForceEtThreshold=True
470 self.elMonAlg.TriggerList=self.electronList
471 self.elMonAlg.DetailedHistograms=self.detailedHistograms
472 self.elMonAlg.DoEmulation = False
473 self.elMonAlg.ComputeEffLH = self.computeEffLH
474 self.elMonAlg.ComputeEffDNN = self.computeEffDNN
475
476 if self.emulator:
477 self.elMonAlg.DoEmulation = True
478 self.emulator.TriggerList += self.electronList
479 self.elMonAlg.EmulationTool = self.emulator.core()
480
481
482 if self.activate_photon:
483
484 self.__logger.info( "Creating the Photon monitor algorithm...")
485 self.phMonAlg = self.helper.addAlgorithm( CompFactory.TrigEgammaMonitorPhotonAlgorithm, "TrigEgammaMonitorPhotonAlgorithm" )
486 self.phMonAlg.Analysis = "Photons"
487 self.phMonAlg.MatchTool = EgammaMatchTool
488 self.phMonAlg.PhotonKey = 'Photons'
489 self.phMonAlg.PhotonIsolationKeys = ["Photons.topoetcone20", "Photons.topoetcone40"]
490 self.phMonAlg.isEMResultNames=self.isemnames
491 self.phMonAlg.LHResultNames=self.lhnames
492 self.phMonAlg.PhotonIsEMSelector =[TightPhotonSelector,MediumPhotonSelector,LoosePhotonSelector]
493 self.phMonAlg.TriggerList=self.photonList
494 self.phMonAlg.BootstrapTriggerMap = self.bootstrapMap
495 self.phMonAlg.DetailedHistograms=self.detailedHistograms
496 self.phMonAlg.ForcePidSelection=True
497 self.phMonAlg.DoUnconverted=False
498 self.phMonAlg.DoEmulation = False
499 self.phMonAlg.OnlyHLT = self.onlyHLT
500
501
502 if self.emulator:
503 self.phMonAlg.DoEmulation = True
504 self.emulator.TriggerList += self.photonList
505 self.phMonAlg.EmulationTool = self.emulator.core()
506
507
508 if self.activate_topo:
509
510 self.__logger.info( "Creating the combo monitor algorithm...")
511 self.topoMonAlg = self.helper.addAlgorithm( CompFactory.TrigEgammaMonitorTopoAlgorithm, "TrigEgammaMonitorTopoAlgorithm" )
512 self.topoMonAlg.MatchTool = EgammaMatchTool
513 self.topoMonAlg.ElectronKey = 'Electrons'
514 self.topoMonAlg.PhotonKey = 'Photons'
515 self.topoMonAlg.isEMResultNames=self.isemnames
516 self.topoMonAlg.LHResultNames=self.lhnames
517 self.topoMonAlg.DNNResultNames=self.dnnnames
518 self.topoMonAlg.ElectronIsEMSelector =[TightElectronSelector,MediumElectronSelector,LooseElectronSelector]
519 self.topoMonAlg.ElectronLikelihoodTool =[TightLHSelector,MediumLHSelector,LooseLHSelector]
520 self.topoMonAlg.DetailedHistograms=self.detailedHistograms
521 self.topoMonAlg.TriggerListConfig = self.topoList # this is a list of dicts
522
523

◆ get_monitoring_mode()

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.get_monitoring_mode ( self)

Definition at line 126 of file TrigEgammaMonitoringConfig.py.

126 def get_monitoring_mode(self):
127
128 self.__logger.info("TrigEgammaMonAlgBuilder.get_monitoring_mode()")
129 self.data_type = self.helper.flags.DQ.DataType
130
131 if self.data_type is DQDataType.MC:
132 self.mc_mode = True
133 self.__logger.info('TrigEgammaMonitoring configured for mc_mode')
134 return True
135 elif self.data_type is DQDataType.Collisions:
136 self.pp_mode = True
137 self.__logger.info('TrigEgammaMonitoring configured for pp_mode')
138 return True
139 elif self.data_type is DQDataType.HeavyIon:
140 self.HI_mode = True
141 self.pPb_mode = True
142 self.__logger.info('TrigEgammaMonitoring configured for hi_mode')
143 return True
144 elif self.data_type is DQDataType.Cosmics:
145 self.cosmic_mode = True
146 self.__logger.info('TrigEgammaMonitoring configured for cosmic_mode')
147 return True
148 else:
149 return False
150
151

◆ getTrigInfo()

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.getTrigInfo ( self,
trigger )

Definition at line 1283 of file TrigEgammaMonitoringConfig.py.

1283 def getTrigInfo( self, trigger ):
1284 class TrigEgammaInfo(object):
1285
1286 EM = {"e", "electron"}
1287 GAMMA = {"g", "photon"}
1288
1289
1290 def __init__(self, trigger):
1291 self.__chain = trigger
1292 self.__legs = HLTChainInfo(trigger)
1293 self.__sigs = {leg.signature for leg in self.__legs}
1294
1295 for legInfo in HLTChainInfo(trigger):
1296 print(legInfo.multiplicity)
1297 print(legInfo.signature)
1298 print(legInfo.threshold)
1299 print(legInfo.legParts)
1300
1301 def chain(self):
1302 return self.__chain
1303
1304 def legs(self):
1305 return self.__legs
1306
1307 def signatures(self):
1308 return self.__sigs
1309
1310 def isElectron(self):
1311 for leg in HLTChainInfo(trigger):
1312 if leg.signature == "e" and "probe" not in self.__chain:
1313 return True
1314 return False
1315
1316 def isPhoton(self):
1317 for leg in HLTChainInfo(trigger):
1318 if leg.signature == "g" and "probe" not in self.__chain:
1319 return True
1320 return False
1321
1322 def isTagAndProbeZeeg(self):
1323 if "probe" in self.__chain:
1324 return True
1325 return False
1326
1327 def threshold(self):
1328 #if self.isElectron() or self.isPhoton():
1329 # for leg in HLTChainInfo(trigger):
1330 # thresholdValue = leg.threshold
1331 # thresholdString = str(thresholdValue)
1332 # return thresholdString
1333
1334 if self.isTagAndProbeZeeg():
1335 for leg in HLTChainInfo(trigger):
1336 if leg.signature != "g":
1337 continue
1338
1339 thresholdValue = leg.threshold
1340 thresholdString = str(thresholdValue)
1341 return thresholdString
1342 return "Invalid Threshold"
1343
1344 def pidname(self):
1345 #if self.isElectron() or self.isPhoton():
1346 # for leg in HLTChainInfo(trigger):
1347 # pidValue = leg.legParts[0]
1348 # return pidValue
1349
1350 if self.isTagAndProbeZeeg():
1351 for leg in HLTChainInfo(trigger):
1352 if leg.signature != "g":
1353 continue
1354
1355 pidValue = leg.legParts[0]
1356 return pidValue
1357 return "Invalid Threshold"
1358
1359 def isIsolated(self):
1360 for part_name in ['iloose', 'ivarloose', 'icaloloose', 'icalovloose', 'icalotight']:
1361 if part_name in self.chain():
1362 return True
1363 return False
1364
1365
1366 return TrigEgammaInfo(trigger)
1367
isElectron
bool isElectron(const T &p)
Definition AtlasPID.h:202
isPhoton
bool isPhoton(const T &p)
Definition AtlasPID.h:376
print
void print(char *figname, TCanvas *c1)
Definition TRTCalib_StrawStatusPlots.cxx:26

◆ setBinning()

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.setBinning ( self,
doJpsiee = False ) 
Method to define all binning required that is variable

Definition at line 1232 of file TrigEgammaMonitoringConfig.py.

1232 def setBinning(self, doJpsiee=False):
1233
1234 """ Method to define all binning required that is variable"""
1235
1236 # Binning as defined in TP framework
1237 coarse_eta_bins = [-2.47,-1.52,-1.37,-0.60,0.00,0.60,1.37,1.52,2.47] # 9 items
1238
1239 coarse_et_bins = [4.,20.,30.,40.,50.,60.,150.] # 7 items
1240
1241 default_eta_bins = [-2.47,-2.37,-2.01,-1.81,-1.52,-1.37,-1.15,-0.80,-0.60,-0.10,0.00,
1242 0.10, 0.60, 0.80, 1.15, 1.37, 1.52, 1.81, 2.01, 2.37, 2.47] # 21 items
1243
1244 default_et_bins = [4.,7.,10.,15.,20.,25.,30.,35.,40.,45.,50.,60.,80.,150.] # 14 items
1245
1246 etabins = [-2.47,-2.37,-2.01,-1.81,-1.52,-1.37,-1.15,-0.8,-0.6,-0.1,
1247 0.0,0.1,0.6,0.8,1.15,1.37,1.52,1.81,2.01,2.37,2.47] # 21 items
1248
1249 # TH2 with variable bin x-Axis, but constant bin y-Axis takes only Double_t arrays
1250 etbins_Zee = [0.,2.,4.,6.,8.,10.,
1251 12.,14.,16.,18.,20.,22.,24.,26.,28.,
1252 30.,32.,34.,36.,38.,40.,42.,44.,46.,48.,50.,55.,60.,65.,80.,100.,120.,140., 170., 200.,250.] # 36 items
1253
1254 etbins_Jpsiee = [ 0, 0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5,
1255 5, 5.5, 6, 6.5, 7, 7.5, 8, 8.5, 9, 9.5,
1256 10,10.5,11,11.5,12,12.5,13,13.5,14,14.5,
1257 15,15.5,16,16.5,17,17.5,18,18.5,19,19.5,
1258 20,20.5,21,21.5,22,22.5,23,23.5,24,24.5,
1259 25,25.5] # 52 items
1260
1261
1262 if doJpsiee:
1263 self._nEtbins=51
1264 self._etbins = etbins_Jpsiee[0:self._nEtbins+1]
1265 else:
1266 self._nEtbins=35
1267 self._etbins = etbins_Zee[0:self._nEtbins+1]
1268
1269 # Define the binning
1270 self._nEtabins=20
1271 self._ndefaultEtbins=13
1272 self._ndefaultEtabins=20
1273 self._ncoarseEtbins=6
1274 self._ncoarseEtabins=8
1275
1276 #Fill the arrays
1277 self._etabins = etabins[0:self._nEtabins+1]
1278 self._defaultEtbins = default_et_bins[0:self._ndefaultEtbins+1]
1279 self._defaultEtabins = default_eta_bins[0:self._ndefaultEtabins+1]
1280 self._coarseEtbins = coarse_et_bins[0:self._ncoarseEtbins+1]
1281 self._coarseEtabins = coarse_eta_bins[0:self._ncoarseEtabins+1]
1282

◆ setDefaultProperties()

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.setDefaultProperties ( self)

Definition at line 178 of file TrigEgammaMonitoringConfig.py.

178 def setDefaultProperties(self):
179
180 from TrigEgammaMonitoring.TrigEgammaMonitCategory import mongroupsCfg
181 mongroups = mongroupsCfg(self.moniAccess,self.data_type)
182 #monitoringTP_tag
183 if self.pp_mode:
184 self.electronList = mongroups['monitoring_electron']
185 self.photonList = mongroups['monitoring_photon']
186 self.bootstrapMap = mongroups['monitoring_bootstrap']
187 self.tpMatchingMap= mongroups['monitoringTP_Matching']
188 self.tpList = mongroups['monitoringTP_electron']
189 self.tpZeegProbeList = mongroups['monitoringTP_probe']
190 self.tpZeegTagList = mongroups['monitoringTP_tag']
191 self.tagItems = mongroups['monitoringTP_tag']
192 self.topoList = mongroups['monitoring_topo']
193 elif self.mc_mode:
194 self.electronList = mongroups['validation_electron']
195 self.photonList = mongroups['validation_photon']
196 self.bootstrapMap = mongroups['monitoring_bootstrap']
197 self.tpMatchingMap= mongroups['monitoringTP_Matching']
198 self.tpList = mongroups['monitoringTP_electron'] + mongroups['validationTP_electron_DNN']
199 self.tpZeegProbeList = mongroups['monitoringTP_probe']
200 self.tpZeegTagList = mongroups['monitoringTP_tag']
201 self.jpsiList = mongroups['validation_jpsi']
202 self.jpsitagItems = mongroups['validationTP_jpsiee']
203 self.tagItems = mongroups['monitoringTP_tag']
204 self.topoList = mongroups['monitoring_topo']
205 elif self.cosmic_mode:
206 self.electronList = mongroups['monitoring_electron_cosmic']
207 self.photonList = mongroups['monitoring_photon_cosmic']
208 self.bootstrapMap = mongroups['monitoring_bootstrap_cosmic']
209 self.tpMatchingMap= mongroups['monitoringTP_Matching']
210 self.tpZeegProbeList = mongroups['monitoringTP_probe']
211 self.tpZeegTagList = mongroups['monitoringTP_tag']
212 else:
213 self.electronList = mongroups['monitoring_electron']
214 self.photonList = mongroups['monitoring_photon']
215 self.bootstrapMap = mongroups['monitoring_bootstrap']
216 self.tpMatchingMap= mongroups['monitoringTP_Matching']
217 self.tpList = mongroups['monitoringTP_electron']
218 self.tagItems = mongroups['monitoringTP_tag']
219 self.topoList = mongroups['monitoring_topo']
220 self.tpZeegProbeList = mongroups['monitoringTP_probe']
221 self.tpZeegTagList = mongroups['monitoringTP_tag']
222
223

◆ setProperties()

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.setProperties ( self)

Definition at line 152 of file TrigEgammaMonitoringConfig.py.

152 def setProperties(self):
153
154 self.__logger.info("TrigEgammaMonAlgBuilder.setProperties()")
155 self.basePath = 'HLT/EgammaMon'
156
157 if self.pp_mode:
158 self.setDefaultProperties()
159 elif self.cosmic_mode:
160 self.setDefaultProperties()
161 elif self.HI_mode or self.pPb_mode:
162 self.setDefaultProperties()
163 elif self.mc_mode:
164 self.setDefaultProperties()
165 else:
166 self.__logger.info('No monitoring mode configured, use default')
167 self.setDefaultProperties()
168
169
170 self.__logger.info('Configuring TP electron chains %s',self.tpList)
171 self.__logger.info('Configuring TP Zeeg tag trigger chains %s',self.tpZeegTagList)
172 self.__logger.info('Configuring TP Zeeg probe trigger chains %s',self.tpZeegProbeList)
173 self.__logger.info('Configuring electron chains %s',self.electronList)
174 self.__logger.info('Configuring photon chains %s',self.photonList)
175 self.__logger.info('Configuring minimal trigger matching to probe trigger', self.tpMatchingMap)
176
177

Member Data Documentation

◆ __chain

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.__chain = trigger
private

Definition at line 1291 of file TrigEgammaMonitoringConfig.py.

◆ __legs

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.__legs = HLTChainInfo(trigger)
private

Definition at line 1292 of file TrigEgammaMonitoringConfig.py.

◆ __logger

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.__logger = logging.getLogger( 'TrigEgammaMonAlgBuilder' )
private

Definition at line 67 of file TrigEgammaMonitoringConfig.py.

◆ __sigs

dict python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.__sigs = {leg.signature for leg in self.__legs}
private

Definition at line 1293 of file TrigEgammaMonitoringConfig.py.

◆ _coarseEtabins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._coarseEtabins = coarse_eta_bins[0:self._ncoarseEtabins+1]
protected

Definition at line 1281 of file TrigEgammaMonitoringConfig.py.

◆ _coarseEtbins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._coarseEtbins = coarse_et_bins[0:self._ncoarseEtbins+1]
protected

Definition at line 1280 of file TrigEgammaMonitoringConfig.py.

◆ _defaultEtabins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._defaultEtabins = default_eta_bins[0:self._ndefaultEtabins+1]
protected

Definition at line 1279 of file TrigEgammaMonitoringConfig.py.

◆ _defaultEtbins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._defaultEtbins = default_et_bins[0:self._ndefaultEtbins+1]
protected

Definition at line 1278 of file TrigEgammaMonitoringConfig.py.

◆ _etabins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._etabins
protected

Definition at line 721 of file TrigEgammaMonitoringConfig.py.

◆ _etbins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._etbins
protected

Definition at line 870 of file TrigEgammaMonitoringConfig.py.

◆ _ncoarseEtabins

int python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._ncoarseEtabins = 8
protected

Definition at line 1274 of file TrigEgammaMonitoringConfig.py.

◆ _ncoarseEtbins

int python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._ncoarseEtbins = 6
protected

Definition at line 1273 of file TrigEgammaMonitoringConfig.py.

◆ _ndefaultEtabins

int python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._ndefaultEtabins = 20
protected

Definition at line 1272 of file TrigEgammaMonitoringConfig.py.

◆ _ndefaultEtbins

int python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._ndefaultEtbins = 13
protected

Definition at line 1271 of file TrigEgammaMonitoringConfig.py.

◆ _nEtabins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._nEtabins
protected

Definition at line 721 of file TrigEgammaMonitoringConfig.py.

◆ _nEtbins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._nEtbins
protected

Definition at line 870 of file TrigEgammaMonitoringConfig.py.

◆ activate_electron

bool python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.activate_electron = False
static

Definition at line 39 of file TrigEgammaMonitoringConfig.py.

◆ activate_jpsiee

bool python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.activate_jpsiee = False
static

Definition at line 43 of file TrigEgammaMonitoringConfig.py.

◆ activate_onlineMonHypos

bool python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.activate_onlineMonHypos = False
static

Definition at line 45 of file TrigEgammaMonitoringConfig.py.

◆ activate_photon

bool python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.activate_photon = False
static

Definition at line 40 of file TrigEgammaMonitoringConfig.py.

◆ activate_topo

bool python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.activate_topo = False
static

Definition at line 44 of file TrigEgammaMonitoringConfig.py.

◆ activate_zee

bool python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.activate_zee = False
static

Definition at line 41 of file TrigEgammaMonitoringConfig.py.

◆ activate_zeeg

bool python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.activate_zeeg = False
static

Definition at line 42 of file TrigEgammaMonitoringConfig.py.

◆ basePath

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.basePath = basePath

Definition at line 72 of file TrigEgammaMonitoringConfig.py.

◆ bootstrapMap

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.bootstrapMap = mongroups['monitoring_bootstrap']

Definition at line 186 of file TrigEgammaMonitoringConfig.py.

◆ computeEffDNN

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.computeEffDNN = ComputeEffDNN

Definition at line 77 of file TrigEgammaMonitoringConfig.py.

◆ computeEffLH

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.computeEffLH = ComputeEffLH

Definition at line 76 of file TrigEgammaMonitoringConfig.py.

◆ cosmic_mode

bool python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.cosmic_mode = False
static

Definition at line 37 of file TrigEgammaMonitoringConfig.py.

◆ data_type

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.data_type = ''
static

Definition at line 33 of file TrigEgammaMonitoringConfig.py.

◆ derivation

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.derivation = derivation

Definition at line 70 of file TrigEgammaMonitoringConfig.py.

◆ detailedHistograms

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.detailedHistograms = detailedHistograms

Definition at line 73 of file TrigEgammaMonitoringConfig.py.

◆ dnnnames

list python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.dnnnames = ["dnntight", "dnnmedium", "dnnloose"]
static

Definition at line 56 of file TrigEgammaMonitoringConfig.py.

◆ electronList

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.electronList = []
static

Definition at line 48 of file TrigEgammaMonitoringConfig.py.

◆ elMonAlg

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.elMonAlg = self.helper.addAlgorithm( CompFactory.TrigEgammaMonitorElectronAlgorithm, "TrigEgammaMonitorElectronAlgorithm" )

Definition at line 458 of file TrigEgammaMonitoringConfig.py.

◆ emulator

# turn on emulator python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.emulator = emulator

Definition at line 71 of file TrigEgammaMonitoringConfig.py.

◆ helper

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.helper = helper

Definition at line 69 of file TrigEgammaMonitoringConfig.py.

◆ HI_mode

bool python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.HI_mode = False
static

Definition at line 36 of file TrigEgammaMonitoringConfig.py.

◆ isemnames

list python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.isemnames = ["tight", "medium", "loose"]
static

Definition at line 54 of file TrigEgammaMonitoringConfig.py.

◆ jpsieeMonAlg

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.jpsieeMonAlg = self.helper.addAlgorithm( CompFactory.TrigEgammaMonitorTagAndProbeAlgorithm, "TrigEgammaMonitorTagAndProbeAlgorithm_Jpsiee" )

Definition at line 430 of file TrigEgammaMonitoringConfig.py.

◆ jpsiList

list python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.jpsiList = []
static

Definition at line 51 of file TrigEgammaMonitoringConfig.py.

◆ jpsitagItems

list python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.jpsitagItems = []
static

Definition at line 47 of file TrigEgammaMonitoringConfig.py.

◆ lhnames

list python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.lhnames = ["lhtight", "lhmedium", "lhloose","lhvloose"]
static

Definition at line 55 of file TrigEgammaMonitoringConfig.py.

◆ mc_mode

bool python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.mc_mode = False
static

Definition at line 38 of file TrigEgammaMonitoringConfig.py.

◆ moniAccess

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.moniAccess = moniAccess

Definition at line 74 of file TrigEgammaMonitoringConfig.py.

◆ onlyHLT

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.onlyHLT = onlyHLT

Definition at line 75 of file TrigEgammaMonitoringConfig.py.

◆ phMonAlg

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.phMonAlg = self.helper.addAlgorithm( CompFactory.TrigEgammaMonitorPhotonAlgorithm, "TrigEgammaMonitorPhotonAlgorithm" )

Definition at line 485 of file TrigEgammaMonitoringConfig.py.

◆ photonList

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.photonList = []
static

Definition at line 49 of file TrigEgammaMonitoringConfig.py.

◆ pp_mode

bool python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.pp_mode = False
static

Definition at line 34 of file TrigEgammaMonitoringConfig.py.

◆ pPb_mode

bool python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.pPb_mode = False
static

Definition at line 35 of file TrigEgammaMonitoringConfig.py.

◆ runFlag

str python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.runFlag = runflag

Definition at line 68 of file TrigEgammaMonitoringConfig.py.

◆ tagItems

list python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.tagItems = []
static

Definition at line 46 of file TrigEgammaMonitoringConfig.py.

◆ topoList

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.topoList = mongroups['monitoring_topo']

Definition at line 192 of file TrigEgammaMonitoringConfig.py.

◆ topoMonAlg

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.topoMonAlg = self.helper.addAlgorithm( CompFactory.TrigEgammaMonitorTopoAlgorithm, "TrigEgammaMonitorTopoAlgorithm" )

Definition at line 511 of file TrigEgammaMonitoringConfig.py.

◆ tpList

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.tpList = []
static

Definition at line 50 of file TrigEgammaMonitoringConfig.py.

◆ tpMatchingMap

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.tpMatchingMap

Definition at line 175 of file TrigEgammaMonitoringConfig.py.

◆ tpZeegProbeList

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.tpZeegProbeList

Definition at line 172 of file TrigEgammaMonitoringConfig.py.

◆ tpZeegTagList

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.tpZeegTagList

Definition at line 171 of file TrigEgammaMonitoringConfig.py.

◆ zeegMonAlg

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.zeegMonAlg = self.helper.addAlgorithm( CompFactory.TrigEgammaMonitorTagAndProbeAlgorithmZeeg, "TrigEgammaMonitorTagAndProbeZeeg" )

Definition at line 390 of file TrigEgammaMonitoringConfig.py.

◆ zeeMonAlg

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.zeeMonAlg = self.helper.addAlgorithm( CompFactory.TrigEgammaMonitorTagAndProbeAlgorithm, "TrigEgammaMonitorTagAndProbeAlgorithm_Zee_LH" )

Definition at line 326 of file TrigEgammaMonitoringConfig.py.

◆ zeeMonAlg_dnn

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.zeeMonAlg_dnn = self.helper.addAlgorithm( CompFactory.TrigEgammaMonitorTagAndProbeAlgorithm, "TrigEgammaMonitorTagAndProbeAlgorithm_Zee_DNN" )

Definition at line 355 of file TrigEgammaMonitoringConfig.py.

The documentation for this class was generated from the following file:
Generated on for ATLAS Offline Software by doxygen 1.16.1