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 DAQ(self, frame):
daughter = dataclasses.I3Particle()
daughter.type = self.particleType
daughter.energy = self.energy
daughter.pos = dataclasses.I3Position(self.xCoord, self.yCoord,
self.zCoord)
daughter.dir = dataclasses.I3Direction(0., 0., -1.)
daughter.time = 0.
daughter.location_type = dataclasses.I3Particle.LocationType.InIce
primary = dataclasses.I3Particle()
primary.type = dataclasses.I3Particle.ParticleType.NuE
primary.energy = self.energy
primary.pos = dataclasses.I3Position(self.xCoord, self.yCoord,
self.zCoord)
primary.dir = dataclasses.I3Direction(0., 0., -1.)
primary.time = 0.
primary.location_type = dataclasses.I3Particle.LocationType.Anywhere
mctree = dataclasses.I3MCTree()
mctree.add_primary(primary)
mctree.append_child(primary, daughter)
frame["I3MCTree"] = mctree
self.PushFrame(frame)
self.eventCounter += 1
if self.eventCounter == self.nEvents:
self.RequestSuspension()
def _create_mc_tree(self, inj_pos, inj_time, inj_dir):
"""Inject accompanying muon in provided I3MCTree
Parameters
----------
inj_pos : I3Position
The position at which to inject the muon.
inj_time : double
The time at which to inject the muon.
inj_dir : I3Direction
The direction of the injected muon.
Returns
-------
I3MCTree
The modified I3MCTree with the injected Muon.
I3MapStringDouble
Information on the injected muon.
"""
mc_tree = dataclasses.I3MCTree()
muon_primary = dataclasses.I3Particle()
muon_primary.shape = dataclasses.I3Particle.ParticleShape.Primary
muon_primary.dir = dataclasses.I3Direction(inj_dir)
muon_primary.pos = dataclasses.I3Position(inj_pos)
muon_primary.time = inj_time
muon = dataclasses.I3Particle()
muon.dir = dataclasses.I3Direction(inj_dir)
muon.pos = dataclasses.I3Position(inj_pos)
muon.time = inj_time
muon.location_type = dataclasses.I3Particle.LocationType.InIce
# sample type: MuPlus or MuMinus
u = self.random_service.uniform(0., 1.)
if u > 0.5:
pdg_encoding = 13
else:
pdg_encoding = -13
muon.pdg_encoding = pdg_encoding
# sample energy
muon.energy = self._sample_energy()
# add muon primary to I3MCTree
mc_tree.add_primary(muon_primary)
# add muon as new child
mc_tree.append_child(muon_primary, muon)
# add info
injection_info = dataclasses.I3MapStringDouble({
'muon_energy':
muon.energy,
'muon_pdg_encoding':
muon.pdg_encoding,
})
return mc_tree, injection_info
def make_mctree(frame, linearized=True):
tree = dataclasses.I3MCTree()
p1 = dataclasses.I3Particle()
tree.insert(p1)
p2 = dataclasses.I3Particle()
tree.append_child(p1, p2)
if linearized:
tree = dataclasses.I3LinearizedMCTree(tree)
frame['I3MCTree'] = tree
def test_get_most_energetic_primary(self):
primary1 = dc.I3Particle()
primary1.energy = 10 * I3Units.TeV
primary2 = dc.I3Particle()
primary2.energy = 1 * I3Units.TeV
tree = dc.I3MCTree()
tree.insert(primary1)
tree.insert(primary2)
mep = get_most_energetic_primary(tree)
self.assertTrue(mep, "got no particles, but there are primaries.")
self.assertEqual(mep.id, primary1.id, "got the wrong particle.")
def Process(self):
frame = icetray.I3Frame(icetray.I3Frame.DAQ)
mctree = dataclasses.I3MCTree()
cascade = dataclasses.I3Particle(dataclasses.I3Particle.Primary,
dataclasses.I3Particle.EPlus)
muon = dataclasses.I3Particle(dataclasses.I3Particle.Primary,
dataclasses.I3Particle.MuPlus)
mctree.add_primary(cascade)
mctree.add_primary(muon)
frame["I3MCTree"] = mctree
self.PushFrame(frame)
def Hybridforge(frame, seed, seedTime, factor, output): #seedC, seedT, output):
if frame.Has(seed):
source = frame[seed]
sourceTime = frame[seedTime]
# sourceT = frame[seedT]
# sourceC = frame[seedC]
if frame.Has("String1Pulses"):
cogPos = common_variables.hit_statistics.calculate_cog(geometry_,frame["String1Pulses"].apply(frame))
else:
cogPos = frame["FirstHLCvertex"].pos
qtot = common_variables.hit_statistics.calculate_q_tot_pulses(geometry_,frame['OfflinePulses_sRT'].apply(frame)) #"SRTTWOfflinePulsesDC"
forged_particle = dataclasses.I3Particle()
# forged_particle.energy = sourceT.energy + sourceC.energy
forged_particle.energy = qtot.value
# forged_particle.length = sourceT.length
forged_particle.length = factor*qtot.value
forged_particle.dir = source.dir
forged_particle.pos.x = cogPos.x+2
forged_particle.pos.y = cogPos.y+2
forged_particle.pos.z = cogPos.z-2
forged_particle.time = sourceTime.time
forged_particle.speed = 0.29979245799999998
forged_particle.shape = dataclasses.I3Particle.ParticleShape.ContainedTrack
forged_particle.fit_status = dataclasses.I3Particle.FitStatus.OK
frame.Put(output, forged_particle)
def make_seed(frame):
truth = frame['trueCascade']
trueX = truth.pos.x
trueY = truth.pos.y
trueZ = truth.pos.z
#print trueX, trueZ
xsteps = options.xsteps
#ysteps = options.zsteps
zsteps = options.zsteps
#print xsteps, zsteps
xstepsize = options.xstepsize
#ystepsize = options.zstepsize
zstepsize = options.zstepsize
#print xstepsize, zstepsize
startX = trueX - (xsteps / 2.) * xstepsize
#startY = trueY - (ysteps/2.)*ystepsize
startZ = trueZ - (zsteps / 2.) * zstepsize
#print startX, startZ
testX = startX + options.x * xstepsize
#testY = startY + options.z*ystepsize
testZ = startZ + options.z * zstepsize
#print testX, testZ
newparticle = dataclasses.I3Particle(truth)
newparticle.pos.x = testX
#newparticle.pos.y = testY
newparticle.pos.z = testZ
#print newparticle
frame['trueCascade_seed'] = newparticle
def Generator(frame,
FromEnergy=1 * I3Units.TeV,
ToEnergy=1 * I3Units.TeV):
p = dataclasses.I3Particle()
p.energy = random.uniform(FromEnergy, ToEnergy)
p.pos = dataclasses.I3Position(0, 0, 0)
# sample on a cylinder
theta = random.uniform(0., 2 * pi)
r = sqrt(random.uniform(0, 300 * I3Units.m * 300 * I3Units.m))
x = r * sin(theta)
y = r * cos(theta)
z = random.uniform(-300 * I3Units.m, 300 * I3Units.m)
zenith = random.uniform(0., pi)
azimuth = random.uniform(0., 2 * pi)
p.dir = dataclasses.I3Direction(zenith, azimuth)
p.length = 500 * I3Units.m
p.type = dataclasses.I3Particle.ParticleType.EMinus
p.location_type = dataclasses.I3Particle.LocationType.InIce
p.time = 0. * I3Units.ns
tree = dataclasses.I3MCTree()
tree.add_primary(p)
frame["I3MCTree"] = tree
def muon_injector(frame):
zenith = randomService.uniform(ZenithMin, ZenithMax)
azimuth = randomService.uniform(0, 360 * I3Units.degree)
x = CylinderRadius * math.cos(azimuth)
y = CylinderRadius * math.sin(azimuth)
z = CylinderRadius * math.cos(zenith)
global mu_type
if mu_type == dataclasses.I3Particle.MuMinus:
mu_type = dataclasses.I3Particle.MuPlus
else:
mu_type = dataclasses.I3Particle.MuMinus
mu = dataclasses.I3Particle()
mu.type = mu_type
mu.pos = dataclasses.I3Position(x, y, z)
mu.dir = dataclasses.I3Direction(zenith, azimuth)
mu.energy = MuonEnergy
mu.time = 0 * I3Units.ns
mu.length = NaN
mu.location_type = dataclasses.I3Particle.InIce
mctree = dataclasses.I3MCTree()
mctree.add_primary(mu)
frame["I3MCTree_preMuonProp"] = mctree
def BestFit(frame):
global pt_tup, delete_keys
content_map = []
igel_seed = frame[vert_seed]
# for i in xrange(len(pt_tup)):
# for j in xrange(num_mins):
seed_id = 'Seed'
millipede_id = 'Milli_'
millipede = frame[millipede_id]
millipede_fitparams = frame[millipede_id + 'FitParams']
rlogl = millipede_fitparams.rlogl
content_map.append([rlogl, millipede_id])
fit = min(content_map, key=lambda content_map: content_map[0])
fit_rlogl = fit[0]
fit_id = fit[1]
print 'Looking for the best fit', fit_id
track_fit = frame[fit_id]
track_fit_fitparams = frame[fit_id + 'FitParams']
zenith, azimuth = track_fit[0].dir.zenith, track_fit[0].dir.azimuth
forged_particle = dataclasses.I3Particle()
forged_particle.energy = 0
forged_particle.dir = dataclasses.I3Direction(zenith, azimuth)
forged_particle.pos.x = igel_seed.pos.x
forged_particle.pos.y = igel_seed.pos.y
forged_particle.pos.z = igel_seed.pos.z
forged_particle.time = igel_seed.time
forged_particle.speed = 0.299792
forged_particle.shape = igel_seed.shape.InfiniteTrack
frame["BlumeFit"] = forged_particle
def Process(self):
try:
c = next(self.lines)
except StopIteration:
self.RequestSuspension()
return
eq = astro.I3Equatorial(c[0] * I3Units.degree, c[1] * I3Units.degree)
time = dataclasses.I3Time(2015, 0)
direction = astro.I3GetDirectionFromEquatorial(eq, time)
eqq = astro.I3GetEquatorialFromDirection(direction, time)
particle = dataclasses.I3Particle()
particle.dir = direction
header = dataclasses.I3EventHeader()
header.start_time = time
frame = icetray.I3Frame("P")
if self.evthdr:
frame["I3EventHeader"] = header
frame["Particle"] = particle
self.PushFrame(frame)
def GetMostEnergeticCascade(frame):
if frame.Has('I3MCTree'):
name = "MostEnergeticCascade"
tree = frame['I3MCTree']
maincascade = dataclasses.I3Particle(dataclasses.get_most_energetic_cascade(tree))
maincascade.fit_status = dataclasses.I3Particle.OK
frame.Put("MostEnergeticCascade", maincascade)
def add_fake_scan(frame):
fp = millipede.MillipedeFitParams()
fp.logl = random.uniform(4000.,6000.)
frame["MillipedeStarting2ndPass_millipedellh"] = fp
p = dataclasses.I3Particle()
frame["MillipedeStarting2ndPass"] = p
time.sleep(0.1)
def Process(self):
if self.counter % 20 == 0:
sframe = icetray.I3Frame('S')
info = simclasses.I3CorsikaInfo()
sframe['I3CorsikaInfo'] = info
self.PushFrame(sframe)
qframe = icetray.I3Frame('Q')
eh = dataclasses.I3EventHeader()
eh.run_id = 1
eh.event_id = self.counter
qframe['I3EventHeader'] = eh
tree = dataclasses.I3MCTree()
p1 = dataclasses.I3Particle()
tree.insert(p1)
if self.counter % 2 == 0:
qframe['I3MCTree'] = tree
qframe['I3MCPrimary'] = p1
self.PushFrame(qframe)
self.counter += 1
if self.counter >= 100:
self.RequestSuspension()
def weight(x, y, z, zenith, azimuth, multiplicity, e, r):
axis = dataclasses.I3Particle()
axis.pos = dataclasses.I3Position(x, y, z)
axis.dir = dataclasses.I3Direction(zenith, azimuth)
assert multiplicity == 1
bundle = MuonGun.BundleConfiguration()
bundle.append(MuonGun.BundleEntry(float(r), float(e)))
return weighter(axis, bundle)
def charge_localization(
frame,
pulses=''
): # the algorithm that computes the reconstructed muon track. Can be used in this form as a module in icetray script.
pulse_series = dataclasses.I3RecoPulseSeriesMap.from_frame(frame, pulses)
DOMcharge = [] ## getting the charge deposited in each DOM
for omkey, pulses in pulse_series:
DOMcharge.append(
np.array([omkey.string, omkey.om,
sum([p.charge for p in pulses])]))
DOMcharge = np.asarray(DOMcharge)
localized_charge, total_event_charge = localize(
DOMcharge
) ## returns [string, om, % total event charge], total charge of the event
brightest_dom_coord = DOMcoord[
int(localized_charge[0][0]),
int(localized_charge[0][1])] ## coordintates of the brightest DOM
brightest_dom_charge = localized_charge[0][2]
second_brightest_dom_charge = 0
for dom in localized_charge:
if int(localized_charge[0][0]) != int(
dom[0]
): # if the second brightest DOM is on the same string as the brightest, add its charge to the brightest, move on to next brightest DOM
second_brightest_dom_coord = DOMcoord[int(dom[0]), int(dom[1])]
second_brightest_dom_charge = dom[2]
break
else:
second_brightest_dom_coord = DOMcoord[int(dom[0]), int(dom[1])]
brightest_dom_charge = +dom[2]
brightest_dom_distance = np.linalg.norm(
brightest_dom_coord - second_brightest_dom_coord
) ## distance betweeen the two brightest DOMs, called the lever arm
if brightest_dom_coord[2] > second_brightest_dom_coord[2]:
charge_localization_vector = (
brightest_dom_coord -
second_brightest_dom_coord) / brightest_dom_distance
else:
charge_localization_vector = (
second_brightest_dom_coord -
brightest_dom_coord) / brightest_dom_distance
localization_zenith, localization_azimuth = angles(
charge_localization_vector)
particle = dataclasses.I3Particle(
) # creating an I3Particle object containing direction and length information
particle.dir = dataclasses.I3Direction(-charge_localization_vector[0],
-charge_localization_vector[1],
-charge_localization_vector[2])
particle.pos = dataclasses.I3Position(brightest_dom_coord[0],
brightest_dom_coord[1],
brightest_dom_coord[2])
frame[
'localization_line'] = particle # writing I3Particle object to the I3File
particle.length = brightest_dom_distance
frame['brightest_dom_charge'] = dataclasses.I3Double(
brightest_dom_charge
) # writing brightest and second brightest DOM charge to I3File
frame['second_brightest_dom_charge'] = dataclasses.I3Double(
second_brightest_dom_charge)
def make_seed(frame):
fPart = frame["CascadeLast_DC"]
myPart = dataclasses.I3Particle(fPart)
myPartP3X = dataclasses.I3Particle(fPart)
myPartP3Y = dataclasses.I3Particle(fPart)
myPartP3Z = dataclasses.I3Particle(fPart)
myPartN3X = dataclasses.I3Particle(fPart)
myPartN3Y = dataclasses.I3Particle(fPart)
myPartN3Z = dataclasses.I3Particle(fPart)
xPos = frame["ThreePosX"].value
yPos = frame["ThreePosY"].value
zPos = frame["ThreePosZ"].value
myPart.pos = dataclasses.I3Position(xPos, yPos, zPos)
myPartP3X.pos = dataclasses.I3Position(xPos + 3, yPos, zPos)
myPartP3Y.pos = dataclasses.I3Position(xPos, yPos + 3, zPos)
myPartP3Z.pos = dataclasses.I3Position(xPos, yPos, zPos + 3)
myPartN3X.pos = dataclasses.I3Position(xPos - 3, yPos, zPos)
myPartN3Y.pos = dataclasses.I3Position(xPos, yPos - 3, zPos)
myPartN3Z.pos = dataclasses.I3Position(xPos, yPos, zPos - 3)
frame["MySeed"] = myPart
frame["MySeedP3X"] = myPartP3X
frame["MySeedP3Y"] = myPartP3Y
frame["MySeedP3Z"] = myPartP3Z
frame["MySeedN3X"] = myPartN3X
frame["MySeedN3Y"] = myPartN3Y
frame["MySeedN3Z"] = myPartN3Z
def make_particle():
p = dataclasses.I3Particle()
p.pos = dataclasses.I3Position(0, 0, 2e3)
p.dir = dataclasses.I3Direction(0, 0)
p.time = 0
p.energy = 10**randomService.Uniform(3, 6)
p.type = p.DeltaE
p.location_type = p.InIce
return p
def forgeseed(fr):
seed = dataclasses.I3Particle()
seed.pos=fr['CascadeLlhVertexFit_DP'].pos
seed.time=fr['CascadeLlhVertexFit_DP'].time
seed.dir=fr['SPEFit32_DP'].dir
seed.shape=dataclasses.I3Particle.Cascade
seed.type=dataclasses.I3Particle.EMinus
seed.fit_status=dataclasses.I3Particle.OK
fr['CascadeSeed']=seed
def particle(f):
p = dataclasses.I3Particle(dataclasses.I3Position(0, 0, 0),
dataclasses.I3Direction(0, 0, 1), 0,
dataclasses.I3Particle.Cascade, 0)
p.type = dataclasses.I3Particle.ParticleType.EMinus
p.location_type = dataclasses.I3Particle.LocationType.InIce
p.energy = 1.e5 * I3Units.GeV
t = dataclasses.I3MCTree()
t.add_primary(p)
f["particle"] = t
def DAQ(self, frame):
azi = self.rs.uniform(self.azimuthMin, self.azimuthMax)
cos_zen_low = math.cos(self.zenithMin / I3Units.radian)
cos_zen_high = math.cos(self.zenithMax / I3Units.radian)
zen = math.acos(self.rs.uniform(cos_zen_low, cos_zen_high))
r = self.ConstructPerpVector(zen, azi) * math.sqrt(
self.rs.uniform(0, self.diskRadius**2))
diskCenter = self.sphereRadius * numpy.array([math.sin(zen) * math.cos(azi),\
math.sin(zen) * math.sin(azi),
math.cos(zen)])
pos = diskCenter + r
# set the particle's energy
energy = self.rs.uniform(self.energyMin, self.energyMax) * I3Units.GeV
daughter = dataclasses.I3Particle()
daughter.type = self.particleType
daughter.energy = energy
daughter.pos = dataclasses.I3Position(pos[0], pos[1], pos[2])
daughter.dir = dataclasses.I3Direction(zen, azi)
daughter.time = 0.
daughter.location_type = dataclasses.I3Particle.LocationType.InIce
primary = dataclasses.I3Particle()
primary.type = dataclasses.I3Particle.ParticleType.NuMu
primary.energy = energy
primary.pos = dataclasses.I3Position(pos[0], pos[1], pos[2])
primary.dir = dataclasses.I3Direction(zen, azi)
primary.time = 0.
primary.location_type = dataclasses.I3Particle.LocationType.Anywhere
mctree = dataclasses.I3MCTree()
mctree.add_primary(primary)
mctree.append_child(primary, daughter)
frame["I3MCTree_preMuonProp"] = mctree
self.PushFrame(frame)
def makeSeed(vertSeed, zen, azi):
partPos = vertSeed.pos
partDir = dataclasses.I3Direction(zen, azi)
partTime = vertSeed.time
partLength = vertSeed.length
partShape = dataclasses.I3Particle.ParticleShape.InfiniteTrack
seedPart = dataclasses.I3Particle(partPos, partDir, partTime, partShape,
partLength)
return seedPart
def make_i3_particle( particle_data ):
"""
This takes one of the lists/tuples from the hdf5 datatable for a particle.
It converts it into an I3Particle
"""
pt = dataclasses.I3Particle()
pt.pdg_encoding = int(particle_data[1])
pt.pos = dataclasses.I3Position( particle_data[2][0], particle_data[2][1], particle_data[2][2])
pt.dir = dataclasses.I3Direction(particle_data[3][0], particle_data[3][1])
pt.energy = particle_data[4]*I3Units.GeV
return(pt)
def DAQ(self, frame):
azi = self.rs.uniform(self.azimuthMin, self.azimuthMax)
cos_zen_low = math.cos(self.zenithMin / I3Units.radian)
cos_zen_high = math.cos(self.zenithMax / I3Units.radian)
zen = math.acos(self.rs.uniform(cos_zen_low, cos_zen_high))
while True:
posX = self.rs.uniform(-self.cylinderRadius, self.cylinderRadius)
posY = self.rs.uniform(-self.cylinderRadius, self.cylinderRadius)
if posX**2 + posY**2 < self.cylinderRadius**2: break
posZ = self.rs.uniform(-self.cylinderHeight / 2.,
self.cylinderHeight / 2.)
# set the particle's energy
energy = self.rs.uniform(self.energyMin, self.energyMax) * I3Units.GeV
daughter = dataclasses.I3Particle()
daughter.type = self.particleType
daughter.energy = energy
daughter.pos = dataclasses.I3Position(posX, posY, posZ)
daughter.dir = dataclasses.I3Direction(zen, azi)
daughter.time = 0.
daughter.location_type = dataclasses.I3Particle.LocationType.InIce
primary = dataclasses.I3Particle()
primary.type = dataclasses.I3Particle.ParticleType.NuMu
primary.energy = energy
primary.pos = dataclasses.I3Position(posX, posY, posZ)
primary.dir = dataclasses.I3Direction(zen, azi)
primary.time = 0.
primary.location_type = dataclasses.I3Particle.LocationType.Anywhere
mctree = dataclasses.I3MCTree()
mctree.add_primary(primary)
mctree.append_child(primary, daughter)
frame["I3MCTree_preMuonProp"] = mctree
self.PushFrame(frame)
def CreatePFrame(self, nside, pixel):
dec, ra = healpy.pix2ang(nside, pixel)
dec = dec - numpy.pi / 2.
zenith, azimuth = astro.equa_to_dir(ra, dec, self.event_mjd)
zenith = float(zenith)
azimuth = float(azimuth)
direction = dataclasses.I3Direction(zenith, azimuth)
position = self.seed_position
time = self.seed_time
energy = self.seed_energy
variationDistance = 20. * I3Units.m
posVariations = [
dataclasses.I3Position(0., 0., 0.),
dataclasses.I3Position(-variationDistance, 0., 0.),
dataclasses.I3Position(variationDistance, 0., 0.),
dataclasses.I3Position(0., -variationDistance, 0.),
dataclasses.I3Position(0., variationDistance, 0.),
dataclasses.I3Position(0., 0., -variationDistance),
dataclasses.I3Position(0., 0., variationDistance)
]
for i in range(0, len(posVariations)):
posVariation = posVariations[i]
p_frame = icetray.I3Frame(icetray.I3Frame.Physics)
thisPosition = dataclasses.I3Position(position.x + posVariation.x,
position.y + posVariation.y,
position.z + posVariation.z)
# generate the particle from scratch
particle = dataclasses.I3Particle()
particle.shape = dataclasses.I3Particle.ParticleShape.InfiniteTrack
particle.fit_status = dataclasses.I3Particle.FitStatus.OK
particle.pos = thisPosition
particle.dir = direction
particle.time = time
particle.energy = energy
p_frame[self.output_particle_name] = particle
# generate a new event header
eventHeader = dataclasses.I3EventHeader(self.event_header)
eventHeader.sub_event_stream = "SCAN_nside%04u_pixel%04u_posvar%04u" % (
nside, pixel, i)
eventHeader.sub_event_id = pixel
p_frame["I3EventHeader"] = eventHeader
p_frame["SCAN_HealpixPixel"] = icetray.I3Int(int(pixel))
p_frame["SCAN_HealpixNSide"] = icetray.I3Int(int(nside))
p_frame["SCAN_PositionVariationIndex"] = icetray.I3Int(int(i))
for frame in self.GCDQpFrames[0:-1]:
self.PushFrame(frame)
self.PushFrame(p_frame)
def extractMCTreeParticles(frame):
mctree = frame["I3MCTree"]
# get tracks in ice/water
mctracksinice = mctree.get_filter(lambda p: p.location_type == p.InIce)
mcmuontrack = None
highestEnergy = -1.
for track in mctracksinice:
if track.energy > highestEnergy:
highestEnergy = track.energy
mcmuontrack = track
if mcmuontrack is None:
mcmuontrack = dataclasses.I3Particle()
primary = dataclasses.get_most_energetic_primary(mctree)
if primary is None:
primary = dataclasses.I3Particle()
frame["MCMostEnergeticInIce"] = mcmuontrack
frame["MCMostEnergeticPrimary"] = primary
def RFrame(self, frame):
position = frame[self.input_pos_name]
time = frame[self.input_time_name].value
energy = float('NaN')
self.PushFrame(frame)
for pixel in self.pixels:
p_frame = icetray.I3Frame(icetray.I3Frame.Physics)
zenith, azimuth = healpy.pix2ang(self.nside, pixel)
direction = dataclasses.I3Direction(zenith,azimuth)
#print "reconstructing with fixed direction", direction, "(npixels=", self.npix, ", pixel=", pixel, ")"
variationDistance = 20.*I3Units.m
posVariations = [dataclasses.I3Position(0.,0.,0.),
dataclasses.I3Position(-variationDistance,0.,0.),
dataclasses.I3Position( variationDistance,0.,0.),
dataclasses.I3Position(0.,-variationDistance,0.),
dataclasses.I3Position(0., variationDistance,0.),
dataclasses.I3Position(0.,0.,-variationDistance),
dataclasses.I3Position(0.,0., variationDistance)]
for i in range(len(posVariations)):
thisPosition = dataclasses.I3Position(position.x + posVariations[i].x,position.y + posVariations[i].y,position.z + posVariations[i].z)
# generate the particle from scratch
particle = dataclasses.I3Particle()
particle.shape = dataclasses.I3Particle.ParticleShape.Cascade
particle.fit_status = dataclasses.I3Particle.FitStatus.OK
particle.pos = thisPosition
particle.dir = direction
particle.time = time
particle.energy = energy
thisParticleName = self.output_particle_name
if i>0: thisParticleName = thisParticleName+"_%i"%i
p_frame[thisParticleName] = particle
p_frame["HealpixPixel"] = icetray.I3Int(int(pixel))
p_frame["HealpixNSide"] = icetray.I3Int(int(self.nside))
# generate a new event header
eventHeader = dataclasses.I3EventHeader(frame["I3EventHeader"])
eventHeader.sub_event_stream = "millipede_scan_nside%04u" % self.nside
eventHeader.sub_event_id = pixel
p_frame["I3EventHeader"] = eventHeader
self.PushFrame(p_frame)
def calc_factor(particle):
factor = 0.
for pos, charge in zip(positions, charges):
diff = pos - particle.pos
diff_p = dataclasses.I3Particle()
diff_p.dir = dataclasses.I3Direction(diff.x, diff.y, diff.z)
angle = I3Calculator.angle(diff_p, particle)
distance = max(10, diff.magnitude)
if distance < 500:
factor += charge * get_angle_factor(angle) / (distance**3)
return factor * particle.energy
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
