Monitor.TrackSelector Class Reference

Public Member Functions
	__init__ (self, options)
	ExecuteEvent (self, event)
	Execute (self)
	Finalize (self)

Public Attributes
	options
	EventNumber
	MonteCarlo
	snd_geo
	MuFilter
	Scifi
	runNr
	run
	muon_reco_task_Sf
	genfitTrack
	muon_reco_task_DS
	trackTask
	outFile
	fSink
	outTree
	fittedTracks
	MuonTracksBranch
	clusScifi
	clusScifiBranch
	clusMufi
	clusMufiBranch
	eventTree
	OT

Detailed Description

Definition at line 689 of file Monitor.py.

Constructor & Destructor Documentation

__init__()

Monitor.TrackSelector.__init__	(		self,
			options
	)

Definition at line 691 of file Monitor.py.

   def __init__(self,options):
        self.options = options
        self.EventNumber = -1
        self.MonteCarlo = False
 
        path     = options.path
        if path.find('eos')>0:
             path  = options.server+options.path
# setup geometry
        if (options.geoFile).find('../')<0: self.snd_geo = SndlhcGeo.GeoInterface(path+options.geoFile)
        else:                                         self.snd_geo = SndlhcGeo.GeoInterface(options.geoFile[3:])
        self.MuFilter = self.snd_geo.modules['MuFilter']
        self.Scifi       = self.snd_geo.modules['Scifi']
 
        self.runNr   = str(options.runNumber).zfill(6)
        if options.runNumber > 0:
           if options.partition < 0:
              partitions = []
              if path.find('eos')>0:
# check for partitions
                 print("xrdfs "+options.server+" ls "+options.path+"run_"+self.runNr)
                 dirlist  = str( subprocess.check_output("xrdfs "+options.server+" ls "+options.path+"run_"+self.runNr,shell=True) )
                 for x in dirlist.split('\\n'):
                     ix = x.find('sndsw_raw-')
                     if ix<0: continue
                     partitions.append(x[ix:])
              else:
# check for partitions
                 dirlist  = os.listdir(options.path+"run_"+self.runNr)
                 for x in dirlist:
                     if not x.find("sndsw_raw-")<0:
                          partitions.append(x)
           else:
                 partitions = ["sndsw_raw-"+ str(options.partition).zfill(4)+".root"]
           eventChain = ROOT.TChain('rawConv')
           for p in partitions:
               eventChain.Add(path+'run_'+self.runNr+'/'+p)
        else:
# for MC data
                eventChain = ROOT.TChain("cbmsim")
                eventChain.Add(options.fname)
                self.MonteCarlo = True
                partitions = []
        rc = eventChain.GetEvent(0)
        self.snd_geo.modules['Scifi'].InitEvent(eventChain.EventHeader)
        self.snd_geo.modules['MuFilter'].InitEvent(eventChain.EventHeader)
# start FairRunAna
        self.run  = ROOT.FairRunAna()
        ioman = ROOT.FairRootManager.Instance()
        ioman.SetTreeName(eventChain.GetName())
        source = ROOT.FairFileSource(eventChain.GetCurrentFile())
        ioman.SetInChain(eventChain)
        first = True
        for p in partitions:
           if first:
                first = False
                continue
           source.AddFile(path+'run_'+self.runNr+'/'+p+'.root')
           self.run.SetSource(source)
 
#avoiding some error messages
        xrdb = ROOT.FairRuntimeDb.instance()
        xrdb.getContainer("FairBaseParSet").setStatic()
        xrdb.getContainer("FairGeoParSet").setStatic()
 
# init() tracking tasks
        if self.options.HoughTracking:
           if self.options.trackType == 'Scifi' or self.options.trackType == 'ScifiDS':
              self.muon_reco_task_Sf = options.FairTasks["houghTransform_Sf"]
              self.muon_reco_task_Sf.Init()
              self.genfitTrack = self.muon_reco_task_Sf.genfitTrack
           if self.options.trackType == 'DS' or self.options.trackType == 'ScifiDS':
              self.muon_reco_task_DS = options.FairTasks["houghTransform_DS"]
              self.muon_reco_task_DS.Init()
              self.genfitTrack = self.muon_reco_task_DS.genfitTrack
        if self.options.simpleTracking:
           self.trackTask = options.FairTasks["simpleTracking"]
           if not self.options.HoughTracking:
              self.genfitTrack = self.options.genfitTrack
           
           self.trackTask.SetTrackClassType(self.genfitTrack)
           self.trackTask.Init()
 
