def white_noise_block(vary=False):
"""
Returns the white noise block of the model:
1. EFAC per backend/receiver system
2. EQUAD per backend/receiver system
3. ECORR per backend/receiver system
:param vary:
If set to true we vary these parameters
with uniform priors. Otherwise they are set to constants
with values to be set later.
"""
# define selection by observing backend
selection = selections.Selection(selections.by_backend)
# white noise parameters
if vary:
efac = parameter.Uniform(0.01, 10.0)
equad = parameter.Uniform(-8.5, -5)
ecorr = parameter.Uniform(-8.5, -5)
else:
efac = parameter.Constant()
equad = parameter.Constant()
ecorr = parameter.Constant()
# white noise signals
ef = white_signals.MeasurementNoise(efac=efac, selection=selection)
eq = white_signals.EquadNoise(log10_equad=equad, selection=selection)
ec = white_signals.EcorrKernelNoise(log10_ecorr=ecorr, selection=selection)
# combine signals
s = ef + eq + ec
return s
def paired_ppta_band_noise(self, option=[]):
"""
Including band noise terms for paired values of the PPTA "-B" flag:
joint 1020-cm and 4050-cm red processes.
"""
for ii, paired_band_term in enumerate(option):
log10_A = parameter.Uniform(self.params.syn_lgA[0],
self.params.syn_lgA[1])
gamma = parameter.Uniform(self.params.syn_gamma[0],\
self.params.syn_gamma[1])
pl = utils.powerlaw(log10_A=log10_A, gamma=gamma, \
components=self.params.red_general_nfouriercomp)
setattr(self, paired_band_term, globals()[paired_band_term])
nfreqs = self.determine_nfreqs(sel_func_name=paired_band_term)
pbn_term = gp_signals.FourierBasisGP(spectrum=pl, Tspan=self.params.Tspan,
name='band_noise_' + paired_band_term,
selection=selections.Selection( \
self.__dict__[paired_band_term] ),
components=nfreqs)
if ii == 0:
pbn = pbn_term
elif ii > 0:
pbn += pbn_term
return pbn
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 __init__(self,
enterprise_pintpulsar,
selection=selections.Selection(selections.by_backend),
nfreqcomps=30):
"""Constructor method
"""
#self.parfile = parfile
#self.timfile = timfile
self.selection = selection
# Initialize enterprise PintPulsar object
#self.ltpsr = None
self.ephem = None
self.F0 = None
self.P0 = None
self.psr = None
self.pname = None
# Initialize white noise vectors and gradients
self.Nvec = None
self.Jvec = None
self.d_Nvec_d_param = dict()
self.d_Jvec_d_param = dict()
# Initialize red noise and jitter mode vectors and gradients
self.Phivec = None
self.d_Phivec_d_param = dict()
# Orthogonalized design matrix
self.Mmat_g = None
# Initialize Fourier design matrix
self.nfreqcomps = nfreqcomps
self.Fmat = None
self.Ffreqs = None
# Initialize ECORR exploder matrix
self.Umat = None
self.Uindslc = None
# Initialize Zmat
self.Zmat = None
# Enterprise signals
self.efac_sig = None
self.equad_sig = None
self.ecorr_sig = None
self.rn_sig = None
self.tm_sig = None
# Signal and parameter dictionaries
self.signals = dict()
self.ptadict = dict()
self.ptaparams = dict()
self.init_hierarchical_model(enterprise_pintpulsar)
def efac(self,option="by_backend"):
"""
EFAC signal: multiplies ToA variance by EFAC**2, where ToA variance
are diagonal components of the Likelihood covariance matrix.
"""
if option not in selections.__dict__.keys():
raise ValueError('EFAC option must be Enterprise selection function name')
se=selections.Selection(selections.__dict__[option])
efacpr = interpret_white_noise_prior(self.params.efac)
efs = white_signals.MeasurementNoise(efac=efacpr,selection=se)
return efs
def equad(self,option="by_backend"):
"""
EQUAD signal: adds EQUAD**2 to the ToA variance, where ToA variance
are diagonal components of the Likelihood covariance matrix.
"""
if option not in selections.__dict__.keys():
raise ValueError('EQUAD option must be Enterprise selection function \
name')
se=selections.Selection(selections.__dict__[option])
equadpr = interpret_white_noise_prior(self.params.equad)
eqs = white_signals.EquadNoise(log10_equad=equadpr,selection=se)
return eqs
def ecorr(self,option="by_backend"):
"""
Similar to EFAC and EQUAD, ECORR is a white noise parameter that
describes a correlation between ToAs in a single epoch (observation).
Arzoumanian, Zaven, et al. The Astrophysical Journal 859.1 (2018): 47.
"""
if option not in selections.__dict__.keys():
raise ValueError('ECORR option must be Enterprise selection function \
name')
se=selections.Selection(selections.__dict__[option])
ecorrpr = interpret_white_noise_prior(self.params.ecorr)
ecs = white_signals.EcorrKernelNoise(log10_ecorr=ecorrpr,selection=se)
return ecs
def test_selections(self):
# note: -B flag ('by_band') not currently represented in test data
for sel in ["cut_half", "by_frontend", "by_backend", "nanograv_backends", "by_telescope", "no_selection"]:
s = selections.Selection(getattr(selections, sel))(self.psr)
msg = "Selection mask count is incorrect for {}".format(sel)
assert sum(sum(mask) for mask in s.masks.values()) == len(self.psr.toas), msg
msg = "Selection mask coverage incomplete for {}".format(sel)
assert np.all(functools.reduce(operator.or_, s.masks.values())), msg
msg = "Selection mask not independent for {}".format(sel)
assert np.all(sum(mask for mask in s.masks.values()) == 1), msg
def ppta_band_noise(self,option=[]):
"""
Including red noise terms by the PPTA "-B" flag, only with flagvals in
noise model file. It is considered a derivative of system noise in our code.
See Lentati, Lindley, et al. MNRAS 458.2 (2016): 2161-2187.
"""
for ii, band_term in enumerate(option):
log10_A = parameter.Uniform(self.params.syn_lgA[0],self.params.syn_lgA[1])
gamma = parameter.Uniform(self.params.syn_gamma[0],\
self.params.syn_gamma[1])
selection_function_name = 'band_noise_selection_' + \
str(self.sys_noise_count)
setattr(self, selection_function_name,
selection_factory(selection_function_name))
band_term, nfreqs = self.option_nfreqs(band_term, \
selection_flag='B', \
sel_func_name=selection_function_name)
if "turnover" in band_term:
fc = parameter.Uniform(self.params.sn_fc[0],self.params.sn_fc[1])
pl = powerlaw_bpl(log10_A=log10_A, gamma=gamma, fc=fc,
components=self.params.red_general_nfouriercomp)
option_split = band_term.split("_")
del option_split[option_split.index("turnover")]
band_term = "_".join(option_split)
else:
pl = utils.powerlaw(log10_A=log10_A, gamma=gamma, \
components=self.params.red_general_nfouriercomp)
tspan = self.determine_tspan(sel_func_name=selection_function_name)
syn_term = gp_signals.FourierBasisGP(spectrum=pl, Tspan=tspan,
name='band_noise_' + \
str(self.sys_noise_count),
selection=selections.Selection( \
self.__dict__[selection_function_name] ),
components=nfreqs)
if ii == 0:
syn = syn_term
elif ii > 0:
syn += syn_term
self.sys_noise_count += 1
return syn
def initialize_pta_sim(psrs, fgw,
inc_efac=True, inc_equad=False, inc_ecorr=False,
selection=None,
inc_red_noise=False, noisedict=None):
# continuous GW signal
s = models.cw_block_circ(log10_fgw=np.log10(fgw), psrTerm=True)
# linearized timing model
s += gp_signals.TimingModel(use_svd=True)
# white noise
if selection == 'backend':
selection = selections.Selection(selections.by_backend)
if inc_efac:
efac = parameter.Constant()
s += white_signals.MeasurementNoise(efac=efac, selection=selection)
if inc_equad:
equad = parameter.Constant()
s += white_signals.EquadNoise(log10_equad=equad,
selection=selection)
if inc_ecorr:
ecorr = parameter.Constant()
s += gp_signals.EcorrBasisModel(log10_ecorr=ecorr,
selection=selection)
if inc_red_noise:
log10_A = parameter.Constant()
gamma = parameter.Constant()
pl = utils.powerlaw(log10_A=log10_A, gamma=gamma)
s += gp_signals.FourierBasisGP(pl, components=30)
model = [s(psr) for psr in psrs]
pta = signal_base.PTA(model)
# set white noise parameters
if noisedict is None:
print('No noise dictionary provided!...')
else:
pta.set_default_params(noisedict)
return pta
def paired_ppta_band_noise(self, option=[]):
"""
Including band noise terms for paired values of the PPTA "-B" flag:
joint 1020-cm and 4050-cm red processes.
"""
for ii, paired_band_term in enumerate(option):
log10_A = parameter.Uniform(self.params.syn_lgA[0],self.params.syn_lgA[1])
gamma = parameter.Uniform(self.params.syn_gamma[0],\
self.params.syn_gamma[1])
if "turnover" in paired_band_term:
fc = parameter.Uniform(self.params.sn_fc[0],self.params.sn_fc[1])
pl = powerlaw_bpl(log10_A=log10_A, gamma=gamma, fc=fc,
components=self.params.red_general_nfouriercomp)
option_split = paired_band_term.split("_")
del option_split[option_split.index("turnover")]
paired_band_term = "_".join(option_split)
else:
pl = utils.powerlaw(log10_A=log10_A, gamma=gamma, \
components=self.params.red_general_nfouriercomp)
if "nfreqs" not in paired_band_term:
setattr(self, paired_band_term, globals()[paired_band_term])
paired_band_term, nfreqs = self.option_nfreqs(paired_band_term, \
sel_func_name=paired_band_term)
setattr(self, paired_band_term, globals()[paired_band_term])
tspan = self.determine_tspan(sel_func_name=paired_band_term)
pbn_term = gp_signals.FourierBasisGP(spectrum=pl, Tspan=tspan,
name='band_noise_' + paired_band_term,
selection=selections.Selection( \
self.__dict__[paired_band_term] ),
components=nfreqs)
if ii == 0:
pbn = pbn_term
elif ii > 0:
pbn += pbn_term
return pbn
def ppta_band_noise(self, option=[]):
"""
Including red noise terms by the PPTA "-B" flag, only with flagvals in
noise model file. It is considered a derivative of system noise in our code.
See Lentati, Lindley, et al. MNRAS 458.2 (2016): 2161-2187.
"""
for ii, band_term in enumerate(option):
log10_A = parameter.Uniform(self.params.syn_lgA[0],
self.params.syn_lgA[1])
gamma = parameter.Uniform(self.params.syn_gamma[0],\
self.params.syn_gamma[1])
pl = utils.powerlaw(log10_A=log10_A, gamma=gamma, \
components=self.params.red_general_nfouriercomp)
selection_function_name = 'band_noise_selection_' + \
str(self.sys_noise_count)
setattr(self, selection_function_name,
selection_factory(selection_function_name))
self.psr.sys_flags.append('B')
self.psr.sys_flagvals.append(band_term)
nfreqs = self.determine_nfreqs(
sel_func_name=selection_function_name)
tspan = self.determine_tspan(sel_func_name=selection_function_name)
syn_term = gp_signals.FourierBasisGP(spectrum=pl, Tspan=tspan,
name='band_noise_' + \
str(self.sys_noise_count),
selection=selections.Selection( \
self.__dict__[selection_function_name] ),
components=nfreqs)
if ii == 0:
syn = syn_term
elif ii > 0:
syn += syn_term
self.sys_noise_count += 1
return syn
def system_noise(self,option=[]):
"""
Including red noise terms by "-group" flag, only with flagvals in noise
model file.
See Lentati, Lindley, et al. MNRAS 458.2 (2016): 2161-2187.
"""
for ii, sys_noise_term in enumerate(option):
log10_A = parameter.Uniform(self.params.syn_lgA[0],self.params.syn_lgA[1])
gamma = parameter.Uniform(self.params.syn_gamma[0],\
self.params.syn_gamma[1])
pl = utils.powerlaw(log10_A=log10_A, gamma=gamma, \
components=self.params.red_general_nfouriercomp)
selection_function_name = 'sys_noise_selection_'+str(self.sys_noise_count)
setattr(self, selection_function_name,
selection_factory(selection_function_name))
sys_noise_term, nfreqs = self.option_nfreqs(sys_noise_term, \
selection_flag='group', \
sel_func_name=selection_function_name)
tspan = self.determine_tspan(sel_func_name=selection_function_name)
syn_term = gp_signals.FourierBasisGP(spectrum=pl, Tspan=tspan,
name='system_noise_' + \
str(self.sys_noise_count),
selection=selections.Selection( \
self.__dict__[selection_function_name] ),
components=nfreqs)
if ii == 0:
syn = syn_term
elif ii > 0:
syn += syn_term
self.sys_noise_count += 1
return syn
save4 = np.load('dpdmpardict.npy')
Dict = {save2[i]: save1[i] for i in range(len(save2))}
Dict.update({save4[i]: save3[i] for i in range(len(save4))})
# The Big Model
# dm noise
log10_A_dm = parameter.Constant()
gamma_dm = parameter.Constant()
pl_dm = utils.powerlaw(log10_A=log10_A_dm, gamma=gamma_dm)
dm_basis = utils.createfourierdesignmatrix_dm(nmodes=50, Tspan=None)
dmn = gp_signals.BasisGP(pl_dm, dm_basis, name='dm_gp', coefficients=False)
# spin noise
log10_A = parameter.Constant()
gamma = parameter.Constant()
pl = utils.powerlaw(log10_A=log10_A, gamma=gamma)
selection = selections.Selection(selections.no_selection)
spn = gp_signals.FourierBasisGP(pl,
components=50,
Tspan=None,
coefficients=False,
selection=selection,
modes=None)
dp = DPDM.dpdm_block(type_='Bayes')
tm = gp_signals.TimingModel()
eph = deterministic_signals.PhysicalEphemerisSignal(use_epoch_toas=True)
wnb = models.white_noise_block(vary=False)
model = tm + dp + wnb + dmn + spn + eph
nparams = [] # Get the number of parameters of each pulsar
signals = []
from enterprise.signals import white_signals
from enterprise.signals import gp_signals
from enterprise import constants as const
from enterprise_extensions import models, model_utils, sampler, dropout
import pta_sim.parse_sim as parse_sim
args = parse_sim.arguments()
logging.basicConfig(level=logging.WARNING)
with open(args.pickle, 'rb') as fin:
psrs = pickle.load(fin)
pidx = args.process #os.environ['SLURM_ARRAY_TASK_ID']
psr = psrs[pidx]
backend = selections.Selection(selections.by_backend)
ng_backend = selections.Selection(selections.nanograv_backends)
efac = parameter.Uniform(0.1,5)
equad = parameter.Uniform(-8.5,-5)
ecorr = parameter.Uniform(-8.5,-5)
kdrop = parameter.Uniform(0,1)
kthresh = 0.5
ef = dropout.dropout_MeasurementNoise(efac=efac,
efac_drop=kdrop,
efac_thresh=kthresh,
selection=backend)
eq = dropout.dropout_EquadNoise(log10_equad=equad,
equad_drop=kdrop,
equad_thresh=kthresh,
def gwb_ul(psrs_cut, num_points):
# find the maximum time span to set GW frequency sampling
tmin = [p.toas.min() for p in psrs_cut]
tmax = [p.toas.max() for p in psrs_cut]
Tspan = np.max(tmax) - np.min(tmin)
# define selection by observing backend
selection = selections.Selection(selections.by_backend)
# white noise parameters
# we set these ourselves so we know the most likely values!
efac = parameter.Constant(1)
# quad = parameter.Constant(0)
# ecorr = parameter.Constant(0)
# red noise parameters
log10_A = parameter.LinearExp(-20, -11)
gamma = parameter.Uniform(0, 7)
# GW parameters (initialize with names here to use parameters in common across pulsars)
log10_A_gw = parameter.LinearExp(-18, -12)('log10_A_gw')
gamma_gw = parameter.Constant(4.33)('gamma_gw')
# white noise
ef = white_signals.MeasurementNoise(efac=efac, selection=selection)
# eq = white_signals.EquadNoise(log10_equad=equad, selection=selection)
# ec = white_signals.EcorrKernelNoise(log10_ecorr=ecorr, selection=selection)
# red noise (powerlaw with 30 frequencies)
pl = utils.powerlaw(log10_A=log10_A, gamma=gamma)
rn = gp_signals.FourierBasisGP(spectrum=pl, components=30, Tspan=Tspan)
# gwb (no spatial correlations)
cpl = utils.powerlaw(log10_A=log10_A_gw, gamma=gamma_gw)
gw = gp_signals.FourierBasisGP(spectrum=cpl,
components=30,
Tspan=Tspan,
name='gw')
# timing model
tm = gp_signals.TimingModel(
use_svd=True) # stabilizing timing model design matrix with SVD
s = ef + rn + gw + tm
# intialize PTA
models = []
for p in psrs_cut:
models.append(s(p))
pta = signal_base.PTA(models)
outDir = './chains/psrs/{0}'.format(psrs_cut[0].name)
sample = sampler.setup_sampler(pta, outdir=outDir)
x0 = np.hstack([p.sample() for p in pta.params])
# sampler for N steps
N = int(
num_points) # normally, we would use 5e6 samples (this will save time)
sample.sample(
x0,
N,
SCAMweight=30,
AMweight=15,
DEweight=50,
)
chain = np.loadtxt(os.path.join(outDir, 'chain_1.txt'))
pars = np.loadtxt(outDir + '/pars.txt', dtype=np.unicode_)
ind = list(pars).index('log10_A_gw')
UL, unc = model_utils.ul(chain[:, ind])
return UL, unc
psrs = pickle.load(f)
with open(args.noisefile, "rb") as f:
noise_params = pickle.load(f)
print("loaded pickles")
#################
## PTA model ##
#################
tmin = np.min([p.toas.min() for p in psrs])
tmax = np.max([p.toas.max() for p in psrs])
Tspan = tmax - tmin
# White Noise
selection = selections.Selection(selections.by_backend)
efac = parameter.Constant()
equad = parameter.Constant()
ecorr = parameter.Constant()
ef = white_signals.MeasurementNoise(efac=efac, selection=selection)
eq = white_signals.EquadNoise(log10_equad=equad, selection=selection)
ec = white_signals.EcorrKernelNoise(log10_ecorr=ecorr, selection=selection)
wn = ef + eq + ec
# Red Noise
if args.UL:
rn_log10_A = parameter.LinearExp(-20, -11)
else:
def white_noise_block(vary=False,
inc_ecorr=False,
gp_ecorr=False,
efac1=False,
select='backend',
name=None):
"""
Returns the white noise block of the model:
1. EFAC per backend/receiver system
2. EQUAD per backend/receiver system
3. ECORR per backend/receiver system
:param vary:
If set to true we vary these parameters
with uniform priors. Otherwise they are set to constants
with values to be set later.
:param inc_ecorr:
include ECORR, needed for NANOGrav channelized TOAs
:param gp_ecorr:
whether to use the Gaussian process model for ECORR
:param efac1:
use a strong prior on EFAC = Normal(mu=1, stdev=0.1)
"""
if select == 'backend':
# define selection by observing backend
backend = selections.Selection(selections.by_backend)
# define selection by nanograv backends
backend_ng = selections.Selection(selections.nanograv_backends)
else:
# define no selection
backend = selections.Selection(selections.no_selection)
# white noise parameters
if vary:
if efac1:
efac = parameter.Normal(1.0, 0.1)
else:
efac = parameter.Uniform(0.01, 10.0)
equad = parameter.Uniform(-8.5, -5)
if inc_ecorr:
ecorr = parameter.Uniform(-8.5, -5)
else:
efac = parameter.Constant()
equad = parameter.Constant()
if inc_ecorr:
ecorr = parameter.Constant()
# white noise signals
ef = white_signals.MeasurementNoise(efac=efac,
selection=backend,
name=name)
eq = white_signals.EquadNoise(log10_equad=equad,
selection=backend,
name=name)
if inc_ecorr:
if gp_ecorr:
if name is None:
ec = gp_signals.EcorrBasisModel(log10_ecorr=ecorr,
selection=backend_ng)
else:
ec = gp_signals.EcorrBasisModel(log10_ecorr=ecorr,
selection=backend_ng,
name=name)
else:
ec = white_signals.EcorrKernelNoise(log10_ecorr=ecorr,
selection=backend_ng,
name=name)
# combine signals
if inc_ecorr:
s = ef + eq + ec
elif not inc_ecorr:
s = ef + eq
return s
def red_noise_block(psd='powerlaw',
prior='log-uniform',
Tspan=None,
components=30,
gamma_val=None,
coefficients=False,
select=None,
modes=None,
wgts=None,
break_flat=False,
break_flat_fq=None):
"""
Returns red noise model:
1. Red noise modeled as a power-law with 30 sampling frequencies
:param psd:
PSD function [e.g. powerlaw (default), turnover, spectrum, tprocess]
:param prior:
Prior on log10_A. Default if "log-uniform". Use "uniform" for
upper limits.
:param Tspan:
Sets frequency sampling f_i = i / Tspan. Default will
use overall time span for indivicual pulsar.
:param components:
Number of frequencies in sampling of red noise
:param gamma_val:
If given, this is the fixed slope of the power-law for
powerlaw, turnover, or tprocess red noise
:param coefficients: include latent coefficients in GP model?
"""
# red noise parameters that are common
if psd in [
'powerlaw', 'powerlaw_genmodes', 'turnover', 'tprocess',
'tprocess_adapt', 'infinitepower'
]:
# parameters shared by PSD functions
if prior == 'uniform':
log10_A = parameter.LinearExp(-20, -11)
elif prior == 'log-uniform' and gamma_val is not None:
if np.abs(gamma_val - 4.33) < 0.1:
log10_A = parameter.Uniform(-20, -11)
else:
log10_A = parameter.Uniform(-20, -11)
else:
log10_A = parameter.Uniform(-20, -11)
if gamma_val is not None:
gamma = parameter.Constant(gamma_val)
else:
gamma = parameter.Uniform(0, 7)
# different PSD function parameters
if psd == 'powerlaw':
pl = utils.powerlaw(log10_A=log10_A, gamma=gamma)
elif psd == 'powerlaw_genmodes':
pl = gpp.powerlaw_genmodes(log10_A=log10_A, gamma=gamma, wgts=wgts)
elif psd == 'turnover':
kappa = parameter.Uniform(0, 7)
lf0 = parameter.Uniform(-9, -7)
pl = utils.turnover(log10_A=log10_A,
gamma=gamma,
lf0=lf0,
kappa=kappa)
elif psd == 'tprocess':
df = 2
alphas = gpp.InvGamma(df / 2, df / 2, size=components)
pl = gpp.t_process(log10_A=log10_A, gamma=gamma, alphas=alphas)
elif psd == 'tprocess_adapt':
df = 2
alpha_adapt = gpp.InvGamma(df / 2, df / 2, size=1)
nfreq = parameter.Uniform(-0.5, 10 - 0.5)
pl = gpp.t_process_adapt(log10_A=log10_A,
gamma=gamma,
alphas_adapt=alpha_adapt,
nfreq=nfreq)
elif psd == 'infinitepower':
pl = gpp.infinitepower()
if psd == 'spectrum':
if prior == 'uniform':
log10_rho = parameter.LinearExp(-10, -4, size=components)
elif prior == 'log-uniform':
log10_rho = parameter.Uniform(-10, -4, size=components)
pl = gpp.free_spectrum(log10_rho=log10_rho)
if select == 'backend':
# define selection by observing backend
selection = selections.Selection(selections.by_backend)
elif select == 'band' or select == 'band+':
# define selection by observing band
selection = selections.Selection(selections.by_band)
else:
# define no selection
selection = selections.Selection(selections.no_selection)
if break_flat:
log10_A_flat = parameter.Uniform(-20, -11)
gamma_flat = parameter.Constant(0)
pl_flat = utils.powerlaw(log10_A=log10_A_flat, gamma=gamma_flat)
freqs = 1.0 * np.arange(1, components + 1) / Tspan
components_low = sum(f < break_flat_fq for f in freqs)
if components_low < 1.5:
components_low = 2
rn = gp_signals.FourierBasisGP(pl,
components=components_low,
Tspan=Tspan,
coefficients=coefficients,
selection=selection)
rn_flat = gp_signals.FourierBasisGP(pl_flat,
modes=freqs[components_low:],
coefficients=coefficients,
selection=selection,
name='red_noise_hf')
rn = rn + rn_flat
else:
rn = gp_signals.FourierBasisGP(pl,
components=components,
Tspan=Tspan,
coefficients=coefficients,
selection=selection,
modes=modes)
if select == 'band+': # Add the common component as well
rn = rn + gp_signals.FourierBasisGP(
pl, components=components, Tspan=Tspan, coefficients=coefficients)
return rn
#Calculate the time span of the dataset
Tspan = psr.toas.max() - psr.toas.min()
## White Noise Block
# Define new mask and selection to avoid non-channelized NICER TOAs (for ECORR)
def channelized_backends(backend_flags):
"""Selection function to split by channelized backend flags only."""
flagvals = np.unique(backend_flags)
ch_b = ['ASP', 'GASP', 'GUPPI', 'PUPPI', 'NUPPI']
flagvals = filter(lambda x: any(map(lambda y: y in x, ch_b)), flagvals)
return {flagval: backend_flags == flagval for flagval in flagvals}
selection_ch = selections.Selection(channelized_backends)
selection = selections.Selection(selections.by_backend)
ef = white_signals.MeasurementNoise(efac=efac, selection=selection)
eq = white_signals.EquadNoise(log10_equad=equad, selection=selection)
ec = white_signals.EcorrKernelNoise(log10_ecorr=ecorr, selection=selection_ch)
# red noise (powerlaw with 5 frequencies)
pl = utils.powerlaw(log10_A=log10_A, gamma=gamma)
basis = utils.createfourierdesignmatrix_red(Tspan=Tspan,
nmodes=args.nfreqs,
logf=args.logf)
rn = gp_signals.BasisGP(priorFunction=pl,
name='red_noise',
basisFunction=basis)
tfile = os.path.join(args.datadir, '{}.tim'.format(psr_name))
nfile = os.path.join(args.datadir, "{}_noise.json".format(psr_name))
psrs.append(Pulsar(pfile, tfile, ephem=args.ephem,
timing_package='tempo2'))
with open(nfile, 'r') as f:
noise_params.update(json.load(f))
# find the maximum time span to set GW frequency sampling
tmin = [p.toas.min() for p in psrs]
tmax = [p.toas.max() for p in psrs]
Tspan = np.max(tmax) - np.min(tmin)
######################
## ipta DR2 model ##
######################
bkend = selections.Selection(selections.by_backend)
bkend_NG = selections.Selection(selections.nanograv_backends)
# fix white noise parameters
efac = parameter.Constant()
equad = parameter.Constant()
ecorr = parameter.Constant()
# DMGP parameters and powerlaw
dm_log10_A = parameter.Uniform(-20, -11)
dm_gamma = parameter.Uniform(0, 7)
dm_pl = utils.powerlaw(log10_A=dm_log10_A, gamma=dm_gamma)
dm_basis = utils.createfourierdesignmatrix_dm(nmodes=30, Tspan=Tspan)
# red noise parameters and powerlaw
if args.ul:
def model_simple(psrs, psd='powerlaw', efac=False, n_gwbfreqs=30,
components=30, freqs=None,
vary_gamma=False, upper_limit=False, bayesephem=False,
select='backend', red_noise=False, Tspan=None, hd_orf=False,
rn_dropout=False, dp_threshold=0.5):
"""
Reads in list of enterprise Pulsar instance and returns a PTA
instantiated with the most simple model allowable for enterprise:
per pulsar:
1. fixed EFAC per backend/receiver system at 1.0
2. Linear timing model.
3. Red noise modeled as a power-law with
30 sampling frequencies. Default=False
global:
1.Common red noise modeled with user defined PSD with
30 sampling frequencies. Available PSDs are
['powerlaw', 'turnover' 'spectrum']
2. Optional physical ephemeris modeling.
:param psd:
PSD to use for common red noise signal. Available options
are ['powerlaw', 'turnover' 'spectrum']. 'powerlaw' is default
value.
:param gamma_common:
Fixed common red process spectral index value. By default we
vary the spectral index over the range [0, 7].
:param upper_limit:
Perform upper limit on common red noise amplitude. By default
this is set to False. Note that when performing upper limits it
is recommended that the spectral index also be fixed to a specific
value.
:param bayesephem:
Include BayesEphem model. Set to False by default
"""
amp_prior = 'uniform' if upper_limit else 'log-uniform'
# find the maximum time span to set GW frequency sampling
if Tspan is None:
Tspan = model_utils.get_tspan(psrs)
# timing model
model = gp_signals.TimingModel()
#Only White Noise is EFAC set to 1.0
selection = selections.Selection(selections.by_backend)
if efac:
ef = parameter.Uniform(0.1,10.0)
else:
ef = parameter.Constant(1.00)
model += white_signals.MeasurementNoise(efac=ef, selection=selection)
# common red noise block
if upper_limit:
log10_A_gw = parameter.LinearExp(-18,-12)('gw_log10_A')
else:
log10_A_gw = parameter.Uniform(-18,-12)('gw_log10_A')
if vary_gamma:
gamma_gw = parameter.Uniform(0,7)('gw_gamma')
else:
gamma_gw = parameter.Constant(4.33)('gw_gamma')
pl = signal_base.Function(utils.powerlaw, log10_A=log10_A_gw,
gamma=gamma_gw)
if hd_orf:
if freqs is None:
gw = gp_signals.FourierBasisCommonGP(spectrum=pl,
orf=utils.hd_orf(),
components=n_gwbfreqs,
Tspan=Tspan,
name='gw')
else:
gw = gp_signals.FourierBasisCommonGP(spectrum=pl,
orf=utils.hd_orf(),
modes=freqs,
name='gw')
model += gw
else:
if freqs is None:
crn = gp_signals.FourierBasisGP(spectrum=pl, components=n_gwbfreqs,
Tspan=Tspan, name='gw')
else:
crn = gp_signals.FourierBasisGP(spectrum=pl, modes=freqs,
name='gw')
model += crn
if red_noise and rn_dropout:
if amp_prior == 'uniform':
log10_A = parameter.LinearExp(-20, -11)
elif amp_prior == 'log-uniform':
log10_A = parameter.Uniform(-20, -11)
else:
log10_A = parameter.Uniform(-20, -11)
gamma = parameter.Uniform(0, 7)
k_drop = parameter.Uniform(0, 1)
if dp_threshold == 6.0:
dp_threshold = parameter.Uniform(0,1)('k_threshold')
pl = dropout.dropout_powerlaw(log10_A=log10_A, gamma=gamma,
k_drop=k_drop, k_threshold=dp_threshold)
rn = gp_signals.FourierBasisGP(pl, components=components,
Tspan=Tspan, name='red_noise')
model += rn
elif red_noise:
# red noise
model += models.red_noise_block(prior=amp_prior, Tspan=Tspan,
components=components)
# ephemeris model
if bayesephem:
model += deterministic_signals.PhysicalEphemerisSignal(use_epoch_toas=True)
# set up PTA
pta = signal_base.PTA([model(p) for p in psrs])
return pta
if np.abs(args.gamma_gw - 4.33) < 0.1:
gw_log10_A = parameter.Uniform(-18, -14)('gw_log10_A')
else:
gw_log10_A = parameter.Uniform(-18, -11)('gw_log10_A')
gw_gamma = parameter.Constant(args.gamma_gw)('gw_gamma')
# White noise parameter priors
efac = parameter.Constant()
equad = parameter.Constant()
ecorr = parameter.Constant()
Nf = args.nfreqs
freqs = np.linspace(1 / Tspan, Nf / Tspan, Nf)
# # white noise
selection = selections.Selection(selections.nanograv_backends)
ef = white_signals.MeasurementNoise(efac=efac,
log10_t2equad=equad,
selection=selection)
ec = white_signals.EcorrKernelNoise(log10_ecorr=ecorr, selection=selection)
# red noise (powerlaw with 30 frequencies)
pl = utils.powerlaw(log10_A=log10_A, gamma=gamma)
rn = gp_signals.FourierBasisGP(spectrum=pl, modes=freqs)
# timing model
tm = gp_signals.TimingModel()
# gw (powerlaw with 5 frequencies)
