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
 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" )
 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_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

Detailed Description

Definition at line 29 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 58 of file TrigEgammaMonitoringConfig.py.

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

Member Function Documentation

◆ addGroup()

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

Definition at line 505 of file TrigEgammaMonitoringConfig.py.

505 def addGroup( self, monAlg, name, path ):
506 return self.helper.addGroup( monAlg, name, path )
507

◆ addHistogram()

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

Definition at line 508 of file TrigEgammaMonitoringConfig.py.

508 def addHistogram(self, monGroup, hist):
509 monGroup.defineHistogram(hist.name, **hist.kwargs)
510
511

◆ bookEFCaloDistributions()

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

Definition at line 679 of file TrigEgammaMonitoringConfig.py.

679 def bookEFCaloDistributions( self, monAlg, trigger ):
680
681 from TrigEgammaMonitoring.TrigEgammaMonitorHelper import TH1F
682 monGroup = self.addGroup( monAlg, trigger+'_Distributions_EFCalo', self.basePath+'/Shifter/'+trigger+'/Distributions/PrecisionCalo' )
683
684 self.addHistogram(monGroup, TH1F("et", "ET; ET [GeV] ; Count", 100, 0., 100.))
685 self.addHistogram(monGroup, TH1F("eta", "eta; eta ; Count", self._nEtabins, self._etabins))
686 self.addHistogram(monGroup, TH1F("phi", "phi; phi ; Count", 20, -3.2, 3.2))
687 self.addHistogram(monGroup, TH1F("energy", "Cluster Energy; E [GeV] ; Count", 50, 0., 100.))
688 self.addHistogram(monGroup, TH1F("highet", "Cluster Energy; E [GeV] ; Count", 100, 0., 800.))
689 self.addHistogram(monGroup, TH1F("eta_calo", "eta_calo; eta_calo ; Count", 50, -2.47, 2.47))
690 self.addHistogram(monGroup, TH1F("phi_calo", "phi_calo; phi_calo ; Count", 50, -3.14, 3.14))
691
692 if self.mc_mode:
693 self.addHistogram(monGroup, TH1F("energyBE0", "Cluster Energy BE0; E [GeV] ; Count", 50, 0., 100.))
694 self.addHistogram(monGroup, TH1F("energyBE1", "Cluster Energy BE1; E [GeV] ; Count", 50, 0., 100.))
695 self.addHistogram(monGroup, TH1F("energyBE2", "Cluster Energy BE2; E [GeV] ; Count", 50, 0., 100.))
696 self.addHistogram(monGroup, TH1F("energyBE3", "Cluster Energy BE3; E [GeV] ; Count", 50, 0., 100.))
697
698

◆ bookEfficiencies()

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

Definition at line 781 of file TrigEgammaMonitoringConfig.py.

781 def bookEfficiencies(self, monAlg, trigger, level, subgroup=None, doEmulation=False ):
782
783 from TrigEgammaMonitoring.TrigEgammaMonitorHelper import TH1F, TH2F, TProfile
784
785 dirname = 'Emulation' if doEmulation else 'Efficiency'
786 if subgroup:
787 monGroup = self.addGroup( monAlg, trigger+'_'+dirname+'_'+level+'_'+subgroup, self.basePath+'/Shifter/'+trigger+'/'+dirname+'/'+level+'/'+subgroup )
788 else:
789 monGroup = self.addGroup( monAlg, trigger+'_'+dirname+'_'+level, self.basePath+'/Shifter/'+trigger+'/'+dirname+'/'+level )
790
791 # Numerator
792 self.addHistogram(monGroup, TH1F("match_pt", "Trigger Matched Offline p_{T}; p_{T} [GeV] ; Count", self._nEtbins, self._etbins))
793 self.addHistogram(monGroup, TH1F("match_et", "Trigger Matched Offline E_{T}; E_{T} [GeV]; Count", self._nEtbins, self._etbins))
794 self.addHistogram(monGroup, TH1F("match_highet", "Trigger Matched Offline E_{T}; E_{T} [GeV]; Count", 40, 0., 500.))
795 self.addHistogram(monGroup, TH1F("match_eta", "Trigger Matched Offline #eta; #eta ; Count", self._nEtabins, self._etabins))
796 self.addHistogram(monGroup, TH1F("match_phi", "Trigger Matched #phi; #phi ; Count", 20, -3.2, 3.2))
797 self.addHistogram(monGroup, TH1F("match_avgmu", "Trigger Matched <#mu>; <#mu> ; Count", 16, 0, 80))
798 self.addHistogram(monGroup, TH1F("match_ptvarcone20rel", "Trigger Matched ptvarcone20rel; ptvarcone20rel ; Count", 50, 0, 0.2))
799 self.addHistogram(monGroup, TH1F("match_ptvarcone30rel", "Trigger Matched ptvarcone30rel; ptvarcone30rel ; Count", 50, 0, 0.2))
800 self.addHistogram(monGroup, TH1F("match_z0", "Trigger Matched z0; z0 ; Count", 50, -200,200))
801 self.addHistogram(monGroup, TH1F("match_d0", "Trigger Matched d0; d0 ; Count", 50, -0.8,0.8))
802
803 # Denominator
804 self.addHistogram(monGroup, TH1F("pt", "Offline p_{T}; p_{T} [GeV] ; Count", self._nEtbins, self._etbins))
805 self.addHistogram(monGroup, TH1F("et", "Offline E_{T}; E_{T} [GeV] ; Count", self._nEtbins, self._etbins))
806 self.addHistogram(monGroup, TH1F("highet", "Offline E_{T}; E_{T} [GeV] ; Count", 50, 0., 800.))
807 self.addHistogram(monGroup, TH1F("eta", "Offline #eta; #eta ; Count", self._nEtabins, self._etabins))
808 self.addHistogram(monGroup, TH1F("phi", "Offline #phi; #phi ; Count", 20, -3.2, 3.2))
809 self.addHistogram(monGroup, TH1F("avgmu", "<#mu>; <#mu> ; Count", 16, 0, 80))
810 self.addHistogram(monGroup, TH1F("ptvarcone20rel", "ptvarcone20rel; ptvarcone20rel ; Count", 50, 0, 0.2))
811 self.addHistogram(monGroup, TH1F("ptvarcone30rel", "ptvarcone30rel; ptvarcone30rel ; Count", 50, 0, 0.2))
812 self.addHistogram(monGroup, TH1F("z0", "z0; z0 ; Count", 50, -200, 200))
813 self.addHistogram(monGroup, TH1F("d0", "d0; d0 ; Count", 50, -0.8, 0.8))
814
815
816 # Efficiency
817 self.addHistogram(monGroup, TProfile("pt,pt_passed", "#epsilon(p_T); p_{T} ; Efficiency", self._nEtbins, self._etbins))
818 self.addHistogram(monGroup, TProfile("et,et_passed", "#epsilon(E_T); E_{T} [GeV] ; Efficiency", self._nEtbins, self._etbins))
819 self.addHistogram(monGroup, TProfile("highet,highet_passed", "#epsilon(E_T); E_{T} [GeV] ; Efficiency", 50, 0., 800.))
820 self.addHistogram(monGroup, TProfile("eta,eta_passed", "#epsilon(#eta); #eta ; Efficiency", self._nEtabins, self._etabins))
821 self.addHistogram(monGroup, TProfile("phi,phi_passed", "#epsilon(#phi); #phi ; Efficiency", 20, -3.2, 3.2))
822 self.addHistogram(monGroup, TProfile("avgmu,avgmu_passed", "#epsilon(<#mu>); <#mu> ; Efficiency", 16, 0, 80))
823 self.addHistogram(monGroup, TProfile("ptvarcone20rel,ptvarcone20rel_passed", "#epsilon(ptvarcone20rel); ptvarcone20rel ; Efficiency", 50, 0, 0.2))
824 self.addHistogram(monGroup, TProfile("ptvarcone30rel,ptvarcone30rel_passed", "#epsilon(ptvarcone30rel); ptvarcone30rel ; Efficiency", 50, 0, 0.2))
825 self.addHistogram(monGroup, TProfile("z0,z0_passed", "#epsilon(z0); z0 ; Efficiency", 50, -200, 200))
826 self.addHistogram(monGroup, TProfile("d0,d0_passed", "#epsilon(d0); d0 ; Efficiency", 50, -0.8, 0.8))
827
828 #2D plots
829 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))
830 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))
831
832
833
834 if self.mc_mode:
835 self.addHistogram(monGroup, TH1F("match_npvtx", "Trigger Matched npvtx; npvtx ; Count", 16, 0, 80))
836 self.addHistogram(monGroup, TH1F("npvtx", "npvtx; npvtx ; Count", 16, 0, 80))
837 self.addHistogram(monGroup, TProfile("npvtx,npvtx_passed", "#epsilon(npvtx); npvtx ; Efficiency", 16, 0, 80))
838 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))
839 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))
840
841 # Inefficiency
842 self.addHistogram(monGroup, TProfile("et,et_failed", "#epsilon(E_T); E_{T} [GeV] ; Inefficiency", self._nEtbins, self._etbins))
843 self.addHistogram(monGroup, TProfile("highet,highet_failed", "#epsilon(E_T); E_{T} [GeV] ; Inefficiency", 50, 0., 800.))
844 self.addHistogram(monGroup, TProfile("eta,eta_failed", "#epsilon(#eta); #eta ; Inefficiency", self._nEtabins, self._etabins))
845
846 # Efficiency ET in eta slices
847
848 self.addHistogram(monGroup, TProfile("et_slice0,et_slice0_passed", "#epsilon(E_T) in [|#eta| <= 0.8]; E_{T} [GeV] ; Efficiency", self._nEtbins, self._etbins))
849 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))
850 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))
851 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))
852
853

