Collaboration diagram for LArG4ShowerLibFunctions.FCALDistEtaShowerLib:

Public Member Functions
	__init__ (self)
	scaleEnergy (self, scalefactor)
	truncate (self, truncate, nShowersMin=0)
	moveDist (self, oldDist, newDist)
	moveEta (self, oldEta, newEta)
	removeDist (self, dist)
	removeEta (self, eta)
	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 894 of file LArG4ShowerLibFunctions.py.

Constructor & Destructor Documentation

◆ init()

LArG4ShowerLibFunctions.FCALDistEtaShowerLib.__init__ ( self )

Definition at line 896 of file LArG4ShowerLibFunctions.py.

    def __init__(self) :
        self.library = {} # key (float) - eta, value (dict), key - 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.FCALDistEtaShowerLib.drawHits ( self )

Definition at line 1319 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)
 
        etas = sorted(self.library.keys())
        for eta in etas :
            dists = sorted(self.library[eta].keys())
            for distlow,disthigh in zip(dists,(dists[1:] + [4.5])) : #looping over eta bins
                for storedShower in self.library[eta][distlow] :
                    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.FCALDistEtaShowerLib.fromLibs	(		self,
			libs )

Definition at line 961 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
        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.xrod_cent != lib.xrod_cent or
                self.yrod_cent != lib.yrod_cent or
                self.step != lib.step or
                etas != set(lib.library.keys()) ) :
                print ("ERROR: DIFFERENT LIBS!!!")
                return False
            for eta in libs[0].library.keys() :
                if (set(libs[0].library[eta].keys()) != set(lib.library[eta].keys())) :
                    print ("ERROR: DIFFERENT LIBS!!!")
                    return False
        for lib in libs :
            for k,v in lib.library.items():
                    for ki,vi in v.items():
                        self.library.setdefault(k,dict()).setdefault(ki,set()).update(vi)
        for k,v in self.library.items():
                for ki,vi in v.items():
                    self.library[k][ki] = list(vi)
        return True

◆ moveDist()

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

Definition at line 937 of file LArG4ShowerLibFunctions.py.

    def moveDist(self,oldDist,newDist) :
        rez = False
        for eta,etabin in self.library.items():
            if (oldDist in etabin.keys()) :
                    etabin[newDist] = etabin.pop(oldDist)
                    rez=True
        return rez

◆ moveEta()

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

Definition at line 944 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.FCALDistEtaShowerLib.printInfo ( self )

