In This Package:

TestRandom.py

Go to the documentation of this file.

#!/usr/bin/env python

from DybPython.DybPythonAlg import DybPythonAlg, SUCCESS, FAILURE
from GaudiPython import gbl
from ROOT import gRandom

class RootRandom(object):
    def __init__(self,maximum):
        self.max = maximum
        self.name = 'ROOT'

    def __call__(self):
        num = gRandom.Uniform(self.max)
        assert 0<=num<self.max, 'Got bogus ROOT random: %f'%num
        return num

class ClhepRandom(object):
    def __init__(self, maximum, rndmsvc):
        self.max = maximum
        self.name = 'CLHEP'
        flat = gbl.Rndm.Flat(0,maximum)
        self.flat = gbl.Rndm.Numbers(rndmsvc,flat)

    def __call__(self):
        num = self.flat()
        assert 0<=num<self.max, 'Got bogus CLHEP random: %f'%num
        return num

class RandomEater(object):
    def __init__(self,nrans,ran):
        self.ran = ran
        self.nrans = nrans
        self.count = 0
        self.numbers = [0]*nrans
        self.avg = [0]*nrans
        self.rms = [0]*nrans
        self.nevents = 0

    def clear(self):
        if self.nrans != self.count:
            raise RuntimeError, "RandomEater not called enough %d != %d" %\
                (self.ntrans,self.count)

        self.avg = map(lambda x: x[0]+x[1], zip(self.avg,self.numbers))
        self.rms = map(lambda x: x[0]+x[1]*x[1], zip(self.rms,self.numbers))
        self.numbers = [0]*self.nrans
        self.count = 0
        self.nevents += 1
        return

    def check(self):
        import math
        avg = map(lambda x: x/self.nevents, self.avg)
        rms = map(lambda x: math.sqrt((x[1] - self.nevents*x[0]**2)/(self.nevents-1)),
                  zip(avg,self.rms))

        nbad = 0
        count = 0;
        target_mean = self.ran.max/2.0
        target_width = self.ran.max/math.sqrt(12)
        target_mean_eps = 100*target_width/self.nevents
        target_width_eps = 0.1*target_width

        for mean, width in zip(avg,rms):
            #print '%s random at %d: %f +/- %f' % (self.ran.name,count,mean,width)
            if abs(mean-target_mean) > target_mean_eps or \
                    abs(width-target_width) > target_width_eps:
                print 'Rogue %s random at %d: %f(%f,%f) +/- %f(%f,%f)' % \
                    (self.ran.name,count,
                     mean,mean-target_mean,(mean-target_mean)/target_mean_eps,
                     width,width-target_width,(width-target_width)/target_width_eps)
                nbad += 1
            count += 1
            continue
        return nbad


    def __call__(self):
        if self.count > self.nrans:
            raise RuntimeError, 'RandomEater called more than max %d'%self.nrans
        num = self.ran()
        self.numbers[self.count] = num
        self.count += 1
        return num
    pass

class EatRandom(DybPythonAlg):
    
    def __init__(self, name = 'EatRandom', nrans = 100):
        '''
        '''
        DybPythonAlg.__init__(self,name)
        self.clhep = None
        self.root = None
        self.maximum = 100.0
        self.nrans = nrans
        return

    def initialize(self):
        sc = DybPythonAlg.initialize(self)
        if sc.isFailure(): return sc
        
        rndmsvc = self.svc('IRndmGenSvc','RndmGenSvc')
        assert rndmsvc.engine(), 'Good not get random engine from random svc'
        self.clhep = RandomEater(self.nrans,ClhepRandom(self.maximum,rndmsvc))
    
        self.root = RandomEater(self.nrans,RootRandom(self.maximum))

        return sc

    def execute(self):
        for n in range(self.nrans):
            self.clhep()
            self.root()
            continue

        self.clhep.clear()
        self.root.clear()
    
        return SUCCESS

    def finalize(self):
        assert 0 == self.root.check(),'ERROR, got bad ROOT randoms'
        assert 0 == self.clhep.check(),'ERROR, Got bad CLHEP randoms'

        return SUCCESS

        
def configure(argv=None):

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

    #from GaudiSvc.GaudiSvcConf import RndmGenSvc
    #rndSvc = RndmGenSvc()
    #rndSvc.Engine = 'HepRndm::Engine<HepRootRandom>'

    #rs.OutputLevel = 2

    return

def run(app):
    alg = EatRandom()
    app.addAlgorithm(alg)
    return

---