◆ bookEvent()

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

Definition at line 589 of file TrigEgammaMonitoringConfig.py.

589 def bookEvent(self, monAlg, analysis, tap=False):
590
591 # Create mon group. The group name should be the path name for map
592 monGroup = self.addGroup( monAlg, analysis, self.basePath+'/Expert/Event/'+analysis )
593
594 if tap:
595 cutLabels = ["Events","LAr","RetrieveElectrons","TwoElectrons","PassTrigger","EventWise","Success"]
596 probeLabels=["Electrons","NotTag","OS","SS","ZMass","HasTrack","HasCluster","Eta","Et","IsGoodOQ","GoodPid","NearbyJet","Isolated","GoodProbe"]
597 tagLabels=["Electrons","HasTrack","HasCluster","GoodPid","Et","Eta","IsGoodOQ","PassTrigger","MatchTrigger"]
598
599 monGroup.defineHistogram("CutCounter", type='TH1I', path='', title="Event Selection; Cut ; Count",
600 xbins=len(cutLabels), xmin=0, xmax=len(cutLabels), xlabels=cutLabels)
601 monGroup.defineHistogram("TagCutCounter", type='TH1F', path='', title="Number of Probes; Cut ; Count",
602 xbins=len(tagLabels), xmin=0, xmax=len(tagLabels), xlabels=tagLabels)
603 monGroup.defineHistogram("ProbeCutCounter", type='TH1F', path='', title="Number of Probes; Cut ; Count",
604 xbins=len(probeLabels), xmin=0, xmax=len(probeLabels), xlabels=probeLabels)
605 monGroup.defineHistogram("Mee", type='TH1F', path='', title="Offline M(ee); m_ee [GeV] ; Count",xbins=50,
606 xmin=monAlg.ZeeLowerMass, xmax=monAlg.ZeeUpperMass)
607
608

◆ bookExpertHistograms()

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

Definition at line 515 of file TrigEgammaMonitoringConfig.py.

515 def bookExpertHistograms( self, monAlg, triggers ):
516
517 self.__logger.info( "Booking all histograms for alg: %s", monAlg.name )
518
519
520 for trigger in triggers:
521
522 info = self.getTrigInfo(trigger)
523
524 if info.isL1Item():
525 self.bookL1CaloDistributions( monAlg, trigger )
526 self.bookEfficiencies( monAlg, trigger, "L1Calo" )
527 self.bookL1CaloResolutions( monAlg, trigger )
528 self.bookL1CaloAbsResolutions( monAlg, trigger )
529
530 else:
531 #
532 # Distributions
533 #
534 self.bookL1CaloDistributions( monAlg, trigger )
535 self.bookL2CaloDistributions( monAlg, trigger )
536 self.bookEFCaloDistributions( monAlg, trigger )
537
538 self.bookL1CaloResolutions( monAlg, trigger )
539 self.bookL1CaloAbsResolutions( monAlg, trigger )
540 self.bookL2CaloResolutions( monAlg, trigger )
541
542 if info.isElectron():
543 self.bookL2ElectronDistributions( monAlg, trigger )
544 # Offline and HLT
545 self.bookShowerShapesDistributions( monAlg, trigger, "HLT" ,online=True)
546 self.bookShowerShapesDistributions( monAlg, trigger, "HLT" ,online=False)
547 self.bookTrackingDistributions( monAlg, trigger, online=True )
548 self.bookTrackingDistributions( monAlg, trigger, online=False )
549 self.bookHLTResolutions( monAlg, trigger,"HLT" )
550 self.bookHLTElectronResolutions( monAlg, trigger, info.isIsolated() )
551
552 elif info.isPhoton():
553 self.bookL2PhotonDistributions( monAlg, trigger )
554 self.bookShowerShapesDistributions( monAlg, trigger, "HLT", online=True )
555 self.bookShowerShapesDistributions( monAlg, trigger, "HLT", online=False)
556 self.bookHLTResolutions( monAlg, trigger,"HLT" )
557 self.bookHLTPhotonResolutions( monAlg, trigger, info.isIsolated() )
558
559
560 #
561 # Efficiencies
562 #
563
564 self.bookEfficiencies( monAlg, trigger, "L1Calo" )
565 self.bookEfficiencies( monAlg, trigger, "FastCalo" )
566 self.bookEfficiencies( monAlg, trigger, "FastPhoton" if info.isPhoton() else "FastElectron")
567 self.bookEfficiencies( monAlg, trigger, "PrecisionCalo" )
568 self.bookEfficiencies( monAlg, trigger, "HLT")
569 if self.detailedHistograms:
570 for pid in self.isemnames + self.lhnames:
571 self.bookEfficiencies( monAlg, trigger, "HLT", pid )
572 self.bookEfficiencies( monAlg, trigger, "HLT", pid+"Iso" )
573
574 #
575 # Emulation
576 #
577 if self.emulator:
578 self.bookEfficiencies( monAlg, trigger, "L1Calo" , doEmulation=True)
579 self.bookEfficiencies( monAlg, trigger, "FastCalo" , doEmulation=True)
580 self.bookEfficiencies( monAlg, trigger, "PrecisionCalo" , doEmulation=True)
581 self.bookEfficiencies( monAlg, trigger, "FastPhoton" if info.isPhoton() else "FastElectron", doEmulation=True)
582 self.bookEfficiencies( monAlg, trigger, "HLT" , doEmulation=True)
583
584 # Inefficiencies
585 self.bookInefficiencies(monAlg, trigger)
586
587
588

◆ bookHLTElectronResolutions()

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

Definition at line 1005 of file TrigEgammaMonitoringConfig.py.

