def white_noise_block(vary=False): """ Returns the white noise block of the model: 1. EFAC per backend/receiver system 2. EQUAD per backend/receiver system 3. ECORR per backend/receiver system :param vary: If set to true we vary these parameters with uniform priors. Otherwise they are set to constants with values to be set later. """ # define selection by observing backend selection = selections.Selection(selections.by_backend) # white noise parameters if vary: efac = parameter.Uniform(0.01, 10.0) equad = parameter.Uniform(-8.5, -5) ecorr = parameter.Uniform(-8.5, -5) else: efac = parameter.Constant() equad = parameter.Constant() ecorr = parameter.Constant() # white noise signals ef = white_signals.MeasurementNoise(efac=efac, selection=selection) eq = white_signals.EquadNoise(log10_equad=equad, selection=selection) ec = white_signals.EcorrKernelNoise(log10_ecorr=ecorr, selection=selection) # combine signals s = ef + eq + ec return s
def paired_ppta_band_noise(self, option=[]): """ Including band noise terms for paired values of the PPTA "-B" flag: joint 1020-cm and 4050-cm red processes. """ for ii, paired_band_term in enumerate(option): log10_A = parameter.Uniform(self.params.syn_lgA[0], self.params.syn_lgA[1]) gamma = parameter.Uniform(self.params.syn_gamma[0],\ self.params.syn_gamma[1]) pl = utils.powerlaw(log10_A=log10_A, gamma=gamma, \ components=self.params.red_general_nfouriercomp) setattr(self, paired_band_term, globals()[paired_band_term]) nfreqs = self.determine_nfreqs(sel_func_name=paired_band_term) pbn_term = gp_signals.FourierBasisGP(spectrum=pl, Tspan=self.params.Tspan, name='band_noise_' + paired_band_term, selection=selections.Selection( \ self.__dict__[paired_band_term] ), components=nfreqs) if ii == 0: pbn = pbn_term elif ii > 0: pbn += pbn_term return pbn
def fd_sys_g(self,option=[]): idx = 1 # fitting linear trend for ii, fd_sys_term in enumerate(option): name = 'fd' + str(idx) + '_sys_' + fd_sys_term slope = parameter.Uniform(-self.params.fd_sys_slope_range,\ self.params.fd_sys_slope_range) wf = fd_system(slope = slope, idx_fd = idx) selection_function_name = 'fd_system_selection_' + \ str(self.sys_noise_count) setattr(self, selection_function_name, selection_factory(selection_function_name)) if fd_sys_term == "WBCORR_10CM_512": self.psr.sys_flags.append('beconfig') self.psr.sys_flagvals.append('wbb256_512_256_3p_b') else: self.psr.sys_flags.append('group') self.psr.sys_flagvals.append(fd_sys_term) fd_sys_term = deterministic_signals.Deterministic( wf, name=name, selection=selections.Selection(\ self.__dict__[selection_function_name]) ) if ii == 0: fd_sys = fd_sys_term elif ii > 0: fd_sys += fd_sys_term self.sys_noise_count += 1 return fd_sys
def __init__(self, enterprise_pintpulsar, selection=selections.Selection(selections.by_backend), nfreqcomps=30): """Constructor method """ #self.parfile = parfile #self.timfile = timfile self.selection = selection # Initialize enterprise PintPulsar object #self.ltpsr = None self.ephem = None self.F0 = None self.P0 = None self.psr = None self.pname = None # Initialize white noise vectors and gradients self.Nvec = None self.Jvec = None self.d_Nvec_d_param = dict() self.d_Jvec_d_param = dict() # Initialize red noise and jitter mode vectors and gradients self.Phivec = None self.d_Phivec_d_param = dict() # Orthogonalized design matrix self.Mmat_g = None # Initialize Fourier design matrix self.nfreqcomps = nfreqcomps self.Fmat = None self.Ffreqs = None # Initialize ECORR exploder matrix self.Umat = None self.Uindslc = None # Initialize Zmat self.Zmat = None # Enterprise signals self.efac_sig = None self.equad_sig = None self.ecorr_sig = None self.rn_sig = None self.tm_sig = None # Signal and parameter dictionaries self.signals = dict() self.ptadict = dict() self.ptaparams = dict() self.init_hierarchical_model(enterprise_pintpulsar)
def efac(self,option="by_backend"): """ EFAC signal: multiplies ToA variance by EFAC**2, where ToA variance are diagonal components of the Likelihood covariance matrix. """ if option not in selections.__dict__.keys(): raise ValueError('EFAC option must be Enterprise selection function name') se=selections.Selection(selections.__dict__[option]) efacpr = interpret_white_noise_prior(self.params.efac) efs = white_signals.MeasurementNoise(efac=efacpr,selection=se) return efs
def equad(self,option="by_backend"): """ EQUAD signal: adds EQUAD**2 to the ToA variance, where ToA variance are diagonal components of the Likelihood covariance matrix. """ if option not in selections.__dict__.keys(): raise ValueError('EQUAD option must be Enterprise selection function \ name') se=selections.Selection(selections.__dict__[option]) equadpr = interpret_white_noise_prior(self.params.equad) eqs = white_signals.EquadNoise(log10_equad=equadpr,selection=se) return eqs
def ecorr(self,option="by_backend"): """ Similar to EFAC and EQUAD, ECORR is a white noise parameter that describes a correlation between ToAs in a single epoch (observation). Arzoumanian, Zaven, et al. The Astrophysical Journal 859.1 (2018): 47. """ if option not in selections.__dict__.keys(): raise ValueError('ECORR option must be Enterprise selection function \ name') se=selections.Selection(selections.__dict__[option]) ecorrpr = interpret_white_noise_prior(self.params.ecorr) ecs = white_signals.EcorrKernelNoise(log10_ecorr=ecorrpr,selection=se) return ecs
def test_selections(self): # note: -B flag ('by_band') not currently represented in test data for sel in ["cut_half", "by_frontend", "by_backend", "nanograv_backends", "by_telescope", "no_selection"]: s = selections.Selection(getattr(selections, sel))(self.psr) msg = "Selection mask count is incorrect for {}".format(sel) assert sum(sum(mask) for mask in s.masks.values()) == len(self.psr.toas), msg msg = "Selection mask coverage incomplete for {}".format(sel) assert np.all(functools.reduce(operator.or_, s.masks.values())), msg msg = "Selection mask not independent for {}".format(sel) assert np.all(sum(mask for mask in s.masks.values()) == 1), msg
def ppta_band_noise(self,option=[]): """ Including red noise terms by the PPTA "-B" flag, only with flagvals in noise model file. It is considered a derivative of system noise in our code. See Lentati, Lindley, et al. MNRAS 458.2 (2016): 2161-2187. """ for ii, band_term in enumerate(option): log10_A = parameter.Uniform(self.params.syn_lgA[0],self.params.syn_lgA[1]) gamma = parameter.Uniform(self.params.syn_gamma[0],\ self.params.syn_gamma[1]) selection_function_name = 'band_noise_selection_' + \ str(self.sys_noise_count) setattr(self, selection_function_name, selection_factory(selection_function_name)) band_term, nfreqs = self.option_nfreqs(band_term, \ selection_flag='B', \ sel_func_name=selection_function_name) if "turnover" in band_term: 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) option_split = band_term.split("_") del option_split[option_split.index("turnover")] band_term = "_".join(option_split) else: pl = utils.powerlaw(log10_A=log10_A, gamma=gamma, \ components=self.params.red_general_nfouriercomp) tspan = self.determine_tspan(sel_func_name=selection_function_name) syn_term = gp_signals.FourierBasisGP(spectrum=pl, Tspan=tspan, name='band_noise_' + \ str(self.sys_noise_count), selection=selections.Selection( \ self.__dict__[selection_function_name] ), components=nfreqs) if ii == 0: syn = syn_term elif ii > 0: syn += syn_term self.sys_noise_count += 1 return syn
def initialize_pta_sim(psrs, fgw, inc_efac=True, inc_equad=False, inc_ecorr=False, selection=None, inc_red_noise=False, noisedict=None): # continuous GW signal s = models.cw_block_circ(log10_fgw=np.log10(fgw), psrTerm=True) # linearized timing model s += gp_signals.TimingModel(use_svd=True) # white noise if selection == 'backend': selection = selections.Selection(selections.by_backend) if inc_efac: efac = parameter.Constant() s += white_signals.MeasurementNoise(efac=efac, selection=selection) if inc_equad: equad = parameter.Constant() s += white_signals.EquadNoise(log10_equad=equad, selection=selection) if inc_ecorr: ecorr = parameter.Constant() s += gp_signals.EcorrBasisModel(log10_ecorr=ecorr, selection=selection) if inc_red_noise: log10_A = parameter.Constant() gamma = parameter.Constant() pl = utils.powerlaw(log10_A=log10_A, gamma=gamma) s += gp_signals.FourierBasisGP(pl, components=30) model = [s(psr) for psr in psrs] pta = signal_base.PTA(model) # set white noise parameters if noisedict is None: print('No noise dictionary provided!...') else: pta.set_default_params(noisedict) return pta
def paired_ppta_band_noise(self, option=[]): """ Including band noise terms for paired values of the PPTA "-B" flag: joint 1020-cm and 4050-cm red processes. """ for ii, paired_band_term in enumerate(option): log10_A = parameter.Uniform(self.params.syn_lgA[0],self.params.syn_lgA[1]) gamma = parameter.Uniform(self.params.syn_gamma[0],\ self.params.syn_gamma[1]) if "turnover" in paired_band_term: 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) option_split = paired_band_term.split("_") del option_split[option_split.index("turnover")] paired_band_term = "_".join(option_split) else: pl = utils.powerlaw(log10_A=log10_A, gamma=gamma, \ components=self.params.red_general_nfouriercomp) if "nfreqs" not in paired_band_term: setattr(self, paired_band_term, globals()[paired_band_term]) paired_band_term, nfreqs = self.option_nfreqs(paired_band_term, \ sel_func_name=paired_band_term) setattr(self, paired_band_term, globals()[paired_band_term]) tspan = self.determine_tspan(sel_func_name=paired_band_term) pbn_term = gp_signals.FourierBasisGP(spectrum=pl, Tspan=tspan, name='band_noise_' + paired_band_term, selection=selections.Selection( \ self.__dict__[paired_band_term] ), components=nfreqs) if ii == 0: pbn = pbn_term elif ii > 0: pbn += pbn_term return pbn
def ppta_band_noise(self, option=[]): """ Including red noise terms by the PPTA "-B" flag, only with flagvals in noise model file. It is considered a derivative of system noise in our code. See Lentati, Lindley, et al. MNRAS 458.2 (2016): 2161-2187. """ for ii, band_term in enumerate(option): log10_A = parameter.Uniform(self.params.syn_lgA[0], self.params.syn_lgA[1]) gamma = parameter.Uniform(self.params.syn_gamma[0],\ self.params.syn_gamma[1]) pl = utils.powerlaw(log10_A=log10_A, gamma=gamma, \ components=self.params.red_general_nfouriercomp) selection_function_name = 'band_noise_selection_' + \ str(self.sys_noise_count) setattr(self, selection_function_name, selection_factory(selection_function_name)) self.psr.sys_flags.append('B') self.psr.sys_flagvals.append(band_term) nfreqs = self.determine_nfreqs( sel_func_name=selection_function_name) tspan = self.determine_tspan(sel_func_name=selection_function_name) syn_term = gp_signals.FourierBasisGP(spectrum=pl, Tspan=tspan, name='band_noise_' + \ str(self.sys_noise_count), selection=selections.Selection( \ self.__dict__[selection_function_name] ), components=nfreqs) if ii == 0: syn = syn_term elif ii > 0: syn += syn_term self.sys_noise_count += 1 return syn
def system_noise(self,option=[]): """ Including red noise terms by "-group" flag, only with flagvals in noise model file. See Lentati, Lindley, et al. MNRAS 458.2 (2016): 2161-2187. """ for ii, sys_noise_term in enumerate(option): log10_A = parameter.Uniform(self.params.syn_lgA[0],self.params.syn_lgA[1]) gamma = parameter.Uniform(self.params.syn_gamma[0],\ self.params.syn_gamma[1]) pl = utils.powerlaw(log10_A=log10_A, gamma=gamma, \ components=self.params.red_general_nfouriercomp) selection_function_name = 'sys_noise_selection_'+str(self.sys_noise_count) setattr(self, selection_function_name, selection_factory(selection_function_name)) sys_noise_term, nfreqs = self.option_nfreqs(sys_noise_term, \ selection_flag='group', \ sel_func_name=selection_function_name) tspan = self.determine_tspan(sel_func_name=selection_function_name) syn_term = gp_signals.FourierBasisGP(spectrum=pl, Tspan=tspan, name='system_noise_' + \ str(self.sys_noise_count), selection=selections.Selection( \ self.__dict__[selection_function_name] ), components=nfreqs) if ii == 0: syn = syn_term elif ii > 0: syn += syn_term self.sys_noise_count += 1 return syn
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() 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 = []
from enterprise.signals import white_signals from enterprise.signals import gp_signals from enterprise import constants as const from enterprise_extensions import models, model_utils, sampler, dropout import pta_sim.parse_sim as parse_sim args = parse_sim.arguments() logging.basicConfig(level=logging.WARNING) with open(args.pickle, 'rb') as fin: psrs = pickle.load(fin) pidx = args.process #os.environ['SLURM_ARRAY_TASK_ID'] psr = psrs[pidx] backend = selections.Selection(selections.by_backend) ng_backend = selections.Selection(selections.nanograv_backends) efac = parameter.Uniform(0.1,5) equad = parameter.Uniform(-8.5,-5) ecorr = parameter.Uniform(-8.5,-5) kdrop = parameter.Uniform(0,1) kthresh = 0.5 ef = dropout.dropout_MeasurementNoise(efac=efac, efac_drop=kdrop, efac_thresh=kthresh, selection=backend) eq = dropout.dropout_EquadNoise(log10_equad=equad, equad_drop=kdrop, equad_thresh=kthresh,
def gwb_ul(psrs_cut, num_points): # find the maximum time span to set GW frequency sampling tmin = [p.toas.min() for p in psrs_cut] tmax = [p.toas.max() for p in psrs_cut] Tspan = np.max(tmax) - np.min(tmin) # define selection by observing backend selection = selections.Selection(selections.by_backend) # white noise parameters # we set these ourselves so we know the most likely values! efac = parameter.Constant(1) # quad = parameter.Constant(0) # ecorr = parameter.Constant(0) # red noise parameters log10_A = parameter.LinearExp(-20, -11) gamma = parameter.Uniform(0, 7) # GW parameters (initialize with names here to use parameters in common across pulsars) log10_A_gw = parameter.LinearExp(-18, -12)('log10_A_gw') gamma_gw = parameter.Constant(4.33)('gamma_gw') # white noise ef = white_signals.MeasurementNoise(efac=efac, selection=selection) # eq = white_signals.EquadNoise(log10_equad=equad, selection=selection) # ec = white_signals.EcorrKernelNoise(log10_ecorr=ecorr, selection=selection) # red noise (powerlaw with 30 frequencies) pl = utils.powerlaw(log10_A=log10_A, gamma=gamma) rn = gp_signals.FourierBasisGP(spectrum=pl, components=30, Tspan=Tspan) # gwb (no spatial correlations) cpl = utils.powerlaw(log10_A=log10_A_gw, gamma=gamma_gw) gw = gp_signals.FourierBasisGP(spectrum=cpl, components=30, Tspan=Tspan, name='gw') # timing model tm = gp_signals.TimingModel( use_svd=True) # stabilizing timing model design matrix with SVD s = ef + rn + gw + tm # intialize PTA models = [] for p in psrs_cut: models.append(s(p)) pta = signal_base.PTA(models) outDir = './chains/psrs/{0}'.format(psrs_cut[0].name) sample = sampler.setup_sampler(pta, outdir=outDir) x0 = np.hstack([p.sample() for p in pta.params]) # sampler for N steps N = int( num_points) # normally, we would use 5e6 samples (this will save time) sample.sample( x0, N, SCAMweight=30, AMweight=15, DEweight=50, ) chain = np.loadtxt(os.path.join(outDir, 'chain_1.txt')) pars = np.loadtxt(outDir + '/pars.txt', dtype=np.unicode_) ind = list(pars).index('log10_A_gw') UL, unc = model_utils.ul(chain[:, ind]) return UL, unc
psrs = pickle.load(f) with open(args.noisefile, "rb") as f: noise_params = pickle.load(f) print("loaded pickles") ################# ## PTA model ## ################# 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 selection = selections.Selection(selections.by_backend) efac = parameter.Constant() equad = parameter.Constant() ecorr = parameter.Constant() ef = white_signals.MeasurementNoise(efac=efac, selection=selection) eq = white_signals.EquadNoise(log10_equad=equad, selection=selection) ec = white_signals.EcorrKernelNoise(log10_ecorr=ecorr, selection=selection) wn = ef + eq + ec # Red Noise if args.UL: rn_log10_A = parameter.LinearExp(-20, -11) else:
def white_noise_block(vary=False, inc_ecorr=False, gp_ecorr=False, efac1=False, select='backend', name=None): """ Returns the white noise block of the model: 1. EFAC per backend/receiver system 2. EQUAD per backend/receiver system 3. ECORR per backend/receiver system :param vary: If set to true we vary these parameters with uniform priors. Otherwise they are set to constants with values to be set later. :param inc_ecorr: include ECORR, needed for NANOGrav channelized TOAs :param gp_ecorr: whether to use the Gaussian process model for ECORR :param efac1: use a strong prior on EFAC = Normal(mu=1, stdev=0.1) """ if select == 'backend': # define selection by observing backend backend = selections.Selection(selections.by_backend) # define selection by nanograv backends backend_ng = selections.Selection(selections.nanograv_backends) else: # define no selection backend = selections.Selection(selections.no_selection) # white noise parameters if vary: if efac1: efac = parameter.Normal(1.0, 0.1) else: efac = parameter.Uniform(0.01, 10.0) equad = parameter.Uniform(-8.5, -5) if inc_ecorr: ecorr = parameter.Uniform(-8.5, -5) else: efac = parameter.Constant() equad = parameter.Constant() if inc_ecorr: ecorr = parameter.Constant() # white noise signals ef = white_signals.MeasurementNoise(efac=efac, selection=backend, name=name) eq = white_signals.EquadNoise(log10_equad=equad, selection=backend, name=name) if inc_ecorr: if gp_ecorr: if name is None: ec = gp_signals.EcorrBasisModel(log10_ecorr=ecorr, selection=backend_ng) else: ec = gp_signals.EcorrBasisModel(log10_ecorr=ecorr, selection=backend_ng, name=name) else: ec = white_signals.EcorrKernelNoise(log10_ecorr=ecorr, selection=backend_ng, name=name) # combine signals if inc_ecorr: s = ef + eq + ec elif not inc_ecorr: s = ef + eq return s
def red_noise_block(psd='powerlaw', prior='log-uniform', Tspan=None, components=30, gamma_val=None, coefficients=False, select=None, modes=None, wgts=None, break_flat=False, break_flat_fq=None): """ Returns red noise model: 1. Red noise modeled as a power-law with 30 sampling frequencies :param psd: PSD function [e.g. powerlaw (default), turnover, spectrum, tprocess] :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 red noise :param gamma_val: If given, this is the fixed slope of the power-law for powerlaw, turnover, or tprocess red noise :param coefficients: include latent coefficients in GP model? """ # red noise parameters that are common if psd in [ 'powerlaw', 'powerlaw_genmodes', 'turnover', 'tprocess', 'tprocess_adapt', 'infinitepower' ]: # parameters shared by PSD functions if prior == 'uniform': log10_A = 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 = parameter.Uniform(-20, -11) else: log10_A = parameter.Uniform(-20, -11) else: log10_A = parameter.Uniform(-20, -11) if gamma_val is not None: gamma = parameter.Constant(gamma_val) else: gamma = parameter.Uniform(0, 7) # different PSD function parameters if psd == 'powerlaw': pl = utils.powerlaw(log10_A=log10_A, gamma=gamma) elif psd == 'powerlaw_genmodes': pl = gpp.powerlaw_genmodes(log10_A=log10_A, gamma=gamma, wgts=wgts) elif psd == 'turnover': kappa = parameter.Uniform(0, 7) lf0 = parameter.Uniform(-9, -7) pl = utils.turnover(log10_A=log10_A, gamma=gamma, lf0=lf0, kappa=kappa) elif psd == 'tprocess': df = 2 alphas = gpp.InvGamma(df / 2, df / 2, size=components) pl = gpp.t_process(log10_A=log10_A, gamma=gamma, alphas=alphas) elif psd == 'tprocess_adapt': df = 2 alpha_adapt = gpp.InvGamma(df / 2, df / 2, size=1) nfreq = parameter.Uniform(-0.5, 10 - 0.5) pl = gpp.t_process_adapt(log10_A=log10_A, gamma=gamma, alphas_adapt=alpha_adapt, nfreq=nfreq) elif psd == 'infinitepower': pl = gpp.infinitepower() if psd == 'spectrum': if prior == 'uniform': log10_rho = parameter.LinearExp(-10, -4, size=components) elif prior == 'log-uniform': log10_rho = parameter.Uniform(-10, -4, size=components) pl = gpp.free_spectrum(log10_rho=log10_rho) if select == 'backend': # define selection by observing backend selection = selections.Selection(selections.by_backend) elif select == 'band' or select == 'band+': # define selection by observing band selection = selections.Selection(selections.by_band) else: # define no selection selection = selections.Selection(selections.no_selection) if break_flat: log10_A_flat = parameter.Uniform(-20, -11) gamma_flat = parameter.Constant(0) pl_flat = utils.powerlaw(log10_A=log10_A_flat, gamma=gamma_flat) freqs = 1.0 * np.arange(1, components + 1) / Tspan components_low = sum(f < break_flat_fq for f in freqs) if components_low < 1.5: components_low = 2 rn = gp_signals.FourierBasisGP(pl, components=components_low, Tspan=Tspan, coefficients=coefficients, selection=selection) rn_flat = gp_signals.FourierBasisGP(pl_flat, modes=freqs[components_low:], coefficients=coefficients, selection=selection, name='red_noise_hf') rn = rn + rn_flat else: rn = gp_signals.FourierBasisGP(pl, components=components, Tspan=Tspan, coefficients=coefficients, selection=selection, modes=modes) if select == 'band+': # Add the common component as well rn = rn + gp_signals.FourierBasisGP( pl, components=components, Tspan=Tspan, coefficients=coefficients) return rn
#Calculate the time span of the dataset Tspan = psr.toas.max() - psr.toas.min() ## White Noise Block # Define new mask and selection to avoid non-channelized NICER TOAs (for ECORR) def channelized_backends(backend_flags): """Selection function to split by channelized backend flags only.""" flagvals = np.unique(backend_flags) ch_b = ['ASP', 'GASP', 'GUPPI', 'PUPPI', 'NUPPI'] flagvals = filter(lambda x: any(map(lambda y: y in x, ch_b)), flagvals) return {flagval: backend_flags == flagval for flagval in flagvals} selection_ch = selections.Selection(channelized_backends) selection = selections.Selection(selections.by_backend) ef = white_signals.MeasurementNoise(efac=efac, selection=selection) eq = white_signals.EquadNoise(log10_equad=equad, selection=selection) ec = white_signals.EcorrKernelNoise(log10_ecorr=ecorr, selection=selection_ch) # red noise (powerlaw with 5 frequencies) 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)
tfile = os.path.join(args.datadir, '{}.tim'.format(psr_name)) nfile = os.path.join(args.datadir, "{}_noise.json".format(psr_name)) psrs.append(Pulsar(pfile, tfile, ephem=args.ephem, timing_package='tempo2')) with open(nfile, 'r') as f: noise_params.update(json.load(f)) # 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) ###################### ## 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:
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
if np.abs(args.gamma_gw - 4.33) < 0.1: gw_log10_A = parameter.Uniform(-18, -14)('gw_log10_A') else: gw_log10_A = parameter.Uniform(-18, -11)('gw_log10_A') gw_gamma = parameter.Constant(args.gamma_gw)('gw_gamma') # White noise parameter priors efac = parameter.Constant() equad = parameter.Constant() ecorr = parameter.Constant() Nf = args.nfreqs freqs = np.linspace(1 / Tspan, Nf / Tspan, Nf) # # white noise selection = selections.Selection(selections.nanograv_backends) ef = white_signals.MeasurementNoise(efac=efac, log10_t2equad=equad, selection=selection) ec = white_signals.EcorrKernelNoise(log10_ecorr=ecorr, selection=selection) # red noise (powerlaw with 30 frequencies) pl = utils.powerlaw(log10_A=log10_A, gamma=gamma) rn = gp_signals.FourierBasisGP(spectrum=pl, modes=freqs) # timing model tm = gp_signals.TimingModel() # gw (powerlaw with 5 frequencies)