def test_simple_fit_binned():
"""Make sure objects adequately implement mathematical intent."""
lct = lctemplate.get_gauss2()
# load in simulated phases
ph = np.loadtxt(datadir + "/template_phases.asc")
lcf = lcfitters.LCFitter(lct, ph)
lcf.fit(unbinned=False, estimate_errors=True)
expected_val = r"""
Log Likelihood for fit: 1080.31
Mixture Amplitudes
------------------
P1 : 0.5840 +\- 0.0220
P2 : 0.4160 +\- 0.0220
DC : 0.0000 +\- 0.0000
P1 -- Gaussian
------------------
Width : 0.0106 +\- 0.0004
Location: 0.1007 +\- 0.0006
P2 -- Gaussian
------------------
Width : 0.0213 +\- 0.0010
Location: 0.5493 +\- 0.0015
delta : 0.1007 +\- 0.0006
Delta : 0.4486 +\- 0.0016
"""
assert expected_val.strip() == str(lcf).strip()
def get_TOA_accuracy(phases):
# Given some subset of the event times, phases, and weights, compute
# the TOA based on a reference event near the middle of the span.
# Build the TOA as a PINT TOA() object
lcf = lcfitters.LCFitter(template, phases)
if args.fitbg:
for i in xrange(2):
lcf.fit_position(unbinned=False)
lcf.fit_background(unbinned=False)
dphi, dphierr = lcf.fit_position(unbinned=args.unbinned)
#print("The TOA error is: {}".format(dphierr/fbary))
return (dphierr / fbary)
def estimate_toa(mjds, phases, tdbs):
""" Return a pint TOA object for the provided times and phases."""
# Given some subset of the event times, phases, and weights, compute
# the TOA based on a reference event near the middle of the span.
# Build the TOA as a PINT TOA() object
lcf = lcfitters.LCFitter(template, phases)
if args.fitbg:
for i in xrange(2):
lcf.fit_position(unbinned=False)
lcf.fit_background(unbinned=False)
dphi, dphierr = lcf.fit_position(unbinned=args.unbinned)
log.info('Measured phase shift dphi={0}, dphierr={1}'.format(
dphi, dphierr))
# find MJD closest to center of observation and turn it into a TOA
argmid = np.searchsorted(mjds, 0.5 * (mjds.min() + mjds.max()))
tmid = tdbs[argmid]
tplus = tmid + TimeDelta(1 * u.s, scale='tdb')
toamid = pint.toa.TOA(tmid)
toaplus = pint.toa.TOA(tplus)
toas = pint.toa.TOAs(toalist=[toamid, toaplus])
toas.compute_TDBs()
toas.compute_posvels(ephem=args.ephem, planets=planets)
phsi, phsf = modelin.phase(toas.table)
fbary = (phsi[1] - phsi[0]) + (phsf[1] - phsf[0])
fbary._unit = u.Hz
# First delta is to get time of phase 0.0 of initial model
# Second term corrects for the measured phase offset to align with template
print("printing dphi: {}".format(dphi))
print("printing fbary: {}".format(fbary))
print("printing TimeDelta(dphi/fbary,scale='tdb'): {}".format(
TimeDelta(dphi / fbary, scale='tdb')))
tfinal = tmid + TimeDelta(-phsf[0].value / fbary, scale='tdb') + TimeDelta(
dphi / fbary, scale='tdb')
print("printing tfinal from trial5_uncertainty.py: {}".format(tfinal))
# Use PINT's TOA writer to save the TOA
nsrc = lcf.template.norm() * len(lcf.phases)
nbkg = (1 - lcf.template.norm()) * len(lcf.phases)
toafinal = pint.toa.TOA(tfinal,
nsrc='%.2f' % nsrc,
nbkg='%.2f' % nbkg,
exposure='%.2f' % exposure,
dphi='%.5f' % dphi)
log.info("Src rate = {0} c/s, Bkg rate = {1} c/s".format(
nsrc / exposure, nbkg / exposure))
print("dphierr = {0}, fbary = {1}".format(dphierr, fbary))
return toafinal, dphierr / fbary * 1e6
def estimate_toa(mjds, phases, tdbs, topo, obs):
""" Return a pint TOA object for the provided times and phases."""
# Given some subset of the event times, phases, and weights, compute
# the TOA based on a reference event near the middle of the span.
# Build the TOA as a PINT TOA() object
lcf = lcfitters.LCFitter(deepcopy(template), phases)
# fitbg does not work! Disabling.
# if args.fitbg:
# for i in xrange(2):
# lcf.fit_position(unbinned=False)
# lcf.fit_background(unbinned=False)
dphi, dphierr = lcf.fit_position(unbinned=args.unbinned)
log.info('Measured phase shift dphi={0}, dphierr={1}'.format(
dphi, dphierr))
# find MJD closest to center of observation and turn it into a TOA
argmid = np.searchsorted(mjds, 0.5 * (mjds.min() + mjds.max()))
tmid = tdbs[argmid] # Should we used tdbld?
if topo: #tdbs are topocentric TT MJD times
tplus = tmid + TimeDelta(1 * u.s, scale='tt')
toamid = pint.toa.TOA(tmid, obs=obs.name)
toaplus = pint.toa.TOA(tplus, obs=obs.name)
else: #tdbs are TDB MJD times
tplus = tmid + TimeDelta(1 * u.s, scale='tdb')
toamid = pint.toa.TOA(tmid)
toaplus = pint.toa.TOA(tplus)
toas = pint.toa.get_TOAs_list([toamid, toaplus],
include_gps=args.use_gps,
include_bipm=args.use_bipm,
ephem=args.ephem,
planets=planets)
phsi, phsf = modelin.phase(toas, abs_phase=True)
if topo:
sc = 'tt'
else:
sc = 'tdb'
# Compute frequency = d(phase)/dt
f = (phsi[1] - phsi[0]) + (phsf[1] - phsf[0])
f._unit = u.Hz
# First delta is to get time of phase 0.0 of initial model
# Second term corrects for the measured phase offset to align with template
tfinal = tmid + TimeDelta(-phsf[0].value / f, scale=sc) + TimeDelta(
dphi / f, scale=sc)
# Use PINT's TOA writer to save the TOA
nsrc = lcf.template.norm() * len(lcf.phases)
nbkg = (1 - lcf.template.norm()) * len(lcf.phases)
if args.topo: #tfinal is a topocentric TT MJD
telposvel = obs.posvel_gcrs(tfinal)
x = telposvel.pos[0].to(u.km)
y = telposvel.pos[1].to(u.km)
z = telposvel.pos[2].to(u.km)
vx = telposvel.vel[0].to(u.km / u.s)
vy = telposvel.vel[1].to(u.km / u.s)
vz = telposvel.vel[2].to(u.km / u.s)
toafinal = pint.toa.TOA(tfinal.utc,
scale='utc',
obs='spacecraft',
nsrc='%.2f' % nsrc,
nbkg='%.2f' % nbkg,
exposure='%.2f' % exposure,
dphi='%.5f' % dphi,
mjdTT='%.8f' % tfinal.tt.mjd,
telx='%.8f' % x.value,
tely='%.8f' % y.value,
telz='%.8f' % z.value,
vx='%.8f' % vx.value,
vy='%.8f' % vy.value,
vz='%.8f' % vz.value)
else:
toafinal = pint.toa.TOA(tfinal,
nsrc='%.2f' % nsrc,
nbkg='%.2f' % nbkg,
exposure='%.2f' % exposure,
dphi='%.5f' % dphi)
log.info("Src rate = {0} c/s, Bkg rate = {1} c/s".format(
nsrc / exposure, nbkg / exposure))
return toafinal, dphierr / f.value * 1.e6
def estimate_toa(mjds, phases, ph_times, topo, obs, modelin, tmid=None):
""" Return a pint TOA object for the provided times and phases.
Longer description here.
Parameters
----------
mjds : array of floats
The MJD times of each photon. These are for sorting the TOAs into
groups and making plots, not for precision work! The timescale
may be different for different datasets (see pint.toa.get_mjds)
phases : array
Array of model-computed phase values for each photon. Should be floats
between 0.0 and 1.0
ph_times : array of astropy.Time objects
Array of photon times, as recorded at Observatory obs
If obs=="Barycenter" then these should be BAT times in the TDB timescale
with the Roemer delays removed (the usual sense of "barycentered" times)
topo : bool
If True, then TOA will be computed for the arrival time at the Spacecraft
and the TOA line will have the spacecraft ECI position included.
If False, then the TOA will be a Barycentric Arrival Time (BAT)
obs : pint.observatory.Observatory
The observatory corresponding to the photon event times.
This is NOT necessarily the observatory for the output TOAs,
which can be the Barycenter.
tmid : Time (default=None)
Fiducial time for TOA. If None, then use photon time closest to midpoint.
Should be at observatory if topo, else should be a BAT
"""
# Given some subset of the event times, phases, and weights, compute
# the TOA based on a reference event near the middle of the span.
# Build the TOA as a PINT TOA() object
lcf = lcfitters.LCFitter(deepcopy(template), phases)
# fitbg does not work! Disabling.
# if args.fitbg:
# for i in xrange(2):
# lcf.fit_position(unbinned=False)
# lcf.fit_background(unbinned=False)
dphi, dphierr = lcf.fit_position(unbinned=args.unbinned, track=args.track)
log.info("Measured phase shift dphi={0}, dphierr={1}".format(
dphi, dphierr))
# find time of event closest to center of observation and turn it into a TOA
argmid = np.searchsorted(mjds, 0.5 * (mjds.min() + mjds.max()))
if tmid is None:
tmid = ph_times[argmid]
# So, tmid should be a time at the observatory if topo, otherwise
# it should be a BAT (in TDB timescale with delays applied)
# Here, convert tmid if not topo and data not barycentered
if topo:
tplus = tmid + TimeDelta(1 * u.s, scale=tmid.scale)
toamid = pint.toa.TOA(tmid, obs=obs.name)
toaplus = pint.toa.TOA(tplus, obs=obs.name)
else:
# If input data were not barycentered but we want barycentric TOAs
# then make TMID into a BAT
if tmid.scale not in ("tdb", "tcb"):
log.debug("Making TOA, tmid {}, tmid.scale {}, obs {}".format(
tmid, tmid.scale, obs.name))
toas = pint.toa.get_TOAs_list(
[pint.toa.TOA(tmid, obs=obs.name)],
include_gps=args.use_gps,
include_bipm=args.use_bipm,
ephem=args.ephem,
planets=planets,
)
tmid = Time(modelin.get_barycentric_toas(toas),
format="mjd",
scale="tdb")[0]
log.debug("New tmid {}, tmid.scale {}".format(tmid, tmid.scale))
tplus = tmid + TimeDelta(1 * u.s, scale=tmid.scale)
toamid = pint.toa.TOA(tmid, obs="Barycenter")
toaplus = pint.toa.TOA(tplus, obs="Barycenter")
toas = pint.toa.get_TOAs_list(
[toamid, toaplus],
include_gps=args.use_gps,
include_bipm=args.use_bipm,
ephem=args.ephem,
planets=planets,
)
phsi, phsf = modelin.phase(toas, abs_phase=True)
if topo:
sc = "tt"
else:
sc = "tdb"
# Compute frequency = d(phase)/dt
f = (phsi[1] - phsi[0]) + (phsf[1] - phsf[0])
f._unit = u.Hz
# First delta is to get time of phase 0.0 of initial model
# Second term corrects for the measured phase offset to align with template
tfinal = (tmid + TimeDelta(-phsf[0].value / f, scale=sc) +
TimeDelta(dphi / f, scale=sc))
# Use PINT's TOA writer to save the TOA
nsrc = lcf.template.norm() * len(lcf.phases)
nbkg = (1 - lcf.template.norm()) * len(lcf.phases)
if args.topo: # tfinal is a topocentric TT MJD
telposvel = obs.posvel_gcrs(tfinal)
x = telposvel.pos[0].to(u.km)
y = telposvel.pos[1].to(u.km)
z = telposvel.pos[2].to(u.km)
vx = telposvel.vel[0].to(u.km / u.s)
vy = telposvel.vel[1].to(u.km / u.s)
vz = telposvel.vel[2].to(u.km / u.s)
toafinal = pint.toa.TOA(
tfinal.utc,
obs="spacecraft",
nsrc="%.2f" % nsrc,
nbkg="%.2f" % nbkg,
exposure="%.2f" % exposure,
dphi="%.5f" % dphi,
mjdTT="%.8f" % tfinal.tt.mjd,
telx="%.8f" % x.value,
tely="%.8f" % y.value,
telz="%.8f" % z.value,
vx="%.8f" % vx.value,
vy="%.8f" % vy.value,
vz="%.8f" % vz.value,
)
else:
# Make a TOA for the Barycenter, which is the default obs
toafinal = pint.toa.TOA(
tfinal,
obs="Barycenter",
nsrc="%.2f" % nsrc,
nbkg="%.2f" % nbkg,
exposure="%.2f" % exposure,
dphi="%.5f" % dphi,
)
toasfinal = pint.toa.get_TOAs_list(
[toafinal],
include_gps=args.use_gps,
include_bipm=args.use_bipm,
ephem=args.ephem,
planets=planets,
)
log.debug("Modelin final phase {}".format(
modelin.phase(toasfinal, abs_phase=True)))
log.info("Src rate = {0} c/s, Bkg rate = {1} c/s".format(
nsrc / exposure, nbkg / exposure))
return toafinal, dphierr / f.value * 1.0e6
log.info("Template properties: \n{0}".format(str(template)))
# load up events and exposure information
f = pyfits.open(args.eventname)
phases = f[1].data.field(args.phasecol)
try:
exposure = f[1].header['exposure']
except:
exposure = 0
h = float(hm(phases))
log.info("Htest : {0:.2f} ({1:.2f} sigma)".format(h, h2sig(h)))
# make sure template shape is fixed
lcf = lcfitters.LCFitter(template, phases)
for prim in lcf.template.primitives:
prim.free[:] = False
# do iterative fit of position and background
for i in xrange(2):
lcf.fit_position(unbinned=False)
lcf.fit_background(unbinned=False)
# get exposure information
try:
f = pyfits.open(args.eventname)
f.close()
except:
exposure = 0