1005 def bookHLTElectronResolutions(self, monAlg, trigger, isolated=False):
1006
1007 from TrigEgammaMonitoring.TrigEgammaMonitorHelper import TH1F, TH2F
1008 monGroup = self.addGroup( monAlg, trigger+'_Resolutions_HLT', self.basePath+'/Shifter/'+trigger+'/Resolutions/HLT')
1009
1010 self.addHistogram(monGroup, TH1F("res_pt", "p_{T} resolution; (p_{T}(on)-p_{T}(off))/p_{T}(off) ; Count", 120, -1.5, 1.5))
1011 self.addHistogram(monGroup, TH1F("res_deta1", "deta1; deta1 ; (deta1(on)-deta1(off))/deta1(off)", 100, -1., 1.))
1012 self.addHistogram(monGroup, TH1F("res_deta2", "deta2; deta2 ; (deta2(on)-deta2(off))/deta2(off)", 100, -1., 1.))
1013 self.addHistogram(monGroup, TH1F("res_dphi2", "dphi2; dphi2 ; (dphi2(on)-dphi2(off))/dphi2(off)", 100, -1., 1.))
1014 self.addHistogram(monGroup, TH1F("res_z0", "resolution z0; (z0(on)-z0(off)) ; Count", 100, -0.5, 0.5))
1015 self.addHistogram(monGroup, TH1F("res_d0", "resolution d0; (d0(on)-d0(off)) ; Count", 100, -0.5, 0.5))
1016 self.addHistogram(monGroup, TH1F("res_d0sig", "resolution d0sig; (d0sig(on)-d0sig(off)) ; Count", 50, -10, 10))
1017
1018 if self.mc_mode:
1019 self.addHistogram(monGroup, TH1F("pt", "online p_{T}; p_{T}; Count", 50, 0., 100.))
1020 self.addHistogram(monGroup, TH1F("res_nscthits","resolution nSCTHit; (nSCTHits(on)-nSCTHits(off); Count",20, -10, 10))
1021 self.addHistogram(monGroup, TH1F("res_npixhits","resolution nPixHit; (nPixHits(on)-nPixHits(off)); Count",10, -5, 5))
1022 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.))
1023 self.addHistogram(monGroup, TH1F("res_dphiresc", "dphiresc; (dphires(on)-dphires(off))/dphires(off) ; Count", 100, -1., 1.))
1024 self.addHistogram(monGroup, TH1F("res_eprobht","resolution eProbHT; (eProbHT(on)-eProbHT(off)); Count",50, -1, 1))
1025
1026 if isolated:
1027 self.addHistogram(monGroup, TH1F("res_ptcone20", "resolution ptcone20; ptcone20 (on-off)/off; Count", 200, -0.1, 0.1))
1028 self.addHistogram(monGroup, TH1F("res_ptcone20_rel", "resolution ptcone20/pt; ptcone20/pt (on-off)/off; Count", 100, -0.1, 0.1))
1029 self.addHistogram(monGroup, TH2F("eta,res_ptcone20_rel", "HLT ptcone20/pt resolution as function of #eta; #eta; (on-off)/off; Count",
1030 50, -2.47, 2.47,
1031 100, -0.1, 0.1))
1032 self.addHistogram(monGroup, TH2F("et,res_ptcone20_rel", "HLT ptcone20/pt resolution as function of E_{T}; E_{T} [GeV]; (on-off)/off; Count",
1033 50, 0., 100.,
1034 100, -0.1, 0.1))
1035 self.addHistogram(monGroup, TH2F("mu,res_ptcone20", "HLT ptcone20 resolution as function of avg #mu; #mu; (on-off)/off; Count",
1036 50, 0, 100,
1037 100, -0.1, 0.1))
1038 self.addHistogram(monGroup, TH2F("mu,res_ptcone20_rel", "HLT ptcone20/pt resolution as function of avg #mu; #mu; (on-off)/off; Count",
1039 50, 0, 100,
1040 100, -0.1, 0.1))
1041
1042 self.addHistogram(monGroup, TH1F("res_ptvarcone20", "resolution ptvarcone20; ptvarcone20 (on-off)/off; Count", 200, -0.1, 0.1))
1043 self.addHistogram(monGroup, TH1F("res_ptvarcone20_rel", "resolution ptvarcone20/pt; ptvarcone20/pt (on-off)/off; Count", 100, -0.1, 0.1))
1044 self.addHistogram(monGroup, TH2F("eta,res_ptvarcone20_rel", "HLT ptvarcone20/pt resolution as function of #eta; #eta; (on-off)/off; Count",
1045 50, -2.47, 2.47,
1046 100, -0.1, 0.1))
1047 self.addHistogram(monGroup, TH2F("et,res_ptvarcone20_rel", "HLT ptvarcone20/pt resolution as function of E_{T}; E_{T} [GeV]; (on-off)/off; Count",
1048 50, 0., 100.,
1049 100, -0.1, 0.1))
1050 self.addHistogram(monGroup, TH2F("mu,res_ptvarcone20", "HLT ptvarcone20 resolution as function of avg #mu; #mu; (on-off)/off; Count",
1051 50, 0, 100,
1052 100, -0.1, 0.1))
1053 self.addHistogram(monGroup, TH2F("mu,res_ptvarcone20_rel", "HLT ptvarcone20/pt resolution as function of avg #mu; #mu; (on-off)/off; Count",
1054 50, 0, 100,
1055 100, -0.1, 0.1))
1056
1057

◆ bookHLTPhotonResolutions()

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

Definition at line 1058 of file TrigEgammaMonitoringConfig.py.

1058 def bookHLTPhotonResolutions(self, monAlg, trigger, isolated=False):
1059
1060
1061 from TrigEgammaMonitoring.TrigEgammaMonitorHelper import TH1F, TH2F
1062 monGroup = self.addGroup( monAlg, trigger+'_Resolutions_HLT', self.basePath+'/Shifter/'+trigger+'/Resolutions/HLT' )
1063
1064 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))
1065 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))
1066
1067 if self.data_type is DQDataType.MC:
1068 self.addHistogram(monGroup, TH2F("eta,res_cnv_et",
1069 "HLT E_{T} resolution as function of #eta for converted Photons; #eta; (E_{T}(on)-E_{T}(off))/E_{T}(off); Count",
1070 50, -2.47, 2.47,
1071 200, -0.1, 0.1))
1072 self.addHistogram(monGroup, TH2F("et,res_cnv_et",
1073 "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",
1074 50, 0., 100.,
1075 200, -0.1, 0.1))
1076 self.addHistogram(monGroup, TH2F("eta,res_uncnv_et",
1077 "HLT E_{T} resolution as function of #eta for unconverted Photons; #eta; (E_{T}(on)-E_{T}(off))/E_{T}(off); Count",
1078 50, -2.47, 2.47,
1079 200, -0.1, 0.1))
1080 self.addHistogram(monGroup, TH2F("et,res_uncnv_et",
1081 "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",
1082 50, 0., 100.,
1083 200, -0.1, 0.1))
1084 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))
1085 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))
1086 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))
1087 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))
1088 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))
1089 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))
1090 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))
1091 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))
1092
1093
1094 if isolated:
1095
1096 self.addHistogram(monGroup, TH1F("res_topoetcone20", "resolution topoetcone20; ptcone20 (on-off)/off; Count", 200, -0.1, 0.1))
1097 self.addHistogram(monGroup, TH1F("res_topoetcone20_rel", "resolution topoetcone20/pt; ptcone20/pt (on-off)/off; Count", 100, -0.1, 0.1))
1098
1099 if self.detailedHistograms:
1100 self.addHistogram(monGroup, TH2F("eta,res_topoetcone20_rel", "HLT topoetcone20/pt resolution as function of #eta; #eta; (on-off)/off; Count",
1101 50, -2.47, 2.47,
1102 100, -0.1, 0.1))
1103 self.addHistogram(monGroup, TH2F("et,res_topoetcone20_rel", "HLT topoetcone20/pt resolution as function of E_{T}; E_{T} [GeV]; (on-off)/off; Count",
1104 50, 0., 100.,
1105 100, -0.1, 0.1))
1106 self.addHistogram(monGroup, TH2F("mu,res_topoetcone20", "HLT topoetcone20 resolution as function of avg #mu; #mu; (on-off)/off; Count",
1107 50, 0, 100,
1108 100, -0.1, 0.1))
1109 self.addHistogram(monGroup, TH2F("mu,res_topoetcone20_rel", "HLT topoetcone20/pt resolution as function of avg #mu; #mu; (on-off)/off; Count",
1110 50, 0, 100,
1111 100, -0.1, 0.1))
1112
1113
1114

◆ bookHLTResolutions()

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

Definition at line 969 of file TrigEgammaMonitoringConfig.py.

