trackingInputValidationBkg.py

#!/usr/bin/env python3
 
 
 
"""
<header>
  <contact>software-tracking@belle2.org</contact>
  <input>EvtGenSim.root</input>
  <output>TrackingInputValidationBkg.root</output>
  <description>
  This module checks the number of input hits for tracking.
  </description>
</header>
"""
 
from tracking.validation.plot import ValidationPlot
from ROOT import Belle2
import collections
import ROOT
import basf2
from svd import add_svd_reconstruction
from pxd import add_pxd_reconstruction
NAME = 'Tracking Input Validation'  # not used?
CONTACT = 'software-tracking@belle2.org'
INPUT_FILE = '../EvtGenSim.root'
OUTPUT_FILE = 'TrackingInputValidationBkg.root'
N_EVENTS = 1000
 
ACTIVE = True
 
 
basf2.set_random_seed(1509)
 
 
class TrackingInputValidation(basf2.Module):
    """
    Module to collect information about the number of
    * PXDDigits
    * PXDClusters
    * PXDSpacePoints
    * SVDShaperDigits
    * SVDClusters
    * SVDSpacePoints
    * CDCHits
    """
 
    def __init__(
        self,
        name='',
        contact='',
        output_file_name=None,
    ):
        """Constructor"""
 
        super().__init__()
        
        self.validation_namevalidation_name = NAME
        
        self.contactcontact = CONTACT
        
        self.output_file_nameoutput_file_name = OUTPUT_FILE
 
    def initialize(self):
        """Receive signal at the start of event processing"""
 
        
        self.PXDDigitsPXDDigits = Belle2.PyStoreArray('PXDDigits')
        
        self.PXDClustersPXDClusters = Belle2.PyStoreArray('PXDClusters')
        
        self.PXDSpacePointsPXDSpacePoints = Belle2.PyStoreArray('PXDSpacePoints')
 
        
        self.SVDShaperDigitsSVDShaperDigits = Belle2.PyStoreArray('SVDShaperDigits')
        
        self.SVDClustersSVDClusters = Belle2.PyStoreArray('SVDClusters')
        
        self.SVDSpacePointsSVDSpacePoints = Belle2.PyStoreArray('SVDSpacePoints')
 
        
        self.CDCHitsCDCHits = Belle2.PyStoreArray('CDCHits')
 
        
        self.nPXDDigitsnPXDDigits = collections.deque()
        
        self.nPXDClustersnPXDClusters = collections.deque()
        
        self.nPXDSpacePointsnPXDSpacePoints = collections.deque()
 
        
        self.nSVDShaperDigitsnSVDShaperDigits = collections.deque()
        
        self.nSVDClustersnSVDClusters = collections.deque()
        
        self.nSVDSpacePointsnSVDSpacePoints = collections.deque()
 
        
        self.nCDCHitsnCDCHits = collections.deque()
 
    def event(self):
        '''Event function'''
 
        self.nPXDDigitsnPXDDigits.append(self.PXDDigitsPXDDigits.getEntries())
        self.nPXDClustersnPXDClusters.append(self.PXDClustersPXDClusters.getEntries())
        self.nPXDSpacePointsnPXDSpacePoints.append(self.PXDSpacePointsPXDSpacePoints.getEntries())
        self.nSVDShaperDigitsnSVDShaperDigits.append(self.SVDShaperDigitsSVDShaperDigits.getEntries())
        self.nSVDClustersnSVDClusters.append(self.SVDClustersSVDClusters.getEntries())
        self.nSVDSpacePointsnSVDSpacePoints.append(self.SVDSpacePointsSVDSpacePoints.getEntries())
        self.nCDCHitsnCDCHits.append(self.CDCHitsCDCHits.getEntries())
 
    def terminate(self):
        """Receive signal at the end of event processing"""
 
        ''' Saving'''
        output_tfile = ROOT.TFile(self.output_file_nameoutput_file_name, 'recreate')
 
        h_nPXDDigits = ValidationPlot('h_nPXDDigits')
        h_nPXDDigits.hist(self.nPXDDigitsnPXDDigits, bins=100, lower_bound=0, upper_bound=1000)
        h_nPXDDigits.contact = self.contactcontact
        h_nPXDDigits.check = 'Average of 250 +/- 100 is expected'
        h_nPXDDigits.description = 'Number of PXDDigits after ROI filtering'
        h_nPXDDigits.title = 'Number of selected PXDDigits per event'
        h_nPXDDigits.xlabel = 'Number of PXDDigits'
        h_nPXDDigits.ylabel = ''
        h_nPXDDigits.write(output_tfile)
 
        h_nPXDClusters = ValidationPlot('h_nPXDClusters')
        h_nPXDClusters.hist(self.nPXDClustersnPXDClusters, bins=100, lower_bound=0, upper_bound=500)
        h_nPXDClusters.contact = self.contactcontact
        h_nPXDClusters.check = 'Average of 75 +/- 20 is expected'
        h_nPXDClusters.description = 'Number of PXDClusters after ROI filtering'
        h_nPXDClusters.title = 'Number of PXDClusters per event'
        h_nPXDClusters.xlabel = 'Number of PXDClusters'
        h_nPXDClusters.ylabel = ''
        h_nPXDClusters.write(output_tfile)
 
        h_nPXDSpacePoints = ValidationPlot('h_nPXDSpacePoints')
        h_nPXDSpacePoints.hist(self.nPXDSpacePointsnPXDSpacePoints, bins=100, lower_bound=0, upper_bound=500)
        h_nPXDSpacePoints.contact = self.contactcontact
        h_nPXDSpacePoints.check = 'Average of 75 +/- 20 is expected'
        h_nPXDSpacePoints.description = 'Number of PXDSpacePoints after ROI filtering. \
                                         Should be the same as the number of PXDClusters'
        h_nPXDSpacePoints.title = 'Number of PXDSpacePoints per event'
        h_nPXDSpacePoints.xlabel = 'Number of PXDSpacePoints'
        h_nPXDSpacePoints.ylabel = ''
        h_nPXDSpacePoints.write(output_tfile)
 
        h_nSVDShaperDigits = ValidationPlot('h_nSVDShaperDigits')
        h_nSVDShaperDigits.hist(self.nSVDShaperDigitsnSVDShaperDigits, bins=100, lower_bound=0, upper_bound=10000)
        h_nSVDShaperDigits.contact = self.contactcontact
        h_nSVDShaperDigits.check = 'First peak at about 3200 +/- 200 is expected, with a second peak round 5500'
        h_nSVDShaperDigits.description = 'Number of SVDDigits'
        h_nSVDShaperDigits.title = 'Number of SVDDigits per event'
        h_nSVDShaperDigits.xlabel = 'Number of SVDDigits'
        h_nSVDShaperDigits.ylabel = ''
        h_nSVDShaperDigits.write(output_tfile)
 
        h_nSVDClusters = ValidationPlot('h_nSVDClusters')
        h_nSVDClusters.hist(self.nSVDClustersnSVDClusters, bins=100, lower_bound=0, upper_bound=2000)
        h_nSVDClusters.contact = self.contactcontact
        h_nSVDClusters.check = 'Average of 500 +/- 100 is expected'
        h_nSVDClusters.description = 'Number of SVDClusters'
        h_nSVDClusters.title = 'Number of SVDClusters per event'
        h_nSVDClusters.xlabel = 'Number of SVDClusters'
        h_nSVDClusters.ylabel = ''
        h_nSVDClusters.write(output_tfile)
 
        h_nSVDSpacePoints = ValidationPlot('h_nSVDSpacePoints')
        h_nSVDSpacePoints.hist(self.nSVDSpacePointsnSVDSpacePoints, bins=100, lower_bound=0, upper_bound=2000)
        h_nSVDSpacePoints.contact = self.contactcontact
        h_nSVDSpacePoints.check = 'Average of 200 +/- 50 is expected'
        h_nSVDSpacePoints.description = 'Number of SVDSpacePoints'
        h_nSVDSpacePoints.title = 'Number of SVDSpacePoints per event'
        h_nSVDSpacePoints.xlabel = 'Number of SVDSpacePoints'
        h_nSVDSpacePoints.ylabel = ''
        h_nSVDSpacePoints.write(output_tfile)
 
        h_nCDCHits = ValidationPlot('h_nCDCHits')
        h_nCDCHits.hist(self.nCDCHitsnCDCHits, bins=100, lower_bound=0, upper_bound=5000)
        h_nCDCHits.contact = self.contactcontact
        h_nCDCHits.check = 'Average of 3000 +/- 200 is expected'
        h_nCDCHits.description = 'Number of CDCHits'
        h_nCDCHits.title = 'Number of CDCHits per event'
        h_nCDCHits.xlabel = 'Number of CDCHits'
        h_nCDCHits.ylabel = ''
        h_nCDCHits.write(output_tfile)
 
        output_tfile.Close()
 
 
""" Steering """
 
path = basf2.create_path()
 
path.add_module('RootInput', inputFileName=INPUT_FILE)
path.add_module('Gearbox')
path.add_module('Geometry')
add_svd_reconstruction(path, isROIsimulation=False)
add_pxd_reconstruction(path)
 
path.add_module(TrackingInputValidation())
 
path.add_module('Progress')
 
 
if ACTIVE:
    print(path)
    basf2.process(path)