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, onlyHLT=False, derivation=False, detailedHistograms=False, basePath='HLT/EgammaMon', ComputeEffLH=False, ComputeEffDNN=False)
 
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
 
 onlyHLT
 
 computeEffLH
 
 computeEffDNN
 
 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,
  onlyHLT = False,
  derivation = False,
  detailedHistograms = False,
  basePath = 'HLT/EgammaMon',
  ComputeEffLH = False,
  ComputeEffDNN = False 
)

Definition at line 58 of file TrigEgammaMonitoringConfig.py.

58  def __init__(self, helper, runflag, moniAccess, emulator=None,
59  onlyHLT = False,
60  derivation=False,
61  detailedHistograms = False,
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()

def 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()

def 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()

def 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()

def 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()

def 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()

def 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()

def 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()

def 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()

def 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()

def 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()

def 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()

def 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()

def 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()

def 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()

def 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()

def 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()

def 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()

def 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()

def 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()

def 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()

def 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 

◆ configureHistograms()

def 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()

def 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 

◆ configureMonitor()

def 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()

def 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()

def 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)

◆ setBinning()

def 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()

def 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()

def 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
private

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

◆ _coarseEtbins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._coarseEtbins
private

Definition at line 1201 of file TrigEgammaMonitoringConfig.py.

◆ _defaultEtabins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._defaultEtabins
private

Definition at line 1200 of file TrigEgammaMonitoringConfig.py.

◆ _defaultEtbins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._defaultEtbins
private

Definition at line 1199 of file TrigEgammaMonitoringConfig.py.

◆ _etabins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._etabins
private

Definition at line 1198 of file TrigEgammaMonitoringConfig.py.

◆ _etbins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._etbins
private

Definition at line 1185 of file TrigEgammaMonitoringConfig.py.

◆ _ncoarseEtabins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._ncoarseEtabins
private

Definition at line 1195 of file TrigEgammaMonitoringConfig.py.

◆ _ncoarseEtbins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._ncoarseEtbins
private

Definition at line 1194 of file TrigEgammaMonitoringConfig.py.

◆ _ndefaultEtabins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._ndefaultEtabins
private

Definition at line 1193 of file TrigEgammaMonitoringConfig.py.

◆ _ndefaultEtbins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._ndefaultEtbins
private

Definition at line 1192 of file TrigEgammaMonitoringConfig.py.

◆ _nEtabins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._nEtabins
private

Definition at line 1191 of file TrigEgammaMonitoringConfig.py.

◆ _nEtbins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._nEtbins
private

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

◆ computeEffDNN

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.computeEffDNN

Definition at line 71 of file TrigEgammaMonitoringConfig.py.

◆ computeEffLH

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.computeEffLH

Definition at line 70 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 402 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 374 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.

◆ onlyHLT

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.onlyHLT

Definition at line 69 of file TrigEgammaMonitoringConfig.py.

◆ phMonAlg

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.phMonAlg

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

◆ topoMonAlg

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.topoMonAlg

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

Definition at line 308 of file TrigEgammaMonitoringConfig.py.

◆ zeeMonAlg_dnn

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.zeeMonAlg_dnn

Definition at line 337 of file TrigEgammaMonitoringConfig.py.

The documentation for this class was generated from the following file:
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.processes.powheg.ZZj_MiNNLO.ZZj_MiNNLO.__init__
def __init__(self, base_directory, **kwargs)
Constructor: all process options are set here.
Definition: ZZj_MiNNLO.py:18
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
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:225
pickleTool.object
object
Definition: pickleTool.py:29
python.TrigEgammaMonitorHelper.TH1F
def TH1F(name, title, nxbins, bins_par2, bins_par3=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:24
python.ParticleTypeUtil.info
def info
Definition: ParticleTypeUtil.py:87
Trk::split
@ split
Definition: LayerMaterialProperties.h:38
Generated on Mon Sep 29 2025 22:12:04 for ATLAS Offline Software by   doxygen 1.8.18