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)
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
def fold_event_prof(ph_mjd, par_file, nbins=16):
params = read_par(par_file, file_format='tempo2')
# Fold data with psr_utils by first calculating phases for each MJD based on par file's F0, F1, ... only good for isolated puslar
ph_phase = pu.calc_phs(ph_mjd, params['pepoch'], params['f'][0], params['f'][1], params['f'][2], params['f'][3])
# Cast all negative phases to be between 0 and 1
while (len(np.where(ph_phase <= 0.)[0]) > 0 ): # Need the [0] because output is a tuple...
below_zero_ind = np.where(ph_phase <= 0.)
ph_phase[below_zero_ind] += 1.0
# Now do the same to ensure anything greater than 1.0 is between (0., 1.0)
while (len(np.where(ph_phase > 1.0)[0]) > 0 ): # Need the [0] because output is a tuple...
above_zero_ind = np.where(ph_phase > 1.0)
ph_phase[below_zero_ind] -= 1.0
# Now histogram phases to create profile for a given number of bins (and thus bin size), and give user option to split data into N equal parts
prof, bin_edges = np.histogram(ph_phase, bins=nbins, range=(0.,1.))
bin_size = (bin_edges[1] - bin_edges[0])
bin_val = bin_edges[0: len(bin_edges)-1] + bin_size/2.
prof_err = np.sqrt(prof)
# Calculate central MJD and MJD span for profile from min/max event MJDs
if(len(ph_mjd) > 0):
mjd_mean = 0.5*(np.min(ph_mjd) + np.max(ph_mjd))
mjd_span = np.max(ph_mjd) - np.min(ph_mjd)
# spin phase at representative MJD of profile
ref_phase = pu.calc_phs(mjd_mean, params['pepoch'], params['f'][0], params['f'][1], params['f'][2], params['f'][3])
# Cast to be between 0 and 1
while(ref_phase <= 0.):
ref_phase += 1.0
while(ref_phase > 1.0):
ref_phase -= 1.0
ref_freq = pu.calc_freq(mjd_mean, params['pepoch'], params['f'][0], params['f'][1], params['f'][2], params['f'][3])
else:
mjd_mean = 0.
ref_phase = 0.
ref_freq = 0.
profile = {'i':prof, 'i_err':prof_err, 'phase':bin_val, 'mjd':mjd_mean, 'mjd_span': mjd_span, 'psrname':params['psr'], 'ref_phase':ref_phase, 'ref_freq':ref_freq}
return profile
def plot_file_panel(in_file, params):
period = []
time = []
if in_file.endswith('.par'):
(epoch, T, fs) = read_par(in_file)
for minute in arange(int(T / 60.0 + 0.5)):
t = minute / 1440.0
time.append(t)
period.append(1.0 / psr_utils.calc_freq(epoch + 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(minute / 1440.0)
period.append(p0 + t * (p1 + 0.5 * t * p2))
print "Plotting: file, epoch, Tobs", in_file, epoch, T
period = asarray(period)
time = asarray(time)
plot(time, period * 1000.0, 'o')
xlabel('Time (s)')
ylabel('Period (ms)')
title("%.3f" % (epoch, ))
model_time = arange(epoch - 0.1, epoch + max(time) + 0.1, 0.001)
plot(model_time - epoch, doppler_period(params, model_time) * 1000.0, 'r')
def plot_file_panel(in_file, params):
period = []
time = []
if in_file.endswith(".par"):
(epoch, T, fs) = read_par(in_file)
for minute in arange(int(T / 60.0 + 0.5)):
t = minute / 1440.0
time.append(t)
period.append(1.0 / psr_utils.calc_freq(epoch + 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(minute / 1440.0)
period.append(p0 + t * (p1 + 0.5 * t * p2))
print "Plotting: file, epoch, Tobs", in_file, epoch, T
period = asarray(period)
time = asarray(time)
plot(time, period * 1000.0, "o")
xlabel("Time (s)")
ylabel("Period (ms)")
title("%.3f" % (epoch,))
model_time = arange(epoch - 0.1, epoch + max(time) + 0.1, 0.001)
plot(model_time - epoch, doppler_period(params, model_time) * 1000.0, "r")
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
#
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
p = 1.0/psr_utils.calc_freq(midtime, fold.epoch, fold.f0, fold.f1, fold.f2)
t0 = psr_utils.calc_t0(midtime, fold.epoch, fold.f0, fold.f1, fold.f2)
t0i= int(t0 + 1e-9)
t0f = t0 - t0i
# The .pfd file was folded using polycos
else:
# Time at the middle of the interval in question
mjdf = fold.epochf + (ii+0.5)*timestep_day
(phs, f0) = pcs.get_phs_and_freq(fold.epochi, mjdf)
phs -= fold.phs0
p = 1.0/fold.f0
t0f = mjdf - phs*p/SECPERDAY
t0i = fold.epochi
for jj in range(numsubbands):
prof = profs[ii][jj]
#
# 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
p = 1.0 / psr_utils.calc_freq(midtime, fold.epoch, fold.f0,
fold.f1, fold.f2)
t0 = psr_utils.calc_t0(midtime, fold.epoch, fold.f0, fold.f1,
fold.f2)
t0i = int(t0 + 1e-9)
t0f = t0 - t0i
# The .pfd file was folded using polycos
else:
# Time at the middle of the interval in question
mjdf = fold.epochf + (ii + 0.5) * timestep_day
(phs, f0) = pcs.get_phs_and_freq(fold.epochi, mjdf)
phs -= fold.phs0
p = 1.0 / f0
if (phs < 0.0): phs += 1.0 # Consistent with pat
t0f = mjdf - phs * p / SECPERDAY
t0i = fold.epochi
def get_ml_toa(fits_fn, prof_mod, parfile, scope='swift', print_offs=None,
frequency=None, epoch=None, sim=False, bg_counts=0, Emin=None,
Emax=None, gauss_err=False, tempo2=False, debug=False,
correct_pf=False, split_num=None, split_orbits=False):
print_timings = False # if want to print summary of runtime
fits = pyfits.open(fits_fn)
t = smu.fits2times(fits_fn, scope=scope, Emin=Emin, Emax=Emax)
#if scope != 'chandra':
# exposure = fits[0].header['EXPOSURE']
try:
obsid = fits[0].header['OBS_ID']
except KeyError:
obsid = os.path.basename(fits_fn)
if bg_counts < 0:
bg_scale = -1.0*bg_counts
bg_fits_fn = fits_fn.replace('reg','bgreg')
bg_fits = pyfits.open(bg_fits_fn)
bg_counts = int(bg_fits[1].header['NAXIS2'] * bg_scale)
print 'BG Counts:',bg_counts
bg_fits.close()
if frequency and epoch:
par = lambda: None
par.epoch = epoch
par.f0 = frequency
par.fdots = [0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0]
else:
par = PSRpar(parfile)
# split times into multiple arrays if needed
if split_orbits:
dt = t[1:] - t[:-1]
splits = np.where(dt > 0.0116)[0] # 1 ks in days
if len(splits):
ts = [ t[:splits[0]] ]
for i in range(len(splits)-1):
ts.append(t[splits[i]+1:splits[i+1]])
ts.append(t[splits[-1]+1:])
else:
ts = np.atleast_2d(t)
elif split_num:
remainder = len(t) % split_num
if remainder:
sys.stderr.write("Warning: Number of events in %s not divisable by %d. " \
"Dropping last %d events.\n" % (obsid, split_num, remainder))
ts = np.split(t[:-remainder],split_num)
else:
ts = np.split(t,split_num)
else:
ts = np.atleast_2d(t)
if len(ts) > 1 and debug:
plt.figure()
for t in ts:
nbins = int((t[-1] - t[0]) * 8640.0)
hist = np.histogram(t,bins=nbins)
plt.plot(hist[1][:-1],hist[0],c='b')
plt.axvline(t[0],ls='--',c='k',lw=2)
plt.axvline(t[-1],ls='-',c='k',lw=2)
plt.show()
for i,t in enumerate(ts):
sys.stderr.write('Measuring TOA #%d for %s\n' % (i+1,obsid))
phases = smu.times2phases(t, parfile)
if correct_pf:
old_model, new_model, corr_folded = correct_model(phases,prof_mod)
maxoff, error = calc_toa_offset(phases,prof_mod.prof_mod,sim_err=sim,bg_counts=bg_counts, gauss_err=gauss_err, debug=debug)
midtime = (t[-1]+t[0])/2.0
p_mid = 1.0/psr_utils.calc_freq(midtime, par.epoch, par.f0, par.fdots[0], par.fdots[1], par.fdots[2], par.fdots[3],
par.fdots[4], par.fdots[5], par.fdots[6], par.fdots[7], par.fdots[8])
t0 = psr_utils.calc_t0(midtime, par.epoch, par.f0, par.fdots[0], par.fdots[1], par.fdots[2], par.fdots[3],
par.fdots[4], par.fdots[5], par.fdots[6], par.fdots[7], par.fdots[8])
t0i = int(t0)
t0f = t0 - t0i
toaf = t0f + maxoff*p_mid / SECPERDAY
newdays = int(np.floor(toaf))
if tempo2:
psr_utils.write_tempo2_toa(t0i+newdays, toaf-newdays, error*p_mid*1.0e6, 0000, 0.0, name=obsid)
else:
psr_utils.write_princeton_toa(t0i+newdays, toaf-newdays, error*p_mid*1.0e6, 0000, 0.0, name=obsid)
if print_offs:
offs_file = open(print_offs,'a')
#print "\t",error*p_mid*1.0e6,"\t",exposure # this was for checking uncertainties scaling with exposure time
offs_file.write(fits_fn + "\t" + str(maxoff) + "\t" + str(error) + "\n")
#print obsid,"\tOffset:",maxoff,"+/-",error
offs_file.close()
fits.close()
#double check PF correction with measuring binned model pulsed fraction
if correct_pf and debug:
plt.figure()
nbins = len(corr_folded[0])
uncertainties = np.sqrt(corr_folded[0])
area = np.sum(corr_folded[0],dtype='float')/nbins
plt.step(corr_folded[1][:-1],np.roll(corr_folded[0]/area,int(1.0-maxoff*nbins)),where='mid')
plt.errorbar(corr_folded[1][:-1],np.roll(corr_folded[0]/area,int(1.0-maxoff*nbins)),uncertainties/area,fmt='ko')
model_x = np.linspace(0,1,100)
plt.plot(model_x,old_model(model_x),label='uncorrected')
plt.plot(model_x,new_model(model_x),label='corrected')
plt.legend()
plt.show()
if print_timings:
global calcprobtime
global logsumtime
global integratetime
sys.stderr.write('\tCalc Prob: %f s\n' % calcprobtime)
sys.stderr.write('\tLog Sum: %f s\n' % logsumtime)
sys.stderr.write('\tIntegrate Norm: %f s\n' % integratetime)
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)
p1s.append(p1)
pepochs.append(epoch)
Torb = min(time)
period = asarray(period)
time = asarray(time)
p0s = asarray(p0s)
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)
p1s.append(p1)
pepochs.append(epoch)
Torb = min(time)
period = asarray(period)
time = asarray(time)
p0s = asarray(p0s)
def add_xte_prof(profile_in, params, days_add=0.5, mjd_start=None, mjd_finish=None, align=False, template=None, filter_files=None):
# Assume we are not adding all profs together to start
add_all = False
if((mjd_start != None) & (mjd_finish != None) & (mjd_start > mjd_finish)):
print 'WARNING: mjd_start is not suppoed to be greater than mjd_finish'
n_prof_in = len(profile_in)
prof = []
prof_mjd = []
for prof_in in profile_in:
prof.append(prof_in['i'])
prof_mjd.append(prof_in['mjd'])
prof = np.array(prof)
prof_mjd = np.array(prof_mjd)
# Sort profs by MJD
sort_ind = np.argsort(prof_mjd)
prof_mjd = prof_mjd[sort_ind]
prof = prof[sort_ind]
# If only certain MJDs are specified in arguments, then filter out those MJDs only for the rest of the function. It will
# then just think these were all the input files, and if all are added together then it would behave the same, but now only selected
# files would be used. This is the easiest way to allow selected MJD range.
# So, add an if statement here that if we are only doing selected dates then no need for while loop; just add all within specified MJDs
#if(mjd_start != None): prof = prof[prof_mjd >= mjd_start]
#if(mjd_finish != None): prof = prof[prof_mjd <= mjd_finish]
# Initialize starting index
if(mjd_start != None):
# Get mjd differences between prof_mjd and mjd_start, take abs of negative ones, get smallest one.
i_first = np.argmin(np.abs(prof_mjd-mjd_start))
if ((prof_mjd[i_first] > mjd_start) & (i_first > 0)): i_first -= 1
#i_first = np.where(prof_mjd == mjd_start)[0]
else:
i_first = 0
if(mjd_finish != None):
i_last = np.argmin(np.abs(prof_mjd-mjd_finish))
if ( (prof_mjd[i_last] < mjd_start) & (i_last< (len(prof_mjd) - 1)) ): i_last += 1
# i_last = np.where(prof_mjd == mjd_finish)[0]
else:
i_last = len(prof_mjd) - 1
print ''
print 'MJD start = ', mjd_start, ' -- prof_mjd[i_first] = ', prof_mjd[i_first], ' -- i_first = ', i_first
print 'MJD finish = ', mjd_finish, ' -- prof_mjd[i_last] = ', prof_mjd[i_last], ' -- i_last = ', i_last
print ''
# If days_add is negative, then add everything in list
if(days_add < 0):
### days_add = np.max(prof_mjd) - np.min(prof_mjd) + 10.0 # add some extra days just to be safe
days_add = prof_mjd[i_last] - prof_mjd[i_first] # add some extra days just to be safe
# print "DAYS ADD = ", days_add, ' = ', days_add/365.0, ' years'
add_all = True
# Same number of phase bins for all profiles, pre- and post-added
prof_phase_out, bin_size = np.linspace(0., 1., num=np.shape(prof)[1], endpoint=False, retstep=True)
prof_phase_out += bin_size/2.
# print 'prof_mjd = ', prof_mjd
# print 'new_mjd = '
# While we are still before the end of the MJD array
profile_out = []
#### while(i_first < len(prof_mjd)):
while(i_first < i_last+1):
bin_inds = (prof_mjd >= prof_mjd[i_first]) & ( prof_mjd < (prof_mjd[i_first] + days_add) )
n_prof_out = len(np.where(bin_inds)[0]) # Number of profs going into added prof
#print prof_mjd[bin_inds]
current_profs = prof[bin_inds]
#print np.shape(current_profs), np.shape(prof), n_prof_out
# Now, if we want to align profiles before adding, do so, rotating profiles in place:
if(align==True):
# In this case, choose the profile with the best 'signal', which I will take to be the largest
# difference between peak and minimum
if(template==None):
i_template = 0
max_peak = -1.
for i_prof in range(n_prof_out):
peak_height = np.max(current_profs[i_prof]) - np.min(current_profs[i_prof])
if(peak_height > max_peak):
max_peak = peak_height
i_template = i_prof
# Now run through and align profiles with our found template. Skip if profile is template.
for i_prof in range(n_prof_out):
if(i_prof != i_template):
current_profs[i_prof] = prof_align(current_profs[i_prof], current_profs[i_template])
# If we have a template, just use it:
else:
for i_prof in range(n_prof_out):
current_profs[i_prof] = prof_align(current_profs[i_prof], template)
# Now, just add!
prof_out = np.sum(current_profs, 0) # I think 0 dim is time, and 1 is phase bins. This way, preserve phase bins.\
prof_err_out = np.sqrt(prof_out)
# Calculate central MJD based on min and max (central) MJD in sub-array
prof_mjd_out = 0.5*(np.min(prof_mjd[bin_inds]) + np.max(prof_mjd[bin_inds]))
# Calculate ref phase and period for this MJD:
prof_ref_phase = pu.calc_phs(prof_mjd_out, params['pepoch'], params['f'][0], params['f'][1], params['f'][2], params['f'][3])
# Cast to be between 0 and 1
while(prof_ref_phase <= 0.):
prof_ref_phase += 1.0
while(prof_ref_phase > 1.0):
prof_ref_phase -= 1.0
# prof_phase_out = ref_phase
prof_ref_freq = pu.calc_freq(prof_mjd_out, params['pepoch'], params['f'][0], params['f'][1], params['f'][2], params['f'][3])
# Create file name
profile_out.append({'i':prof_out, 'i_err':prof_err_out, 'phase':prof_phase_out, 'mjd':prof_mjd_out, 'psrname':params['psr'], 'ref_phase':prof_ref_phase, 'ref_freq':prof_ref_freq})
# Now increase i_first to point to the beginning of next set
i_first = np.where(bin_inds)[0][-1] + 1 # = last index of previous set of indices, plus 1
# If there is only one output file, then just make profile_out a single profile (i.e. not an array of profiles)
if(add_all):
profile_out = profile_out[0]
pass
# print 'OUT PROFS = ', profile_out
# print 'LEN OUT PROFS = ', len(profile_out)
return profile_out
