Collaboration diagram for LArG4ShowerLibFunctions.EtaEnergyShowerLib:

Public Member Functions
	__init__ (self)
	scaleEnergy (self, scalefactor)
	truncate (self, truncate)
	fromLibs (self, libs)
	moveEta (self, oldEta, newEta)
	removeEta (self, eta)
	readFromFile (self, filename)
	writeToFile (self, filename)
	printInfo (self)
	drawHits (self)

Public Attributes
dict	library = {}
str	detector = ""
str	particle = ""
str	release = ""
str	geometry = ""
str	geant = ""
str	phys = ""
str	comment = ""
	mineta = libs[0].mineta
	maxeta = libs[0].maxeta

Private Attributes
	__class__

Detailed Description

Definition at line 236 of file LArG4ShowerLibFunctions.py.

Constructor & Destructor Documentation

◆ init()

LArG4ShowerLibFunctions.EtaEnergyShowerLib.__init__ ( self )

Definition at line 237 of file LArG4ShowerLibFunctions.py.

    def __init__(self) :
        self.library = {} # key (float) - eta, value (list) - list of StoredEnergyShower objs
        self.detector= ""
        self.particle= ""
        self.release= ""
        self.geometry= ""
        self.geant= ""
        self.phys= ""
        self.comment= ""

Member Function Documentation

◆ drawHits()

LArG4ShowerLibFunctions.EtaEnergyShowerLib.drawHits ( self )

Definition at line 543 of file LArG4ShowerLibFunctions.py.

    def drawHits(self):
        from ROOT import TH3F
        from math import sqrt,copysign,log10
        hits = TH3F("HITS","Hits Distrib",50,1,1000,101,-300,300,100,0,500)
        containmentZ = TH3F("CONTZ","ContZ Distrib",50,1,1000,101,-300,300,100,0,500)
        containmentR = TH3F("CONTR","ContR Distrib",50,1,1000,101,-300,300,100,0,500)
        for etabin in self.library.values():
            for storedShower in etabin :
                containmentR.Fill(log10(storedShower.egen)*333,storedShower.rsize,storedShower.zsize,10)
                containmentR.Fill(log10(storedShower.egen)*333,-storedShower.rsize,storedShower.zsize,10)
                containmentZ.Fill(log10(storedShower.egen)*333,0,storedShower.zsize,10)
                for hit in storedShower.shower :
                    hits.Fill(log10(storedShower.egen)*333,copysign(sqrt(hit.x*hit.x + hit.y*hit.y),hit.x),hit.z)
        return hits,containmentZ,containmentR
 

◆ fromLibs()

LArG4ShowerLibFunctions.EtaEnergyShowerLib.fromLibs	(		self,
			libs )

Definition at line 266 of file LArG4ShowerLibFunctions.py.

    def fromLibs(self,libs) :
        for lib in libs :
            if not isinstance(lib,self.__class__):
                print ("ERROR: Different types of libs")
                return False
        self.detector = libs[0].detector
        self.particle = libs[0].particle
        self.release = libs[0].release
        self.geometry = libs[0].geometry
        self.geant = libs[0].geant
        self.phys = libs[0].phys
        self.mineta = libs[0].mineta
        self.maxeta = libs[0].maxeta
        self.comment = libs[0].comment
        etas = set(libs[0].library.keys())
        for lib in libs :
            if (    self.detector != lib.detector or
                self.particle != lib.particle or
                self.release != lib.release or
                self.geometry != lib.geometry or
                self.geant != lib.geant or
                self.phys != lib.phys or
                self.mineta != lib.mineta or
                self.maxeta != lib.maxeta or
                etas != set(lib.library.keys()) ) :
                print ("ERROR: DIFFERENT LIBS!!!")
                return False
        for lib in libs :
            for k,v in lib.library.items():
                self.library.setdefault(k,set()).update(v)
        for k,v in self.library.items():
            self.library[k] = list(v)
        return True

◆ moveEta()

LArG4ShowerLibFunctions.EtaEnergyShowerLib.moveEta	(	self,
		oldEta,
		newEta )

Definition at line 299 of file LArG4ShowerLibFunctions.py.

    def moveEta(self,oldEta,newEta) :
        if not (oldEta in self.library.keys()) :
            return False
        self.library[newEta] = self.library.pop(oldEta)
        return True

◆ printInfo()

LArG4ShowerLibFunctions.EtaEnergyShowerLib.printInfo ( self )

