def make_DC_muon_hadron_hypothesis(frame, pdg=13):
new_muon = dataclasses.I3Particle()
new_muon.pos.x = temp_parameters[0]
new_muon.pos.y = temp_parameters[1]
new_muon.pos.z = temp_parameters[2]
new_muon.time = temp_parameters[5]
new_direction = dataclasses.I3Direction(temp_parameters[4],
temp_parameters[3])
new_muon.dir = new_direction
new_muon.length = temp_parameters[7]
new_muon.energy = temp_parameters[7] / muon_energy_loss
new_muon.pdg_encoding = pdg
hypothesis = dataclasses.I3VectorI3Particle()
hypothesis.append(new_muon)
new_hadron = dataclasses.I3Particle()
new_hadron.pos.x = temp_parameters[0]
new_hadron.pos.y = temp_parameters[1]
new_hadron.pos.z = temp_parameters[2]
new_hadron.time = temp_parameters[5]
#change temp_parameters to 3, to 4 here to say hadron and muon angles are the same
new_direction = dataclasses.I3Direction(temp_parameters[9],
temp_parameters[8])
new_hadron.dir = new_direction
new_hadron.energy = temp_parameters[6]
new_hadron.pdg_encoding = hadron_pdg
hypothesis.append(new_hadron)
frame["DC_cascade_hypothesis_" + str(event_counter)] = hypothesis
def make_DC_cascade_hypothesis(frame, pdg=11):
new_particle = dataclasses.I3Particle()
new_particle.pos.x = temp_parameters[0]
new_particle.pos.y = temp_parameters[1]
new_particle.pos.z = temp_parameters[2]
new_particle.time = temp_parameters[5]
new_direction = dataclasses.I3Direction(temp_parameters[4],
temp_parameters[3])
new_particle.dir = new_direction
new_particle.energy = temp_parameters[6]
new_particle.pdg_encoding = pdg
hypothesis = dataclasses.I3VectorI3Particle()
hypothesis.append(new_particle)
frame["DC_cascade_hypothesis_" + str(event_counter)] = hypothesis
def make_n_segment_vector(frame, fit, n=1):
if n % 2 == 0:
print "n=", n, "is even! Change this!"
sys.exit(910)
try:
basep = frame[fit]
except:
print "I don't see what you're looking for"
return True
#shift to closest approach to 0,0,0
origin_cap = phys_services.I3Calculator.closest_approach_position(
basep, dataclasses.I3Position(0, 0, 0))
#print origin_cap
basep_shift_d=numpy.sign(origin_cap.z - basep.pos.z) *\
numpy.sign(basep.dir.z) *\
(origin_cap-basep.pos).magnitude
#print basep_shift_d
basep_shift_pos = basep.shift_along_track(basep_shift_d)
#print basep_shift_pos
basep_shift_t = basep_shift_d / basep.speed
#print basep_shift_t
basep.pos = basep_shift_pos
basep.time = basep.time + basep_shift_t
segments = []
segment_length = 1950. / n
for idx in range(n):
dshift = segment_length * (idx - ((n - 1) / 2.))
particle = dataclasses.I3Particle()
particle.time = basep.time + (dshift / basep.speed)
particle.pos = basep.shift_along_track(dshift)
particle.dir = basep.dir
particle.energy = 0.01
if n == 1:
particle.shape = particle.shape.InfiniteTrack
particle.length = 0
else:
particle.shape = particle.shape.ContainedTrack
particle.length = segment_length
segments.append(particle)
del frame[fit + "_" + str(n) + "_segments"]
frame[fit + "_" + str(n) +
"_segments"] = dataclasses.I3VectorI3Particle(segments)
print "Put", fit + "_" + str(n) + "_segments", "in the frame"
del segments
def NSegmentVector(frame, FitName, N=1):
#Make Segments out of tracks, Required for STV aan TH (made by K.Jero)
if frame.Has(FitName):
if N % 2 == 0:
print "n=", N, "is even! Change this!"
sys.exit(910)
try:
basep = copy.deepcopy(frame[FitName])
except:
return True
basep.shape = basep.shape.InfiniteTrack
##shift to closest approach to 0,0,0
origin_cap = phys_services.I3Calculator.closest_approach_position(
basep, dataclasses.I3Position(0, 0, 0))
basep_shift_d = numpy.sign(origin_cap.z - basep.pos.z) * numpy.sign(
basep.dir.z) * (origin_cap - basep.pos).magnitude
basep_shift_pos = basep.pos + (basep.dir * basep_shift_d)
basep_shift_t = basep_shift_d / basep.speed
basep.pos = basep_shift_pos
basep.time = basep.time + basep_shift_t
segments = []
segment_length = 1950. / N
for idx in range(N):
dshift = segment_length * (idx - ((N - 1) / 2.))
particle = dataclasses.I3Particle()
particle.time = basep.time + (dshift / basep.speed)
particle.pos = basep.pos + (basep.dir * dshift)
particle.dir = basep.dir
particle.energy = 0.01
if N == 1:
particle.shape = particle.shape.InfiniteTrack
particle.length = 0
else:
particle.shape = particle.shape.ContainedTrack
particle.length = segment_length
segments.append(particle)
del frame[FitName + "_" + str(N) + "_segments"]
frame[FitName + "_" + str(N) +
"_segments"] = dataclasses.I3VectorI3Particle(segments)
# print "Put", FitName+"_"+str(N)+"_segments", "in the frame"
del segments
def FramePacket(self, frames):
partvec = dataclasses.I3VectorI3Particle()
mask = dataclasses.I3RecoPulseSeriesMapMask(
frames[0], self.pulseSourceName,
dataclasses.I3RecoPulseSeriesMap())
for frame in frames:
if (frame.Stop == icetray.I3Frame.Physics):
if (frame["I3EventHeader"].sub_event_stream == self.splitName):
primary = deepcopy(frame[self.fitName])
primary.type = dataclasses.I3Particle.MuMinus
primary.shape = dataclasses.I3Particle.ContainedTrack
primary.length = 500 #part.speed*(tr.start-tr.stop)
partvec.append(frame[self.fitName])
mask = mask | frame[self.recoMapName]
frame.Put("Primary", primary)
frames[0].Put(self.outputPrefix + self.recoMapName, mask)
frames[0].Put(self.outputPrefix + self.fitName, partvec)
for frame in frames:
self.PushFrame(frame)
#!/usr/bin/env python from icecube import dataclasses as dc v = dc.I3VectorI3Particle() dc.takes_vector_I3Particle(v)
def Physics(self, frame):
if not frame.Has(self.inputMapName):
self.PushFrame(frame)
return
if type(frame[self.inputMapName]) == dataclasses.I3RecoPulseSeriesMapMask or \
type(frame[self.inputMapName]) == dataclasses.I3RecoPulseSeriesMap:
workingOnPulses = True
else:
workingOnPulses = False
if frame.Has(self.inputTrack):
seed = frame[self.inputTrack]
if type(frame[self.inputTrack]) == dataclasses.I3MCTree:
seed = frame[self.inputTrack][0]
initialPos = [seed.pos.x, seed.pos.y, seed.pos.z]
initialDir = [
seed.speed * seed.dir.x, seed.speed * seed.dir.y,
seed.speed * seed.dir.z
]
initialState = initialPos + initialDir
else:
print("Kalman - Error: InputTrack not found")
self.PushFrame(frame)
return
## timewise sorted Pulses/DomLaunches - [(OMkey, Time, Pulse/DomLaunch)]
hitlist = hitfilter(frame, self.inputMapName, self.IgnoreDC)
if self.useAcceleration:
stateDim = 9
else:
stateDim = 6
## Initialize Kalman filter
kalman = Kalman(stateDim, 3, initialState, self.noiseQ, self.noiseR)
for i in range(self.iterations):
## create variables for results
prediction = dataclasses.I3VectorI3Particle()
if self.useAcceleration:
acceleration = dataclasses.I3VectorI3Particle()
varianceVector = dataclasses.I3VectorDouble()
if workingOnPulses:
recoPulseSeriesMapMask = dataclasses.I3RecoPulseSeriesMapMask(
frame, self.inputMapName)
recoPulseSeriesMapMask.set_none()
else:
domLaunchSeriesMap = dataclasses.I3DOMLaunchSeriesMap()
## write seed to predictionlist
seed = dataclasses.I3Particle()
seed.pos = dataclasses.I3Position(initialState[0], initialState[1],
initialState[2])
seed.dir = dataclasses.I3Direction(initialState[3],
initialState[4],
initialState[5])
seed.speed = np.linalg.norm(initialState[3:6])
seed.time = 0
prediction.append(seed)
## Write acceleration seed
if self.useAcceleration:
accel = dataclasses.I3Particle()
accel.pos = dataclasses.I3Position(0, 0, 0)
acceleration.append(accel)
## clean variables
hitList = []
predList = []
time = []
chi2 = 0
lastTime = 0
p = kalman.Predict()
## loop over all hits in given map
for hit in hitlist:
## extrapolate Kalman-Prediction
pos = p[0:3] + p[3:6] * (hit.time - lastTime)
om = np.array(self.geo.omgeo[hit.omkey].position)
## Distance to next hit
d = np.linalg.norm(om - pos)
if d <= self.cutRadius:
dt = hit.time - lastTime
lastTime = hit.time
## Update Kalman filter with new hit
kalman.Update(om, dt)
p = kalman.Predict()
## Uncomment to activate debug mode
#kalman.Debug()
## Add Kalman-step to predictionlist
pred = dataclasses.I3Particle()
pred.pos = dataclasses.I3Position(p[0], p[1], p[2])
pred.dir = dataclasses.I3Direction(p[3], p[4], p[5])
pred.speed = np.linalg.norm(p[3:6])
pred.time = hit.time
prediction.append(pred)
if self.useAcceleration:
accel = dataclasses.I3Particle()
accel.pos = dataclasses.I3Position(p[6], p[7], p[8])
acceleration.append(accel)
varianceVector.append(kalman.GetVariance()[0])
chi2 += d**2
## write PulseMapMask/DOMLaunchMap
if workingOnPulses:
recoPulseSeriesMapMask.set(hit.omkey, hit.info, True)
else:
if hit.omkey in domLaunchSeriesMap:
domLaunchSeriesMap[hit.omkey].append(hit.info)
else:
domLaunchSeries = dataclasses.I3DOMLaunchSeries()
domLaunchSeries.append(hit.info)
domLaunchSeriesMap[hit.omkey] = domLaunchSeries
hitList += [om]
predList += [p[0:3]]
time += [hit.time]
## new initialization for the next global iteration
if len(hitList) > 0:
## use last iteration as LineFit
if self.iterationMethod == 1:
x0 = p[0] - p[3] * hit.time
y0 = p[1] - p[4] * hit.time
z0 = p[2] - p[5] * hit.time
particle = dataclasses.I3Particle()
particle.pos = dataclasses.I3Position(x0, y0, z0)
particle.dir = dataclasses.I3Direction(p[3], p[4], p[5])
particle.speed = np.linalg.norm([p[3:6]])
particle.time = 0
elif self.iterationMethod == 2:
## calculate the LineFit on selected pulses
particle = LineFitCallKalman(hitList, time)
elif self.iterationMethod == 3:
## calculate the LineFit on iteration steps
particle = LineFitCallKalman(predList, time)
else:
raise NotImplementedError(
"No IterationMethod with number %s" %
str(self.IterationMethod))
## Last Iteration ?
if i < self.iterations - 1:
initialPos = [
particle.pos.x, particle.pos.y, particle.pos.z
]
initialDir = [
particle.speed * particle.dir.x,
particle.speed * particle.dir.y,
particle.speed * particle.dir.z
]
initialState = initialPos + initialDir
initialP = kalman.GetVarianceVector()
kalman = Kalman(stateDim, 3, initialState, self.noiseQ,
self.noiseR, initialP)
else:
## Write everything to the frame
frame["%s_LineFit" % (self.outputTrack)] = particle
frame["%s_NHits" %
(self.outputTrack)] = dataclasses.I3Double(
len(hitList))
frame["%s_P" % (self.outputTrack)] = varianceVector
frame["%s_Chi2Pred" %
(self.outputTrack)] = dataclasses.I3Double(
Chi2CallKalman(predList, time, particle))
if workingOnPulses:
frame["%s_Map" %
(self.outputTrack)] = recoPulseSeriesMapMask
else:
frame["%s_Map" %
(self.outputTrack)] = domLaunchSeriesMap
if self.additionalInformation:
frame["%s_Pred" % (self.outputTrack)] = prediction
if self.useAcceleration:
frame["%s_Accel" %
(self.outputTrack)] = acceleration
self.PushFrame(frame)
mypart.pos = dataclasses.I3Position(10.0 * icetray.I3Units.m,
10.0 * icetray.I3Units.m,
10.0 * icetray.I3Units.m)
mypart.time = 0.0 * icetray.I3Units.ns
mypart.energy = 1000.0 * icetray.I3Units.GeV
mypart.shape = dataclasses.I3Particle.InfiniteTrack
mypart.fit_status = dataclasses.I3Particle.OK
my_other_particle = mypart.clone()
# everything but the minor ID should be the same
# we could really use a compare clone method
assert (my_other_particle != mypart)
print(mypart)
print(my_other_particle)
mypartvec = dataclasses.I3VectorI3Particle()
mypartvec.append(mypart)
for party in mypartvec:
print(party)
#I3RecoPulse
print('Testing I3RecoPulse')
rp = dataclasses.I3RecoPulse()
rp.charge = 1.5 ## PEs
rp.time = 100.0 * icetray.I3Units.ns
rp.flags = dataclasses.I3RecoPulse.PulseFlags.ATWD
print(rp)
trigger_vect = dataclasses.I3VectorI3Trigger()
trigger_vect.append(dataclasses.I3Trigger())
from parser_options import *
params = RunParameters()
usage = "%usage: %prog [options]"
parser = OptionParser(usage)
parseOptions(parser, params)
Infile_List = glob.glob(params.Infile)
tray = I3Tray()
tray.AddModule("I3Reader", "reader", filenamelist=Infile_List)
#code to work through
tray.AddModule('PyMillipede',
'trueCascade_seed2',
Hypothesis=lambda fr: dataclasses.I3VectorI3Particle(
[fr['trueCascade_seed']]),
Output='pyMillipede_likelihood_tables',
ExcludedDOMs=ExcludedDOMs,
CascadePhotonicsService=cascade_tables,
MuonPhotonicsService=muon_tables,
Pulses=Pulses,
ReadoutWindow=ReadoutWindow)
tray.AddModule('TrashCan', 'Done')
if (params.NEvents == -1):
tray.Execute()
else:
tray.Execute(params.NEvents)
tray.Finish()
def make_n_segment_vector(frame, fit, n=1):
'''
Splits fit up into segments which is required for
StartingTrackVeto. If n=1, one infinite track segment
is saved to the frame. If n>1, finite track segements
are saved to the frame.
Inputs:
-------
-frame: I3Frame
-fit: I3Particle fit to be segemented and used
in StartingTackVeto
-n: number of segments to split fit up into
(must be odd!)
Outputs:
--------
-Save segments to frame as an I3Vector of I3Particles
'''
#Check that n is odd and fit exists in frame
if n % 2 == 0:
print("n =", n, "is even! change this!")
sys.exit(910)
try:
basep = frame[fit]
except:
print("I can't find the fit you want to segment")
return False
#Shift to closest approach position (cap) to the origin (0,0,0)
origin_cap = phys_services.I3Calculator.closest_approach_position(
basep, dataclasses.I3Position(0, 0, 0))
basep_shift_d = np.sign(origin_cap.z - basep.pos.z) *\
np.sign(basep.dir.z) *\
(origin_cap - basep.pos).magnitude
basep_shift_pos = basep.pos + (basep.dir * basep_shift_d)
basep_shift_t = basep_shift_d / basep.speed
basep.pos = basep_shift_pos
basep.time = basep.time + basep_shift_t
#Create segments
segments = []
segment_length = 1950. / n
for idx in range(n):
dshift = segment_length * (idx - ((n - 1) / 2.))
particle = dataclasses.I3Particle()
particle.time = basep.time + (dshift / basep.speed)
particle.pos = basep.pos + (basep.dir * dshift)
particle.dir = basep.dir
particle.energy = 0.01
if n == 1:
particle.shape = particle.shape.InfiniteTrack
particle.length = 0
else:
particle.shape = particle.shape.ContainedTrack
particle.length = segment_length
segments.append(particle)
#Save segments in frame
segments_str = fit + '_' + str(n) + '_segments'
rmdictvalue(frame, [segments_str])
frame[segments_str] = dataclasses.I3VectorI3Particle(segments)
print("Put", segments_str, "in the frame")
del segments
print garbage, llh_result.logl
for i in xrange(-10, 10):
tray = I3Tray()
tray.AddModule("I3Reader",
"reader",
filenamelist=[params.GCDfile] + Infile_List)
tray.AddModule(make_seed,
"make_seed_" + str(i),
garbage=i,
streams=[icetray.I3Frame.Physics])
tray.AddModule('PyMillipede',
'trueNeutrino_seed_' + str(i),
Hypothesis=lambda fr: dataclasses.I3VectorI3Particle(
[fr['trueNeutrino_seed_' + str(i)]]),
Output='pyMillipede_' + str(i),
ExcludedDOMs=ExcludedDOMs,
CascadePhotonicsService=cascade_tables,
MuonPhotonicsService=muon_tables,
Pulses=Pulses,
ReadoutWindow=ReadoutWindow)
tray.AddModule(print_llh, "print_llh_" + str(i), garbage=i)
tray.AddModule("I3Writer",
"writer",
filename=params.Outfile,
DropOrphanStreams=[icetray.I3Frame.DAQ],
streams=[icetray.I3Frame.DAQ, icetray.I3Frame.Physics])
tray.AddModule('TrashCan', 'Done')
def Physics(self, frame):
# get muon
muon = mu_utils.get_muon(
frame=frame,
primary=frame[self._primary_key],
convex_hull=self._convex_hull,
)
labels = dataclasses.I3MapStringDouble()
if self._write_vector:
binned_energy_losses, bin_center_pos = \
mu_utils.get_binned_energy_losses_in_cube(
frame=frame,
muon=muon,
bin_width=self._bin_width,
boundary=self._boundary,
return_bin_centers=self._write_vector
)
else:
binned_energy_losses = mu_utils.get_binned_energy_losses_in_cube(
frame=frame,
muon=muon,
bin_width=self._bin_width,
boundary=self._boundary,
return_bin_centers=self._write_vector)
# write to frame
labels['track_anchor_x'] = muon.pos.x
labels['track_anchor_y'] = muon.pos.y
labels['track_anchor_z'] = muon.pos.z
labels['track_anchor_time'] = muon.time
labels['azimuth'] = muon.dir.azimuth
labels['zenith'] = muon.dir.zenith
for i, energy_i in enumerate(binned_energy_losses):
# stop adding energy losses if we reached the maximum
if self._max_num_bins is not None:
if i >= self._max_num_bins:
msg = 'MaxNumBinsis set to {}. '.format(self._max_num_bins)
msg += 'Cutting off an additional {} losses!'.format(
len(binned_energy_losses) - self._max_num_bins)
log_warn(msg)
break
labels['EnergyLoss_{:05d}'.format(i)] = energy_i
# pad rest with NaNs
if self._max_num_bins is not None:
for i in range(len(binned_energy_losses), self._max_num_bins):
labels['EnergyLoss_{:05d}'.format(i)] = float('NaN')
frame.Put(self._output_key, labels)
if self._write_vector:
part_vec = dataclasses.I3VectorI3Particle()
for energy_i, pos_i in zip(binned_energy_losses, bin_center_pos):
part = dataclasses.I3Particle()
part.pos = dataclasses.I3Position(*pos_i)
part.energy = energy_i
part.dir = dataclasses.I3Direction(muon.dir)
part.time = ((muon.pos - part.pos).magnitude /
dataclasses.I3Constants.c)
part_vec.append(part)
frame.Put(self._output_key + 'ParticleVector', part_vec)
self.PushFrame(frame)
#!/usr/bin/env python
# The I3FrameObject base was missing in the python bindings.
# Now the I3ParticleVect inherits from I3FrameObject in python.
# just as it does in C++, so you can create them and add them
# to frames...just like in C++.
from icecube import icetray
from icecube import dataclasses
particle_vect = dataclasses.I3VectorI3Particle()
p1 = dataclasses.I3Particle()
particle_vect.append(p1)
p2 = dataclasses.I3Particle()
particle_vect.append(p2)
p3 = dataclasses.I3Particle()
particle_vect.append(p3)
frame = icetray.I3Frame()
frame['pv'] = particle_vect
# test out all the vector operations
if particle_vect[0] != p1:
raise Exception('index particle not equal')
particle_vect2 = dataclasses.I3VectorI3Particle()
particle_vect2.append(p1)
particle_vect2.append(p2)
if particle_vect[:2] != particle_vect2:
raise Exception('slice not equal')