969 def bookHLTResolutions(self, monAlg, trigger,level):
970
971 from TrigEgammaMonitoring.TrigEgammaMonitorHelper import TH1F, TH2F
972 monGroup = self.addGroup( monAlg, trigger+'_Resolutions_HLT', self.basePath+'/Shifter/'+trigger+'/Resolutions/'+level )
973
974 # online values used to fill all 2d histograms
975 self.addHistogram(monGroup, TH1F("et", "E_{T}; E_{T}[GeV] ; Count", 50, 0.0, 100.))
976 self.addHistogram(monGroup, TH1F("eta", "#eta; #eta ; Count", 50, -2.47, 2.47))
977 self.addHistogram(monGroup, TH1F("mu", "#mu; #mu ; Count", 50, 0, 100))
978
979 self.addHistogram(monGroup, TH1F("res_et", "E_{T} resolution; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 100, -0.1, 0.1))
980 self.addHistogram(monGroup, TH1F("res_eta", "#eta resolution; (#eta(on)-#eta(off))/#eta(off) ; Count", 40, -0.001, 0.001))
981 self.addHistogram(monGroup, TH1F("res_phi", "#phi resolution; (#phi(on)-#phi(off))/#phi(off) ; Count", 40, -0.001, 0.001))
982 self.addHistogram(monGroup, TH1F("res_ethad", "ethad resolution; (ethad(on)-ethad(off))/ethad(off) ; Count", 20, -5, 5))
983 self.addHistogram(monGroup, TH1F("res_Rhad", "Rhad resolution; (Rhad(on)-Rhad(off))/Rhad(off) ; Count", 20, -10., 10.))
984 self.addHistogram(monGroup, TH1F("res_Reta", "Reta resolution; (Reta(on)-Reta(off))/Reta(off) ; Count", 20, -0.01, 0.01))
985 self.addHistogram(monGroup, TH1F("res_Rphi", "Rphi resolution; (Rphi(on)-Rphi(off))/Rphi(off) ; Count", 20, -0.01, 0.01))
986 self.addHistogram(monGroup, TH1F("res_weta2", "weta2 resolution; (weta2(on)-weta2(off))/weta2(off) ; Count", 20, -0.05, 0.05))
987 self.addHistogram(monGroup, TH1F("res_eratio", "eratio resolution; (eratio(on)-eratio(off))/eratio(off) ; Count", 20, -0.001, 0.001))
988
989
990 if self.mc_mode:
991 self.addHistogram(monGroup, TH1F("res_weta1", "weta1 resolution; (weta1(on)-weta1(off))/weta1(off) ; Count", 20, -0.05, 0.05))
992 self.addHistogram(monGroup, TH1F("res_ethad1", "ethad1 resolution; (ethad1(on)-ethad1(off))/ethad1(off) ; Count", 20, -5, 5))
993 self.addHistogram(monGroup, TH1F("res_Rhad1", "Rhad1; Rhad1 resolution; (Rhad1(on)-Rhad1(off))/Rhad1(off)", 20, -10., 10.))
994 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))
995 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))
996 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))
997 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))
998 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))
999 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))
1000 self.addHistogram(monGroup, TH1F("res_f1", "f1 resolution; (f1(on)-f1(off))/f1(off) ; Count", 20, -0.05, 0.05))
1001 self.addHistogram(monGroup, TH1F("res_f3", "f3 resolution; (f3(on)-f3(off))/f3(off) ; Count", 20, -0.05, 0.05))
1002
1003
1004

◆ bookInefficiencies()

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

Definition at line 854 of file TrigEgammaMonitoringConfig.py.

854 def bookInefficiencies(self, monAlg, trigger):
855
856 monGroup = self.addGroup( monAlg, trigger+'_Inefficiency', self.basePath+'/Expert/Inefficiency/'+trigger)
857 levelLabels = ["L1Calo","L2Calo","L2","EFCalo","HLT"]
858 monGroup.defineHistogram("InefficiencyCounts", type='TH1F', path='', title="Inefficiency; Steps ; Count",xbins=len(levelLabels), xmin=0, xmax=len(levelLabels), xlabels=levelLabels)
859
860

◆ bookL1CaloAbsResolutions()

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

Definition at line 872 of file TrigEgammaMonitoringConfig.py.

872 def bookL1CaloAbsResolutions(self, monAlg, trigger):
873
874 from TrigEgammaMonitoring.TrigEgammaMonitorHelper import TH1F, TH2F
875 monGroup = self.addGroup( monAlg, trigger+'_AbsResolutions_L1Calo', self.basePath+'/Shifter/'+trigger+'/AbsResolutions/L1Calo' )
876 self.addHistogram(monGroup, TH1F("res_et", "E_{T} resolution; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 100, -0.1, 0.1))
877 self.addHistogram(monGroup, TH1F("eta", "#eta; #eta ; Count", 50, -2.47, 2.47))
878
879 if self.mc_mode:
880 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))
881
882

◆ bookL1CaloDistributions()

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

Definition at line 612 of file TrigEgammaMonitoringConfig.py.

612 def bookL1CaloDistributions( self , monAlg, trigger ):
613
614 from TrigEgammaMonitoring.TrigEgammaMonitorHelper import TH1F
615 monGroup = self.addGroup( monAlg, trigger+'_Distributions_L1Calo', self.basePath+'/Shifter/'+trigger+'/Distributions/L1Calo' )
616
617 if 'L1eEM' in trigger:
618
619 self.addHistogram(monGroup, TH1F("et" , "Et; Et [GeV] ; Count", 100, 0., 800.))
620 self.addHistogram(monGroup, TH1F("eta" , "eta; eta ; Count" , 50, -2.5, 2.5))
621 self.addHistogram(monGroup, TH1F("phi" , "phi; phi ; Count" , 20, -3.2, 3.2))
622 self.addHistogram(monGroup, TH1F("Rhad" , "Rhad; Rhad ; Count" , 40, 0, 1))
623 self.addHistogram(monGroup, TH1F("Reta" , "Reta; Reta ; Count" , 40, 0, 1 ))
624 self.addHistogram(monGroup, TH1F("Wstot" , "Wstot; Wstot ; Count", 40, 0, 4 ))
625
626 else: # L1Calo Legacy
627 self.addHistogram(monGroup, TH1F("energy", "Cluster Energy; E [GeV] ; Count", 100, 0., 800.))
628 self.addHistogram(monGroup, TH1F("roi_et", "RoI word Cluster Energy; E [GeV] ; Count", 100, 0, 200))
629 self.addHistogram(monGroup, TH1F("emIso", "EM Isolation; E [GeV] ; Count", 50, -1., 20.))
630 self.addHistogram(monGroup, TH1F("hadCore", "HAD Isolation; E [GeV] ; Count", 50, -1., 20.))
631 self.addHistogram(monGroup, TH1F("eta", "eta; eta ; Count", 50, -2.5, 2.5))
632 self.addHistogram(monGroup, TH1F("phi", "phi; phi ; Count", 20, -3.2, 3.2))
633
634
635

◆ bookL1CaloResolutions()

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

Definition at line 861 of file TrigEgammaMonitoringConfig.py.

861 def bookL1CaloResolutions(self, monAlg, trigger):
862
863 from TrigEgammaMonitoring.TrigEgammaMonitorHelper import TH1F, TH2F
864 monGroup = self.addGroup( monAlg, trigger+'_Resolutions_L1Calo', self.basePath+'/Shifter/'+trigger+'/Resolutions/L1Calo' )
865 self.addHistogram(monGroup, TH1F("res_et", "E_{T} resolution; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 100, -0.1, 0.1))
866
867 if self.mc_mode:
868 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))
869 self.addHistogram(monGroup, TH1F("eta", "eta; eta ; Count", 50, -2.47, 2.47))
870
871

◆ bookL2CaloDistributions()

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

Definition at line 639 of file TrigEgammaMonitoringConfig.py.

639 def bookL2CaloDistributions( self , monAlg, trigger ):
640
641 from TrigEgammaMonitoring.TrigEgammaMonitorHelper import TH1F
642 monGroup = self.addGroup( monAlg, trigger+'_Distributions_L2Calo', self.basePath+'/Shifter/'+trigger+'/Distributions/FastCalo' )
643
644 self.addHistogram(monGroup, TH1F("et", "ET; ET [GeV] ; Count", 100, 0., 100.))
645 self.addHistogram(monGroup, TH1F("highet", "ET; ET [GeV] ; Count", 100, 0., 800.))
646 self.addHistogram(monGroup, TH1F("eta", "eta; eta ; Count", self._nEtabins, self._etabins))
647 self.addHistogram(monGroup, TH1F("phi", "phi; phi ; Count", 20, -3.2, 3.2))
648
649

◆ bookL2CaloResolutions()

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

Definition at line 883 of file TrigEgammaMonitoringConfig.py.

