def K_element(l1, m1, l2, m2, ff, inverse=False):
# inverse calculates int Ylm Ylm/omega while no inverse calculates in Ylm Ylm * omega
if m1 != m2: return 0
# with phi part 'integrated out'
def realYlm(l, m, theta):
if abs(m) > l: return 0
x = np.cos(theta)
if m == 0:
return np.sqrt((2 * l + 1.) / 2) * lpmv(
0, l, x) # time sqrt(2pi) because phi integral is 2pi
N = np.sqrt(2 * l + 1) / 2 * np.sqrt(
CR.factorial_ratio(
l - abs(m),
l + abs(m))) # times sqrt(pi) because phi integral is pi
P = lpmv(abs(m), l, x)
return np.sqrt(2) * N * P
if inverse:
return quad(lambda theta: realYlm(l1, m1, theta) * realYlm(
l2, m2, theta) * np.sin(theta) / omega(CR.dec2theta(theta), ff),
0,
np.pi,
epsrel=1e-4,
limit=100)[0]
else:
return quad(lambda theta: realYlm(l1, m1, theta) * realYlm(
l2, m2, theta) * np.sin(theta) * omega(CR.dec2theta(theta), ff),
0,
np.pi,
epsrel=1e-4,
limit=100)[0]
def gen_iso(N):
N = int(N)
dts = ["dec", "theta", "phi"]
dt = [(d, "f") for d in dts]
events = np.empty(N, dtype=dt)
sin_decs = 2 * np.random.rand(N) - 1
decs = np.arcsin(sin_decs)
events["dec"] = decs
events["theta"] = CR.dec2theta(decs)
events["phi"] = 2 * np.pi * np.random.rand(N)
return events
def gen_iso_exposure(N, ff):
N = int(N)
omega_max = max(CR.omega(-np.pi / 2, ff), CR.omega(np.pi / 2, ff))
count = 0
decs = np.empty(N)
while count < N:
sin_dec = 2 * np.random.rand() - 1
dec = np.arcsin(sin_dec)
if omega_max * np.random.rand() > CR.omega(dec, ff): continue
decs[count] = dec
count += 1
dts = ["dec", "theta", "phi"]
dt = [(d, "f") for d in dts]
events = np.empty(N, dtype=dt)
events["dec"] = decs
events["theta"] = CR.dec2theta(decs)
events["phi"] = 2 * np.pi * np.random.rand(N)
return events
def get_alms_exposure_K(events, l_max, Kinv):
return -1
# requiring Kinv is slow
# either K_matrix(inverse = True) or np.linalg.inv(K) gives similar results
blms = np.empty((l_max + 1)**2) # the uncorrected alms
for l in xrange(l_max + 1):
for m in xrange(-l, l + 1):
blms[lm2i(l, m)] = np.sum(
realYlm(l, m, CR.dec2theta(events["dec"]),
events["phi"])) / len(events)
alms = KM.almKs(blms, Kinv)
return alms
def realYlm(l, m, theta):
if abs(m) > l: return 0
x = np.cos(theta)
if m == 0:
return np.sqrt((2 * l + 1.) / 2) * lpmv(
0, l, x) # time sqrt(2pi) because phi integral is 2pi
N = np.sqrt(2 * l + 1) / 2 * np.sqrt(
CR.factorial_ratio(
l - abs(m),
l + abs(m))) # times sqrt(pi) because phi integral is pi
P = lpmv(abs(m), l, x)
return np.sqrt(2) * N * P
def get_alms_exposure(events, l_max, ff):
# this is the prefered way
# 1702.07209 eq 8
# same as Sommers
omegas = CR.omega(events["dec"], ff)
# check field names in events
phi_field = "phi"
if phi_field not in events.dtype.names:
names = list(events.dtype.names)
idx = names.index("RA")
names[idx] = phi_field
events.dtype.names = names
exposure_alms = np.zeros(Alm.getsize(l_max), dtype=complex)
for l in xrange(l_max + 1):
for m in xrange(l + 1):
cplx_alms = cplxYlm(l, m, CR.dec2theta(events["dec"]),
events["phi"]) / omegas
exposure_alms[Alm.getidx(l_max, l, m)] = np.sum(cplx_alms)
return exposure_alms / (exposure_alms[0] * np.sqrt(4 * np.pi)
) # normalize the alms so that a00 = 1/sqrt(4pi)
def gen_iso_exposure_one_exp(N, Auger=True):
dts = ["dec", "theta", "phi"]
dt = [(d, "f") for d in dts]
events = np.empty(N, dtype=dt)
if Auger: omega_max = CR.omega(-np.pi / 2, True, 1)
else: omega_max = CR.omega(np.pi / 2, False, 1)
count = 0
decs = np.empty(N)
while count < N:
sin_dec = 2 * np.random.rand() - 1
dec = np.arcsin(sin_dec)
# ff is irrelevant for one exp
if omega_max * np.random.rand() > CR.omega(dec, Auger, 1): continue
decs[count] = dec
count += 1
events["dec"] = decs
events["theta"] = CR.dec2theta(decs)
events["phi"] = 2 * np.pi * np.random.rand(N)
return events
def logLikelihood(m):
"""
takes a healpy map m and returns the likelihood that the UHECR data agrees with it
assumes that the map is normalized to:
int dOmega m(Omega) = 1
"""
n_side = hp.pixelfunc.npix2nside(len(m))
logL = 0
for i in xrange(len(events)):
dec = events["dec"][i]
theta = np.pi / 2 - dec
RA = events["RA"][i]
phi = RA
pixel = hp.pixelfunc.ang2pix(n_side, theta, phi)
logL += np.log(m[pixel] / CR.omega(dec, ff)[0])
return logL
def load_Auger_TA(E_min_Auger=None,
E_min_TA=None,
E_scale=None,
purge_hotspot=False):
assert [E_min_Auger, E_min_TA, E_scale].count(None) <= 1
if E_min_TA == None: E_min_TA = E_min_Auger * E_scale
if E_min_Auger == None: E_min_Auger = E_min_TA / E_scale
Auger_events = load_Auger(E_min_Auger)
TA_events = load_TA(E_min_TA, purge_hotspot=purge_hotspot)
# overlap region, calculate fudge factor
N_Auger_overlap = sum(1 for Auger_event in Auger_events
if Auger_event["dec"] > CR.dec_min)
N_TA_overlap = sum(1 for TA_event in TA_events
if TA_event["dec"] < CR.dec_max)
return np.append(Auger_events,
TA_events), CR.fudge(N_Auger_overlap, N_TA_overlap)
def load_TA(E_min, purge_hotspot=False):
dts = ["E", "RA", "dec", "l", "b"]
cols = (7, 8, 9, 10, 11)
dt = [(d, "f") for d in dts]
dataf = open("inputs/TA.txt", "r")
TA_events = np.loadtxt(dataf, dtype=dt, usecols=cols)
dataf.close()
for angle in dts[1:]:
TA_events[angle] = TA_events[angle] * np.pi / 180
# apply energy cut
mask = TA_events["E"] > E_min
TA_events = TA_events[mask]
# put TA hotspot back to bkg
if purge_hotspot:
# 19 events within 20 degrees compared to 4.5 estimated
dec_TA_hotspot, RA_TA_hotspot = (43.2 * np.pi / 180,
146.7 * np.pi / 180)
count_total = 0
count_removed = 0
mask = np.ones(len(TA_events), dtype=bool)
for i in xrange(len(TA_events)):
if CR.cos_angle_between(
dec_TA_hotspot, RA_TA_hotspot, TA_events[i]["dec"],
TA_events[i]["RA"]) > np.cos(20 * np.pi / 180):
count_total += 1
if np.random.rand() > 4.5 / 19:
mask[i] = False
count_removed += 1
print "TA hotspot events:", count_total, " Removed", count_removed, "events"
TA_events = TA_events[mask]
# add a dtype
TA_events_ = np.empty(TA_events.shape, dtype=dt + [("is_Auger", "b")])
for name in TA_events.dtype.names:
TA_events_[name] = TA_events[name]
TA_events_["is_Auger"] = False
return TA_events_
import matplotlib.pyplot as plt
import numpy as np
import CR_funcs as CR
import Data
E_min_Auger = 57
E_scale = 1.13
tmp, ff = Data.load_Auger_TA(E_min_Auger = E_min_Auger, E_scale = E_scale, purge_hotspot = False)
decs = np.linspace(-np.pi / 2, np.pi / 2, 100)
omegas_auger = CR.omega_one_exp(decs, True, ff)
omegas_TA = CR.omega_one_exp(decs, False, ff)
omegas_both = omegas_auger + omegas_TA
decs *= 180 / np.pi
plt.plot(decs, omegas_both, "k-")
plt.plot(decs, omegas_auger, "k:")
plt.plot(decs, omegas_TA, "k:")
plt.xlabel(r"${\rm Declination}$")
plt.ylabel(r"${\rm Relative\ Exposure}$")
v = list(plt.axis())
v[0] = -90
v[1] = 90
v[2] = 0
plt.axis(v)
plt.xticks([-90, -45, 0, 45, 90])
E_scale=E_scale,
purge_hotspot=purge_hotspot)
Auger_events = Data.load_Auger(E_min_Auger)
TA_events = Data.load_TA(E_min_TA, purge_hotspot=purge_hotspot)
# draw map at earth in equatorial coordinates
# initialize maps
Auger_map = np.zeros(hp.nside2npix(nside))
TA_map = np.zeros(hp.nside2npix(nside))
earth_map = np.zeros(hp.nside2npix(nside))
# fill in maps
for event in Auger_events:
Auger_map[hp.pixelfunc.ang2pix(
nside, np.pi / 2 - event["b"],
event["l"])] += 1. / CR.omega_one_exp(event["dec"], True, ff)
for event in TA_events:
TA_map[hp.pixelfunc.ang2pix(
nside, np.pi / 2 - event["b"],
event["l"])] += 1. / CR.omega_one_exp(event["dec"], False, ff)
# smooth maps
earth_map += hp.sphtfunc.smoothing(Auger_map,
sigma=Auger_angular_sigma,
verbose=False)
earth_map += hp.sphtfunc.smoothing(TA_map,
sigma=TA_angular_sigma,
verbose=False)
# maximum direction
theta_gal, phi_gal = hp.pix2ang(nside, np.argmax(earth_map))