def load_pulsars(datadir, PINT=False, ephemeris='DE438', save=False):
"""
This is specific to the file structure used in this tutorial.
If you use a different file structure, this function will need to be modified!
"""
psrlist = None # define a list of pulsar name strings that can be used to filter.
# for the entire pta
parfiles = sorted(glob.glob(datadir + '/par/*par'))
timfiles = sorted(glob.glob(datadir + '/tim/*tim'))
if not parfiles or not timfiles:
print(
'Check that your data directory exists and has the right folder structure.'
)
print(
'If you interupted this function, you may have to reset the kernel and try again.'
)
# filter
if psrlist is not None:
parfiles = [
x for x in parfiles if x.split('/')[-1].split('.')[0] in psrlist
]
timfiles = [
x for x in timfiles if x.split('/')[-1].split('.')[0] in psrlist
]
# Make sure you use the tempo2 parfile for J1713+0747!!
# ...filtering out the tempo parfile...
if PINT:
parfiles = [
x for x in parfiles
if 'J1713+0747_NANOGrav_12yv3.gls.t2.par' not in x
]
else:
parfiles = [
x for x in parfiles if 'J1713+0747_NANOGrav_12yv3.gls.par' not in x
]
# check for file and load pickle if it exists:
pickle_loc = datadir + '/psrs.pkl'
if os.path.exists(pickle_loc):
with open(pickle_loc, 'rb') as f:
psrs = pickle.load(f)
return psrs
# else: load them in slowly:
else:
psrs = []
for p, t in zip(parfiles, timfiles):
if PINT:
psr = Pulsar(p, t, ephem=ephemeris, timing_package='PINT')
else:
psr = Pulsar(p, t, ephem=ephemeris)
psrs.append(psr)
if save:
# Make your own pickle of these loaded objects to reduce load times significantly
# at the cost of some space on your computer (~1.8 GB).
with open(datadir + '/psrs.pkl', 'wb') as f:
pickle.dump(psrs, f)
return psrs
def setUpClass(cls):
"""Setup the Pulsar object."""
# initialize Pulsar class
cls.psrs = [
Pulsar(datadir + "/B1855+09_NANOGrav_9yv1.gls.par", datadir + "/B1855+09_NANOGrav_9yv1.tim"),
Pulsar(datadir + "/J1909-3744_NANOGrav_9yv1.gls.par", datadir + "/J1909-3744_NANOGrav_9yv1.tim"),
]
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.psr2 = Pulsar(datadir + "/B1937+21_NANOGrav_9yv1.gls.par",
datadir + "/B1937+21_NANOGrav_9yv1.tim")
def setUpClass(cls):
"""Setup the Pulsar object."""
cls.psrs = [
Pulsar(datadir + '/B1855+09_NANOGrav_9yv1.gls.par',
datadir + '/B1855+09_NANOGrav_9yv1.tim'),
Pulsar(datadir + '/J1909-3744_NANOGrav_9yv1.gls.par',
datadir + '/J1909-3744_NANOGrav_9yv1.tim')
]
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")
# IPTA-like pulsar
cls.ipsr = Pulsar(datadir + "/1713.Sep.T2.par",
datadir + "/1713.Sep.T2.tim")
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',
ephem='DE430',
timing_package='pint')
# IPTA-like pulsar
cls.ipsr = Pulsar(datadir + '/1713.Sep.T2.par',
datadir + '/1713.Sep.T2.tim',
ephem='DE421',
timint_package='pint')
def setUpClass(cls):
"""Setup the Pulsar object."""
# initialize Pulsar class
cls.psrs = [
Pulsar(datadir + '/B1855+09_NANOGrav_9yv1.gls.par',
datadir + '/B1855+09_NANOGrav_9yv1.tim',
ephem='DE430',
timing_package='pint'),
Pulsar(datadir + '/J1909-3744_NANOGrav_9yv1.gls.par',
datadir + '/J1909-3744_NANOGrav_9yv1.tim',
ephem='DE430',
timing_package='pint')
]
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",
ephem="DE430",
timing_package="pint",
)
# IPTA-like pulsar
cls.ipsr = Pulsar(datadir + "/1713.Sep.T2.par",
datadir + "/1713.Sep.T2.tim",
ephem="DE421",
timint_package="pint")
def test_wrong_input(self):
"""Test exception when incorrect par(tim) file given."""
with self.assertRaises(IOError) as context:
Pulsar("wrong.par", "wrong.tim")
msg = "Cannot find parfile wrong.par or timfile wrong.tim!"
self.assertTrue(msg in context.exception)
def setUpClass(cls):
"""Setup the Pulsar object."""
cls.psr = Pulsar(
datadir + "/J1832-0836_NANOGrav_12yv3.wb.gls.par",
datadir + "/J1832-0836_NANOGrav_12yv3.wb.tim",
timing_package="pint",
)
def setUpClass(cls):
"""Setup the Pulsar object."""
# initialize Pulsar class
cls.psrs = [
Pulsar(
datadir + "/B1855+09_NANOGrav_9yv1.gls.par",
datadir + "/B1855+09_NANOGrav_9yv1.tim",
ephem="DE430",
timing_package="pint",
),
Pulsar(
datadir + "/J1909-3744_NANOGrav_9yv1.gls.par",
datadir + "/J1909-3744_NANOGrav_9yv1.tim",
ephem="DE430",
timing_package="pint",
),
]
def setUpClass(cls):
"""Set up the :func:`enterprise.Pulsar` object used in tests (PINT version)."""
# initialize Pulsar class
cls.psr = Pulsar(
datadir + "/B1855+09_NANOGrav_9yv1.gls.par",
datadir + "/B1855+09_NANOGrav_9yv1.tim",
ephem="DE430",
timing_package="pint",
)
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",
ephem="DE430",
drop_pintpsr=False,
timing_package="pint",
)
def test_load_radec_psr(self):
"""Setup the Pulsar object."""
with self.assertRaises(pint.models.timing_model.TimingModelError):
# initialize Pulsar class with RAJ DECJ and PMLAMBDA, PMBETA
Pulsar(
datadir + "/J0030+0451_RADEC_wrong.par",
datadir + "/J0030+0451_NANOGrav_9yv1.tim",
ephem="DE430",
drop_pintpsr=False,
timing_package="pint",
)
def load_fakes():
# import the par and tim files
datadir = './fakes_gwb'
parfiles = sorted(glob.glob(datadir + '/par/' + '*.par'))
timfiles = sorted(glob.glob(datadir + '/tim/' + '*.tim'))
psrs = []
for p, t in zip(parfiles, timfiles):
# psrname = parfiles[0].split('/')[-1].split('_')[0]
psr = Pulsar(p, t, ephem='DE438')
psrs.append(psr)
return psrs
def test_no_planet(self):
"""Test exception when incorrect par(tim) file given."""
with self.assertRaises(ValueError) as context:
model, toas = get_model_and_toas(
datadir + "/J0030+0451_NANOGrav_9yv1.gls.par",
datadir + "/J0030+0451_NANOGrav_9yv1.tim",
planets=False)
Pulsar(model, toas, planets=True)
msg = "obs_earth_pos is not in toas.table.colnames. Either "
msg += "`planet` flag is not True in `toas` or further Pint "
msg += "development to add additional planets is needed."
self.assertTrue(msg in context.exception)
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 load_real():
try:
with open("psrs.p", "rb") as f:
psrs_cut = pickle.load(f)
return psrs_cut
except:
psrlist = None # define a list of pulsar name strings that can be used to filter.
# set the data directory
datadir = './data'
if not os.path.isdir(datadir):
datadir = '../data'
# print(datadir)
# for the entire pta
parfiles = sorted(glob.glob(datadir + '/partim/*par'))
timfiles = sorted(glob.glob(datadir + '/partim/*tim'))
# print(parfiles)
# filter
if psrlist is not None:
parfiles = [
x for x in parfiles
if x.split('/')[-1].split('.')[0] in psrlist
]
timfiles = [
x for x in timfiles
if x.split('/')[-1].split('.')[0] in psrlist
]
# Make sure you use the tempo2 parfile for J1713+0747!!
# ...filtering out the tempo parfile...
parfiles = [
x for x in parfiles if 'J1713+0747_NANOGrav_12yv3.gls.par' not in x
]
psrs = []
ephemeris = 'DE436'
for p, t in zip(parfiles, timfiles):
psr = Pulsar(p, t, ephem=ephemeris)
psrs.append(psr)
psrs_cut = []
for p in psrs:
time_tot = (max(p.toas) - min(p.toas)) / 86400 / 365.25
if time_tot > 6:
psrs_cut.append(p)
with open("psrs.p", "wb") as f:
pickle.dump(psrs_cut, f)
print(len(psrs_cut))
return psrs_cut
def get_pulsars(psrlist=None, ephem='DE436'):
"""
Reads in list of pulsar names and ephemeris version
and returns list of instantiated enterprise Pulsar objects.
By default the input list is None and we use the 34 pulsars used in
the stochastic background analysis. The default ephemeris is that used
in the 11-year dataset (DE436)
"""
if psrlist is None:
psrlist = np.loadtxt('psrlist.txt', dtype=np.unicode_)
parfiles = sorted(glob(DATADIR + '/partim/*.par'))
timfiles = sorted(glob(DATADIR + '/partim/*.tim'))
psrs = []
for par, tim in zip(parfiles, timfiles):
pname = par.split('/')[-1].split('_')[0]
if pname in psrlist:
psrs.append(Pulsar(par, tim, ephem=ephem))
return psrs
def get_Tspan(pulsar, datadir):
"""Returns timespan of a pulsars dataset by loading the pulsar as an
`enterprise.Pulsar()` object.
Parameters
----------
pulsar : str
datadir : str
Directory where `par` and `tim` files are found.
"""
if not ent_present:
raise ImportError('enterprise is not available for import. '
'Please provide time span of data in another form.')
parfile = glob.glob(datadir + '/{0}*.par'.format(pulsar))[0]
timfile = glob.glob(datadir + '/{0}*.tim'.format(pulsar))[0]
psr = Pulsar(parfile, timfile, ephem='{0}'.format('DE436'))
T = psr.toas.max() - psr.toas.min()
return T
def test_deflate_inflate(self):
psr = Pulsar(datadir + "/B1855+09_NANOGrav_9yv1.gls.par",
datadir + "/B1855+09_NANOGrav_9yv1.tim")
dm = psr._designmatrix.copy()
psr.deflate()
psr.to_pickle()
with open("B1855+09.pkl", "rb") as f:
pkl_psr = pickle.load(f)
pkl_psr.inflate()
assert np.allclose(dm, pkl_psr._designmatrix)
del pkl_psr
psr.destroy()
with open("B1855+09.pkl", "rb") as f:
pkl_psr = pickle.load(f)
with self.assertRaises(FileNotFoundError):
pkl_psr.inflate()
def get_pulsars(psrlist=None, ephem='DE436', use_cache=True):
"""
Reads in list of pulsar names and ephemeris version
and returns list of instantiated enterprise Pulsar objects.
By default the input list is None and we use the 34 pulsars used in
the stochastic background analysis. The default ephemeris is that used
in the 11-year dataset (DE436)
"""
if psrlist is None:
psrlist = np.loadtxt('psrlist.txt', dtype=np.unicode_)
parfiles = sorted(glob(DATADIR + '/partim/*.par'))
timfiles = sorted(glob(DATADIR + '/partim/*.tim'))
# create pulsar hash
psr_str = ''.join(sorted(psrlist)) + ephem
psr_hash = hashlib.sha1(psr_str.encode()).hexdigest()
# check for cached file
cached_file = CACHEDIR + psr_hash
if os.path.exists(cached_file) and use_cache:
print('Reading pulsars from cached file.\n')
with open(cached_file, 'rb') as fin:
psrs = pickle.load(fin)
else:
psrs = []
for par, tim in zip(parfiles, timfiles):
pname = par.split('/')[-1].split('_')[0]
if pname in psrlist:
psrs.append(Pulsar(par, tim, ephem=ephem))
print('Writing pulsars to cache.\n')
with open(cached_file, 'wb') as fout:
pickle.dump(psrs, fout)
return psrs
def init_ePulsars(self, **kwarg):
if not self.gwb_added:
raise ValueError('Must add GWB signal (createGWB) before '
'initializing enterprise.Pulsar objects. If none '
'desired set A_gwb=0.')
psrs = []
for p in self.libs_psrs:
psr = Pulsar(p, ephem=self.ephem, **kwarg)
### Check first toa ####
#mn = psr.residuals[:100].mean()
#std = psr.residuals[:100].std()
#check_val = mn + 4*std
#if any([abs(res)>abs(check_val) for res in psr.residuals]):
# mask = np.where(abs(psr.residuals)>abs(check_val),False,True)
# model_utils.mask_filter(psr,mask)
# mask = np.ones_like(psr.toas,dtype=bool)
# mask[0] = False
# model_utils.mask_filter(psr,mask)
psrs.append(psr)
self.psrs=psrs
sys.end() #Hmmmm what to do here?
else:
pass
if args.pickle == 'no_pickle':
#Get par and tim files.
parfiles = sorted(glob.glob(args.pardir + '*.par'))
timfiles = sorted(glob.glob(args.timdir + '*.tim'))
if args.psr_list is not None:
parfiles = filter_psr_path(parfiles, args.psr_list, rhs='_')
timfiles = filter_psr_path(timfiles, args.psr_list, rhs='_')
psrs = []
for p, t in zip(parfiles, timfiles):
psr = Pulsar(p, t, ephem=args.ephem)
psrs.append(psr)
else:
with open('{0}'.format(args.pickle), "rb") as f:
psrs = pickle.load(f)
if args.psr_list is not None:
idxs = []
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]
def init_pulsars(self):
"""
Initiate Enterprise pulsar objects.
"""
cachedir = self.out + '.psrs_cache/'
psrs_cache = None
# Caching is disabled due to problems: Part 1
#if not os.path.exists(cachedir):
# if self.opts.mpi_regime != 2:
# os.makedirs(cachedir)
#
#if not self.psrcachefile==None or (not self.psrlist==[]):
# print('Attempting to load pulsar objects from cache')
# if self.psrcachefile is not None:
# cached_file = self.psrcachefile
# else:
# psr_str = ''.join(sorted(self.psrlist)) + self.ssephem
# psr_hash = hashlib.sha1(psr_str.encode()).hexdigest()
# cached_file = cachedir + psr_hash
# if os.path.exists(cached_file):
# if bool(self.opts.clearcache):
# os.remove(cached_file)
# print('Cache file existed, but got removed, following \
# command line options')
# else:
# with open(cached_file, 'rb') as fin:
# print('Loading pulsars from cache')
# psrs_cache = pickle.load(fin)
# else:
# print('Could not load pulsars from cache: file does not exist')
# psrs_cache = None
#else:
# psrs_cache = None
# print('Condition for loading pulsars from cache is not satisfied')
parfiles = sorted(glob.glob(self.datadir + '/*.par'))
timfiles = sorted(glob.glob(self.datadir + '/*.tim'))
print('Number of .par files: ', len(parfiles))
print('Number of .tim files: ', len(timfiles))
if len(parfiles) != len(timfiles):
print(
'Error - there should be the same number of .par and .tim files.'
)
exit()
if self.array_analysis == 'True':
self.output_dir = self.out + self.label_models + '_' + \
self.paramfile_label + '/'
if psrs_cache == None:
print('Loading pulsars')
self.psrlist_new = list()
for p, t in zip(parfiles, timfiles):
pname = p.split('/')[-1].split('_')[0].split('.')[0]
if (pname in self.psrlist) or self.psrlist == []:
psr = Pulsar(p, t, ephem=self.ssephem, clk=self.clock, \
drop_t2pulsar=False)
self.psrs.append(psr)
self.psrlist_new.append(pname)
# Caching is disabled due to problems: Part 2
#print('Writing pulsars to cache.\n')
#psr_str = ''.join(sorted(self.psrlist_new)) + self.ssephem
#psr_hash = hashlib.sha1(psr_str.encode()).hexdigest()
#cached_file = cachedir + psr_hash
#with open(cached_file, 'wb') as fout:
# pickle.dump(self.psrs, fout)
else:
print('Using pulsars from cache')
self.psrs = psrs_cache
# find the maximum time span to set GW frequency sampling
tmin = [p.toas.min() for p in self.psrs]
tmax = [p.toas.max() for p in self.psrs]
self.Tspan = np.max(tmax) - np.min(tmin)
#psr = []
exit_message = "PTA analysis has already been carried out using a given parameter file"
elif self.array_analysis == 'False':
self.psrs = Pulsar(parfiles[self.opts.num], timfiles[self.opts.num], \
drop_t2pulsar=False, \
ephem=self.ssephem) #, clk=self.clock)
self.Tspan = self.psrs.toas.max() - self.psrs.toas.min(
) # observation time in seconds
self.output_dir = self.out + self.label_models + '_' + \
self.paramfile_label + '/' + str(self.opts.num) + \
'_' + self.psrs.name + '/'
parfiles = parfiles[self.opts.num]
timfiles = timfiles[self.opts.num]
print('Current .par file: ', parfiles)
print('Current .tim file: ', timfiles)
exit_message = "This pulsar has already been processed"
self.psrs = [self.psrs]
if self.opts.mpi_regime != 2:
if not os.path.exists(self.output_dir):
os.makedirs(self.output_dir)
elif bool(self.opts.wipe_old_output):
warn_message = 'Warning: removing everything in ' + self.output_dir
warnings.warn(warn_message)
shutil.rmtree(self.output_dir)
os.makedirs(self.output_dir)
def test_value_error(self):
"""Test exception when unknown argument is given"""
with self.assertRaises(ValueError):
Pulsar(datadir + "/B1855+09_NANOGrav_9yv1.gls.par",
datadir + "/B1855+09_NANOGrav_9yv1.time")
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')
def setUpClass(cls):
"""Set up the :func:`enterprise.Pulsar` object used in tests (tempo2 version)."""
# initialize Pulsar class
cls.psr = Pulsar(datadir + "/B1855+09_NANOGrav_9yv1.gls.par",
datadir + "/B1855+09_NANOGrav_9yv1.tim")
from enterprise.pulsar import Pulsar
import enterprise.signals.parameter as parameter
import enterprise.signals.white_signals as white_signals
import enterprise.signals.gp_signals as gp_signals
from enterprise.signals import signal_base
import glob
import bilby
from enterprise_warp import bilby_warp
parfiles = sorted(glob.glob('data/*.par'))
timfiles = sorted(glob.glob('data/*.tim'))
psrs = []
for p, t in zip(parfiles, timfiles):
psr = Pulsar(p, t)
psrs.append(psr)
##### parameters and priors #####
# Uniform prior on EFAC
# efac = parameter.Uniform(0.1, 5.0)
efac = parameter.LinearExp(0.1, 5.0)
# white noise
ef = white_signals.MeasurementNoise(efac=efac)
# timing model
tm = gp_signals.TimingModel()
# full model is sum of components
timfile = 'J1713+0747.tim'
thetas = [0.05, 0.1, 0.15]
for theta in thetas:
# simulate data
idx = random.getrandbits(32)
sigma_out = 1e-6
simulate_data(parfile, timfile, theta=theta, idx=idx, sigma_out=sigma_out)
# grab simulated data
simparfile = 'simulated_data/outlier/{}/{}/J1713+0747.par'.format(
theta, idx)
simtimfile = 'simulated_data/outlier/{}/{}/J1713+0747.tim'.format(
theta, idx)
psr = Pulsar(simparfile, simtimfile)
simparfile = 'simulated_data/no_outlier/{}/{}/J1713+0747.par'.format(
theta, idx)
simtimfile = 'simulated_data/no_outlier/{}/{}/J1713+0747.tim'.format(
theta, idx)
psr2 = Pulsar(simparfile, simtimfile)
psrs = [psr, psr2]
## Set up enterprise model ##
# white noise
efac = parameter.Constant(1.0)
equad = parameter.Uniform(-10, -5)
# backend selection