Definition at line 476 of file LArG4ShowerLibFunctions.py.

    def printInfo(self) :
        print ("VERSION: EtaEnergyLib","PARTICLE:",self.particle,"DETECTOR:",self.detector)
        print (self.release, self.geometry, self.geant, self.phys)
        print (self.comment)
        ebins = [1,2,5,10,20,50,100,200,500,1000]
        etas = sorted(self.library.keys())
        print ("Number of etabins:",str(len(etas)))
        print ("MinEta:",self.mineta,"MaxEta:",self.maxeta)
        fstot = 0
        for eta in etas :
            fstot +=len(self.library[eta])
        print ("Number of showers:",str(fstot))
        print ("-"*(12+len(ebins)*8)) #horizontal line
        infostr = "|etas|ebins|"
        for ebin in ebins : #header for energy bins
            infostr += ("<%d" %ebin).rjust(7)                         #str(ebin).rjust(7)
            infostr += "|"
        print (infostr)
        print ("-"*(12+len(ebins)*8)) #horizontal line
        for etalow,etahigh in zip(etas,(etas[1:] + [self.maxeta])) : #looping over eta bins
            prevebin = 0
            erec = {}
            egen = {}
            hits = {}
            count = {}
            for ebin in ebins : # for all energy bins
                count[ebin] = 0
                erec[ebin] = 0.
                egen[ebin] = 0.
                hits[ebin] = 0.
                for shower in self.library[etalow] :
                    if (shower.egen <= ebin) and (shower.egen > prevebin) :
                        count[ebin] += 1
                        egenshow = shower.egen
                        erecshow = 0
                        for hit in shower.shower :
                            erecshow += hit.e
                        erec[ebin] += erecshow
                        egen[ebin] += egenshow
                        hits[ebin] += len(shower.shower)
                if (count[ebin] > 0) :
                    hits[ebin] /= count[ebin]
                prevebin = ebin
            infostr = "|#"                # |
            infostr+= str(round(etalow,5)).rjust(9) # | eta header
            infostr+= "|"                # |\
            infostr2 = "|Hits"
            infostr2+= str(round(etahigh,3)).rjust(6) # | eta header
            infostr2+= "|"                # |
            infostr3 = "|ErecEgen"
            infostr3+= " ".rjust(2) # | eta header
            infostr3+= "|"                # |
            for ebin in ebins :
                infostr+= str(count[ebin]).rjust(7) #print the number of showers
                if (egen[ebin] > 0) :
                    infostr2+= ("%.2f" %(hits[ebin])).rjust(7)
                    infostr3+= ("%.5f" %(erec[ebin]/egen[ebin])).rjust(7)
                else :
                    infostr2+= ("%.2f" %(hits[ebin])).rjust(7)
                    infostr3+= "0.0".rjust(7) #else print "xxx"
                infostr+="|"
                infostr2+="|"
                infostr3+="|"
            print (infostr)
            print (infostr2)
            print (infostr3)
            print ("-"*(12+len(ebins)*8)) #horizontal line

◆ readFromFile()

LArG4ShowerLibFunctions.EtaEnergyShowerLib.readFromFile	(		self,
			filename )

Definition at line 309 of file LArG4ShowerLibFunctions.py.

    def readFromFile(self,filename) :
        from ROOT import TFile
        #from sets import Set
        tfile = TFile(filename)
        try:
            ver = int(tfile.Get("version").GetVal())
        except Exception:
            print ("Not an EtaEnergyLib: Broken file")
            tfile.Close()
            return False
 
        if (ver != 1) : #<<<<<<<<<<<<<<<<<<<<<<-------------- lib ver
            print ("Not an EtaEnergyLib")
            tfile.Close()
            return False
        meta = tfile.Get("meta")
        libr = tfile.Get("library")
 
        for event in meta :
            self.detector=str(event.detector)
            self.particle=str(event.particle)
            self.release=str(event.release)
            self.geometry=str(event.geometry)
            self.geant=str(event.geantVersion)
            self.phys=str(event.physicsList)
            self.comment=str(event.comment)
 
        state = 0
        lastShower = False
 
        for event in libr : #this is quite unclear, but easy to implement
            if   (state == 0) : #eta bin header
                showersInCurEta = event.x
                curEta = round(event.y,4)
                self.mineta = event.z
                self.maxeta = event.e
                self.library[curEta] = []
                if (showersInCurEta > 0) :
                    state = 1 #go to shower header
            elif (state == 1) : #shower header
                hitsInCurShower = event.x
                rSize = event.y
                zSize = event.z
                genEnergy = event.e
                showersInCurEta -= 1
                if (showersInCurEta == 0) : #last shower
                    lastShower = True
                curShower = StoredEnergyShower()
                curShower.egen = genEnergy
                curShower.rsize = rSize
                curShower.zsize = zSize
                #curShower["hits"] = []
                if (hitsInCurShower > 0) :
                    state = 2 #go to hits
                else : #empty shower
                    self.library[curEta].append(curShower)
                    if (lastShower) : #special case of last shower in bin being the empty one
                        lastShower = False
                        state = 0 #next bin
            elif (state == 2) :
                hit = FourVector()
                hit.e = event.e
                hit.x = event.x
                hit.y = event.y
                hit.z = event.z
                hit.time = event.time
                curShower.shower.append(hit)
                hitsInCurShower -= 1
                if (hitsInCurShower == 0) : #last hit
                    self.library[curEta].append(curShower)
                    if (lastShower) : # end of eta bin
                        lastShower = False
                        state = 0
                    else : #not yet
                        state = 1
        tfile.Close()
        if (state != 0) :
            print ("FILE CORRUPTED!!")
            return False
        return True

