def staff():
staff = ROOT.staff_t()
# The input file cern.dat is a copy of the CERN staff data base
# from 1988
f = TFile('staff.root', 'RECREATE')
tree = TTree('T', 'staff data from ascii file')
tree.Branch('staff', staff,
'Category/I:Flag:Age:Service:Children:Grade:Step:Hrweek:Cost')
tree.Branch('Divisions', AddressOf(staff, 'Division'), 'Division/C')
tree.Branch('Nation', AddressOf(staff, 'Nation'), 'Nation/C')
# note that the branches Division and Nation cannot be on the first branch
fname = os.path.expandvars('$ROOTSYS/tutorials/tree/cernstaff.dat')
for line in open(fname).readlines():
t = filter(lambda x: x, re.split('\s+', line))
staff.Category = int(t[0]) # assign as integers
staff.Flag = int(t[1])
staff.Age = int(t[2])
staff.Service = int(t[3])
staff.Children = int(t[4])
staff.Grade = int(t[5])
staff.Step = int(t[6])
staff.Hrweek = int(t[7])
staff.Cost = int(t[8])
staff.Division = t[9] # assign as strings
staff.Nation = t[10]
tree.Fill()
tree.Print()
tree.Write()
def initLbdata(self):
#
# Define LBDATA tree
gROOT.ProcessLine("struct LbdataStruct {\
Float_t fB1IntensityBPTX;\
Float_t fB2IntensityBPTX;\
Float_t fB1IntensityAllBPTX;\
Float_t fB2IntensityAllBPTX;\
Float_t fB1IntensityBCT;\
Float_t fB2IntensityBCT;\
Float_t fB1IntensityAllBCT;\
Float_t fB2IntensityAllBCT;\
Float_t fB1IntensityAllDCCT;\
Float_t fB2IntensityAllDCCT;\
};")
from ROOT import LbdataStruct
self.lbdataStruct = LbdataStruct()
self.tree.Branch(
'BPTX_LBDATA', AddressOf(self.lbdataStruct, 'fB1IntensityBPTX'),
'BPTX_B1Intensity/F:BPTX_B2Intensity/F:BPTX_B1IntensityAll/F:BPTX_B2IntensityAll/F'
)
self.tree.Branch(
'BCT_LBDATA', AddressOf(self.lbdataStruct, 'fB1IntensityBCT'),
'BCT_B1Intensity/F:BCT_B2Intensity/F:BCT_B1IntensityAll/F:BCT_B2IntensityAll/F'
)
self.tree.Branch('DCCT_LBDATA',
AddressOf(self.lbdataStruct, 'fB1IntensityAllDCCT'),
'DCCT_B1IntensityAll/F:DCCT_B2IntensityAll/F')
def test05WriteSomeDataObjectBranched(self):
"""Test writing of a complex object across different branches"""
f = TFile(self.fname, 'RECREATE')
t = TTree(self.tname, self.ttitle)
d = SomeDataStruct()
# note: for p2.2, which has incomplete support of property types,
# we need to keep a reference alive to the result of the property
# call, or it will be deleted too soon; for later pythons, it is
# safe to use d.Floats directly in the Branch() call
fl = d.Floats
t.Branch('floats', fl)
t.Branch('nlabel', AddressOf(d, 'NLabel'), 'NLabel/I')
t.Branch('label', AddressOf(d, 'Label'), 'Label/C')
for i in range(self.N):
for j in range(self.M):
d.Floats.push_back(i * self.M + j)
d.NLabel = i
d.Label = '%d' % i
t.Fill()
f.Write()
f.Close()
def main(basedir=None):
#production directory
if basedir is None:
basedir = ".."
#input
infile = basedir + "/lmon.root"
#output
outfile = basedir + "/HCal.csv"
#lmon input
inp = TFile.Open(infile)
tree = inp.Get("DetectorTree")
#load the tree
gROOT.ProcessLine("struct EntryD {Double_t v;};")
ucal_edep_EMC = rt.EntryD()
ucal_edep_HAC1 = rt.EntryD()
ucal_edep_HAC2 = rt.EntryD()
ucal_edep_layers = std.vector(float)()
tree.SetBranchAddress("ucal_edep_EMC", AddressOf(ucal_edep_EMC, "v"))
tree.SetBranchAddress("ucal_edep_HAC1", AddressOf(ucal_edep_HAC1, "v"))
tree.SetBranchAddress("ucal_edep_HAC2", AddressOf(ucal_edep_HAC2, "v"))
tree.SetBranchAddress("ucal_edep_layers", ucal_edep_layers)
#output txt csv
out = open(outfile, "write")
#file header
tree.GetEntry(0)
nlay = ucal_edep_layers.size()
col = ["ucal_edep_EMC", "ucal_edep_HAC1", "ucal_edep_HAC2"]
for i in range(nlay):
col.append("ucal_edep_layer" + str(i))
strcol = ""
for i in col:
strcol += "," + i
out.write(strcol + "\n")
#event loop
for iev in xrange(tree.GetEntriesFast()):
tree.GetEntry(iev)
lin = str(iev + 1)
lin += "," + str(ucal_edep_EMC.v)
lin += "," + str(ucal_edep_HAC1.v)
lin += "," + str(ucal_edep_HAC2.v)
for i in xrange(nlay):
lin += "," + str(ucal_edep_layers.at(i))
out.write(lin + "\n")
out.close()
def initFillParams(self):
#
# Define FILLPARAMS tree
gROOT.ProcessLine("struct FillParamsStruct {\
Int_t fB1Bunches;\
Int_t fB1BCIDs[3564];\
Int_t fB2Bunches;\
Int_t fB2BCIDs[3564];\
Int_t fLuminousBunches;\
Int_t fLuminousBCIDs[3564];\
};")
from ROOT import FillParamsStruct
self.fillParamsStruct = FillParamsStruct()
self.fillParamsStruct.fB1Bunches = 0
self.fillParamsStruct.fB2Bunches = 0
self.fillParamsStruct.fLuminousBunches = 0
# self.fB1BCIDs = array('i', 3564*[0])
# self.fB2BCIDs = array('i', 3564*[0])
# self.fLuminousBCIDs = array('i', 3564*[0])
self.tree.Branch('FILLPARAMSB1',
AddressOf(self.fillParamsStruct, 'fB1Bunches'),
'B1Bunches/I:B1BCIDs[B1Bunches]/I')
self.tree.Branch('FILLPARAMSB2',
AddressOf(self.fillParamsStruct, 'fB2Bunches'),
'B2Bunches/I:B2BCIDs[B2Bunches]/I')
self.tree.Branch('FILLPARAMS',
AddressOf(self.fillParamsStruct, 'fLuminousBunches'),
'LuminousBunches/I:LuminousBCIDs[LuminousBunches]/I')
print('Defined FillParams data type')
def init_tree_from_table(hit_table,
meta_table,
chunk_size=1,
hit_tree_entry=None,
meta_tree_entry=None):
''' Initializes a ROOT tree from a HDF5 table.
Takes the HDF5 table column names and types and creates corresponding
branches. If a chunk size is specified the branches will have the length of
the chunk size and an additional parameter is returned to change the chunk
size at a later stage. If a tree_entry is defined (a ROOT c-struct) the new
tree has the branches set to the corresponding tree entry address.
Parameters
----------
numpy_type_descriptor: np.dtype
'''
if (chunk_size > 1 and hit_tree_entry is not None
and meta_tree_entry is not None):
raise NotImplementedError()
tree = TTree('Table', 'Converted HDF5 table')
n_entries = None
if chunk_size > 1:
n_entries = ctypes.c_int(chunk_size) if chunk_size > 1 else 1
# needs to be added, otherwise one cannot access chunk_size_tree:
tree.Branch('n_entries', ctypes.addressof(n_entries), 'n_entries/I')
# adding branches for hit table:
for hit_column_name in hit_table.dtype.names:
print hit_column_name, hit_table.dtype[
hit_column_name], get_root_type_descriptor(
hit_table.dtype[hit_column_name])
tree.Branch(
hit_column_name, 'NULL' if hit_tree_entry is None else AddressOf(
hit_tree_entry, hit_column_name),
hit_column_name + '[n_entries]/' +
get_root_type_descriptor(hit_table.dtype[hit_column_name])
if chunk_size > 1 else hit_column_name + '/' +
get_root_type_descriptor(hit_table.dtype[hit_column_name]))
# adding branches for meta table (timestamps):
for meta_column_name in meta_table.dtype.names:
print meta_column_name, meta_table.dtype[
meta_column_name], get_root_type_descriptor(
meta_table.dtype[meta_column_name])
if meta_column_name == 'timestamp_start' or meta_column_name == 'timestamp_stop':
tree.Branch(
meta_column_name,
'NULL' if meta_tree_entry is None else AddressOf(
meta_tree_entry, meta_column_name),
meta_column_name + '[n_entries]/' +
get_root_type_descriptor(meta_table.dtype[meta_column_name])
if chunk_size > 1 else meta_column_name + '/' +
get_root_type_descriptor(meta_table.dtype[meta_column_name]))
return tree, n_entries
def main(basedir=None):
#production directory
if basedir is None:
basedir = ".."
#input
infile = basedir + "/lmon.root"
#output
outfile = basedir + "/HCal.csv"
#lmon input
inp = TFile.Open(infile)
tree = inp.Get("DetectorTree")
#load the tree
gROOT.ProcessLine("struct EntryD {Double_t v;};")
hcal_edep_EM = rt.EntryD()
hcal_edep_HAD = rt.EntryD()
hcal_edep_layers = std.vector(float)()
tree.SetBranchAddress("hcal_edep_EM", AddressOf(hcal_edep_EM, "v"))
tree.SetBranchAddress("hcal_edep_HAD", AddressOf(hcal_edep_HAD, "v"))
tree.SetBranchAddress("hcal_edep_layers", hcal_edep_layers)
tree.GetEntry(0)
nlay = hcal_edep_layers.size()
#output DataFrame
col = ["hcal_edep_EM", "hcal_edep_HAD"]
lnam = {}
for i in range(nlay):
n = "hcal_edep_layer"+str(i)
lnam[i] = n
col.append(n)
df = DataFrame(columns=col)
#event loop
for iev in xrange(tree.GetEntriesFast()):
tree.GetEntry(iev)
#print hcal_edep_EM.v, hcal_edep_HAD.v
df.loc[iev+1, "hcal_edep_EM"] = hcal_edep_EM.v
df.loc[iev+1, "hcal_edep_HAD"] = hcal_edep_HAD.v
for i in xrange(nlay):
#print "i", i, hcal_edep_layers.at(i)
df.loc[iev+1, lnam[i]] = hcal_edep_layers.at(i)
#print df
df.to_csv(outfile)
def run_convert(basedir, beam):
print "Converting for:", beam
infile = basedir + "/lmon_p"+str(beam)+".root"
outfile = basedir + "/HCal_p"+str(beam)+".h5"
#lmon input
inp = TFile.Open(infile)
tree = inp.Get("DetectorTree")
#load the tree
ucal_edep_EMC = rt.EntryD()
ucal_edep_HAC1 = rt.EntryD()
ucal_edep_HAC2 = rt.EntryD()
ucal_edep_layers = std.vector(float)()
tree.SetBranchAddress("ucal_edep_EMC", AddressOf(ucal_edep_EMC, "v"))
tree.SetBranchAddress("ucal_edep_HAC1", AddressOf(ucal_edep_HAC1, "v"))
tree.SetBranchAddress("ucal_edep_HAC2", AddressOf(ucal_edep_HAC2, "v"))
tree.SetBranchAddress("ucal_edep_layers", ucal_edep_layers)
tree.GetEntry(0)
nlay = ucal_edep_layers.size()
#output DataFrame
col = ["ucal_edep_EMC", "ucal_edep_HAC1", "ucal_edep_HAC2"]
for i in range(nlay):
col.append( "ucal_edep_layer"+str(i) )
df_inp = []
#event loop
for iev in xrange(tree.GetEntriesFast()):
tree.GetEntry(iev)
lin = []
lin.append(ucal_edep_EMC.v)
lin.append(ucal_edep_HAC1.v)
lin.append(ucal_edep_HAC2.v)
for i in xrange(nlay):
lin.append(ucal_edep_layers.at(i))
df_inp.append(lin)
df = DataFrame(df_inp, columns=col)
print df
out = HDFStore(outfile)
out["hcal"] = df
out.close()
inp.Close()
def pion(args, figname):
datatype = args[0]
label = args[1]
test = get_options(args, 'test')
batch = get_options(args, 'batch')
if batch:
cmd = create_batch_cmd()
bashname = '%s.sh' %figname
bashfile = create_bashfile_cmd(cmd, bashname, label, test=test)
logfile = set_logfile('fig', datatype, label, figname)
jobname = 'figptpion'
bsub_jobs(logfile, jobname, bashfile, test)
return
figfile = set_figfile(figname, label, '.pdf', test=test)
rootfile = atr.rootfile(datatype, label, test=test)
obj = atr.root_tree_obj(datatype, label)
chain = root_chain(rootfile, obj)
canvas = TCanvas("aCanvas", "Canvas", 600, 600)
hist = TH1F('pionpt', '#pi p_{T}', 100, 0, 20)
Gen_Pion_P4_ = TClonesArray('TLorentzVector')
chain.SetBranchAddress('Gen_Pion_P4', AddressOf(Gen_Pion_P4_))
PionPP4_ = TClonesArray('TLorentzVector')
chain.SetBranchAddress('PionPP4', AddressOf(PionPP4_))
ntot = chain.GetEntries()
if test:
ntot = 1000
sys.stdout.write('Processing %s events ...\n' %ntot)
sys.stdout.flush()
nfill = 0
for i in xrange(ntot):
chain.LoadTree(i)
chain.GetEntry(i)
if 'GEN' in label:
pionp4 = chain.Gen_Pion_P4[0]
else:
if chain.nXcand <= 0:
continue
pionp4 = pionp4 = chain.PionPP4[0]
hist.Fill(pionp4.Pt())
nfill += 1
sys.stdout.write('Filled %s events. \n' %nfill)
hist.GetXaxis().SetTitle('p_{T} (GeV/c)')
hist.Draw()
canvas.SaveAs(figfile)
hist.Delete()
def cli():
helpString = "This script takes an input Sim file from Cosima and spits out a Root\
file which can be used in Alex MGeant analysis scripts. Takes as\
input the Simulation File name and the Root File name."
import argparse
parser = argparse.ArgumentParser(description=helpString)
parser.add_argument("SimFile", help="Input Simulation File (from Cosima)")
parser.add_argument("RootFile", help="Output Root File")
args = parser.parse_args()
from EventViewer import parse
from ROOT import TFile, TTree, AddressOf
sim = parse(args.SimFile)
print "There are {} events in this file.".format(len(sim.events))
#for event in sim.events[:10]:
# print event.hits
#Make the tree
f = TFile(args.RootFile, 'RECREATE')
t = TTree('h10','Simulations')
MGS = MGSimulation()
t.Branch('Runevt', AddressOf(MGS.MGStruct, 'Runevt'), 'Runevt/F')
t.Branch('Xcor', AddressOf(MGS.MGStruct, 'Xcor'), 'Xcor/F')
t.Branch('Ycor', AddressOf(MGS.MGStruct, 'Ycor'), 'Ycor/F')
t.Branch('Zcor', AddressOf(MGS.MGStruct, 'Zcor'), 'Zcor/F')
t.Branch('Estep', AddressOf(MGS.MGStruct, 'Estep'), 'Estep/F')
#t.Branch('Det', AddressOf(MGS.MGStruct, 'Det'), 'Det/F')
for event in sim.events:
hits = zip(event.hits.detector,
event.hits.x,
event.hits.y,
event.hits.z,
event.hits.energy)
for hit in hits:
MGS.MGStruct.Runevt = float(event.id_trigger)
#MGS.MGStruct.Det = hit[0]
MGS.MGStruct.Xcor = hit[1]
MGS.MGStruct.Ycor = hit[2]
MGS.MGStruct.Zcor = hit[3]
MGS.MGStruct.Estep = hit[4]
t.Fill()
f.Write()
f.Close()
def __init__(self, file, tree, events):
self.file = file
self.tree = tree
self.events = events
# self.tree.Branch("events", events, 'nEvts/I:nPhotons:Energy')
self.tree.Branch("nPhotons", AddressOf(self.events, 'nPhotons'),
'nPhotons/I')
self.tree.Branch("isr_e", AddressOf(self.events, 'Energy'),
'isr_e[nPhotons]/D')
def initLBData(self):
self.lbDataStruct = self.getLBDataStruct()
# l = 64 bit unsigned int, L = 64 bit signed int
self.tree.Branch('LBDATA', self.lbDataStruct,
'StartTime/l:EndTime/l:Run/i:LB/i:stable/i')
self.tree.Branch('BPTXBeam1All',
AddressOf(self.lbDataStruct, 'fBPTXBeam1'),
'BPTXBeam1All/F')
self.tree.Branch('BPTXBeam2All',
AddressOf(self.lbDataStruct, 'fBPTXBeam2'),
'BPTXBeam2All/F')
self.tree.Branch('BCTBeam1All',
AddressOf(self.lbDataStruct, 'fBCTBeam1'),
'BCTBeam1All/F')
self.tree.Branch('BCTBeam2All',
AddressOf(self.lbDataStruct, 'fBCTBeam2'),
'BCTBeam2All/F')
self.tree.Branch('DCCTBeam1All',
AddressOf(self.lbDataStruct, 'fDCCTBeam1'),
'DCCTBeam1All/F')
self.tree.Branch('DCCTBeam2All',
AddressOf(self.lbDataStruct, 'fDCCTBeam2'),
'DCCTBeam2All/F')
self.tree.Branch('DCCT24Beam1All',
AddressOf(self.lbDataStruct, 'fDCCT24Beam1'),
'DCCT24Beam1All/F')
self.tree.Branch('DCCT24Beam2All',
AddressOf(self.lbDataStruct, 'fDCCT24Beam2'),
'DCCT24Beam2All/F')
def setBranchAddress(self, tree, varname, holder, pointername=None):
if not pointername: pointername = varname
" Set tree branch varname to holder "
if not tree.GetBranchStatus(varname):
tree.SetBranchStatus(varname, True)
# fix the AddressOf in new ROOT versions we need only one argument
try:
tree.SetBranchAddress(varname, AddressOf(holder, pointername))
except:
tree.SetBranchAddress(varname, AddressOf(holder))
MSG_DEBUG(self, "Set %s branch address on %s", varname, tree)
else:
MSG_DEBUG(self, "Already set %s branch address on %s", varname,
tree)
def make_root(self, parse):
#ROOT output
nam = parse.get("lgen", "nam").strip("\"'") + ".root"
print "ROOT output name:", nam
self.out_root = TFile(nam, "recreate")
#tree variables, all Double_t
tlist = ["phot_en", "phot_theta", "phot_phi"]
tlist += ["el_en", "el_theta", "el_phi"]
#C structure holding the variables
struct = "struct tree_out { Double_t "
for i in tlist:
struct += i + ", "
struct = struct[:-2] + ";};"
gROOT.ProcessLine(struct)
#create the output tree
self.tree_out = rt.tree_out() # instance of the C structure
self.ltree = TTree("ltree", "ltree")
for i in tlist:
exec("self.tree_out." + i + "=0")
self.ltree.Branch(i, AddressOf(self.tree_out, i), i + "/D")
#particles array
self.particles_out = TClonesArray("TParticle")
self.particles_out.SetOwner(True)
self.ltree.Branch("particles", self.particles_out)
atexit.register(self.close_root)
def load_phase_template(self, path):
from ROOT import TTree, TFile, gROOT, AddressOf
gROOT.ProcessLine("""struct fidSettings_t {
Double_t const_baseline;
Double_t const_baseline_used;
Double_t edge_width;
Double_t edge_ignore;
Double_t start_amplitude;
Double_t baseline_freq_thresh;
Double_t filter_low_freq;
Double_t filter_high_freq;
Double_t filter_freq_width;
Double_t fft_peak_width;
Double_t centroid_thresh;
Double_t hyst_thresh;
Double_t snr_thresh;
Double_t len_thresh;
Double_t t0_shift;
Double_t t0_shift_corr;
Double_t LengthReduction;
Double_t LengthReduction1;
Double_t LengthReduction2;
Double_t LengthReduction3;
Double_t SpikeThreshold;
Double_t FreqTemplate[378];
Double_t PhaseTemplate[378*4096];
Int_t PhaseTemplateN;
Int_t fit_range_scheme;
Int_t phase_fit_scheme;
Int_t SmoothWidth;
UInt_t TruncateBeginning;
UInt_t TruncateEnd;
UInt_t ZeroPadding;
UInt_t const_baseline_start;
UInt_t const_baseline_end;
UInt_t baseline_mode;
UInt_t baseline_event;
UInt_t SmoothIteration;
UInt_t poln;
UInt_t auto_filter_window;
UInt_t higher_order_correction;
UInt_t ha_npar;
UInt_t NSample;
UInt_t CompareDistance;
UInt_t HalfVetoWindow;
UInt_t FitStart[378];
UInt_t FitEnd[378];
UInt_t NZeros[378];
char filter[64];
char PhaseTemplateFile[128];
char TemplatePath[128];
char FitRangeTemplateFile[128];}""")
from ROOT import fidSettings_t
data = fidSettings_t()
f = TFile(path)
tree = f.Get("SettingsCollector/settings")
tree.SetBranchAddress("FixedProbeFid", AddressOf(data,"const_baseline"))
tree.GetEntry(0)
self.phase_template = np.array(np.frombuffer(data.PhaseTemplate, dtype='double').reshape([378,4096]))
self.frequency_template = np.array(np.frombuffer(data.FreqTemplate, dtype='double').reshape(378))
def create_simple_tree(nevents):
"""Create a simple TTree with a couple of branches."""
t = TTree('aTTree','A TTree')
t.Branch('run', AddressOf(pytree, 'run'),'run/I')
t.Branch('evt', AddressOf(pytree, 'evt'),'evt/I')
t.Branch('x', AddressOf(pytree, 'x'),'x/F')
t.Branch('y', AddressOf(pytree, 'y'),'y/F')
t.Branch('z', AddressOf(pytree, 'z'),'z/F')
for i in range(nevents):
pytree.run = 1 if (i<500) else 2
pytree.evt = i
pytree.x = gauss(0., 10.)
pytree.y = gauss(0, 10.)
pytree.z = gauss(5., 50.)
t.Fill()
return t
def save_delta_VTHR_root(self):
"""
Save the information about thr and baseline in a root file
:return:
"""
if self.primo_giro:
gROOT.ProcessLine('struct TreeStruct2 {\
int layer_id;\
int gemroc_id;\
int software_feb_id;\
int channel_id;\
int baseline_t;\
int baseline_e;\
int vth1;\
int vth2;\
int delta_vth1_baseline;\
int delta_vth2_baseline;\
float thr_t_fC;\
float thr_e_fC;\
};')
self.primo_giro=False
rootFile = ROOT.TFile("delta_vth.root", 'recreate')
tree = ROOT.TTree('tree', '')
mystruct = ROOT.TreeStruct2()
for key in ROOT.TreeStruct2.__dict__.keys():
if '__' not in key:
formstring = '/F'
if isinstance(mystruct.__getattribute__(key), int):
formstring = '/I'
tree.Branch(key, AddressOf(mystruct, key), key + formstring)
for GEMROC in range(0, 11):
if GEMROC < 4:
lyr = 1
elif GEMROC < 11:
lyr = 2
else:
lyr = 3
for TIGER in range(0, 8):
for ch in range(0, 64):
mystruct.layer_id = int(lyr)
mystruct.gemroc_id = (int(GEMROC))
mystruct.software_feb_id = int(TIGER)
mystruct.channel_id = int(ch)
mystruct.baseline_t = int(self.real_baseline_T[GEMROC][TIGER][ch])
mystruct.baseline_e = int(self.real_baseline_E[GEMROC][TIGER][ch])
mystruct.vth1 = int(self.thr_matrix_T[GEMROC][TIGER][ch])
mystruct.vth2 = int(self.thr_matrix_E[GEMROC][TIGER][ch])
mystruct.delta_vth1_baseline = int(self.real_baseline_T[GEMROC][TIGER][ch]-self.thr_matrix_T[GEMROC][TIGER][ch])
mystruct.delta_vth2_baseline = int(self.real_baseline_E[GEMROC][TIGER][ch]-self.thr_matrix_E[GEMROC][TIGER][ch])
mystruct.thr_t_fC = float(self.real_baseline_T[GEMROC][TIGER][ch]-self.thr_matrix_T[GEMROC][TIGER][ch])*0.42
mystruct.thr_e_fC = float(self.real_baseline_E[GEMROC][TIGER][ch]-self.thr_matrix_E[GEMROC][TIGER][ch])*0.42
tree.Fill()
rootFile.Write()
rootFile.Close()
os.system("root -l convert_VTH.cxx")
os.system("rm delta_vth.root")
def test05WriteSomeDataObjectBranched( self ):
"""Test writing of a complex object across different branches"""
f = TFile( self.fname, 'RECREATE' )
t = TTree( self.tname, self.ttitle )
d = SomeDataStruct()
# note: for p2.2, which has incomplete support of property types,
# we need to keep a reference alive to the result of the property
# call, or it will be deleted too soon; for later pythons, it is
# safe to use d.Floats directly in the Branch() call
fl = d.Floats
t.Branch( 'floats', fl )
if exp_pyroot:
# The Branch pythonization expects an integer with the
# address of the field of the struct
addressof_nlabel = addressof( d, 'NLabel' )
addressof_label = addressof( d, 'Label' )
else:
# Old PyROOT has a bug in AddressOf(o, 'field').
# Instead of returning a buffer whose first position
# contains the address of the field, it just returns the
# address of the field (which is what we need here).
# addressof(o, 'field'), which is what we should really
# use, is also broken in old PyROOT, so we need to use
# AddressOf here
addressof_nlabel = AddressOf( d, 'NLabel' )
addressof_label = AddressOf( d, 'Label' )
t.Branch( 'nlabel', addressof_nlabel, 'NLabel/I' )
t.Branch( 'label', addressof_label, 'Label/C' )
for i in range( self.N ):
for j in range( self.M ):
d.Floats.push_back( i*self.M+j )
d.NLabel = i
d.Label = '%d' % i
t.Fill()
f.Write()
f.Close()
def test14OpaquePointerPassing(self):
"""Test passing around of opaque pointers"""
import ROOT
s = TString("Hello World!")
co = AsCObject(s)
if self.exp_pyroot:
# In new Cppyy, addressof returns an integer/long
ad = AddressOf(s)
else:
ad = AddressOf(s)[0]
self.assert_(s == BindObject(co, s.__class__))
self.assert_(s == BindObject(co, "TString"))
self.assert_(s == BindObject(ad, s.__class__))
self.assert_(s == BindObject(ad, "TString"))
def __setBranchAddress( self, tree, varname, holder ):
" Set tree branch varname to holder "
if not tree.GetBranchStatus(varname):
tree.SetBranchStatus( varname, True )
from ROOT import AddressOf
tree.SetBranchAddress( varname, AddressOf(holder, varname) )
self._debug("Set %s branch address on %s", varname, tree )
else:
self._debug("Already set %s branch address on %s", varname, tree)
def _bindBranches(self,name,items,datastore):
struct = self.myStructs[name]
if isinstance(datastore,dict):
tree = self.myTrees[name]
#print ROOT.selected_z_vars_holder.ell1LVec
for item in items:
#print name, item, getattr(struct,item)
if ( isinstance(datastore[item],int) or
isinstance(datastore[item],bool) ):
tree.Branch(item,
AddressOf(struct,item),
'%s/I'%item)
elif isinstance(datastore[item],float):
tree.Branch(item,
AddressOf(struct,item),
'%s/F'%item)
elif isinstance(datastore[item],long):
tree.Branch(item,
AddressOf(struct,item),
'%s/L'%item)
elif isinstance(datastore[item],ROOT.TObject):
tree.Branch(item,
datastore[item].Class().GetName(),
self.myDicts[name][item])
else:
raise Exception("Type %s not supported"%type(datastore[item]))
elif isinstance(datastore,TTree):
tree = self.importedTrees[name]
leaves = tree.GetListOfLeaves()
size = leaves.GetEntries()
for i in range(size):
leafName = leaves.At(i).GetName()
#sanitize leafnames... weirdness
if leafName[-1] == '_':
leafName = leafName[0:-1]
if ( items is None or
leafName in items ):
tree.SetBranchAddress(leafName,
AddressOf(struct,leafName))
else:
print "Data store type %s is not supported!"%(str(type(datastore)))
exit(1)
def get_bins(tree, bnam, bmatch, prec, ons, delt):
#load tracks momenta to lists for all and matched tracks
tree.SetBranchStatus("*", 0)
tree.SetBranchStatus(bnam[0], 1)
tree.SetBranchStatus(bnam[1], 1)
tree.SetBranchStatus(bmatch[0], 1)
tree.SetBranchStatus(bmatch[1], 1)
#C++ structure for tree entry
gROOT.ProcessLine("struct Entry {Double_t p0, p1; Bool_t match0, match1;};")
entry = rt.Entry()
tree.SetBranchAddress(bnam[0], AddressOf(entry, "p0"))
tree.SetBranchAddress(bnam[1], AddressOf(entry, "p1"))
tree.SetBranchAddress(bmatch[0], AddressOf(entry, "match0"))
tree.SetBranchAddress(bmatch[1], AddressOf(entry, "match1"))
#momenta values for all and matched tracks
valAll = rt.list(double)()
valSel = rt.list(double)()
for i in xrange(tree.GetEntriesFast()):
tree.GetEntry(i)
valAll.push_back(entry.p0)
valAll.push_back(entry.p1)
if entry.match0 == 1: valSel.push_back(entry.p0)
if entry.match1 == 1: valSel.push_back(entry.p1)
tree.ResetBranchAddresses()
#bin edges
bins = vector(rt.double)()
t0 = time()
#runs faster when the algorithm is in plain ROOT
gROOT.LoadMacro("get_bins.C")
rt.get_bins(bins, valAll, valSel, prec, ons, delt)
t1 = time()
print "Time to calculate the bins (sec):", t1-t0
return bins
def mkdir_cd_rootfile(root_file_, folder_path_):
from ROOT import AddressOf
try:
AddressOf(root_file_.GetDirectory(folder_path_))
except ValueError:
root_file_.mkdir(folder_path_)
root_file_.cd(folder_path_)
return root_file_.GetDirectory(folder_path_)
def save_delta_VTHR_root(self):
"""
Save the information about thr and baseline in a root file
:return:
"""
gROOT.ProcessLine('struct TreeStruct2 {\
int layer_id;\
int gemroc_id;\
int software_feb_id;\
int channel_id;\
int baseline;\
int vth1_digit;\
int vth2_digit;\
float vth1_mV;\
float vth2_mV;\
};')
rootFile = ROOT.TFile("thresholds.root", 'recreate')
tree = ROOT.TTree('tree', '')
mystruct = ROOT.TreeStruct2()
for key in ROOT.TreeStruct2.__dict__.keys():
if '__' not in key:
formstring = '/F'
if isinstance(mystruct.__getattribute__(key), int):
formstring = '/I'
tree.Branch(key, AddressOf(mystruct, key), key + formstring)
for GEMROC in range(0, 4):
for TIGER in range(0, 8):
for ch in range(0, 64):
mystruct.layer_id = int(1)
mystruct.gemroc_id = (int(GEMROC))
mystruct.software_feb_id = int(TIGER)
mystruct.channel_id = int(ch)
mystruct.vth1_digit = int(self.thr_matrix_T[GEMROC][TIGER][ch])
mystruct.vth2_digit = int(self.thr_matrix_E[GEMROC][TIGER][ch])
mystruct.vth1_mV = float(mystruct.vth1_digit*step+base_value)
mystruct.vth2_mV = float(mystruct.vth2_digit*step+base_value)
tree.Fill()
for GEMROC in range(4, 11):
for TIGER in range(0, 8):
for ch in range(0, 64):
mystruct.layer_id = int(2)
mystruct.gemroc_id = (int(GEMROC))
mystruct.software_feb_id = int(TIGER)
mystruct.channel_id = int(ch)
mystruct.baseline = int(self.real_baseline_T[GEMROC][TIGER][ch])
mystruct.vth1_digit = int(self.thr_matrix_T[GEMROC][TIGER][ch])
mystruct.vth2_digit = int(self.thr_matrix_E[GEMROC][TIGER][ch])
mystruct.vth1_mV = float(mystruct.vth1_digit*step+base_value)
mystruct.vth2_mV = float(mystruct.vth2_digit*step+base_value)
tree.Fill()
rootFile.Write()
rootFile.Close()
def extract_baseline(self):
"""
Excrat the baseline values and write them in a pickle (and in a root file)
:return:
"""
# Create root file and tree
map_file = ROOT.TFile.Open("mapping_IHEP_L2_2planari_penta.root")
mapping_matrix = {1: {}, 2: {}, 3: {}, 0: {}}
for event in map_file.tree:
mapping_matrix[event.layer_id][event.HW_FEB_id, event.chip_id] = [
event.gemroc_id, event.SW_FEB_id
]
gROOT.ProcessLine('struct TreeStruct {\
int layer_id;\
int hardware_FEB_id;\
int chip_id;\
int channel_id;\
float baseline;\
};')
rootFile = ROOT.TFile("baselines.root", 'recreate')
tree = ROOT.TTree('tree', '')
mystruct = ROOT.TreeStruct()
for key in ROOT.TreeStruct.__dict__.keys():
if '__' not in key:
formstring = '/F'
if isinstance(mystruct.__getattribute__(key), int):
formstring = '/I'
tree.Branch(key, AddressOf(mystruct, key), key + formstring)
for root, dirs, files in os.walk(self.run_path):
for scan_file, (layer, HW_FEB, chip, others) in glob2.iglob(
root + sep + "L*FEB*_c*_VTH*.dat",
with_matches=True,
recursive=True):
importer = dt.Import_Data("./", scan_file, False)
try:
GEMROC_ID, TIGER_ID = mapping_matrix[int(layer)][
int(HW_FEB), int(chip)]
for ch in range(0, 64):
data = importer.labVIEW_data[ch][0]['tot_evts']
self.baseline_from_calib_matrix[GEMROC_ID][TIGER_ID][
ch] = int((np.argmax(data)))
# if GEMROC_ID==6 and TIGER_ID==7:
# input("Ho preso per gemroc {}, tiger {} dal file {}".format(GEMROC_ID,TIGER_ID,scan_file))
mystruct.layer_id = int(layer)
mystruct.hardware_FEB_id = int(HW_FEB)
mystruct.chip_id = int(chip)
mystruct.channel_id = int(ch)
mystruct.baseline = int((np.argmax(data)))
tree.Fill()
except KeyError:
print("{} is spare FEB".format(HW_FEB))
rootFile.Write()
rootFile.Close()
def book(self):
structcode = ['struct', 'struct_name', '{']
for var, type in self.vars.iteritems():
structcode.append('{type} {var};'.format(type=type, var=var))
structcode.append('};')
gROOT.ProcessLine(' '.join(structcode))
from ROOT import struct_name
self.s = struct_name()
for var, type in self.vars.iteritems():
self.ttree.Branch(var, AddressOf(self.s, var),
'/'.join([var, self.shortType(type)]))
self.reinit()
def _preSetsLoop(self):
""" Just build a tree to keep information of each set of toy """
self.otree = ROOT.TTree("tree", "")
self.treeContent = ROOT.MyTreeContent()
self.otree.Branch("fl", AddressOf(self.treeContent, 'fl'), 'fl/D')
self.otree.Branch("afb", AddressOf(self.treeContent, 'afb'), 'afb/D')
self.otree.Branch("fs", AddressOf(self.treeContent, 'fs'), 'fs/D')
self.otree.Branch("transAs", AddressOf(self.treeContent, 'transAs'), 'as/D')
self.otree.Branch("nSig", AddressOf(self.treeContent, 'nSig'), 'nSig/D')
self.otree.Branch("nBkgComb", AddressOf(self.treeContent, 'nBkgComb'), 'nBkgComb/D')
self.otree.Branch("nll", AddressOf(self.treeContent, 'nll'), 'nll/D')
def write_root(self, NUM):
path = "noise.n"
gROOT.ProcessLine('struct TreeStruct {\
int layer_id;\
int gemroc_id;\
int tiger_id;\
float noise_lvl;\
int channel_id;\
float variance;\
};')
rname = path.replace(".n", ".root")
rootFile = ROOT.TFile(rname, 'recreate')
tree = ROOT.TTree('tree', '')
mystruct = ROOT.TreeStruct()
for key in ROOT.TreeStruct.__dict__.keys():
if '__' not in key:
formstring = '/F'
if isinstance(mystruct.__getattribute__(key), int):
formstring = '/I'
tree.Branch(key, AddressOf(mystruct, key), key + formstring)
if type(NUM) == tuple:
first = NUM[0]
last = NUM[1] + 1
else:
first = NUM
last = NUM + 1
for G in range(first, last):
filename = "GEMROC{}".format(G) + sep + "noise.n"
with open(filename, 'r') as file:
linee = file.readlines()
for linea in linee:
mystruct.gemroc_id = G
mystruct.tiger_id = int(linea.split()[2].replace("TIG", ""))
mystruct.channel_id = int(linea.split()[3].replace("CH", ""))
mystruct.noise_lvl = float(linea.split()[5])
mystruct.variance = float(linea.split()[7])
if G < 4:
mystruct.layer_id = 1
elif G < 11:
mystruct.layer_id = 2
else:
mystruct.layer_id = 3
tree.Fill()
rootFile.Write()
rootFile.Close()
def test13WriteMisnamedLeaf(self):
"""Test writing of an differently named leaf"""
f = TFile(self.fname, 'RECREATE')
t = TTree(self.tname, self.ttitle)
s = SomeDataStruct()
t.Branch('cpu_packet_time', AddressOf(s, 'NLabel'), 'time/I')
for i in range(self.N):
s.NLabel = i
t.Fill()
f.Write()
f.Close()
def main(input_folder, output_folder, iCore, nCores):
mySPP = SPP()
f = TFile(str(output_folder) + 'MC_FS_SPP.root', 'RECREATE')
tree = TTree('SPP', 'Just A Tree')
tree.Branch('ASIC', AddressOf(mySPP, 'fAsicID'), 'AsicID/I')
tree.Branch('Col', AddressOf(mySPP, 'fCol'), 'Col/I')
tree.Branch('Row', AddressOf(mySPP, 'fRow'), 'Row/I')
tree.Branch('Original_BCID', AddressOf(mySPP, 'fOriginal_BCID'),
'Original_BCID/I')
tree.Branch('Full_BCID', AddressOf(mySPP, 'fFull_BCID'), 'Full_BCID/I')
tree.Branch('Hitmap', AddressOf(mySPP, 'fHitmap'), 'Hitmap/C')
tree.Branch('Hitmap_I', AddressOf(mySPP, 'fHitmap_I'), 'Hitmap_I/I')
fileList = []
for iFile in glob.glob(os.path.join(str(input_folder), '*.txt')):
fileList.append(iFile)
for thisFile in fileList:
asicID = int(
((thisFile.split('/')[1]).split('.')[0]).split('desync')[1])
if asicID % nCores == iCore:
print 'Processing file:', thisFile
with open(thisFile) as i_file:
raw_data = i_file.read().split('\n')
spp_list = split_spp(raw_data)
spp_sorted = time_sort(spp_list)
cycle = 0
prevBCID = -1
for each_spp in spp_sorted:
if int(each_spp) != 0:
myBCID = gtoi(each_spp[:9])
if myBCID < prevBCID:
cycle += 1
if cycle == 21:
break
prevBCID = myBCID
mySPP.fAsicID = asicID
mySPP.fCol = int(each_spp[9:16], 2) #7 bits: from 0 to 128
mySPP.fRow = int(each_spp[16:22], 2) #6 bits: from 0 to 64
mySPP.fOriginal_BCID = myBCID
mySPP.fFull_BCID = myBCID + 512 * (cycle % 7)
mySPP.fHitmap = str(
each_spp[22:]) # note string assignment
mySPP.fHitmap_I = int(each_spp[22:],
2) # note string assignment
tree.Fill()
f.Write()
f.Close()
