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

Public Member Functions

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

Public Attributes

 runFlag
 
 helper
 
 derivation
 
 emulator
 
 basePath
 
 detailedHistograms
 
 moniAccess
 
 bootstrapMap
 
 topoList
 
 zeeMonAlg
 
 zeeMonAlg_dnn
 
 jpsieeMonAlg
 
 elMonAlg
 
 phMonAlg
 
 topoMonAlg
 

Static Public Attributes

 data_type
 
 pp_mode
 
 pPb_mode
 
 HI_mode
 
 cosmic_mode
 
 mc_mode
 
 activate_electron
 
 activate_photon
 
 activate_zee
 
 activate_jpsiee
 
 activate_topo
 
 activate_onlineMonHypos
 
 tagItems
 
 jpsitagItems
 
 electronList
 
 photonList
 
 tpList
 
 jpsiList
 
 isemnames
 
 lhnames
 
 dnnnames
 

Private Attributes

 __logger
 
 _nEtbins
 
 _etbins
 
 _nEtabins
 
 _ndefaultEtbins
 
 _ndefaultEtabins
 
 _ncoarseEtbins
 
 _ncoarseEtabins
 
 _etabins
 
 _defaultEtbins
 
 _defaultEtabins
 
 _coarseEtbins
 
 _coarseEtabins
 
 __chain
 

Detailed Description

Definition at line 29 of file TrigEgammaMonitoringConfig.py.

Constructor & Destructor Documentation

◆ __init__()

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

Definition at line 58 of file TrigEgammaMonitoringConfig.py.

58  def __init__(self, helper, runflag, moniAccess, emulator=None,
59  derivation=False,
60  detailedHistograms = False,
61  basePath = 'HLT/EgammaMon'):
62 
63  from AthenaCommon.Logging import logging
64  self.__logger = logging.getLogger( 'TrigEgammaMonAlgBuilder' )
65  self.runFlag = runflag
66  self.helper = helper
67  self.derivation = derivation
68  self.emulator = emulator
69  self.basePath = basePath
70  self.detailedHistograms = detailedHistograms
71  self.moniAccess = moniAccess
72  self.configureMode()
73 
74 
75 

Member Function Documentation

◆ addGroup()

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

Definition at line 501 of file TrigEgammaMonitoringConfig.py.

501  def addGroup( self, monAlg, name, path ):
502  return self.helper.addGroup( monAlg, name, path )
503 

◆ addHistogram()

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

Definition at line 504 of file TrigEgammaMonitoringConfig.py.

504  def addHistogram(self, monGroup, hist):
505  monGroup.defineHistogram(hist.name, **hist.kwargs)
506 
507 

◆ bookEFCaloDistributions()

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

Definition at line 675 of file TrigEgammaMonitoringConfig.py.

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

◆ bookEfficiencies()

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

Definition at line 775 of file TrigEgammaMonitoringConfig.py.

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

◆ bookEvent()

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

Definition at line 585 of file TrigEgammaMonitoringConfig.py.

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

◆ bookExpertHistograms()

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

Definition at line 511 of file TrigEgammaMonitoringConfig.py.

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

◆ bookHLTElectronResolutions()

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

Definition at line 994 of file TrigEgammaMonitoringConfig.py.

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

◆ bookHLTPhotonResolutions()

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

Definition at line 1047 of file TrigEgammaMonitoringConfig.py.

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

◆ bookHLTResolutions()

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

Definition at line 958 of file TrigEgammaMonitoringConfig.py.

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

◆ bookInefficiencies()

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

Definition at line 843 of file TrigEgammaMonitoringConfig.py.

843  def bookInefficiencies(self, monAlg, trigger):
844 
845  monGroup = self.addGroup( monAlg, trigger+'_Inefficiency', self.basePath+'/Expert/Inefficiency/'+trigger)
846  levelLabels = ["L1Calo","L2Calo","L2","EFCalo","HLT"]
847  monGroup.defineHistogram("InefficiencyCounts", type='TH1F', path='', title="Inefficiency; Steps ; Count",xbins=len(levelLabels), xmin=0, xmax=len(levelLabels), xlabels=levelLabels)
848 
849 

◆ bookL1CaloAbsResolutions()

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

Definition at line 861 of file TrigEgammaMonitoringConfig.py.

861  def bookL1CaloAbsResolutions(self, monAlg, trigger):
862 
863  from TrigEgammaMonitoring.TrigEgammaMonitorHelper import TH1F, TH2F
864  monGroup = self.addGroup( monAlg, trigger+'_AbsResolutions_L1Calo', self.basePath+'/Shifter/'+trigger+'/AbsResolutions/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  self.addHistogram(monGroup, TH1F("eta", "#eta; #eta ; Count", 50, -2.47, 2.47))
867 
868  if self.mc_mode:
869  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))
870 
871 

