vetoTimeCalibration.vetoTDCplaneCalibration Class Reference

Inheritance diagram for vetoTimeCalibration.vetoTDCplaneCalibration:

Collaboration diagram for vetoTimeCalibration.vetoTDCplaneCalibration:

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

Public Attributes
	M
	minChannels
	tag
	xCheck
	nbars
	tdcVetoCalib
	tdcVetoPlaneCalib

Detailed Description

Definition at line 25 of file vetoTimeCalibration.py.

Member Function Documentation

ExecuteEvent()

vetoTimeCalibration.vetoTDCplaneCalibration.ExecuteEvent	(		self,
			event
	)

Definition at line 60 of file vetoTimeCalibration.py.

   def ExecuteEvent(self,event):
       h = self.M.h
       s = 1
       vetoHits = {10:[],11:[]}
       for aHit in event.Digi_MuFilterHits:
          if not aHit.isValid(): continue
          detID = aHit.GetDetectorID()//1000
          if not detID<20: continue
          vetoHits[detID].append(aHit)
       if not(len(vetoHits[10])==1) and not(len(vetoHits[11])==1): return
       for aTrack in event.Reco_MuonTracks:
          if not aTrack.GetUniqueID()==1: continue
          tdc = {10:{},11:{}}
          S = aTrack.getFitStatus()
          if S.isFitConverged():   continue
          state    = aTrack.getFittedState()
          mom    = state.getMom()
          slopeX  = mom.X()/mom.Z()
          slopeY  = mom.Y()/mom.Z()
          pos = state.getPos()
          rc = h[detector+'trackSlopes'].Fill(slopeX*1000,slopeY*1000)
          rc = h[detector+'trackSlopesXL'].Fill(slopeX,slopeY)
          rc = h[detector+'trackPos'].Fill(pos.X(),pos.Y())
          if abs(slopeX)<0.1 and abs(slopeY)<0.1:  rc = h[detector+'trackPosBeam'].Fill(pos.X(),pos.Y())
 
          if abs(mom.x()/mom.z())>0.25: continue   # 4cm distance, 250mrad = 1cm
          if mom.y()/mom.z()>0.05: continue
 
          for l in range(2):
             zEx = self.M.zPos['MuFilter'][1*10+l]
             lam      = (zEx-pos.z())/mom.z()
             yEx        = pos.y()+lam*mom.y()
             xEx        = pos.x()+lam*mom.x()  # needed for correction of signal propagation
             for aHit in vetoHits[10+l]:
                detID = aHit.GetDetectorID()
                bar = (detID%1000)
                self.M.MuFilter.GetPosition(detID,A,B)
                D = (A[1]+B[1])/2. - yEx
                rc = h['exBar_'+str(l)+str(bar)].Fill(D)
                if abs(D)<5:
                   tdc[10+l][bar] = {'L':{},'R':{}}
                   for k in range(16):
                      qdc = aHit.GetSignal(k)
                      if qdc <0: continue
                      kx = k
                      side = 'L'
                      if not k < 8 : 
                           kx = k - 8
                           side = 'R'
                      cor = 0
                      if kx in self.tdcVetoCalib[s*10+l][side][bar]: 
                           cor = self.tdcVetoCalib[s*10+l][side][bar][kx][0]
                      elif kx>0: print('no correction:',s,l,side,bar,kx)
                      tdc[10+l][bar][side][kx] = aHit.GetTime(k) - cor
                      if self.xCheck:
                           tdc[10+l][bar][side][kx] -= self.tdcVetoPlaneCalib[s*10+l][side][bar]
 
      # make plane alignment
          l0 = 0
          l1 = 1
          for bar in tdc[10+l0]:
             for side in tdc[10+l0][bar]:
                tdc0 = 0
                n=0
                fastTDC0 = 999.
                for k in tdc[10+l0][bar][side]:
                     n+=1
                     tdc0+=tdc[10+l0][bar][side][k]
                     if tdc[10+l0][bar][side][k] < fastTDC0 : fastTDC0 = tdc[10+l0][bar][side][k]
 
                if n<self.minChannels: continue
                tdc0 = tdc0/n
                for bar1 in [bar-1,bar,bar+1]:
                    if not bar1 in tdc[10+l1]: continue
                    if not side in tdc[10+l1][bar1]: continue
                    tdc1 = 0
                    n=0
                    fastTDC1 = 999.
                    for k in tdc[10+l1][bar1][side]:
                       n+=1
                       tdc1+=tdc[10+l1][bar1][side][k]
                       if tdc[10+l1][bar1][side][k] < fastTDC1 : fastTDC1 = tdc[10+l1][bar1][side][k]
                    if n<self.minChannels: continue
                    tdc1 = tdc1/n
                    # dt = tdc1-tdc0
                    dt = fastTDC1 - fastTDC0
                    key = self.M.sdict[s]+str(bar)+'_'+str(bar1)+side+self.tag
                    rc = h['dtBar_'+key].Fill(dt)
 

