def readIso(self, n):
"""Read detector det data structure"""
#print "self.nisomers:", self.nisomers
if self.nisomers < 0: return None
f = open(self.file, "rb")
fortran.skip(f)
if self.evol:
fortran.skip(f)
for _ in range(n):
fortran.skip(f) # Detector Header & Data
if self.evol:
fortran.skip(f) # TDecay
fortran.skip(f) # Detector data
if self.nisomers:
fortran.skip(f) # Isomers header
fortran.skip(f) # Isomers data
fortran.skip(f)
if self.evol:
fortran.skip(f) # TDecay
fortran.skip(f) # Detector data
isohead = fortran.read(f) # Isomers header
data = fortran.read(f) # Isomers data
#print "isohead:",len(isohead)
#header = struct.unpack("=10xi", isohead)
#print "isohead:",header[0]
f.close()
return (isohead, data)
def readIso(self, n):
"""Read detector det data structure"""
#print "self.nisomers:", self.nisomers
if self.nisomers < 0: return None
f = open(self.file, "rb")
fortran.skip(f)
if self.evol:
fortran.skip(f)
for i in range(n):
fortran.skip(f) # Detector Header & Data
if self.evol:
fortran.skip(f) # TDecay
fortran.skip(f) # Detector data
if self.nisomers:
fortran.skip(f) # Isomers header
fortran.skip(f) # Isomers data
fortran.skip(f)
if self.evol:
fortran.skip(f) # TDecay
fortran.skip(f) # Detector data
isohead = fortran.read(f) # Isomers header
data = fortran.read(f) # Isomers data
#print "isohead:",len(isohead)
header = struct.unpack("=10xi", isohead)
#print "isohead:",header[0]
f.close()
return (isohead, data)
def readHeader(self, filename):
""" Reads the file header info
Based on Data.Usrbdx
"""
f = Data.Usrxxx.readHeader(self, filename)
# self.sayHeader()
while True:
data = fortran.read(f)
if data is None: break
size = len(data)
# print("size: ", size)
if size == 14 and data.decode('utf8')[:10] == "STATISTICS":
self.statpos = f.tell()
for det in self.detector:
data = Data.unpackArray(fortran.read(f))
det.total = data[0]
det.totalerror = data[1]
# for j in range(6):
# fortran.skip(f)
break
if size != 50:
raise IOError("Invalid USRTRACK/USRCOLL file %d " % size)
header = struct.unpack("=i10siiififfif", data)
det = Data.Detector()
det.nb = header[0]
det.name = header[1].decode(
'utf8').strip() # titutc - track/coll name
det.type = header[
2] # itustc - type of binning: 1 - linear energy etc
det.dist = header[3] # idustc = distribution to be scored
det.reg = header[4] # nrustc = region
det.volume = header[5] # vusrtc = volume (cm**3) of the detector
det.lowneu = header[6] # llnutc = low energy neutron flag
det.elow = header[7] # etclow = minimum energy [GeV]
det.ehigh = header[8] # etchgh = maximum energy [GeV]
det.ne = header[9] # netcbn = number of energy intervals
det.de = header[10] # detcbn = energy bin width
self.detector.append(det)
if det.lowneu:
data = fortran.read(f)
det.ngroup = struct.unpack("=i", data[:4])[0]
det.egroup = struct.unpack("=%df" % (det.ngroup + 1), data[4:])
print("Low energy neutrons scored with %d groups" % det.ngroup)
else:
det.ngroup = 0
det.egroup = []
size = (det.ngroup + det.ne) * 4
if size != fortran.skip(f):
raise IOError("Invalid USRTRACK file")
f.close()
def readHeader(self, filename):
""" Reads the file header info
Based on Data.Usrbdx
"""
f = Data.Usrxxx.readHeader(self, filename)
# self.sayHeader()
while True:
data = fortran.read(f)
if data is None: break
size = len(data)
# print("size: ", size)
if size == 14 and data[:10] == "STATISTICS":
self.statpos = f.tell()
for det in self.detector:
data = Data.unpackArray(fortran.read(f))
det.total = data[0]
det.totalerror = data[1]
# for j in range(6):
# fortran.skip(f)
break
if size != 50: raise IOError("Invalid USRTRACK/USRCOLL file")
header = struct.unpack("=i10siiififfif", data)
det = Data.Detector()
det.nb = header[0]
det.name = header[1].strip() # titutc - track/coll name
det.type = header[2] # itustc - type of binning: 1 - linear energy etc
det.dist = header[3] # idustc = distribution to be scored
det.reg = header[4] # nrustc = region
det.volume = header[5] # vusrtc = volume (cm**3) of the detector
det.lowneu = header[6] # llnutc = low energy neutron flag
det.elow = header[7] # etclow = minimum energy [GeV]
det.ehigh = header[8] # etchgh = maximum energy [GeV]
det.ne = header[9] # netcbn = number of energy intervals
det.de = header[10] # detcbn = energy bin width
self.detector.append(det)
if det.lowneu:
data = fortran.read(f)
det.ngroup = struct.unpack("=i",data[:4])[0]
det.egroup = struct.unpack("=%df"%(det.ngroup+1), data[4:])
print("Low energy neutrons scored with %d groups" % det.ngroup)
else:
det.ngroup = 0
det.egroup = []
size = (det.ngroup+det.ne) * 4
if size != fortran.skip(f):
raise IOError("Invalid USRTRACK file")
f.close()
def readEvent(self, type=None):
# Read header
data = fortran.read(self.hnd)
if data is None: return None
if len(data) == 20:
ndum, mdum, jdum, edum, wdum \
= struct.unpack("=iiiff", data)
else:
raise IOError("Invalid MGREAD file")
self.nevent += 1
if ndum > 0:
if type is None or type == 0:
self.readTracking(ndum, mdum, jdum, edum, wdum)
else:
fortran.skip(self.hnd)
return 0
elif ndum == 0:
if type is None or type == 1:
self.readEnergy(mdum, jdum, edum, wdum)
else:
fortran.skip(self.hnd)
return 1
else:
if type is None or type == 2:
self.readSource(-ndum, mdum, jdum, edum, wdum)
else:
fortran.skip(self.hnd)
return 2
def readEvent(self, typeid=None):
# Read header
data = fortran.read(self.hnd)
if data is None: return None
if len(data) == 20:
ndum, mdum, jdum, edum, wdum \
= struct.unpack("=iiiff", data)
else:
raise IOError("Invalid MGREAD file")
self.nevent += 1
if ndum > 0:
if typeid is None or typeid == 0:
self.readTracking(ndum, mdum, jdum, edum, wdum)
else:
fortran.skip(self.hnd)
return 0
elif ndum == 0:
if typeid is None or typeid == 1:
self.readEnergy(mdum, jdum, edum, wdum)
else:
fortran.skip(self.hnd)
return 1
else:
if typeid is None or typeid == 2:
self.readSource(-ndum, mdum, jdum, edum, wdum)
else:
fortran.skip(self.hnd)
return 2
def readStat(self, n): """Read detector det statistical data""" if self.statpos < 0: return None f = open(self.file,"rb") f.seek(self.statpos) f.seek(self.statpos) if self.nisomers: nskip = 7*n else: nskip = 6*n for i in range(nskip): fortran.skip(f) # Detector Data total = fortran.read(f) A = fortran.read(f) errA = fortran.read(f) Z = fortran.read(f) errZ = fortran.read(f) data = fortran.read(f) if self.nisomers: iso = fortran.read(f) else: iso = None f.close() return (total, A, errA, Z, errZ, data, iso)
def readStat(self, n):
"""Read n(th) detector statistical data"""
if self.statpos < 0: return None
f = open(self.file, "rb")
f.seek(self.statpos)
f.seek(self.statpos)
if self.nisomers:
nskip = 7 * n
else:
nskip = 6 * n
for _ in range(nskip):
fortran.skip(f) # Detector Data
total = fortran.read(f)
A = fortran.read(f)
errA = fortran.read(f)
Z = fortran.read(f)
errZ = fortran.read(f)
data = fortran.read(f)
if self.nisomers:
iso = fortran.read(f)
else:
iso = None
f.close()
return (total, A, errA, Z, errZ, data, iso)
def readStat(self, det,lowneu): """ Read detector # det statistical data """ if self.statpos < 0: return None with open(self.file,"rb") as f: f.seek(self.statpos) for i in range(det+3): # check that 3 gives correct errors with 1 USRTRACK detector fortran.skip(f) # skip previous detectors data = fortran.read(f) return data
def readEnergy(self, icode, jtrack, etrack, wtrack):
self.icode = icode
self.jtrack = jtrack
self.etrack = etrack
self.wtrack = wtrack
data = fortran.read(self.hnd)
if data is None: raise IOError("Invalid energy deposition event")
self.data = struct.unpack("=4f", data)
return icode
def readEnergy(self, icode, jtrack, etrack, wtrack):
self.icode = icode
self.jtrack = jtrack
self.etrack = etrack
self.wtrack = wtrack
data = fortran.read(self.hnd)
if data is None: raise IOError("Invalid energy deposition event")
self.data = struct.unpack("=4f", data)
return icode
def readData(self, n):
"""Read n(th) detector data structure"""
f = open(self.file, "rb")
fortran.skip(f) # Skip header
for _ in range(2 * n):
fortran.skip(f) # Detector Header & Data
fortran.skip(f) # Detector Header
data = fortran.read(f)
f.close()
return data
def readData(self, det): """Read detector det data structure""" f = open(self.file,"rb") fortran.skip(f) # Skip header for i in range(2*det): fortran.skip(f) # Detector Header & Data fortran.skip(f) # Detector Header data = fortran.read(f) f.close() return data
def readStat(self, n): """Read detector n statistical data""" if self.statpos < 0: return None f = open(self.file,"rb") f.seek(self.statpos) for i in range(n): fortran.skip(f) # Detector Data data = fortran.read(f) f.close() return data
def readStat(self, n):
"""Read n(th) detector statistical data"""
if self.statpos < 0: return None
f = open(self.file, "rb")
f.seek(self.statpos)
for _ in range(n):
fortran.skip(f) # Detector Data
data = fortran.read(f)
f.close()
return data
def readTracking(self, ntrack, mtrack, jtrack, etrack, wtrack):
self.ntrack = ntrack
self.mtrack = mtrack
self.jtrack = jtrack
self.etrack = etrack
self.wtrack = wtrack
data = fortran.read(self.hnd)
if data is None: raise IOError("Invalid track event")
fmt = "=%df" % (3 * (ntrack + 1) + mtrack + 1)
self.data = struct.unpack(fmt, data)
return ntrack
def readData(self, n):
"""Read detector det data structure"""
f = open(self.file, "rb")
fortran.skip(f)
for i in range(n):
fortran.skip(f) # Detector Header
fortran.skip(f) # Detector data
fortran.skip(f) # Detector Header
data = fortran.read(f) # Detector data
f.close()
return data
def readStat(self, det, lowneu):
""" Read detector # det statistical data """
if self.statpos < 0: return None
with open(self.file, "rb") as f:
f.seek(self.statpos)
for i in range(
det + 3
): # check that 3 gives correct errors with 1 USRTRACK detector
fortran.skip(f) # skip previous detectors
data = fortran.read(f)
return data
def readTracking(self, ntrack, mtrack, jtrack, etrack, wtrack):
self.ntrack = ntrack
self.mtrack = mtrack
self.jtrack = jtrack
self.etrack = etrack
self.wtrack = wtrack
data = fortran.read(self.hnd)
if data is None: raise IOError("Invalid track event")
fmt = "=%df" % (3*(ntrack+1) + mtrack + 1)
self.data = struct.unpack(fmt, data)
return ntrack
def readSource(self, ncase, npflka, nstmax, tkesum, weipri):
self.ncase = ncase
self.npflka = npflka
self.nstmax = nstmax
self.tkesum = tkesum
self.weipri = weipri
data = fortran.read(self.hnd)
if data is None: raise IOError("Invalid source event")
fmt = "=" + ("i8f" * npflka)
self.data = struct.unpack(fmt, data)
return ncase
def readSource(self, ncase, npflka, nstmax, tkesum, weipri):
self.ncase = ncase
self.npflka = npflka
self.nstmax = nstmax
self.tkesum = tkesum
self.weipri = weipri
data = fortran.read(self.hnd)
if data is None: raise IOError("Invalid source event")
fmt = "=" + ("i8f" * npflka)
self.data = struct.unpack(fmt, data)
return ncase
def readData(self, det, lowneu):
"""Read detector det data structure"""
f = open(self.file, "rb")
fortran.skip(f) # Skip header
for i in range(2 * det):
fortran.skip(f) # Detector Header & Data
fortran.skip(f) # Detector Header
if lowneu:
fortran.skip(f) # skip low enery neutron data
data = fortran.read(f)
f.close()
return data
def readData(self, n): """Read detector n data structure""" f = open(self.file, "rb") fortran.skip(f) for i in range(n): fortran.skip(f) # Detector Header if self.detector[i].lowneu: fortran.skip(f) # Detector low enetry neutron groups fortran.skip(f) # Detector data fortran.skip(f) # Detector Header if self.detector[n].lowneu: fortran.skip(f) # Detector low enetry neutron groups data = fortran.read(f) # Detector data f.close() return data
def readData(self, n):
"""Read n(th) detector data structure"""
f = open(self.file, "rb")
fortran.skip(f)
for i in range(n):
fortran.skip(f) # Detector Header
if self.detector[i].lowneu:
fortran.skip(f) # Detector low enetry neutron groups
fortran.skip(f) # Detector data
fortran.skip(f) # Detector Header
if self.detector[n].lowneu:
fortran.skip(f) # Detector low enetry neutron groups
data = fortran.read(f) # Detector data
f.close()
return data
def readHeader(self, filename):
"""Read header information, and return the file handle"""
self.reset()
self.file = filename
f = open(self.file, "rb")
# Read header
data = fortran.read(f)
if data is None: raise IOError("Invalid USRxxx file")
size = len(data)
over1b = 0
if size == 116:
(title, time, self.weight) = \
struct.unpack("=80s32sf", data)
self.ncase = 1
self.nbatch = 1
elif size == 120:
(title, time, self.weight, self.ncase) = \
struct.unpack("=80s32sfi", data)
self.nbatch = 1
elif size == 124:
(title, time, self.weight,
self.ncase, self.nbatch) = \
struct.unpack("=80s32sfii", data)
elif size == 128:
(title, time, self.weight,
self.ncase, over1b, self.nbatch) = \
struct.unpack("=80s32sfiii", data)
elif size == 136: # FLUKA2021.2: LISFVR and LMSFVR variables added
(title, time, self.weight,
self.ncase, over1b, self.nbatch, lisfvr, lmsfvr) = \
struct.unpack("=80s32sfiiiii", data)
else:
raise IOError("Invalid USRxxx file")
if over1b > 0:
self.ncase = self.ncase + over1b * 1000000000
self.title = title.strip().decode()
self.time = time.strip().decode()
return f
def readData(self, n):
"""Read n(th) detector data structure"""
f = open(self.file, "rb")
fortran.skip(f)
if self.evol:
fortran.skip(f)
for _ in range(n):
fortran.skip(f) # Detector Header & Data
if self.evol:
fortran.skip(f) # TDecay
fortran.skip(f) # Detector data
if self.nisomers:
fortran.skip(f) # Isomers header
fortran.skip(f) # Isomers data
fortran.skip(f) # Detector Header & Data
if self.evol:
fortran.skip(f) # TDecay
data = fortran.read(f) # Detector data
f.close()
return data
def readData(self, n): """Read detector det data structure""" f = open(self.file, "rb") fortran.skip(f) if self.evol: fortran.skip(f) for i in range(n): fortran.skip(f) # Detector Header & Data if self.evol: fortran.skip(f) # TDecay fortran.skip(f) # Detector data if self.nisomers: fortran.skip(f) # Isomers header fortran.skip(f) # Isomers data fortran.skip(f) # Detector Header & Data if self.evol: fortran.skip(f) # TDecay data = fortran.read(f) # Detector data f.close() return data
def readHeader(self, filename):
"""Read header information, and return the file handle"""
self.reset()
self.file = filename
f = open(self.file, "rb")
# Read header
data = fortran.read(f)
if data is None: raise IOError("Invalid USRxxx file")
size = len(data)
over1b = 0
if size == 116:
(title, time, self.weight) = \
struct.unpack("=80s32sf", data)
self.ncase = 1
self.nbatch = 1
elif size == 120:
(title, time, self.weight, self.ncase) = \
struct.unpack("=80s32sfi", data)
self.nbatch = 1
elif size == 124:
(title, time, self.weight,
self.ncase, self.nbatch) = \
struct.unpack("=80s32sfii", data)
elif size == 128:
(title, time, self.weight,
self.ncase, over1b, self.nbatch) = \
struct.unpack("=80s32sfiii", data)
else:
raise IOError("Invalid USRxxx file")
if over1b > 0:
self.ncase = long(self.ncase) + long(over1b) * 1000000000
self.title = title.strip()
self.time = time.strip()
return f
def readHeader(self, filename):
"""Read header information, and return the file handle"""
self.reset()
self.file = filename
f = open(self.file, "rb")
# Read header
data = fortran.read(f)
if data is None: raise IOError("Invalid USRxxx file")
size = len(data)
over1b = 0
if size == 116:
(title, time, self.weight) = \
struct.unpack("=80s32sf", data)
self.ncase = 1
self.nbatch = 1
elif size == 120:
(title, time, self.weight, self.ncase) = \
struct.unpack("=80s32sfi", data)
self.nbatch = 1
elif size == 124:
(title, time, self.weight,
self.ncase, self.nbatch) = \
struct.unpack("=80s32sfii", data)
elif size == 128:
(title, time, self.weight,
self.ncase, over1b, self.nbatch) = \
struct.unpack("=80s32sfiii", data)
else:
raise IOError("Invalid USRxxx file")
if over1b>0:
self.ncase = long(self.ncase) + long(over1b)*1000000000
self.title = title.strip()
self.time = time.strip()
return f
def readHeader(self, filename):
"""Read USRBIN detector information"""
f = Usrxxx.readHeader(self, filename)
for i in range(1000):
# Header
data = fortran.read(f)
if data is None: break
size = len(data)
# Statistics are present?
if size == 14 and data[:10] == "STATISTICS":
self.statpos = f.tell()
break
if size != 86: raise IOError("Invalid USRBIN file")
# Parse header
header = struct.unpack("=i10siiffifffifffififff", data)
bin = Detector()
bin.nb = header[0]
bin.name = header[1].strip()
bin.type = header[2]
bin.score = header[3]
bin.xlow = float(bmath.format(header[4], 9, useD=False))
bin.xhigh = float(bmath.format(header[5], 9, useD=False))
bin.nx = header[6]
if bin.nx > 0 and bin.type not in (2, 12, 8, 18):
bin.dx = (bin.xhigh - bin.xlow) / float(bin.nx)
else:
bin.dx = float(bmath.format(header[7], 9, useD=False))
if bin.type in (1, 11):
bin.ylow = -math.pi
bin.yhigh = math.pi
else:
bin.ylow = float(bmath.format(header[8], 9, useD=False))
bin.yhigh = float(bmath.format(header[9], 9, useD=False))
bin.ny = header[10]
if bin.ny > 0 and bin.type not in (2, 12, 8, 18):
bin.dy = (bin.yhigh - bin.ylow) / float(bin.ny)
else:
bin.dy = float(bmath.format(header[11], 9, useD=False))
bin.zlow = float(bmath.format(header[12], 9, useD=False))
bin.zhigh = float(bmath.format(header[13], 9, useD=False))
bin.nz = header[14]
if bin.nz > 0 and bin.type not in (2, 12): # 8=special with z=real
bin.dz = (bin.zhigh - bin.zlow) / float(bin.nz)
else:
bin.dz = float(bmath.format(header[15], 9, useD=False))
bin.lntzer = header[16]
bin.bk = header[17]
bin.b2 = header[18]
bin.tc = header[19]
self.detector.append(bin)
size = bin.nx * bin.ny * bin.nz * 4
if fortran.skip(f) != size:
raise IOError("Invalid USRBIN file")
f.close()
def readHeader(self, filename):
"""Read USRBIN detector information"""
f = Usrxxx.readHeader(self, filename)
for i in range(1000):
# Header
data = fortran.read(f)
if data is None: break
size = len(data)
# Statistics are present?
if size == 14 and data[:10] == "STATISTICS":
self.statpos = f.tell()
break
if size != 86: raise IOError("Invalid USRBIN file")
# Parse header
header = struct.unpack("=i10siiffifffifffififff", data)
bin = Detector()
bin.nb = header[ 0]
bin.name = header[ 1].strip()
bin.type = header[ 2]
bin.score = header[ 3]
bin.xlow = float(bmath.format(header[ 4],9,useD=False))
bin.xhigh = float(bmath.format(header[ 5],9,useD=False))
bin.nx = header[ 6]
if bin.nx > 0 and bin.type not in (2,12,8,18):
bin.dx = (bin.xhigh-bin.xlow) / float(bin.nx)
else:
bin.dx = float(bmath.format(header[ 7],9,useD=False))
if bin.type in (1,11):
bin.ylow = -math.pi
bin.yhigh = math.pi
else:
bin.ylow = float(bmath.format(header[ 8],9,useD=False))
bin.yhigh = float(bmath.format(header[ 9],9,useD=False))
bin.ny = header[10]
if bin.ny > 0 and bin.type not in (2,12,8,18):
bin.dy = (bin.yhigh-bin.ylow) / float(bin.ny)
else:
bin.dy = float(bmath.format(header[11],9,useD=False))
bin.zlow = float(bmath.format(header[12],9,useD=False))
bin.zhigh = float(bmath.format(header[13],9,useD=False))
bin.nz = header[14]
if bin.nz > 0 and bin.type not in (2,12): # 8=special with z=real
bin.dz = (bin.zhigh-bin.zlow) / float(bin.nz)
else:
bin.dz = float(bmath.format(header[15],9,useD=False))
bin.lntzer= header[16]
bin.bk = header[17]
bin.b2 = header[18]
bin.tc = header[19]
self.detector.append(bin)
size = bin.nx * bin.ny * bin.nz * 4
if fortran.skip(f) != size:
raise IOError("Invalid USRBIN file")
f.close()
def main():
""" Converts ustsuw output into a ROOT TH1F histogram """
parser = argparse.ArgumentParser(
description=main.__doc__,
epilog="Homepage: https://github.com/kbat/mc-tools")
parser.add_argument('eventdat',
type=str,
nargs='*',
help='list of eventdat files')
parser.add_argument('-o',
dest='root',
type=str,
help='output ROOT file name',
default="")
parser.add_argument('-v',
'--verbose',
action='store_true',
default=False,
dest='verbose',
help='print what is being done')
parser.add_argument('-f',
'--force',
action='store_true',
default=False,
dest='overwrite',
help='overwrite the output ROOT file')
args = parser.parse_args()
for f in args.eventdat:
if not os.path.isfile(f):
print("eventdat2root: File %s does not exist." % f,
file=sys.stderr)
return 1
if not args.overwrite and os.path.isfile(args.root):
sys.exit("%s exists. Use '-f' to overwrite it." % args.root)
first = True
for eventdat in args.eventdat:
with open(eventdat, 'rb') as f:
print(eventdat)
while True:
data = fortran.read(f)
if data is None:
break
size = len(data)
print("\nsize:", size)
if first:
first = False
title, time, nregs, nsco, dist = struct.unpack(
"=80s32siii", data)
print("title:", title)
print("time:", time)
print("number of regions:", nregs)
print("number of scoring distributions:", nsco)
print("distribution:", dist)
DATA = array('f', nsco * nregs * [0.0])
fout = ROOT.TFile(args.root, "recreate", title)
T = ROOT.TTree("EVENTDAT", time)
T.Branch("DATA", DATA, "d%d[%d]/F" % (dist, nsco * nregs))
elif size == 12:
pass
elif size == 48:
pass
elif size == 8:
pass
elif size == nregs * nsco * 4:
val = struct.unpack("%df" % nregs * nsco, data)
for i, v in enumerate(val):
DATA[i] = v
T.Fill()
T.Write()
fout.Close()
def readHeader(self, filename):
"""Read USRBIN detector information"""
f = super().readHeader(filename)
for _ in range(1000):
# Header
data = fortran.read(f)
if data is None: break
size = len(data)
# Statistics are present?
if size == 14 and data[:10] == b"STATISTICS":
self.statpos = f.tell()
break
elif size != 86:
raise IOError("Invalid USRBIN file")
# Parse header
header = struct.unpack("=i10siiffifffifffififff", data)
usrbin = Detector()
usrbin.nb = header[0]
usrbin.name = header[1].strip().decode()
usrbin.type = header[2]
usrbin.score = header[3]
usrbin.xlow = float(bmath.format(header[4], 9))
usrbin.xhigh = float(bmath.format(header[5], 9))
usrbin.nx = header[6]
if usrbin.nx > 0 and usrbin.type not in (2, 12, 8, 18):
usrbin.dx = (usrbin.xhigh - usrbin.xlow) / float(usrbin.nx)
else:
usrbin.dx = float(bmath.format(header[7], 9))
usrbin.ylow = float(bmath.format(header[8], 9))
usrbin.yhigh = float(bmath.format(header[9], 9))
if usrbin.type in (1, 11):
# Round to pi if needed
if abs(usrbin.ylow + math.pi) < 1e-6:
usrbin.ylow = -math.pi
if abs(usrbin.yhigh - math.pi) < 1e-6:
usrbin.yhigh = math.pi
elif abs(usrbin.yhigh - math.pi * 2) < 1e-6:
usrbin.yhigh = 2 * math.pi
usrbin.ny = header[10]
if usrbin.ny > 0 and usrbin.type not in (2, 12, 8, 18):
usrbin.dy = (usrbin.yhigh - usrbin.ylow) / float(usrbin.ny)
else:
usrbin.dy = float(bmath.format(header[11], 9))
usrbin.zlow = float(bmath.format(header[12], 9))
usrbin.zhigh = float(bmath.format(header[13], 9))
usrbin.nz = header[14]
if usrbin.nz > 0 and usrbin.type not in (
2, 12): # 8=special with z=real
usrbin.dz = (usrbin.zhigh - usrbin.zlow) / float(usrbin.nz)
else:
usrbin.dz = float(bmath.format(header[15], 9))
usrbin.lntzer = header[16]
usrbin.bk = header[17]
usrbin.b2 = header[18]
usrbin.tc = header[19]
self.detector.append(usrbin)
size = usrbin.nx * usrbin.ny * usrbin.nz * 4
if fortran.skip(f) != size:
raise IOError("Invalid USRBIN file")
f.close()
def main():
""" Converts ustsuw output into a ROOT TH1F histogram """
parser = argparse.ArgumentParser(description=main.__doc__,
epilog="Homepage: https://github.com/kbat/mc-tools")
parser.add_argument('eventdat', type=str, nargs='*', help='list of eventdat files')
parser.add_argument('-o', dest='root', type=str, help='output ROOT file name', default="")
parser.add_argument('-v', '--verbose', action='store_true', default=False, dest='verbose', help='print what is being done')
parser.add_argument('-f', '--force', action='store_true', default=False, dest='overwrite', help='overwrite the output ROOT file')
args = parser.parse_args()
for f in args.eventdat:
if not os.path.isfile(f):
print("eventdat2root: File %s does not exist." % f, file=sys.stderr)
return 1
if not args.overwrite and os.path.isfile(args.root):
sys.exit("%s exists. Use '-f' to overwrite it." % args.root)
first = True
for eventdat in args.eventdat:
with open(eventdat, 'rb') as f:
print(eventdat)
while True:
data = fortran.read(f)
if data is None:
break
size = len(data)
print("\nsize:",size)
if first:
first = False
title, time, nregs, nsco, dist = struct.unpack("=80s32siii", data)
print("title:", title)
print("time:", time)
print("number of regions:",nregs)
print("number of scoring distributions:", nsco)
print("distribution:",dist)
DATA = array('f', nsco*nregs*[0.0])
fout = ROOT.TFile(args.root, "recreate", title)
T = ROOT.TTree("EVENTDAT", time)
T.Branch("DATA", DATA, "d%d[%d]/F" % (dist,nsco*nregs))
elif size == 12:
pass
elif size == 48:
pass
elif size == 8:
pass
elif size == nregs*nsco*4:
val = struct.unpack("%df" % nregs*nsco, data)
for i,v in enumerate(val):
DATA[i] = v
T.Fill()
T.Write()
fout.Close()
def readHeader(self, filename):
"""Read residual nuclei detector information"""
f = Usrxxx.readHeader(self, filename)
self.nisomers = 0
if self.ncase <= 0:
self.evol = True
self.ncase = -self.ncase
data = fortran.read(f)
nir = (len(data)-4)//8
self.irrdt = struct.unpack("=i%df"%(2*nir), data)
else:
self.evol = False
self.irrdt = None
for i in range(1000):
# Header
data = fortran.read(f)
if data is None: break
size = len(data)
self.irrdt = None
# Statistics are present?
if size == 14 and data[:8] == "ISOMERS:":
self.nisomers = struct.unpack("=10xi",data)[0]
data = fortran.read(f)
data = fortran.read(f)
size = len(data)
if size == 14 and data[:10] == "STATISTICS":
self.statpos = f.tell()
break
if size != 38:
raise IOError("Invalid RESNUCLEi file header size=%d"%(size))
# Parse header
header = struct.unpack("=i10siif3i", data)
det = Detector()
det.nb = header[ 0]
det.name = header[ 1].strip()
det.type = header[ 2]
det.region = header[ 3]
det.volume = header[ 4]
det.mhigh = header[ 5]
det.zhigh = header[ 6]
det.nmzmin = header[ 7]
self.detector.append(det)
if self.evol:
data = fortran.read(f)
self.tdecay = struct.unpack("=f", data)
else:
self.tdecay = 0.0
size = det.zhigh * det.mhigh * 4
if size != fortran.skip(f):
raise IOError("Invalid RESNUCLEi file")
f.close()
def readHeader(self, filename):
"""Read boundary crossing detector information"""
f = super().readHeader(filename)
for _ in range(1000):
# Header
data = fortran.read(f)
if data is None: break
size = len(data)
# Statistics are present?
if size == 14:
# In statistics
# 1: total, error
# 2: N,NG,Elow (array with Emaxi)
# 3: Differential integrated over solid angle
# 4: -//- errors
# 5: Cumulative integrated over solid angle
# 6: -//- errors
# 7: Double differential data
self.statpos = f.tell()
for det in self.detector:
data = unpackArray(fortran.read(f))
det.total = data[0]
det.totalerror = data[1]
for j in range(6):
fortran.skip(f)
break
elif size != 78:
raise IOError("Invalid USRBDX file")
# Parse header
header = struct.unpack("=i10siiiifiiiffifffif", data)
det = Detector()
det.nb = header[0] # mx
det.name = header[1].strip().decode() # titusx
det.type = header[2] # itusbx
det.dist = header[3] # idusbx
det.reg1 = header[4] # nr1usx
det.reg2 = header[5] # nr2usx
det.area = header[6] # ausbdx
det.twoway = header[7] # lwusbx
det.fluence = header[8] # lfusbx
det.lowneu = header[9] # llnusx
det.elow = header[10] # ebxlow
det.ehigh = header[11] # ebxhgh
det.ne = header[12] # nebxbn
det.de = header[13] # debxbn
det.alow = header[14] # abxlow
det.ahigh = header[15] # abxhgh
det.na = header[16] # nabxbn
det.da = header[17] # dabxbn
self.detector.append(det)
if det.lowneu:
data = fortran.read(f)
det.ngroup = struct.unpack("=i", data[:4])[0]
det.egroup = struct.unpack("=%df" % (det.ngroup + 1), data[4:])
else:
det.ngroup = 0
det.egroup = []
size = (det.ngroup + det.ne) * det.na * 4
if size != fortran.skip(f):
raise IOError("Invalid USRBDX file")
f.close()
def readHeader(self, filename):
"""Read residual nuclei detector information"""
f = super().readHeader(filename)
self.nisomers = 0
if self.ncase <= 0:
self.evol = True
self.ncase = -self.ncase
data = fortran.read(f)
nir = (len(data) - 4) // 8
self.irrdt = struct.unpack("=i%df" % (2 * nir), data)
else:
self.evol = False
self.irrdt = None
for _ in range(1000):
# Header
data = fortran.read(f)
if data is None: break
size = len(data)
self.irrdt = None
# Statistics are present?
if size == 14:
if data[:8] == b"ISOMERS:":
self.nisomers = struct.unpack("=10xi", data)[0]
data = fortran.read(f)
data = fortran.read(f)
size = len(data)
if data[:10] == b"STATISTICS":
self.statpos = f.tell()
break
elif size != 38:
raise IOError("Invalid RESNUCLEi file header size=%d" % (size))
# Parse header
header = struct.unpack("=i10siif3i", data)
det = Detector()
det.nb = header[0]
det.name = header[1].strip().decode()
det.type = header[2]
det.region = header[3]
det.volume = header[4]
det.mhigh = header[5]
det.zhigh = header[6]
det.nmzmin = header[7]
self.detector.append(det)
if self.evol:
data = fortran.read(f)
self.tdecay = struct.unpack("=f", data)
else:
self.tdecay = 0.0
size = det.zhigh * det.mhigh * 4
if size != fortran.skip(f):
raise IOError("Invalid RESNUCLEi file")
f.close()
def main():
""" Converts PLOTGEOM output into a ROOT TMuiltiGraph object """
parser = argparse.ArgumentParser(description=main.__doc__,
epilog="Homepage: https://github.com/kbat/mc-tools")
parser.add_argument('plotgeom', type=str, nargs='*', help='list of plotgeom files')
parser.add_argument('-o', dest='root', type=str, help='output ROOT file name', default="")
parser.add_argument('-v', '--verbose', action='store_true', default=False, dest='verbose', help='print what is being done')
parser.add_argument('-f', '--force', action='store_true', default=False, dest='overwrite', help='overwrite the output ROOT file')
args = parser.parse_args()
for f in args.plotgeom:
if not os.path.isfile(f):
sys.exit("plotgeom2root: File %s does not exist." % f)
wlength = 0
title = ""
for plotgeom in args.plotgeom:
if args.root == "":
rootFileName = "%s%s" % (plotgeom,".root")
else:
rootFileName = args.root
if not args.overwrite and os.path.isfile(rootFileName):
sys.exit("%s exists. Use '-f' to overwrite it." % rootFileName)
with open(plotgeom, 'rb') as f:
data = fortran.read(f)
size = len(data)
if size != 80:
sys.exit("Format error [title]")
title = struct.unpack("=80s", data)[0].decode('utf-8').strip()
if args.verbose:
print(title)
data = fortran.read(f)
size = len(data)
if size != 14*4:
print("Format error [basis]")
X0,Y0,Z0,X1,Y1,Z1,TYX,TYY,TYZ,TXX,TXY,TXZ,XAXLEN,YAXLEN = struct.unpack("=14f", data) # http://www.fluka.org/fluka.php?id=man_onl&sub=63
if not args.verbose:
print("Bottom left corner:",X0,Y0,Z0)
print("Top right corner:",X1,Y1,Z1)
print("Direction cosines of the x-axis:",TXX,TXY,TXZ)
print("Direction cosines of the y-axis:",TYX,TYY,TYZ)
print("x and y axis length:",XAXLEN,YAXLEN)
# print(X0,Y0,Z0,X1,Y1,Z1,TYX,TYY,TYZ,TXX,TXY,TXZ,XAXLEN,YAXLEN)
for i in range(1):
data = fortran.read(f)
size = len(data)
if args.verbose:
print("size: ",size)
if size==8:
NWORMS,dummy = struct.unpack("=2i", data)
if args.verbose:
print("NWORMS:",NWORMS,dummy)
# elif size==12: # this is never called
# NWORMS,dummy,dummy1 = struct.unpack("=3i", data)
# print(NWORMS,dummy,dummy1)
i = 0
fout = ROOT.TFile(rootFileName, "recreate", plotgeom)
mg = ROOT.TMultiGraph("mg", title)
while True:
i = i + 1
data = fortran.read(f)
if data is None:
break
size = len(data)
if args.verbose:
print("\nsize:",size)
if size == 12:
windex,dummy,wlength = struct.unpack("=3i",data)
if args.verbose:
print(windex,dummy,wlength)
elif size==8:
tmp = struct.unpack("=2i", data)
if args.verbose:
print("size8:",tmp)
## break
elif size==24:
tmp = struct.unpack("=3i3f", data)
if args.verbose:
print("size24:",tmp)
else:
if args.verbose:
print("a",wlength)
coord = struct.unpack("=%df" % (wlength*2),data) # pairs of x,y
if args.verbose:
print(coord[:10])
x = list(map(lambda x:x+Y0, coord[::2])) #[x+Y0 for x in coord[::2]]
y = list(map(lambda y:y+X0, coord[1::2]))
g = ROOT.TGraph(len(x), array('f', x), array('f', y))
g.SetName("g%d" % i)
mg.Add(g)
mg.Write()
fout.Close()
def readHeader(self, filename):
"""Read boundary crossing detector information"""
f = Usrxxx.readHeader(self, filename)
for i in range(1000):
# Header
data = fortran.read(f)
if data is None: break
size = len(data)
# Statistics are present?
if size == 14:
# In statistics
# 1: total, error
# 2: N,NG,Elow (array with Emaxi)
# 3: Differential integrated over solid angle
# 4: -//- errors
# 5: Cumulative integrated over solid angle
# 6: -//- errors
# 7: Double differential data
self.statpos = f.tell()
for det in self.detector:
data = unpackArray(fortran.read(f))
det.total = data[0]
det.totalerror = data[1]
for j in range(6):
fortran.skip(f)
break
if size != 78: raise IOError("Invalid USRBDX file")
# Parse header
header = struct.unpack("=i10siiiifiiiffifffif", data)
det = Detector()
det.nb = header[ 0] # mx
det.name = header[ 1].strip() # titusx
det.type = header[ 2] # itusbx
det.dist = header[ 3] # idusbx
det.reg1 = header[ 4] # nr1usx
det.reg2 = header[ 5] # nr2usx
det.area = header[ 6] # ausbdx
det.twoway = header[ 7] # lwusbx
det.fluence = header[ 8] # lfusbx
det.lowneu = header[ 9] # llnusx
det.elow = header[10] # ebxlow
det.ehigh = header[11] # ebxhgh
det.ne = header[12] # nebxbn
det.de = header[13] # debxbn
det.alow = header[14] # abxlow
det.ahigh = header[15] # abxhgh
det.na = header[16] # nabxbn
det.da = header[17] # dabxbn
self.detector.append(det)
if det.lowneu:
data = fortran.read(f)
det.ngroup = struct.unpack("=i",data[:4])[0]
det.egroup = struct.unpack("=%df"%(det.ngroup+1), data[4:])
else:
det.ngroup = 0
det.egroup = []
size = (det.ngroup+det.ne) * det.na * 4
if size != fortran.skip(f):
raise IOError("Invalid USRBDX file")
f.close()