883 def bookL2CaloResolutions(self, monAlg, trigger):
884
885 from TrigEgammaMonitoring.TrigEgammaMonitorHelper import TH1F, TH2F
886 monGroup = self.addGroup( monAlg, trigger+'_Resolutions_L2Calo', self.basePath+'/Shifter/'+trigger+'/Resolutions/FastCalo' )
887
888 # online values used to fill all 2d histograms
889
890 self.addHistogram(monGroup, TH1F("res_Rhad", "Rhad resolution; (Rhad(on)-Rhad(off))/Rhad(off) ; Count", 20, -10., 10.))
891 self.addHistogram(monGroup, TH1F("res_et", "E_{T} resolution; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 100, -0.1, 0.1))
892 self.addHistogram(monGroup, TH1F("res_eta", "#eta resolution; (#eta(on)-#eta(off))/#eta(off) ; Count", 40, -0.001, 0.001))
893 self.addHistogram(monGroup, TH1F("res_phi", "#phi resolution; (#phi(on)-#phi(off))/#phi(off) ; Count", 40, -0.001, 0.001))
894 self.addHistogram(monGroup, TH1F("res_ethad", "ethad resolution; (ethad(on)-ethad(off))/ethad(off) ; Count", 20, -5, 5))
895 self.addHistogram(monGroup, TH1F("res_weta2", "weta2 resolution; (weta2(on)-weta2(off))/weta2(off) ; Count", 20, -0.05, 0.05))
896 self.addHistogram(monGroup, TH1F("res_Reta", "Reta resolution; (Reta(on)-Reta(off))/Reta(off) ; Count", 20, -0.01, 0.01))
897 self.addHistogram(monGroup, TH1F("res_Rphi", "Rphi resolution; (Rphi(on)-Rphi(off))/Rphi(off) ; Count", 20, -0.01, 0.01))
898 self.addHistogram(monGroup, TH1F("res_eratio", "eratio resolution; (eratio(on)-eratio(off))/eratio(off) ; Count", 20, -0.001, 0.001))
899
900 if self.mc_mode:
901 self.addHistogram(monGroup, TH1F("res_ethad1", "ethad1 resolution; (ethad1(on)-ethad1(off))/ethad1(off) ; Count", 20, -5, 5))
902 self.addHistogram(monGroup, TH1F("res_Rhad1", "Rhad1; Rhad1 resolution; (Rhad1(on)-Rhad1(off))/Rhad1(off)", 20, -10., 10.))
903 self.addHistogram(monGroup, TH1F("res_f1", "f1 resolution; (f1(on)-f1(off))/f1(off) ; Count", 20, -0.05, 0.05))
904 self.addHistogram(monGroup, TH1F("res_f3", "f3 resolution; (f3(on)-f3(off))/f3(off) ; Count", 20, -0.05, 0.05))
905
906 # Book all 2D histograms
907 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",
908 50, 0., 100.,
909 100, -0.1, 0.1))
910 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",
911 50, -2.47, 2.47,
912 100, -0.1, 0.1))
913 self.addHistogram(monGroup, TH2F("eta,res_f3", "L2Calo f3 resolution as function of #eta; #eta; (f3(on)-f3(off))/f3(off); Count",
914 50, -2.47, 2.47,
915 20, -0.05, 0.05))
916 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",
917 50, 0., 100.,
918 20, -0.05, 0.05))
919 self.addHistogram(monGroup, TH2F("eta,res_f1", "L2Calo f1 resolution as function of #eta; #eta; (f1(on)-f1(off))/f1(off); Count",
920 50, -2.47, 2.47,
921 20, -0.05, 0.05))
922 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",
923 50, 0., 100.,
924 20, -0.05, 0.05))
925 self.addHistogram(monGroup, TH2F("eta,res_weta2", "L2Calo weta2 resolution as function of #eta; #eta; (weta2(on)-weta2(off))/weta2(off); Count",
926 50, -2.47, 2.47,
927 20, -0.05, 0.05))
928 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",
929 50, 0., 100.,
930 20, -0.05, 0.05))
931 self.addHistogram(monGroup, TH2F("eta,res_Reta", "L2Calo Reta resolution as function of #eta; #eta; (Reta(on)-Reta(off))/Reta(off); Count",
932 50, -2.47, 2.47,
933 20, -0.05, 0.05))
934 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",
935 50, 0., 100.,
936 20, -0.05, 0.05))
937 self.addHistogram(monGroup, TH2F("eta,res_Rhad1", "L2Calo E_{T} Rhad1 resolution as function of #eta; #eta; (Rhad1(on)-Rhad1(off))/Rhad1(off); Count",
938 50, -2.47, 2.47,
939 20, -10, 10))
940 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",
941 50, 0., 100.,
942 20, -10, 10))
943 self.addHistogram(monGroup, TH2F("eta,res_Rhad", "L2Calo E_{T} Rhad resolution as function of #eta; #eta; (Rhad(on)-Rhad(off))/Rhad(off); Count",
944 50, -2.47, 2.47,
945 20, -10, 10))
946 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",
947 50, 0., 100.,
948 20, -10, 10))
949 self.addHistogram(monGroup, TH2F("eta,res_ethad1", "L2Calo E_{T} Had1 resolution as function of #eta; #eta; (ethad1(on)-ethad1(off))/ethad1(off); Count",
950 50, -2.47, 2.47,
951 20, -0.5, 0.5))
952 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",
953 50, 0., 100.,
954 20, -0.5, 0.5))
955 self.addHistogram(monGroup, TH2F("eta,res_ethad", "L2Calo E_{T} Had resolution as function of #eta; #eta; (ethad(on)-ethad(off))/ethad(off); Count",
956 50, -2.47, 2.47,
957 20, -0.5, 0.5))
958 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",
959 50, 0., 100.,
960 20, -0.5, 0.5))
961 self.addHistogram(monGroup, TH2F("eta,res_eratio", "L2Calo eratio resolution as function of #eta; #eta; (eratio(on)-eratio(off))/eratio(off); Count",
962 50, -2.47, 2.47,
963 20, -0.001, 0.001))
964 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",
965 50, 0., 100.,
966 50, -0.001, 0.001))
967
968

◆ bookL2ElectronDistributions()

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

Definition at line 653 of file TrigEgammaMonitoringConfig.py.

653 def bookL2ElectronDistributions( self, monAlg, trigger ):
654
655 from TrigEgammaMonitoring.TrigEgammaMonitorHelper import TH1F
656 monGroup = self.addGroup( monAlg, trigger+'_Distributions_L2Electron', self.basePath+'/Shifter/'+trigger+'/Distributions/FastElectron' )
657
658 self.addHistogram(monGroup, TH1F("et", "ET; ET [GeV] ; Count", 100, 0., 100.))
659 self.addHistogram(monGroup, TH1F("highet", "ET; ET [GeV] ; Count", 100, 0., 800.))
660 self.addHistogram(monGroup, TH1F("eta", "eta; eta ; Count", self._nEtabins, self._etabins))
661 self.addHistogram(monGroup, TH1F("phi", "phi; phi ; Count", 20, -3.2, 3.2))
662

◆ bookL2PhotonDistributions()

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

Definition at line 667 of file TrigEgammaMonitoringConfig.py.

667 def bookL2PhotonDistributions( self, monAlg, trigger ):
668
669 from TrigEgammaMonitoring.TrigEgammaMonitorHelper import TH1F
670 monGroup = self.addGroup( monAlg, trigger+'_Distributions_L2Photon', self.basePath+'/Shifter/'+trigger+'/Distributions/FastPhoton' )
671
672 self.addHistogram(monGroup, TH1F("et", "ET; ET [GeV] ; Count", 100, 0., 100.))
673 self.addHistogram(monGroup, TH1F("highet", "ET; ET [GeV] ; Count", 100, 0., 800.))
674 self.addHistogram(monGroup, TH1F("eta", "eta; eta ; Count", self._nEtabins, self._etabins))
675 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 702 of file TrigEgammaMonitoringConfig.py.