# prepare output tree, same branches as input plus track(s)
        self.outFile = ROOT.TFile(options.oname,'RECREATE')
        self.fSink    = ROOT.FairRootFileSink(self.outFile)
 
        self.outTree = eventChain.CloneTree(0)
        ROOT.gDirectory.pwd()
        
        # after track tasks init(), output track format is known
        if self.genfitTrack:
                self.fittedTracks = ROOT.TClonesArray("genfit::Track")
                self.fittedTracks.BypassStreamer(ROOT.kFALSE)
        else:
                self.fittedTracks = ROOT.TClonesArray("sndRecoTrack")
        self.MuonTracksBranch    = self.outTree.Branch("Reco_MuonTracks",self.fittedTracks,32000,0)
 
        if self.options.simpleTracking and not self.options.trackType.find('Scifi')<0 and not eventChain.GetBranch("Cluster_Scifi"):
           self.clusScifi   = ROOT.TClonesArray("sndCluster")
           self.clusScifiBranch    = self.outTree.Branch("Cluster_Scifi",self.clusScifi,32000,1)
        if self.options.simpleTracking and not self.options.trackType.find('DS')<0 and not eventChain.GetBranch("Cluster_Mufi"):
           self.clusMufi   = ROOT.TClonesArray("sndCluster")
           self.clusMufiBranch    = self.outTree.Branch("Cluster_Mufi",self.clusMufi,32000,1)
 
        B = ROOT.TList()
        B.SetName('BranchList')
        B.Add(ROOT.TObjString('Reco_MuonTracks'))
        B.Add(ROOT.TObjString('Scifi_sndCluster'))
        B.Add(ROOT.TObjString('Mufi_sndCluster'))
        B.Add(ROOT.TObjString('sndScifiHit'))
        B.Add(ROOT.TObjString('MuFilterHit'))
        B.Add(ROOT.TObjString('FairEventHeader'))
        self.fSink.WriteObject(B,"BranchList", ROOT.TObject.kSingleKey)
        self.fSink.SetRunId(options.runNumber)
        self.fSink.SetOutTree(self.outTree)
 
        self.eventTree = eventChain
        self.run.SetSink(self.fSink)
        self.OT = ioman.GetSink().GetOutTree()
 

Member Function Documentation

Execute()

Monitor.TrackSelector.Execute

(

self

)

Definition at line 849 of file Monitor.py.

   def Execute(self):
      for n in range(self.options.nStart,self.options.nStart+self.options.nEvents):
 
          if self.options.scaleFactor > 1:
             if ROOT.gRandom.Rndm() > 1.0/self.options.scaleFactor: continue
 
          self.eventTree.GetEvent(n)
          # delete track containers
          self.fittedTracks.Delete()
          
          self.ExecuteEvent(self.eventTree)
          if not self.MonteCarlo and self.fittedTracks.GetEntries() == 0: continue
          if self.options.simpleTracking and not self.options.trackType.find('Scifi')<0:
             if not self.eventTree.GetBranch("Cluster_Scifi"):
                self.clusScifi.Delete()
                self.clusScifi.Expand(len(self.trackTask.clusScifi))
                for index, aCl in enumerate(self.trackTask.clusScifi):
                     self.clusScifi[index] = aCl
          if self.options.simpleTracking and not self.options.trackType.find('DS')<0:
             if not self.eventTree.GetBranch("Cluster_Mufi"):
                self.clusMufi.Delete()
                self.clusMufi.Expand(len(self.trackTask.clusMufi))
                for index, aCl in enumerate(self.trackTask.clusMufi):
                     self.clusMufi[index] = aCl
 
          # if using FairEventHeader, i.e. before sndlhc header was introduced
          if hasattr(self.OT.EventHeader, "SetMCEntryNumber"):
              self.OT.EventHeader.SetMCEntryNumber(n)
          self.fSink.Fill()
 

ExecuteEvent()

Monitor.TrackSelector.ExecuteEvent	(		self,
			event
	)

