Scifi_monitoring.Scifi_trackEfficiency Class Reference

Inheritance diagram for Scifi_monitoring.Scifi_trackEfficiency:

Collaboration diagram for Scifi_monitoring.Scifi_trackEfficiency:

Public Member Functions
	Init (self, options, monitor)
	ExecuteEvent (self, event)
	Plot (self)

Public Attributes
	M
	debug
	zEx
	zExVeto
	res
	unbiased
	masked
	deadTime
	eventBefore

Detailed Description

Definition at line 506 of file Scifi_monitoring.py.

Member Function Documentation

ExecuteEvent()

Scifi_monitoring.Scifi_trackEfficiency.ExecuteEvent	(		self,
			event
	)

Definition at line 537 of file Scifi_monitoring.py.

   def ExecuteEvent(self,event):
       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
       vetoHits = []
       USQDC = 0
       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:
           Minfo = self.M.MuFilter_PlaneBars(aHit.GetDetectorID())
           s,l,bar = Minfo['station'],Minfo['plane'],Minfo['bar']
           if s==2 and j==0:  USQDC += aHit.SumOfSignals()['Sum']
           if s>1: continue
           X = aHit.GetAllSignals()
           if len(X)<5: continue   # number of fired SiPMs
           vetoHits.append(aHit.GetDetectorID())
       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
       if dT < self.deadTime and dT > vetoHitsFromPrev:
           return
       self.eventBefore['T'] = Tcurrent
 
       h = self.M.h
       W = self.M.Weight
       MufiTracks    = []
       ScifiTracks = []
       k = -1
       for theTrack in self.M.Reco_MuonTracks:
          k+=1
          fitStatus = theTrack.getFitStatus()
          if not fitStatus.isFitConverged(): continue
          if theTrack.GetUniqueID()==1:   ScifiTracks.append(k)
          if theTrack.GetUniqueID()==3:   MufiTracks.append(k)
       if len(MufiTracks)==0: return
          
       xExTag, yExTag = -10000,-10000
       for kMu in MufiTracks:
          theTrack = self.M.Reco_MuonTracks[kMu]
          fstate =  theTrack.getFittedState()
          posT,momT  = fstate.getPos(),fstate.getMom()
          slopeXT = momT.X()/momT.Z()
          slopeYT = momT.Y()/momT.Z()
          if not abs(slopeXT)<0.1 or not abs(slopeYT)<0.1: continue
          lam      = (self.zEx-posT.z())/momT.z()
          yExTag      = posT.y()+lam*momT.y()
          xExTag      = posT.x()+lam*momT.x()
          # eventually require hit in veto to remove ghost tracks
          ok = False
          for detID in vetoHits:
              self.M.MuFilter.GetPosition(detID,A,B)
# calculate DOCA
              lam = (self.zExVeto-posT.z())/momT.z()
              xExV,yExV = posT.x()+lam*momT.x(),posT.y()+lam*momT.y()
              pq = A-posT
              uCrossv= (B-A).Cross(momT)
              doca = pq.Dot(uCrossv)/uCrossv.Mag()
              if abs(doca)<self.res: 
                ok=True
                break
          if not ok: continue
          rc = h['DStag'].Fill(xExTag,yExTag)
          for kSc in ScifiTracks:
             scifiTrack = self.M.Reco_MuonTracks[kSc]
             fstate =  scifiTrack.getFittedState()
             pos,mom  = fstate.getPos(),fstate.getMom()
             lam      = (self.zEx-pos.z())/mom.z()
             yEx      = pos.y()+lam*mom.y()
             xEx      = pos.x()+lam*mom.x()
             dx = xExTag-xEx
             dy = yExTag-yEx
             rc = h['Xdx'].Fill(dx)
             rc = h['Xdy'].Fill(dy)
             if abs(dy)<self.res and abs(dx)<self.res:
                  rc = h['scifiTrack'].Fill(xExTag,yExTag)
                  rc = h['USQDC'].Fill(USQDC)
             sortedClusters={}
             NscifiTot = 0
             for aCl in self.M.trackTask.clusScifi:
                s = aCl.GetFirst()//100000
                if not (s in sortedClusters): sortedClusters[s]=0
                sortedClusters[s]+=aCl.GetN()
                rc = h['clSize'].Fill(aCl.GetN())
             for s in sortedClusters:
                 rc = h['hitPerPlane'].Fill(sortedClusters[s])
