In This Package:

FullChainSimple.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 "FullChainSimple -T SingleLoader" > log

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

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

    //////
    Aside: 
    This is a copy of MDC09b.runIBD15.FullChain, however with less options, 
    less generators configured and less truth info saved.
    //////
    
'''
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 or SingleLoader",
                          default="SingleLoader")
        parser.add_option("-s","--seed",
                          help="Random seed for 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 human readable format',self.opts.start_time 
        print 'Start time in seconds UTC =',self.start_time_seconds
        print 'Top stage =',self.opts.top_stage

        return

    def configureKinematic(self):
        #IBD
        from Gnrtr.IBD import EvtGenerator
        # from IBD import EvtGenerator
        ibd_gds = EvtGenerator(name     = 'IBD_gds',
                               seed     = self.opts.seed,
                               volume   = '/dd/Structure/AD/db-oil1',
                               strategy = 'Material',
                               material = 'GdDopedLS',
                               mode     = 'Uniform',
                               lifetime = 78.4*units.second, #daya bay site
                               wallTime = self.start_time_seconds)

        ibd_gds.ThisStageName = "Kinematic"
        self.stage_cfg.KinematicSequence.Members.append( ibd_gds )

        from Gnrtr.Radioact import Radioact
        #K40
        k40_gds = Radioact(name       = 'K40_gds',
                           volume     = '/dd/Structure/AD/db-oil1',
                           nuclide    = 'K40',
                           abundance  = 3.01e17,
                           strategy   = 'Material',
                           material   = 'GdDopedLS',
                           start_time = self.start_time_seconds)

        k40_gds.ThisStageName = "Kinematic"
        self.stage_cfg.KinematicSequence.Members.append( k40_gds )
        
        return

    def configureDetector(self):
        '''Configure the Detector stage'''
        
        import DetSim
        ds = DetSim.Configure(physlist=DetSim.physics_list_basic+DetSim.physics_list_nuclear,site="dayabay",
                              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

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

        ds.historian(trackSelection="(pdg == 2112)",vertexSelection="(pdg == 2112)")
        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)
        # wangzhe
        from ElecSim.ElecSimConf import EsIdealFeeTool
        feetool = EsIdealFeeTool()
        feetool.EnableNonlinearity=False
        #feetool.OutputLevel = 2
        # wz
        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()
        # Run for a long time by default You can use "nuwa.py -n XXX"
        # to limit.  This is actually the default now:
        sim15.TimeRange = 365*24*60*60*units.second 
        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

---