def get_data():
"""Get the population data."""
# Construct population
pop = CosmicPopulation(n_srcs=SIZE, n_days=1, name='standard_candle')
pop.set_dist(model='sfr', z_max=2.5, H_0=67.74, W_m=0.3089, W_v=0.6911)
pop.set_dm_host(model='constant', value=100)
pop.set_dm_igm(model='ioka', slope=1000, std=None)
pop.set_dm_mw(model='ne2001')
pop.set_emission_range(low=10e6, high=10e9)
pop.set_lum(model='constant', value=1e36)
pop.set_w(model='constant', value=1.)
pop.set_si(model='constant', value=0)
pop.generate()
# Survey population
pops = {}
for b in BEAMPATTERNS:
pprint(f'Surveying with {b} beampattern')
n_s = 0
bp = b
if b.startswith('airy'):
bp, n_s = b.split('-')
n_s = int(n_s)
survey = Survey(name='perfect-small')
# Prevent beam from getting larger than the sky
survey.set_beam(model=bp, n_sidelobes=n_s, size=10)
surv_pop = SurveyPopulation(pop, survey)
print(surv_pop.source_rate)
pops[b] = surv_pop
return pops
def complex_rates(remake=REMAKE, alphas=ALPHAS, size=SIZE, surveys=SURVEYS):
"""Calculate expected rates for a complex populations."""
rates = defaultdict(list)
# Don't always regenerate a population
if remake is False:
for alpha in alphas:
for s in surveys:
surv_rates = unpickle(f'complex_alpha_{alpha}_{s}').source_rate
pprint(f'Alpha:{alpha:.2}, Survey: {s}, Det: {surv_rates.det}')
rate = (surv_rates.det / surv_rates.days)
rates[s].append(rate)
else:
pops = []
for alpha in alphas:
if alpha <= -1.0 and ADAPTATIVE_SCALING:
size = 1e7
if alpha <= -1.5 and ADAPTATIVE_SCALING:
size = 1e8
pop = CosmicPopulation.complex(size)
pop.set_dist(model='vol_co',
z_max=2.5,
alpha=alpha,
H_0=67.74,
W_m=0.3089,
W_v=0.6911)
pop.set_lum(model='powerlaw', low=1e40, high=1e45, power=-1)
pop.name = f'complex_alpha_{alpha}'
pops.append(pop)
# Set up surveys
ss = []
for s in surveys:
survey = Survey(name=s)
survey.set_beam(model='airy', n_sidelobes=1)
ss.append(survey)
surv_pops = LargePopulation(pop, *ss).pops
for i, s in enumerate(surveys):
surv_rates = surv_pops[i].source_rate
pprint(f'Alpha:{alpha:.2}, Survey: {s}, Det: {surv_rates.det}')
rate = (surv_rates.det / surv_rates.days)
rates[s].append(rate)
# Scale rates to first survey in list
for s in surveys:
if s != surveys[0]:
norm = []
for i, r in enumerate(rates[s]):
norm.append(r / rates[surveys[0]][i])
rates[s] = norm
rates[surveys[0]] = [r / r for r in rates[surveys[0]]]
return rates
def get_data():
"""Get survey populations."""
# Don't always regenerate a population
if REMAKE is False:
# Check where a possible population would be located
path = ''
surv_pops = []
for telescope in TELESCOPES:
if telescope == 'askap':
telescope = 'askap-fly'
name = f'{telescope}'
path = paths.populations() + f'complex_{name}.p'
surv_pops.append(unpickle(path))
return surv_pops
cosmic_pop = CosmicPopulation.complex(SIZE, generate=False)
surveys = []
for telescope in TELESCOPES:
pattern = 'airy'
if telescope == 'parkes':
pattern = telescope
s = telescope
if telescope == 'askap':
s = 'askap-fly'
surveys.append(Survey(s, gain_pattern=pattern, n_sidelobes=1))
return LargePopulation(cosmic_pop, *surveys).pops
def main():
"""Run main part of code."""
# Be a bit smart about which populations need to be loaded
load = True
if not MAKE and not OBSERVE:
load = False
pop = get_cosmic_pop('standard', SIZE, load=load, overwrite=MAKE)
for telescope in TELESCOPES:
pattern = 'airy'
if telescope == 'parkes':
pattern = telescope
s = telescope
if telescope == 'askap':
s = 'askap-fly'
survey = Survey(s, gain_pattern=pattern, n_sidelobes=1)
surv_pop = get_survey_pop(pop, survey, overwrite=OBSERVE)
if PLOT:
plot_dists(surv_pop, telescope)
def simple_rates(remake=REMAKE, alphas=ALPHAS, size=SIZE, surveys=SURVEYS):
"""Calculate expected rates for a simple populations."""
rates = defaultdict(list)
# Don't always regenerate a population
if remake is False:
for alpha in alphas:
for s in surveys:
surv_rates = unpickle(f'simple_alpha_{alpha}_{s}').source_rate
pprint(f'Alpha:{alpha:.2}, Survey: {s}, Det: {surv_rates.det}')
rate = (surv_rates.det / surv_rates.days)
rates[s].append(rate)
else:
pops = []
for alpha in alphas:
pop = CosmicPopulation.simple(size)
pop.set_dist(alpha=alpha)
pop.name = f'simple_alpha_{alpha}'
pops.append(pop)
# Set up surveys
ss = []
for s in surveys:
survey = Survey(name=s)
survey.set_beam(model='perfect',
n_sidelobes=0.5)
ss.append(survey)
surv_pops = LargePopulation(pop, *ss).pops
for i, s in enumerate(surveys):
surv_rates = surv_pops[i].source_rate
pprint(f'Alpha:{alpha:.2}, Survey: {s}, Det: {surv_rates.det}')
rate = (surv_rates.det / surv_rates.days)
rates[s].append(rate)
# Scale rates to HTRU
for s in surveys:
if s != 'parkes-htru':
norm = []
for i, r in enumerate(rates[s]):
norm.append(r/rates['parkes-htru'][i])
rates[s] = norm
rates['parkes-htru'] = [r/r for r in rates['parkes-htru']]
return rates
def toy_rates(surveys=SURVEYS, alphas=ALPHAS):
"""Use a toy model to scale detection rates to various alphas."""
rates = {}
for surv in surveys:
# Get survey parameters
surv1 = Survey(surv, gain_pattern='perfect', n_sidelobes=0.5)
surv2 = Survey('htru', gain_pattern='perfect', n_sidelobes=0.5)
# Calculate rate per alpha
rate = []
for alpha in alphas:
rate.append(compare_surveys(surv1, surv2, alpha))
rates[surv] = rate
return rates
def get_data():
"""Get the population data."""
# Construct population
pop = CosmicPopulation(SIZE,
days=1,
name='standard_candle',
H_0=67.74,
W_m=0.3089,
W_v=0.6911,
dm_host_model='gaussian',
dm_host_mu=100,
dm_host_sigma=0,
dm_igm_index=1000,
dm_igm_sigma=None,
dm_mw_model='ne2001',
emission_range=[10e6, 10e9],
lum_range=[1e36, 1e36],
lum_index=0.,
n_model='sfr',
alpha=-1.5,
w_model='uniform',
w_range=[1., 1.],
w_mu=0.1,
w_sigma=0.,
si_mu=0.,
si_sigma=0.,
z_max=2.5)
# Survey population
pops = {}
for b in BEAMPATTERNS:
n_s = 0
bp = b
if b.startswith('airy'):
bp, n_s = b.split('-')
n_s = int(n_s)
survey = Survey(name='perfect-small')
survey.gain_pattern = bp
survey.n_sidelobes = n_s
surv_pop = SurveyPopulation(pop, survey)
pops[b] = surv_pop
return pops
def get_local(make=MAKE, size=SIZE):
# Construct populations
pop = get_cosmic_pop('alpha_simple',
size,
load=True,
overwrite=make,
alpha=-1.5)
# Survey populations
survey = Survey(name='perfect', gain_pattern='perfect', n_sidelobes=0.5)
surv_pop = SurveyPopulation(pop, survey)
return surv_pop.frbs.fluence
def simple_rates(make=MAKE,
observe=OBSERVE,
alphas=ALPHAS,
size=SIZE,
surveys=SURVEYS,
output=False):
# Be a bit smart about which populations need to be loaded
load = True
if not make and not observe:
load = False
# Construct populations
pops = []
for alpha in alphas:
pop = get_cosmic_pop('alpha_simple',
size,
load=load,
overwrite=make,
alpha=alpha)
pops.append(pop)
# Survey populations
rates = defaultdict(list)
for s in surveys:
survey = Survey(name=s, gain_pattern='perfect', n_sidelobes=0.5)
for i, pop in enumerate(pops):
surv_rates = get_survey_pop(pop, survey).rates()
if output:
alpha = alphas[i]
print(f'Alpha:{alpha:.2}, Survey: {s}, Det: {surv_rates.det}')
rate = (surv_rates.det / surv_rates.days)
rates[s].append(rate)
# Scale rates to HTRU
for surv in surveys:
if surv != 'htru':
norm = []
for i, r in enumerate(rates[surv]):
norm.append(r / rates['htru'][i])
rates[surv] = norm
rates['htru'] = [r / r for r in rates['htru']]
return rates
def set_up_surveys(self):
"""Set up surveys."""
surveys = []
for name in self.survey_names:
survey = Survey(name=name)
survey.set_beam(model='airy', n_sidelobes=1)
if name in ('chime-frb', 'wsrt-apertif', 'parkes-htru'):
survey.set_beam(model=name)
surveys.append(survey)
return surveys
def get_further(gamma, make=MAKE, size=SIZE):
"""Construct populations going further out."""
# Construct populations
pop = get_cosmic_pop('gamma',
size,
load=True,
overwrite=make,
gamma=gamma)
if gamma == 1:
pop.frbs.lum_bol = np.ones_like(pop.frbs.lum_bol)*10**43
# Survey populations
survey = Survey(name='perfect', gain_pattern='perfect', n_sidelobes=0.5)
surv_pop = SurveyPopulation(pop, survey)
return surv_pop.frbs.fluence
def analytical_rates(surveys=SURVEYS, alphas=ALPHAS):
"""Use a analytical model to scale detection rates to various alphas."""
rates = {}
for surv in surveys:
# Get survey parameters
surv1 = Survey(surv)
surv1.set_beam('perfect', n_sidelobes=0.5)
surv2 = Survey(surveys[0])
surv2.set_beam('perfect', n_sidelobes=0.5)
# Calculate rate per alpha
rate = []
for alpha in alphas:
rate.append(compare_surveys(surv1, surv2, alpha))
rates[surv] = rate
return rates
def get_further(gamma):
"""Construct populations going further out."""
# Construct populations
pop = CosmicPopulation.simple(SIZE)
pop.set_dist(z_max=2.5)
pop.set_si(model='constant', value=gamma)
pop.set_lum(model='constant', value=10**42.5)
pop.generate()
if gamma == 1:
pop.set_lum(model='constant', value=10**43)
pop.gen_lum()
# Survey populations
survey = Survey('perfect')
surv_pop = SurveyPopulation(pop, survey)
return surv_pop.frbs.s_peak
def get_further(gamma):
"""Construct populations going further out."""
# Construct populations
pop = CosmicPopulation.simple(SIZE)
pop.si_mu = gamma
pop.z_max = 2.5
pop.lum_min = 10**42.5
pop.lum_max = pop.lum_min
pop.generate()
if gamma == 1:
pop.frbs.lum_bol = np.ones_like(pop.frbs.lum_bol)*10**43
# Survey populations
survey = Survey('perfect')
surv_pop = SurveyPopulation(pop, survey)
return surv_pop.frbs.s_peak
def complex_rates(remake=REMAKE, alphas=ALPHAS, size=SIZE, surveys=SURVEYS):
"""Calculate expected rates for a complex populations."""
rates = defaultdict(list)
# Don't always regenerate a population
if remake is False:
for alpha in alphas:
for s in surveys:
surv_rates = unpickle(f'complex_alpha_{alpha}_{s}').rates()
pprint(f'Alpha:{alpha:.2}, Survey: {s}, Det: {surv_rates.det}')
rate = (surv_rates.det / surv_rates.days)
rates[s].append(rate)
else:
pops = []
for alpha in alphas:
pop = CosmicPopulation.complex(size)
pop.alpha = alpha
pop.name = f'complex_alpha_{alpha}'
pops.append(pop)
# Set up surveys
ss = []
for s in surveys:
survey = Survey(name=s, gain_pattern='airy', n_sidelobes=1)
ss.append(survey)
surv_pops = LargePopulation(pop, *ss).pops
for i, s in enumerate(surveys):
surv_rates = surv_pops[i].rates()
pprint(f'Alpha:{alpha:.2}, Survey: {s}, Det: {surv_rates.det}')
rate = (surv_rates.det / surv_rates.days)
rates[s].append(rate)
# Scale rates to HTRU
for s in surveys:
if s != 'htru':
norm = []
for i, r in enumerate(rates[s]):
norm.append(r / rates['htru'][i])
rates[s] = norm
rates['htru'] = [r / r for r in rates['htru']]
return rates
def main():
"""Run main part of code."""
# Be a bit smart about which populations need to be loaded
load = True
if not MAKE and not OBSERVE:
load = False
# Construct populations
pops = {}
for gamma in GAMMAS:
pops[gamma] = []
for alpha in ALPHAS:
pop = get_cosmic_pop('alpha_gamma',
SIZE,
load=load,
overwrite=MAKE,
alpha=alpha,
gamma=gamma)
pops[gamma].append(pop)
# Survey populations
rates = defaultdict(list)
for gamma in GAMMAS:
print(gamma)
for alpha in ALPHAS:
pattern = 'perfect'
n_sl = 0.5
survey = Survey(name=SURVEY,
gain_pattern=pattern,
n_sidelobes=n_sl)
surv_rates = get_survey_pop(pop, survey).rates()
m = f'Alpha:{alpha:.2}, Gamma:{gamma}, Det: {surv_rates.det}'
print(m)
events = (surv_rates.det / surv_rates.days)
rates[gamma].append(events)
# Plot population event rates
if PLOT:
plot_rates(rates, filename='plots/rates_chime.pdf')
def do_survey():
# Construct population
pop = get_cosmic_pop('standard_candle', SIZE, load=True, overwrite=MAKE)
# Survey population
pops = {}
for b in BEAMPATTERNS:
n_s = 0
bp = b
if b.startswith('airy'):
bp, n_s = b.split('-')
n_s = int(n_s)
survey = Survey(name='perfect-small', gain_pattern=bp, n_sidelobes=n_s)
surv_pop = SurveyPopulation(pop, survey)
pops[b] = surv_pop
return pops
def iter_run(i):
r = CosmicPopulation(N_SRCS, n_days=N_DAYS, repeaters=True)
r.set_dist(model='vol_co', z_max=1.0)
r.set_dm_host(model='gauss', mean=100, std=200)
r.set_dm_igm(model='ioka', slope=1000, std=None)
r.set_dm(mw=True, igm=True, host=True)
r.set_emission_range(low=100e6, high=10e9)
r.set_lum(model='powerlaw',
per_source='different',
low=1e40,
high=1e45,
power=0)
r.set_si(model='gauss', mean=-1.4, std=1)
r.set_w(model='lognormal', per_source='different', mean=0.1, std=1)
rate = lognormal(RATE, 2, N_SRCS)
if LARGE_POP:
rate = lognormal(RATE, 2, int(MAX_SIZE)) # Not completely kosher
r.set_time(model='poisson', rate=rate)
# Set up survey
s = Survey('chime-frb', n_days=N_DAYS)
s.set_beam(model='chime-frb')
s.gen_pointings() # To ensure each sub pop has the same pointings
# Only generate FRBs in CHIME's survey region
r.set_direction(model='uniform',
min_ra=s.ra_min,
max_ra=s.ra_max,
min_dec=s.dec_min,
max_dec=s.dec_max)
if LARGE_POP:
surv_pop = LargePopulation(r, s, max_size=MAX_SIZE).pops[0]
else:
r.generate()
surv_pop = SurveyPopulation(r, s)
surv_pop.name = f'cosmic_chime_longer_{i}'
surv_pop.save()
print(surv_pop.source_rate)
print(surv_pop.burst_rate)
pprint(f'i: {i}')
pprint(f'# one-offs: {surv_pop.n_one_offs()}')
pprint(f'# repeaters: {surv_pop.n_repeaters()}')
def gen_survey(self, name):
survey = Survey(name)
survey.set_beam('gaussian')
return survey
return r
def calc_logn_logs(self, parameter='fluence', min_p=None, max_p=None):
"""TODO. Currently unfinished."""
parms = getattr(self.frbs, parameter)
if min_p is None:
f_0 = min(parms)
else:
f_0 = min_p
parms = parms[parms >= min_p]
if max_p is not None:
parms = parms[parms <= max_p]
n = len(parms)
alpha = -1 / ((1 / n) * sum([math.log(f / f_0) for f in parms]))
alpha *= (n - 1) / n # Removing bias in alpha
alpha_err = n * alpha / ((n - 1) * (n - 2)**0.5)
norm = n / (f_0**alpha) # Normalisation at lowest parameter
return alpha, alpha_err, norm
if __name__ == '__main__':
from frbpoppy import CosmicPopulation, Survey
cosmic = CosmicPopulation(10000, days=4)
survey = Survey('apertif', gain_pattern='apertif')
surv_pop = SurveyPopulation(cosmic, survey)
print(surv_pop.rates())
"""Example of simulating a perfect survey."""
from frbpoppy import CosmicPopulation, Survey, SurveyPopulation, plot
# Generate an FRB population
cosmic_pop = CosmicPopulation.simple(1e4, generate=True)
# Setup a survey
survey = Survey('perfect')
# Observe the FRB population
survey_pop = SurveyPopulation(cosmic_pop, survey)
# Check the detection rates
print(survey_pop.rates())
# Note that due to redshift you won't see all bursts, as some will have
# redshifted out of the observing time. But no matter how faint, you'll see
# all bursts within the observing time
# Plot populations
plot(cosmic_pop, survey_pop, frbcat=False, mute=False)
pop[n].frbs.lum_bol = dis.powerlaw(10**n, 10**n, 0, n_gen)
pop[n].name = f'sc-{n}'
pop[n].save()
pop_obs = {}
if OBSERVE:
for n in (35, 36, 37):
if not CREATE:
pop[n] = unpickle(f'sc-{n}')
# Create Survey
perfect = Survey('perfect-small',
gain_pattern='gaussian',
n_sidelobes=8)
# Observe populations
pop_obs[n] = SurveyPopulation(pop[n], perfect)
pop_obs[n].name = f'sc-{n}-obs'
pop_obs[n].rates()
pop_obs[n].save()
else:
for n in (35, 36, 37):
pop_obs[n] = unpickle(f'sc-{n}-obs')
f, (ax1) = plt.subplots(1, 1)
for n in pop_obs:
"""Example of changing parameters."""
from frbpoppy import CosmicPopulation, Survey
import frbpoppy.gen_dists as gd
# Set up a population
cosmic_pop = CosmicPopulation(1e4, generate=False)
# ... or adapt the population per parameter, e.g.
cosmic_pop.set_dist(z_max=2.5)
# Or to adapt the luminosity
cosmic_pop.set_lum(model='powerlaw', low=1e44, high=1e45)
# Generate the population
cosmic_pop.generate()
# Setup a survey
survey = Survey('wsrt-apertif')
# and adapt the survey with
survey.set_beam('airy', n_sidelobes=2)
survey.snr_limit = 2
# For a full list of available arguments or parameters check the classes as
# defined in /frbpoppy/*.py
# Some more difficult examples
# Use a convolution of two distributions
cosmic_pop = CosmicPopulation.simple(n_srcs=1e4, repeaters=True)
# Draw the mean value per source from a normal distribution
mean_dist = gd.trunc_norm(mean=1, std=2, shape=int(1e4))
# And use those means as a _means_ to generate from a new Gaussian
# distribution per source
cosmic_pop.set_w(model='gauss',
"""Calculate the expected detection rates for apertif."""
import numpy as np
import matplotlib.pyplot as plt
from tqdm import tqdm
from frbpoppy import CosmicPopulation, Survey, SurveyPopulation, hist
from tests.convenience import plot_aa_style, rel_path
from alpha_real import EXPECTED, poisson_interval
N_DAYS = 1 # Not used in eventual result
SCALE_TO = 'parkes-htru'
pop = CosmicPopulation.complex(n_srcs=1e5, n_days=N_DAYS)
pop.generate()
apertif = Survey('wsrt-apertif', n_days=N_DAYS)
apertif.set_beam(model='apertif_real')
if SCALE_TO == 'parkes-htru':
htru = Survey('parkes-htru', n_days=N_DAYS)
htru.set_beam(model='parkes')
if SCALE_TO == 'askap':
askap = Survey('askap-fly', n_days=N_DAYS)
askap.set_beam(model='gaussian', n_sidelobes=0.5)
days_per_frbs = []
for i in tqdm(range(2000), desc='Survey Run'):
apertif_pop = SurveyPopulation(pop, apertif, mute=True)
if SCALE_TO == 'parkes-htru':
BEAMPATTERNS = ['perfect', 'airy', 'gaussian']
# Generate population with standard candles
pop = CosmicPopulation(n_srcs=5e4, n_days=1, name='standard')
pop.set_dist(model='sfr', z_max=2.5, H_0=67.74, W_m=0.3089, W_v=0.6911)
pop.set_dm_igm(model='ioka', slope=1200, std=0)
pop.set_dm(mw=False, host=False, igm=True)
pop.set_emission_range(low=10e6, high=10e9)
pop.set_lum(model='constant', value=1e36)
pop.set_w(model='constant', value=1)
pop.set_si(model='constant', value=0)
pop.generate()
pop_obs = {}
survey = Survey('perfect-small')
for pattern in BEAMPATTERNS:
survey.set_beam(model=pattern, n_sidelobes=0, size=90)
# Observe populations
pop_obs[pattern] = SurveyPopulation(pop, survey)
pop_obs[pattern].name = f'obs-{pattern}'
pop_obs[pattern].source_rate
print(pop_obs[pattern].source_rate)
pop_obs[pattern].save()
plot_aa_style()
f, (ax1) = plt.subplots(1, 1)
def plot_coordinates(ra, dec):
"""Plot coordinate in 3D plot."""
dec = np.deg2rad(dec)
ra = np.deg2rad(ra)
x = np.cos(ra) * np.cos(dec)
y = np.sin(ra) * np.cos(dec)
z = np.sin(dec)
fig = plt.figure()
ax = fig.add_subplot(111, projection=Axes3D.name)
p = ax.scatter(x, y, z, c=np.arange(0, x.size))
plt.colorbar(p)
ax.axes.set_xlim3d(left=-1, right=1)
ax.axes.set_ylim3d(bottom=-1, top=1)
ax.axes.set_zlim3d(bottom=-1, top=1)
plt.show()
if __name__ == '__main__':
transit = Survey('chime-frb')
transit.set_pointings(mount_type='transit', n_pointings=N_POINTS)
transit.gen_pointings()
plot_coordinates(*transit.pointings)
tracking = Survey('perfect-small')
tracking.set_pointings(mount_type='tracking', n_pointings=N_POINTS)
tracking.gen_pointings()
plot_coordinates(*tracking.pointings)
r.set_dm_host(model='gauss', mean=100, std=200)
r.set_dm_igm(model='ioka', slope=1000, std=None)
r.set_dm(mw=True, igm=True, host=True)
r.set_emission_range(low=100e6, high=10e9)
r.set_lum(model='powerlaw',
per_source='different',
low=1e40,
high=1e45,
power=0)
r.set_si(model='gauss', mean=-1.4, std=1)
r.set_w(model='lognormal', per_source='different', mean=0.1, std=1)
rate = lognormal(ra, 1, int(n))
r.set_time(model='poisson', rate=rate)
# Set up survey
s = Survey('chime-frb', n_days=N_DAYS)
s.set_beam(model='chime-frb')
# Only generate FRBs in CHIME's survey region
r.set_direction(model='uniform',
min_ra=s.ra_min,
max_ra=s.ra_max,
min_dec=s.dec_min,
max_dec=s.dec_max)
r.generate()
surv_pop = SurveyPopulation(r, s)
surv_pop.name = 'cosmic_chime'
print(surv_pop.source_rate)
print(surv_pop.burst_rate)
si_mu=0.,
si_sigma=0.,
z_max=2.5)
pop.save()
pop_obs = {}
if OBSERVE:
if not CREATE:
pop = unpickle(f'simple')
for pattern in BEAMPATTERNS:
# Create Survey
survey = Survey('perfect-small', gain_pattern=pattern, n_sidelobes=0)
# Observe populations
pop_obs[pattern] = SurveyPopulation(pop, survey)
pop_obs[pattern].name = f'obs-{pattern}'
pop_obs[pattern].rates()
pop_obs[pattern].save()
else:
for p in BEAMPATTERNS:
pop_obs[p] = unpickle(f'obs-{p}')
f, (ax1) = plt.subplots(1, 1)
for p in BEAMPATTERNS:
linestyle = self.lz[pop.z_max]
colour = self.colours[int(i % (len(pops)/2))]
label = '_'.join(pop.name.split('_')[0:-1])
if i > (len(pops)/2 - 1): # Turn off some line labels
label = f'_{label}'
ax.step(*self.calc_cum_hist(pop), where='mid',
label=rf'{label}', linestyle=linestyle,
color=colour)
def calc_cum_hist(self, pop):
# Bin up parameter in a cumulative bin
edges, values = hist(pop.frbs.snr, bin_type='log')
if isinstance(edges, float):
return np.nan, np.nan
n_gt_s = np.cumsum(values[::-1])[::-1]
# Normalise to S/N of 10^5
log_diff = (np.log10(edges[0]) - np.log10(1e0))
edges = 10**(np.log10(edges) - log_diff)
return edges, n_gt_s
if __name__ == '__main__':
for s in SURVEYS:
survey = Survey(s)
survey.set_beam('gaussian')
if s == 'perfect':
survey.set_beam('perfect')
Flattening(SIZE, survey)
SIDELOBES = [0, 1, 8]
# Generate population with standard candles
pop = CosmicPopulation(n_srcs=5e5, n_days=1, name='standard')
pop.set_dist(model='sfr', z_max=2.5, H_0=67.74, W_m=0.3089, W_v=0.6911)
pop.set_dm_igm(model='ioka', slope=1200, std=0)
pop.set_dm(mw=False, host=False, igm=True)
pop.set_emission_range(low=10e6, high=10e9)
pop.set_lum(model='constant', value=1e36)
pop.set_w(model='constant', value=1)
pop.set_si(model='constant', value=0)
pop.generate()
pop_obs = {}
survey = Survey('perfect-small')
survey.beam_size_at_fwhm = 10.
survey.set_beam(model='airy')
for sidelobe in SIDELOBES:
survey.set_beam(model='airy', n_sidelobes=sidelobe)
# Observe populations
pop_obs[sidelobe] = SurveyPopulation(pop, survey)
pop_obs[sidelobe].name = f'obs-{sidelobe}'
pop_obs[sidelobe].source_rate
pop_obs[sidelobe].save()
plot_aa_style()
f, (ax1) = plt.subplots(1, 1)
