def standard_candle_pop(self):
"""Generate a standard candle population."""
pop = CosmicPopulation(self.n,
days=1,
name=self.name,
H_0=67.74,
W_m=0.3089,
W_v=0.6911,
dm_host_model='normal',
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,
pulse_model='uniform',
pulse_range=[1., 1.],
pulse_mu=0.1,
pulse_sigma=0.,
si_mu=0.,
si_sigma=0.,
z_max=2.5)
pop.save()
return pop
def alpha_simple_pop(self):
"""Generate a simple local population varying with alpha."""
pop = CosmicPopulation(self.n,
days=1,
name=self.name,
H_0=67.74,
W_m=0.3089,
W_v=0.6911,
dm_host_model='normal',
dm_host_mu=0.,
dm_host_sigma=0.,
dm_igm_index=0.,
dm_igm_sigma=None,
dm_mw_model='zero',
emission_range=[10e6, 10e9],
lum_range=[1e38, 1e38],
lum_index=0.,
n_model='vol_co',
alpha=self.alpha,
pulse_model='uniform',
pulse_range=[10, 10],
pulse_mu=0.1,
pulse_sigma=1.,
si_mu=0.,
si_sigma=0.,
z_max=0.01)
pop.save()
return pop
def gamma_pop(self):
"""Generate a population varying with spectral index."""
pop = CosmicPopulation(self.n,
days=1,
name=self.name,
H_0=67.74,
W_m=0.3089,
W_v=0.6911,
dm_host_model='normal',
dm_host_mu=0.,
dm_host_sigma=0.,
dm_igm_index=0.,
dm_igm_sigma=None,
dm_mw_model='zero',
emission_range=[10e6, 10e9],
lum_range=[10**42.5, 10**42.5],
lum_index=0.,
n_model='vol_co',
alpha=-1.5,
pulse_model='uniform',
pulse_range=[10, 10],
pulse_mu=0.1,
pulse_sigma=1.,
si_mu=self.gamma,
si_sigma=0.,
z_max=2.5)
pop.save()
return pop
def alpha_pop(self):
"""Generate a population varying with alpha."""
pop = CosmicPopulation(self.n,
days=1,
name=self.name,
H_0=67.74,
W_m=0.3089,
W_v=0.6911,
dm_host_model='normal',
dm_host_mu=100,
dm_host_sigma=200,
dm_igm_index=1000,
dm_igm_sigma=None,
dm_mw_model='ne2001',
emission_range=[10e6, 10e9],
lum_range=[1e40, 1e45],
lum_index=0.,
n_model='vol_co',
alpha=self.alpha,
pulse_model='lognormal',
pulse_range=[1., 1.],
pulse_mu=0.1,
pulse_sigma=0.5,
si_mu=-1.4,
si_sigma=1.,
z_max=2.5)
pop.save()
return pop
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 iter_alpha(i, surveys=surveys, parallel=None):
alpha = ALPHAS[i]
pop = CosmicPopulation.complex(SIZE)
pop.set_dist(model='vol_co', z_max=1.0, alpha=alpha)
pop.set_lum(model='powerlaw', low=1e40, high=1e45, power=-1)
pop.generate()
for li in LIS:
pop.set_lum(model='powerlaw', low=1e40, high=1e45, power=li)
pop.gen_lum()
for si in SIS:
pop.set_si(model='constant', value=si)
pop.gen_si()
pop.name = f'complex_alpha_{alpha}_lum_{li}_si_{si}'
for survey in surveys:
surv_pop = SurveyPopulation(pop, survey)
print(surv_pop.name)
surv_pop.save()
sr = surv_pop.source_rate
rate = sr.det / sr.days
mask = (df.alpha == alpha) & (df.li == li) & (df.si == si)
if parallel is not None:
i = df[mask].index
j = SURVEY_NAMES.index(survey.name)
parallel[i, j] = rate
else:
df.loc[mask, survey.name] = rate
def setup_pop(n_srcs):
pop = CosmicPopulation.simple(n_srcs, n_days=MAX_DAYS,
repeaters=True)
pop.set_dist(z_max=0.01)
pop.set_lum(model='powerlaw', per_source='different', low=1e35, high=1e40,
power=-1.7)
pop.set_w(model='constant', value=1)
pop.set_dm(mw=False, igm=True, host=False)
pop.set_dm_igm(model='ioka', slope=1000, std=0)
return pop
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 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}').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.simple(size)
pop.alpha = alpha
pop.name = f'simple_alpha_{alpha}'
pops.append(pop)
# Set up surveys
ss = []
for s in surveys:
survey = Survey(name=s,
gain_pattern='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].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 iter_alpha(i):
alpha = alphas[i]
pop = CosmicPopulation.complex(self.pop_size)
pop.set_dist(model='vol_co', z_max=1.0, alpha=alpha)
pop.set_lum(model='constant', value=1)
if not np.isnan(w_mean):
pop.set_w(model='lognormal', mean=w_mean, std=w_std)
if not np.isnan(dm_igm_slope):
pop.set_dm_igm(model='ioka', slope=dm_igm_slope)
pop.set_dm_host(model='constant', value=dm_host)
pop.generate()
for si in sis:
pop.set_si(model='constant', value=si)
pop.gen_si()
for li in lis:
pop.set_lum(model='powerlaw',
low=1e40,
high=1e45,
power=li)
if not np.isnan(lum_min):
pop.set_lum(model='powerlaw',
low=lum_min,
high=lum_max,
index=li)
pop.gen_lum()
for survey in self.surveys:
surv_pop = SurveyPopulation(pop, survey)
# Get unique identifier
mask = (self.so.df.par_set == 1)
mask &= (self.so.df.run == run)
mask &= (self.so.df.alpha == alpha)
mask &= (self.so.df.si == si)
mask &= (self.so.df.li == li)
mask &= (self.so.df.survey == survey.name)
uuid = self.so.df[mask].uuid.iloc[0]
surv_pop.name = f'mc/run_{run}/{uuid}'
surv_pop.save()
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_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 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
"""Short example of how frbpoppy works."""
from frbpoppy import CosmicPopulation, Survey, SurveyPopulation, plot
PLOT = False
# Generate an FRB population
cosmic_pop = CosmicPopulation(10000, days=1, name='example')
# Setup a survey
survey = Survey('htru')
# Observe the FRB population
survey_pop = SurveyPopulation(cosmic_pop, survey)
# Check the detection rates
print(survey_pop.rates())
# Plot populations
if PLOT:
plot(cosmic_pop, survey_pop, frbcat='parkes')
from tests.convenience import plot_aa_style, rel_path
MAKE = True
NUM_FRBS = True
DENSITY_FRBS = True
pop = {}
pop_types = ('cst', 'sfr', 'smd', 'shallow', 'steep')
titles = ('Constant', 'SFR', 'SMD', r'$\alpha_{\text{in}}=-0.5$',
r'$\alpha_{\text{in}}=-2.0$')
if MAKE:
n_frbs = int(1e5)
# Generate population following a constant number density / comoving volume
pop['cst'] = CosmicPopulation.simple(n_frbs)
pop['cst'].set_dist(model='vol_co', z_max=3.)
pop['cst'].name = 'cst'
pop['cst'].generate()
# Generate population following star forming rate
pop['sfr'] = CosmicPopulation.simple(n_frbs)
pop['sfr'].set_dist(model='sfr', z_max=3.)
pop['sfr'].name = 'sfr'
pop['sfr'].generate()
# Generate population following stellar mass density
pop['smd'] = CosmicPopulation.simple(n_frbs)
pop['smd'].set_dist(model='smd', z_max=3.)
pop['smd'].name = 'smd'
pop['smd'].generate()
for n in (35, 36, 37):
p = float(f'1e{n}')
if n == 35:
# Generate population with standard candles
pop[n] = CosmicPopulation(n_per_day * days,
days=days,
name=f'sc-{n}',
dm_host_model='normal',
dm_host_mu=0,
dm_host_sigma=0,
dm_igm_index=1200,
dm_igm_sigma=0,
dm_mw_model='zero',
emission_range=[10e6, 10e9],
lum_range=[p, p],
lum_index=0,
n_model='sfr',
pulse_model='uniform',
pulse_range=[1., 1.],
pulse_mu=1.,
pulse_sigma=0.,
repeat=0.,
si_mu=0.,
si_sigma=0.,
z_max=2.5)
pop[n].save()
else:
pop[n] = copy.deepcopy(pop[35])
n_gen = len(pop[35].frbs.lum_bol)
"""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':
"""Plot how beampatterns can change the IGM DM distribution."""
import numpy as np
import matplotlib.pyplot as plt
from frbpoppy import CosmicPopulation, Survey, SurveyPopulation
from tests.convenience import plot_aa_style, rel_path
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
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())
"""Simulate a number of large CHIME populations."""
from frbpoppy import CosmicPopulation, lognormal, Survey
from frbpoppy import SurveyPopulation, pprint
N_SRCS = [3e4, 3.5e4, 4e4]
N_DAYS = 100
RATE = [8, 9, 10] # per day
# Chime started in Aug 2018. Assuming 2/day for one-offs.
# Total of 9 repeaters published on 9 Aug 2019. = ~year
N_CHIME = {'rep': 9, 'one-offs': 365 * 2, 'time': 365}
for n in N_SRCS:
for ra in RATE:
print(f'# sources: {n}')
print(f'rate: {ra}')
r = CosmicPopulation(n, 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(ra, 1, int(n))
r.set_time(model='poisson', rate=rate)
import numpy as np
import matplotlib.pyplot as plt
from scipy.signal import savgol_filter
from frbpoppy import CosmicPopulation, Survey, SurveyPopulation
from convenience import plot_aa_style, rel_path
SIS = (-2, 0, 2) # Spectral indices
n_tot = 1e5 # Number of sources
pop = {}
for si in SIS:
if si == min(SIS):
pop[si] = CosmicPopulation.simple(n_tot)
pop[si].name = f'si-{si}'
pop[si].si_mu = si
pop[si].z_max = 2.5
pop[si].generate()
pop[si].save()
else:
pop[si] = copy.deepcopy(pop[min(SIS)])
pop[si].frbs.si = np.random.normal(si, 0, int(n_tot))
pop[si].name = f'si-{si}'
pop[si].save()
pop_obs = {}
for si in SIS:
"""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)
"""Check the log N log F slope of a local population."""
import numpy as np
import matplotlib.pyplot as plt
from frbpoppy import CosmicPopulation, Survey, SurveyPopulation
from frbpoppy.population import unpickle
from tests.convenience import plot_aa_style, rel_path
MAKE = True
if MAKE:
population = CosmicPopulation.simple(1e5, generate=True)
survey = Survey('perfect')
surv_pop = SurveyPopulation(population, survey)
surv_pop.name = 'lognlogflocal'
surv_pop.save()
else:
surv_pop = unpickle('lognlogflocal')
# Get parameter
parms = surv_pop.frbs.fluence
min_p = min(parms)
max_p = max(parms)
# Bin up
min_f = np.log10(min(parms))
max_f = np.log10(max(parms))
log_bins = np.logspace(min_f, max_f, 50)
hist, edges = np.histogram(parms, bins=log_bins)
n_gt_s = np.cumsum(hist[::-1])[::-1]
"""How to access frb population parameters."""
from frbpoppy import CosmicPopulation, Survey, SurveyPopulation
cosmic_pop = CosmicPopulation.simple(1e3, repeaters=True, generate=True)
dm = cosmic_pop.frbs.dm # Get dispersion measure values
survey_pop = SurveyPopulation(cosmic_pop, Survey('perfect'))
survey_dm = survey_pop.frbs.dm # Also works for SurveyPopulations
# Inbuilt functions help with detection rates
print(f'Number of sources: {survey_pop.n_sources()}')
print(f'Number of bursts: {survey_pop.n_bursts()}')
print(f'Number of repeating sources: {survey_pop.n_repeaters()}')
print(f'Number of one-off sources: {survey_pop.n_oneoffs()}')
"""Example of changing parameters."""
from frbpoppy import CosmicPopulation, Survey
# Set up a population with arguments such as z_max ...
cosmic_pop = CosmicPopulation(1e4, z_max=0.01, generate=False)
# ... or adapt the population with e.g.
cosmic_pop.z_max = 2.5
# Generate the population
cosmic_pop.generate()
# Setup a survey with arguments ...
survey = Survey('apertif', gain_pattern='airy', n_sidelobes=2)
# ... or adapt the survey later with
survey.snr_limit = 2
# For a full list of available arguments or parameters check the classes as
# defined in /frbpoppy/*.py
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 get_local():
"""Construct a local population."""
pop = CosmicPopulation.simple(SIZE, generate=True)
survey = Survey('perfect')
surv_pop = SurveyPopulation(pop, survey)
return surv_pop.frbs.s_peak
def gen_def_pop(self):
self.default_pop = CosmicPopulation.simple(self.size)
self.default_pop.set_lum(model='constant', value=1e43)
self.default_pop.generate()
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()}')