def dm_exponential_dip(tmin, tmax, idx=2, sign='negative', name='dmexp'):
"""
Returns chromatic exponential dip (i.e. TOA advance):
:param tmin, tmax:
search window for exponential dip time.
:param idx:
index of radio frequency dependence (i.e. DM is 2). If this is set
to 'vary' then the index will vary from 1 - 6
:param sign:
set sign of dip: 'positive', 'negative', or 'vary'
:param name: Name of signal
:return dmexp:
chromatic exponential dip waveform.
"""
t0_dmexp = parameter.Uniform(tmin, tmax)
log10_Amp_dmexp = parameter.Uniform(-10, -2)
log10_tau_dmexp = parameter.Uniform(0, 2.5)
if sign == 'vary':
sign_param = parameter.Uniform(-1.0, 1.0)
elif sign == 'positive':
sign_param = 1.0
else:
sign_param = -1.0
wf = chrom_exp_decay(log10_Amp=log10_Amp_dmexp,
t0=t0_dmexp,
log10_tau=log10_tau_dmexp,
sign_param=sign_param,
idx=idx)
dmexp = deterministic_signals.Deterministic(wf, name=name)
return dmexp
def test_fdm(self):
"""Test FDM waveform."""
log10_A = parameter.Uniform(-20, -11)("fdm_log10_A")
log10_f = parameter.Uniform(-9, -7)("fdm_log10_f")
phase_e = parameter.Uniform(0, 2 * np.pi)("fdm_phase_e")
phase_p = parameter.Uniform(0, 2 * np.pi)("fdm_phase_p")
fdm_wf = utils.fdm_delay(log10_A=log10_A,
log10_f=log10_f,
phase_e=phase_e,
phase_p=phase_p)
fdm = deterministic_signals.Deterministic(fdm_wf)
m = fdm(self.psr)
# true parameters
log10_A = -14
log10_f = -8
phase_e = np.pi
phase_p = np.pi
params = {
"fdm_log10_A": log10_A,
"fdm_log10_f": log10_f,
"fdm_phase_e": phase_e,
"fdm_phase_p": phase_p,
}
d1 = utils.fdm_delay(self.psr.toas,
log10_A=log10_A,
log10_f=log10_f,
phase_e=phase_e,
phase_p=phase_p)
# test
msg = "FDM Delay incorrect"
assert np.all(m.get_delay(params) == d1), msg
def fd_sys_g(self,option=[]):
idx = 1 # fitting linear trend
for ii, fd_sys_term in enumerate(option):
name = 'fd' + str(idx) + '_sys_' + fd_sys_term
slope = parameter.Uniform(-self.params.fd_sys_slope_range,\
self.params.fd_sys_slope_range)
wf = fd_system(slope = slope, idx_fd = idx)
selection_function_name = 'fd_system_selection_' + \
str(self.sys_noise_count)
setattr(self, selection_function_name,
selection_factory(selection_function_name))
if fd_sys_term == "WBCORR_10CM_512":
self.psr.sys_flags.append('beconfig')
self.psr.sys_flagvals.append('wbb256_512_256_3p_b')
else:
self.psr.sys_flags.append('group')
self.psr.sys_flagvals.append(fd_sys_term)
fd_sys_term = deterministic_signals.Deterministic( wf, name=name,
selection=selections.Selection(\
self.__dict__[selection_function_name]) )
if ii == 0:
fd_sys = fd_sys_term
elif ii > 0:
fd_sys += fd_sys_term
self.sys_noise_count += 1
return fd_sys
def bwm_block(Tmin,
Tmax,
amp_prior='log-uniform',
skyloc=None,
logmin=-18,
logmax=-11,
name='bwm'):
"""
Returns deterministic GW burst with memory model:
1. Burst event parameterized by time, sky location,
polarization angle, and amplitude
:param Tmin:
Min time to search, probably first TOA (MJD).
:param Tmax:
Max time to search, probably last TOA (MJD).
:param amp_prior:
Prior on log10_A. Default if "log-uniform". Use "uniform" for
upper limits.
:param skyloc:
Fixed sky location of BWM signal search as [cos(theta), phi].
Search over sky location if ``None`` given.
:param logmin:
log of minimum BWM amplitude for prior (log10)
:param logmax:
log of maximum BWM amplitude for prior (log10)
:param name:
Name of BWM signal.
"""
# BWM parameters
amp_name = '{}_log10_A'.format(name)
if amp_prior == 'uniform':
log10_A_bwm = parameter.LinearExp(logmin, logmax)(amp_name)
elif amp_prior == 'log-uniform':
log10_A_bwm = parameter.Uniform(logmin, logmax)(amp_name)
pol_name = '{}_pol'.format(name)
pol = parameter.Uniform(0, np.pi)(pol_name)
t0_name = '{}_t0'.format(name)
t0 = parameter.Uniform(Tmin, Tmax)(t0_name)
costh_name = '{}_costheta'.format(name)
phi_name = '{}_phi'.format(name)
if skyloc is None:
costh = parameter.Uniform(-1, 1)(costh_name)
phi = parameter.Uniform(0, 2 * np.pi)(phi_name)
else:
costh = parameter.Constant(skyloc[0])(costh_name)
phi = parameter.Constant(skyloc[1])(phi_name)
# BWM signal
bwm_wf = ee_deterministic.bwm_delay(log10_h=log10_A_bwm,
t0=t0,
cos_gwtheta=costh,
gwphi=phi,
gwpol=pol)
bwm = deterministic_signals.Deterministic(bwm_wf, name=name)
return bwm
def bwm_sglpsr_block(Tmin,
Tmax,
amp_prior='log-uniform',
logmin=-17,
logmax=-12,
name='ramp',
fixed_sign=None):
if fixed_sign is None:
sign = parameter.Uniform(-1, 1)("sign")
else:
sign = np.sign(fixed_sign)
amp_name = '{}_log10_A'.format(name)
if amp_prior == 'uniform':
log10_A_ramp = parameter.LinearExp(logmin, logmax)(amp_name)
elif amp_prior == 'log-uniform':
log10_A_ramp = parameter.Uniform(logmin, logmax)(amp_name)
t0_name = '{}_t0'.format(name)
t0 = parameter.Uniform(Tmin, Tmax)(t0_name)
ramp_wf = ee_deterministic.bwm_sglpsr_delay(log10_A=log10_A_ramp,
t0=t0,
sign=sign)
ramp = deterministic_signals.Deterministic(ramp_wf, name=name)
return ramp
def dm_exponential_dip(tmin,
tmax,
idx=2,
sign='negative',
name='dmexp',
lgA_min=-10.,
lgA_max=-2.,
sign_min=-1.,
sign_max=1.,
tau_min_10_pow=5,
tau_max_10_pow=100):
t0_dmexp = parameter.Uniform(tmin, tmax)
log10_Amp_dmexp = parameter.Uniform(lgA_min, lgA_max)
log10_tau_dmexp = parameter.Uniform(np.log10(tau_min_10_pow),
np.log10(tau_max_10_pow))
if idx == 'vary':
idx = parameter.Uniform(-7, 7)
if sign == 'vary':
sign_param = parameter.Uniform(sign_min, sign_max)
elif sign == 'positive':
sign_param = 1.0
else:
sign_param = -1.0
wf = models.chrom_exp_decay(log10_Amp=log10_Amp_dmexp,
t0=t0_dmexp,
log10_tau=log10_tau_dmexp,
sign_param=sign_param,
idx=idx)
dmexp = deterministic_signals.Deterministic(wf, name=name)
return dmexp
def fdm_block(Tmin,
Tmax,
amp_prior='log-uniform',
name='fdm',
amp_lower=-18,
amp_upper=-11,
freq_lower=-9,
freq_upper=-7,
use_fixed_freq=False,
fixed_freq=-8):
"""
Returns deterministic fuzzy dark matter model:
1. FDM parameterized by frequency, phase,
and amplitude (mass and DM energy density).
:param Tmin:
Min time to search, probably first TOA (MJD).
:param Tmax:
Max time to search, probably last TOA (MJD).
:param amp_prior:
Prior on log10_A.
:param logmin:
log of minimum FDM amplitude for prior (log10)
:param logmax:
log of maximum FDM amplitude for prior (log10)
:param name:
Name of FDM signal.
:param amp_upper, amp_lower, freq_upper, freq_lower:
The log-space bounds on the amplitude and frequency priors.
:param use_fixed_freq:
Whether to do a fixed-frequency run and not search over the frequency.
:param fixed_freq:
The frequency value to do a fixed-frequency run with.
"""
# BWM parameters
amp_name = '{}_log10_A'.format(name)
log10_A_fdm = parameter.Uniform(amp_lower, amp_upper)(amp_name)
if use_fixed_freq is True:
log10_f_fdm = fixed_freq
if use_fixed_freq is False:
freq_name = '{}_log10_f'.format(name)
log10_f_fdm = parameter.Uniform(freq_lower, freq_upper)(freq_name)
phase_e_name = '{}_phase_e'.format(name)
phase_e_fdm = parameter.Uniform(0, 2 * np.pi)(phase_e_name)
phase_p = parameter.Uniform(0, 2 * np.pi)
fdm_wf = fdm_delay(log10_A=log10_A_fdm,
log10_f=log10_f_fdm,
phase_e=phase_e_fdm,
phase_p=phase_p)
fdm = deterministic_signals.Deterministic(fdm_wf, name=name)
return fdm
def dm_dual_exp_cusp(tmin,
tmax,
idx1=2,
idx2=4,
sign='negative',
symmetric=False,
name='dual_dm_cusp'):
"""
Returns chromatic exponential cusp (i.e. TOA advance):
:param tmin, tmax:
search window for exponential cusp time.
:param idx:
index of radio frequency dependence (i.e. DM is 2). If this is set
to 'vary' then the index will vary from 1 - 6
:param sign:
set sign of dip: 'positive', 'negative', or 'vary'
:param name: Name of signal
:return dmexp:
chromatic exponential dip waveform.
"""
t0_dual_cusp = parameter.Uniform(tmin, tmax)
log10_Amp_dual_cusp_1 = parameter.Uniform(-10, -2)
log10_Amp_dual_cusp_2 = parameter.Uniform(-10, -2)
log10_tau_dual_cusp_pre_1 = parameter.Uniform(0, 2.5)
log10_tau_dual_cusp_pre_2 = parameter.Uniform(0, 2.5)
if sign == 'vary':
sign_param = parameter.Uniform(-1.0, 1.0)
elif sign == 'positive':
sign_param = 1.0
else:
sign_param = -1.0
if symmetric:
log10_tau_dual_cusp_post_1 = 1
log10_tau_dual_cusp_post_2 = 1
else:
log10_tau_dual_cusp_post_1 = parameter.Uniform(0, 2.5)
log10_tau_dual_cusp_post_2 = parameter.Uniform(0, 2.5)
wf = chrom_dual_exp_cusp(t0=t0_dual_cusp,
sign_param=sign_param,
symmetric=symmetric,
log10_Amp_1=log10_Amp_dual_cusp_1,
log10_tau_pre_1=log10_tau_dual_cusp_pre_1,
log10_tau_post_1=log10_tau_dual_cusp_post_1,
log10_Amp_2=log10_Amp_dual_cusp_2,
log10_tau_pre_2=log10_tau_dual_cusp_pre_2,
log10_tau_post_2=log10_tau_dual_cusp_post_2,
idx1=idx1,
idx2=idx2)
dm_cusp = deterministic_signals.Deterministic(wf, name=name)
return dm_cusp
def dm_annual_signal(idx=2, name='dm_s1yr'):
"""
Returns chromatic annual signal (i.e. TOA advance)
"""
log10_Amp_dm1yr = parameter.Uniform(-10., -5.)
phase_dm1yr = parameter.Uniform(0, 2*np.pi)
wf = chromatic.chrom_yearly_sinusoid(log10_Amp=log10_Amp_dm1yr,
phase=phase_dm1yr, idx=idx)
dm1yr = deterministic_signals.Deterministic(wf, name=name)
return dm1yr
def bwm_sngl_block(Tmin,
Tmax,
amp_prior='log-uniform',
logmin=-18,
logmax=-9,
name='bwm'):
"""
Returns deterministic single pulsar GW burst with memory model:
1. Burst event parameterized by time, amplitude, and sign (+/-)
:param Tmin:
Min time to search, probably first TOA (MJD).
:param Tmax:
Max time to search, probably last TOA (MJD).
:param amp_prior:
Prior on log10_A. Default if "log-uniform". Use "uniform" for
upper limits.
:param logmin:
log of minimum BWM amplitude for prior (log10)
:param logmax:
log of maximum BWM amplitude for prior (log10)
:param name:
Name of BWM signal.
"""
# BWM parameters
amp_name = '{}_log10_A'.format(name)
if amp_prior == 'uniform':
log10_A_bwm = parameter.LinearExp(logmin, logmax)(amp_name)
elif amp_prior == 'log-uniform':
log10_A_bwm = parameter.Uniform(logmin, logmax)(amp_name)
elif amp_prior == 'log-normal':
log10_A_bwm = parameter.Normal(logmin, logmax)(amp_name)
elif amp_prior == 'true-uniform':
amp_name = '{}_A'.format(name)
A_bwm = parameter.Uniform(10**logmin, 10**logmax)(amp_name)
else:
raise NotImplementedError('Unknown prior for BWM amplitude!')
t0_name = '{}_t0'.format(name)
t0 = parameter.Uniform(Tmin, Tmax)(t0_name)
sign_name = '{}_sign'.format(name)
sign = parameter.Uniform(-1.0, 1.0)(sign_name)
# BWM signal
if amp_prior == 'true-uniform':
bwm_wf = bwm_sngl_delay(h=A_bwm, t0=t0, sign=sign)
else:
bwm_wf = bwm_sngl_delay(log10_h=log10_A_bwm, t0=t0, sign=sign)
bwm = deterministic_signals.Deterministic(bwm_wf, name=name)
return bwm
def f2_signal(self,option="uniform"):
"""
F2 parameter
"""
with open(self.psr.parfile_name, "r") as parf:
for line in parf:
if "PEPOCH" in line:
self.psr.pepoch = float(line.split()[1]) * 24 * 60 * 60
print("PEPOCH extraction: ", self.psr.pepoch)
f2_coeff = parameter.Uniform(-self.params.f2_range, self.params.f2_range)('f2')
wf = f2_waveform(coeff = f2_coeff)
f2_signal = deterministic_signals.Deterministic(wf)
return f2_signal
def timing_block(
tmparam_list=['RAJ', 'DECJ', 'F0', 'F1', 'PMRA', 'PMDEC', 'PX']):
"""
Returns the timing model block of the model
:param tmparam_list: a list of parameters to vary in the model
"""
# default 5-sigma prior above and below the parfile mean
tm_params = parameter.Uniform(-5.0, 5.0, size=len(tmparam_list))
# timing model
tm_func = tm_delay(tmparams=tm_params, which=tmparam_list)
tm = deterministic_signals.Deterministic(tm_func, name='timing model')
return tm
def test_bwm(self):
"""Tests :meth:`enterprise.signals.deterministic_signals.Deterministic`
using the burst-with-memory function :func:`enterprise.signals.utils.bwm_delay`.
The test instantiates a deterministic Signal on our test pulsar, and
compares the array returned by calling `get_delay()` on the Signal
with a fixed dictionary of parameters, with the result of calling
the function directly with those parameters.
"""
log10_h = parameter.Uniform(-20, -11)("bwm_log10_h")
cos_gwtheta = parameter.Uniform(-1, 1)("bwm_cos_gwtheta")
gwphi = parameter.Uniform(0, 2 * np.pi)("bwm_gwphi")
gwpol = parameter.Uniform(0, np.pi)("bwm_gwpol")
t0 = parameter.Uniform(53000, 57000)("bwm_t0")
bwm_wf = utils.bwm_delay(log10_h=log10_h,
cos_gwtheta=cos_gwtheta,
gwphi=gwphi,
gwpol=gwpol,
t0=t0)
bwm = deterministic_signals.Deterministic(bwm_wf)
m = bwm(self.psr)
# true parameters
log10_h = -14
cos_gwtheta = 0.5
gwphi = 0.5
gwpol = 0.0
t0 = 55000
params = {
"bwm_log10_h": log10_h,
"bwm_cos_gwtheta": cos_gwtheta,
"bwm_gwphi": gwphi,
"bwm_gwpol": gwpol,
"bwm_t0": t0,
}
d1 = utils.bwm_delay(self.psr.toas,
self.psr.pos,
log10_h=log10_h,
cos_gwtheta=cos_gwtheta,
gwphi=gwphi,
gwpol=gwpol,
t0=t0)
# test
msg = "BWM Delay incorrect"
assert np.all(m.get_delay(params) == d1), msg
def CWSignal(cw_wf, ecc=False, psrTerm=False, name='cw'):
BaseClass = deterministic_signals.Deterministic(cw_wf, name=name)
class CWSignal(BaseClass):
def __init__(self, psr):
super(CWSignal, self).__init__(psr)
self._wf[''].add_kwarg(psrTerm=psrTerm)
if ecc:
pgam = parameter.Uniform(0, 2 * np.pi)('_'.join(
[psr.name, 'pgam', name]))
self._params['pgam'] = pgam
self._wf['']._params['pgam'] = pgam
return CWSignal
def dpdm_block(type_,
log10_ma=None,
log10_eps=None,
dec_dp=None,
ra_dp=None,
phase_e=None,
dphase=None):
# Tips: you may wonder why 'x' before '_dp_', it's beacuse I want to make sure they are the last parameters to show up.
name = 'x_dp_'
if log10_ma == None:
log10_ma = parameter.Uniform(-23.0, -21.0)(name + 'log10_ma')
if log10_eps == None:
log10_eps = parameter.Uniform(-28.0, -16.0)(name + 'log10_eps')
if dec_dp == None:
dec_dp = parameter.Uniform(-np.pi / 2., np.pi / 2.)(name + 'Dec')
if ra_dp == None:
ra_dp = parameter.Uniform(0, 2 * np.pi)(name + 'Ra')
if phase_e == None:
phase_e = parameter.Uniform(0, np.pi)(name + 'phase_e')
if type_ == 'Bayes':
# In Bayes Method, we need to model the DPDM signals on every pulsar at the same time,
# so that the 'dphase' are included
if dphase == None:
dphase = parameter.Uniform(-np.pi, np.pi)
# I don't give 'dphase' a name, so that each pulsar will have its own 'dphase'.
delay = dpdm_delay(log10_ma=log10_ma,
log10_eps=log10_eps,
ra_dp=ra_dp,
dec_dp=dec_dp,
phase_e=phase_e,
dphase=dphase)
elif type_ == 'Freq':
delay = dpdm_delay(log10_ma=log10_ma,
log10_eps=log10_eps,
ra_dp=ra_dp,
dec_dp=dec_dp,
phase_e=phase_e)
dpdm = deterministic_signals.Deterministic(delay, name=name)
return dpdm
def dm_gaussian_bump(tmin, tmax, idx=2, sigma_min=20, sigma_max=140,
log10_A_low=-6, log10_A_high=-5, name='dm_bump'):
"""
For the extreme scattering event in J1603-7202.
"""
sign_param = 1.0
t0_dm_bump = parameter.Uniform(tmin,tmax)
sigma_dm_bump = parameter.Uniform(sigma_min,sigma_max)
log10_Amp_dm_bump = parameter.Uniform(log10_A_low, log10_A_high)
if idx == 'vary':
idx = parameter.Uniform(0, 6)
wf = chrom_gaussian_bump(log10_Amp=log10_Amp_dm_bump,
t0=t0_dm_bump, sigma=sigma_dm_bump,
sign_param=sign_param, idx=idx)
dm_bump = deterministic_signals.Deterministic(wf, name=name)
return dm_bump
def CWSignal(cw_wf, inc_psr_term=True):
BaseClass = deterministic_signals.Deterministic(cw_wf, name='cgw')
class CWSignal(BaseClass):
def __init__(self, psr):
super(CWSignal, self).__init__(psr)
self._wf[''].add_kwarg(inc_psr_term=inc_psr_term)
#if inc_psr_term:
# pdist = parameter.Normal(psr.pdist[0], psr.pdist[1])('_'.join([psr.name, 'cgw', 'pdist']))
# pphase = parameter.Uniform(0, 2*np.pi)('_'.join([psr.name, 'cgw', 'pphase']))
# self._params['p_dist'] = pdist
# self._params['p_phase'] = pphase
# self._wf['']._params['p_dist'] = pdist
# self._wf['']._params['p_phase'] = pphase
return CWSignal
def test_delay_backend(self):
"""Same as :meth:`TestDeterministicSignals.test_delay`, but
instantiates the Signal with :func:`enterprise.signals.selections.by_backend`,
which creates separated named parameters for 430_ASP, 430_PUPPI,
L-wide_ASP, L-wide_PUPPI. The parameters are automatically accounted for
in `get_delay()`, but they need to be used explicitly when calling the
function directly. The tests therefore reconstructs the delay vector by
building selection masks from :meth:`enterprise.Pulsar.backend_flags`."""
# set up signal and parameters
log10_Ad = parameter.Uniform(-10, -5)
log10_fd = parameter.Uniform(-9, -7)
waveform = sine_wave(log10_A=log10_Ad, log10_f=log10_fd)
selection = Selection(selections.by_backend)
dt = deterministic_signals.Deterministic(waveform, selection=selection)
m = dt(self.psr)
# parameters
lAs = [-7.6, -7.1, -6, -6.4]
lfs = [-7.6, -8.0, -9, -8.4]
params = {
"B1855+09_430_ASP_log10_A": lAs[0],
"B1855+09_430_PUPPI_log10_A": lAs[1],
"B1855+09_L-wide_ASP_log10_A": lAs[2],
"B1855+09_L-wide_PUPPI_log10_A": lAs[3],
"B1855+09_430_ASP_log10_f": lfs[0],
"B1855+09_430_PUPPI_log10_f": lfs[1],
"B1855+09_L-wide_ASP_log10_f": lfs[2],
"B1855+09_L-wide_PUPPI_log10_f": lfs[3],
}
# correct value
flags = ["430_ASP", "430_PUPPI", "L-wide_ASP", "L-wide_PUPPI"]
delay = np.zeros_like(self.psr.toas)
for ct, flag in enumerate(np.unique(flags)):
ind = flag == self.psr.backend_flags
delay[ind] = sine_wave(self.psr.toas[ind],
log10_A=lAs[ct],
log10_f=lfs[ct])
# test
msg = "Delay incorrect."
assert np.all(m.get_delay(params) == delay), msg
def test_delay(self):
"""Test deterministic signal no selection."""
# set up signal and parameters
log10_Ad = parameter.Uniform(-10, -5)
log10_fd = parameter.Uniform(-9, -7)
waveform = sine_wave(log10_A=log10_Ad, log10_f=log10_fd)
dt = deterministic_signals.Deterministic(waveform)
m = dt(self.psr)
# parameters
log10_A = -7.2
log10_f = -8.0
params = {"B1855+09_log10_A": log10_A, "B1855+09_log10_f": log10_f}
# correct value
delay = sine_wave(self.psr.toas, log10_A=log10_A, log10_f=log10_f)
# test
msg = "Delay incorrect"
assert np.all(m.get_delay(params) == delay), msg
def dm_annual_signal(idx=2, name='dm_s1yr'):
"""
Returns chromatic annual signal (i.e. TOA advance):
:param idx:
index of radio frequency dependence (i.e. DM is 2). If this is set
to 'vary' then the index will vary from 1 - 6
:param name: Name of signal
:return dm1yr:
chromatic annual waveform.
"""
log10_Amp_dm1yr = parameter.Uniform(-10, -2)
phase_dm1yr = parameter.Uniform(0, 2 * np.pi)
wf = chrom_yearly_sinusoid(log10_Amp=log10_Amp_dm1yr,
phase=phase_dm1yr,
idx=idx)
dm1yr = deterministic_signals.Deterministic(wf, name=name)
return dm1yr
def test_bwm(self):
"""Test BWM waveform."""
log10_h = parameter.Uniform(-20, -11)('bwm_log10_h')
cos_gwtheta = parameter.Uniform(-1, 1)('bwm_cos_gwtheta')
gwphi = parameter.Uniform(0, 2 * np.pi)('bwm_gwphi')
gwpol = parameter.Uniform(0, np.pi)('bwm_gwpol')
t0 = parameter.Uniform(53000, 57000)('bwm_t0')
bwm_wf = utils.bwm_delay(log10_h=log10_h,
cos_gwtheta=cos_gwtheta,
gwphi=gwphi,
gwpol=gwpol,
t0=t0)
bwm = deterministic_signals.Deterministic(bwm_wf)
m = bwm(self.psr)
# true parameters
log10_h = -14
cos_gwtheta = 0.5
gwphi = 0.5
gwpol = 0.0
t0 = 55000
params = {
'bwm_log10_h': log10_h,
'bwm_cos_gwtheta': cos_gwtheta,
'bwm_gwphi': gwphi,
'bwm_gwpol': gwpol,
'bwm_t0': t0
}
d1 = utils.bwm_delay(self.psr.toas,
self.psr.pos,
log10_h=log10_h,
cos_gwtheta=cos_gwtheta,
gwphi=gwphi,
gwpol=gwpol,
t0=t0)
# test
msg = 'BWM Delay incorrect'
assert np.all(m.get_delay(params) == d1), msg
def test_bwm(self):
"""Test BWM waveform."""
log10_h = parameter.Uniform(-20, -11)("bwm_log10_h")
cos_gwtheta = parameter.Uniform(-1, 1)("bwm_cos_gwtheta")
gwphi = parameter.Uniform(0, 2 * np.pi)("bwm_gwphi")
gwpol = parameter.Uniform(0, np.pi)("bwm_gwpol")
t0 = parameter.Uniform(53000, 57000)("bwm_t0")
bwm_wf = utils.bwm_delay(log10_h=log10_h,
cos_gwtheta=cos_gwtheta,
gwphi=gwphi,
gwpol=gwpol,
t0=t0)
bwm = deterministic_signals.Deterministic(bwm_wf)
m = bwm(self.psr)
# true parameters
log10_h = -14
cos_gwtheta = 0.5
gwphi = 0.5
gwpol = 0.0
t0 = 55000
params = {
"bwm_log10_h": log10_h,
"bwm_cos_gwtheta": cos_gwtheta,
"bwm_gwphi": gwphi,
"bwm_gwpol": gwpol,
"bwm_t0": t0,
}
d1 = utils.bwm_delay(self.psr.toas,
self.psr.pos,
log10_h=log10_h,
cos_gwtheta=cos_gwtheta,
gwphi=gwphi,
gwpol=gwpol,
t0=t0)
# test
msg = "BWM Delay incorrect"
assert np.all(m.get_delay(params) == d1), msg
def dmx_signal(dmx_data, name='dmx_signal'):
"""
Returns DMX signal:
:param dmx_data: dictionary of DMX data for each pulsar from parfile.
:param name: Name of signal.
:return dmx_sig:
dmx signal waveform.
"""
dmx = {}
for dmx_id in sorted(dmx_data):
dmx_data_tmp = dmx_data[dmx_id]
dmx.update({
dmx_id:
parameter.Normal(mu=dmx_data_tmp['DMX_VAL'],
sigma=dmx_data_tmp['DMX_ERR'])
})
wf = dmx_delay(dmx_ids=dmx_data, **dmx)
dmx_sig = deterministic_signals.Deterministic(wf, name=name)
return dmx_sig
def dm_gaussian_bump(tmin,
tmax,
idx=2,
sigma_min=20,
sigma_max=140,
log10_A_low=-6,
log10_A_high=-1,
name='dm_bump'):
"""
Returns chromatic Gaussian bump (i.e. TOA advance):
:param tmin, tmax:
search window for exponential cusp time.
:param idx:
index of radio frequency dependence (i.e. DM is 2). If this is set
to 'vary' then the index will vary from 1 - 6
:param sigma_min, sigma_max:
standard deviation of a Gaussian in MJD
:param sign:
[boolean] allow for positive or negative exponential features.
:param name: Name of signal
:return dm_bump:
chromatic Gaussian bump waveform.
"""
sign_param = 1.0
t0_dm_bump = parameter.Uniform(tmin, tmax)
sigma_dm_bump = parameter.Uniform(sigma_min, sigma_max)
log10_Amp_dm_bump = parameter.Uniform(log10_A_low, log10_A_high)
if idx == 'vary':
idx = parameter.Uniform(0, 6)
wf = chrom_gaussian_bump(log10_Amp=log10_Amp_dm_bump,
t0=t0_dm_bump,
sigma=sigma_dm_bump,
sign_param=sign_param,
idx=idx)
dm_bump = deterministic_signals.Deterministic(wf, name=name)
return dm_bump
def dpdm_block_constant(DP_pars):
# This block is for single pulsar analysis in the Frequentist scheme, therefore 5 common parameters are constants.
name = 'x_dp_'
log10_ma = parameter.Constant(DP_pars[name + 'log10_ma'])(name +
'const_log10_ma')
log10_eps = parameter.Constant(
DP_pars[name + 'log10_eps'])(name + 'const_log10_eps')
dec_dp = parameter.Constant(DP_pars[name + 'Dec'])(name + 'const_Dec')
ra_dp = parameter.Constant(DP_pars[name + 'Ra'])(name + 'const_Ra')
phase_e = parameter.Constant(DP_pars[name + 'phase_e'])(name +
'const_phase_e')
dphase = parameter.Uniform(-np.pi, np.pi)(name + 'vary_dphase')
delay = dpdm_delay(log10_ma=log10_ma,
log10_eps=log10_eps,
ra_dp=ra_dp,
dec_dp=dec_dp,
phase_e=phase_e,
dphase=dphase)
dpdm = deterministic_signals.Deterministic(delay, name='x_dp')
return dpdm
def test_delay_backend(self):
"""Test deterministic signal with selection."""
# set up signal and parameters
log10_Ad = parameter.Uniform(-10, -5)
log10_fd = parameter.Uniform(-9, -7)
waveform = sine_wave(log10_A=log10_Ad, log10_f=log10_fd)
selection = Selection(selections.by_backend)
dt = deterministic_signals.Deterministic(waveform, selection=selection)
m = dt(self.psr)
# parameters
lAs = [-7.6, -7.1, -6, -6.4]
lfs = [-7.6, -8.0, -9, -8.4]
params = {
"B1855+09_430_ASP_log10_A": lAs[0],
"B1855+09_430_PUPPI_log10_A": lAs[1],
"B1855+09_L-wide_ASP_log10_A": lAs[2],
"B1855+09_L-wide_PUPPI_log10_A": lAs[3],
"B1855+09_430_ASP_log10_f": lfs[0],
"B1855+09_430_PUPPI_log10_f": lfs[1],
"B1855+09_L-wide_ASP_log10_f": lfs[2],
"B1855+09_L-wide_PUPPI_log10_f": lfs[3],
}
# correct value
flags = ["430_ASP", "430_PUPPI", "L-wide_ASP", "L-wide_PUPPI"]
delay = np.zeros_like(self.psr.toas)
for ct, flag in enumerate(np.unique(flags)):
ind = flag == self.psr.backend_flags
delay[ind] = sine_wave(self.psr.toas[ind],
log10_A=lAs[ct],
log10_f=lfs[ct])
# test
msg = "Delay incorrect."
assert np.all(m.get_delay(params) == delay), msg
def dm_exponential_dip(tmin, tmax, idx=2, name='dmexp'):
"""
Returns chromatic exponential dip (i.e. TOA advance):
:param tmin, tmax:
search window for exponential dip time.
:param idx:
index of radio frequency dependence (i.e. DM is 2). If this is set
to 'vary' then the index will vary from 1 - 6
:param name: Name of signal
:return dmexp:
chromatic exponential dip waveform.
"""
t0_dmexp = parameter.Uniform(tmin, tmax)
log10_Amp_dmexp = parameter.Uniform(-10, -2)
log10_tau_dmexp = parameter.Uniform(np.log10(5), np.log10(100))
wf = chrom_exp_decay(log10_Amp=log10_Amp_dmexp,
t0=t0_dmexp,
log10_tau=log10_tau_dmexp,
idx=idx)
dmexp = deterministic_signals.Deterministic(wf, name=name)
return dmexp
Basis for chromatic quadratic function.
:param idx: index of chromatic dependence
:return ret: normalized quadratic basis matrix [Ntoa, 3]
"""
t0 = (toas.max() + toas.min()) / 2
a, b, c = 10**quad_coeff[0], 10**quad_coeff[1], 10**quad_coeff[2]
quad = (a * (toas - t0)**2 + b * (toas - t0) + c) * (1400 / freqs)**idx
return quad
quad_coeff = parameter.Uniform(-10, -4, size=3)
deter_chrom = chromatic_quad(quad_coeff=quad_coeff)
chrom_quad = deterministic_signals.Deterministic(deter_chrom,
name='deter_chrom_quad')
for ii, ent in enumerate(model_labels):
if ent[2] and ent[5]:
extra = dmgp + dmgp2 + chromgp + chrom_quad
elif ent[2]:
extra = dmgp + dmgp2 + chromgp
elif ent[5]:
extra = dmgp + chromgp + chrom_quad
else:
extra = dmgp + chromgp
new_kwargs = {
'dm_nondiag_kernel': ent[1],
'dm_var': False,
'chrom_gp': ent[3],
# timing model
s = gp_signals.MarginalizingTimingModel()
# intrinsic red noise
s += blocks.red_noise_block(prior='log-uniform',
Tspan=Tspan_PTA,
components=30)
# adding white-noise, separating out Adv Noise Psrs, and acting on psr objects
final_psrs = []
psr_models = []
### Add a stand alone SW deter model
bins = np.linspace(53215, 57934, 26)
bins *= 24 * 3600 #Convert to secs
n_earth = chrom.solar_wind.ACE_SWEPAM_Parameter(size=bins.size -
1)('n_earth')
deter_sw = chrom.solar_wind.solar_wind(n_earth=n_earth, n_earth_bins=bins)
mean_sw = deterministic_signals.Deterministic(deter_sw, name='sw_r2')
np_earth = parameter.Uniform(-4, -2)('np_4p39')
sw_power = parameter.Constant(4.39)('sw_power_4p39')
deter_sw_p = chrom.solar_wind.solar_wind_r_to_p(n_earth=np_earth,
power=sw_power,
log10_ne=True)
mean_sw += deterministic_signals.Deterministic(deter_sw_p, name='sw_4p39')
for psr in pkl_psrs:
# Filter out other Adv Noise Pulsars
if psr.name in adv_noise_psr_list:
### Get the new pulsar object
## Remember that J1713's pickle is something you made yourself ##
filepath = '/gscratch/gwastro/hazboun/nanograv/noise/noise_model_selection/no_dmx_pickles/'
filepath += '{0}_ng12p5yr_v3_nodmx_ePSR.pkl'.format(psr.name)
with open(filepath, 'rb') as fin:
def Dropout_PhysicalEphemerisSignal(
frame_drift_rate=parameter.Uniform(-1e-9, 1e-9)('frame_drift_rate'),
d_jupiter_mass=parameter.Normal(0, 1.54976690e-11)('d_jupiter_mass'),
d_saturn_mass=parameter.Normal(0, 8.17306184e-12)('d_saturn_mass'),
d_uranus_mass=parameter.Normal(0, 5.71923361e-11)('d_uranus_mass'),
d_neptune_mass=parameter.Normal(0, 7.96103855e-11)('d_neptune_mass'),
jup_orb_elements=parameter.Uniform(-0.05, 0.05,
size=6)('jup_orb_elements'),
sat_orb_elements=parameter.Uniform(-0.5, 0.5,
size=6)('sat_orb_elements'),
inc_jupiter_orb=True,
inc_saturn_orb=False,
use_epoch_toas=True,
k_drop=parameter.Uniform(0.0, 1.0),
k_threshold=0.5,
name=''):
""" Class factory for dropout physical ephemeris model signal."""
# turn off saturn orbital element parameters if not including in signal
if not inc_saturn_orb:
sat_orb_elements = np.zeros(6)
# define waveform
jup_mjd, jup_orbelxyz, sat_mjd, sat_orbelxyz = (
utils.get_planet_orbital_elements())
wf = dropout_physical_ephem_delay(frame_drift_rate=frame_drift_rate,
d_jupiter_mass=d_jupiter_mass,
d_saturn_mass=d_saturn_mass,
d_uranus_mass=d_uranus_mass,
d_neptune_mass=d_neptune_mass,
jup_orb_elements=jup_orb_elements,
sat_orb_elements=sat_orb_elements,
inc_jupiter_orb=inc_jupiter_orb,
jup_orbelxyz=jup_orbelxyz,
jup_mjd=jup_mjd,
inc_saturn_orb=inc_saturn_orb,
sat_orbelxyz=sat_orbelxyz,
sat_mjd=sat_mjd,
k_drop=k_drop,
k_threshold=k_threshold)
BaseClass = deterministic_signals.Deterministic(wf, name=name)
class Dropout_PhysicalEphemerisSignal(BaseClass):
signal_name = 'phys_ephem'
signal_id = 'phys_ephem_' + name if name else 'phys_ephem'
def __init__(self, psr):
# not available for PINT yet
if isinstance(psr, enterprise.pulsar.PintPulsar):
msg = 'Physical Ephemeris model is not compatible with PINT '
msg += 'at this time.'
raise NotImplementedError(msg)
super(Dropout_PhysicalEphemerisSignal, self).__init__(psr)
if use_epoch_toas:
# get quantization matrix and calculate daily average TOAs
U, _ = utils.create_quantization_matrix(psr.toas, nmin=1)
self.uinds = utils.quant2ind(U)
avetoas = np.array([psr.toas[sc].mean() for sc in self.uinds])
self._wf[''].add_kwarg(toas=avetoas)
# interpolate ssb planet position vectors to avetoas
planetssb = np.zeros((len(avetoas), 9, 3))
for jj in range(9):
planetssb[:, jj, :] = np.array([
np.interp(avetoas, psr.toas, psr.planetssb[:, jj, aa])
for aa in range(3)
]).T
self._wf[''].add_kwarg(planetssb=planetssb)
# Inteprolating the pulsar position vectors onto epoch TOAs
pos_t = np.array([
np.interp(avetoas, psr.toas, psr.pos_t[:, aa])
for aa in range(3)
]).T
self._wf[''].add_kwarg(pos_t=pos_t)
# initialize delay
self._delay = np.zeros(len(psr.toas))
@signal_base.cache_call('delay_params')
def get_delay(self, params):
delay = self._wf[''](params=params)
if use_epoch_toas:
for slc, val in zip(self.uinds, delay):
self._delay[slc] = val
return self._delay
else:
return delay
return Dropout_PhysicalEphemerisSignal