702 def bookShowerShapesDistributions( self, monAlg, trigger, level, online=True):
703
704 from TrigEgammaMonitoring.TrigEgammaMonitorHelper import TH1F
705
706 monGroup = self.addGroup( monAlg, trigger+'_Distributions_' + ("HLT" if online else "Offline"),
707 self.basePath+'/Shifter/'+trigger+'/Distributions/' + (level if online else "Offline") )
708
709 info = self.getTrigInfo(trigger)
710
711 self.addHistogram(monGroup, TH1F("Rhad", "Rhad; Rhad ; Count", 35, -0.3, 0.3))
712 self.addHistogram(monGroup, TH1F("Reta", "Reta; Reta ; Count", 15, 0.4, 1.2))
713 self.addHistogram(monGroup, TH1F("Rphi", "Rphi; Rphi ; Count", 15, 0.4, 1.2))
714 self.addHistogram(monGroup, TH1F("weta2", "weta2; weta2 ; Count", 20, 0., 0.02))
715 self.addHistogram(monGroup, TH1F("f1", "f1; f1 ; Count", 11, 0, 1.))
716 self.addHistogram(monGroup, TH1F("f3", "f3; f3 ; Count", 21, -0.05, 0.1))
717 self.addHistogram(monGroup, TH1F("eratio","eratio; eratio; Count",20, 0, 2))
718 self.addHistogram(monGroup, TH1F("et", "ET; ET [GeV] ; Count", 100, 0., 100.))
719 self.addHistogram(monGroup, TH1F("highet", "Offline E_{T}; E_{T} [GeV] ; Count", 100, 0., 800.))
720 self.addHistogram(monGroup, TH1F("eta", "eta; eta ; Count", self._nEtabins, self._etabins))
721 self.addHistogram(monGroup, TH1F("phi", "phi; phi ; Count", 20, -3.2, 3.2))
722
723 if not info.isElectron():
724 self.addHistogram(monGroup, TH1F("topoetcone20", "topoetcone20; topoetcone20 [GeV] ; Count", 100, -10.0, 10.0))
725 self.addHistogram(monGroup, TH1F("topoetcone20_rel", "topoetcone20/pt; topoetcone20/pt ; Count", 100, -0.5, 0.5))
726 self.addHistogram(monGroup, TH1F("topoetcone40_shift", "topoetcone40-2.45 GeV; topoetcone40-2.45 GeV [GeV] ; Count", 100, -10.0, 10.0))
727 self.addHistogram(monGroup, TH1F("topoetcone40_shift_rel", "(topoetcone40-2.45 GeV)/pt; (topoetcone40-2.45 GeV)/pt ; Count", 100, -0.5, 0.5))
728
729 if self.mc_mode:
730 self.addHistogram(monGroup, TH1F("Rhad1", "Rhad1; Rhad1 ; Count", 30, -0.3, 0.3))
731 self.addHistogram(monGroup, TH1F("weta1", "weta1; weta1 ; Count", 12, 0.4, 1.))

◆ bookTopoHistograms()

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

Definition at line 1115 of file TrigEgammaMonitoringConfig.py.

1115 def bookTopoHistograms(self, monAlg, trigger_configs ):
1116
1117 from TrigEgammaMonitoring.TrigEgammaMonitorHelper import TH1F, TProfile
1118 from TrigEgammaMonitoring.TrigEgammaMonitCategory import topo_config
1119
1120
1121 for d in trigger_configs:
1122
1123 trigger = d['trigger_num']
1124
1125 if not d['topo'] in topo_config.keys():
1126 self.__logger.fatal("Mon combo tool only support Zee, Jpsiee, Heg trigger. Current chain is %s", trigger)
1127
1128 monGroup_on = self.addGroup( monAlg, trigger+'_Efficiency_HLT', self.basePath+'/Expert/'+trigger+'/Efficiency/HLT' )
1129 monGroup_off = self.addGroup( monAlg, trigger+'_Efficiency_Offline', self.basePath+'/Expert/'+trigger+'/Efficiency/Offline' )
1130
1131 xmin = topo_config[d['topo']]['mass'][0]
1132 xmax = topo_config[d['topo']]['mass'][1]
1133 self.addHistogram(monGroup_on, TH1F("mass", "Online M(ee); m_ee [GeV] ; Count", 50, xmin, xmax))
1134 self.addHistogram(monGroup_on, TH1F("match_mass", "Online M(ee); m_ee [GeV] ; Count", 50, xmin, xmax))
1135 self.addHistogram(monGroup_on, TProfile("mass,match_mass", "Online #epsilon(M(ee)); m_ee; #epsilon(M(ee))", 50, xmin, xmax))
1136 self.addHistogram(monGroup_off, TH1F("mass", "Offline M(ee); m_ee [GeV] ; Count", 50, xmin, xmax))
1137 self.addHistogram(monGroup_off, TH1F("match_mass", "Offline M(ee); m_ee [GeV] ; Count", 50, xmin, xmax))
1138 self.addHistogram(monGroup_off, TProfile("mass,match_mass", "Offline #epsilon(M(ee)); p_{T} ; #epsilon(M(ee))", 50, xmin, xmax))
1139
1140 xmin = topo_config[d['topo']]['dphi'][0]
1141 xmax = topo_config[d['topo']]['dphi'][1]
1142 self.addHistogram(monGroup_on, TH1F("dphi", "Online #Delta#phi; #Delte#phi; Count", 50, xmin, xmax))
1143 self.addHistogram(monGroup_on, TH1F("match_dphi", "Online #Delta#phi; #Delte#phi; Count", 50, xmin, xmax))
1144 self.addHistogram(monGroup_on, TProfile("dphi,match_dphi", "Online #epsilon(#Delta#phi); #Delta#phi; #epsilon(#Delta#phi)", 50, xmin, xmax))
1145 self.addHistogram(monGroup_off, TH1F("dphi", "Offline #Delta#phi; #Delte#phi; Count", 50, xmin, xmax))
1146 self.addHistogram(monGroup_off, TH1F("match_dphi", "Offline #Delta#phi; #Delte#phi; Count", 50, xmin, xmax))
1147 self.addHistogram(monGroup_off, TProfile("dphi,match_dphi", "Offline #epsilon(#Delta#phi); #Delta#phi; #epsilon(#Delta#phi)", 50, xmin, xmax))
1148
1149

◆ bookTrackingDistributions()

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

Definition at line 735 of file TrigEgammaMonitoringConfig.py.

735 def bookTrackingDistributions( self, monAlg, trigger,online=True ):
736
737
738 from TrigEgammaMonitoring.TrigEgammaMonitorHelper import TH1F, TH2F
739
740 monGroup = self.addGroup( monAlg, trigger+'_Distributions_' + ("HLT" if online else "Offline"),
741 self.basePath+'/Shifter/'+trigger+'/Distributions/' + ("HLT" if online else "Offline") )
742
743 # Tracking quantities
744 self.addHistogram(monGroup, TH1F("deta2", "deta2; deta2 ; Count", 40, -0.01, 0.01))
745 self.addHistogram(monGroup, TH1F("dphi2", "dphi2; dphi2 ; Count", 40, -0.1, 0.1))
746 self.addHistogram(monGroup, TH1F("eprobht","eProbHT; eProbHT; Count",20, 0, 1.))
747 self.addHistogram(monGroup, TH1F("npixhits","nPixHit; nPixHits; Count",10, 0, 10))
748 self.addHistogram(monGroup, TH1F("nscthits","nSCTHit; nSCTHits; Count",20, 0, 20))
749 self.addHistogram(monGroup, TH1F("pt", "p_{T}; p_{T} [GeV] ; Count", 50,0.,200.))
750 self.addHistogram(monGroup, TH1F("pt_track", "p_{T} tracks; p_{T} [GeV] ; Count", 100,0.,200.))
751 self.addHistogram(monGroup, TH1F("ptcone20", "ptcone20; ptcone20; Count", 50, 0.0, 5.0))
752 self.addHistogram(monGroup, TH1F("ptvarcone20", "ptvarcone20; ptvarcone20; Count", 50, 0.0, 5.0))
753 self.addHistogram(monGroup, TH1F("ptcone20_rel", "ptcone20/pt; ptcone20/pt; Count", 50, 0.0, 1.0))
754 self.addHistogram(monGroup, TH1F("ptcone30_rel", "ptcone30/pt; ptcone30/pt; Count", 50, 0.0, 1.0))
755 self.addHistogram(monGroup, TH1F("ptvarcone20_rel", "ptvarcone20/pt; ptvarcone20/pt; Count", 50, 0.0, 0.2))
756 self.addHistogram(monGroup, TH1F("ptvarcone30_rel", "ptvarcone30/pt; ptvarcone30/pt; Count", 50, 0.0, 0.2))
757 self.addHistogram(monGroup, TH1F("z0", "z0; z0 ; Count", 50, -200, 200))
758 self.addHistogram(monGroup, TH1F("d0", "d0; d0 ; Count", 40, -1, 1))
759 self.addHistogram(monGroup, TH1F("d0sig", "d0sig; d0sig ; Count", 40, -10, 10))
760
761 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))
762 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))
763
764 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))
765 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))
766
767 if self.mc_mode:
768 self.addHistogram(monGroup, TH1F("deta1_EMECA", "deta1 EMEC-A; deta1 ; Count", 40, -0.01, 0.01))
769 self.addHistogram(monGroup, TH1F("deta1_EMECC", "deta1 EMEC-C; deta1 ; Count", 40, -0.01, 0.01))
770 self.addHistogram(monGroup, TH1F("deta1_EMEBA", "deta1 EMEB-A; deta1 ; Count", 40, -0.01, 0.01))
771 self.addHistogram(monGroup, TH1F("deta1_EMEBC", "deta1 EMEB-A; deta1 ; Count", 40, -0.01, 0.01))
772 self.addHistogram(monGroup, TH1F("deta1", "deta1; deta1 ; Count", 40, -0.01, 0.01))
773 self.addHistogram(monGroup, TH1F("charge","charge; charge; Count", 4,-2,2))
774 self.addHistogram(monGroup, TH1F("dphiresc", "dphiresc; dphiresc ; Count", 40, -0.1, 0.1))
775 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))
776
777

