In This Package:

FullChain.py

Go to the documentation of this file.

#!/usr/bin/env python

'''

Configure the full chain of simulation from kinematics to readouts and
with multiple kinematics types mixed together.

usage:
    nuwa.py -n50 -o fifteen.root -m "FullChain -T Kinematic" > log

    -T: Optional stages are: Kinematic, Detector, Electronic, TrigRead or SingleLoader.

    More options are available like -w: wall clock starting time
                                    -s: seed for standalone generators
                                    -F: time format

    Here is another example:
    nuwa.py -n50 -o fifteen.root -m "FullChain -T Detector -w 2008-04-15T15:15:00 -s 1"

'''
import GaudiKernel.SystemOfUnits as units

class ConfigureFullChain:

    '''
    Configure a Full Chain of pull simulations.
    '''

    def __init__(self,argv):
        self.parse_args(argv)
        return

    def parse_args(self,argv):
        from optparse import OptionParser
        import time
        parser = OptionParser(usage=self.__doc__)
        default_time_format = '%Y-%m-%dT%H:%M:%S'
        parser.add_option("-w","--start-time",
                          help="Date string to set simulation start, assumed UTC",
                          default=time.strftime(default_time_format,time.gmtime(0)))
        parser.add_option("-F","--time-format",
                          help="Format for parsing time (see man date), " \
                              + "default is '%s'"%default_time_format \
                              + " ('[YYYY]-[MM]-[DD]T[HH]:[MM]:[SS]')",
                          default=default_time_format)
        parser.add_option("-T","--top-stage",
                          help="Kinematic,Detector,Electronic,TrigRead,SingleLoader",
                          default="SingleLoader")
        parser.add_option("-s","--seed",
                          help="Random seed for standalone generators",
                          default=1234567)

        (options,args) = parser.parse_args(args=argv)
        self.opts = options
        self.args = args

        timeformat = self.opts.time_format
        print "Using time format =",timeformat

        try:
            datestring = self.opts.start_time
        except AttributeError:
            self.start_time_seconds = 0
        else:
            # This may raise ValueError if string and format don't
            # match.  Just let it get thrown.
            t = time.strptime(datestring,timeformat)
            self.start_time_seconds = time.mktime(t) - time.timezone
        print 'Start time in seconds UTC =',self.start_time_seconds
        print 'Top stage =',self.opts.top_stage

        return

    def configureKinematic(self):
        #from Stage.gun import gun
        #gun=gun(stage=self.stage_cfg,start_time=self.start_time_seconds)

        #from Stage.Muon import Muon
        #muon=Muon(stage=self.stage_cfg,start_time=self.start_time_seconds)

        from FastMuon import FastMuon
        fastMuon=FastMuon(stage=self.stage_cfg,
                          start_time=self.start_time_seconds,
                          seed=self.opts.seed)

        #from GunMuon import GunMuon
        #gunMuon=GunMuon(stage=self.stage_cfg,
        #                start_time=self.start_time_seconds,
        #                seed=self.opts.seed)

        return

    def configureDetector(self):
        '''Configure the Detector stage'''
        
        import DetSim
        ds = DetSim.Configure(physlist=DetSim.physics_list_basic+DetSim.physics_list_nuclear,
                              use_push_algs = False)

        # QuantumEfficiency*CollectionEfficiency*QEScale = 0.24*1/0.9
        from DetSim.DetSimConf import DsPhysConsOptical
        optical = DsPhysConsOptical()
        optical.UseScintillation = False
        #optical.CerenPhotonScaleWeight = 3.5
        optical.UseCerenkov = False
        #optical.ScintPhotonScaleWeight = 3.5

        ## ......
        ## ApplyWaterQe and WaterCerenQeApplied should be same
        optical.ApplyWaterQe = True
        from DetSim.DetSimConf import DsPmtSensDet
        pmtsd = DsPmtSensDet("GiGaGeo.DsPmtSensDet")
        pmtsd.WaterCerenQeApplied = optical.ApplyWaterQe
        ## ......

        from DetSimProc.DetSimProcConf import DetSimProc
        dsp = DetSimProc()
        dsp.ThisStageName = "Detector"
        dsp.LowerStageName = "Kinematic"
        #dsp.OutputLevel = 2
        self.stage_cfg.DetectorSequence.Members.append(dsp)
        return

    def configureElectronic(self):
        '''Configure the Electronics stage'''

        import ElecSim
        es = ElecSim.Configure(use_push_algs = 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=self.opts.top_stage
        
        from Gaudi.Configuration import ApplicationMgr
        theApp = ApplicationMgr()
        theApp.TopAlg.append(sim15)

    def configure(self):

        from Stage import Configure as StageConfigure
        self.stage_cfg = StageConfigure()

        stagedic={'Kinematic':1,'Detector':2,'Electronic':3,'TrigRead':4,'SingleLoader':5}

        if not self.opts.top_stage in stagedic:
            print 'Error, wrong top stage parameter.', self.opts.top_stage
            print 'Valid stage is Kinematic, Detector, Electronic, TrigRead or SingleLoader'

        for stg,idx in stagedic.iteritems():
            if idx <= stagedic[self.opts.top_stage]:
                self.stage_cfg.addStages([stg])           ## stage tools are configured here.
                
        for stg in self.stage_cfg.stages:
            #self.stage_cfg.__dict__[stg].OutputLevel = 2
            pass

        if stagedic[self.opts.top_stage]>=1:
            self.configureKinematic()
        if stagedic[self.opts.top_stage]>=2:
            self.configureDetector()
        if stagedic[self.opts.top_stage]>=3:
            self.configureElectronic()
        if stagedic[self.opts.top_stage]>=4:
            self.configureTrigRead()
        if stagedic[self.opts.top_stage]>=5:
            self.configureSingleLoader()

        self.configureSim15()
        
        return
        
def configure(argv=[]):
    cfc = ConfigureFullChain(argv)
    cfc.configure()
    return

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

---