Test15: MixItUp::WillItBlend Class Reference

def MixItUp::WillItBlend::__init__ ( self )

Definition at line 9 of file MixItUp.py.

00011                       :
00012         self.stage_cfg = None
        return

def MixItUp::WillItBlend::configureMixing	(	self,
		streams
	)

Definition at line 13 of file MixItUp.py.

00015                                      :
00016         'Configure mixing'
00017 
00018         from Gaudi.Configuration import ApplicationMgr
00019         theApp = ApplicationMgr()
00020         from LoadingProc.LoadingProcConf import LoadingProc, HsAssembler
00021         from RootIOSvc.RootIOSvcConf import RootIOCnvSvc
00022         from DybIO.DybIOConf import DybInputLoadTool
00023         from DybIO.DybIOConf import DybNextEntryPolicyTool
00024 
00025         for name,rate,filelist in streams:
00026 
00027             lpname = 'LoadingProcFor_'+name
00028             assname = 'AssemblerFor_'+name
00029             iltname = 'LoadToolFor_'+name
00030             nepname = 'NextEntryPolicyFor_'+name
00031             rioname = 'RootIOCnvSvcFor_'+name
00032 
00033             lp = LoadingProc(lpname)
00034             lp.StartSec = 0
00035             lp.StartNano = 0
00036             #lp.Distribution = "Exponential"
00037             lp.Distribution = "Periodic"
00038             lp.Rate = rate
00039             lp.HsAssembler = assname
00040             lp.OutputLevel = 2
00041             lp.ThisStageName = "Detector"
00042             lp.LowerStageName = ""
00043             self.stage_cfg.DetectorSequence.Members.append(lp)
00044 
00045             
00046             ass = HsAssembler(assname)
00047             #ass.Debug = True
00048             ass.OutputLevel = 2
00049             ass.DybInputLoadTool = iltname
00050             ass.DybNextEntryPolicyTool = nepname
00051 
00052             rio = RootIOCnvSvc(rioname)
00053             theApp.ExtSvc.append(rio)
00054 
00055             inputstream = {'default': filelist}
00056             from RootIOSvc import wash_streams
00057             rio.InputStreams = wash_streams( inputstream )
00058         
00059 
00060             ilt = DybInputLoadTool(iltname)
00061             ilt.RootIOSvc = rio
00062             ilt.ConversionSvc = rio        
00063 
00064             pol = DybNextEntryPolicyTool(nepname)
00065             pol.Mode = "sequential"
00066             #pol.Mode = "random" # default
00067             continue
00068         return

def MixItUp::WillItBlend::configureElectronic ( self )

Configure the Electronics stage

Definition at line 69 of file MixItUp.py.

00071                                  :
00072         '''Configure the Electronics stage'''
00073         
00074         import ElecSim
00075         es = ElecSim.Configure(use_push_algs = False)
00076         
00077         # from ElecSim.ElecSimConf import EsIdealFeeTool
00078         # feeTool = EsIdealFeeTool()
00079         # feeTool.EnableNonlinearity=False
00080 
00081         from ElecSimProc.ElecSimProcConf import ElecSimProc
00082         esp = ElecSimProc()
00083         esp.ThisStageName = "Electronic"
00084         esp.LowerStageName = "Detector"
00085         esp.OutputLevel = 2
00086         self.stage_cfg.ElectronicSequence.Members.append(esp)
        return

def MixItUp::WillItBlend::configureTrigRead ( self )

Configure the Trigger and Readout stage

Definition at line 87 of file MixItUp.py.

00089                                :
00090         '''Configure the Trigger and Readout stage'''
00091         from TrigReadProc.TrigReadProcConf import TrigReadProc
00092         tsp = TrigReadProc()
00093         tsp.ThisStageName = "TrigRead"
00094         tsp.LowerStageName = "Electronic"
00095         #tsp.TrigTools = [...]
00096         #tsp.RoTools = [...]
00097         tsp.OutputLevel = 2
00098         self.stage_cfg.TrigReadSequence.Members.append(tsp)
        return

def MixItUp::WillItBlend::configureSingleLoader ( self )

Configure the SingleLoader stage

Definition at line 99 of file MixItUp.py.

00101                                    :
00102         '''Configure the SingleLoader stage'''
00103         from SingleLoader.SingleLoaderConf import SingleLoader
00104         sll = SingleLoader()
00105         sll.ThisStageName = "SingleLoader"
00106         sll.LowerStageName = "TrigRead"
00107         sll.OutputLevel = 2
        self.stage_cfg.SingleLoaderSequence.Members.append(sll)

def MixItUp::WillItBlend::configureSim15 ( self )

Definition at line 108 of file MixItUp.py.

00110                             :
00111         from Stage.StageConf import Sim15
00112         sim15=Sim15()
00113         sim15.TopStage = "SingleLoader"
00114         #sim15.TopStage = "Detector"
00115 
00116         from Gaudi.Configuration import ApplicationMgr
00117         theApp = ApplicationMgr()
        theApp.TopAlg.append(sim15)

def MixItUp::WillItBlend::configure	(	self,
		streams
	)

Definition at line 118 of file MixItUp.py.

00120                                :
00121         from Stage import Configure as StageConfigure
00122         self.stage_cfg = StageConfigure()
00123         self.stage_cfg.addStages(['Detector','Electronic','TrigRead','SingleLoader'])
00124 
00125         self.configureMixing(streams)
00126         self.configureElectronic()
00127         self.configureTrigRead()
00128         self.configureSingleLoader()
00129         self.configureSim15()
00130         
        return

MixItUp::WillItBlend::stage_cfg

Definition at line 10 of file MixItUp.py.

In This Package:

MixItUp::WillItBlend Class Reference

Public Member Functions

Public Attributes

Detailed Description

Member Function Documentation

Member Data Documentation


Public Member Functions
def	__init__
def	configureMixing
def	configureElectronic
def	configureTrigRead
def	configureSingleLoader
def	configureSim15
def	configure
Public Attributes
	stage_cfg