# finished for Scifi track efficiency
# start of Scifi plane inefficiency
       if len(ScifiTracks) < 1: return
       if xExTag< -9000 or not ok: return
       sortedClusters={}
       for aCl in self.M.trackTask.clusScifi:
          so = aCl.GetFirst()//100000
          if not so in sortedClusters: sortedClusters[so]=0
          sortedClusters[so]+=1
       trackClusters = {}
       for x in self.M.trackTask.trackCandidates['Scifi'][0]:
          aCl = self.M.trackTask.trackCandidates['Scifi'][0][x]
          so = aCl.GetFirst()//100000
          if not so in trackClusters: trackClusters[so]=0
          trackClusters[so]+=1
 
       for s in range(1,6):
       # s is test station
          if self.unbiased:
             # build trackCandidate without s
             self.M.trackTask.maskPlane = s
             self.M.trackTask.fittedTracks.Delete()
             self.M.trackTask.ExecuteTask(option='Scifi')
             if self.M.trackTask.fittedTracks.GetEntries()==0: continue
             theTrack = self.M.trackTask.fittedTracks[0]
             if not hasattr(theTrack,"getFittedState"): continue
             if not theTrack.getFitStatus().isFitConverged():
                self.M.trackTask.fittedTracks.Delete()
                continue
          else:
         # check that test station not required for making track
             nproj = {0:0,1:0}
             for aCl in trackClusters:
                sq = aCl//10
                if sq==s or self.masked.find(str(sq))>-0.5: continue
                nproj[aCl%10]+=1
             if nproj[0]<3 or nproj[1]<3: continue
             theTrack = self.M.Reco_MuonTracks[ScifiTracks[0]]
             
          flightDir = self.M.trackTask.trackDir(theTrack)
          rc = h['flightDir'].Fill(flightDir[0])
          if flightDir[0] < -100:
              if self.unbiased: self.M.trackTask.fittedTracks.Delete()
              continue
          fstate   = theTrack.getFittedState()
          pos,mom  = fstate.getPos(),fstate.getMom()
          lam      = (self.zEx-pos.z())/mom.z()
          yEx      = pos.y()+lam*mom.y()
          xEx      = pos.x()+lam*mom.x()
          dx = xExTag-xEx
          dy = yExTag-yEx
          slopeX = mom.X()/mom.Z()
          slopeY = mom.Y()/mom.Z()
          if not abs(slopeX)<0.1 or not abs(slopeY)<0.1: 
              if self.unbiased: self.M.trackTask.fittedTracks.Delete()
              continue
          if abs(dy)>self.res or abs(dx)>self.res:
              if self.unbiased: self.M.trackTask.fittedTracks.Delete()
              continue
          testPlane = 10*s
          z = self.M.zPos['Scifi'][testPlane]
          lam      = (z-pos.z())/mom.z()
          yEx      = pos.y()+lam*mom.y()
          xEx      = pos.x()+lam*mom.x()
          rc = h['XscifiTrack_0'+str(s)].Fill(xEx,yEx)
          if not ( (s*10 in sortedClusters) or ( (s*10+1)  in sortedClusters) ):
              rc = h['XscifiTrack_'+str(s)].Fill(xEx,yEx)
              if -39<xEx and xEx<-16 and 22<yEx and yEx<47 and self.debug:
                        print('inefficient scifi detector ',s,self.M.EventNumber,xEx,yEx,len(vetoHits))
          if not (s*10 in sortedClusters):
              rc = h['XscifiTrack_'+str(s*10)].Fill(xEx,yEx)
          if not ((s*10+1) in sortedClusters):
              rc = h['XscifiTrack_'+str(s*10+1)].Fill(xEx,yEx)
          if s==1:
             nproj = {0:0,1:0}
             for aCl in trackClusters:
                sq = aCl//10
                if sq==2 or sq==1: continue
                nproj[aCl%10]+=1
             if nproj[0]<3 or nproj[1]<3: continue
             rc = h['2scifiTrack_0'+str(s)].Fill(xEx,yEx)
             if not ( (s*10 in sortedClusters) or ( (s*10+1)  in sortedClusters) or ( (2*10)  in sortedClusters) or ( (2*10+1)  in sortedClusters) ):
                 rc = h['2scifiTrack_'+str(s)].Fill(xEx,yEx)
             if not (s*10 in sortedClusters or 2*10 in sortedClusters ):
               rc = h['2scifiTrack_'+str(s*10)].Fill(xEx,yEx)
             if not ((s*10+1) in sortedClusters or (2*10+1) in sortedClusters):
               rc = h['2scifiTrack_'+str(s*10+1)].Fill(xEx,yEx)
       if self.unbiased:
# restore original track
           self.M.trackTask.maskPlane = -1
           self.M.trackTask.fittedTracks.Delete()
# analysis and plots 

Init()

Scifi_monitoring.Scifi_trackEfficiency.Init	(		self,
			options,
			monitor
	)

Definition at line 508 of file Scifi_monitoring.py.

   def Init(self,options,monitor):
       self.M = monitor
       self.debug = False
       h = self.M.h
       ut.bookHist(h,'DStag','DS track X/Y at scifi 1; X[cm]; Y[cm]',100,-50,0.,100,10,60)
       ut.bookHist(h,'Xdx','DS track X - scifi X; X[cm]',100,-20.,20.)
       ut.bookHist(h,'Xdy','DS track Y - scifi Y; Y[cm]',100,-20.,20.)
       ut.bookHist(h,'scifiTrack','scifi track X/Y at scifi 1; X[cm]; Y[cm]',100,-50,0.,100,10,60)
       ut.bookHist(h,'USQDC','US QDC for matched tracks; qdc',220,-10,2190.)
       ut.bookHist(h,'clSize','Scifi cluster size for matched tracks; n hits',10,-0.5,9.5)
       ut.bookHist(h,'hitPerPlane','Scifi hits per detector ; n hits',50,-0.5,49.5)
       ut.bookHist(h,'flightDir','flight direction',100,-20.,20.)
       for s in range(6):
           ut.bookHist(h,'XscifiTrack_'+str(s),'scifi track X/Y at scifi 1 missing station '+str(s)+'; X[cm]; Y[cm]',100,-50,0.,100,10,60)
           if s==0: continue
           ut.bookHist(h,'XscifiTrack_0'+str(s),'scifi track X/Y at scifi 1 missing station '+str(s)+'; X[cm]; Y[cm]',100,-50,0.,100,10,60)
           for proj in range(2):
               ut.bookHist(h,'XscifiTrack_'+str(10*s+proj),'scifi track X/Y at scifi 1 missing plane '+str(s*10+proj)+'; X[cm]; Y[cm]',100,-50,0.,100,10,60)
       ut.bookHist(h,'2scifiTrack_1','scifi track X/Y at scifi 1 missing station 1 and 2; X[cm]; Y[cm]',100,-50,0.,100,10,60)
       ut.bookHist(h,'2scifiTrack_01','scifi track X/Y at scifi 1 missing station 1 and 2; X[cm]; Y[cm]',100,-50,0.,100,10,60)
       for proj in range(2):
               ut.bookHist(h,'2scifiTrack_'+str(10*1+proj),'scifi track X/Y at scifi 1 missing plane '+str(proj)+' in 1 and 2; X[cm]; Y[cm]',100,-50,0.,100,10,60)
       self.zEx = self.M.zPos['Scifi'][10]
       self.zExVeto = self.M.zPos['MuFilter'][10]
       self.res = 10.
       self.unbiased = options.ScifiResUnbiased
       self.masked = options.ScifiStationMasked
       self.deadTime = 100
       self.eventBefore={'T':-1,'N':-1,'hits':{1:0,0:0,'0L':0,'0R':0,'1L':0,'1R':0}}

Plot()

Scifi_monitoring.Scifi_trackEfficiency.Plot

(

self

)