Definition at line 1249 of file LArG4ShowerLibFunctions.py.

    def printInfo(self) :
        print ("VERSION: FCALDistEtaEnergyLib","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,3,4,5,10,20,50,100,200,500,1000]
        etas = sorted(self.library.keys())
        print ("Number of etabins:",str(len(etas)))
        fstot = 0
        for etabin in self.library.values():
            for distbin in etabin.values():
                fstot +=len(distbin)
        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 eta in etas :
            dists = sorted(self.library[eta].keys())
            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[eta][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(eta).rjust(10)  # | eta header
                infostr+= "|"                 # |\
                infostr2 = "|Hits"
                infostr2+= str(round(distlow,5)).rjust(7) # | eta header
                infostr2+= "|"                # |
                infostr3 = "|E/E"
                infostr3+= str(round(disthigh,3)).rjust(8) # | 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.FCALDistEtaShowerLib.readFromFile	(		self,
			filename )

Definition at line 1002 of file LArG4ShowerLibFunctions.py.

    def readFromFile(self,filename) :
        log = logging.getLogger("FCALDistEtaShowerLib::readFromFile()")
        from ROOT import TFile
        #from sets import Set
        tfile = TFile(filename)
        try:
            ver = int(tfile.Get("version").GetVal())
        except Exception:
            print ("Not an FCALDistEtaEnergyLib: Broken file")
            tfile.Close()
            return False
 
        if (ver != 5) : #<<<<<<<<<<<<<<<<<<<<<<-------------- lib ver
            print ("Not an FCALDistEtaEnergyLib")
            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
        lastEta = False
 
        log.debug("dector: %s", str(event.detector))
        log.debug("particle: %s", str(event.particle))
        log.debug("release: %s", str(event.release))
        log.debug("geometry: %s", str(event.geometry))
        log.debug("geant ver: %s", str(event.geantVersion))
        log.debug("physList: %s", str(event.physicsList))
        log.debug("comment: %s", str(event.comment))
 
        for event in libr : #this is quite unclear, but easy to implement, we change the "state" depending on what we are reading
            log.debug("-------")
            log.debug("x=%f, y=%f, z=%f, e=%f",event.x,event.y,event.z,event.e)
            log.debug("beginnnig ev loop. lastShower: %s",str(lastShower))
            log.debug("beginnnig ev loop. state: %s",str(state))
 
            if   (state == -1) : #library header (calculator parameters)
                log.debug("in state=-1")
 
                self.xrod_cent = event.x
                self.yrod_cent = event.y
                self.step = event.z
                state = 0
            elif (state == 0) : #eta bin header
                log.debug("in state=0")
                log.debug("x=distsInCurEta, y=curEta")
 
                distsInCurEta = event.x
                curEta = round(event.y,4)
                self.library[curEta] = {}
                if (distsInCurEta > 0) :
                    state = 1 #go to dist header
            elif (state == 1) :
                log.debug("in state=1")
                log.debug("x=showersInCurDist, y=curDist")
 
                showersInCurDist = event.x
                curDist = round(event.y,4)
                self.library[curEta][curDist] = []
                distsInCurEta -= 1
                if (distsInCurEta == 0) :
                    lastEta = True
                if (showersInCurDist > 0) :
                    state = 2 #go to shower header
                else : #empty dist bin
                    if (lastEta) : #special case of last eta bin being the empty one
                        lastEta = False
                        state = 0
            elif (state == 2) :
                # writing shower info
                log.debug("in state=2")
                log.debug("x=hitsInCurShower, y=curShower.rSize, z=curShower.zSize, e=curShower.genEnergy")
 
                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 = 3 #go to hits
                else : #empty shower
                    log.debug("Appending shower to lib pos %s %s",curEta,curDist)
 
                    self.library[curEta][curDist].append(curShower)
                    if (lastShower) : #special case of last shower in bin being the empty one
                        lastShower = False
                        if (lastEta) : #double special case: last shower in last eta bin is empty
                            lastEta = False
                            state = 0 #next eta bin
                        else :
                            state = 1 #next dist bin
            elif (state == 3) :
                
                log.debug("in state=3")
                log.debug("x=hit.x, y=hit.y, z=hit.z, e=hit.e")
 
                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
                    log.debug("Appending shower+hit to lib pos %s %s",curEta,curDist)
 
                    self.library[curEta][curDist].append(curShower)
                    if (lastShower) : # end of dist bin
                        lastShower = False
                        if (lastEta) : #end of eta bin as well
                            lastEta = False
                            state = 0 #next eta bin
                        else :
                            state = 1 #next dist bin
                    else : #not yet
                        state = 2
 
            log.debug("ending ev loop. lastShower: %s", lastShower)
            log.debug("ending ev loop. state %s", state)
            if log.root.level == logging.DEBUG:
                input("Continue? Press Enter.")
 
        tfile.Close()
        if (state != 0) : #the last entry should be the last hit of the last shower in the last bin. if not - file is corrupted
            print ("FILE CORRUPTED!!")
            return False
        return True

◆ removeDist()

LArG4ShowerLibFunctions.FCALDistEtaShowerLib.removeDist	(		self,
			dist )

Definition at line 949 of file LArG4ShowerLibFunctions.py.

    def removeDist(self,dist) :
        rez = False
        for eta,etabin in self.library.items():
            if (dist in etabin.keys()) :
                    self.library.pop(dist)
                    rez=True
        return rez

◆ removeEta()

LArG4ShowerLibFunctions.FCALDistEtaShowerLib.removeEta	(		self,
			eta )

Definition at line 956 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.FCALDistEtaShowerLib.scaleEnergy	(		self,
			scalefactor )

Definition at line 908 of file LArG4ShowerLibFunctions.py.

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

◆ truncate()

LArG4ShowerLibFunctions.FCALDistEtaShowerLib.truncate	(	self,
		truncate,
		nShowersMin = 0 )

Definition at line 915 of file LArG4ShowerLibFunctions.py.

    def truncate(self,truncate,nShowersMin=0) :
        log = logging.getLogger("FCALDistEtaShowerLib::truncate()")
        showers = []
        for eta,etabin in self.library.items():
            for dist,distbin in etabin.items():
                log.info("Number of showers in %s %s is %d",str(eta),str(dist),len(distbin))
                for storedShower in distbin :
                    showers += [(eta, dist, storedShower)]
        log.info("total number of showers: %d", len(showers))
        if nShowersMin:
            log.info("will not remove from eta-dist bins with less then %d showers", nShowersMin)
        if len(showers) <= truncate :
            log.warning("Size of the library is already less: %d < %d",truncate,len(showers))
            return
        from random import randint
        while (len(showers) > truncate) :
            rand = randint(0,len(showers)-1)
            if len(self.library[showers[rand][0]][showers[rand][1]]) < nShowersMin:
                continue
            self.library[showers[rand][0]][showers[rand][1]].remove(showers[rand][2])
            del showers[rand]
        return

◆ writeToFile()

LArG4ShowerLibFunctions.FCALDistEtaShowerLib.writeToFile	(		self,
			filename )

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