◆ bookL1CaloDistributions()

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

Definition at line 608 of file TrigEgammaMonitoringConfig.py.

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

◆ bookL1CaloResolutions()

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

Definition at line 850 of file TrigEgammaMonitoringConfig.py.

850  def bookL1CaloResolutions(self, monAlg, trigger):
851 
852  from TrigEgammaMonitoring.TrigEgammaMonitorHelper import TH1F, TH2F
853  monGroup = self.addGroup( monAlg, trigger+'_Resolutions_L1Calo', self.basePath+'/Shifter/'+trigger+'/Resolutions/L1Calo' )
854  self.addHistogram(monGroup, TH1F("res_et", "E_{T} resolution; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 100, -0.1, 0.1))
855 
856  if self.mc_mode:
857  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))
858  self.addHistogram(monGroup, TH1F("eta", "eta; eta ; Count", 50, -2.47, 2.47))
859 
860 

◆ bookL2CaloDistributions()

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

Definition at line 635 of file TrigEgammaMonitoringConfig.py.

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

◆ bookL2CaloResolutions()

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

Definition at line 872 of file TrigEgammaMonitoringConfig.py.

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

◆ bookL2ElectronDistributions()

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

Definition at line 649 of file TrigEgammaMonitoringConfig.py.

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

◆ bookL2PhotonDistributions()

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

Definition at line 663 of file TrigEgammaMonitoringConfig.py.

663  def bookL2PhotonDistributions( self, monAlg, trigger ):
664 
665  from TrigEgammaMonitoring.TrigEgammaMonitorHelper import TH1F
666  monGroup = self.addGroup( monAlg, trigger+'_Distributions_L2Photon', self.basePath+'/Shifter/'+trigger+'/Distributions/FastPhoton' )
667 
668  self.addHistogram(monGroup, TH1F("et", "ET; ET [GeV] ; Count", 100, 0., 100.))
669  self.addHistogram(monGroup, TH1F("highet", "ET; ET [GeV] ; Count", 100, 0., 800.))
670  self.addHistogram(monGroup, TH1F("eta", "eta; eta ; Count", self._nEtabins, self._etabins))
671  self.addHistogram(monGroup, TH1F("phi", "phi; phi ; Count", 20, -3.2, 3.2))

◆ bookShowerShapesDistributions()

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

Definition at line 698 of file TrigEgammaMonitoringConfig.py.

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

◆ bookTopoHistograms()

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

Definition at line 1104 of file TrigEgammaMonitoringConfig.py.

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

◆ bookTrackingDistributions()

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

Definition at line 731 of file TrigEgammaMonitoringConfig.py.

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

◆ configure()

def python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.configure (   self)

Definition at line 111 of file TrigEgammaMonitoringConfig.py.

111  def configure(self):
112  self.setProperties()
113  self.configureMonitor()
114  self.configureHistograms()
115 
116 

◆ configureHistograms()

def python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.configureHistograms (   self)

Definition at line 464 of file TrigEgammaMonitoringConfig.py.

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

◆ configureMode()

def python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.configureMode (   self)

Definition at line 76 of file TrigEgammaMonitoringConfig.py.

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

◆ configureMonitor()

def python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.configureMonitor (   self)

Definition at line 208 of file TrigEgammaMonitoringConfig.py.

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

◆ get_monitoring_mode()

def python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.get_monitoring_mode (   self)

Definition at line 117 of file TrigEgammaMonitoringConfig.py.

117  def get_monitoring_mode(self):
118 
119  self.__logger.info("TrigEgammaMonAlgBuilder.get_monitoring_mode()")
120  self.data_type = self.helper.flags.DQ.DataType
121 
122  if self.data_type is DQDataType.MC:
123  self.mc_mode = True
124  return True
125  elif self.data_type is DQDataType.Collisions:
126  self.pp_mode = True
127  return True
128  elif self.data_type is DQDataType.HeavyIon:
129  self.HI_mode = True
130  self.pPb_mode = True
131  return True
132  elif self.data_type is DQDataType.Cosmics:
133  self.cosmic_mode = True
134  return True
135  else:
136  return False
137 
138 

◆ getTrigInfo()

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

Definition at line 1195 of file TrigEgammaMonitoringConfig.py.

1195  def getTrigInfo( self, trigger ):
1196 
1197  class TrigEgammaInfo(object):
1198 
1199  def __init__(self, trigger):
1200  self.__chain = trigger
1201 
1202  def chain(self):
1203  return self.__chain
1204 
1205  def isL1Item(self):
1206  return True if self.chain().startswith('L1') else False
1207 
1208  def isElectron(self):
1209  return True if (self.isL1Item() or self.chain().startswith('HLT_e')) else False
1210 
1211  def isPhoton(self):
1212  return True if (self.chain().startswith('HLT_g')) else False
1213 
1214  def pidname(self):
1215  return self.chain().split('_')[2]
1216 
1217  def isIsolated(self):
1218  for part_name in ['iloose', 'ivarloose', 'icaloloose', 'icalovloose', 'icalotight']:
1219  if part_name in self.chain():
1220  return True
1221  return False
1222 
1223 
1224 
1225  return TrigEgammaInfo(trigger)