Definition at line 724 of file Scifi_monitoring.py.

   def Plot(self):
       h = self.M.h
       ut.bookCanvas(h,'dxdy','',1200,1200,2,1)
       tc = h['dxdy'].cd(1)
       h['Xdx'].Draw()
       tc = h['dxdy'].cd(2)
       h['Xdy'].Draw()
       self.M.myPrint(h['dxdy'],'ScifiMufiPulls',subdir='scifi/expert')
       ut.bookCanvas(h,'scifiEff','',1600,800,3,1)
       tc = h['scifiEff'].cd(1)
       h['DStag'].Draw('colz')
       tc = h['scifiEff'].cd(2)
       h['scifiTrack'].Draw('colz')
       h['eff']=h['scifiTrack'].Clone('eff')
       h['eff'].Divide(h['DStag'])
       tc = h['scifiEff'].cd(3)
       h['eff'].DrawCopy('colz')
       self.M.myPrint(h['scifiEff'],'ScifiTrackEfficiency',subdir='scifi/expert')
       limits = {1:{'X':[-44,-8],'Y':[16,50]},2:{'X':[-40,-12],'Y':[18,47]}}
       bins = {}
       for l in limits :
         bins[l] = []
         for p in limits[l]:
           for x in limits[l][p]:
             bins[l].append(eval('h["DStag"].Get'+p+'axis().FindBin(x)'))
         e = h['scifiTrack'].Integral(bins[l][0],bins[l][1],bins[l][2],bins[l][3])/h['DStag'].Integral(bins[l][0],bins[l][1],bins[l][2],bins[l][3])*100
         print('average efficiency: %5.2F<X<%5.2F %5.2F<Y<%5.2F = %5.2F%%'%(limits[l]['X'][0],limits[l]['X'][1],limits[l]['Y'][0],limits[l]['Y'][1],e))
       # station inefficiency
       ut.bookCanvas(h,'Tsineff','',1200,900,3,2)
       sRef=1
       border = [14.964849051657234, 54.00431913184336, -46.21974599493218, -7.146496817384938]  # scifi 1 boundaries
       h['TlineTop'+str(sRef)] = ROOT.TLine(border[2],border[1],border[3],border[1])
       h['TlineBot'+str(sRef)] = ROOT.TLine(border[2],border[0],border[3],border[0])
       h['TlineLef'+str(sRef)] = ROOT.TLine(border[2],border[0],border[2],border[1])
       h['TlineRig'+str(sRef)] = ROOT.TLine(border[3],border[0],border[3],border[1])
       for x in ['TlineTop'+str(sRef),'TlineBot'+str(sRef),'TlineLef'+str(sRef),'TlineRig'+str(sRef)]: 
           h[x].SetLineWidth(2)
           h[x].SetLineColor(ROOT.kRed)
       for s in range(1,6):
          tc = h['Tsineff'].cd(s)
          tc.SetRightMargin(0.1)
          tc.SetLogz(1)
          h['sineff'+str(s)] = h['XscifiTrack_'+str(s)].Clone('sineff'+str(s))
          h['sineff'+str(s)].Divide(h['XscifiTrack_0'])
          h['sineff'+str(s)].SetStats(0)
          h['sineff'+str(s)].SetMaximum(0.1)
          h['sineff'+str(s)].DrawCopy('colz')
          for x in ['TlineTop'+str(sRef),'TlineBot'+str(sRef),'TlineLef'+str(sRef),'TlineRig'+str(sRef)]: h[x].Draw('same')
          tc.Update()
          for l in limits :
            e = h['XscifiTrack_'+str(s)].Integral(bins[l][0],bins[l][1],bins[l][2],bins[l][3])/h['scifiTrack'].Integral(bins[l][0],bins[l][1],bins[l][2],bins[l][3])
            print('average efficiency station: %2i %5.2F<X<%5.2F %5.2F<Y<%5.2F = %5.2G'%(s,limits[l]['X'][0],limits[l]['X'][1],limits[l]['Y'][0],limits[l]['Y'][1],e))
       self.M.myPrint(h['Tsineff'],'ScifiStationInEfficiency',subdir='scifi/expert')
       ut.bookCanvas(h,'Tqdc','',1200,900,1,1)
       tc = h['Tqdc'].cd()
       h['USQDC'].Draw()
       self.M.myPrint(h['Tqdc'],'US QDC for muon track',subdir='mufilter/expert')

Member Data Documentation

deadTime

Scifi_monitoring.Scifi_trackEfficiency.deadTime

Definition at line 535 of file Scifi_monitoring.py.

debug

Scifi_monitoring.Scifi_trackEfficiency.debug

Definition at line 510 of file Scifi_monitoring.py.

eventBefore

Scifi_monitoring.Scifi_trackEfficiency.eventBefore

Definition at line 536 of file Scifi_monitoring.py.

M

Scifi_monitoring.Scifi_trackEfficiency.M

Definition at line 509 of file Scifi_monitoring.py.

masked

Scifi_monitoring.Scifi_trackEfficiency.masked

Definition at line 534 of file Scifi_monitoring.py.

res

Scifi_monitoring.Scifi_trackEfficiency.res

Definition at line 532 of file Scifi_monitoring.py.

unbiased

Scifi_monitoring.Scifi_trackEfficiency.unbiased

Definition at line 533 of file Scifi_monitoring.py.

zEx

Scifi_monitoring.Scifi_trackEfficiency.zEx

Definition at line 530 of file Scifi_monitoring.py.

zExVeto

Scifi_monitoring.Scifi_trackEfficiency.zExVeto

Definition at line 531 of file Scifi_monitoring.py.

---

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

• shipLHC/scripts/Scifi_monitoring.py