In This Package:

TestShuffle.py

Go to the documentation of this file.

#!/usr/bin/env python

from DybPython.DybPythonAlg import DybPythonAlg, SUCCESS, FAILURE
from DybPython.Control import nuwa
from GaudiPython import gbl
from ROOT import gRandom, TFile, TH1F, TH2F, TGraph
import os

class DumpRandom(DybPythonAlg):
    '''
    
    Dump random numbers to file
    
    '''
    
    def __init__(self, name = 'DumpRandom', filename = 'random.dump'):
        '''
        
        Make a DumpRandom alg
        
        Arguments:
        - "name":object name
        - "filename":name of file in to which random numbers will be written
        '''
        DybPythonAlg.__init__(self,name)
        self.fp = open(filename,'w')
        self.tfile = TFile(filename+'.root',"RECREATE")
        self.executions = 0

        self.clhep_random = None
        self.rndm_svc = None
        self.rndm_engine = None

        self.maximum = 100.0    # guess a number between 0 and maximum
        self.epsilon = 1.0/(int(nuwa.opts.executions)*self.maximum)

        class Chaos(): pass

        root = Chaos()
        root.last_seed = None
        root.lucky = 0
        root.tries = 0
        root.last_tries = []
        root.seed = self.root_seed
        root.number = self.root_number
        root.name = 'ROOT'
        root.hist = TH1F("rootran","ROOT randoms",1000,0,self.maximum)
        root.hused = TH2F("rootused","ROOT randoms",100,0,100,100,0,self.maximum)
        root.graf = TGraph()
        root.graf.SetName("rootrangraf")
        root.nused = 0          # number of randoms used
        self.root = root

        clhep = Chaos()
        clhep.last_seed = None
        clhep.lucky = 0
        clhep.tries = 0
        clhep.last_tries = []
        clhep.seed = self.clhep_seed
        clhep.number = self.clhep_number
        clhep.name = 'CLHEP'
        clhep.hist = TH1F("clhepran","CLHEP randoms",1000,0,self.maximum)
        clhep.hused = TH2F("clhepused","CLHEP randoms",100,0,100,100,0,self.maximum)
        clhep.graf = TGraph()
        clhep.graf.SetName("clheprangraf")
        clhep.nused = 0         # number of randoms used
        self.clhep = clhep

        return
    
    def clhep_seed(self):
        'Return the current CLHEP seed'
        seeds = gbl.std.vector('long')();
        self.rndm_engine.seeds(seeds)
        return seeds[0]

    def root_seed(self):
        'Return the current ROOT seed'
        return gRandom.GetSeed()

    def clhep_number(self):
        'Return the next CLHEP random in [0,maximum)'
        if self.clhep_random is None:
            flat = gbl.Rndm.Flat(0,self.maximum)
            self.clhep_random = gbl.Rndm.Numbers(self.rndm_svc,flat)
        self.clhep.nused += 1
        num = self.clhep_random()
        self.clhep.hist.Fill(num)
        self.clhep.hused.Fill(self.clhep.nused,num)
        self.clhep.graf.SetPoint(self.executions,self.executions,num)
        return num

    def root_number(self):
        'Return the next ROOT random in [0,maximum)'
        self.root.nused += 1
        num = gRandom.Uniform(0,self.maximum)
        self.root.hist.Fill(num)
        self.root.hused.Fill(self.root.nused,num)
        self.root.graf.SetPoint(self.executions,self.executions,num)
        return num


    def check_tries(self,who,tries):
        assert who.last_tries != tries, '%s is really boring using the same guesses: %s' % (who.name, str(tries))
        
        if len(who.last_tries) != len(tries):
            #print '%s: new tries are different lengths %d != %d' % (who.name,len(who.last_tries),len(tries))
            who.last_tries = tries
            return

        for t1,t2 in zip(who.last_tries,tries):
            #print who.name,t1,t2
            assert abs(t1-t2) > self.epsilon, '%s does no pick fresh enough values (%f vs. %f)' % (who.name,t1,t2)

        who.last_tries = tries
        return

    def global_thermo_nuclear_war(self,who):
        'Exercise the random number stream'
        answer = who.number()
        nguesses = 50
        self.fp.write(who.name+": Seed = %d\n"%who.seed())
        self.fp.write(who.name+": Let's play guess my number\n")
        tries = []
        for n in range(nguesses):
            guess = who.number()

            assert answer != guess, "No one is that lucky to get %f == %f !" % (answer,guess)

            who.tries += 1
            tries.append(guess)
            if int(guess) == int(answer):
                self.fp.write(who.name+": Guess #%d: %f is close enough to %f, you win\n" % (n+1, guess,answer))
                if n == 0: 
                    who.lucky += 1
                    print '%s got lucky %d times' % (who.name,who.lucky)
                return
            self.fp.write(who.name+": Guess #%d: %f is wrong\n" % (n+1,guess) )
            continue
        self.check_tries(who,tries)
        self.fp.write(who.name+": You failed! The right answer was %f\n" % answer)
        return

    def play_game(self):
        self.global_thermo_nuclear_war(self.root)
        self.global_thermo_nuclear_war(self.clhep)

    def initialize(self):
        sc = DybPythonAlg.initialize(self)
        if sc.isFailure(): return sc

        
        self.rndm_svc = self.svc('IRndmGenSvc','RndmGenSvc')
        self.rndm_engine = self.rndm_svc.engine()
        assert self.rndm_engine, 'Good not get random engine from random svc'

        self.play_game()

        return SUCCESS

    def check_seed(self, who):
        'Do some checks on new seed against last seed, return new seed'
        if who.last_seed is None:
            who.last_seed = who.seed()
            return
        assert who.last_seed != who.seed(), 'Seed has not changed between executions!: %d'%who.seed()

    def check_seeds(self):

        # Seeds should be same to each other
        rs = self.root.seed()
        cs = self.clhep.seed()
        assert rs == cs, 'ROOT seed %d != CLHEP seed %d' % (rs,cs)
        
        # But they should differ from the previous
        self.check_seed(self.root)
        self.check_seed(self.clhep)

        return

    def execute(self):
        self.root.nused = 0
        self.clhep.nused = 0
        self.root.numbers = []
        self.clhep.numbers = []
        self.executions += 1
        try:
            self.check_seeds()
            self.play_game()
        except AssertionError,err:
            print err
            return FAILURE

        return SUCCESS

    def check_luck(self,who):
        msg = '%s is lucky %d out of %d = %.2f percent' % (who.name, who.lucky, who.tries, 
                                                           (100.0*who.lucky)/(1.0*who.tries))
        print msg
        assert who.lucky != who.tries, 'no one, not even %s'%msg

    def finalize(self):
        import math

        self.fp.close()

        self.root.hist.Write()
        self.root.hused.Write()
        self.root.graf.Write()
        self.clhep.hist.Write()
        self.clhep.hused.Write()
        self.clhep.graf.Write()
        self.tfile.Close()

        try:
            self.check_luck(self.root)
            self.check_luck(self.clhep)
        except AssertionError,err:
            print err
            return FAILURE
        return DybPythonAlg.finalize(self)

    pass

filenames = []

def configure(argv=None):
    global filenames

    # Everytime this module is used in a job it adds a new file
    if not argv: 
        if not filenames:
            filenames.append("test_shuffle.txt")
        return
    filenames.append(argv[0])

    from DybAlg.DybAlgConf import DybShuffle
    rs = DybShuffle("random_seeder")
    try:
        burn = argv[1]
    except IndexError:
        print 'Using default burn count',rs.BurnCount
    else:
        rs.BurnCount = int(burn)
        print 'Setting burn to',rs.BurnCount
    #rs.OutputLevel = 2

    return

def run(app):
    global filenames
    for fn in filenames:
        name = os.path.splitext(os.path.basename(fn))[0]
        alg = DumpRandom(name,fn)
        app.addAlgorithm(alg)
        print 'Added algorithm: DumpRandom("%s","%s")' % (name, fn)
        continue
    return

---