Collaboration diagram for LArG4ShowerLibFunctions.EtaEnergyShowerLib:

Public Member Functions
def	__init__ (self)

def	scaleEnergy (self, scalefactor)

def	truncate (self, truncate)

def	fromLibs (self, libs)

def	moveEta (self, oldEta, newEta)

def	removeEta (self, eta)

def	readFromFile (self, filename)

def	writeToFile (self, filename)

def	printInfo (self)

def	drawHits (self)

Public Attributes
	library

	detector

	particle

	release

	geometry

	geant

	phys

	comment

	mineta

	maxeta

Detailed Description

Definition at line 236 of file LArG4ShowerLibFunctions.py.

Constructor & Destructor Documentation

◆ init()

def 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()

def 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()

def 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()

def 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()

def 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()

def 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()

def 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()

def 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()

def 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()

def 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()