◆ setBinning()

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

Definition at line 1142 of file TrigEgammaMonitoringConfig.py.

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

◆ setDefaultProperties()

def python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.setDefaultProperties (   self)

Definition at line 166 of file TrigEgammaMonitoringConfig.py.

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

◆ setProperties()

def python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.setProperties (   self)

Definition at line 139 of file TrigEgammaMonitoringConfig.py.

139  def setProperties(self):
140 
141  self.__logger.info("TrigEgammaMonAlgBuilder.setProperties()")
142  self.basePath = 'HLT/EgammaMon'
143 
144  if self.pp_mode:
145  self.setDefaultProperties()
146  elif self.cosmic_mode:
147  # This should be change in future
148  self.setDefaultProperties()
149  elif self.HI_mode or self.pPb_mode:
150  # This should be change in future
151  self.setDefaultProperties()
152  elif self.mc_mode:
153  # This should be change in future
154  self.setDefaultProperties()
155  else:
156  self.__logger.info('No monitoring mode configured, use default')
157  self.setDefaultProperties()
158 
159 
160  self.__logger.info('Configuring TP electron chains %s',self.tpList)
161  self.__logger.info('Configuring electron chains %s',self.electronList)
162  self.__logger.info('Configuring photon chains %s',self.photonList)
163 
164 
165 

Member Data Documentation

◆ __chain

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.__chain
private

Definition at line 1200 of file TrigEgammaMonitoringConfig.py.

◆ __logger

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.__logger
private

Definition at line 61 of file TrigEgammaMonitoringConfig.py.

◆ _coarseEtabins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._coarseEtabins
private

Definition at line 1191 of file TrigEgammaMonitoringConfig.py.

◆ _coarseEtbins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._coarseEtbins
private

Definition at line 1190 of file TrigEgammaMonitoringConfig.py.

◆ _defaultEtabins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._defaultEtabins
private

Definition at line 1189 of file TrigEgammaMonitoringConfig.py.

◆ _defaultEtbins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._defaultEtbins
private

Definition at line 1188 of file TrigEgammaMonitoringConfig.py.

◆ _etabins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._etabins
private

Definition at line 1187 of file TrigEgammaMonitoringConfig.py.

◆ _etbins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._etbins
private

Definition at line 1174 of file TrigEgammaMonitoringConfig.py.

◆ _ncoarseEtabins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._ncoarseEtabins
private

Definition at line 1184 of file TrigEgammaMonitoringConfig.py.

◆ _ncoarseEtbins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._ncoarseEtbins
private

Definition at line 1183 of file TrigEgammaMonitoringConfig.py.

◆ _ndefaultEtabins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._ndefaultEtabins
private

Definition at line 1182 of file TrigEgammaMonitoringConfig.py.

◆ _ndefaultEtbins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._ndefaultEtbins
private

Definition at line 1181 of file TrigEgammaMonitoringConfig.py.

◆ _nEtabins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._nEtabins
private

Definition at line 1180 of file TrigEgammaMonitoringConfig.py.

◆ _nEtbins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._nEtbins
private

Definition at line 1173 of file TrigEgammaMonitoringConfig.py.

◆ activate_electron

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.activate_electron
static

Definition at line 37 of file TrigEgammaMonitoringConfig.py.

◆ activate_jpsiee

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.activate_jpsiee
static

Definition at line 40 of file TrigEgammaMonitoringConfig.py.

◆ activate_onlineMonHypos

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.activate_onlineMonHypos
static

Definition at line 42 of file TrigEgammaMonitoringConfig.py.

◆ activate_photon

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.activate_photon
static

Definition at line 38 of file TrigEgammaMonitoringConfig.py.

◆ activate_topo

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.activate_topo
static

Definition at line 41 of file TrigEgammaMonitoringConfig.py.

◆ activate_zee

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.activate_zee
static

Definition at line 39 of file TrigEgammaMonitoringConfig.py.

◆ basePath

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.basePath

Definition at line 66 of file TrigEgammaMonitoringConfig.py.

◆ bootstrapMap

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.bootstrapMap

Definition at line 174 of file TrigEgammaMonitoringConfig.py.

◆ cosmic_mode

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.cosmic_mode
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

Definition at line 64 of file TrigEgammaMonitoringConfig.py.

◆ detailedHistograms

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.detailedHistograms

Definition at line 67 of file TrigEgammaMonitoringConfig.py.

