In This Package:

MixItUp.py

Go to the documentation of this file.

import GaudiKernel.SystemOfUnits as units

from DybPython.Tools import unitify

class WillItBlend:

    '''
    Class to configure mixing of different files.
    '''

    def __init__(self):
        self.stage_cfg = None
        return

    def configureMixing(self,streams):
        'Configure mixing'

        from Gaudi.Configuration import ApplicationMgr
        theApp = ApplicationMgr()
        from LoadingProc.LoadingProcConf import LoadingProc, HsAssembler
        from RootIOSvc.RootIOSvcConf import RootIOCnvSvc
        from DybIO.DybIOConf import DybInputLoadTool
        from DybIO.DybIOConf import DybNextEntryPolicyTool

        for name,rate,filelist in streams:

            lpname = 'LoadingProcFor_'+name
            assname = 'AssemblerFor_'+name
            iltname = 'LoadToolFor_'+name
            nepname = 'NextEntryPolicyFor_'+name
            rioname = 'RootIOCnvSvcFor_'+name

            lp = LoadingProc(lpname)
            lp.StartSec = 0
            lp.StartNano = 0
            #lp.Distribution = "Exponential"
            lp.Distribution = "Periodic"
            lp.Rate = rate
            lp.HsAssembler = assname
            lp.OutputLevel = 2
            lp.ThisStageName = "Detector"
            lp.LowerStageName = ""
            self.stage_cfg.DetectorSequence.Members.append(lp)

            
            ass = HsAssembler(assname)
            #ass.Debug = True
            ass.OutputLevel = 2
            ass.DybInputLoadTool = iltname
            ass.DybNextEntryPolicyTool = nepname

            rio = RootIOCnvSvc(rioname)
            theApp.ExtSvc.append(rio)

            inputstream = {'default': filelist}
            from RootIOSvc import wash_streams
            rio.InputStreams = wash_streams( inputstream )
        

            ilt = DybInputLoadTool(iltname)
            ilt.RootIOSvc = rio
            ilt.ConversionSvc = rio        

            pol = DybNextEntryPolicyTool(nepname)
            pol.Mode = "sequential"
            #pol.Mode = "random" # default
            continue
        return

        
    def configureElectronic(self):
        '''Configure the Electronics stage'''
        
        import ElecSim
        es = ElecSim.Configure(use_push_algs = False)
        
        # from ElecSim.ElecSimConf import EsIdealFeeTool
        # feeTool = EsIdealFeeTool()
        # feeTool.EnableNonlinearity=False

        from ElecSimProc.ElecSimProcConf import ElecSimProc
        esp = ElecSimProc()
        esp.ThisStageName = "Electronic"
        esp.LowerStageName = "Detector"
        esp.OutputLevel = 2
        self.stage_cfg.ElectronicSequence.Members.append(esp)
        return
    
    def configureTrigRead(self):
        '''Configure the Trigger and Readout stage'''
        from TrigReadProc.TrigReadProcConf import TrigReadProc
        tsp = TrigReadProc()
        tsp.ThisStageName = "TrigRead"
        tsp.LowerStageName = "Electronic"
        #tsp.TrigTools = [...]
        #tsp.RoTools = [...]
        tsp.OutputLevel = 2
        self.stage_cfg.TrigReadSequence.Members.append(tsp)
        return
    
    def configureSingleLoader(self):
        '''Configure the SingleLoader stage'''
        from SingleLoader.SingleLoaderConf import SingleLoader
        sll = SingleLoader()
        sll.ThisStageName = "SingleLoader"
        sll.LowerStageName = "TrigRead"
        sll.OutputLevel = 2
        self.stage_cfg.SingleLoaderSequence.Members.append(sll)
        
    def configureSim15(self):
        from Stage.StageConf import Sim15
        sim15=Sim15()
        sim15.TopStage = "SingleLoader"
        #sim15.TopStage = "Detector"

        from Gaudi.Configuration import ApplicationMgr
        theApp = ApplicationMgr()
        theApp.TopAlg.append(sim15)

    def configure(self,streams):
        from Stage import Configure as StageConfigure
        self.stage_cfg = StageConfigure()
        self.stage_cfg.addStages(['Detector','Electronic','TrigRead','SingleLoader'])

        self.configureMixing(streams)
        self.configureElectronic()
        self.configureTrigRead()
        self.configureSingleLoader()
        self.configureSim15()
        
        return
        
def configure(argv=None):
    assert argv,'Got no arguments.\n' + WillItBlend.__doc__
    streams = unitify(argv[0])
    print 'Configured with streams =',streams
    cfc = WillItBlend()
    cfc.configure(streams)
    return

if __name__ == "__main__":
    configure()
    pass

---