In This Package:

runDoublePulse.py

Go to the documentation of this file.

#!/usr/bin/env python

'''

usage:
    nuwa.py -n 2 -o test.root -m "runDoublePulse -I 10000 -i 6000 -D 3000"

Options:

  -T TOP_STAGE, --top-stage=TOP_STAGE
                        Kinematic,Detector,Electronic,TrigRead,SingleLoader

  -I PRIMARY_LED_INTENSITY, --Primary-LED-intensity=PRIMARY_LED_INTENSITY
                        Number of photons per LED flash for primary LED. If <=
                        0 then no LED flashing enabled.
  -i SECONDARY_LED_INTENSITY, --Secondary-LED-intensity=SECONDARY_LED_INTENSITY
                        Number of photons per LED flash for secondary LED. If
                        <= 0 then SECONDARY LED flashing is DISABLED.
  -D DOUBLE_PULSE_DELAY, --Double-pulse-delay=DOUBLE_PULSE_DELAY
                        Delay in nanoseconds of Secondary LED with respect to
                        Primary LED for double-pulse

'''
import GaudiKernel.SystemOfUnits as units

class ConfigureDoublePulse:

    '''
    Configure a Full Chain of pull simulations for cosmics and LEDs.
    '''

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

        return

    def parse_args(self,argv):
        from optparse import OptionParser
        import time
        import sys
        parser = OptionParser(usage=self.__doc__)

        parser.add_option("-T","--top-stage",
                          help="Kinematic,Detector,Electronic,TrigRead,SingleLoader",
                          default="SingleLoader")

        # Primary LED specification
        parser.add_option("-I","--Primary-LED-intensity",
                          help="Number of photons per LED flash for primary LED. If <= 0 then no LED flashing enabled.",
                          default=3500, type="int")

        # Secondary LED specification. Default is no secondary LED.
        parser.add_option("-i","--Secondary-LED-intensity",
                          help="Number of photons per LED flash for secondary LED. If <= 0 then SECONDARY LED flashing is DISABLED.",
                          default=-1, type="int")
        
        # double-pulse delay
        parser.add_option("-D","--Double-pulse-delay",
                          help="Delay in nanoseconds of Secondary LED with respect to Primary LED for double-pulse",
                          default=30.e3,
                          type="float")


        # Now parse options to setup the job. Quit if invalid inputs are found.
        (options,args) = parser.parse_args(args=argv)
        self.opts = options
        self.args = args

        print 'Top stage =',self.opts.top_stage

        print "ACU A LED intensity/flash (photons) = ", self.opts.Primary_LED_intensity
        print "ACU B LED intensity/flash (photons) = ", self.opts.Secondary_LED_intensity
        print 'Double-pulse separation (ns) = ',self.opts.Double_pulse_delay

        return

    def configureKinematic(self):

        # only import and configure LED if it will be used
        from MDC10b.runLED_Muon import LED
        led1=LED.LED(stage=self.stage_cfg,
                 name='PrimaryLED',
                 intensity=self.opts.Primary_LED_intensity,
                 time_offset_in_nanosec=0,
                 ledName='DayaBayAD1_ACU_A_Center_LED')
        
        led2=LED.LED(stage=self.stage_cfg,
                 name='SecondaryLED',
                 intensity=self.opts.Secondary_LED_intensity,
                 time_offset_in_nanosec= self.opts.Double_pulse_delay,
                 ledName= 'DayaBayAD1_ACU_B_GdlsEdge_LED')
    
        return

    def configureDetector(self):
        '''Configure the Detector stage'''

        # only use basic physics list, not nuclear.
        # set volume to simulate SAB (or full daya bay site, if chosen by user option)
        import DetSim
        from DetSim import Configure

        Configure.giga_dayabay_items = ["/dd/Structure/AD/db-ade1"] # set volume to simulate
        
        ds = Configure(physlist=DetSim.physics_list_basic,
                              use_push_algs = False,
                              site = 'dayabay')
       

        # QuantumEfficiency*CollectionEfficiency*QEScale = 0.24*1/0.9
        from DetSim.DetSimConf import DsPhysConsOptical
        optical = DsPhysConsOptical("GiGa.GiGaPhysListModular.DsPhysConsOptical")
        optical.UseScintillation = False
        #optical.ScintPhotonScaleWeight = 3.5
        #optical.UseCerenkov = False
        optical.CerenPhotonScaleWeight = 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)

        # turn off non-linear model (suspect that it fails for many pe pulse)
        from ElecSim.ElecSimConf import EsPmtEffectPulseTool
        pmtTool = EsPmtEffectPulseTool()
        pmtTool.AfterPulseAmpMode="PDF"
        pmtTool.EnablePrePulse=True
        pmtTool.EnableAfterPulse=True
        
        from ElecSim.ElecSimConf import EsIdealFeeTool
        feeTool = EsIdealFeeTool()
        feeTool.EnableNonlinearity=True
        feeTool.EnableOvershoot=True
        feeTool.EnableRinging=True 

        from ElecSimProc.ElecSimProcConf import ElecSimProc
        esp = ElecSimProc()
        esp.ThisStageName = "Electronic"
        esp.LowerStageName = "Detector"
        self.stage_cfg.ElectronicSequence.Members.append(esp)
        
                
        from StatisticsSvc.StatisticsSvcConf import StatisticsSvc
        statsSvc = StatisticsSvc()
        statsSvc.Output ={"file1":"waveforms.root"}
        
        return

    def configureTrigRead(self):
        '''Configure the Trigger and Readout stage'''
        from TrigReadProc.TrigReadProcConf import TrigReadProc
        tsp = TrigReadProc()
        tsp.ThisStageName = "TrigRead"
        tsp.LowerStageName = "Electronic"
        
        # setup Nhit trigger for Daya Bay AD1 = AD in SAB
        from TrigSim.TrigSimConf import TsMultTriggerTool 
        mtt = TsMultTriggerTool()
        mtt.ADThreshold = 25
        mtt.DetectorsToProcess = ["DayaBayAD1"]

        tsp.TrigTools = [mtt]
        
        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=[]):
    
    cdp = ConfigureDoublePulse(argv)
    cdp.configure()

    return

def run(app):
    app.ExtSvc += ["StatisticsSvc"]
    
    from ElecTutorial import WaveDumper
    
    wavealg = WaveDumper.WaveDumperAlg("WaveDumper")
    app.addAlgorithm(wavealg)
    
    pass

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

---