◆ dnnnames

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.dnnnames
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

Definition at line 400 of file TrigEgammaMonitoringConfig.py.

◆ emulator

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.emulator

Definition at line 65 of file TrigEgammaMonitoringConfig.py.

◆ helper

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.helper

Definition at line 63 of file TrigEgammaMonitoringConfig.py.

◆ HI_mode

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.HI_mode
static

Definition at line 34 of file TrigEgammaMonitoringConfig.py.

◆ isemnames

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.isemnames
static

Definition at line 51 of file TrigEgammaMonitoringConfig.py.

◆ jpsieeMonAlg

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.jpsieeMonAlg

Definition at line 372 of file TrigEgammaMonitoringConfig.py.

◆ jpsiList

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.jpsiList
static

Definition at line 48 of file TrigEgammaMonitoringConfig.py.

◆ jpsitagItems

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.jpsitagItems
static

Definition at line 44 of file TrigEgammaMonitoringConfig.py.

◆ lhnames

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.lhnames
static

Definition at line 52 of file TrigEgammaMonitoringConfig.py.

◆ mc_mode

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.mc_mode
static

Definition at line 36 of file TrigEgammaMonitoringConfig.py.

◆ moniAccess

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.moniAccess

Definition at line 68 of file TrigEgammaMonitoringConfig.py.

◆ phMonAlg

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.phMonAlg

Definition at line 425 of file TrigEgammaMonitoringConfig.py.

◆ photonList

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.photonList
static

Definition at line 46 of file TrigEgammaMonitoringConfig.py.

◆ pp_mode

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.pp_mode
static

Definition at line 32 of file TrigEgammaMonitoringConfig.py.

◆ pPb_mode

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.pPb_mode
static

Definition at line 33 of file TrigEgammaMonitoringConfig.py.

◆ runFlag

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.runFlag

Definition at line 62 of file TrigEgammaMonitoringConfig.py.

◆ tagItems

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.tagItems
static

Definition at line 43 of file TrigEgammaMonitoringConfig.py.

◆ topoList

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.topoList

Definition at line 177 of file TrigEgammaMonitoringConfig.py.

◆ topoMonAlg

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.topoMonAlg

Definition at line 451 of file TrigEgammaMonitoringConfig.py.

◆ tpList

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.tpList
static

Definition at line 47 of file TrigEgammaMonitoringConfig.py.

◆ zeeMonAlg

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.zeeMonAlg

Definition at line 306 of file TrigEgammaMonitoringConfig.py.

◆ zeeMonAlg_dnn

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.zeeMonAlg_dnn

Definition at line 335 of file TrigEgammaMonitoringConfig.py.

The documentation for this class was generated from the following file:
grepfile.info
info
Definition: grepfile.py:38
runLayerRecalibration.chain
chain
Definition: runLayerRecalibration.py:175
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
python.TrigEgammaMonitorHelper.TH2F
def TH2F(name, title, nxbins, bins_par2, bins_par3, bins_par4, bins_par5=None, bins_par6=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:45
python.TrigEgammaMonitCategory.mongroupsCfg
def mongroupsCfg(moniAccess, data_type)
Definition: TrigEgammaMonitCategory.py:8
python.TrigEgammaMonitorHelper.TProfile
def TProfile(*args, **kwargs)
Definition: TrigEgammaMonitorHelper.py:81
xAOD::EgammaHelpers::isElectron
bool isElectron(const xAOD::Egamma *eg)
is the object an electron (not Fwd)
Definition: EgammaxAODHelpers.cxx:12
python.processes.powheg.ZZ.ZZ.__init__
def __init__(self, base_directory, **kwargs)
Constructor: all process options are set here.
Definition: ZZ.py:18
xAOD::EgammaHelpers::isPhoton
bool isPhoton(const xAOD::Egamma *eg)
is the object a photon
Definition: EgammaxAODHelpers.cxx:21
python.TrigEgammaMonitoringConfig.treat_list_of_chains_by_name
def treat_list_of_chains_by_name(list_of_chains, part_name=None)
Definition: TrigEgammaMonitoringConfig.py:17
if
if(febId1==febId2)
Definition: LArRodBlockPhysicsV0.cxx:567
L1TopoOnlineMonitoringConfig.configureHistograms
def configureHistograms(alg, flags, doHwMonCtp, doHwMon, doComp, doMultComp)
Definition: L1TopoOnlineMonitoringConfig.py:78
pickleTool.object
object
Definition: pickleTool.py:30
python.TrigEgammaMonitorHelper.TH1F
def TH1F(name, title, nxbins, bins_par2, bins_par3=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:24
Trk::split
@ split
Definition: LayerMaterialProperties.h:38
Generated on Thu Nov 7 2024 22:24:20 for ATLAS Offline Software by   doxygen 1.8.18