◆ removeEta()

LArG4ShowerLibFunctions.EtaEnergyShowerLib.removeEta	(		self,
			eta )

Definition at line 304 of file LArG4ShowerLibFunctions.py.

    def removeEta(self,eta) :
        if not (eta in self.library.keys()) :
            return False
        self.library.pop(eta)
        return True

◆ scaleEnergy()

LArG4ShowerLibFunctions.EtaEnergyShowerLib.scaleEnergy	(		self,
			scalefactor )

Definition at line 246 of file LArG4ShowerLibFunctions.py.

    def scaleEnergy(self,scalefactor) :
        for etabin in self.library.values():
            for storedShower in etabin :
                for hit in storedShower.shower :
                    hit.e *= scalefactor
        self.comment += " SCALED: "+str(scalefactor)

◆ truncate()

LArG4ShowerLibFunctions.EtaEnergyShowerLib.truncate	(		self,
			truncate )

Definition at line 252 of file LArG4ShowerLibFunctions.py.

    def truncate(self,truncate) :
        showers = []
        for eta,etabin in self.library.items():
            for storedShower in etabin :
                showers += [(eta,storedShower)]
        if len(showers) <= truncate :
            print ("WARNING: Size of the library is already less:",truncate,"<",len(showers))
            return
        from random import randint
        while (len(showers) > truncate) :
            rand = randint(0,len(showers)-1)
            self.library[showers[rand][0]].remove(showers[rand][1])
            del showers[rand]
        return

◆ writeToFile()

LArG4ShowerLibFunctions.EtaEnergyShowerLib.writeToFile	(		self,
			filename )

Definition at line 389 of file LArG4ShowerLibFunctions.py.

    def writeToFile(self,filename) :
        from ROOT import TFile,TTree,TParameter
        from ROOT import gROOT, addressof
        gROOT.ProcessLine(
            "struct MyMetaStruct {\
            Char_t   detector[40];\
            Char_t   release[40];\
            Char_t   geometry[40];\
            Char_t   geant[40];\
            Char_t   phys[40];\
            Char_t   comment[400];\
            Int_t    particle;\
        };" )
        from ROOT import MyMetaStruct
        gROOT.ProcessLine(
            "struct MyStruct {\
            Float_t   x;\
            Float_t   y;\
            Float_t   z;\
            Float_t   e;\
            Float_t   time;\
        };" )
        from ROOT import MyStruct
 
        tfile = TFile(filename,"RECREATE")
 
        ver = TParameter(int)("version",1) #<<<<<<<<<<<<<<<<<<<<<<-------------- lib ver
        ver.Write("version")
 
        meta = TTree()
        libr = TTree()
 
        mmstruct = MyMetaStruct()
 
        mmstruct.detector = "%s" % (str(self.detector))
        mmstruct.particle = int(self.particle)
        mmstruct.release = "%s" % (str(self.release))
        mmstruct.geometry = "%s" % (str(self.geometry))
        mmstruct.geant = "%s" % (str(self.geant))
        mmstruct.phys = "%s" % (str(self.phys))
        mmstruct.comment = "%s" % (str(self.comment))
 
        meta.Branch("detector",addressof(mmstruct,"detector"),"detector/C")
        meta.Branch("particle",addressof(mmstruct,"particle"),"particle/I")
        meta.Branch("release",addressof(mmstruct,"release"),"release/C")
        meta.Branch("geometry",addressof(mmstruct,"geometry"),"geometry/C")
        meta.Branch("geantVersion",addressof(mmstruct,"geant"),"geantVersion/C")
        meta.Branch("physicsList",addressof(mmstruct,"phys"),"physicsList/C")
        meta.Branch("comment",addressof(mmstruct,"comment"),"physicsList/C")
 
        meta.Fill()
 
        mstruct = MyStruct()
 
        libr.Branch("x",addressof(mstruct,"x"),"x/F")
        libr.Branch("y",addressof(mstruct,"y"),"y/F")
        libr.Branch("z",addressof(mstruct,"z"),"z/F")
        libr.Branch("e",addressof(mstruct,"e"),"e/F")
        libr.Branch("time",addressof(mstruct,"time"),"time/F")
 
        etas = self.library.keys()
 
        for eta in sorted(etas) :
            mstruct.x = len(self.library[eta])
            mstruct.y = eta
            mstruct.z = self.mineta
            mstruct.e = self.maxeta
            mstruct.time = 0
            libr.Fill()
            self.library[eta].sort(key=lambda x: x.egen)
            for storedShower in self.library[eta] :
                mstruct.x = len(storedShower.shower)
                mstruct.y = storedShower.rsize
                mstruct.z = storedShower.zsize
                mstruct.e = storedShower.egen
                mstruct.time = 0
                libr.Fill()
                for hit in storedShower.shower:
                    mstruct.e = hit.e
                    mstruct.x = hit.x
                    mstruct.y = hit.y
                    mstruct.z = hit.z
                    mstruct.time = hit.time
                    libr.Fill()
        meta.Write("meta")
        libr.Write("library")
        tfile.Close()