Mufi_monitoring.Veto_Efficiency Class Reference

Inheritance diagram for Mufi_monitoring.Veto_Efficiency:

Collaboration diagram for Mufi_monitoring.Veto_Efficiency:

Public Member Functions
	Init (self, options, monitor)
	ExecuteEvent (self, event)
	checkOtherTriggers (self, event, debug=False)
	Plot (self, beamOnly=False)

Public Attributes
	debug
	deadTime
	M
	eventBefore
	trackTask
	OT
	noiseCuts
	zEx

Detailed Description

Definition at line 922 of file Mufi_monitoring.py.

Member Function Documentation

checkOtherTriggers()

Mufi_monitoring.Veto_Efficiency.checkOtherTriggers	(		self,
			event,
			debug = False
	)

Definition at line 1182 of file Mufi_monitoring.py.

   def checkOtherTriggers(self,event,debug=False):
      T0 = event.EventHeader.GetEventTime()
      N = event.EventHeader.GetEventNumber()
      otherFastTrigger = False
      otherAdvTrigger = False
      tightNoiseFilter = False
      Nprev = 1
      if N<Nprev: return otherFastTrigger, otherAdvTrigger, tightNoiseFilter, -1, 0
      rc = event.GetEvent(N-Nprev)
      dt = T0 - event.EventHeader.GetEventTime()
      while dt < self.deadTime and N>Nprev:
         otherFastTrigger = False
         for x in event.EventHeader.GetFastNoiseFilters():
             if debug: print('fast:', x.first, x.second )
             if x.second and not x.first == 'Veto_Total': otherFastTrigger = True
         otherAdvTrigger = False
         for x in event.EventHeader.GetAdvNoiseFilters():
             if debug: print('adv:', x.first, x.second )
             if x.second and not x.first == 'VETO_Planes': otherAdvTrigger = True
         if debug: print('pre event ',Nprev,dt,otherFastTrigger,otherAdvTrigger)
         if otherFastTrigger and otherAdvTrigger:
             rc = event.GetEvent(N)
             return otherFastTrigger, otherAdvTrigger, tightNoiseFilter, Nprev, dt
         Nprev+=1
         rc = event.GetEvent(N-Nprev)
         dt = T0 - event.EventHeader.GetEventTime()
      Nprev = 1
      rc = event.GetEvent(N-Nprev)
      dt = T0 - event.EventHeader.GetEventTime()
      while dt < self.deadTime and Nprev>N:
         hits = {2:0,1:0,0:0}
         for aHit in event.Digi_MuFilterHits:
            Minfo = self.M.MuFilter_PlaneBars(aHit.GetDetectorID())
            s,l,bar = Minfo['station'],Minfo['plane'],Minfo['bar']
            if s>1: continue
            allChannels = aHit.GetAllSignals(False,False)
            hits[l]+=len(allChannels)
         noiseFilter0 = sum(hits)>4.5
         noiseFilter1 = all(p > 0 for p in hits)
         if debug: print('veto hits:',hits)
         if noiseFilter0 and noiseFilter1: 
            tightNoiseFilter = True
            rc = event.GetEvent(N)
            return otherFastTrigger, otherAdvTrigger, tightNoiseFilter, Nprev-1, dt
         Nprev+=1
         rc = event.GetEvent(N-Nprev)
         dt = T0 - event.EventHeader.GetEventTime()
      if Nprev>1: 
            rc = event.GetEvent(N-Nprev+1)
            dt = T0 - event.EventHeader.GetEventTime()
      rc = event.GetEvent(N)
      return otherFastTrigger, otherAdvTrigger, tightNoiseFilter, Nprev-1, dt
 

ExecuteEvent()

Mufi_monitoring.Veto_Efficiency.ExecuteEvent	(		self,
			event
	)

