Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
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')
 
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
 
 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' 
)

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'):
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.configureMode()
75 
76 
77 

Member Function Documentation

◆ addGroup()

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

Definition at line 506 of file TrigEgammaMonitoringConfig.py.

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

◆ addHistogram()

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

Definition at line 509 of file TrigEgammaMonitoringConfig.py.

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

◆ bookEFCaloDistributions()

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

Definition at line 680 of file TrigEgammaMonitoringConfig.py.

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

◆ bookEfficiencies()

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

Definition at line 782 of file TrigEgammaMonitoringConfig.py.

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

◆ bookEvent()

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

Definition at line 590 of file TrigEgammaMonitoringConfig.py.

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

◆ bookExpertHistograms()

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

Definition at line 516 of file TrigEgammaMonitoringConfig.py.

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

◆ bookHLTElectronResolutions()

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

Definition at line 1006 of file TrigEgammaMonitoringConfig.py.

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

◆ bookHLTPhotonResolutions()

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

Definition at line 1059 of file TrigEgammaMonitoringConfig.py.

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

◆ bookHLTResolutions()

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

Definition at line 970 of file TrigEgammaMonitoringConfig.py.

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

◆ bookInefficiencies()

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

Definition at line 855 of file TrigEgammaMonitoringConfig.py.

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

◆ bookL1CaloAbsResolutions()

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

Definition at line 873 of file TrigEgammaMonitoringConfig.py.

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

◆ bookL1CaloDistributions()

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

Definition at line 613 of file TrigEgammaMonitoringConfig.py.

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

◆ bookL1CaloResolutions()

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

Definition at line 862 of file TrigEgammaMonitoringConfig.py.

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

◆ bookL2CaloDistributions()

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

Definition at line 640 of file TrigEgammaMonitoringConfig.py.

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

◆ bookL2CaloResolutions()

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

Definition at line 884 of file TrigEgammaMonitoringConfig.py.

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

◆ bookL2ElectronDistributions()

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

Definition at line 654 of file TrigEgammaMonitoringConfig.py.

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

◆ bookL2PhotonDistributions()

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

Definition at line 668 of file TrigEgammaMonitoringConfig.py.

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

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

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

◆ bookTrackingDistributions()

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

Definition at line 736 of file TrigEgammaMonitoringConfig.py.

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

◆ configure()

def python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.configure (   self)

Definition at line 114 of file TrigEgammaMonitoringConfig.py.

114  def configure(self):
115  self.setProperties()
116  self.configureMonitor()
117  self.configureHistograms()
118 
119 

◆ configureHistograms()

def python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.configureHistograms (   self)

Definition at line 469 of file TrigEgammaMonitoringConfig.py.

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

◆ configureMode()

def python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.configureMode (   self)

Definition at line 78 of file TrigEgammaMonitoringConfig.py.

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

◆ configureMonitor()

def python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.configureMonitor (   self)

Definition at line 213 of file TrigEgammaMonitoringConfig.py.

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

◆ get_monitoring_mode()

def python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.get_monitoring_mode (   self)

Definition at line 120 of file TrigEgammaMonitoringConfig.py.

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

◆ getTrigInfo()

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

Definition at line 1207 of file TrigEgammaMonitoringConfig.py.

1207  def getTrigInfo( self, trigger ):
1208 
1209  class TrigEgammaInfo(object):
1210 
1211  def __init__(self, trigger):
1212  self.__chain = trigger
1213 
1214  def chain(self):
1215  return self.__chain
1216 
1217  def isL1Item(self):
1218  return True if self.chain().startswith('L1') else False
1219 
1220  def isElectron(self):
1221  return True if (self.isL1Item() or self.chain().startswith('HLT_e')) else False
1222 
1223  def isPhoton(self):
1224  return True if (self.chain().startswith('HLT_g')) else False
1225 
1226  def pidname(self):
1227  return self.chain().split('_')[2]
1228 
1229  def isIsolated(self):
1230  for part_name in ['iloose', 'ivarloose', 'icaloloose', 'icalovloose', 'icalotight']:
1231  if part_name in self.chain():
1232  return True
1233  return False
1234 
1235 
1236 
1237  return TrigEgammaInfo(trigger)

◆ setBinning()

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

Definition at line 1154 of file TrigEgammaMonitoringConfig.py.

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

◆ setDefaultProperties()

def python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.setDefaultProperties (   self)

Definition at line 170 of file TrigEgammaMonitoringConfig.py.

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

◆ setProperties()

def python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.setProperties (   self)

Definition at line 146 of file TrigEgammaMonitoringConfig.py.

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

Member Data Documentation

◆ __chain

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.__chain
private

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

◆ _coarseEtbins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._coarseEtbins
private

Definition at line 1202 of file TrigEgammaMonitoringConfig.py.

◆ _defaultEtabins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._defaultEtabins
private

Definition at line 1201 of file TrigEgammaMonitoringConfig.py.

◆ _defaultEtbins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._defaultEtbins
private

Definition at line 1200 of file TrigEgammaMonitoringConfig.py.

◆ _etabins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._etabins
private

Definition at line 1199 of file TrigEgammaMonitoringConfig.py.

◆ _etbins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._etbins
private

Definition at line 1186 of file TrigEgammaMonitoringConfig.py.

◆ _ncoarseEtabins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._ncoarseEtabins
private

Definition at line 1196 of file TrigEgammaMonitoringConfig.py.

◆ _ncoarseEtbins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._ncoarseEtbins
private

Definition at line 1195 of file TrigEgammaMonitoringConfig.py.

◆ _ndefaultEtabins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._ndefaultEtabins
private

Definition at line 1194 of file TrigEgammaMonitoringConfig.py.

◆ _ndefaultEtbins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._ndefaultEtbins
private

Definition at line 1193 of file TrigEgammaMonitoringConfig.py.

◆ _nEtabins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._nEtabins
private

Definition at line 1192 of file TrigEgammaMonitoringConfig.py.

◆ _nEtbins

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder._nEtbins
private

Definition at line 1185 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 178 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 405 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 377 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 430 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 181 of file TrigEgammaMonitoringConfig.py.

◆ topoMonAlg

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.topoMonAlg

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

◆ zeeMonAlg_dnn

python.TrigEgammaMonitoringConfig.TrigEgammaMonAlgBuilder.zeeMonAlg_dnn

Definition at line 340 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:220
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 Sun Apr 27 2025 22:03:22 for ATLAS Offline Software by   doxygen 1.8.18