def dm_noise(self, option="powerlaw"): """ A term to account for stochastic variations in DM. It is based on spin noise model, with Fourier amplitudes depending on radio frequency nu as ~ 1/nu^2. """ log10_A = parameter.Uniform(self.params.dmn_lgA[0], self.params.dmn_lgA[1]) gamma = parameter.Uniform(self.params.dmn_gamma[0], self.params.dmn_gamma[1]) if option == "powerlaw": pl = utils.powerlaw(log10_A=log10_A, gamma=gamma, \ components=self.params.red_general_nfouriercomp) elif option == "turnover": 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) nfreqs = self.determine_nfreqs(sel_func_name=None) dm_basis = utils.createfourierdesignmatrix_dm(nmodes=nfreqs, Tspan=self.params.Tspan, fref=self.params.fref) dmn = gp_signals.BasisGP(pl, dm_basis, name='dm_gp') return dmn
def setUpClass(cls): """Setup the Pulsar object.""" # initialize Pulsar class cls.psr = Pulsar(datadir + "/B1855+09_NANOGrav_9yv1.gls.par", datadir + "/B1855+09_NANOGrav_9yv1.tim") cls.F, _ = utils.createfourierdesignmatrix_red(cls.psr.toas, nmodes=30) cls.Fdm, _ = utils.createfourierdesignmatrix_dm(cls.psr.toas, freqs=cls.psr.freqs, nmodes=30) cls.Feph, cls.feph = utils.createfourierdesignmatrix_ephem( cls.psr.toas, cls.psr.pos, nmodes=30) cls.Mm = utils.create_stabletimingdesignmatrix(cls.psr.Mmat)
def setUpClass(cls): """Setup the Pulsar object.""" # initialize Pulsar class cls.psr = Pulsar(datadir + '/B1855+09_NANOGrav_9yv1.gls.par', datadir + '/B1855+09_NANOGrav_9yv1.tim') cls.F, _ = utils.createfourierdesignmatrix_red( cls.psr.toas, nmodes=30) cls.Fdm, _ = utils.createfourierdesignmatrix_dm( cls.psr.toas,freqs=cls.psr.freqs, nmodes=30) tmp = utils.createfourierdesignmatrix_eph(t=cls.psr.toas, phi=cls.psr.phi, theta=cls.psr.theta, nmodes=30) cls.Fx, cls.Fy, cls.Fz = tmp cls.Mm = utils.create_stabletimingdesignmatrix(cls.psr.Mmat)
psr = Pulsar(p, t) psrs.append(psr) save1 = np.load('noisepars.npy') save2 = np.load('noisepardict.npy') save3 = np.load('dpdmpars-maxposprob.npy') 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()
def dm_noise_block(gp_kernel='diag', psd='powerlaw', nondiag_kernel='periodic', prior='log-uniform', Tspan=None, components=30, gamma_val=None): """ Returns DM noise model: 1. DM noise modeled as a power-law with 30 sampling frequencies :param psd: PSD function [e.g. powerlaw (default), turnover, free spectrum] :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 DM-variations. :param gamma_val: If given, this is the fixed slope of the power-law for powerlaw or turnover DM-variations """ # dm noise parameters that are common if gp_kernel == 'diag': if psd in ['powerlaw', 'turnover']: # parameters shared by PSD functions if prior == 'uniform': log10_A_dm = 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_dm = parameter.Uniform(-20, -11) else: log10_A_dm = parameter.Uniform(-20, -11) else: log10_A_dm = parameter.Uniform(-20, -11) if gamma_val is not None: gamma_dm = parameter.Constant(gamma_val) else: gamma_dm = parameter.Uniform(0, 7) # different PSD function parameters if psd == 'powerlaw': dm_prior = utils.powerlaw(log10_A=log10_A_dm, gamma=gamma_dm) elif psd == 'turnover': kappa_dm = parameter.Uniform(0, 7) lf0_dm = parameter.Uniform(-9, -7) dm_prior = utils.turnover(log10_A=log10_A_dm, gamma=gamma_dm, lf0=lf0_dm, kappa=kappa_dm) if psd == 'spectrum': if prior == 'uniform': log10_rho_dm = parameter.LinearExp(-10, -4, size=components) elif prior == 'log-uniform': log10_rho_dm = parameter.Uniform(-10, -4, size=components) dm_prior = free_spectrum(log10_rho=log10_rho_dm) dm_basis = utils.createfourierdesignmatrix_dm(nmodes=components, Tspan=Tspan) elif gp_kernel == 'nondiag': if nondiag_kernel == 'periodic': # Periodic GP kernel for DM log10_sigma = parameter.Uniform(-10, -4) log10_ell = parameter.Uniform(1, 4) period = parameter.Uniform(0.2, 5.0) gam_p = parameter.Uniform(0.1, 30.0) dm_basis = linear_interp_basis_dm(dt=15 * const.day) dm_prior = periodic_kernel(log10_sigma=log10_sigma, log10_ell=log10_ell, gam_p=gam_p, p=period) elif nondiag_kernel == 'periodic_rfband': # Periodic GP kernel for DM with RQ radio-frequency dependence log10_sigma = parameter.Uniform(-10, -4) log10_ell = parameter.Uniform(1, 4) log10_ell2 = parameter.Uniform(2, 7) alpha_wgt = parameter.Uniform(0.2, 6) period = parameter.Uniform(0.2, 5.0) gam_p = parameter.Uniform(0.1, 30.0) dm_basis = get_tf_quantization_matrix(df=200, dt=15 * const.day, dm=True) dm_prior = tf_kernel(log10_sigma=log10_sigma, log10_ell=log10_ell, gam_p=gam_p, p=period, alpha_wgt=alpha_wgt, log10_ell2=log10_ell2) elif nondiag_kernel == 'dmx_like': # DMX-like signal log10_sigma = parameter.Uniform(-10, -4) dm_basis = linear_interp_basis_dm(dt=30 * const.day) dm_prior = dmx_ridge_prior(log10_sigma=log10_sigma) dmgp = gp_signals.BasisGP(dm_prior, dm_basis, name='dm_gp') return dmgp
def dm_noise_block(gp_kernel='diag', psd='powerlaw', nondiag_kernel='periodic', prior='log-uniform', dt=15, df=200, Tspan=None, components=30, gamma_val=None, coefficients=False): """ Returns DM noise model: 1. DM noise modeled as a power-law with 30 sampling frequencies :param psd: PSD function [e.g. powerlaw (default), spectrum, tprocess] :param prior: Prior on log10_A. Default if "log-uniform". Use "uniform" for upper limits. :param dt: time-scale for linear interpolation basis (days) :param df: frequency-scale for linear interpolation basis (MHz) :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 DM-variations. :param gamma_val: If given, this is the fixed slope of the power-law for powerlaw, turnover, or tprocess DM-variations """ # dm noise parameters that are common if gp_kernel == 'diag': if psd in ['powerlaw', 'turnover', 'tprocess', 'tprocess_adapt']: # parameters shared by PSD functions if prior == 'uniform': log10_A_dm = 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_dm = parameter.Uniform(-20, -11) else: log10_A_dm = parameter.Uniform(-20, -11) else: log10_A_dm = parameter.Uniform(-20, -11) if gamma_val is not None: gamma_dm = parameter.Constant(gamma_val) else: gamma_dm = parameter.Uniform(0, 7) # different PSD function parameters if psd == 'powerlaw': dm_prior = utils.powerlaw(log10_A=log10_A_dm, gamma=gamma_dm) elif psd == 'turnover': kappa_dm = parameter.Uniform(0, 7) lf0_dm = parameter.Uniform(-9, -7) dm_prior = utils.turnover(log10_A=log10_A_dm, gamma=gamma_dm, lf0=lf0_dm, kappa=kappa_dm) elif psd == 'tprocess': df = 2 alphas_dm = gpp.InvGamma(df / 2, df / 2, size=components) dm_prior = gpp.t_process(log10_A=log10_A_dm, gamma=gamma_dm, alphas=alphas_dm) elif psd == 'tprocess_adapt': df = 2 alpha_adapt_dm = gpp.InvGamma(df / 2, df / 2, size=1) nfreq_dm = parameter.Uniform(-0.5, 10 - 0.5) dm_prior = gpp.t_process_adapt(log10_A=log10_A_dm, gamma=gamma_dm, alphas_adapt=alpha_adapt_dm, nfreq=nfreq_dm) if psd == 'spectrum': if prior == 'uniform': log10_rho_dm = parameter.LinearExp(-10, -4, size=components) elif prior == 'log-uniform': log10_rho_dm = parameter.Uniform(-10, -4, size=components) dm_prior = gpp.free_spectrum(log10_rho=log10_rho_dm) dm_basis = utils.createfourierdesignmatrix_dm(nmodes=components, Tspan=Tspan) elif gp_kernel == 'nondiag': if nondiag_kernel == 'periodic': # Periodic GP kernel for DM log10_sigma = parameter.Uniform(-10, -4) log10_ell = parameter.Uniform(1, 4) log10_p = parameter.Uniform(-4, 1) log10_gam_p = parameter.Uniform(-3, 2) dm_basis = gpk.linear_interp_basis_dm(dt=dt * const.day) dm_prior = gpk.periodic_kernel(log10_sigma=log10_sigma, log10_ell=log10_ell, log10_gam_p=log10_gam_p, log10_p=log10_p) elif nondiag_kernel == 'periodic_rfband': # Periodic GP kernel for DM with RQ radio-frequency dependence log10_sigma = parameter.Uniform(-10, -4) log10_ell = parameter.Uniform(1, 4) log10_ell2 = parameter.Uniform(2, 7) log10_alpha_wgt = parameter.Uniform(-4, 1) log10_p = parameter.Uniform(-4, 1) log10_gam_p = parameter.Uniform(-3, 2) dm_basis = gpk.get_tf_quantization_matrix(df=df, dt=dt * const.day, dm=True) dm_prior = gpk.tf_kernel(log10_sigma=log10_sigma, log10_ell=log10_ell, log10_gam_p=log10_gam_p, log10_p=log10_p, log10_alpha_wgt=log10_alpha_wgt, log10_ell2=log10_ell2) elif nondiag_kernel == 'sq_exp': # squared-exponential GP kernel for DM log10_sigma = parameter.Uniform(-10, -4) log10_ell = parameter.Uniform(1, 4) dm_basis = gpk.linear_interp_basis_dm(dt=dt * const.day) dm_prior = gpk.se_dm_kernel(log10_sigma=log10_sigma, log10_ell=log10_ell) elif nondiag_kernel == 'sq_exp_rfband': # Sq-Exp GP kernel for DM with RQ radio-frequency dependence log10_sigma = parameter.Uniform(-10, -4) log10_ell = parameter.Uniform(1, 4) log10_ell2 = parameter.Uniform(2, 7) log10_alpha_wgt = parameter.Uniform(-4, 1) dm_basis = gpk.get_tf_quantization_matrix(df=df, dt=dt * const.day, dm=True) dm_prior = gpk.sf_kernel(log10_sigma=log10_sigma, log10_ell=log10_ell, log10_alpha_wgt=log10_alpha_wgt, log10_ell2=log10_ell2) elif nondiag_kernel == 'dmx_like': # DMX-like signal log10_sigma = parameter.Uniform(-10, -4) dm_basis = gpk.linear_interp_basis_dm(dt=dt * const.day) dm_prior = gpk.dmx_ridge_prior(log10_sigma=log10_sigma) dmgp = gp_signals.BasisGP(dm_prior, dm_basis, name='dm_gp', coefficients=coefficients) return dmgp
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) # timing model tm = gp_signals.TimingModel(use_svd=False) model = tm + ef + eq + ec + rn if args.dm_gp_psrs[0] == args.psr: dm_basis = utils.createfourierdesignmatrix_dm(Tspan=Tspan, nmodes=args.nfreqs, logf=args.logf) dm_gp = gp_signals.BasisGP(priorFunction=pl, basisFunction=dm_basis, name='dm_gp') model += dm_gp pta = signal_base.PTA(model(psr)) x0 = np.hstack(p.sample() for p in pta.params) ndim = len(x0) pta.get_lnlikelihood(x0) groups = model_utils.get_parameter_groups(pta) groups.extend([[pta.param_names.index(p) for p in pta.param_names if fl in p]
def solar_wind_block(n_earth=None, ACE_prior=False, include_dmgp=False, sw_prior=None, sw_basis=None, Tspan=None): """ Returns Solar Wind DM noise model. Best model from Hazboun, et al (in prep) Contains a single mean electron density with an auxiliary perturbation modeled using a gaussian process. The GP has common prior parameters between all pulsars, but the realizations are different for all pulsars. Solar Wind DM noise modeled as a power-law with 30 sampling frequencies :param n_earth: Solar electron density at 1 AU. :param ACE_prior: Whether to use the ACE SWEPAM data as an astrophysical prior. :param include_dmgp: Boolean flag to add in a simple power-law DM GP automatically. :param sw_prior: Prior function for solar wind Gaussian process. Default is a power law. :param sw_basis: Basis to be used for solar wind Gaussian process. Default is to use the built in function to creat a GP with 15 frequencies (1/Tspan,15/Tspan). :param Tspan: Sets frequency sampling f_i = i / Tspan. Default will use overall time span for indivicual pulsar. """ # dm noise parameters that are common if sw_prior is None: log10_A_sw = parameter.Uniform(-10, 1)('log10_A_sw') gamma_sw = parameter.Uniform(-2, 1)('gamma_sw') sw_prior = utils.powerlaw(log10_A=log10_A_sw, gamma=gamma_sw) if n_earth is None and ACE_prior: n_earth = parameter.Uniform(0, 30)('n_earth') elif n_earth is None and not ACE_prior: n_earth = ACE_SWEPAM_Parameter()('n_earth') else: pass if sw_basis is None: sw_basis = createfourierdesignmatrix_solar_dm(nmodes=15, Tspan=Tspan) else: pass gp_sw = gp_signals.BasisGP(sw_prior, sw_basis, name='gp_sw') deter_sw = solar_wind(n_earth=n_earth) mean_sw = deterministic_signals.Deterministic(deter_sw, name='n_earth') sw_model = mean_sw + gp_sw if include_dmgp: # DM GP signals log10_A_dm = parameter.Uniform(-20, -12) gamma_dm = parameter.Uniform(0, 7) dm_basis = utils.createfourierdesignmatrix_dm(nmodes=10, Tspan=Tspan, logf=True) dm_prior = utils.powerlaw(log10_A=log10_A_dm, gamma=gamma_dm) dmgp = gp_signals.BasisGP(dm_prior, dm_basis, name='dm_gp') sw_model += dmgp return sw_model
###################### ## 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: rn_log10_A = parameter.LinearExp(-20, -11) else: rn_log10_A = parameter.Uniform(-20, -11) rn_gamma = parameter.Uniform(0, 7) rn_pl = utils.powerlaw(log10_A=rn_log10_A, gamma=rn_gamma) # GWB parameters and powerlaw orf = utils.hd_orf() if args.ul: gwb_log10_A = parameter.LinearExp(-18, -12)('gwb_log10_A') else: gwb_log10_A = parameter.Uniform(-18, -12)('gwb_log10_A')