Finalize()

vetoTimeCalibration.vetoTDCplaneCalibration.Finalize

(

self

)

Definition at line 200 of file vetoTimeCalibration.py.

   def Finalize(self):
       h = self.M.h
       s = 1
       h['matrix'+self.tag] = {}
       ut.bookCanvas(h,'dummy','',900,600,1,1)
       h['dummy'].cd()
       for side in ['L','R']:
           h['matrix'+self.tag][side] = {}
           for bar in range(self.nbars):
                h['matrix'+self.tag][side][bar] = {}
                for bar1 in [bar-1,bar,bar+1]:
                    if bar1 < 0 or bar1 > self.nbars: continue
                    histo = h['dtBar_Veto'+str(bar)+'_'+str(bar1)+side+self.tag]
                    rc = histo.Fit('gaus','SQ')
                    h['matrix'+self.tag][side][bar][bar1] = [histo.GetMean(),histo.GetMeanError()]
 

Init()

vetoTimeCalibration.vetoTDCplaneCalibration.Init	(		self,
			options,
			monitor
	)

Definition at line 27 of file vetoTimeCalibration.py.

   def Init(self,options,monitor):
       self.M = monitor
       h = self.M.h
       self.minChannels = 4
       self.tag = ""
       self.xCheck = False
       if options.xCheck : 
           self.xCheck = True
           self.tag = "X"
 
       s = 1
       # delta T between bar i of plane 0 and bar i-1,i,i+1 of plane 1
       l = 0
       self.nbars = self.M.systemAndBars[s]
       for bar in range(self.nbars):
          ut.bookHist(h,'exBar_0'+str(bar),'ex y;dy [cm]',50,-10.,10.)
          ut.bookHist(h,'exBar_1'+str(bar),'ex y;dy [cm]',50,-10.,10.)
          for side in ['L','R']:
                for bar1 in [bar-1,bar,bar+1]:
                     if bar1 < 0 or bar1 > self.nbars: continue
                     key = self.M.sdict[s]+str(bar)+'_'+str(bar1)+side+self.tag
                     ut.bookHist(h,'dtBar_'+key,'dt '+key+";dt [timestamp]",200,-1.,1.)
       with open('tdcVetoInternalCalibration', 'rb') as fh:
               self.tdcVetoCalib = pickle.load(fh)
       if self.xCheck:
            with open('tdcVetoPlaneCalibration', 'rb') as fh:
               self.tdcVetoPlaneCalib = pickle.load(fh)
 
       ut.bookHist(h,detector+'trackSlopes','track slope; x/z [mrad]; y/z [mrad]',1000,-100,100,1000,-100,100)
       ut.bookHist(h,detector+'trackSlopesXL','track slope; x/z [rad]; y/z [rad]',120,-1.1,1.1,120,-1.1,1.1)
       ut.bookHist(h,detector+'trackPos','track pos; x [cm]; y [cm]',100,-90,10.,80,0.,80.)
       ut.bookHist(h,detector+'trackPosBeam','beam track pos slopes<0.1rad; x [cm]; y [cm]',100,-90,10.,80,0.,80.)
 

