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