◆ configure()

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.configure ( self)

Definition at line 116 of file TrigEgammaMonitoringConfig.py.

116 def configure(self):
117 self.setProperties()
118 self.configureMonitor()
119 self.configureHistograms()
120
121
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 468 of file TrigEgammaMonitoringConfig.py.

468 def configureHistograms(self):
469
470 self.setBinning()
471
472 if self.activate_zee:
473
474 # LH plots
475 self.bookEvent( self.zeeMonAlg, self.zeeMonAlg.Analysis , True)
476 triggers = self.zeeMonAlg.TriggerList; triggers.extend( self.zeeMonAlg.TagTriggerList )
477 self.bookExpertHistograms( self.zeeMonAlg, triggers )
478
479 # dnn plots
480 self.bookEvent( self.zeeMonAlg_dnn, self.zeeMonAlg_dnn.Analysis , True)
481 triggers = self.zeeMonAlg_dnn.TriggerList; triggers.extend( self.zeeMonAlg_dnn.TagTriggerList )
482 self.bookExpertHistograms( self.zeeMonAlg_dnn, triggers )
483
484 if self.activate_jpsiee:
485 self.setBinning(True)
486 self.bookEvent( self.jpsieeMonAlg, self.jpsieeMonAlg.Analysis, True )
487 triggers = self.jpsieeMonAlg.TriggerList; triggers.extend( self.jpsieeMonAlg.TagTriggerList )
488 self.bookExpertHistograms( self.jpsieeMonAlg, triggers )
489
490 # back to default bin configuration
491 self.setBinning()
492 if self.activate_electron:
493 self.bookExpertHistograms( self.elMonAlg, self.elMonAlg.TriggerList )
494 if self.activate_photon:
495 self.bookExpertHistograms( self.phMonAlg, self.phMonAlg.TriggerList )
496
497
498 # configure topo chains
499 if self.activate_topo:
500 self.bookTopoHistograms( self.topoMonAlg, self.topoMonAlg.TriggerListConfig )
501
502

◆ configureMode()

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.configureMode ( self)

Definition at line 80 of file TrigEgammaMonitoringConfig.py.

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

◆ configureMonitor()

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.configureMonitor ( self)

Definition at line 210 of file TrigEgammaMonitoringConfig.py.

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

◆ get_monitoring_mode()

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.get_monitoring_mode ( self)

Definition at line 122 of file TrigEgammaMonitoringConfig.py.

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

◆ getTrigInfo()

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

Definition at line 1206 of file TrigEgammaMonitoringConfig.py.

1206 def getTrigInfo( self, trigger ):
1207
1208 class TrigEgammaInfo(object):
1209
1210 def __init__(self, trigger):
1211 self.__chain = trigger
1212
1213 def chain(self):
1214 return self.__chain
1215
1216 def isL1Item(self):
1217 return True if self.chain().startswith('L1') else False
1218
1219 def isElectron(self):
1220 return True if (self.isL1Item() or self.chain().startswith('HLT_e')) else False
1221
1222 def isPhoton(self):
1223 return True if (self.chain().startswith('HLT_g')) else False
1224
1225 def pidname(self):
1226 return self.chain().split('_')[2]
1227
1228 def isIsolated(self):
1229 for part_name in ['iloose', 'ivarloose', 'icaloloose', 'icalovloose', 'icalotight']:
1230 if part_name in self.chain():
1231 return True
1232 return False
1233
1234
1235
1236 return TrigEgammaInfo(trigger)
isElectron
bool isElectron(const T &p)
Definition AtlasPID.h:202
isPhoton
bool isPhoton(const T &p)
Definition AtlasPID.h:376
split
std::vector< std::string > split(const std::string &s, const std::string &t=":")
Definition hcg.cxx:177
object

◆ setBinning()

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

Definition at line 1153 of file TrigEgammaMonitoringConfig.py.

1153 def setBinning(self, doJpsiee=False):
1154
1155 """ Method to define all binning required that is variable"""
1156
1157 # Binning as defined in TP framework
1158 coarse_eta_bins = [-2.47,-1.52,-1.37,-0.60,0.00,0.60,1.37,1.52,2.47] # 9 items
1159
1160 coarse_et_bins = [4.,20.,30.,40.,50.,60.,150.] # 7 items
1161
1162 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,
1163 0.10, 0.60, 0.80, 1.15, 1.37, 1.52, 1.81, 2.01, 2.37, 2.47] # 21 items
1164
1165 default_et_bins = [4.,7.,10.,15.,20.,25.,30.,35.,40.,45.,50.,60.,80.,150.] # 14 items
1166
1167 etabins = [-2.47,-2.37,-2.01,-1.81,-1.52,-1.37,-1.15,-0.8,-0.6,-0.1,
1168 0.0,0.1,0.6,0.8,1.15,1.37,1.52,1.81,2.01,2.37,2.47] # 21 items
1169
1170 # TH2 with variable bin x-Axis, but constant bin y-Axis takes only Double_t arrays
1171 etbins_Zee = [0.,2.,4.,6.,8.,10.,
1172 12.,14.,16.,18.,20.,22.,24.,26.,28.,
1173 30.,32.,34.,36.,38.,40.,42.,44.,46.,48.,50.,55.,60.,65.,80.,100.,120.,140., 170., 200.,250.] # 36 items
1174
1175 etbins_Jpsiee = [ 0, 0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5,
1176 5, 5.5, 6, 6.5, 7, 7.5, 8, 8.5, 9, 9.5,
1177 10,10.5,11,11.5,12,12.5,13,13.5,14,14.5,
1178 15,15.5,16,16.5,17,17.5,18,18.5,19,19.5,
1179 20,20.5,21,21.5,22,22.5,23,23.5,24,24.5,
1180 25,25.5] # 52 items
1181
1182
1183 if doJpsiee:
1184 self._nEtbins=51
1185 self._etbins = etbins_Jpsiee[0:self._nEtbins+1]
1186 else:
1187 self._nEtbins=35
1188 self._etbins = etbins_Zee[0:self._nEtbins+1]
1189
1190 # Define the binning
1191 self._nEtabins=20
1192 self._ndefaultEtbins=13
1193 self._ndefaultEtabins=20
1194 self._ncoarseEtbins=6
1195 self._ncoarseEtabins=8
1196
1197 #Fill the arrays
1198 self._etabins = etabins[0:self._nEtabins+1]
1199 self._defaultEtbins = default_et_bins[0:self._ndefaultEtbins+1]
1200 self._defaultEtabins = default_eta_bins[0:self._ndefaultEtabins+1]
1201 self._coarseEtbins = coarse_et_bins[0:self._ncoarseEtbins+1]
1202 self._coarseEtabins = coarse_eta_bins[0:self._ncoarseEtabins+1]
1203
1204
1205

◆ setDefaultProperties()

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.setDefaultProperties ( self)

Definition at line 172 of file TrigEgammaMonitoringConfig.py.

