def freq_offsets(self, p=None, pd=None, pdd=None):
"""
freq_offsets(p=*bestp*, pd=*bestpd*, pdd=*bestpdd*):
Return the offsets between given frequencies
and fold frequencies.
If p, pd or pdd are None use the best values.
A 3-tuple is returned.
"""
if self.fold_pow == 1.0:
bestp = self.bary_p1
bestpd = self.bary_p2
bestpdd = self.bary_p3
else:
if self.topo_p1 == 0.0:
bestp = self.fold_p1
bestpd = self.fold_p2
bestpdd = self.fold_p3
else:
bestp = self.topo_p1
bestpd = self.topo_p2
bestpdd = self.topo_p3
if p is not None:
bestp = p
if pd is not None:
bestpd = pd
if pdd is not None:
bestpdd = pdd
# self.fold_p[123] are actually frequencies, convert to periods
foldf, foldfd, foldfdd = self.fold_p1, self.fold_p2, self.fold_p3
foldp, foldpd, foldpdd = psr_utils.p_to_f(self.fold_p1, \
self.fold_p2, self.fold_p3)
# Get best f, fd, fdd
# Use folding values to be consistent with prepfold_plot.c
bestfdd = psr_utils.p_to_f(foldp, foldpd, bestpdd)[2]
bestfd = psr_utils.p_to_f(foldp, bestpd)[1]
bestf = 1.0 / bestp
# Get frequency and frequency derivative offsets
f_diff = bestf - foldf
fd_diff = bestfd - foldfd
# bestpdd=0.0 only if there was no searching over pdd
if bestpdd != 0.0:
fdd_diff = bestfdd - foldfdd
else:
fdd_diff = 0.0
return (f_diff, fd_diff, fdd_diff)
def parse_eph(filenm):
global period, time
suffix = filenm.split(".")[-1]
if suffix == "bestprof":
x = bestprof.bestprof(filenm)
fs = pu.p_to_f(x.p0_bary, x.p1_bary, x.p2_bary)
epoch = x.epochi_bary + x.epochf_bary
T = x.T
elif suffix == "par":
x = parfile.psr_par(filenm)
# Try to see how many freq derivs we have
fs = [x.F0]
for ii in range(1, 20): # hopefully 20 is an upper limit!
attrib = "F%d" % ii
if hasattr(x, attrib):
fs.append(getattr(x, attrib))
else:
break
epoch = x.PEPOCH
T = (x.FINISH - x.START) * 86400.0
else:
print("I don't recognize the file type for", filenm)
sys.exit()
newts = epoch + num.arange(int(T / 10.0 + 0.5), dtype=num.float) / 8640.0
time = num.concatenate((time, newts))
newps = 1.0 / pu.calc_freq(newts, epoch, *fs)
period = num.concatenate((period, newps))
print("%13.7f (%0.1f sec): " % (epoch, T), fs)
params_start = [p_start, pb_sec_start, x_start, T0_start, e_start, w_start]
# build the dictionary of parameter information
params_info = get_params_info(params_start, const_params)
period = []
time = []
pepochs = []
p0s = []
p1s = []
# get the observed periods and times from the .bestprof files
for in_file in in_files:
if in_file.endswith('.par'):
(epoch, T, fs) = read_par(in_file)
if (fs[1] != 0.0):
p0tmp, p1tmp = psr_utils.p_to_f(fs[0], fs[1])
p0s.append(p0tmp)
p1s.append(p1tmp)
pepochs.append(epoch)
for minute in arange(int(T / 60.0 + 0.5)):
t = epoch + minute / 1440.0
time.append(t)
period.append(1.0 / psr_utils.calc_freq(t, epoch, *fs))
else:
(epoch, T, p0, p1, p2) = read_bestprof(in_file)
for minute in arange(int(T / 60.0 + 0.5)):
t = minute * 60.0
time.append(epoch + minute / 1440.0)
period.append(p0 + t * (p1 + 0.5 * t * p2))
if p1 != 0.0:
p0s.append(p0)
def read(self, parfilenm):
self.FILE = parfilenm
pf = open(parfilenm)
for line in pf.readlines():
# Convert any 'D-' or 'D+' to 'E-' or 'E+'
line = line.replace("D-", "E-")
line = line.replace("D+", "E+")
try:
splitline = line.split()
key = splitline[0]
if key in str_keys:
setattr(self, key, splitline[1])
elif key in float_keys:
try:
setattr(self, key, float(splitline[1]))
except ValueError:
pass
if len(
splitline
) == 3: # Some parfiles don't have flags, but do have errors
if splitline[2] not in ['0', '1']:
setattr(self, key + '_ERR', float(splitline[2]))
if len(splitline) == 4:
setattr(self, key + '_ERR', float(splitline[3]))
except:
print('')
# Read PSR name
if hasattr(self, 'PSR'):
setattr(self, 'PSR', self.PSR)
if hasattr(self, 'PSRJ'):
setattr(self, 'PSRJ', self.PSRJ)
# Deal with Ecliptic coords
if (hasattr(self, 'BETA') and hasattr(self, 'LAMBDA')):
self.use_eclip = True
setattr(self, 'ELAT', self.BETA)
setattr(self, 'ELONG', self.LAMBDA)
if (slalib and hasattr(self, 'ELAT') and hasattr(self, 'ELONG')):
self.use_eclip = True
if hasattr(self, 'POSEPOCH'):
epoch = self.POSEPOCH
else:
epoch = self.PEPOCH
ra_rad, dec_rad = sla_ecleq(self.ELONG * pu.DEGTORAD,
self.ELAT * pu.DEGTORAD, epoch)
rstr = pu.coord_to_string(*pu.rad_to_hms(ra_rad))
dstr = pu.coord_to_string(*pu.rad_to_dms(dec_rad))
setattr(self, 'RAJ', rstr)
setattr(self, 'DECJ', dstr)
if hasattr(self, 'RAJ'):
setattr(self, 'RA_RAD', pu.ra_to_rad(self.RAJ))
if hasattr(self, 'DECJ'):
setattr(self, 'DEC_RAD', pu.dec_to_rad(self.DECJ))
# Compute the Galactic coords
if (slalib and hasattr(self, 'RA_RAD') and hasattr(self, 'DEC_RAD')):
l, b = sla_eqgal(self.RA_RAD, self.DEC_RAD)
setattr(self, 'GLONG', l * pu.RADTODEG)
setattr(self, 'GLAT', b * pu.RADTODEG)
# Compute the Ecliptic coords
if (slalib and hasattr(self, 'RA_RAD') and hasattr(self, 'DEC_RAD')):
if hasattr(self, 'POSEPOCH'):
epoch = self.POSEPOCH
else:
epoch = self.PEPOCH
elon, elat = sla_eqecl(self.RA_RAD, self.DEC_RAD, epoch)
setattr(self, 'ELONG', elon * pu.RADTODEG)
setattr(self, 'ELAT', elat * pu.RADTODEG)
if hasattr(self, 'P'):
setattr(self, 'P0', self.P)
if hasattr(self, 'P0'):
setattr(self, 'F0', 1.0 / self.P0)
if hasattr(self, 'F0'):
setattr(self, 'P0', 1.0 / self.F0)
if hasattr(self, 'F1'):
setattr(self, 'P1', -self.F1 / (self.F0 * self.F0))
if hasattr(self, 'FB0'):
setattr(self, 'PB', (1.0 / self.FB0) / 86400.0)
if hasattr(self, 'P0_ERR'):
if hasattr(self, 'P1_ERR'):
f, ferr, fd, fderr = pu.pferrs(self.P0, self.P0_ERR, self.P1,
self.P1_ERR)
setattr(self, 'F0_ERR', ferr)
setattr(self, 'F1', fd)
setattr(self, 'F1_ERR', fderr)
else:
f, fd, = pu.p_to_f(self.P0, self.P1)
setattr(self, 'F0_ERR', self.P0_ERR / (self.P0 * self.P0))
setattr(self, 'F1', fd)
if hasattr(self, 'F0_ERR'):
if hasattr(self, 'F1_ERR'):
p, perr, pd, pderr = pu.pferrs(self.F0, self.F0_ERR, self.F1,
self.F1_ERR)
setattr(self, 'P0_ERR', perr)
setattr(self, 'P1', pd)
setattr(self, 'P1_ERR', pderr)
else:
p, pd, = pu.p_to_f(self.F0, self.F1)
setattr(self, 'P0_ERR', self.F0_ERR / (self.F0 * self.F0))
setattr(self, 'P1', pd)
if hasattr(self, 'DM'):
setattr(self, 'DM', self.DM)
if hasattr(self, 'EPS1') and hasattr(self, 'EPS2'):
self.use_ell = True
ecc = math.sqrt(self.EPS1 * self.EPS1 + self.EPS2 * self.EPS2)
omega = math.atan2(self.EPS1, self.EPS2)
setattr(self, 'ECC', ecc)
setattr(self, 'OM', omega)
if hasattr(self, 'PB') and hasattr(self,
'A1') and not hasattr(self, 'ECC'):
setattr(self, 'ECC', 0.0)
pf.close()
obs = scopes[fold_pfd.telescope.split()[0]]
except KeyError: sys.stderr.write("Unknown telescope!!! : " + fold_pfd.telescope)
# Read the polyco file (if required)
if (fold.psr and fold.topo):
if ("polycos" in fold_pfd.__dict__ and
not fold_pfd.polycos==0):
pcs = fold_pfd.polycos
else:
pcs = polycos(fold.psr, sys.argv[-1]+".polycos")
(fold.phs0, fold.f0) = pcs.get_phs_and_freq(fold.epochi, fold.epochf)
fold.f1 = fold.f2 = 0.0
else:
pcs = None
fold.phs0 = 0.0
(fold.f0, fold.f1, fold.f2) = psr_utils.p_to_f(fold.p0, fold.p1, fold.p2)
#
# Calculate the TOAs
#
if t2format:
print("FORMAT 1")
for ii in range(numtoas):
# The .pfd file was generated using -nosearch and a specified
# folding period, p-dot, and p-dotdot (or f, f-dot, and f-dotdot).
if (pcs is None):
# Time at the middle of the interval in question
midtime = fold.epoch + (ii+0.5)*timestep_day
def __init__(self, filename):
self.pfd_filename = filename
infile = open(filename, "rb")
# See if the .bestprof file is around
try:
self.bestprof = bestprof(filename + ".bestprof")
except IOError:
self.bestprof = 0
swapchar = '<' # this is little-endian
data = infile.read(5 * 4)
testswap = struct.unpack(swapchar + "i" * 5, data)
# This is a hack to try and test the endianness of the data.
# None of the 5 values should be a large positive number.
if (Num.fabs(Num.asarray(testswap))).max() > 100000:
swapchar = '>' # this is big-endian
(self.numdms, self.numperiods, self.numpdots, self.nsub, self.npart) = \
struct.unpack(swapchar+"i"*5, data)
(self.proflen, self.numchan, self.pstep, self.pdstep, self.dmstep, \
self.ndmfact, self.npfact) = struct.unpack(swapchar+"i"*7, infile.read(7*4))
self.filenm = infile.read(
struct.unpack(swapchar + "i", infile.read(4))[0])
self.candnm = infile.read(
struct.unpack(swapchar + "i", infile.read(4))[0]).decode("utf-8")
self.telescope = infile.read(
struct.unpack(swapchar + "i", infile.read(4))[0]).decode("utf-8")
self.pgdev = infile.read(
struct.unpack(swapchar + "i", infile.read(4))[0])
test = infile.read(16)
if not test[:8] == b"Unknown" and b':' in test:
self.rastr = test[:test.find(b'\0')]
test = infile.read(16)
self.decstr = test[:test.find(b'\0')]
else:
self.rastr = "Unknown"
self.decstr = "Unknown"
if ':' not in test:
infile.seek(-16, 1) # rewind the file before the bad read
(self.dt, self.startT) = struct.unpack(swapchar + "dd",
infile.read(2 * 8))
(self.endT, self.tepoch, self.bepoch, self.avgvoverc, self.lofreq, \
self.chan_wid, self.bestdm) = struct.unpack(swapchar+"d"*7, infile.read(7*8))
# The following "fixes" (we think) the observing frequency of the Spigot
# based on tests done by Ingrid on 0737 (comparing it to GASP)
# The same sorts of corrections should be made to WAPP data as well...
# The tepoch corrections are empirically determined timing corrections
# Note that epoch is only double precision and so the floating
# point accuracy is ~1 us!
if self.telescope == 'GBT':
if (Num.fabs(Num.fmod(self.dt, 8.192e-05) < 1e-12) and \
("spigot" in filename.lower() or "guppi" not in filename.lower()) and \
(self.tepoch < 54832.0)):
sys.stderr.write("Assuming SPIGOT data...\n")
if self.chan_wid == 800.0 / 1024: # Spigot 800 MHz mode 2
self.lofreq -= 0.5 * self.chan_wid
# original values
#if self.tepoch > 0.0: self.tepoch += 0.039334/86400.0
#if self.bestprof: self.bestprof.epochf += 0.039334/86400.0
# values measured with 1713+0747 wrt BCPM2 on 13 Sept 2007
if self.tepoch > 0.0: self.tepoch += 0.039365 / 86400.0
if self.bestprof:
self.bestprof.epochf += 0.039365 / 86400.0
elif self.chan_wid == 800.0 / 2048:
self.lofreq -= 0.5 * self.chan_wid
if self.tepoch < 53700.0: # Spigot 800 MHz mode 16 (downsampled)
if self.tepoch > 0.0: self.tepoch += 0.039352 / 86400.0
if self.bestprof:
self.bestprof.epochf += 0.039352 / 86400.0
else: # Spigot 800 MHz mode 14
# values measured with 1713+0747 wrt BCPM2 on 13 Sept 2007
if self.tepoch > 0.0: self.tepoch += 0.039365 / 86400.0
if self.bestprof:
self.bestprof.epochf += 0.039365 / 86400.0
elif self.chan_wid == 50.0 / 1024 or self.chan_wid == 50.0 / 2048: # Spigot 50 MHz modes
self.lofreq += 0.5 * self.chan_wid
# Note: the offset has _not_ been measured for the 2048-lag mode
if self.tepoch > 0.0: self.tepoch += 0.039450 / 86400.0
if self.bestprof:
self.bestprof.epochf += 0.039450 / 86400.0
(self.topo_pow, tmp) = struct.unpack(swapchar + "f" * 2,
infile.read(2 * 4))
(self.topo_p1, self.topo_p2, self.topo_p3) = struct.unpack(swapchar+"d"*3, \
infile.read(3*8))
(self.bary_pow, tmp) = struct.unpack(swapchar + "f" * 2,
infile.read(2 * 4))
(self.bary_p1, self.bary_p2, self.bary_p3) = struct.unpack(swapchar+"d"*3, \
infile.read(3*8))
(self.fold_pow, tmp) = struct.unpack(swapchar + "f" * 2,
infile.read(2 * 4))
(self.fold_p1, self.fold_p2, self.fold_p3) = struct.unpack(swapchar+"d"*3, \
infile.read(3*8))
# Save current p, pd, pdd
# NOTE: Fold values are actually frequencies!
self.curr_p1, self.curr_p2, self.curr_p3 = \
psr_utils.p_to_f(self.fold_p1, self.fold_p2, self.fold_p3)
self.pdelays_bins = Num.zeros(self.npart, dtype='d')
(self.orb_p, self.orb_e, self.orb_x, self.orb_w, self.orb_t, self.orb_pd, \
self.orb_wd) = struct.unpack(swapchar+"d"*7, infile.read(7*8))
self.dms = Num.asarray(struct.unpack(swapchar+"d"*self.numdms, \
infile.read(self.numdms*8)))
if self.numdms == 1:
self.dms = self.dms[0]
self.periods = Num.asarray(struct.unpack(swapchar+"d"*self.numperiods, \
infile.read(self.numperiods*8)))
self.pdots = Num.asarray(struct.unpack(swapchar+"d"*self.numpdots, \
infile.read(self.numpdots*8)))
self.numprofs = self.nsub * self.npart
if (swapchar == '<'): # little endian
self.profs = Num.zeros((self.npart, self.nsub, self.proflen),
dtype='d')
for ii in range(self.npart):
for jj in range(self.nsub):
self.profs[ii,
jj, :] = Num.fromfile(infile, Num.float64,
self.proflen)
else:
self.profs = Num.asarray(struct.unpack(swapchar+"d"*self.numprofs*self.proflen, \
infile.read(self.numprofs*self.proflen*8)))
self.profs = Num.reshape(self.profs,
(self.npart, self.nsub, self.proflen))
if (self.numchan == 1):
try:
idata = infodata.infodata(
self.filenm[:self.filenm.rfind(b'.')] + b".inf")
try:
if idata.waveband == "Radio":
self.bestdm = idata.DM
self.numchan = idata.numchan
except:
self.bestdm = 0.0
self.numchan = 1
except IOError:
print("Warning! Can't open the .inf file for " + filename +
"!")
self.binspersec = self.fold_p1 * self.proflen
self.chanpersub = self.numchan // self.nsub
self.subdeltafreq = self.chan_wid * self.chanpersub
self.hifreq = self.lofreq + (self.numchan - 1) * self.chan_wid
self.losubfreq = self.lofreq + self.subdeltafreq - self.chan_wid
self.subfreqs = Num.arange(self.nsub, dtype='d')*self.subdeltafreq + \
self.losubfreq
self.subdelays_bins = Num.zeros(self.nsub, dtype='d')
# Save current DM
self.currdm = 0
self.killed_subbands = []
self.killed_intervals = []
self.pts_per_fold = []
# Note: a foldstats struct is read in as a group of 7 doubles
# the correspond to, in order:
# numdata, data_avg, data_var, numprof, prof_avg, prof_var, redchi
self.stats = Num.zeros((self.npart, self.nsub, 7), dtype='d')
for ii in range(self.npart):
currentstats = self.stats[ii]
for jj in range(self.nsub):
if (swapchar == '<'): # little endian
currentstats[jj] = Num.fromfile(infile, Num.float64, 7)
else:
currentstats[jj] = Num.asarray(struct.unpack(swapchar+"d"*7, \
infile.read(7*8)))
self.pts_per_fold.append(
self.stats[ii][0][0]) # numdata from foldstats
self.start_secs = Num.add.accumulate([0] +
self.pts_per_fold[:-1]) * self.dt
self.pts_per_fold = Num.asarray(self.pts_per_fold)
self.mid_secs = self.start_secs + 0.5 * self.dt * self.pts_per_fold
if (not self.tepoch == 0.0):
self.start_topo_MJDs = self.start_secs / 86400.0 + self.tepoch
self.mid_topo_MJDs = self.mid_secs / 86400.0 + self.tepoch
if (not self.bepoch == 0.0):
self.start_bary_MJDs = self.start_secs / 86400.0 + self.bepoch
self.mid_bary_MJDs = self.mid_secs / 86400.0 + self.bepoch
self.Nfolded = Num.add.reduce(self.pts_per_fold)
self.T = self.Nfolded * self.dt
self.avgprof = (self.profs / self.proflen).sum()
self.varprof = self.calc_varprof()
# nominal number of degrees of freedom for reduced chi^2 calculation
self.DOFnom = float(self.proflen) - 1.0
# corrected number of degrees of freedom due to inter-bin correlations
self.dt_per_bin = self.curr_p1 / self.proflen / self.dt
self.DOFcor = self.DOFnom * self.DOF_corr()
infile.close()
self.barysubfreqs = None
if self.avgvoverc == 0:
if self.candnm.startswith("PSR_"):
# If this doesn't work, we should try to use the barycentering calcs
# in the presto module.
try:
psrname = self.candnm[4:]
self.polycos = polycos.polycos(psrname,
filenm=self.pfd_filename +
".polycos")
midMJD = self.tepoch + 0.5 * self.T / 86400.0
self.avgvoverc = self.polycos.get_voverc(
int(midMJD), midMJD - int(midMJD))
#sys.stderr.write("Approximate Doppler velocity (in c) is: %.4g\n"%self.avgvoverc)
# Make the Doppler correction
self.barysubfreqs = self.subfreqs * (1.0 + self.avgvoverc)
except IOError:
self.polycos = 0
if self.barysubfreqs is None:
self.barysubfreqs = self.subfreqs
def __init__(self, parfilenm):
self.FILE = parfilenm
pf = open(parfilenm)
for line in pf.readlines():
# Skip comments
if line[0] == '#':
continue
# Convert any 'D-' or 'D+' to 'E-' or 'E+'
line = line.replace("D-", "E-")
line = line.replace("D+", "E+")
splitline = line.split()
# Skip blank lines
if len(splitline) == 0:
continue
key = splitline[0]
# Regex checks for non-digit chars, followed by digit chars
m1 = re.search(r'(\D+)(\d+)$', key)
# This one looks for the DMX[RF][12]_* params
m2 = re.search(r'(\D+\d+_)(\d+)$', key)
if key == "JUMP":
if splitline[3] not in ['0', '1']:
setattr(self, key + '_%s' % splitline[2],
float(splitline[3]))
if len(splitline) == 5:
if splitline[4] not in ['0', '1']:
setattr(self, key + '_%s' % splitline[2] + '_ERR',
float(splitline[4]))
elif len(splitline) == 6:
setattr(self, key + '_%s' % splitline[2] + '_ERR',
float(splitline[5]))
if key in str_keys:
setattr(self, key, splitline[1])
elif key in float_keys:
try:
setattr(self, key, float(splitline[1]))
except ValueError:
pass
elif m1 is not None:
m = m1
if m2 is not None:
m = m2
if m.group(1) in floatn_keys:
try:
setattr(self, key, float(splitline[1]))
except ValueError:
pass
if len(
splitline
) == 3: # Some parfiles don't have flags, but do have errors
if splitline[2] not in ['0', '1']:
setattr(self, key + '_ERR', float(splitline[2]))
if len(splitline) == 4:
setattr(self, key + '_ERR', float(splitline[3]))
# Deal with Ecliptic coords
if (hasattr(self, 'BETA') and hasattr(self, 'LAMBDA')):
setattr(self, 'ELAT', self.BETA)
setattr(self, 'ELONG', self.LAMBDA)
if (slalib and hasattr(self, 'ELAT') and hasattr(self, 'ELONG')):
# TEMPO's ecliptic coords are always based on J2000 epoch
ra_rad, dec_rad = sla_ecleq(self.ELONG * pc.DEGTORAD,
self.ELAT * pc.DEGTORAD, J2000)
rstr = pu.coord_to_string(*pu.rad_to_hms(ra_rad))
dstr = pu.coord_to_string(*pu.rad_to_dms(dec_rad))
setattr(self, 'RAJ', rstr)
setattr(self, 'DECJ', dstr)
if hasattr(self, 'RAJ'):
setattr(self, 'RA_RAD', pu.ra_to_rad(self.RAJ))
if hasattr(self, 'DECJ'):
setattr(self, 'DEC_RAD', pu.dec_to_rad(self.DECJ))
# Compute the Galactic coords
if (slalib and hasattr(self, 'RA_RAD') and hasattr(self, 'DEC_RAD')):
l, b = sla_eqgal(self.RA_RAD, self.DEC_RAD)
setattr(self, 'GLONG', l * pc.RADTODEG)
setattr(self, 'GLAT', b * pc.RADTODEG)
# Compute the Ecliptic coords
if (slalib and hasattr(self, 'RA_RAD') and hasattr(self, 'DEC_RAD')):
# TEMPO's ecliptic coords are always based on J2000 epoch
elon, elat = sla_eqecl(self.RA_RAD, self.DEC_RAD, J2000)
setattr(self, 'ELONG', elon * pc.RADTODEG)
setattr(self, 'ELAT', elat * pc.RADTODEG)
if hasattr(self, 'P'):
setattr(self, 'P0', self.P)
if hasattr(self, 'P0'):
setattr(self, 'F0', 1.0 / self.P0)
if hasattr(self, 'F0'):
setattr(self, 'P0', 1.0 / self.F0)
if hasattr(self, 'FB0'):
setattr(self, 'PB', (1.0 / self.FB0) / pc.SECPERDAY)
if hasattr(self, 'P0_ERR'):
if hasattr(self, 'P1_ERR'):
f, ferr, fd, fderr = pu.pferrs(self.P0, self.P0_ERR, self.P1,
self.P1_ERR)
setattr(self, 'F0_ERR', ferr)
setattr(self, 'F1', fd)
setattr(self, 'F1_ERR', fderr)
else:
f, fd, = pu.p_to_f(self.P0, self.P1)
setattr(self, 'F0_ERR', self.P0_ERR / (self.P0 * self.P0))
setattr(self, 'F1', fd)
else:
if hasattr(self, 'P1'):
f, fd, = pu.p_to_f(self.P0, self.P1)
setattr(self, 'F1', fd)
elif hasattr(self, 'F1'):
p, pd, = pu.p_to_f(self.F0, self.F1)
setattr(self, 'P1', pd)
if (hasattr(self, 'F0_ERR') and hasattr(self, 'F1_ERR')):
p, perr, pd, pderr = pu.pferrs(self.F0, self.F0_ERR, self.F1,
self.F1_ERR)
setattr(self, 'P0_ERR', perr)
setattr(self, 'P1', pd)
setattr(self, 'P1_ERR', pderr)
elif (hasattr(self, 'F0') and hasattr(self, 'F0_ERR')):
setattr(self, 'P0_ERR', self.F0_ERR / (self.F0 * self.F0))
if hasattr(self, 'EPS1') and hasattr(self, 'EPS2'):
ecc = math.sqrt(self.EPS1 * self.EPS1 + self.EPS2 * self.EPS2)
omega = math.atan2(self.EPS1, self.EPS2)
setattr(self, 'E', ecc)
setattr(self, 'OM', omega * pc.RADTODEG)
setattr(self, 'T0', self.TASC + self.PB * omega / pc.TWOPI)
if hasattr(self, 'PB') and hasattr(self, 'A1') and not \
(hasattr(self, 'E') or hasattr(self, 'ECC')):
setattr(self, 'E', 0.0)
if hasattr(self, 'T0') and not hasattr(self, 'TASC'):
setattr(self, 'TASC', self.T0 - self.PB * self.OM / 360.0)
if hasattr(self, 'E') and not hasattr(self, 'ECC'):
setattr(self, 'ECC', self.E)
if not hasattr(self, 'EPS1'):
if hasattr(self, 'E_ERR'):
setattr(self, 'ECC_ERR', self.E_ERR)
if hasattr(self, 'ECC') and not hasattr(self, 'E'):
setattr(self, 'E', self.ECC)
setattr(self, 'E_ERR', self.ECC_ERR)
pf.close()
allpsrs["J%s" % psr.jname] = psr
if psr.alias:
allpsrs[psr.alias] = psr
if psr.name:
allpsrs[psr.name] = psr
allpsrs["b%s" % psr.name] = psr
allpsrs["B%s" % psr.name] = psr
# Add a couple important pulsars
for psr in psrs:
if psr.jname=="1614-23":
psr.jname=="1614-2318"
psr.f = 29.8475387364133766
psr.fd = -4.683105034721e-17
psr.p, psr.pd = pu.p_to_f(psr.f, psr.fd)
psr.x = 1.327490
psr.e = 0.0
psr.To = 52819.878171
psr.pb = 3.15238573
psr.w = 0.0
psr.dm = 52.43
psr.l = 351.91856
psr.b = 19.74496
psr.dist = 1.80
if psr.jname=="2204+27":
psr.x = 0.1
psr.xerr = 1.0
psr.e = 0.129
psr.eerr = 0.05
psr.To = 57000.0