Definition at line 971 of file Mufi_monitoring.py.

   def ExecuteEvent(self,event):
       scifiCorTest = False
       systemAndPlanes = self.M.systemAndPlanes
       sdict = self.M.sdict
       s = 1
       h = self.M.h
       W = self.M.Weight
       nSiPMs = self.M.MuFilter.GetConfParI("MuFilter/VetonSiPMs")
       hits = {2:0,1:0,0:0,'0L':0,'0R':0,'1L':0,'1R':0}
       vetoHitsFromPrev = 0
       if event.EventHeader.GetRunId() < 6204 and event.EventHeader.GetRunId() > 5480: vetoHitsFromPrev = 5
       # special treatment for first 10fb-1 in 2023, wrong time alignment, again!
       N1 = event.GetReadEntry()
       Tcurrent = event.EventHeader.GetEventTime()
       dT = abs(Tcurrent-self.eventBefore['T'])
       prevAdded = False
       for j in [0,-1]:
         if j<0 and N1>0: 
              if dT > vetoHitsFromPrev: continue
              rc = event.GetEvent(N1-1)  # add veto hits from prev event
              prevAdded = True
         for aHit in event.Digi_MuFilterHits:
           if not aHit.isValid(): continue
           Minfo = self.M.MuFilter_PlaneBars(aHit.GetDetectorID())
           s,l,bar = Minfo['station'],Minfo['plane'],Minfo['bar']
           if s>1: continue
           allChannels = self.M.map2Dict(aHit,'GetAllSignals')
           hits[l]+=len(allChannels)
           if l != 2:
             for c in allChannels:
                if  nSiPMs > c:  # left side
                   hits[str(l)+'L']+=1
                else:
                      hits[str(l)+'R']+=1
           allChannels.clear()
       if prevAdded and N1>1:
         rc = event.GetEvent(N1-2)
         Tprevprev = event.EventHeader.GetEventTime()
         dT = abs(Tcurrent-Tprevprev)
       if prevAdded: event.GetEvent(N1)
       prevEvent = False
       tightNoiseFilter = None
       otherAdvTrigger  = None
       otherFastTrigger = None
       if dT < self.deadTime and dT > vetoHitsFromPrev:
           prevEvent = True
           # check type of prev event, if it would pass tight noise filter, run 6568 ++ 
           if event.EventHeader.GetRunId() > 6567 and N1>0:
              tightNoiseFilter, otherFastTrigger, otherAdvTrigger,Nprev,dt = self.checkOtherTriggers(event)
 
       tmpT = self.eventBefore['T']
       tmpN = self.eventBefore['N']
       self.eventBefore['T'] = Tcurrent
       if (self.M.EventNumber - self.eventBefore['N'] > 1) and self.M.options.postScale < 2:
          print('what is going on?', self.M.EventNumber, self.eventBefore['N'])
       self.eventBefore['N'] = self.M.EventNumber
 
       rc = h['scaler'].Fill(11)
       if self.M.Reco_MuonTracks.GetEntries()<2: return # require Scifi and DS track