minimize()

vetoTimeCalibration.vetoTDCplaneCalibration.minimize

(

self

)

Definition at line 149 of file vetoTimeCalibration.py.

   def minimize(self):
       h = self.M.h
       s = 1
       h['tdcCalibPlane'] = {10:{'L':{},'R':{}},11:{'L':{},'R':{}}}
       for side in ['L','R']:
         global X
         X = h['matrix'][side]
         global nbars
         nbars  = self.M.systemAndBars[s]
         npar = nbars*2
         ierflg    = ctypes.c_int(0)
         vstart  = array('d',[0]*npar)
         gMinuit = ROOT.TMinuit(npar)
         gMinuit.SetFCN(FCN)
         gMinuit.SetErrorDef(1.0)
         gMinuit.SetMaxIterations(10000)
         p = 0
         err = 1E-3
         for l in range(2):
           for o in range(nbars):
             name = "o"+str(10*l+o)
             gMinuit.mnparm(p, name, vstart[p], err, 0.,0.,ierflg)
             p+=1
         gMinuit.FixParameter(4)
         strat = array('d',[0])
         gMinuit.mnexcm("SET STR",strat,1,ierflg) # 0 faster, 2 more reliable
         gMinuit.mnexcm("SIMPLEX",vstart,npar,ierflg)
         gMinuit.mnexcm("MIGRAD",vstart,npar,ierflg)
         cor0 = ctypes.c_double(0)
         ecor0 = ctypes.c_double(0)
         cor1 = ctypes.c_double(0)
         ecor1 = ctypes.c_double(0)
 
         for bar in range(npar):
            if bar<7: l=0
            else:   l=1
            rc = gMinuit.GetParameter(bar,cor0,ecor0)
            h['tdcCalibPlane'][10+l][side][bar-7*l] = cor0.value
 
         for bar in range(nbars):
           for bar1 in [bar-1,bar,bar+1]:
              if bar1 < 0 or bar1 > nbars: continue
              if X[bar][bar1][0]==0: continue
              rc = gMinuit.GetParameter(bar,cor0,ecor0)
              rc = gMinuit.GetParameter(bar1+nbars,cor1,ecor1)
              d = X[bar][bar1][0] - (cor1.value - cor0.value)
              print("relation between veto0 %i and veto1 %i, before correction %6.4F and after %6.4F"%(bar,bar1,X[bar][bar1][0],d))
 
       with open('tdcVetoPlaneCalibration', 'wb') as fh:
           pickle.dump(h['tdcCalibPlane'], fh)
 

Member Data Documentation

M

vetoTimeCalibration.vetoTDCplaneCalibration.M

Definition at line 28 of file vetoTimeCalibration.py.

minChannels

vetoTimeCalibration.vetoTDCplaneCalibration.minChannels

Definition at line 30 of file vetoTimeCalibration.py.

nbars

vetoTimeCalibration.vetoTDCplaneCalibration.nbars

Definition at line 40 of file vetoTimeCalibration.py.

tag

vetoTimeCalibration.vetoTDCplaneCalibration.tag

Definition at line 31 of file vetoTimeCalibration.py.

tdcVetoCalib

vetoTimeCalibration.vetoTDCplaneCalibration.tdcVetoCalib

Definition at line 50 of file vetoTimeCalibration.py.

tdcVetoPlaneCalib

vetoTimeCalibration.vetoTDCplaneCalibration.tdcVetoPlaneCalib

Definition at line 53 of file vetoTimeCalibration.py.

xCheck

vetoTimeCalibration.vetoTDCplaneCalibration.xCheck

Definition at line 32 of file vetoTimeCalibration.py.

---

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

• shipLHC/scripts/vetoTimeCalibration.py