Definition at line 812 of file Monitor.py.

   def ExecuteEvent(self,event):
           track_container_list = []
           # Delete SndlhcTracking fitted tracks container
           if self.options.simpleTracking:
              self.trackTask.fittedTracks.Delete()
 
           if self.options.trackType == 'ScifiDS':
              if self.options.HoughTracking:
                 self.muon_reco_task_Sf.Exec(0)
                 self.muon_reco_task_DS.Exec(0)
                 track_container_list = [self.muon_reco_task_Sf.kalman_tracks,self.muon_reco_task_DS.kalman_tracks]
              if self.options.simpleTracking:
                 self.trackTask.ExecuteTask(option='ScifiDS')
                 track_container_list.append(self.trackTask.fittedTracks)
 
           elif self.options.trackType == 'Scifi':
              if self.options.HoughTracking:
                 self.muon_reco_task_Sf.Exec(0)
                 track_container_list.append(self.muon_reco_task_Sf.kalman_tracks)
              if self.options.simpleTracking:
                 self.trackTask.ExecuteTask(option='Scifi')
                 track_container_list.append(self.trackTask.fittedTracks)
                 
           elif self.options.trackType == 'DS':
              if self.options.HoughTracking:
                 self.muon_reco_task_DS.Exec(0)
                 track_container_list.append(self.muon_reco_task_DS.kalman_tracks)
              if self.options.simpleTracking:
                 self.trackTask.ExecuteTask(option='DS')
                 track_container_list.append(self.trackTask.fittedTracks)
 
           i_muon = -1
           for item in track_container_list:
               for aTrack in item:
                   i_muon += 1
                   self.fittedTracks[i_muon] = aTrack
 

Finalize()

Monitor.TrackSelector.Finalize

(

self

)

Definition at line 879 of file Monitor.py.

   def Finalize(self):
         self.fSink.Write()
         self.outFile.Close()

Member Data Documentation

clusMufi

Monitor.TrackSelector.clusMufi

Definition at line 793 of file Monitor.py.

clusMufiBranch

Monitor.TrackSelector.clusMufiBranch

Definition at line 794 of file Monitor.py.

clusScifi

Monitor.TrackSelector.clusScifi

Definition at line 790 of file Monitor.py.

clusScifiBranch

Monitor.TrackSelector.clusScifiBranch

Definition at line 791 of file Monitor.py.

EventNumber

Monitor.TrackSelector.EventNumber

Definition at line 693 of file Monitor.py.

eventTree

Monitor.TrackSelector.eventTree

Definition at line 808 of file Monitor.py.

fittedTracks

Monitor.TrackSelector.fittedTracks

Definition at line 783 of file Monitor.py.

fSink

Monitor.TrackSelector.fSink

Definition at line 776 of file Monitor.py.

genfitTrack

Monitor.TrackSelector.genfitTrack

Definition at line 761 of file Monitor.py.

MonteCarlo

Monitor.TrackSelector.MonteCarlo

Definition at line 694 of file Monitor.py.

MuFilter

Monitor.TrackSelector.MuFilter

Definition at line 702 of file Monitor.py.

muon_reco_task_DS

Monitor.TrackSelector.muon_reco_task_DS

Definition at line 763 of file Monitor.py.

muon_reco_task_Sf

Monitor.TrackSelector.muon_reco_task_Sf

Definition at line 759 of file Monitor.py.

MuonTracksBranch

Monitor.TrackSelector.MuonTracksBranch

Definition at line 787 of file Monitor.py.

options

Monitor.TrackSelector.options

Definition at line 692 of file Monitor.py.

OT

Monitor.TrackSelector.OT

Definition at line 810 of file Monitor.py.

outFile

Monitor.TrackSelector.outFile

Definition at line 775 of file Monitor.py.

outTree

Monitor.TrackSelector.outTree

Definition at line 778 of file Monitor.py.

run

Monitor.TrackSelector.run

Definition at line 738 of file Monitor.py.

runNr

Monitor.TrackSelector.runNr

Definition at line 705 of file Monitor.py.

Scifi

Monitor.TrackSelector.Scifi

Definition at line 703 of file Monitor.py.

snd_geo

Monitor.TrackSelector.snd_geo

Definition at line 700 of file Monitor.py.

trackTask

Monitor.TrackSelector.trackTask

Definition at line 767 of file Monitor.py.

---

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

• shipLHC/scripts/Monitor.py