def get_All_results():
# Modeling each pulsar.
tm = gp_signals.TimingModel()
wnb = models.white_noise_block(vary=True)
dmn = models.dm_noise_block(components=30)
spn = models.red_noise_block(components=30)
model = tm + wnb + dmn + spn
ptas = [signal_base.PTA(model(psr)) for psr in psrs]
# Multiprocessing.
jobs = []
RETs={}
for i in range(len(psrs)):
RETs[i] = multiprocessing.Manager().Value('i',0)
p = multiprocessing.Process(target=get_pulsar_noise, args=(ptas[i],RETs[i]))
jobs.append(p)
p.start()
for p in jobs:
p.join()
# Return the sum of the Ln Maximal Likelihood values.
MLHselect = [RET.value for RET in RETs.values()]
return MLHselect
def test_model_2a_altpol_spectrum(nodmx_psrs, caplog):
log10_A_tt = parameter.LinearExp(-18, -12)('log10_A_tt')
log10_A_st = parameter.LinearExp(-18, -12)('log10_A_st')
log10_A_vl = parameter.LinearExp(-18, -15)('log10_A_vl')
log10_A_sl = parameter.LinearExp(-18, -16)('log10_A_sl')
kappa = parameter.Uniform(0, 15)('kappa')
p_dist = parameter.Normal(1.0, 0.2)
pl = model_orfs.generalized_gwpol_psd(log10_A_tt=log10_A_tt,
log10_A_st=log10_A_st,
log10_A_vl=log10_A_vl,
log10_A_sl=log10_A_sl,
kappa=kappa,
p_dist=p_dist,
alpha_tt=-2 / 3,
alpha_alt=-1)
s = models.white_noise_block(vary=False, inc_ecorr=True)
s += models.red_noise_block(prior='log-uniform')
s += gp_signals.FourierBasisGP(spectrum=pl, name='gw')
s += gp_signals.TimingModel()
m = signal_base.PTA([s(psr) for psr in nodmx_psrs])
m.set_default_params(noise_dict)
for param in m.params:
if 'gw_p_dist' in str(param):
# get pulsar name and distance
psr_name = str(param).split('_')[0].strip('"')
psr_dist = [p._pdist for p in nodmx_psrs if psr_name in p.name][0]
# edit prior settings
param._prior = parameter.Normal(mu=psr_dist[0], sigma=psr_dist[1])
param._mu = psr_dist[0]
param._sigma = psr_dist[1]
assert hasattr(m, 'get_lnlikelihood')
for p, t in zip(parfiles, timfiles):
psr = Pulsar(p, t)
psrs.append(psr)
# The Big Model
dp = DPDM.dpdm_block(type_ = 'Bayes')
tm = gp_signals.TimingModel()
wnb = models.white_noise_block(vary=False)
dmn = models.dm_noise_block(components=80)
spn = models.red_noise_block(components=80)
model = tm + dp + wnb + dmn + spn
nparams = [] # Get the number of parameters of each pulsar
signals = []
for psr in psrs:
signal = model(psr)
nparams.append(len(signal.params)-5) # Subtracting common DPDM params
signals.append(signal)
PTA = signal_base.PTA(signals)
ndim = len(PTA.params)
# Get Starting Points and constant parameter values.
save1 = np.load('M80/noisepars.npy')
save2 = np.load('M80/noisepardict.npy')
save3 = np.load('M80/dpdmpars-mlh.npy')
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,
gamma_val=None)
### GWB ###
gw = models.common_red_noise_block(psd='powerlaw',
prior='log-uniform',
Tspan=Tspan,
gamma_val=13 / 3.,
name='gw')
base_model = wn
if args.bayes_ephem:
base_model += deterministic_signals.PhysicalEphemerisSignal(
use_epoch_toas=True)
model_1 = base_model + rn_plaw
c0.set_rn_freqs(freq_path=Outdir+'/achrom_freqs.txt')
c0.save(args.corepath+f'{psr.name}.core')
sys.exit() #Hmmmm what to do here?
else:
pass
emp_dist_path = args.emp_distr
if args.gwb_bf or args.gwb_ul:
if args.gwb_bf:
prior = 'log-uniform'
elif args.gwb_ul:
prior = 'uniform'
m = models.white_noise_block(vary=True, inc_ecorr=True)
m += gp_signals.TimingModel(use_svd=False)
m += models.red_noise_block(psd=args.psd, prior=prior,
components=args.nfreqs, gamma_val=None)
m += models.common_red_noise_block(gamma_val=13/3., prior=prior,
psd=args.psd, components=args.nfreqs)
pta = signal_base.PTA(m(psr))
else:
if args.gfl:
vary_rn = False
else:
vary_rn = True
pta = models.model_singlepsr_noise(psr, red_var=vary_rn,
psd=args.psd, Tspan=args.tspan,
components=args.nfreqs,
factorized_like=args.gfl,
gw_components=args.n_gwbfreqs,
fact_like_logmin=-14.2,
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