def test_process_and_accuracy(self):
# Checks that instantiating an observatory and phasing of
# topocentric times works. Verifies accuracy to the sub-mus
# level by comparison with stored Tempo2 "Fermi plugin" results.
modelin = pint.models.get_model(parfile)
get_satellite_observatory("Fermi", ft2file)
tl = load_Fermi_TOAs(eventfileraw, weightcolumn="PSRJ0030+0451")
# ts = toa.TOAs(toalist=tl)
ts = toa.get_TOAs_list(tl,
include_gps=False,
include_bipm=False,
planets=False,
ephem="DE405")
iphss, phss = modelin.phase(ts, abs_phase=True)
ph_pint = phss % 1
with fits.open(eventfileraw) as f:
ph_tempo2 = f[1].data.field("pulse_phase")
dphi = ph_pint - ph_tempo2
dphi[dphi < -0.1] += 1
dphi[dphi > 0.1] -= 1
resids_mus = dphi / modelin.F0.value * 1e6
# if the "2 mus" problem exists, the scatter in these values will
# be 4-5 mus, whereas if everything is OK it should be few 100 ns
# require range in TOAs to be less than 200ns
self.assertTrue((resids_mus.max() - resids_mus.min()) < 0.2)
# require absolute phase to be within 500 ns; NB this relies on
# GBT clock corrections since the TZR is referenced there
self.assertTrue(max(abs(resids_mus)) < 0.5)
def test_good_calls():
# ensure that valid entries are accepted
ft2file = os.path.join(datadir,
"lat_spacecraft_weekly_w323_p202_v001.fits")
fermi_obs = get_satellite_observatory("Fermi", ft2file, overwrite=True)
tt_mjd = fermi_obs.FT2["MJD_TT"]
good_times = Time(
tt_mjd[::len(tt_mjd) // 10] + (np.random.rand(1) * 4 - 2) / (60 * 24),
format="mjd",
scale="tt",
)
# NB this also tests calls with a vector Time
fermi_obs._check_bounds(good_times)
def test_good_calls():
# ensure that valid entries are accepted
ft2file = os.path.join(datadir,
"lat_spacecraft_weekly_w323_p202_v001.fits")
fermi_obs = get_satellite_observatory("Fermi", ft2file, overwrite=True)
tt_mjd = fermi_obs.FT2["MJD_TT"]
test_mjds = tt_mjd[::len(tt_mjd) //
10] + (np.random.rand(1) * 4 - 2) / (60 * 24)
# add an explicit entry 20s after the last FT2 point; should pass with
# default settings
test_mjds = np.append(test_mjds, tt_mjd[-1] + 20.0 / 86400)
assert test_mjds[-1] > tt_mjd[-1]
good_times = Time(test_mjds, format="mjd", scale="tt")
# NB this also tests calls with a vector Time
fermi_obs._check_bounds(good_times)
def test_bad_calls():
# find an SAA passage, which will be internal
ft2file = os.path.join(datadir,
"lat_spacecraft_weekly_w323_p202_v001.fits")
fermi_obs = get_satellite_observatory("Fermi", ft2file, overwrite=True)
tt_mjd = fermi_obs.FT2["MJD_TT"]
saa_idx = np.argmax((tt_mjd[1:] - tt_mjd[:-1]))
bad_time_saa = Time(tt_mjd[saa_idx] + 3.0 / (60 * 24),
format="mjd",
scale="tt")
# and test extrapolation from the ends
# NB this also tests calls with a scalar Time
bad_time_end = Time(tt_mjd[-1] + 3.0 / (60 * 24), format="mjd", scale="tt")
bad_time_beg = Time(tt_mjd[0] - 3.0 / (60 * 24), format="mjd", scale="tt")
with pytest.raises(ValueError):
fermi_obs._check_bounds(bad_time_saa)
with pytest.raises(ValueError):
fermi_obs._check_bounds(bad_time_end)
with pytest.raises(ValueError):
fermi_obs._check_bounds(bad_time_beg)
def main(argv=None):
parser = argparse.ArgumentParser(
description=
"PINT tool for MCMC optimization of timing models using event data.")
parser.add_argument("eventfile", help="event file to use")
parser.add_argument("parfile", help="par file to read model from")
parser.add_argument("gaussianfile",
help="gaussian file that defines template")
parser.add_argument("--ft2", help="Path to FT2 file.", default=None)
parser.add_argument(
"--weightcol",
help="name of weight column (or 'CALC' to have them computed",
default=None,
)
parser.add_argument("--nwalkers",
help="Number of MCMC walkers (def 200)",
type=int,
default=200)
parser.add_argument(
"--burnin",
help="Number of MCMC steps for burn in (def 100)",
type=int,
default=100,
)
parser.add_argument(
"--nsteps",
help="Number of MCMC steps to compute (def 1000)",
type=int,
default=1000,
)
parser.add_argument("--minMJD",
help="Earliest MJD to use (def 54680)",
type=float,
default=54680.0)
parser.add_argument("--maxMJD",
help="Latest MJD to use (def 57250)",
type=float,
default=57250.0)
parser.add_argument("--phs",
help="Starting phase offset [0-1] (def is to measure)",
type=float)
parser.add_argument("--phserr",
help="Error on starting phase",
type=float,
default=0.03)
parser.add_argument(
"--minWeight",
help="Minimum weight to include (def 0.05)",
type=float,
default=0.05,
)
parser.add_argument(
"--wgtexp",
help=
"Raise computed weights to this power (or 0.0 to disable any rescaling of weights)",
type=float,
default=0.0,
)
parser.add_argument(
"--testWeights",
help="Make plots to evalute weight cuts?",
default=False,
action="store_true",
)
parser.add_argument(
"--doOpt",
help="Run initial scipy opt before MCMC?",
default=False,
action="store_true",
)
parser.add_argument(
"--initerrfact",
help=
"Multiply par file errors by this factor when initializing walker starting values",
type=float,
default=0.1,
)
parser.add_argument(
"--priorerrfact",
help=
"Multiple par file errors by this factor when setting gaussian prior widths",
type=float,
default=10.0,
)
parser.add_argument(
"--usepickle",
help="Read events from pickle file, if available?",
default=False,
action="store_true",
)
global nwalkers, nsteps, ftr
args = parser.parse_args(argv)
eventfile = args.eventfile
parfile = args.parfile
gaussianfile = args.gaussianfile
weightcol = args.weightcol
if args.ft2 is not None:
# Instantiate Fermi observatory once so it gets added to the observatory registry
get_satellite_observatory("Fermi", args.ft2)
nwalkers = args.nwalkers
burnin = args.burnin
nsteps = args.nsteps
if burnin >= nsteps:
log.error("burnin must be < nsteps")
sys.exit(1)
nbins = 256 # For likelihood calculation based on gaussians file
outprof_nbins = 256 # in the text file, for pygaussfit.py, for instance
minMJD = args.minMJD
maxMJD = args.maxMJD # Usually set by coverage of IERS file
minWeight = args.minWeight
do_opt_first = args.doOpt
wgtexp = args.wgtexp
# Read in initial model
modelin = pint.models.get_model(parfile)
# The custom_timing version below is to manually construct the TimingModel
# class, which allows it to be pickled. This is needed for parallelizing
# the emcee call over a number of threads. So far, it isn't quite working
# so it is disabled. The code above constructs the TimingModel class
# dynamically, as usual.
# modelin = custom_timing(parfile)
# Remove the dispersion delay as it is unnecessary
# modelin.delay_funcs['L1'].remove(modelin.dispersion_delay)
# Set the target coords for automatic weighting if necessary
if "ELONG" in modelin.params:
tc = SkyCoord(
modelin.ELONG.quantity,
modelin.ELAT.quantity,
frame="barycentrictrueecliptic",
)
else:
tc = SkyCoord(modelin.RAJ.quantity,
modelin.DECJ.quantity,
frame="icrs")
target = tc if weightcol == "CALC" else None
# TODO: make this properly handle long double
if not args.usepickle or (not (os.path.isfile(eventfile + ".pickle") or
os.path.isfile(eventfile + ".pickle.gz"))):
# Read event file and return list of TOA objects
tl = fermi.load_Fermi_TOAs(eventfile,
weightcolumn=weightcol,
targetcoord=target,
minweight=minWeight)
# Limit the TOAs to ones in selected MJD range and above minWeight
tl = [
tl[ii] for ii in range(len(tl))
if (tl[ii].mjd.value > minMJD and tl[ii].mjd.value < maxMJD and (
weightcol is None or tl[ii].flags["weight"] > minWeight))
]
log.info("There are %d events we will use" % len(tl))
# Now convert to TOAs object and compute TDBs and posvels
ts = toa.TOAs(toalist=tl)
ts.filename = eventfile
ts.compute_TDBs()
ts.compute_posvels(ephem="DE421", planets=False)
ts.pickle()
else: # read the events in as a pickle file
picklefile = toa._check_pickle(eventfile)
if not picklefile:
picklefile = eventfile
ts = toa.TOAs(picklefile)
if weightcol is not None:
if weightcol == "CALC":
weights = np.asarray([x["weight"] for x in ts.table["flags"]])
log.info("Original weights have min / max weights %.3f / %.3f" %
(weights.min(), weights.max()))
# Rescale the weights, if requested (by having wgtexp != 0.0)
if wgtexp != 0.0:
weights **= wgtexp
wmx, wmn = weights.max(), weights.min()
# make the highest weight = 1, but keep min weight the same
weights = wmn + ((weights - wmn) * (1.0 - wmn) / (wmx - wmn))
for ii, x in enumerate(ts.table["flags"]):
x["weight"] = weights[ii]
weights = np.asarray([x["weight"] for x in ts.table["flags"]])
log.info("There are %d events, with min / max weights %.3f / %.3f" %
(len(weights), weights.min(), weights.max()))
else:
weights = None
log.info("There are %d events, no weights are being used." % ts.ntoas)
# Now load in the gaussian template and normalize it
gtemplate = read_gaussfitfile(gaussianfile, nbins)
gtemplate /= gtemplate.mean()
# Set the priors on the parameters in the model, before
# instantiating the emcee_fitter
# Currently, this adds a gaussian prior on each parameter
# with width equal to the par file uncertainty * priorerrfact,
# and then puts in some special cases.
# *** This should be replaced/supplemented with a way to specify
# more general priors on parameters that need certain bounds
phs = 0.0 if args.phs is None else args.phs
fitkeys, fitvals, fiterrs = get_fit_keyvals(modelin,
phs=phs,
phserr=args.phserr)
for key, v, e in zip(fitkeys[:-1], fitvals[:-1], fiterrs[:-1]):
if key == "SINI" or key == "E" or key == "ECC":
getattr(modelin, key).prior = Prior(uniform(0.0, 1.0))
elif key == "PX":
getattr(modelin, key).prior = Prior(uniform(0.0, 10.0))
elif key.startswith("GLPH"):
getattr(modelin, key).prior = Prior(uniform(-0.5, 1.0))
else:
getattr(modelin, key).prior = Prior(
norm(loc=float(v), scale=float(e * args.priorerrfact)))
# Now define the requirements for emcee
ftr = emcee_fitter(ts, modelin, gtemplate, weights, phs, args.phserr)
# Use this if you want to see the effect of setting minWeight
if args.testWeights:
log.info("Checking H-test vs weights")
ftr.prof_vs_weights(use_weights=True)
ftr.prof_vs_weights(use_weights=False)
sys.exit()
# Now compute the photon phases and see if we see a pulse
phss = ftr.get_event_phases()
maxbin, like_start = marginalize_over_phase(phss,
gtemplate,
weights=ftr.weights,
minimize=True,
showplot=False)
log.info("Starting pulse likelihood: %f" % like_start)
if args.phs is None:
fitvals[-1] = 1.0 - maxbin[0] / float(len(gtemplate))
if fitvals[-1] > 1.0:
fitvals[-1] -= 1.0
if fitvals[-1] < 0.0:
fitvals[-1] += 1.0
log.info("Starting pulse phase: %f" % fitvals[-1])
else:
log.warning("Measured starting pulse phase is %f, but using %f" %
(1.0 - maxbin / float(len(gtemplate)), args.phs))
fitvals[-1] = args.phs
ftr.fitvals[-1] = fitvals[-1]
ftr.phaseogram(plotfile=ftr.model.PSR.value + "_pre.png")
plt.close()
# ftr.phaseogram()
# Write out the starting pulse profile
vs, xs = np.histogram(ftr.get_event_phases(),
outprof_nbins,
range=[0, 1],
weights=ftr.weights)
f = open(ftr.model.PSR.value + "_prof_pre.txt", "w")
for x, v in zip(xs, vs):
f.write("%.5f %12.5f\n" % (x, v))
f.close()
# Try normal optimization first to see how it goes
if do_opt_first:
result = op.minimize(ftr.minimize_func, np.zeros_like(ftr.fitvals))
newfitvals = np.asarray(result["x"]) * ftr.fiterrs + ftr.fitvals
like_optmin = -result["fun"]
log.info("Optimization likelihood: %f" % like_optmin)
ftr.set_params(dict(zip(ftr.fitkeys, newfitvals)))
ftr.phaseogram()
else:
like_optmin = -np.inf
# Set up the initial conditions for the emcee walkers. Use the
# scipy.optimize newfitvals instead if they are better
ndim = ftr.n_fit_params
if like_start > like_optmin:
# Keep the starting deviations small...
pos = [
ftr.fitvals +
ftr.fiterrs * args.initerrfact * np.random.randn(ndim)
for ii in range(nwalkers)
]
# Set starting params
for param in [
"GLPH_1", "GLEP_1", "SINI", "M2", "E", "ECC", "PX", "A1"
]:
if param in ftr.fitkeys:
idx = ftr.fitkeys.index(param)
if param == "GLPH_1":
svals = np.random.uniform(-0.5, 0.5, nwalkers)
elif param == "GLEP_1":
svals = np.random.uniform(minMJD + 100, maxMJD - 100,
nwalkers)
# svals = 55422.0 + np.random.randn(nwalkers)
elif param == "SINI":
svals = np.random.uniform(0.0, 1.0, nwalkers)
elif param == "M2":
svals = np.random.uniform(0.1, 0.6, nwalkers)
elif param in ["E", "ECC", "PX", "A1"]:
# Ensure all positive
svals = np.fabs(ftr.fitvals[idx] + ftr.fiterrs[idx] *
np.random.randn(nwalkers))
if param in ["E", "ECC"]:
svals[svals > 1.0] = 1.0 - (svals[svals > 1.0] - 1.0)
for ii in range(nwalkers):
pos[ii][idx] = svals[ii]
else:
pos = [
newfitvals + ftr.fiterrs * args.initerrfact * np.random.randn(ndim)
for i in range(nwalkers)
]
# Set the 0th walker to have the initial pre-fit solution
# This way, one walker should always be in a good position
pos[0] = ftr.fitvals
import emcee
# Following are for parallel processing tests...
if 0:
def unwrapped_lnpost(theta, ftr=ftr):
return ftr.lnposterior(theta)
import pathos.multiprocessing as mp
pool = mp.ProcessPool(nodes=8)
sampler = emcee.EnsembleSampler(nwalkers,
ndim,
unwrapped_lnpost,
pool=pool,
args=[ftr])
else:
sampler = emcee.EnsembleSampler(nwalkers, ndim, ftr.lnposterior)
# The number is the number of points in the chain
sampler.run_mcmc(pos, nsteps)
def chains_to_dict(names, sampler):
chains = [sampler.chain[:, :, ii].T for ii in range(len(names))]
return dict(zip(names, chains))
def plot_chains(chain_dict, file=False):
npts = len(chain_dict)
fig, axes = plt.subplots(npts, 1, sharex=True, figsize=(8, 9))
for ii, name in enumerate(chain_dict.keys()):
axes[ii].plot(chain_dict[name], color="k", alpha=0.3)
axes[ii].set_ylabel(name)
axes[npts - 1].set_xlabel("Step Number")
fig.tight_layout()
if file:
fig.savefig(file)
plt.close()
else:
plt.show()
plt.close()
chains = chains_to_dict(ftr.fitkeys, sampler)
plot_chains(chains, file=ftr.model.PSR.value + "_chains.png")
# Make the triangle plot.
samples = sampler.chain[:, burnin:, :].reshape((-1, ndim))
try:
import corner
fig = corner.corner(
samples,
labels=ftr.fitkeys,
bins=50,
truths=ftr.maxpost_fitvals,
plot_contours=True,
)
fig.savefig(ftr.model.PSR.value + "_triangle.png")
plt.close()
except ImportError:
pass
# Make a phaseogram with the 50th percentile values
# ftr.set_params(dict(zip(ftr.fitkeys, np.percentile(samples, 50, axis=0))))
# Make a phaseogram with the best MCMC result
ftr.set_params(dict(zip(ftr.fitkeys[:-1], ftr.maxpost_fitvals[:-1])))
ftr.phaseogram(plotfile=ftr.model.PSR.value + "_post.png")
plt.close()
# Write out the output pulse profile
vs, xs = np.histogram(ftr.get_event_phases(),
outprof_nbins,
range=[0, 1],
weights=ftr.weights)
f = open(ftr.model.PSR.value + "_prof_post.txt", "w")
for x, v in zip(xs, vs):
f.write("%.5f %12.5f\n" % (x, v))
f.close()
# Write out the par file for the best MCMC parameter est
f = open(ftr.model.PSR.value + "_post.par", "w")
f.write(ftr.model.as_parfile())
f.close()
# Print the best MCMC values and ranges
ranges = map(
lambda v: (v[1], v[2] - v[1], v[1] - v[0]),
zip(*np.percentile(samples, [16, 50, 84], axis=0)),
)
log.info("Post-MCMC values (50th percentile +/- (16th/84th percentile):")
for name, vals in zip(ftr.fitkeys, ranges):
log.info("%8s:" % name + "%25.15g (+ %12.5g / - %12.5g)" % vals)
# Put the same stuff in a file
f = open(ftr.model.PSR.value + "_results.txt", "w")
f.write("Post-MCMC values (50th percentile +/- (16th/84th percentile):\n")
for name, vals in zip(ftr.fitkeys, ranges):
f.write("%8s:" % name + " %25.15g (+ %12.5g / - %12.5g)\n" % vals)
f.write("\nMaximum likelihood par file:\n")
f.write(ftr.model.as_parfile())
f.close()
from six.moves import cPickle as pickle
pickle.dump(samples, open(ftr.model.PSR.value + "_samples.pickle", "wb"))
if args.topo and barydata:
log.error("Can't compute topocentric TOAs from barycentered events!")
sys.exit(1)
if (args.orbfile is not None) and barydata:
log.warning("Data are barycentered, so ignoring orbfile!")
if hdr["TELESCOP"] == "NICER":
# Instantiate NICERObs once so it gets added to the observatory registry
# Bug! It should not do this if the events have already been barycentered!
if barydata:
obs = "Barycenter"
else:
if args.orbfile is not None:
log.info("Setting up NICER observatory")
obs = get_satellite_observatory("NICER", args.orbfile)
else:
log.error("NICER .orb file required for non-barycentered events!\n"
"Please specify with --orbfile")
sys.exit(2)
# Read event file and return list of TOA objects
try:
tl = local_load_NICER_TOAs(args.eventname)
except KeyError:
log.error(
"Failed to load NICER TOAs. Make sure orbit file is specified on command line!"
)
raise
elif hdr["TELESCOP"] == "XTE":
if barydata:
def main(argv=None):
import argparse
parser = argparse.ArgumentParser(
description=
"Use PINT to compute event phases and make plots of photon event files."
)
parser.add_argument(
"eventfile",
help=
"Photon event FITS file name (e.g. from NICER, RXTE, XMM, Chandra).",
)
parser.add_argument("parfile", help="par file to construct model from")
parser.add_argument("--orbfile", help="Name of orbit file", default=None)
parser.add_argument("--maxMJD",
help="Maximum MJD to include in analysis",
default=None)
parser.add_argument("--minMJD",
help="Minimum MJD to include in analysis",
default=None)
parser.add_argument("--plotfile",
help="Output figure file name (default=None)",
default=None)
parser.add_argument(
"--addphase",
help="Write FITS file with added phase column",
default=False,
action="store_true",
)
parser.add_argument(
"--addorbphase",
help="Write FITS file with added orbital phase column",
default=False,
action="store_true",
)
parser.add_argument(
"--absphase",
help="Write FITS file with integral portion of pulse phase (ABS_PHASE)",
default=False,
action="store_true",
)
parser.add_argument(
"--barytime",
help=
"Write FITS file with a column containing the barycentric time as double precision MJD.",
default=False,
action="store_true",
)
parser.add_argument(
"--outfile",
help="Output FITS file name (default=same as eventfile)",
default=None,
)
parser.add_argument("--ephem",
help="Planetary ephemeris to use (default=DE421)",
default="DE421")
parser.add_argument(
"--tdbmethod",
help="Method for computing TT to TDB (default=astropy)",
default="default",
)
parser.add_argument("--plot",
help="Show phaseogram plot.",
action="store_true",
default=False)
parser.add_argument(
"--use_gps",
default=False,
action="store_true",
help="Apply GPS to UTC clock corrections",
)
parser.add_argument(
"--use_bipm",
default=False,
action="store_true",
help="Use TT(BIPM) instead of TT(TAI)",
)
# parser.add_argument("--fix",help="Apply 1.0 second offset for NICER", action='store_true', default=False)
args = parser.parse_args(argv)
# If outfile is specified, that implies addphase
if args.outfile is not None:
args.addphase = True
# If plotfile is specified, that implies plot
if args.plotfile is not None:
args.plot = True
# set MJD ranges
maxmjd = np.inf if (args.maxMJD is None) else float(args.maxMJD)
minmjd = 0.0 if (args.minMJD is None) else float(args.minMJD)
# Read event file header to figure out what instrument is is from
hdr = pyfits.getheader(args.eventfile, ext=1)
log.info("Event file TELESCOPE = {0}, INSTRUMENT = {1}".format(
hdr["TELESCOP"], hdr["INSTRUME"]))
if hdr["TELESCOP"] == "NICER":
# Instantiate NICER observatory once so it gets added to the observatory registry
if args.orbfile is not None:
log.info("Setting up NICER observatory")
get_satellite_observatory("NICER", args.orbfile)
# Read event file and return list of TOA objects
try:
tl = load_NICER_TOAs(args.eventfile, minmjd=minmjd, maxmjd=maxmjd)
except KeyError:
log.error(
"Observatory not recognized. This probably means you need to provide an orbit file or barycenter the event file."
)
sys.exit(1)
elif hdr["TELESCOP"] == "XTE":
# Instantiate RXTE observatory once so it gets added to the observatory registry
if args.orbfile is not None:
# Determine what observatory type is.
log.info("Setting up RXTE observatory")
get_satellite_observatory("RXTE", args.orbfile)
# Read event file and return list of TOA objects
tl = load_RXTE_TOAs(args.eventfile, minmjd=minmjd, maxmjd=maxmjd)
elif hdr["TELESCOP"].startswith("XMM"):
# Not loading orbit file here, since that is not yet supported.
tl = load_XMM_TOAs(args.eventfile, minmjd=minmjd, maxmjd=maxmjd)
elif hdr["TELESCOP"].lower().startswith("nustar"):
if args.orbfile is not None:
log.info("Setting up NuSTAR observatory")
get_satellite_observatory("NuSTAR", args.orbfile)
tl = load_NuSTAR_TOAs(args.eventfile, minmjd=minmjd, maxmjd=maxmjd)
else:
log.error(
"FITS file not recognized, TELESCOPE = {0}, INSTRUMENT = {1}".
format(hdr["TELESCOP"], hdr["INSTRUME"]))
sys.exit(1)
# Now convert to TOAs object and compute TDBs and posvels
if len(tl) == 0:
log.error("No TOAs, exiting!")
sys.exit(0)
# Read in model
modelin = pint.models.get_model(args.parfile)
use_planets = False
if "PLANET_SHAPIRO" in modelin.params:
if modelin.PLANET_SHAPIRO.value:
use_planets = True
if "AbsPhase" not in modelin.components:
log.error(
"TimingModel does not include AbsPhase component, which is required "
"for computing phases. Make sure you have TZR* parameters in your par file!"
)
raise ValueError("Model missing AbsPhase component.")
if args.addorbphase and (not hasattr(modelin, "binary_model_name")):
log.error(
"TimingModel does not include a binary model, which is required for "
"computing orbital phases. Make sure you have BINARY and associated "
"model parameters in your par file!")
raise ValueError("Model missing BINARY component.")
ts = toa.get_TOAs_list(
tl,
ephem=args.ephem,
include_bipm=args.use_bipm,
include_gps=args.use_gps,
planets=use_planets,
tdb_method=args.tdbmethod,
)
ts.filename = args.eventfile
# if args.fix:
# ts.adjust_TOAs(TimeDelta(np.ones(len(ts.table))*-1.0*u.s,scale='tt'))
print(ts.get_summary())
mjds = ts.get_mjds()
print(mjds.min(), mjds.max())
# Compute model phase for each TOA
iphss, phss = modelin.phase(ts, abs_phase=True)
phases = phss.value % 1
h = float(hm(phases))
print("Htest : {0:.2f} ({1:.2f} sigma)".format(h, h2sig(h)))
if args.plot:
phaseogram_binned(mjds, phases, bins=100, plotfile=args.plotfile)
# Compute orbital phases for each photon TOA
if args.addorbphase:
delay = modelin.delay(ts)
orbits = modelin.binary_instance.orbits()
# These lines are already in orbits.orbit_phase() in binary_orbits.py.
# What is the correct syntax is to call this function here?
norbits = np.array(np.floor(orbits), dtype=np.long)
orbphases = orbits - norbits # fractional phase
if args.addphase or args.addorbphase:
# Read input FITS file (again).
# If overwriting, open in 'update' mode
if args.outfile is None:
hdulist = pyfits.open(args.eventfile, mode="update")
else:
hdulist = pyfits.open(args.eventfile)
datacol = []
data_to_add = {}
# Handle case where minMJD/maxMJD do not exceed length of events
mjds_float = read_fits_event_mjds(hdulist[1])
time_mask = np.logical_and((mjds_float > minmjd),
(mjds_float < maxmjd))
if args.addphase:
if time_mask.sum() != len(phases):
raise RuntimeError(
"Mismatch between data selection {0} and length of phase array ({1})!"
.format(time_mask.sum(), len(phases)))
data_to_add["PULSE_PHASE"] = [phases, "D"]
if args.absphase:
data_to_add["ABS_PHASE"] = [iphss - negmask, "K"]
if args.barytime:
bats = modelin.get_barycentric_toas(ts)
data_to_add["BARY_TIME"] = [bats, "D"]
if args.addorbphase:
if time_mask.sum() != len(orbphases):
raise RuntimeError(
"Mismatch between data selection ({0}) and length of orbital phase array ({1})!"
.format(time_mask.sum(), len(orbphases)))
data_to_add["ORBIT_PHASE"] = [orbphases, "D"]
# End if args.addorbphase
for key in data_to_add.keys():
if key in hdulist[1].columns.names:
log.info("Found existing %s column, overwriting..." % key)
# Overwrite values in existing Column
hdulist[1].data[key][time_mask] = data_to_add[key][0]
else:
# Construct and append new column, preserving HDU header and name
log.info("Adding new %s column." % key)
new_dat = np.full(time_mask.shape,
-1,
dtype=data_to_add[key][0].dtype)
new_dat[time_mask] = data_to_add[key][0]
datacol.append(
pyfits.ColDefs([
pyfits.Column(name=key,
format=data_to_add[key][1],
array=new_dat)
]))
if len(datacol) > 0:
cols = hdulist[1].columns
for c in datacol:
cols = cols + c
bt = pyfits.BinTableHDU.from_columns(cols,
header=hdulist[1].header,
name=hdulist[1].name)
hdulist[1] = bt
if args.outfile is None:
# Overwrite the existing file
log.info("Overwriting existing FITS file " + args.eventfile)
hdulist.flush(verbose=True, output_verify="warn")
else:
# Write to new output file
log.info("Writing output FITS file " + args.outfile)
hdulist.writeto(args.outfile,
overwrite=True,
checksum=True,
output_verify="warn")
def main(argv=None):
parser = argparse.ArgumentParser(
description=
"Use PINT to compute H-test and plot Phaseogram from a Fermi FT1 event file."
)
parser.add_argument("eventfile", help="Fermi event FITS file name.")
parser.add_argument("parfile", help="par file to construct model from")
parser.add_argument(
"weightcol",
help="Column name for event weights (or 'CALC' to compute them)")
parser.add_argument("--ft2", help="Path to FT2 file.", default=None)
parser.add_argument(
"--addphase",
help="Write FT1 file with added phase column",
default=False,
action="store_true",
)
parser.add_argument("--plot",
help="Show phaseogram plot.",
action="store_true",
default=False)
parser.add_argument("--plotfile",
help="Output figure file name (default=None)",
default=None)
parser.add_argument("--maxMJD",
help="Maximum MJD to include in analysis",
default=None)
parser.add_argument("--minMJD",
help="Minimum MJD to include in analysis",
default=None)
parser.add_argument(
"--outfile",
help="Output figure file name (default is to overwrite input file)",
default=None,
)
parser.add_argument(
"--planets",
help="Use planetary Shapiro delay in calculations (default=False)",
default=False,
action="store_true",
)
parser.add_argument("--ephem",
help="Planetary ephemeris to use (default=DE421)",
default="DE421")
args = parser.parse_args(argv)
# If outfile is specified, that implies addphase
if args.outfile is not None:
args.addphase = True
# Read in model
modelin = pint.models.get_model(args.parfile)
if "ELONG" in modelin.params:
tc = SkyCoord(
modelin.ELONG.quantity,
modelin.ELAT.quantity,
frame="barycentrictrueecliptic",
)
else:
tc = SkyCoord(modelin.RAJ.quantity,
modelin.DECJ.quantity,
frame="icrs")
if args.ft2 is not None:
# Instantiate Fermi observatory once so it gets added to the observatory registry
get_satellite_observatory("Fermi", args.ft2)
# Read event file and return list of TOA objects
maxmjd = np.inf if (args.maxMJD is None) else float(args.maxMJD)
minmjd = 0.0 if (args.minMJD is None) else float(args.minMJD)
tl = load_Fermi_TOAs(
args.eventfile,
maxmjd=maxmjd,
minmjd=minmjd,
weightcolumn=args.weightcol,
targetcoord=tc,
)
# Now convert to TOAs object and compute TDBs and posvels
# For Fermi, we are not including GPS or TT(BIPM) corrections
ts = toa.get_TOAs_list(
tl,
include_gps=False,
include_bipm=False,
planets=args.planets,
ephem=args.ephem,
)
ts.filename = args.eventfile
print(ts.get_summary())
mjds = ts.get_mjds()
print(mjds.min(), mjds.max())
# Compute model phase for each TOA
iphss, phss = modelin.phase(ts, abs_phase=True)
phss %= 1
phases = phss.value
mjds = ts.get_mjds()
weights = np.array([w["weight"] for w in ts.table["flags"]])
h = float(hmw(phases, weights))
print("Htest : {0:.2f} ({1:.2f} sigma)".format(h, h2sig(h)))
if args.plot:
log.info("Making phaseogram plot with {0} photons".format(len(mjds)))
phaseogram(mjds, phases, weights, bins=100, plotfile=args.plotfile)
if args.addphase:
# Read input FITS file (again).
# If overwriting, open in 'update' mode
if args.outfile is None:
hdulist = pyfits.open(args.eventfile, mode="update")
else:
hdulist = pyfits.open(args.eventfile)
event_hdu = hdulist[1]
event_hdr = event_hdu.header
event_dat = event_hdu.data
event_mjds = read_fits_event_mjds_tuples(event_hdu)
mjds_float = np.asarray([r[0] + r[1] for r in event_mjds])
time_mask = np.logical_and((mjds_float > minmjd),
(mjds_float < maxmjd))
new_phases = np.full(len(event_dat), -1, dtype=float)
new_phases[time_mask] = phases
if "PULSE_PHASE" in event_hdu.columns.names:
log.info("Found existing PULSE_PHASE column, overwriting...")
# Overwrite values in existing Column
event_dat["PULSE_PHASE"] = new_phases
else:
# Construct and append new column, preserving HDU header and name
log.info("Adding new PULSE_PHASE column.")
phasecol = pyfits.ColDefs([
pyfits.Column(name="PULSE_PHASE", format="D", array=new_phases)
])
bt = pyfits.BinTableHDU.from_columns(event_hdu.columns + phasecol,
header=event_hdr,
name=event_hdu.name)
hdulist[1] = bt
if args.outfile is None:
# Overwrite the existing file
log.info("Overwriting existing FITS file " + args.eventfile)
hdulist.flush(verbose=True, output_verify="warn")
else:
# Write to new output file
log.info("Writing output FITS file " + args.outfile)
hdulist.writeto(args.outfile,
overwrite=True,
checksum=True,
output_verify="warn")
return 0
def main(argv=None):
import argparse
parser = argparse.ArgumentParser(
description=
"Use PINT to compute event phases and make plots of photon event files.",
formatter_class=argparse.ArgumentDefaultsHelpFormatter,
)
parser.add_argument(
"eventfile",
help=
"Photon event FITS file name (e.g. from NICER, RXTE, XMM, Chandra).",
)
parser.add_argument("parfile", help="par file to construct model from")
parser.add_argument("--orbfile", help="Name of orbit file", default=None)
parser.add_argument("--maxMJD",
help="Maximum MJD to include in analysis",
default=None)
parser.add_argument("--minMJD",
help="Minimum MJD to include in analysis",
default=None)
parser.add_argument("--plotfile",
help="Output figure file name",
default=None)
parser.add_argument(
"--addphase",
help="Write FITS file with added phase column",
default=False,
action="store_true",
)
parser.add_argument(
"--addorbphase",
help="Write FITS file with added orbital phase column",
default=False,
action="store_true",
)
parser.add_argument(
"--absphase",
help="Write FITS file with integral portion of pulse phase (ABS_PHASE)",
default=False,
action="store_true",
)
parser.add_argument(
"--barytime",
help=
"Write FITS file with a column containing the barycentric time as double precision MJD.",
default=False,
action="store_true",
)
parser.add_argument(
"--outfile",
help="Output FITS file name (default=same as eventfile)",
default=None,
)
parser.add_argument("--ephem",
help="Planetary ephemeris to use",
default="DE421")
parser.add_argument(
"--tdbmethod",
help="Method for computing TT to TDB (default=astropy)",
default="default",
)
parser.add_argument("--plot",
help="Show phaseogram plot.",
action="store_true",
default=False)
parser.add_argument(
"--use_gps",
default=False,
action="store_true",
help="Apply GPS to UTC clock corrections",
)
parser.add_argument(
"--use_bipm",
default=False,
action="store_true",
help="Use TT(BIPM) instead of TT(TAI)",
)
parser.add_argument(
"--log-level",
type=str,
choices=("TRACE", "DEBUG", "INFO", "WARNING", "ERROR"),
default="WARNING",
help="Logging level",
dest="loglevel",
)
# parser.add_argument("--fix",help="Apply 1.0 second offset for NICER", action='store_true', default=False)
parser.add_argument(
"--polycos",
default=False,
action="store_true",
help=
"Use polycos to calculate phases; use when working with very large event files",
)
args = parser.parse_args(argv)
log.remove()
log.add(
sys.stderr,
level=args.loglevel,
colorize=True,
format=pint.logging.format,
filter=pint.logging.LogFilter(),
)
# If outfile is specified, that implies addphase
if args.outfile is not None:
args.addphase = True
# If plotfile is specified, that implies plot
if args.plotfile is not None:
args.plot = True
# set MJD ranges
maxmjd = np.inf if (args.maxMJD is None) else float(args.maxMJD)
minmjd = 0.0 if (args.minMJD is None) else float(args.minMJD)
# Read event file header to figure out what instrument is is from
hdr = pyfits.getheader(args.eventfile, ext=1)
log.info("Event file TELESCOPE = {0}, INSTRUMENT = {1}".format(
hdr["TELESCOP"], hdr["INSTRUME"]))
telescope = hdr["TELESCOP"].lower()
# Instantiate observatory once so it gets added to the observatory registry
if args.orbfile is not None:
log.info(f"Setting up {telescope.upper()} observatory")
try:
get_satellite_observatory(telescope, args.orbfile)
except Exception:
log.error(
"The orbit file is not recognized. It is likely that this mission is not supported. "
"Please barycenter the event file using the official mission tools before processing with PINT"
)
# Read event file and return list of TOA objects, if not using polycos
if args.polycos == False:
try:
tl = load_event_TOAs(args.eventfile,
telescope,
minmjd=minmjd,
maxmjd=maxmjd)
except KeyError:
log.error(
"Observatory not recognized. This probably means you need to provide an orbit file or barycenter the event file."
)
sys.exit(1)
# Now convert to TOAs object and compute TDBs and posvels
if len(tl) == 0:
log.error("No TOAs, exiting!")
sys.exit(0)
# Read in model
modelin = pint.models.get_model(args.parfile)
use_planets = False
if "PLANET_SHAPIRO" in modelin.params:
if modelin.PLANET_SHAPIRO.value:
use_planets = True
if "AbsPhase" not in modelin.components:
log.error(
"TimingModel does not include AbsPhase component, which is required "
"for computing phases. Make sure you have TZR* parameters in your par file!"
)
raise ValueError("Model missing AbsPhase component.")
if args.addorbphase and (not hasattr(modelin, "binary_model_name")):
log.error(
"TimingModel does not include a binary model, which is required for "
"computing orbital phases. Make sure you have BINARY and associated "
"model parameters in your par file!")
raise ValueError("Model missing BINARY component.")
# Use polycos to calculate pulse phases
if args.polycos:
log.info("Using polycos to get pulse phases.")
if args.addorbphase:
raise ValueError("Cannot use orbphase with polycos.")
# Polycos parameters
segLength = 120 # in minutes
ncoeff = 10
obsfreq = 0
# Open event file and get start and end mjds
hdulist = pyfits.open(args.eventfile)
data = hdulist[1].data
mjds = read_fits_event_mjds(hdulist[1])
minmjd = min(mjds)
maxmjd = max(mjds)
# Check if event file is barycentered
if hdulist[1].header["TIMESYS"] != "TDB":
raise ValueError(
"The event file has not been barycentered. Polycos can only be used with barycentered data."
)
# Create polycos table
log.debug("Generating polycos")
telescope_n = "@"
p = polycos.Polycos()
ptable = p.generate_polycos(modelin, minmjd, maxmjd, telescope_n,
segLength, ncoeff, obsfreq)
# Calculate phases
log.debug("Evaluating polycos")
phases = p.eval_phase(mjds)
phases[phases < 0] += 1.0
h = float(hm(phases))
print("Htest : {0:.2f} ({1:.2f} sigma)".format(h, h2sig(h)))
else: # Normal mode, not polycos
ts = toa.get_TOAs_list(
tl,
ephem=args.ephem,
include_bipm=args.use_bipm,
include_gps=args.use_gps,
planets=use_planets,
tdb_method=args.tdbmethod,
)
ts.filename = args.eventfile
# if args.fix:
# ts.adjust_TOAs(TimeDelta(np.ones(len(ts.table))*-1.0*u.s,scale='tt'))
print(ts.get_summary())
mjds = ts.get_mjds()
print(mjds.min(), mjds.max())
# Compute model phase for each TOA
iphss, phss = modelin.phase(ts, abs_phase=True)
phases = phss.value % 1
h = float(hm(phases))
print("Htest : {0:.2f} ({1:.2f} sigma)".format(h, h2sig(h)))
if args.plot:
phaseogram_binned(mjds, phases, bins=100, plotfile=args.plotfile)
# Compute orbital phases for each photon TOA
if args.addorbphase:
delay = modelin.delay(ts)
orbits = modelin.binary_instance.orbits()
# These lines are already in orbits.orbit_phase() in binary_orbits.py.
# What is the correct syntax is to call this function here?
norbits = np.array(np.floor(orbits), dtype=int)
orbphases = orbits - norbits # fractional phase
if args.addphase or args.addorbphase:
# Read input FITS file (again).
# If overwriting, open in 'update' mode
if args.outfile is None:
hdulist = pyfits.open(args.eventfile, mode="update")
else:
hdulist = pyfits.open(args.eventfile)
datacol = []
data_to_add = {}
# Handle case where minMJD/maxMJD do not exceed length of events
mjds_float = read_fits_event_mjds(hdulist[1])
time_mask = np.logical_and((mjds_float > minmjd),
(mjds_float < maxmjd))
if args.polycos:
time_mask = np.logical_and((mjds_float >= minmjd),
(mjds_float <= maxmjd))
if args.addphase:
if time_mask.sum() != len(phases):
raise RuntimeError(
"Mismatch between data selection {0} and length of phase array ({1})!"
.format(time_mask.sum(), len(phases)))
data_to_add["PULSE_PHASE"] = [phases, "D"]
if args.absphase:
data_to_add["ABS_PHASE"] = [iphss, "K"]
if args.barytime:
bats = modelin.get_barycentric_toas(ts)
data_to_add["BARY_TIME"] = [bats, "D"]
if args.addorbphase:
if time_mask.sum() != len(orbphases):
raise RuntimeError(
"Mismatch between data selection ({0}) and length of orbital phase array ({1})!"
.format(time_mask.sum(), len(orbphases)))
data_to_add["ORBIT_PHASE"] = [orbphases, "D"]
# End if args.addorbphase
for key in data_to_add.keys():
if key in hdulist[1].columns.names:
log.info("Found existing %s column, overwriting..." % key)
# Overwrite values in existing Column
hdulist[1].data[key][time_mask] = data_to_add[key][0]
else:
# Construct and append new column, preserving HDU header and name
log.info("Adding new %s column." % key)
new_dat = np.full(time_mask.shape,
-1,
dtype=data_to_add[key][0].dtype)
new_dat[time_mask] = data_to_add[key][0]
datacol.append(
pyfits.ColDefs([
pyfits.Column(name=key,
format=data_to_add[key][1],
array=new_dat)
]))
if len(datacol) > 0:
cols = hdulist[1].columns
for c in datacol:
cols = cols + c
bt = pyfits.BinTableHDU.from_columns(cols,
header=hdulist[1].header,
name=hdulist[1].name)
hdulist[1] = bt
if args.outfile is None:
# Overwrite the existing file
log.info("Overwriting existing FITS file " + args.eventfile)
hdulist.flush(verbose=True, output_verify="warn")
else:
# Write to new output file
log.info("Writing output FITS file " + args.outfile)
hdulist.writeto(args.outfile,
overwrite=True,
checksum=True,
output_verify="warn")
def pulse_profile(ax, etable, args):
if (args.orb is None) or (args.par is None):
log.warning("You did not specify orbfile or parfile")
log.info("Please input files for orb and par with --orb and --par")
return
import pint
import astropy.io.fits as pyfits
from astropy.time import TimeDelta
import pint.toa, pint.models
from pint.plot_utils import phaseogram_binned
from pint.observatory.satellite_obs import get_satellite_observatory
from pint.eventstats import hm
### Make arguments for parfile and orbfile and only do this if both are present
log.info("Event file TELESCOPE = {0}, INSTRUMENT = {1}".format(
etable.meta["TELESCOP"], etable.meta["INSTRUME"]))
# Instantiate NICERObs once so it gets added to the observatory registry
log.info("Setting up NICER observatory")
get_satellite_observatory("NICER", args.orb)
log.info("Reading model from PARFILE")
# Load PINT model objects
modelin = pint.models.get_model(args.par)
log.info(str(modelin))
# Read event file and return list of TOA objects
log.info("doing the load_toas thing")
# tl = load_NICER_TOAs(pulsefilename[0])
# Create TOA list
tl = []
for t in etable["T"]:
tl.append(pint.toa.TOA(t, obs="NICER"))
planets = False
if "PLANET_SHAPIRO" in modelin.params:
if modelin.PLANET_SHAPIRO.value:
planets = True
ts = pint.toa.get_TOAs_list(tl,
planets=planets,
include_bipm=False,
include_gps=False)
# No longer needed, since Feb 28 reprocessing
# log.warning('Applying -1.0s time correction to event time TOAs for pulse phase plot')
# ts.adjust_TOAs(TimeDelta(np.ones(len(ts.table))*-1.0*u.s,scale='tt'))
# Note: adjust_TOAs recomputes TDBs and posvels so no need to do again.
# ts.compute_TDBs()
# ts.compute_posvels(ephem='DE421',planets=True)
# Compute phases
phss = modelin.phase(ts, abs_phase=True)[1]
# Strip the units, because PINT may return u.cycle
phss = np.array(phss)
# ensure all postive
phases = np.where(phss < 0.0, phss + 1.0, phss)
mjds = ts.get_mjds()
h = hm(phases)
if not np.isfinite(h):
log.error("H not finite, using {0} phases!".format(len(phases)))
print("Phases from {0} to {1}\n".format(h.min(), h.max()))
else:
log.info("H = {0} from {1} phases".format(h, len(phases)))
ax.hist(phases, bins=32)
ax.text(0.1, 0.1, "H = {0:.2f}".format(h), transform=ax.transAxes)
# np.savetxt('{0}.phases'.format(args.basename),np.transpose([etable['MET'], etable['PI'],phases]))
plot.ylabel("Counts")
plot.xlabel("Pulse Phase")
plot.title("Pulse Profile")
return
def main(argv=None):
parser = argparse.ArgumentParser(
description=
"PINT tool for MCMC optimization of timing models using event data from multiple sources."
)
parser.add_argument("eventfiles",
help="Specify a file listing all event files")
parser.add_argument("parfile", help="par file to read model from")
parser.add_argument("--ft2", help="Path to FT2 file.", default=None)
parser.add_argument("--nwalkers",
help="Number of MCMC walkers (def 200)",
type=int,
default=200)
parser.add_argument(
"--burnin",
help="Number of MCMC steps for burn in (def 100)",
type=int,
default=100,
)
parser.add_argument(
"--nsteps",
help="Number of MCMC steps to compute (def 1000)",
type=int,
default=1000,
)
parser.add_argument("--minMJD",
help="Earliest MJD to use (def 54680)",
type=float,
default=54680.0)
parser.add_argument("--maxMJD",
help="Latest MJD to use (def 57250)",
type=float,
default=57250.0)
parser.add_argument("--phs",
help="Starting phase offset [0-1] (def is to measure)",
type=float)
parser.add_argument("--phserr",
help="Error on starting phase",
type=float,
default=0.03)
parser.add_argument(
"--minWeight",
help="Minimum weight to include (def 0.05)",
type=float,
default=0.05,
)
parser.add_argument(
"--wgtexp",
help=
"Raise computed weights to this power (or 0.0 to disable any rescaling of weights)",
type=float,
default=0.0,
)
parser.add_argument(
"--testWeights",
help="Make plots to evalute weight cuts?",
default=False,
action="store_true",
)
parser.add_argument(
"--initerrfact",
help=
"Multiply par file errors by this factor when initializing walker starting values",
type=float,
default=0.1,
)
parser.add_argument(
"--priorerrfact",
help=
"Multiple par file errors by this factor when setting gaussian prior widths",
type=float,
default=10.0,
)
parser.add_argument(
"--samples",
help="Pickle file containing samples from a previous run",
default=None,
)
global nwalkers, nsteps, ftr
args = parser.parse_args(argv)
parfile = args.parfile
if args.ft2 is not None:
# Instantiate Fermi observatory once so it gets added to the observatory registry
get_satellite_observatory("Fermi", args.ft2)
nwalkers = args.nwalkers
burnin = args.burnin
nsteps = args.nsteps
if burnin >= nsteps:
log.error("burnin must be < nsteps")
sys.exit(1)
nbins = 256 # For likelihood calculation based on gaussians file
outprof_nbins = 256 # in the text file, for pygaussfit.py, for instance
minMJD = args.minMJD
maxMJD = args.maxMJD # Usually set by coverage of IERS file
minWeight = args.minWeight
wgtexp = args.wgtexp
# Read in initial model
modelin = pint.models.get_model(parfile)
# Set the target coords for automatic weighting if necessary
if "ELONG" in modelin.params:
tc = SkyCoord(
modelin.ELONG.quantity,
modelin.ELAT.quantity,
frame="barycentrictrueecliptic",
)
else:
tc = SkyCoord(modelin.RAJ.quantity,
modelin.DECJ.quantity,
frame="icrs")
eventinfo = load_eventfiles(args.eventfiles,
tcoords=tc,
minweight=minWeight,
minMJD=minMJD,
maxMJD=maxMJD)
nsets = len(eventinfo["toas"])
log.info("Total number of events:\t%d" %
np.array([len(t.table) for t in eventinfo["toas"]]).sum())
log.info("Total number of datasets:\t%d" % nsets)
funcs = {"prob": lnlikelihood_prob, "resid": lnlikelihood_resid}
lnlike_funcs = [None] * nsets
wlist = [None] * nsets
gtemplates = [None] * nsets
# Loop over all TOA sets
for i in range(nsets):
# Determine lnlikelihood function for this set
try:
lnlike_funcs[i] = funcs[eventinfo["lnlikes"][i]]
except:
raise ValueError("%s is not a recognized function" %
eventinfo["lnlikes"][i])
# Load in weights
ts = eventinfo["toas"][i]
if eventinfo["weightcol"][i] is not None:
if eventinfo["weightcol"][i] == "CALC":
weights = np.asarray([x["weight"] for x in ts.table["flags"]])
log.info(
"Original weights have min / max weights %.3f / %.3f" %
(weights.min(), weights.max()))
# Rescale the weights, if requested (by having wgtexp != 0.0)
if wgtexp != 0.0:
weights **= wgtexp
wmx, wmn = weights.max(), weights.min()
# make the highest weight = 1, but keep min weight the same
weights = wmn + ((weights - wmn) * (1.0 - wmn) /
(wmx - wmn))
for ii, x in enumerate(ts.table["flags"]):
x["weight"] = weights[ii]
weights = np.asarray([x["weight"] for x in ts.table["flags"]])
log.info(
"There are %d events, with min / max weights %.3f / %.3f" %
(len(weights), weights.min(), weights.max()))
else:
weights = None
log.info("There are %d events, no weights are being used." %
ts.ntoas)
wlist[i] = weights
# Load in templates
tname = eventinfo["templates"][i]
if tname == "none":
continue
if tname[-6:] == "pickle" or tname == "analytic":
# Analytic template
try:
gtemplate = cPickle.load(file(tname))
except:
phases = (modelin.phase(ts)[1].value).astype(np.float64) % 1
gtemplate = lctemplate.get_gauss2()
lcf = lcfitters.LCFitter(gtemplate, phases, weights=wlist[i])
lcf.fit(unbinned=False)
cPickle.dump(
gtemplate,
file("%s_template%d.pickle" % (jname, i), "wb"),
protocol=2,
)
phases = (modelin.phase(ts)[1].value).astype(np.float64) % 1
lcf = lcfitters.LCFitter(gtemplate,
phases,
weights=wlist[i],
binned_bins=200)
lcf.fit_position(unbinned=False)
lcf.fit(overall_position_first=True,
estimate_errors=False,
unbinned=False)
for prim in lcf.template:
prim.free[:] = False
lcf.template.norms.free[:] = False
else:
# Binned template
gtemplate = read_gaussfitfile(tname, nbins)
gtemplate /= gtemplate.mean()
gtemplates[i] = gtemplate
# Set the priors on the parameters in the model, before
# instantiating the emcee_fitter
# Currently, this adds a gaussian prior on each parameter
# with width equal to the par file uncertainty * priorerrfact,
# and then puts in some special cases.
# *** This should be replaced/supplemented with a way to specify
# more general priors on parameters that need certain bounds
phs = 0.0 if args.phs is None else args.phs
sampler = EmceeSampler(nwalkers)
ftr = CompositeMCMCFitter(
eventinfo["toas"],
modelin,
sampler,
lnlike_funcs,
templates=gtemplates,
weights=wlist,
phs=phs,
phserr=args.phserr,
minMJD=minMJD,
maxMJD=maxMJD,
)
fitkeys, fitvals, fiterrs = ftr.get_fit_keyvals()
# Use this if you want to see the effect of setting minWeight
if args.testWeights:
log.info("Checking H-test vs weights")
ftr.prof_vs_weights(use_weights=True)
ftr.prof_vs_weights(use_weights=False)
sys.exit()
ftr.phaseogram(plotfile=ftr.model.PSR.value + "_pre.png")
like_start = ftr.lnlikelihood(ftr, ftr.get_parameters())
log.info("Starting Pulse Likelihood:\t%f" % like_start)
# Set up the initial conditions for the emcee walkers
ndim = ftr.n_fit_params
if args.samples is None:
pos = None
else:
chains = cPickle.load(file(args.samples))
chains = np.reshape(chains, [nwalkers, -1, ndim])
pos = chains[:, -1, :]
ftr.fit_toas(nsteps,
pos=pos,
priorerrfact=args.priorerrfact,
errfact=args.initerrfact)
def plot_chains(chain_dict, file=False):
npts = len(chain_dict)
fig, axes = plt.subplots(npts, 1, sharex=True, figsize=(8, 9))
for ii, name in enumerate(chain_dict.keys()):
axes[ii].plot(chain_dict[name], color="k", alpha=0.3)
axes[ii].set_ylabel(name)
axes[npts - 1].set_xlabel("Step Number")
fig.tight_layout()
if file:
fig.savefig(file)
plt.close()
else:
plt.show()
plt.close()
chains = sampler.chains_to_dict(ftr.fitkeys)
plot_chains(chains, file=ftr.model.PSR.value + "_chains.png")
# Make the triangle plot.
samples = sampler.sampler.chain[:, burnin:, :].reshape(
(-1, ftr.n_fit_params))
try:
import corner
fig = corner.corner(
samples,
labels=ftr.fitkeys,
bins=50,
truths=ftr.maxpost_fitvals,
plot_contours=True,
)
fig.savefig(ftr.model.PSR.value + "_triangle.png")
plt.close()
except ImportError:
pass
# Make a phaseogram with the 50th percentile values
# ftr.set_params(dict(zip(ftr.fitkeys, np.percentile(samples, 50, axis=0))))
# Make a phaseogram with the best MCMC result
ftr.set_parameters(ftr.maxpost_fitvals)
ftr.phaseogram(plotfile=ftr.model.PSR.value + "_post.png")
plt.close()
# Write out the par file for the best MCMC parameter est
f = open(ftr.model.PSR.value + "_post.par", "w")
f.write(ftr.model.as_parfile())
f.close()
# Print the best MCMC values and ranges
ranges = map(
lambda v: (v[1], v[2] - v[1], v[1] - v[0]),
zip(*np.percentile(samples, [16, 50, 84], axis=0)),
)
log.info("Post-MCMC values (50th percentile +/- (16th/84th percentile):")
for name, vals in zip(ftr.fitkeys, ranges):
log.info("%8s:" % name + "%25.15g (+ %12.5g / - %12.5g)" % vals)
# Put the same stuff in a file
f = open(ftr.model.PSR.value + "_results.txt", "w")
f.write("Post-MCMC values (50th percentile +/- (16th/84th percentile):\n")
for name, vals in zip(ftr.fitkeys, ranges):
f.write("%8s:" % name + " %25.15g (+ %12.5g / - %12.5g)\n" % vals)
f.write("\nMaximum likelihood par file:\n")
f.write(ftr.model.as_parfile())
f.close()
import cPickle
cPickle.dump(samples, open(ftr.model.PSR.value + "_samples.pickle", "wb"))
