def test_model_singlepsr_fact_like(nodmx_psrs, caplog):
# caplog.set_level(logging.CRITICAL)
psr = nodmx_psrs[1]
Tspan = model_utils.get_tspan([psr])
m=models.model_singlepsr_noise(psr, chrom_gp=True,
chrom_gp_kernel='diag',
factorized_like=False,
Tspan=Tspan, fact_like_gamma=13./3,
gw_components=5)
assert hasattr(m, 'get_lnlikelihood')
x0 = {pname: p.sample() for pname, p in zip(m.param_names, m.params)}
m.get_lnlikelihood(x0)
def pta_pshift(dmx_psrs, caplog):
Tspan = model_utils.get_tspan(dmx_psrs)
tm = gp_signals.TimingModel()
wn = blocks.white_noise_block(inc_ecorr=True, tnequad=True)
rn = blocks.red_noise_block(Tspan=Tspan)
pseed = parameter.Uniform(0, 10000)('gw_pseed')
gw_log10_A = parameter.Uniform(-18, -14)('gw_log10_A')
gw_gamma = parameter.Constant(13. / 3)('gw_gamma')
gw_pl = utils.powerlaw(log10_A=gw_log10_A, gamma=gw_gamma)
gw_pshift = gp_signals.FourierBasisGP(spectrum=gw_pl,
components=5,
Tspan=Tspan,
name='gw',
pshift=True,
pseed=pseed)
model = tm + wn + rn + gw_pshift
pta_pshift = signal_base.PTA([model(p) for p in dmx_psrs])
pta_pshift.set_default_params(noise_dict)
return pta_pshift
if os.path.exists(args.pta_pkl):
with open(args.pta_pkl, "rb") as f:
pta_crn = cloudpickle.load(f)
with open(args.noisepath, 'r') as fin:
noise = json.load(fin)
else:
with open('{0}'.format(args.pickle), "rb") as f:
pkl_psrs = pickle.load(f)
with open(args.noisepath, 'r') as fin:
noise = json.load(fin)
# Set Tspan for RN
Tspan_PTA = model_utils.get_tspan(pkl_psrs)
# common red noise block
fmin = 10.0
modes, wgts = model_utils.linBinning(Tspan_PTA, 1, 1.0 / fmin / Tspan_PTA,
14, 5)
# wgts = wgts**2.0
# timing model
s = gp_signals.MarginalizingTimingModel()
s += blocks.white_noise_block(vary=False, inc_ecorr=True, select='backend')
s += blocks.red_noise_block(
psd='powerlaw',
prior='log-uniform',
Tspan=Tspan_PTA,
for idx, psr in enumerate(psrs):
if psr.name not in args.psr_list:
idxs.append(idx)
for idx in reversed(idxs):
del psrs[idx]
with open(args.noisepath, 'r') as fin:
noise_json = json.load(fin)
noise = {}
for p in psrs:
noise.update(noise_json[p.name])
if args.tspan is None:
Tspan = model_utils.get_tspan(psrs)
else:
Tspan = args.tspan
if args.wideband:
inc_ecorr = False
else:
inc_ecorr = True
### White Noise ###
wn = models.white_noise_block(vary=False, inc_ecorr=inc_ecorr)
### Red Noise ###
rn_plaw = models.red_noise_block(psd='powerlaw',
prior='log-uniform',
Tspan=Tspan,
components=30,
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
import pta_sim
import pta_sim.parse_sim as parse_sim
from pta_sim.bayes import chain_length_bool, save_core, get_freqs, filter_psr_path
args = parse_sim.arguments()
with open(args.pickle, 'rb') as fin:
psrs = pickle.load(fin)
psr = psrs[args.process]
print(f'Starting {psr.name}.')
with open(args.noisepath, 'r') as fin:
noise = json.load(fin)
if args.tspan is None:
Tspan = model_utils.get_tspan([psr])
else:
Tspan = args.tspan
tm = gp_signals.TimingModel()
log10_rho = parameter.Uniform(-10, -4, size=30)
fs = gp_priors.free_spectrum(log10_rho=log10_rho)
wn = blocks.white_noise_block(inc_ecorr=True)
log10_A = parameter.Constant()
gamma = parameter.Constant()
plaw_pr = gp_priors.powerlaw(log10_A=log10_A, gamma=gamma)
plaw = gp_signals.FourierBasisGP(plaw_pr, components=30, Tspan=Tspan)
rn = gp_signals.FourierBasisGP(fs,
components=30,
Tspan=Tspan,
sim.createGWB(A_gwb=args.A_gwb, gamma_gw=args.gamma_gw, seed=seed_gwb)
sim.init_ePulsars()
# noise = {}
# with open(args.noisepath, 'r') as fin:
# noise.update(json.load(fin))
#
# pta = models.model_2a(psrs=sim.psrs, psd='powerlaw', noisedict=noise,
# components=30, gamma_common=args.gamma_gw,
# upper_limit=True, bayesephem=False)
#Get Tspan _before_ going through time filter!!
if args.tspan is None:
Tspan = model_utils.get_tspan(sim.psrs)
else:
Tspan=args.tspan
freqs = np.logspace(np.log10(1/Tspan),
np.log10(args.nfreqs/Tspan),
args.nfreqs)
sim.filter_by_mjd(args.end_time)
pta = model_simple(psrs=sim.psrs, psd='powerlaw', freqs=freqs,
gamma_common=args.gamma_gw, upper_limit=True,
bayesephem=False, select='backend', red_noise=False)
x0 = np.hstack(p.sample() for p in pta.params)
ndim = x0.size
