def test_chain(self):
self.store = EventStore([self.filename, self.filename])
rootfile = TFile(self.filename)
events = rootfile.Get(str('events'))
numbers = []
for iev, event in enumerate(self.store):
evinfo = self.store.get("info")
numbers.append(evinfo[0].Number())
self.assertEqual(iev + 1, 2 * events.GetEntries())
# testing that numbers is [0, .. 1999, 0, .. 1999]
self.assertEqual(numbers, list(range(events.GetEntries())) * 2)
# trying to go to an event beyond the last one
self.assertRaises(ValueError, self.store.__getitem__, 4001)
# this is in the first event in the second file,
# so its event number should be 0.
self.assertEqual(self.store[2000].get("info")[0].Number(), 0)
from ROOT import gSystem
from EventStore import EventStore
gSystem.Load("libdatamodelDict")
storeWithNoise = EventStore(['output_ecalReco_flatNoise_test.root'])
storeNoNoise = EventStore(['output_ecalReco_noNoise_test.root'])
for event in storeWithNoise:
clusters = event.get('caloClusters')
assert (len(clusters) == 1)
for event in storeNoNoise:
clusters = event.get('caloClusters')
assert (len(clusters) == 1)
def cellPosGdml(cellId):
z = (cellId % cellNo - cellNo / 2) * cellSize
x = ((cellId / (cellNo * cellNo)) - cellNo / 2) * cellSize
y = ((cellId / cellNo % cellNo) - cellNo / 2) * cellSize
return array('d', (x, y, z))
def cmpId(cellIdGdml, cellIdDd4hep):
IdGdml = cellIdGdml(cellIdGdml)
IdDd4hep = cellIdDd4hep(cellIdDd4hep)
return bool(IdGdml == IdDd4hep)
if __name__ == "__main__":
gSystem.Load("libdatamodelDict")
storeGdml = EventStore(["testCellId_gdml.root"])
storeDD4hep = EventStore(["testCellId_dd4hep.root"])
gdmlPos = []
for iev, event in enumerate(storeGdml):
hits = event.get('caloHits')
for hit in hits:
cellId = hit.Core().Cellid
gdmlPos.append(cellPosGdml(cellId))
dd4hepPos = []
for iev, event in enumerate(storeDD4hep):
hits = event.get('caloHits')
for hit in hits:
cellId = hit.Core().Cellid
dd4hepPos.append(cellPosDd4hep(cellId))
assert (gdmlPos == dd4hepPos)
histFCC_1 = TH1F("FCCee_1", "; z [mm]; hits / cm^{2} / BX", 25, -125, 125)
histFCC_2 = TH1F("FCCee_2", "; z [mm]; hits / cm^{2} / BX", 25, -125, 125)
histFCC_3 = TH1F("FCCee_3", "; z [mm]; hits / cm^{2} / BX", 25, -125, 125)
histFCC_4 = TH1F("FCCee_4", "; z [mm]; hits / cm^{2} / BX", 25, -125, 125)
histFCC_5 = TH1F("FCCee_5", "; z [mm]; hits / cm^{2} / BX", 25, -125, 125)
histFCC_6 = TH1F("FCCee", "; z [mm]; hits / cm^{2} / BX", 25, -125, 125)
histR_2d = TH2F("FCCee", "; z [mm]; Radius [mm]", 25, -125, 125, 6, 0, 60)
histR = TH1F("FCCee", "; Radius [mm]; Occupancy", 6, 0, 60)
index = 22
directory = "shielding"
fcc_file_name = "/afs/cern.ch/work/n/nali/Fellow/SoftwareFCC/FCCSW/SimuOutput/" + directory + "/allEvents.root"
store = EventStore([fcc_file_name])
radius_1 = 1 # cm
radius_2 = 1 # cm
radius_3 = 1 # cm
radius_4 = 1 # cm
radius_5 = 1 # cm
radius_6 = 1 # cm
for event in store:
hits = event.get(readout)
for i in range(0, hits.size()):
energy = hits[i].core().energy * 1e6
cellid = hits[i].core().cellId
zpos = hits[i].position().z
from ROOT import gSystem
from EventStore import EventStore
import csv
gSystem.Load("libdatamodelDict")
filename = "test"
store = EventStore([filename + ".root"])
with open(filename + '.csv', 'w') as csvfile:
csv_writer = csv.writer(csvfile, delimiter=',')
csv_writer.writerow(["x", "y", "z", "cellId", "energy", "time"])
for event in store:
hits = event.get("positionedHits")
print "====================", hits.size()
for i in range(0, hits.size()):
print "x=", hits[i].position().x
print "y=", hits[i].position().y
print "z=", hits[i].position().z
cellid = hits[i].core().cellId
print "system=", cellid % 16
#csv_writer.writerow([hits[i].position().x, hits[i].position().y, hits[i].position().z, hits[i].core().cellId, hits[i].core().energy, hits[i].core().time])
bla = raw_input()
from ROOT import gSystem
from EventStore import EventStore
gSystem.Load("libdatamodelDict")
store = EventStore(['out_full_moreEvents.root'])
entries = [300, 622, 942, 152, 135, 233, 501, 286, 77, 820]
for iev, event in enumerate(store):
if (iev < 10):
particles = event.get('allGenParticles')
print(entries[iev], len(particles))
assert (len(particles) == entries[iev])
def test_context_managers(self):
with EventStore([self.filename]) as store:
self.assertTrue(len(store) >= 0)
self.assertTrue(store.isValid())
print "creating root file and trees ..."
f = ROOT.TFile(args.output, "recreate")
t = ROOT.TTree('processedEvents', 'tree with processed fcc data')
psvb = t.Branch("primaryStartVertices", primaryStartVertexVector)
pevb = t.Branch("primaryEndVertices", primaryEndVertexVector)
ssvb = t.Branch("secondaryStartVertices", secondaryStartVertexVector)
sevb = t.Branch("secondaryEndVertices", secondaryEndVertexVector)
hb = t.Branch("hitProducingStartVertices", hitProducingStartVertices)
def r(point):
return np.sqrt(point.x**2 + point.y**2 + point.z**2)
events = EventStore([args.filename])
if args.nevents == -1:
args.nevents = len(events)
print len(events), " events in rootfile ", args.filename
j = 0
k = 0
print ""
for i, store in enumerate(events):
print ".",
if i > args.nevents:
break
trackId2Vertex = {}
trackId2Particle = {}
graph = nx.DiGraph()
simparticles = store.get("simParticles")
from ROOT import gSystem
from EventStore import EventStore
gSystem.Load("libdatamodelDict")
store_signal = EventStore(["./output_geant_pgun_fullsim.root"])
store_pileup = EventStore(["./tracker_with_field.root"])
store_merged = EventStore(["./output_overlaid_with_pileup.root"])
assert (len(store_merged) <= len(store_signal))
# assuming that the pileup read wasn't randomized for this test
# and that just one pileup event was overlaid, as in the current overlay example
for iev in range(len(store_merged)):
event_signal = store_signal[iev]
event_pileup = store_pileup[iev]
event_merged = store_merged[iev]
particles_signal = event_signal.get('allGenParticles')
particles_pileup = event_pileup.get('allGenParticles')
particles_merged = event_merged.get("overlaidGenParticles")
# check that the right number of particles are present
assert (len(particles_merged) == len(particles_signal) +
len(particles_pileup))
total_px_signal = 0
total_px_pileup = 0
total_px_merged = 0
for i in range(len(particles_signal)):
s = particles_signal[i]
from ROOT import gSystem
from EventStore import EventStore
gSystem.Load("libdatamodelDict")
store = EventStore(["./pythia_test.root"])
store_after = EventStore(["./test.root"])
nevts = min(len(store_after), len(store))
for iev in range(nevts):
event_after = store_after[iev]
event = store[iev]
particles_before = event.get("allGenParticles")
particles_after = event_after.get('allGenParticles')
assert (len(particles_before) == len(particles_after))
for before, after in zip(particles_before, particles_after):
assert (before.core().p4.px == after.core().p4.px)
assert (before.core().p4.py == after.core().p4.py)
assert (before.core().p4.pz == after.core().p4.pz)
from math import floor
def pos2cell(pos):
return int(floor((pos + 0.5 * cellSize) / cellSize))
def z2cell(z):
return int(floor((z - width / 2. + 0.5 * cellSize) / cellSize))
if __name__ == "__main__":
gSystem.Load("libdatamodelDict")
store = EventStore(["./out_simpleTrackerSD_2cm.root"])
for iev, event in enumerate(store):
hitsClus = event.get('hitClusterAssociation')
print(len(hitsClus))
for assoc in hitsClus:
hit = assoc.Hit()
clu = assoc.Cluster()
cellId = hit.Core().Cellid
hxx = x(cellId)
hyy = y(cellId)
hzz = z(cellId)
hE = hit.Core().Energy
cxx = pos2cell(clu.Core().position.X)
cyy = pos2cell(clu.Core().position.Y)
czz = z2cell(clu.Core().position.Z)
cE = clu.Core().Energy
interface1 = NrfInterface(0x10, 'Nrf24', 26, False) #interface 1
interface2 = BleInterface(0x20, 'BT Smart', 20, False) #interface 2
interface3 = TcpIpInterface(0x30, 'TCP IP', 65535, False) #interface 2
transport = TransportHandler(rq, rsq)
transport.addInterface(interface1.name, interface1)
transport.addInterface(interface2.name, interface2)
transport.addInterface(interface3.name, interface3)
transport.initialize()
handle = RequestHandler(0, 'dss', 'models/iot-lite.rdf',
rsq) #protocol handler
tspace = Space(tq)
tregistry = Registry()
tfactory = ThingFactory()
estore = EventStore(tq)
transport.start(
) #start listening on all the initialized network interfaces
tspace.start()
logging.debug("Server started")
estore.start()
print("Server running...")
#st = time.time()
cntr = 0
while (True): #run forever
if (not rq.empty()): #if there is a request in the queue
fullrqst = rq.get(
) #get the request from the queue - includes the transport
rqst = fullrqst[1]
cntr += 1
from ROOT import gSystem
from EventStore import EventStore
gSystem.Load("libedm4hepDict")
store = EventStore(['test_geant_fullsim_moreEvents.root'])
#entries = [300, 622, 942, 152, 135, 233, 501, 286, 77, 820]
entries = [1] * 10
for iev, event in enumerate(store):
if (iev < 10):
particles = event.get('GenParticles')
print(entries[iev], len(particles))
assert (len(particles) == entries[iev])
from ROOT import gSystem
from EventStore import EventStore
# refer to HepMCFromScratch for the particle tree that is checked here
if __name__ == "__main__":
gSystem.Load("libdatamodelDict")
store = EventStore(["test_hepmc_graph.root"])
for iev, event in enumerate(store):
parts = event.get('allGenParticles')
vertices = event.get('allGenVertices')
# event contains 8 particles, intermediate and final
assert (len(parts) == 8)
part1 = parts[3]
part2 = parts[4]
endvertex1 = part1.endVertex()
startvertex2 = part2.startVertex()
# part2 is the daughter of part1, so they should share a vertex
assert (endvertex1 == startvertex2)
from ROOT import gSystem
from EventStore import EventStore
gSystem.Load("libdatamodelDict")
store = EventStore(['output_ecalReco_test.root'])
for event in store:
clusters = event.get('caloClusters')
assert (len(clusters) == 1)
def z(cellId):
return retrieve(cellId, 0b000000000000111111,0)
def y(cellId):
return retrieve(cellId, 0b000000111111000000,1*bitfieldsize)
def x(cellId):
return retrieve(cellId, 0b111111000000000000,2*bitfieldsize)
def cell(cellId):
return array('d',(x(cellId),y(cellId),z(cellId)))
if __name__ == "__main__":
gSystem.Load("libdatamodelDict")
store1 = EventStore(["./out_dd4hepTrackerSD_2cm.root"])
store2 = EventStore(["./out_simpleTrackerSD_2cm.root"])
bins = array('i',(cellNo, cellNo, cellNo))
axisMin = array('d',(-cellNo/2-0.5, -cellNo/2-0.5, -cellNo/2-0.5))
axisMax = array('d',(cellNo/2+0.5, cellNo/2+0.5, cellNo/2+0.5))
hist1 = THnSparseD('hist1','hist1', 3, bins, axisMin, axisMax)
hist2 = THnSparseD('hist2','hist2', 3, bins, axisMin, axisMax)
for iev, event in enumerate(store1):
hits = event.get('hits')
for hit in hits:
cellId = hit.cellId()
hE = hit.energy()
hist1.Fill(cell(cellId),hE)
for iev, event in enumerate(store2):
hits = event.get('hits')
for hit in hits:
from ROOT import gSystem
from EventStore import EventStore
gSystem.Load("libdatamodelDict")
storeExt = EventStore(["out_simpleTrackerSD_2cm.root"])
for iev, event in enumerate(storeExt):
genptcs = event.get('allGenParticles')
assert (len(genptcs) == 1.)
hits = event.get('hits')
hitsExt = len(hits)
storeInt = EventStore(["out_simpleTrackerSD_2cm.root"])
for iev, event in enumerate(storeInt):
genptcs = event.get('allGenParticles')
assert (len(genptcs) == 1.)
hits = event.get('hits')
hitsInt = len(hits)
assert (hitsExt == hitsInt)
from ROOT import gSystem
from EventStore import EventStore
from numpy import testing
centre_x = [1968.99, -675.552, 2142.64, -2023.78, -2229.37]
centre_y = [-0.8434, 2081.93, 685.885, 658.538, 6.85499]
centre_z = [0, 0, 0, 0, 0]
if __name__ == "__main__":
gSystem.Load("libdatamodelDict")
store = EventStore(["positions_ecalInclinedSim.root"])
for iev, event in enumerate(store):
positions = event.get('Positions')
for pos in positions:
x = pos.position().x
y = pos.position().y
z = pos.position().z
testing.assert_allclose(x , centre_x[iev], 1e-3, 1e-3)
testing.assert_allclose(y , centre_y[iev], 1e-3, 1e-3)
testing.assert_allclose(z , centre_z[iev], 1e-3, 1e-3)
from ROOT import gSystem
from EventStore import EventStore
gSystem.Load("libdatamodelDict")
#store = EventStore(["./pythia_test.root"])
store_after = EventStore(["./test.root"])
#print store
print(store_after)
for event in store_after:
particles_before = event.get("allGenParticles")
print(len(particles_before))
id = (no & mask)
id = id >> offset
if (signed):
id = id - 2**bitfieldsize if id >= 2**(bitfieldsize - 1) else id
return id
def sublayer(cellId):
# for bitfield system:4,subsystem:1,type:3,subtype:3,layer:8,sublayer:8,eta:10,phi:10
return retrieve(cellId, 0b00000000000000000000111111110000000000000000000,
19)
if __name__ == "__main__":
gSystem.Load("libdatamodelDict")
store = EventStore(["positions_ecalEndcapSim.root"])
for iev, event in enumerate(store):
positions = event.get('caloPositions')
for pos in positions:
x = pos.position().x
y = pos.position().y
z = pos.position().z
cellId = pos.core().cellId
layerId = sublayer(cellId)
# - 1 because the sublayer ID starts form ID=1
layerId -= 1
# detector begins at 5300, cryostat thickness of 50, bath of 90, margin 1.65, readout 1.2 => 5442.85
if layerId == 0:
# first active half-disc
layer_z = 5443.1
def test_no_file(self):
'''Test that non-accessible files are gracefully handled.'''
with self.assertRaises(ValueError):
self.store = EventStore('foo.root')
outtree.Branch("rechit_detid", rec_detid)
outtree.Branch("rechit_bits", rec_bits)
outtree.Branch("gen_pt", gen_pt)
outtree.Branch("gen_x", gen_x)
outtree.Branch("gen_y", gen_y)
outtree.Branch("gen_z", gen_z)
outtree.Branch("gen_eta", gen_eta)
outtree.Branch("gen_phi", gen_phi)
outtree.Branch("gen_energy", gen_energy)
outtree.Branch("gen_status", gen_status)
outtree.Branch("gen_pdgid", gen_pdgid)
outtree.Branch("gen_bits", gen_bits)
numEvent = 0
with EventStore([infile_name
]) as evs: # p.ex output of Examples/options/simple_pythia.py
for ev in evs:
ev_num[0] = numEvent
numHits = 0
E = .0
Ebench = .0
Eem = .0
Ehad = .0
EemLast = .0
EhadFirst = .0
etaGen = .0
phiGen = .0
energyGen = .0
if ev.get("GenParticles"):
from EventStore import EventStore
import os.path
import numpy as np
gROOT.ProcessLine(".L ~/CLICdpStyle/rootstyle/CLICdpStyle.C")
CLICdpStyle()
gStyle.SetOptStat(0)
gStyle.SetPadRightMargin(0.17)
gROOT.ForceStyle()
histNbLayers = TH2F("nb. of layers", "; #phi [deg]; Number of wires", 1440,
-180, 180, 5, 0, 5)
hist = TH1F("nb. of layers", "; #phi [deg]; Number of wires", 180, -180, 180)
filename = "/afs/cern.ch/work/n/nali/Fellow/SoftwareFCC/FCCSW/angleScan_layer1.root"
store = EventStore([filename])
pos = {}
for event in store:
hits = event.get("positionedHits")
phi = []
nb = hits.size()
#print "hit: ", hits.size()
for i in range(0, hits.size()):
xpos = hits[i].position().x
ypos = hits[i].position().y
cellID = hits[i].core().cellId
pos[cellId].append((x, y, z))
def main():
import argparse
#parse arguments from command line
parser = argparse.ArgumentParser(
description=
'This script does some validation plotting. One can simply pass teh input digit file and get some histograms. If one also passes the hits file, one gets direct comparisons of the two estimates of quantities'
)
parser.add_argument(
'--input',
dest='ifile',
help=
'Input file name. Leave empty to run with no input file (for example to debug sensor properties)'
)
parser.add_argument('--outputROOT',
dest='ofile',
help='Output file name',
default='output_digit.podio.root')
parser.add_argument('--inputHits',
dest='hitfile',
help='Optiona input hits file')
parser.add_argument('--debug',
action='store_true',
dest='debug',
default=False,
help='Print more debugging information')
parser.add_argument('--outputPdf',
dest='outPDF',
default='validation_output.pdf',
help='Name of teh output pdf file')
par = parser.parse_args()
filename = par.ifile
hitfilename = par.hitfile
ofilename = par.ofile
store = EventStore(filename)
storehit = None
ofile = ROOT.TFile(ofilename, "recreate")
ofile.mkdir("Digitization")
ofile.cd("Digitization")
h_list = []
h_c_fiber_energy = ROOT.TH1F("h_c_fiber_energy", "", 100, 0, -1)
h_c_fiber_energy.SetXTitle("Individual C fibre energy (arbitrary units)")
h_list.append(h_c_fiber_energy)
h_s_fiber_energy = ROOT.TH1F("h_s_fiber_energy", "", 100, 0, -1)
h_s_fiber_energy.SetXTitle("Individual S fibre energy (arbitrary units)")
h_list.append(h_s_fiber_energy)
h_c_fiber_time = ROOT.TH1F("h_c_fiber_time", "", 100, 0, -1)
h_c_fiber_time.SetXTitle("Individual C fibre time [ns]")
h_list.append(h_c_fiber_time)
h_s_fiber_time = ROOT.TH1F("h_s_fiber_time", "", 100, 0, -1)
h_s_fiber_time.SetXTitle("Individual S fibre time [ns]")
h_list.append(h_s_fiber_time)
h_c_energy = ROOT.TH1F("h_c_energy", "", 100, 0, -1)
h_c_energy.SetXTitle("Total C Energy (a.u.)")
h_list.append(h_c_energy)
h_s_energy = ROOT.TH1F("h_s_energy", "", 100, 0, -1)
h_s_energy.SetXTitle("Total S Energy (a.u.)")
h_list.append(h_s_energy)
h_c_time = ROOT.TH1F("h_c_time", "", 100, 0, -1)
h_c_time.SetXTitle("Average C time [ns]")
h_list.append(h_c_time)
h_s_time = ROOT.TH1F("h_s_time", "", 100, 0, -1)
h_s_time.SetXTitle("Average C time [ns]")
h_list.append(h_s_time)
h_n_s_fiber = ROOT.TH1F("h_n_s_fiber", "", 100, 0, -1)
h_n_s_fiber.SetXTitle("S fibre multiplicity")
h_list.append(h_n_s_fiber)
h_n_c_fiber = ROOT.TH1F("h_n_c_fiber", "", 100, 0, -1)
h_n_c_fiber.SetXTitle("C fibre multiplicity")
h_list.append(h_n_c_fiber)
c = ROOT.TCanvas()
if hitfilename != None:
storehit = EventStore(hitfilename)
ofile.mkdir("DigiVsHits")
ofile.cd("DigiVsHits")
h_c_ratio_simdigi = ROOT.TH1F("h_c_ratio_simdigi", "", 100, 0, -1)
h_c_ratio_simdigi.SetXTitle("Hit energy/Digi energy")
h_list.append(h_c_ratio_simdigi)
h_s_ratio_simdigi = ROOT.TH1F("h_s_ratio_simdigi", "", 100, 0, -1)
h_s_ratio_simdigi.SetXTitle("Hit energy/Digi energy")
h_list.append(h_s_ratio_simdigi)
for i, event in enumerate(store):
if i % 1000 == 0:
print('reading event', i)
c_hits = event.get("C_CalorimeterHits")
s_hits = event.get("S_CalorimeterHits")
tot_s_energy = 0
tot_c_energy = 0
tot_s_time = 0
tot_c_time = 0
n_s_fiber = 0
n_c_fiber = 0
for hit in c_hits:
h_c_fiber_energy.Fill(hit.getEnergy())
h_c_fiber_time.Fill(hit.getTime())
tot_c_energy = tot_c_energy + hit.getEnergy()
tot_c_time = tot_c_time + hit.getTime()
n_c_fiber = n_c_fiber + 1
for hit in s_hits:
h_s_fiber_energy.Fill(hit.getEnergy())
h_s_fiber_time.Fill(hit.getTime())
tot_s_energy = tot_s_energy + hit.getEnergy()
tot_s_time = tot_s_time + hit.getTime()
n_s_fiber = n_s_fiber + 1
if (n_s_fiber != 0):
tot_s_time = tot_s_time / n_s_fiber
if (n_c_fiber != 0):
tot_c_time = tot_c_time / n_c_fiber
h_c_energy.Fill(tot_c_energy)
h_s_energy.Fill(tot_s_energy)
h_c_time.Fill(tot_c_time)
h_s_time.Fill(tot_s_time)
h_n_s_fiber.Fill(n_s_fiber + 0.5)
h_n_c_fiber.Fill(n_c_fiber + 0.5)
# ok done, now let's try to access the hits as well
if hitfilename != None:
eventhits = storehit[i]
c_simhits = eventhits.get("C_caloHits")
s_simhits = eventhits.get("S_caloHits")
tot_s_hitenergy = 0
tot_c_hitenergy = 0
for hit in c_simhits:
tot_c_hitenergy = tot_c_hitenergy + hit.getEnergy()
for hit in s_simhits:
tot_s_hitenergy = tot_s_hitenergy + hit.getEnergy()
if (tot_c_energy != 0):
h_c_ratio_simdigi.Fill(tot_c_hitenergy / tot_c_energy)
if (tot_s_energy != 0):
h_s_ratio_simdigi.Fill(tot_s_hitenergy / tot_s_energy)
c.Print(par.outPDF + '[')
for h in h_list:
c.Clear()
h.Draw()
c.Print(par.outPDF)
c.Print(par.outPDF + ']')
ofile.Write()
ofile.Close()
from ROOT import gSystem
from EventStore import EventStore
gSystem.Load("libdatamodelDict")
store = EventStore(["./out_fast_simple.root"])
for iev, event in enumerate(store):
particles = event.get('smearedParticles')
print(len(particles))
assert (len(particles) > 0)
"""
Quick script to dump FCCSW tracker validation data to plaintext spacepoints.
Requires podio, fcc-edm in pythonpath and ld-library-path.
"""
from EventStore import EventStore
import numpy as np
import sys
filename = sys.argv[1]
basefilename = filename.replace(".root", "")
events = EventStore([filename])
print 'number of events: ', len(events)
pos_b = []
ids_b = []
pos_e = []
ids_e = []
barrel_ids = []
nEventsMax = 100000
#nEventsMax = 1
for i, store in enumerate(events):
# Only run over 100000 events
if i > nEventsMax:
break
# <class 'ROOT.fcc.PositionedTrackHitCollection'>
clusters = store.get('positionedHits')
#print clusters
layerIdmax = 0
return retrieve(sign, cellId, 0b000011110000,1*bitfieldsize)
def x(cellId, sign):
return retrieve(sign, cellId, 0b111100000000,2*bitfieldsize)
def cellPosDd4hep(cellId, sign):
if(sign):
return array('d',(x(cellId, sign)*cellSize,y(cellId, sign)*cellSize,z(cellId, sign)*cellSize))
return array('d',((x(cellId, sign)-cellNo/2)*cellSize,
(y(cellId, sign)-cellNo/2)*cellSize,
(z(cellId, sign)-cellNo/2)*cellSize))
if __name__ == "__main__":
gSystem.Load("libdatamodelDict")
storeSeg = EventStore(["testCellId_dd4hep_segmentation.root"])
storeVol = EventStore(["testCellId_dd4hep_volumes.root"])
segPos = []
for iev, event in enumerate(storeSeg):
hits = event.get('caloHits')
for hit in hits:
cellId = hit.Core().Cellid
segPos.append(cellPosDd4hep(cellId,True))
volPos = []
for iev, event in enumerate(storeVol):
hits = event.get('caloHits')
for hit in hits:
cellId = hit.Core().Cellid
volPos.append(cellPosDd4hep(cellId,False))
assert(segPos == volPos)
id = (no & mask)
id = id >> offset
if (signed):
id = id - 2**bitfieldsize if id >= 2**(bitfieldsize - 1) else id
return id
def sublayer(cellId):
# for bitfield system:4,subsystem:1,type:3,subtype:3,layer:8,sublayer:8,eta:10,phi:10
return retrieve(cellId, 0b00000000000000000000111111110000000000000000000,
19)
if __name__ == "__main__":
gSystem.Load("libdatamodelDict")
store = EventStore(["positions_ecalNegativeEndcapSim.root"])
for iev, event in enumerate(store):
positions = event.get('caloPositions')
for pos in positions:
x = pos.position().x
y = pos.position().y
z = pos.position().z
cellId = pos.core().cellId
layerId = sublayer(cellId)
# - 1 because the ID starts form ID=1
layerId -= 1
# detector begins at 5300, cryostat thickness of 50, bath of 90, margin 1.65, readout 1.2 => 5442.85
if layerId == 0:
# first active half-disc
layer_z = -5443.1
def setUp(self):
self.filename = 'example.root'
self.assertTrue( os.path.isfile(self.filename) )
self.store = EventStore(self.filename)
from ROOT import gSystem
from EventStore import EventStore
gSystem.Load("libdatamodelDict")
store = EventStore(['output_ecalReco_noiseFromFile_test.root'])
for event in store:
clusters = event.get('caloClusters')
assert (len(clusters) == 1)
