Collaboration diagram for LArG4ShowerLibFunctions.FCALDistShowerLib:

Public Member Functions
	__init__ (self)
	scaleEnergy (self, scalefactor)
	truncate (self, truncate)
	moveDist (self, oldDist, newDist)
	removeDist (self, dist)
	fromLibs (self, libs)
	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 = ""
float	xrod_cent = 0.0
float	yrod_cent = 0.0
float	step = 0.0

Private Attributes
	__class__

Detailed Description

Definition at line 558 of file LArG4ShowerLibFunctions.py.

Constructor & Destructor Documentation

◆ init()

LArG4ShowerLibFunctions.FCALDistShowerLib.__init__ ( self )

Definition at line 559 of file LArG4ShowerLibFunctions.py.

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

Member Function Documentation

◆ drawHits()

LArG4ShowerLibFunctions.FCALDistShowerLib.drawHits ( self )

Definition at line 879 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 distbin in self.library.values():
            for storedShower in distbin :
                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.FCALDistShowerLib.fromLibs	(		self,
			libs )

Definition at line 601 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.comment = libs[0].comment
        self.xrod_cent = libs[0].xrod_cent
        self.yrod_cent = libs[0].yrod_cent
        self.step = libs[0].step
        dists = 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.xrod_cent != lib.xrod_cent or
                self.yrod_cent != lib.yrod_cent or
                self.step != lib.step or
                dists != 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

◆ moveDist()

LArG4ShowerLibFunctions.FCALDistShowerLib.moveDist	(	self,
		oldDist,
		newDist )

Definition at line 591 of file LArG4ShowerLibFunctions.py.

    def moveDist(self,oldDist,newDist) :
        if not (oldDist in self.library.keys()) :
            return False
        self.library[newDist] = self.library.pop(oldDist)
        return True

◆ printInfo()

LArG4ShowerLibFunctions.FCALDistShowerLib.printInfo ( self )

Definition at line 812 of file LArG4ShowerLibFunctions.py.

    def printInfo(self) :
        print ("VERSION: FCALDistEnergyLib","PARTICLE:",self.particle,"DETECTOR:",self.detector)
        print (self.release, self.geometry, self.geant, self.phys)
        print ("xrodcent:",self.xrod_cent,"yrodcent:",self.yrod_cent,"step:",self.step)
        print (self.comment)
        ebins = [1,2,5,10,20,50,100,200,500,1000]
        dists = sorted(self.library.keys())
        print ("Number of etabins:",str(len(dists)))
        fstot = 0
        for dist in dists :
            fstot +=len(self.library[dist])
        print ("Number of showers:",str(fstot))
        print ("-"*(13+len(ebins)*8)) #horizontal line
        infostr = "|dists|ebins|"
        for ebin in ebins : #header for energy bins
            infostr += ("<%d" %ebin).rjust(7)                         #str(ebin).rjust(7)
            infostr += "|"
        print (infostr)
        print ("-"*(13+len(ebins)*8)) #horizontal line
        for distlow,disthigh in zip(dists,(dists[1:] + [4.5])) : #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[distlow] :
                    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(distlow,5)).rjust(10) # | eta header
            infostr+= "|"                # |\
            infostr2 = "|Hits"
            infostr2+= str(round(disthigh,3)).rjust(7) # | eta header
            infostr2+= "|"                # |
            infostr3 = "|ErecEgen"
            infostr3+= " ".rjust(3) # | 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.FCALDistShowerLib.readFromFile	(		self,
			filename )

Definition at line 636 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 FCALDistEnergyLib: Broken file")
            tfile.Close()
            return False
        if (ver != 4) : #<<<<<<<<<<<<<<<<<<<<<<-------------- lib ver
            print ("Not an FCALDistEnergyLib")
            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 = -1
        lastShower = False
 
        for event in libr : #this is quite unclear, but easy to implement
            if   (state == -1) : #library header (calculator parameters)
                self.xrod_cent = event.x
                self.yrod_cent = event.y
                self.step = event.z
                state = 0
            elif (state == 0) : #eta bin header
                showersInCurDist = event.x
                curDist = round(event.y,4)
                self.library[curDist] = []
                if (showersInCurDist > 0) :
                    state = 1 #go to shower header
            elif (state == 1) : #shower header
                hitsInCurShower = event.x
                rSize = event.y
                zSize = event.z
                genEnergy = event.e
                showersInCurDist -= 1
                if (showersInCurDist == 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[curDist].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[curDist].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

◆ removeDist()

LArG4ShowerLibFunctions.FCALDistShowerLib.removeDist	(		self,
			dist )

Definition at line 596 of file LArG4ShowerLibFunctions.py.

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

◆ scaleEnergy()

LArG4ShowerLibFunctions.FCALDistShowerLib.scaleEnergy	(		self,
			scalefactor )

Definition at line 571 of file LArG4ShowerLibFunctions.py.

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

◆ truncate()

LArG4ShowerLibFunctions.FCALDistShowerLib.truncate	(		self,
			truncate )

Definition at line 577 of file LArG4ShowerLibFunctions.py.

    def truncate(self,truncate) :
        showers = []
        for dist,distbin in self.library.items():
            for storedShower in distbin :
                showers += [(dist,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.FCALDistShowerLib.writeToFile	(		self,
			filename )

Definition at line 718 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",4) #<<<<<<<<<<<<<<<<<<<<<<-------------- 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")
 
        mstruct.x = self.xrod_cent
        mstruct.y = self.yrod_cent
        mstruct.z = self.step
        mstruct.e = 0
        mstruct.time = 0
        libr.Fill()
 
        dists = sorted(self.library.keys())
 
        for dist in dists :
            mstruct.x = len(self.library[dist])
            mstruct.y = dist
            mstruct.z = 0
            mstruct.e = 0
            mstruct.time = 0
            libr.Fill()
            self.library[dist].sort(key=lambda x: x.egen)
            for storedShower in self.library[dist] :
                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()