def test_physical_ephem_model_setIII(self): """Test physical ephemeris model""" # define signals with and without epoch TOAs eph1 = deterministic_signals.PhysicalEphemerisSignal( sat_orb_elements=True, model="setIII") eph2 = deterministic_signals.PhysicalEphemerisSignal( sat_orb_elements=True, use_epoch_toas=False, model="setIII") # initialize signals e1, e2 = eph1(self.psr), eph2(self.psr) # set parameters params = { "d_jupiter_mass": -8.561198198000628e-12, "d_neptune_mass": 1.0251757860647059e-11, "d_saturn_mass": 6.22114376130324e-12, "d_uranus_mass": -2.1157536169469958e-10, "frame_drift_rate": 2.874659280396648e-10, "jup_orb_elements": np.array([ 0.04140015, -0.03422412, 0.01165894, -0.03525219, -0.00406852, 0.0421522 ]), "sat_orb_elements": np.array([ -0.39701798, -0.13322608, -0.05025925, 0.36331171, -0.17080321, 0.25093799 ]), } # test against waveform and compare non-epoch and epoch TOA results d1 = e1.get_delay(params=params) d2 = e2.get_delay(params=params) (jup_mjd, jup_orbel, sat_orbel) = utils.get_planet_orbital_elements("setIII") d3 = utils.physical_ephem_delay( self.psr.toas, self.psr.planetssb, self.psr.pos_t, times=jup_mjd, jup_orbit=jup_orbel, sat_orbit=sat_orbel, **params, ) msg1 = "Signal delay does not match function delay" assert np.allclose(d1, d3, rtol=1e-10), msg1 msg2 = "epoch-TOA delay does not match full TOA delay" assert np.allclose(d1, d2, rtol=1e-10), msg2
def bayes_ephem(self, option="default"): """ Deterministic signal from errors in Solar System ephemerides. """ eph = deterministic_signals.PhysicalEphemerisSignal( use_epoch_toas=True) return eph
def test_ephemeris(self): """Test physical-ephemeris delay, made three ways: from marginalized GP, from coefficient-based GP, from deterministic model.""" ef = white_signals.MeasurementNoise( efac=parameter.Uniform(0.1, 5.0)) eph = gp_signals.FourierBasisCommonGP_physicalephem( sat_orb_elements=None) ephc = gp_signals.FourierBasisCommonGP_physicalephem( sat_orb_elements=None, coefficients=True) ephd = deterministic_signals.PhysicalEphemerisSignal( sat_orb_elements=False) model = ef + eph modelc = ef + ephc modeld = ef + ephd pta = signal_base.PTA([model(self.psr), model(self.psr2)]) ptac = signal_base.PTA([modelc(self.psr), modelc(self.psr2)]) ptad = signal_base.PTA([modeld(self.psr), modeld(self.psr2)]) cf = 1e-3 * np.random.randn(11) cf[0] = 1e-5 # this is more sensitive to linearity bs = pta.get_basis() da = [np.dot(bs[0], cf), np.dot(bs[1], cf)] params = { "B1855+09_efac": 1, "B1937+21_efac": 1, "B1855+09_phys_ephem_gp_coefficients": cf, "B1937+21_phys_ephem_gp_coefficients": cf, } db = ptac.get_delay(params=params) dparams = { "B1855+09_efac": 1, "B1937+21_efac": 1, "frame_drift_rate": cf[0], "d_jupiter_mass": cf[1], "d_saturn_mass": cf[2], "d_uranus_mass": cf[3], "d_neptune_mass": cf[4], "jup_orb_elements": cf[5:], } dc = ptad.get_delay(params=dparams) msg = "Reconstructed ephemeris signals differ!" assert np.allclose(da[0], db[0]), msg assert np.allclose(da[1], db[1]), msg # we don't expect an exact match since we are linearizing assert np.allclose(da[0], dc[0], atol=1e-3), msg assert np.allclose(da[1], dc[1], atol=1e-3), msg
def __init__(self, psrs, params=None, psrTerm=True, bayesephem=True, pta=None): if pta is None: # initialize standard model with fixed white noise # and powerlaw red noise # uses the implementation of ECORR in gp_signals print('Initializing the model...') tmin = np.min([p.toas.min() for p in psrs]) tmax = np.max([p.toas.max() for p in psrs]) Tspan = tmax - tmin s = deterministic.cw_block_circ(amp_prior='log-uniform', psrTerm=psrTerm, tref=tmin, name='cw') s += gp_signals.TimingModel() s += blocks.red_noise_block(prior='log-uniform', psd='powerlaw', Tspan=Tspan, components=30) if bayesephem: s += deterministic_signals.PhysicalEphemerisSignal(use_epoch_toas=True) # adding white-noise, and acting on psr objects models = [] for p in psrs: if 'NANOGrav' in p.flags['pta']: s2 = s + blocks.white_noise_block(vary=False, inc_ecorr=True, gp_ecorr=True) models.append(s2(p)) else: s3 = s + blocks.white_noise_block(vary=False, inc_ecorr=False) models.append(s3(p)) pta = signal_base.PTA(models) # set white noise parameters if params is None: print('No noise dictionary provided!') else: pta.set_default_params(params) self.pta = pta else: # user can specify their own pta object # if ECORR is included, use the implementation in gp_signals self.pta = pta self.psrs = psrs self.params = params self.Nmats = self.get_Nmats()
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 = [] 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) + 5 # Use the best fit noise parameters! PTA.set_default_params(Dict)
def test_physical_ephem_model(self): """Test physical ephemeris model""" if isinstance(self.psr, enterprise.pulsar.Tempo2Pulsar): # define signals with and without epoch TOAs eph1 = deterministic_signals.PhysicalEphemerisSignal( sat_orb_elements=True, model="orbel") eph2 = deterministic_signals.PhysicalEphemerisSignal( sat_orb_elements=True, use_epoch_toas=False, model="orbel") # initialize signals e1, e2 = eph1(self.psr), eph2(self.psr) # set parameters params = { "d_jupiter_mass": -8.561198198000628e-12, "d_neptune_mass": 1.0251757860647059e-11, "d_saturn_mass": 6.22114376130324e-12, "d_uranus_mass": -2.1157536169469958e-10, "frame_drift_rate": 2.874659280396648e-10, "jup_orb_elements": np.array([ 0.04140015, -0.03422412, 0.01165894, -0.03525219, -0.00406852, 0.0421522 ]), "sat_orb_elements": np.array([ -0.39701798, -0.13322608, -0.05025925, 0.36331171, -0.17080321, 0.25093799 ]), } # test against waveform and compare non-epoch and epoch TOA results d1 = e1.get_delay(params=params) d2 = e2.get_delay(params=params) (jup_mjd, jup_orbel, sat_orbel) = utils.get_planet_orbital_elements("orbel") d3 = utils.physical_ephem_delay( self.psr.toas, self.psr.planetssb, self.psr.pos_t, times=jup_mjd, jup_orbit=jup_orbel, sat_orbit=sat_orbel, **params, ) msg1 = "Signal delay does not match function delay" assert np.allclose(d1, d3, rtol=1e-10), msg1 msg2 = "epoch-TOA delay does not match full TOA delay" assert np.allclose(d1, d2, rtol=1e-10), msg2 # test against pre-computed wafeform eph_wf = np.load(datadir + "/phys_ephem_1855_test.npy") msg = "Ephemeris delay does not match pre-computed values" assert np.allclose(d1, eph_wf, rtol=1e-10), msg # test PINT exception raising elif isinstance(self.psr, enterprise.pulsar.PintPulsar): with self.assertRaises(NotImplementedError) as context: eph1 = deterministic_signals.PhysicalEphemerisSignal( sat_orb_elements=True) e1 = eph1(self.psr) msg = "Physical Ephemeris model is not compatible with PINT " msg += "at this time." self.assertEqual(msg, str(context.exception))
def model_bwm(psrs, Tmin_bwm=None, Tmax_bwm=None, skyloc=None, logmin=-18, logmax=-11, upper_limit=False, bayesephem=False, sngl_psr=False, dmgp=False, free_rn=False): """ Reads in list of enterprise Pulsar instance and returns a PTA instantiated with BWM model: per pulsar: 1. fixed EFAC per backend/receiver system 2. fixed EQUAD per backend/receiver system 3. fixed ECORR per backend/receiver system 4. Red noise modeled as a power-law with 30 sampling frequencies 5. Linear timing model. global: 1. Deterministic GW burst with memory signal. 2. Optional physical ephemeris modeling. :param Tmin_bwm: Min time to search for BWM (MJD). If omitted, uses first TOA. :param Tmax_bwm: Max time to search for BWM (MJD). If omitted, uses last TOA. :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 upper_limit: Perform upper limit on common red noise amplitude. By default this is set to False. Note that when perfoming 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 :param sngl_psr: run on a single pulsar only. Uses different BWM parameterization to avoid problem with sky nulls. Set to False by default. :param free_rn: Use free red noise spectrum 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 tmin = np.min([p.toas.min() for p in psrs]) tmax = np.max([p.toas.max() for p in psrs]) Tspan = tmax - tmin if Tmin_bwm == None: Tmin_bwm = tmin / const.day if Tmax_bwm == None: Tmax_bwm = tmax / const.day # white noise s = white_noise_block(vary=False) # red noise if free_rn: s += free_noise_block(prior=amp_prior, Tspan=Tspan) else: s += red_noise_block(prior=amp_prior, Tspan=Tspan) # GW BWM signal block s += bwm_block(Tmin_bwm, Tmax_bwm, amp_prior=amp_prior, skyloc=skyloc, logmin=logmin, logmax=logmax, sngl=sngl_psr, name='bwm') # ephemeris model if bayesephem: s += deterministic_signals.PhysicalEphemerisSignal(use_epoch_toas=True) # timing model s += gp_signals.TimingModel(use_svd=True) # set up PTA pta = signal_base.PTA([s(psr) for psr in psrs]) return pta
def model_gwb(psrs, psd='powerlaw', gamma_common=None, orf=None, upper_limit=False, bayesephem=False): """ Reads in list of enterprise Pulsar instance and returns a PTA instantiated with GWB model: per pulsar: 1. fixed EFAC per backend/receiver system 2. fixed EQUAD per backend/receiver system 3. fixed ECORR per backend/receiver system 4. Red noise modeled as a power-law with 30 sampling frequencies 5. Linear timing model. global: 1.Common red noise modeled with user defined PSD with 30 sampling frequencies. Available PSDs are ['powerlaw', 'turnover'] 2. Optional physical ephemeris modeling. :param psd: PSD to use for common red noise signal. Available options are ['powerlaw', 'turnover']. '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 orf: String representing which overlap reduction function to use. By default we do not use any spatial correlations. Permitted values are ['hd', 'dipole', 'monopole']. :param upper_limit: Perform upper limit on common red noise amplitude. By default this is set to False. Note that when perfoming 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 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 s = white_noise_block(vary=False) # red noise s += red_noise_block(prior=amp_prior, Tspan=Tspan) # common red noise block s += common_red_noise_block(psd=psd, prior=amp_prior, Tspan=Tspan, gamma_val=gamma_common, name='gwb', orf=orf) # ephemeris model if bayesephem: s += deterministic_signals.PhysicalEphemerisSignal(use_epoch_toas=True) # timing model s += gp_signals.TimingModel() # set up PTA pta = signal_base.PTA([s(psr) for psr in psrs]) return pta
def test_physical_ephem_model(self): """Tests physical ephemeris model (which is implemented as a deterministic signal) four ways: - computed directly with :func:`enterprise.signals.utils.physical_ephem_delay`; - computed with :meth:`enterprise.signals.deterministic_signals.PhysicalEphemerisSignal.get_delay` with `use_epoch_toas=True` (the default), which reduces computation by evaluating ephemeris corrections once per measurement epoch, and then interpolating to the full `toas` vector; - computed with :meth:`enterprise.signals.deterministic_signals.PhysicalEphemerisSignal.get_delay`, setting `use_epoch_toas=False`; - loaded from a golden copy. """ if isinstance(self.psr, enterprise.pulsar.Tempo2Pulsar): # define signals with and without epoch TOAs eph1 = deterministic_signals.PhysicalEphemerisSignal( sat_orb_elements=True, model="orbel") eph2 = deterministic_signals.PhysicalEphemerisSignal( sat_orb_elements=True, use_epoch_toas=False, model="orbel") # initialize signals e1, e2 = eph1(self.psr), eph2(self.psr) # set parameters params = { "d_jupiter_mass": -8.561198198000628e-12, "d_neptune_mass": 1.0251757860647059e-11, "d_saturn_mass": 6.22114376130324e-12, "d_uranus_mass": -2.1157536169469958e-10, "frame_drift_rate": 2.874659280396648e-10, "jup_orb_elements": np.array([ 0.04140015, -0.03422412, 0.01165894, -0.03525219, -0.00406852, 0.0421522 ]), "sat_orb_elements": np.array([ -0.39701798, -0.13322608, -0.05025925, 0.36331171, -0.17080321, 0.25093799 ]), } # test against waveform and compare non-epoch and epoch TOA results d1 = e1.get_delay(params=params) d2 = e2.get_delay(params=params) (jup_mjd, jup_orbel, sat_orbel) = utils.get_planet_orbital_elements("orbel") d3 = utils.physical_ephem_delay( self.psr.toas, self.psr.planetssb, self.psr.pos_t, times=jup_mjd, jup_orbit=jup_orbel, sat_orbit=sat_orbel, **params, ) msg1 = "Signal delay does not match function delay" assert np.allclose(d1, d3, rtol=1e-10), msg1 msg2 = "epoch-TOA delay does not match full TOA delay" assert np.allclose(d1, d2, rtol=1e-10), msg2 # test against pre-computed wafeform eph_wf = np.load(datadir + "/phys_ephem_1855_test.npy") msg = "Ephemeris delay does not match pre-computed values" assert np.allclose(d1, eph_wf, rtol=1e-10), msg
def model_3d(psrs, psd='powerlaw', gamma_common=None, upper_limit=False, bayesephem=False): """ Reads in list of enterprise Pulsar instance and returns a PTA instantiated with model 3D from the analysis paper: per pulsar: 1. fixed EFAC per backend/receiver system 2. fixed EQUAD per backend/receiver system 3. fixed ECORR per backend/receiver system 4. Red noise modeled as a power-law with 30 sampling frequencies 5. Linear timing model. global: 1. GWB with HD correlations modeled with user defined PSD with 30 sampling frequencies. Available PSDs are ['powerlaw', 'turnover' 'spectrum'] 2. Monopole signal modeled with user defined PSD with 30 sampling frequencies. Available PSDs are ['powerlaw', 'turnover' 'spectrum'] 3. 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 perfoming 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 tmin = [p.toas.min() for p in psrs] tmax = [p.toas.max() for p in psrs] Tspan = np.max(tmax) - np.min(tmin) # white noise s = white_noise_block(vary=False) # red noise s += red_noise_block(prior=amp_prior, Tspan=Tspan) # common red noise block s += common_red_noise_block(psd=psd, prior=amp_prior, Tspan=Tspan, gamma_val=gamma_common, orf='hd', name='gw') # monopole s += common_red_noise_block(psd=psd, prior=amp_prior, Tspan=Tspan, gamma_val=gamma_common, orf='monopole', name='monopole') # ephemeris model if bayesephem: s += deterministic_signals.PhysicalEphemerisSignal(use_epoch_toas=True) # timing model s += gp_signals.TimingModel() # set up PTA pta = signal_base.PTA([s(psr) for psr in psrs]) # set white noise parameters noisedict = get_noise_dict(psrlist=[p.name for p in psrs]) pta.set_default_params(noisedict) return pta
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
deter_sw, name='sw_{0}'.format(ii + 1)) elif len(power) > 1: print('3 ', power, pr_range) n_earth = parameter.Uniform(pr_range[0], pr_range[1])('nE_{0}'.format(ii + 1)) sw_power = parameter.Uniform(power[0], power[1])('sw_power_{0}'.format(ii + 1)) log10_ne = True if pr_range[0] < 0 else False deter_sw = SW.solar_wind_r_to_p(n_earth=n_earth, power=sw_power, log10_ne=log10_ne) dm_block += deterministic_signals.Deterministic( deter_sw, name='sw_{0}'.format(ii + 1)) if args.bayes_ephem: eph = deterministic_signals.PhysicalEphemerisSignal(model='setIII', use_epoch_toas=True) model += eph if args.sw_pta_gp: @signal_base.function def solar_wind_perturb(toas, freqs, planetssb, sunssb, pos_t, n_earth_rho=0, n_mean=5, nmodes=20, Tspan=None, logf=False,
def model_bwm(psrs, Tmin_bwm=None, Tmax_bwm=None, skyloc=None, logmin=-18, logmax=-11, amp_prior='log-uniform', bayesephem=False, dmgp=False, free_rn=False): """ Reads in list of enterprise Pulsar instance and returns a PTA instantiated with BWM model: per pulsar: 1. fixed EFAC per backend/receiver system 2. fixed EQUAD per backend/receiver system 3. fixed ECORR per backend/receiver system 4. Red noise modeled as a power-law with 30 sampling frequencies 5. Linear timing model. global: 1. Deterministic GW burst with memory signal. 2. Optional physical ephemeris modeling. :param Tmin_bwm: Min time to search for BWM (MJD). If omitted, uses first TOA. :param Tmax_bwm: Max time to search for BWM (MJD). If omitted, uses last TOA. :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 upper_limit: Perform upper limit on common red noise amplitude. By default this is set to False. Note that when perfoming 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 :param free_rn: Use free red noise spectrum model. Set to False by default """ # find the maximum time span to set GW frequency sampling tmin = np.min([p.toas.min() for p in psrs]) tmax = np.max([p.toas.max() for p in psrs]) Tspan = tmax - tmin if Tmin_bwm == None: Tmin_bwm = tmin / const.day if Tmax_bwm == None: Tmax_bwm = tmax / const.day # white noise s = models.white_noise_block(vary=False) # red noise if free_rn: s += models.free_noise_block(prior=amp_prior, Tspan=Tspan) else: s += red_noise_block(prior=amp_prior, Tspan=Tspan) # GW BWM signal block s += bwm_sngl_block(Tmin_bwm, Tmax_bwm, amp_prior=amp_prior, logmin=logmin, logmax=logmax, name='bwm') # ephemeris model if bayesephem: s += deterministic_signals.PhysicalEphemerisSignal(use_epoch_toas=True) # timing model s += gp_signals.TimingModel(use_svd=True) # DM variations model if dmgp: s += models.dm_noise_block(gp_kernel='diag', psd='powerlaw', prior=amp_prior, Tspan=Tspan) s += models.dm_annual_signal() # DM exponential dip for J1713's DM event dmexp = models.dm_exponential_dip(tmin=54500, tmax=54900) s2 = s + dmexp # set up PTA mods = [] for p in psrs: if dmgp and 'J1713+0747' == p.name: mods.append(s2(p)) else: mods.append(s(p)) pta = signal_base.PTA(mods) return pta
ec = white_signals.EcorrKernelNoise(log10_ecorr=ecorr, selection=bkend_NG) dmgp = gp_signals.BasisGP(dm_pl, dm_basis, name='dm_gp') dmexp = models.dm_exponential_dip(tmin=54500, tmax=55000, name='dmexp_1') dm1yr = models.dm_annual_signal() rn = gp_signals.FourierBasisGP(spectrum=rn_pl, components=30, Tspan=Tspan) gwb = gp_signals.FourierBasisCommonGP(gwb_pl, orf, components=30, Tspan=Tspan, name='gw') tm = gp_signals.TimingModel(use_svd=True) be = deterministic_signals.PhysicalEphemerisSignal( # widen prior on jup orbit use_epoch_toas=True, jup_orb_elements=parameter.Uniform(-0.1, 0.1, size=6)('jup_orb_elements')) # full model mod_root = tm + ef + eq + dmgp + dm1yr + rn + gwb if args.be: mod_root += be mod_J1713 = mod_root + dmexp mod_ecorr = mod_root + ec mods = [] for psr in psrs: if 'J1713+0747' == psr.name: if 'NANOGrav' in psr.flags['pta']: mod_J1713 += ec mods.append(mod_J1713(psr)) elif 'NANOGrav' in psr.flags['pta']:
def bayes_ephem(self,option="default"): """ Deterministic signal from errors in Solar System ephemerides. """ ekw = {} ekw['model'] = "setIII" if isinstance(option, dict): # Converting parameters to bool masks for bekey, beval in option.items(): if isinstance(beval, list): option[bekey] = np.array(beval, dtype=bool) else: option[bekey] = bool(beval) options = '_'.join(option.keys()) else: options = option print(options) print(option) #adding keyword arguments to PhysicalEphemerisSignal based on input options #where PhysicalEphemerisSignal kwargs default to True, here we set to False if "framedr" in option: ekw['frame_drift_rate'] = parameter.Uniform(-1e-10, 1e-10)\ ('frame_drift_rate') else: ekw['frame_drift_rate'] = False if "mer_m" in option or "inner" in option: ekw['d_mercury_mass'] = parameter.Normal(0, 1.66e-10)('d_mer_mass') if "mer_el" in option: if isinstance(option, dict): ekw['mer_orb_elements'] = UniformMask(-0.5, 0.5, option['mer_el'])\ ('mer_oe') else: ekw['mer_orb_elements'] = parameter.Uniform(-0.5, 0.5, size=6)('mer_oe') if "ven_m" in options or "inner" in options: ekw['d_venus_mass'] = parameter.Normal(0, 2.45e-9)('d_ven_mass') if "ven_el" in options: if isinstance(option, dict): ekw['ven_orb_elements'] = UniformMask(-1., 1., option['ven_el'])('ven_oe') else: ekw['ven_orb_elements'] = parameter.Uniform(-1., 1., size=6)('ven_oe') if "mar_m" in option or "inner" in option: ekw['d_mars_mass'] = parameter.Normal(0, 3.23e-10)('d_mar_mass') if "mar_el" in option: if isinstance(option, dict): ekw['mar_orb_elements'] = UniformMask(-5., 5., option['mar_el'])('mar_oe') else: ekw['mar_orb_elements'] = parameter.Uniform(-5., 5., size=6)('mar_oe') if "jup_m" in option or "d_jupiter_mass" in option or "outer" in option or "default" in option: ekw['d_jupiter_mass'] = parameter.Normal(0, 1e-10)('d_jup_mass') #parameter.Normal(0, 1.54976690e-11)('d_jup_mass') else: ekw['d_jupiter_mass'] = False if "jup_el" in option or "outer" in option or "default" in option: if isinstance(option, dict) and (type(option['jup_el']) is list or \ type(option['jup_el']) is np.ndarray): ekw['jup_orb_elements'] = UniformMask(-0.5, 0.5, option['jup_el'])\ ('jup_oe') else: ekw['jup_orb_elements'] = parameter.Uniform(-0.5, 0.5, size=6)\ ('jup_oe') else: ekw['jup_orb_elements'] = False if "sat_m" in option or "outer" in option or "default" in option: ekw['d_saturn_mass'] = parameter.Normal(0, 8.17306184e-12)('d_sat_mass') else: ekw['d_saturn_mass'] = False if "sat_el" in option or "outer" in option: if isinstance(option, dict): ekw['sat_orb_elements'] = UniformMask(-5., 5., option['sat_el'])('sat_oe') else: ekw['sat_orb_elements'] = parameter.Uniform(-5., 5., size=6)('sat_oe') else: ekw['sat_orb_elements'] = False if "ura_m" in option or "outer" in option or "default" in option: ekw['d_uranus_mass'] = parameter.Normal(0, 5.71923361e-11)('d_ura_mass') else: ekw['d_uranus_mass'] = False if "ura_el" in option: if isinstance(option, dict): ekw['ura_orb_elements'] = UniformMask(-.5, .5, option['ura_el'])('ura_oe') else: ekw['ura_orb_elements'] = parameter.Uniform(-0.5, 0.5, size=6)('ura_oe') #else: # ekw['ura_orb_elements'] = False if "nep_m" in option or "outer" in option or "default" in option: ekw['d_neptune_mass'] = parameter.Normal(0, 7.96103855e-11)\ ('d_nep_mass') else: ekw['d_neptune_mass'] = False if "nep_el" in option: if isinstance(option, dict): ekw['nep_orb_elements'] = UniformMask(-.5, .5, option['nep_el'])('nep_oe') else: ekw['nep_orb_elements'] = parameter.Uniform(-0.5, 0.5, size=6)('nep_oe') #else: # ekw['nep_orb_elements'] = False #print(ekw) eph = deterministic_signals.PhysicalEphemerisSignal(**ekw) return eph