# check that track has scifi cluster in station 1, afterthought: require measurements in all planes
       planes = {}
       for scifiTrack in self.M.Reco_MuonTracks:
           if not scifiTrack.GetUniqueID()==1: continue
           fitStatus = scifiTrack.getFitStatus()
           if not fitStatus.isFitConverged(): continue
           if fitStatus.getNdf() < 5 or fitStatus.getNdf()>12 : continue
           if fitStatus.getChi2()/fitStatus.getNdf() > 80: continue
           for nM in range(scifiTrack.getNumPointsWithMeasurement()):
              M = scifiTrack.getPointWithMeasurement(nM)
              W = M.getRawMeasurement()
              detID = W.getDetId()
              planes[detID//100000] = 1
       rc = h['scaler'].Fill(10)
       scifiOneEff = 10 in planes or 11 in planes or not scifiCorTest
       if not scifiOneEff  and len(planes) < 8: return
       if scifiOneEff and len(planes) < 10: return
       rc = h['scaler'].Fill(0)
       if not prevEvent: rc = h['scaler'].Fill(1)
 
       for l in range(systemAndPlanes[1]-1):
          rc = h['hitVeto_'+str(l)].Fill(hits[str(l)+'L'],hits[str(l)+'R'])
       rc = h['hitVeto_01'].Fill(hits[0],hits[1])
       if systemAndPlanes[1] > 2 :
         rc = h['hitVeto_02'].Fill(hits[0],hits[2])
         rc = h['hitVeto_12'].Fill(hits[1],hits[2])
 
       for muTrack in self.M.Reco_MuonTracks:
          if not muTrack.GetUniqueID()==3: continue
          fstate =  muTrack.getFittedState()
          posT,momT  = fstate.getPos(),fstate.getMom()
          lam      = (self.zEx-posT.z())/momT.z()
          yExTag      = posT.y()+lam*momT.y()
          xExTag      = posT.x()+lam*momT.x()
          sstate = scifiTrack.getFittedState()
          pos = sstate.getPos()
          delX = xExTag - pos.x()
          delY = yExTag - pos.y()
          rc = h['X/Y'].Fill(delX,delY)
          if abs(delX)>10 or abs(delY)>10: return
          
       for aTrack in self.M.Reco_MuonTracks:
           if not aTrack.GetUniqueID()==1: continue
           fitStatus = aTrack.getFitStatus()
           if not fitStatus.isFitConverged(): continue
           fstate =  aTrack.getFittedState()
           pos,mom = [fstate.getPos(),fstate.getMom()]
           beam = False
           if abs(mom.x()/mom.z())<0.1 and abs(mom.y()/mom.z())<0.1: beam = True
# extrapolate to veto
# check timing, remove backward tracks
# 1: get early DS time in horizontal plane 2:
           dsHitTimes = []
           for aHit in event.Digi_MuFilterHits:
              if not aHit.isValid(): continue
              detID = aHit.GetDetectorID()
              Minfo = self.M.MuFilter_PlaneBars(detID)
              s,l,bar = Minfo['station'],Minfo['plane'],Minfo['bar']
              if s==3 and l==2:
                   self.M.MuFilter.GetPosition(detID,A,B)
                   timeLeft = aHit.GetTime(0)
                   timeRight = aHit.GetTime(1)
                   if timeLeft>0 and timeRight>0:
                      dL = abs(A[0]-B[0])
                      avTime = self.M.MuFilter.GetCorrectedTime(detID, 0, timeLeft*self.M.TDC2ns,0) + \
                               self.M.MuFilter.GetCorrectedTime(detID, 1, timeRight*self.M.TDC2ns,0)
                      dsHitTimes.append( (avTime-abs(A[0]-B[0])/15)/2) # L/2 / 15cm/ns
           dsHitTimes.sort()
           scifiHitTimes = {1:[],2:[],3:[],4:[],5:[]}
           deltaT = -100
           if len(dsHitTimes)>0:
            for scifiHit in event.Digi_ScifiHits:
              detID = scifiHit.GetDetectorID()
              s = int(scifiHit.GetDetectorID()/1000000)
              if s>1.5: continue
              scifiHitTimes[s].append(self.M.Scifi.GetCorrectedTime(detID,scifiHit.GetTime()*self.M.TDC2ns,0))
            for s in scifiHitTimes:
                if len(scifiHitTimes[s])<1: continue
                scifiHitTimes[s].sort()
                deltaT = dsHitTimes[0] - scifiHitTimes[s][0] - (self.M.zPos['MuFilter'][34]-self.M.zPos['Scifi'][s*10])/u.speedOfLight
           rc = h['deltaT'].Fill(deltaT)
           if deltaT < -10: continue
           #look for previous event time
           T1 = event.EventHeader.GetEventTime()
           N1 = event.EventHeader.GetEventNumber()
           if prevAdded: rc = event.GetEvent(N1-2)
           else:         rc = event.GetEvent(N1-1)
           T0 = event.EventHeader.GetEventTime()
           rc = event.GetEvent(N1+1)
           T2 = event.EventHeader.GetEventTime()
           rc = event.GetEvent(N1)
           if (T1-T0) < 100 and self.M.options.postScale < 2:
               if not prevEvent: print('what is going on?',N1,T1,T0,N1-1,tmpN,tmpT)
               prevEvent = True
           s = 1
           xEx = {}
           yEx = {}
           for l in range(systemAndPlanes[1]):
              zEx = self.M.zPos['MuFilter'][s*10+l]
              lam = (zEx-pos.z())/mom.z()
              xEx[l] = pos.x()+lam*mom.x()
              yEx[l] = pos.y()+lam*mom.y()
           for l in range(systemAndPlanes[1]):
              for noiseCut in self.noiseCuts:
                 c=''
                 if not prevEvent: c='NoPrev'
                 nc = 'T'+c+str(noiseCut)
                 ncL = 'T'+'TiNoFi'+str(noiseCut)
                 if hits[l] > noiseCut or (l==2 and hits[l] > int(noiseCut/2+0.5)):
                      rc = h[nc+'PosVeto_'+str(l)].Fill(xEx[l],yEx[l])
                      if tightNoiseFilter: rc = h[ncL+'PosVeto_'+str(l)].Fill(xEx[l],yEx[l])
                      if beam: rc = h[nc+'beamPosVeto_'+str(l)].Fill(xEx[l],yEx[l])
                 else:                        
                      rc = h[nc+'XPosVeto_'+str(l)].Fill(xEx[l],yEx[l])
                      rc = h[nc+'XPosVetoXL_'+str(l)].Fill(xEx[l],yEx[l])
                      if tightNoiseFilter: h[ncL+'XPosVeto_'+str(l)].Fill(xEx[l],yEx[l])
                      if beam: rc = h[nc+'beamXPosVeto_'+str(l)].Fill(xEx[l],yEx[l])
                 if l==0:
                    if -45<xEx[l] and xEx[l]<-10 and 27<yEx[l] and yEx[l]<54:
                          rc = h['timeDiffPrev_'+str(noiseCut)].Fill(T1-T0)
                          rc = h['timeDiffNext_'+str(noiseCut)].Fill(T2-T1)
                    if ( systemAndPlanes[1]==2 and hits[0] > noiseCut and hits[1] > noiseCut) or \
                       ( systemAndPlanes[1]==3 and hits[0] > noiseCut and hits[1] > noiseCut \
                                               and hits[2] > int(noiseCut/2+0.5) ):
                      for l1 in range(systemAndPlanes[1]):
                        rc = h[nc+'PosVeto_111'+str(l1)].Fill(xEx[l1],yEx[l1])
                        if tightNoiseFilter: 
                          rc = h[ncL+'PosVeto_111'+str(l1)].Fill(xEx[l1],yEx[l1])
                      if beam: rc = h[nc+'beamPosVeto_1110'].Fill(xEx[l],yEx[l])
                    if ( systemAndPlanes[1]==2 and (hits[0] > noiseCut or hits[1] > noiseCut)) or \
                       ( systemAndPlanes[1]==3 and (hits[0] > noiseCut or hits[1] > noiseCut \
                                               or hits[2] > int(noiseCut/2+0.5)) ):
                      rc = h[nc+'PosVeto_000'].Fill(xEx[l],yEx[l])
                      if tightNoiseFilter: h[ncL+'PosVeto_000'].Fill(xEx[l],yEx[l])
                      if beam: rc = h[nc+'beamPosVeto_000'].Fill(xEx[l],yEx[l])
                    else:
                        if -45<xEx[l] and xEx[l]<-10 and 27<yEx[l] and yEx[l]<54:
                          rc = h['XtimeDiffPrev_'+str(noiseCut)].Fill(T1-T0)
                          rc = h['XtimeDiffNext_'+str(noiseCut)].Fill(T2-T1)
                          if not prevEvent or (prevEvent and not tightNoiseFilter):
                            if self.debug: print('no hits',noiseCut,prevEvent,beam,N1,tightNoiseFilter,otherFastTrigger,otherAdvTrigger)
                        for l1 in range(systemAndPlanes[1]):
                          rc = h[nc+'XPosVeto_111'+str(l1)].Fill(xEx[l1],yEx[l1])
                          if tightNoiseFilter: 
                           rc = h[ncL+'XPosVeto_111'+str(l1)].Fill(xEx[l1],yEx[l1])
                        if beam: rc = h[nc+'beamXPosVeto_1110'].Fill(xEx[l],yEx[l])
                    # also for the 2 planea
                    if hits[0] > noiseCut and hits[1] > noiseCut:
                      rc = h[nc+'PosVeto_11'].Fill(xEx[l],yEx[l])
                    if not (hits[0] > noiseCut or hits[1] > noiseCut):
                      rc = h[nc+'XPosVeto_11'].Fill(xEx[l],yEx[l])
 

Init()

Mufi_monitoring.Veto_Efficiency.Init	(		self,
			options,
			monitor
	)

Definition at line 924 of file Mufi_monitoring.py.

   def Init(self,options,monitor):
       self.debug = True
       self.deadTime = 100
       self.M = monitor
       sdict = self.M.sdict
       self.eventBefore={'T':-1,'N':-1,'hits':{2:0,1:0,0:0,'0L':0,'0R':0,'1L':0,'1R':0}}
       h = self.M.h
       run = ROOT.FairRunAna.Instance()
       self.trackTask = run.GetTask('simpleTracking')
       if not self.trackTask: self.trackTask = run.GetTask('houghTransform')
       ioman = ROOT.FairRootManager.Instance()
       self.OT = ioman.GetSink().GetOutTree()
       s = 1
       self.noiseCuts = [1,5,10,12]
       self.zEx = self.M.zPos['Scifi'][10]
       for noiseCut in self.noiseCuts:
        ut.bookHist(h,'timeDiffPrev_'+str(noiseCut),'time diff; [clock cycles] ',100,-0.5,999.5)
        ut.bookHist(h,'XtimeDiffPrev_'+str(noiseCut),'time diff no hits; [clock cycles] ',100,-0.5,999.5)
        ut.bookHist(h,'timeDiffNext_'+str(noiseCut),'time diff next; [clock cycles] ',100,-0.5,999.5)
        ut.bookHist(h,'XtimeDiffNext_'+str(noiseCut),'time diff next no hits; [clock cycles] ',100,-0.5,999.5)
        for c in ['','NoPrev','TiNoFi']:
         for b in ['','beam']:
          nc = 'T'+c+str(noiseCut)+b
          for l in range(monitor.systemAndPlanes[s]):
            ut.bookHist(h,nc+'PosVeto_'+str(l),'track pos at veto'+str(l)+' with hit '+';X [cm]; Y [cm]',110,-55.,0.,110,10.,65.)
            ut.bookHist(h,nc+'XPosVeto_'+str(l),'track pos at veto'+str(l)+' no hit'+str(l)+';X [cm]; Y [cm]',110,-55.,0.,110,10.,65.)
            ut.bookHist(h,nc+'XPosVetoXL_'+str(l),'track pos at veto'+str(l)+' no hit'+str(l)+';X [cm]; Y [cm]',1100,-55.,0.,1100,10.,65.)
            ut.bookHist(h,nc+'PosVeto_111'+str(l),'track pos at veto AND hit'+';X [cm]; Y [cm]',110,-55.,0.,110,10.,65.)
            ut.bookHist(h,nc+'XPosVeto_111'+str(l),'track pos at veto no hit'+';X [cm]; Y [cm]',110,-55.,0.,110,10.,65.)
            if l == 0:
              ut.bookHist(h,nc+'PosVeto_11','track pos at veto AND hit'+';X [cm]; Y [cm]',110,-55.,0.,110,10.,65.)
              ut.bookHist(h,nc+'XPosVeto_11','track pos at veto no hit'+';X [cm]; Y [cm]',110,-55.,0.,110,10.,65.)
          ut.bookHist(h,nc+'PosVeto_000','track pos at veto OR hit'+';X [cm]; Y [cm]',110,-55.,0.,110,10.,65.)
          for x in h:
            if isinstance(h[x], ROOT.TH2) and x.find("PosVeto")>0:
              h[x].SetStats(0)
 
       ut.bookHist(h,'hitVeto_0','nr hits L vs R;n sipm; n sipm',25,-0.5,24.5,25,-0.5,24.5)
       ut.bookHist(h,'hitVeto_1','nr hits L vs R;n sipm; n sipm',25,-0.5,24.5,25,-0.5,24.5)
       ut.bookHist(h,'hitVeto_2','nr hits T ;n sipm', 25,-0.5,24.5)
       ut.bookHist(h,'hitVeto_01','nr hits 0 vs 1;n sipm; n sipm',25,-0.5,24.5,25,-0.5,24.5)
       ut.bookHist(h,'hitVeto_02','nr hits 0 vs 2;n sipm; n sipm',25,-0.5,24.5,25,-0.5,24.5)
       ut.bookHist(h,'hitVeto_12','nr hits 1 vs 2;n sipm; n sipm',25,-0.5,24.5,25,-0.5,24.5)
       ut.bookHist(h,'scaler','all no prevEvent',25,-0.5,24.5)
       ut.bookHist(h,'deltaT','delta T DS 2 and Scifi 1',100,-20.0,20.)
       ut.bookHist(h,'X/Y','xy matching of scifi DS',100,-20.0,20.,100,-20.0,20.)
 

Plot()

Mufi_monitoring.Veto_Efficiency.Plot	(		self,
			beamOnly = False
	)

Definition at line 1235 of file Mufi_monitoring.py.

   def Plot(self,beamOnly=False):
     h = self.M.h
     nVetoPlanes =self.M.systemAndPlanes[1]
     if nVetoPlanes > 2 : hist_idx = ['0','1','2','000','1110']
     else: hist_idx = ['0','1','000','1110']
     if beamOnly: b='beam'
     else: b=''
     for c in ['','NoPrev']:
      allTracks = h['T'+c+'1PosVeto_0'].Clone('tmp')
      allTracks.Add(h['T'+c+'1XPosVeto_0'])
      for noiseCut in self.noiseCuts:
       nc = 'T'+c+str(noiseCut)+b
       h[nc+'XPosVeto_000']=allTracks.Clone(nc+'XPosVeto_000')
       h[nc+'XPosVeto_000'].Add(h[nc+'PosVeto_000'],-1)
       for l in hist_idx:
           h[nc+'Veto_ineff'+l] = h[nc+'PosVeto_'+l].Clone(nc+'Veto_ineff'+l)
           if l != '2': h[nc+'Veto_ineff'+l].SetTitle('Veto inefficiency '+l+' noise cut='+str(noiseCut))
           else: h[nc+'Veto_ineff'+l].SetTitle('Veto inefficiency '+l+' noise cut='+str(int(noiseCut/2+0.5)))
           h[nc+'Veto_ineff'+l].SetMinimum(0)
           h[nc+'Veto_ineff'+l].SetMaximum(1)
       for ix in range(allTracks.GetNbinsX()):
          for iy in range(allTracks.GetNbinsY()):
              for l in hist_idx:
                 bc = allTracks.GetBinContent(ix,iy)
                 if bc < 100:
                    h[nc+'Veto_ineff'+l].SetBinContent(ix,iy,-1)
                    h[nc+'Veto_ineff'+l].SetBinError(ix,iy,0)
                 else:
                    h[nc+'Veto_ineff'+l].SetBinContent(ix,iy,max(h[nc+'XPosVeto_'+l].GetBinContent(ix+1,iy+1)/bc, 2.7/bc))
                    h[nc+'Veto_ineff'+l].SetBinError(ix,iy,h[nc+'XPosVeto_'+l].GetBinError(ix+1,iy+1)/bc)
       ut.bookCanvas(h,nc+'VetoEff','',1400,1800, nVetoPlanes, 2*nVetoPlanes)
       for p in range(2*nVetoPlanes**2):
         tc = h[nc+'VetoEff'].cd(p+1)
         if p < nVetoPlanes:
           h[nc+'PosVeto_'+str(p%nVetoPlanes)].Draw('colz')
         if p in range(nVetoPlanes, 2*nVetoPlanes):
           h[nc+'PosVeto_111'+str(p%nVetoPlanes)].Draw('colz')
         if p in range(2*nVetoPlanes, 3*nVetoPlanes):
           h[nc+'XPosVeto_'+str(p%nVetoPlanes)].Draw('colz')
         if p in range(3*nVetoPlanes, 4*nVetoPlanes):
           h[nc+'XPosVeto_111'+str(p%nVetoPlanes)].Draw('colz')
       tc = h[nc+'VetoEff'].cd(4*nVetoPlanes+1)
       h[nc+'PosVeto_000'].Draw('colz')
 
       ut.bookCanvas(h,nc+'VetoInEff','',1800,1400,nVetoPlanes,2)
       for p in range(nVetoPlanes): 
         tc = h[nc+'VetoInEff'].cd(p+1)
         tc.SetLogz(1)
         h[nc+'Veto_ineff'+str(p)].Draw('colz')
       tc = h[nc+'VetoInEff'].cd(nVetoPlanes+1)
       tc.SetLogz(1)
       h[nc+'Veto_ineff1110'].Draw('colz')
       tc = h[nc+'VetoInEff'].cd(nVetoPlanes+2)
       tc.SetLogz(1)
       h[nc+'Veto_ineff000'].Draw('colz')
# make some printout
       Ntot = h[nc+'PosVeto_0'].Clone('Ntot')
       Ntot.Add(h[nc+'XPosVeto_0'])
       ineff0 =  h[nc+'XPosVeto_0'].GetEntries()/(Ntot.GetEntries()+1E-20)
       ineff1 = h[nc+'XPosVeto_1'].GetEntries()/(Ntot.GetEntries()+1E-20)
       ineff2, ineffAND_old, ineffOR_old = 0, 0, 0
       if nVetoPlanes > 2:
         ineff2 = h[nc+'XPosVeto_2'].GetEntries()/(Ntot.GetEntries()+1E-20)
         ineffOR_old =  h[nc+'XPosVeto_11'].GetEntries()/(Ntot.GetEntries()+1E-20)
         ineffAND_old = 1.-h[nc+'PosVeto_11'].GetEntries()/(Ntot.GetEntries()+1E-20)
       ineffOR =  h[nc+'XPosVeto_1110'].GetEntries()/(Ntot.GetEntries()+1E-20)
       ineffAND = 1.-h[nc+'PosVeto_1110'].GetEntries()/(Ntot.GetEntries()+1E-20)
       region = [21,91,34,89]
       xax = h[nc+'PosVeto_0'].GetXaxis()
       yax = h[nc+'PosVeto_0'].GetYaxis()
       Ntot_r = Ntot.Integral(region[0],region[1],region[2],region[3])+1E-20
       ineff0_r = h[nc+'XPosVeto_0'].Integral(region[0],region[1],region[2],region[3])/Ntot_r
       ineff1_r = h[nc+'XPosVeto_1'].Integral(region[0],region[1],region[2],region[3])/Ntot_r
       ineff2_r, ineffAND_old_r, ineffOR_old_r = 0, 0, 0
       if nVetoPlanes > 2:
         ineff2_r = h[nc+'XPosVeto_2'].Integral(region[0],region[1],region[2],region[3])/Ntot_r
         ineffOR_r_old =  h[nc+'XPosVeto_11'].Integral(region[0],region[1],region[2],region[3])/Ntot_r
         ineffAND_r_old = 1.-h[nc+'PosVeto_11'].Integral(region[0],region[1],region[2],region[3])/Ntot_r
       ineffOR_r =  h[nc+'XPosVeto_1110'].Integral(region[0],region[1],region[2],region[3])/Ntot_r
       ineffAND_r = 1.-h[nc+'PosVeto_1110'].Integral(region[0],region[1],region[2],region[3])/Ntot_r
       print('noise cut = ',noiseCut, 'previous event:',c)
       print('global inefficiency veto0: %5.2F%% veto1: %5.2F%% veto2: %5.2F%%'
                                  %(ineff0*100,ineff1*100,ineff2*100),
             'vetoAND: %5.2F%% vetoOR: %5.2F%% veto0AND1: %5.2F%% veto0OR1: %5.2F%%'
                                  %(ineffAND*100,ineffOR*100,ineffAND_old*100,ineffOR_old*100))
       print('region %5.2F < X < %5.2F and %5.2F < Y < %5.2F '%(xax.GetBinCenter(region[0]),
          xax.GetBinCenter(region[1]),yax.GetBinCenter(region[0]),yax.GetBinCenter(region[1])))
       print('veto0: %5.2F%% veto1: %5.2F%% veto2: %5.2F%%'
              %(ineff0_r*100,ineff1_r*100,ineff2_r*100),
             'vetoAND: %5.2F%% vetoOR: %5.2F%% veto0AND1: %5.2F%% veto0OR1: %5.2F%%'
             %(ineffAND_r*100,ineffOR_r*100,ineffAND_old*100,ineffOR_old*100))
#
     for p in range(1,nVetoPlanes):
       if p == 1:
         h['hitVeto_X'] = h['hitVeto_0'+str(p)].ProjectionX('hitVeto_X')
         h['hitVeto_X'].SetStats(0)
         h['hitVeto_X'].SetLineColor(ROOT.kOrange)
         h['hitVeto_X'].SetLineWidth(3)
       h['hitVeto_Y'+str(p)] = h['hitVeto_0'+str(p)].ProjectionY('hitVeto_Y'+str(p))
       h['hitVeto_Y'+str(p)].SetLineColor(ROOT.kBlue-2*p)
       h['hitVeto_Y'+str(p)].SetStats(0)
     ut.bookCanvas(h,'ThitVeto','',900,600,1,1)
     tc = h['ThitVeto'].cd()
     tc.SetLogy(1)
     h['hitVeto_X'].Draw('hist')
     for p in range(1,nVetoPlanes): h['hitVeto_Y'+str(p)].Draw('histsame')
 
     #save the Veto inefficiency plots to file
     if self.M.options.postScale<2:
        self.M.presenterFile.mkdir('mufilter/VetoIneff')
     for item in h:
       if isinstance(h[item], ROOT.TCanvas) and \
          (item.find('Eff')>0 or item.find('ThitVeto')>0):
              self.M.myPrint(h[item],item,subdir='mufilter/expert/VetoIneff')

Member Data Documentation

deadTime

Mufi_monitoring.Veto_Efficiency.deadTime

Definition at line 926 of file Mufi_monitoring.py.

debug

Mufi_monitoring.Veto_Efficiency.debug

Definition at line 925 of file Mufi_monitoring.py.

eventBefore

Mufi_monitoring.Veto_Efficiency.eventBefore

Definition at line 929 of file Mufi_monitoring.py.

M

Mufi_monitoring.Veto_Efficiency.M

Definition at line 927 of file Mufi_monitoring.py.

noiseCuts

Mufi_monitoring.Veto_Efficiency.noiseCuts

Definition at line 937 of file Mufi_monitoring.py.

OT

Mufi_monitoring.Veto_Efficiency.OT

Definition at line 935 of file Mufi_monitoring.py.

trackTask

Mufi_monitoring.Veto_Efficiency.trackTask

Definition at line 932 of file Mufi_monitoring.py.

zEx

Mufi_monitoring.Veto_Efficiency.zEx

Definition at line 938 of file Mufi_monitoring.py.

---

The documentation for this class was generated from the following file:

• shipLHC/scripts/Mufi_monitoring.py