172 def setDefaultProperties(self):
173
174 from TrigEgammaMonitoring.TrigEgammaMonitCategory import mongroupsCfg
175 mongroups = mongroupsCfg(self.moniAccess,self.data_type)
176
177 if self.pp_mode:
178 self.electronList = mongroups['monitoring_electron']
179 self.photonList = mongroups['monitoring_photon']
180 self.bootstrapMap = mongroups['monitoring_bootstrap']
181 self.tpList = mongroups['monitoringTP_electron']
182 self.tagItems = mongroups['monitoring_tags']
183 self.topoList = mongroups['monitoring_topo']
184 elif self.mc_mode:
185 self.electronList = mongroups['validation_electron']
186 self.photonList = mongroups['validation_photon']
187 self.bootstrapMap = mongroups['monitoring_bootstrap']
188 self.tpList = mongroups['monitoringTP_electron'] + mongroups['validationTP_electron_DNN']
189 self.jpsiList = mongroups['validation_jpsi']
190 self.jpsitagItems = mongroups['validationTP_jpsiee']
191 self.tagItems = mongroups['monitoring_tags']
192 self.topoList = mongroups['monitoring_topo']
193 elif self.cosmic_mode:
194 self.electronList = mongroups['monitoring_electron_cosmic']
195 self.photonList = mongroups['monitoring_photon_cosmic']
196 self.bootstrapMap = mongroups['monitoring_bootstrap_cosmic']
197 else:
198 self.electronList = mongroups['monitoring_electron']
199 self.photonList = mongroups['monitoring_photon']
200 self.bootstrapMap = mongroups['monitoring_bootstrap']
201 self.tpList = mongroups['monitoringTP_electron']
202 self.tagItems = mongroups['monitoring_tags']
203 self.topoList = mongroups['monitoring_topo']
204
205

◆ setProperties()

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.setProperties ( self)

Definition at line 148 of file TrigEgammaMonitoringConfig.py.

148 def setProperties(self):
149
150 self.__logger.info("TrigEgammaMonAlgBuilder.setProperties()")
151 self.basePath = 'HLT/EgammaMon'
152
153 if self.pp_mode:
154 self.setDefaultProperties()
155 elif self.cosmic_mode:
156 self.setDefaultProperties()
157 elif self.HI_mode or self.pPb_mode:
158 self.setDefaultProperties()
159 elif self.mc_mode:
160 self.setDefaultProperties()
161 else:
162 self.__logger.info('No monitoring mode configured, use default')
163 self.setDefaultProperties()
164
165
166 self.__logger.info('Configuring TP electron chains %s',self.tpList)
167 self.__logger.info('Configuring electron chains %s',self.electronList)
168 self.__logger.info('Configuring photon chains %s',self.photonList)
169
170
171

Member Data Documentation

◆ __chain

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.__chain = trigger
private

Definition at line 1211 of file TrigEgammaMonitoringConfig.py.

◆ __logger

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

Definition at line 65 of file TrigEgammaMonitoringConfig.py.

◆ _coarseEtabins

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

Definition at line 1202 of file TrigEgammaMonitoringConfig.py.

◆ _coarseEtbins

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

Definition at line 1201 of file TrigEgammaMonitoringConfig.py.

◆ _defaultEtabins

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

Definition at line 1200 of file TrigEgammaMonitoringConfig.py.

◆ _defaultEtbins

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

Definition at line 1199 of file TrigEgammaMonitoringConfig.py.

◆ _etabins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._etabins
protected

Definition at line 646 of file TrigEgammaMonitoringConfig.py.

◆ _etbins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._etbins
protected

Definition at line 792 of file TrigEgammaMonitoringConfig.py.

◆ _ncoarseEtabins

int python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._ncoarseEtabins = 8
protected

Definition at line 1195 of file TrigEgammaMonitoringConfig.py.

◆ _ncoarseEtbins

int python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._ncoarseEtbins = 6
protected

Definition at line 1194 of file TrigEgammaMonitoringConfig.py.

◆ _ndefaultEtabins

int python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._ndefaultEtabins = 20
protected

Definition at line 1193 of file TrigEgammaMonitoringConfig.py.

◆ _ndefaultEtbins

int python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._ndefaultEtbins = 13
protected

Definition at line 1192 of file TrigEgammaMonitoringConfig.py.

◆ _nEtabins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._nEtabins
protected

Definition at line 646 of file TrigEgammaMonitoringConfig.py.

◆ _nEtbins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._nEtbins
protected

Definition at line 792 of file TrigEgammaMonitoringConfig.py.

◆ activate_electron

bool python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.activate_electron = False
static

Definition at line 37 of file TrigEgammaMonitoringConfig.py.

◆ activate_jpsiee

bool python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.activate_jpsiee = False
static

Definition at line 40 of file TrigEgammaMonitoringConfig.py.

◆ activate_onlineMonHypos

bool python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.activate_onlineMonHypos = False
static

Definition at line 42 of file TrigEgammaMonitoringConfig.py.

◆ activate_photon

bool python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.activate_photon = False
static

Definition at line 38 of file TrigEgammaMonitoringConfig.py.

◆ activate_topo

bool python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.activate_topo = False
static

Definition at line 41 of file TrigEgammaMonitoringConfig.py.

◆ activate_zee

bool python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.activate_zee = False
static

Definition at line 39 of file TrigEgammaMonitoringConfig.py.

◆ basePath

str python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.basePath = basePath

Definition at line 70 of file TrigEgammaMonitoringConfig.py.

◆ bootstrapMap

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

Definition at line 180 of file TrigEgammaMonitoringConfig.py.

◆ computeEffDNN

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.computeEffDNN = ComputeEffDNN

Definition at line 75 of file TrigEgammaMonitoringConfig.py.

◆ computeEffLH

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.computeEffLH = ComputeEffLH

Definition at line 74 of file TrigEgammaMonitoringConfig.py.

◆ cosmic_mode

bool python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.cosmic_mode = False
static

Definition at line 35 of file TrigEgammaMonitoringConfig.py.

◆ data_type

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.data_type = ''
static

Definition at line 31 of file TrigEgammaMonitoringConfig.py.

◆ derivation

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.derivation = derivation

Definition at line 68 of file TrigEgammaMonitoringConfig.py.

◆ detailedHistograms

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.detailedHistograms = detailedHistograms

Definition at line 71 of file TrigEgammaMonitoringConfig.py.

◆ dnnnames

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

Definition at line 53 of file TrigEgammaMonitoringConfig.py.

◆ electronList

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.electronList = []
static

Definition at line 45 of file TrigEgammaMonitoringConfig.py.

◆ elMonAlg

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

Definition at line 402 of file TrigEgammaMonitoringConfig.py.

◆ emulator

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

Definition at line 69 of file TrigEgammaMonitoringConfig.py.

◆ helper

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.helper = helper

Definition at line 67 of file TrigEgammaMonitoringConfig.py.

◆ HI_mode

bool python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.HI_mode = False
static

Definition at line 34 of file TrigEgammaMonitoringConfig.py.

◆ isemnames

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

Definition at line 51 of file TrigEgammaMonitoringConfig.py.

◆ jpsieeMonAlg

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

Definition at line 374 of file TrigEgammaMonitoringConfig.py.

◆ jpsiList

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

Definition at line 48 of file TrigEgammaMonitoringConfig.py.

◆ jpsitagItems

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

Definition at line 44 of file TrigEgammaMonitoringConfig.py.

◆ lhnames

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

Definition at line 52 of file TrigEgammaMonitoringConfig.py.

◆ mc_mode

bool python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.mc_mode = False
static

Definition at line 36 of file TrigEgammaMonitoringConfig.py.

◆ moniAccess

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.moniAccess = moniAccess

Definition at line 72 of file TrigEgammaMonitoringConfig.py.

◆ onlyHLT

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.onlyHLT = onlyHLT

Definition at line 73 of file TrigEgammaMonitoringConfig.py.

◆ phMonAlg

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

Definition at line 429 of file TrigEgammaMonitoringConfig.py.

◆ photonList

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.photonList = []
static

Definition at line 46 of file TrigEgammaMonitoringConfig.py.

◆ pp_mode

bool python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.pp_mode = False
static

Definition at line 32 of file TrigEgammaMonitoringConfig.py.

◆ pPb_mode

bool python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.pPb_mode = False
static

Definition at line 33 of file TrigEgammaMonitoringConfig.py.

◆ runFlag

str python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.runFlag = runflag

Definition at line 66 of file TrigEgammaMonitoringConfig.py.

◆ tagItems

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

Definition at line 43 of file TrigEgammaMonitoringConfig.py.

◆ topoList

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

Definition at line 183 of file TrigEgammaMonitoringConfig.py.

◆ topoMonAlg

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

Definition at line 455 of file TrigEgammaMonitoringConfig.py.

◆ tpList

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.tpList = []
static

Definition at line 47 of file TrigEgammaMonitoringConfig.py.

◆ zeeMonAlg

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

Definition at line 308 of file TrigEgammaMonitoringConfig.py.

◆ zeeMonAlg_dnn

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

Definition at line 337 of file TrigEgammaMonitoringConfig.py.

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