def test_broken_parameter_line_fit():
broken_line1 = "\nPMELONG 3 SC 0.8"
broken1 = base_par + broken_line1
with pytest.raises(ValueError,
match="Unidentified string 'SC' in parfile "
"line PMELONG 3 SC 0.8"):
get_model(StringIO(broken1))
def setUpClass(cls):
os.chdir(datadir)
# This uses ELONG and ELAT
cls.m1 = mb.get_model("B1855+09_NANOGrav_9yv1.gls.par")
# This uses RA and DEC
cls.m2 = mb.get_model("B1855+09_NANOGrav_dfg+12_TAI_FB90.par")
cls.t = 5000 * np.random.randn(100) + 49453.0
def setUpClass(self):
os.chdir(datadir)
# This uses ELONG and ELAT
self.m1 = mb.get_model('B1855+09_NANOGrav_9yv1.gls.par')
# This uses RA and DEC
self.m2 = mb.get_model('B1855+09_NANOGrav_dfg+12_TAI_FB90.par')
self.t = 5000 * np.random.randn(100) + 49453.0
def test_valid_model(tmp_dir, name, expectation):
"""Check handling of bogus binary models.
Note that ``get_model_new`` currently reports different errors
from the old ``get_model``.
"""
fn = join(tmp_dir, "file.par")
with open(fn, "w") as f:
f.write(par_template.format(name))
with expectation:
get_model(f.name)
def setUpClass(cls):
# J0613 is in equatorial
cls.parfileJ0613 = os.path.join(
datadir, "J0613-0200_NANOGrav_dfg+12_TAI_FB90.par")
cls.modelJ0613 = mb.get_model(cls.parfileJ0613)
# B1855+09 is in ecliptic
cls.parfileB1855 = os.path.join(datadir,
"B1855+09_NANOGrav_9yv1.gls.par")
cls.modelB1855 = mb.get_model(cls.parfileB1855)
cls.log = logging.getLogger("TestGalactic")
def test_get_model_roundtrip(tmp_dir, parfile):
if basename(parfile) in bad_trouble:
pytest.skip("This parfile is unclear")
try:
m_old = get_model(parfile)
except (ValueError, IOError, MissingParameter) as e:
pytest.skip("Existing code raised an exception {}".format(e))
fn = join(tmp_dir, "file.par")
with open(fn, "w") as f:
f.write(m_old.as_parfile())
m_roundtrip = get_model(fn)
assert set(m_roundtrip.get_params_mapping().keys()) == set(
m_old.get_params_mapping().keys())
assert set(m_roundtrip.components.keys()) == set(m_old.components.keys())
def setUpClass(cls):
os.chdir(datadir)
cls.par = "B1855+09_NANOGrav_dfg+12_TAI_FB90.par"
cls.tim = "B1855+09_NANOGrav_dfg+12.tim"
cls.m = get_model(cls.par)
cls.t = toa.get_TOAs(cls.tim, ephem="DE405")
cls.f = WLSFitter(cls.t, cls.m)
# set perturb parameter step
cls.per_param = {
"A1": 1e-05,
"DECJ": 1e-06,
"DMX_0003": 120,
"ECC": 0.2,
"F0": 1e-12,
"F1": 0.001,
"JUMP3": 10.0,
"M2": 10.0,
"OM": 1e-06,
"PB": 1e-08,
"PMDEC": 0.1,
"PMRA": 0.1,
"PX": 100,
"RAJ": 1e-08,
"SINI": -0.004075,
"T0": 1e-10,
}
def setUpClass(self):
self.parfileB1855 = 'B1855+09_NANOGrav_dfg+12_modified.par'
self.timB1855 = 'B1855+09_NANOGrav_dfg+12.tim'
self.toasB1855 = toa.get_TOAs(self.timB1855, ephem="DE405", planets=False)
self.modelB1855 = mb.get_model(self.parfileB1855)
self.psrB1855 = lt.tempopulsar(self.parfileB1855, self.timB1855)
self.ltres = self.psrB1855.residuals()
def test_ecorr_average():
par = os.path.join(datadir, "J0023+0923_NANOGrav_11yv0.gls.par")
tim = os.path.join(datadir, "J0023+0923_NANOGrav_11yv0.tim")
m = mb.get_model(par)
t = toa.get_TOAs(tim, ephem="DE436")
f = GLSFitter(t, m)
# Get comparison resids and uncertainties
mjd, freq, res, err, ophase, chi2, info = np.genfromtxt(par + ".resavg",
unpack=True)
resavg_mjd = mjd * u.d
# resavg_freq = freq * u.MHz
resavg_res = res * u.us
resavg_err = err * u.us
# resavg_chi2 = chi2
f.fit_toas()
avg = f.resids.ecorr_average()
# The comparison data always come out time-sorted
# so we need to sort here.
ii = np.argsort(avg["mjds"])
mjd_diff = avg["mjds"][ii] - resavg_mjd
res_diff = avg["time_resids"][ii] - resavg_res
err_ratio = avg["errors"][ii] / resavg_err
assert np.abs(mjd_diff).max() < 1e-9 * u.d
assert np.abs(res_diff).max() < 7 * u.ns
assert np.abs(err_ratio - 1.0).max() < 5e-4
def setUpClass(self):
self.parf = 'B1855+09_NANOGrav_dfg+12_TAI.par'
self.timf = 'B1855+09_NANOGrav_dfg+12.tim'
self.JUMPm = mb.get_model(self.parf)
self.toas = toa.get_TOAs(self.timf, ephem="DE405", planets=False)
# libstempo calculation
self.ltres = np.genfromtxt(self.parf + '.tempo_test', unpack=True, names=True, dtype='float128')
def test_ECL_to_ICRS_uncertainties():
# start with ECL model, fit with both models
# compare parameter values and uncertainties
model_ECL = get_model(io.StringIO(modelstring_ECL))
toas = pint.simulation.make_fake_toas_uniform(MJDStart,
MJDStop,
NTOA,
model=model_ECL,
error=1 * u.us,
add_noise=True)
fit_ECL = WLSFitter(toas, model_ECL)
fit_ICRS = WLSFitter(toas, model_ECL.as_ICRS())
fit_ECL.fit_toas()
fit_ICRS.fit_toas()
m1 = fit_ECL.model
m2 = fit_ICRS.model.as_ECL()
for p in ("ELONG", "ELAT", "PMELONG", "PMELAT"):
assert np.isclose(m1.__getitem__(p).value, m2.__getitem__(p).value)
# do a generous test here since the uncertainties could change
assert np.isclose(m1.__getitem__(p).uncertainty,
m2.__getitem__(p).uncertainty,
rtol=0.5)
def setUpClass(self):
self.parf = 'test_FD.par'
self.timf = 'test_FD.simulate.pint_corrected'
self.FDm = mb.get_model(self.parf)
self.toas = toa.get_TOAs(self.timf)
# libstempo result
self.ltres, self.ltbindelay = np.genfromtxt(self.parf + '.tempo_test', unpack=True)
def test_mix_alise():
mixed_par = base_par + "\nEQUAD -fe 430 1\nT2EQUAD -fe guppi 2"
m = get_model(StringIO(mixed_par), allow_name_mixing=True)
assert hasattr(m, "EQUAD2")
assert m.EQUAD2.value == 2
assert m.EQUAD2.key == "-fe"
assert m.EQUAD2.key_value == ["guppi"]
def test_residuals(self):
model = mb.get_model(self.parfile)
toas = toa.get_TOAs(self.tim, ephem="DE436", planets=False,
include_bipm=True)
r = resids(toas, model)
assert np.all(np.abs(r.time_resids.to(u.us)) < 800 * u.us), \
"Residuals did not computed correctly for early CHIME data."
def setUpClass(self):
self.par = 'B1855+09_NANOGrav_dfg+12_TAI_FB90.par'
self.tim = 'B1855+09_NANOGrav_dfg+12.tim'
self.m = mb.get_model(self.par)
self.t = toa.get_TOAs(self.tim, ephem='DE405')
self.f = WlsFitter(self.t, self.m)
# set perturb parameter step
self.per_param = {
'A1': 1e-05,
'DECJ': 1e-06,
'DMX_0003': 120,
'ECC': 0.2,
'F0': 1e-12,
'F1': 0.001,
'JUMP3': 10.0,
'M2': 10.0,
'OM': 1e-06,
'PB': 1e-08,
'PMDEC': 0.1,
'PMRA': 0.1,
'PX': 100,
'RAJ': 1e-08,
'SINI': -0.004075,
'T0': 1e-10
}
def setUpClass(self):
self.parfileB1855 = 'B1855+09_NANOGrav_9yv1.gls.par'
self.timB1855 = 'B1855+09_NANOGrav_9yv1.tim'
self.toasB1855 = toa.get_TOAs(self.timB1855, ephem="DE421",
planets=False, include_bipm=False)
self.modelB1855 = mb.get_model(self.parfileB1855)
self.out_parfile = 'test_parfile_write.par'
def test_compare_get_model_new_and_old():
m_new = get_model_new(parfile)
m_old = get_model(parfile)
assert set(m_new.get_params_mapping().keys()) == set(
m_old.get_params_mapping().keys())
assert set(m_new.components.keys()) == set(m_old.components.keys())
def setUpClass(self):
self.parfileB1855 = 'B1855+09_NANOGrav_dfg+12_modified_DD.par'
self.timB1855 = 'B1855+09_NANOGrav_dfg+12.tim'
self.toasB1855 = toa.get_TOAs(self.timB1855, ephem="DE405", planets=False)
self.modelB1855 = mb.get_model(self.parfileB1855)
# libstempo result
self.ltres, self.ltbindelay = np.genfromtxt(self.parfileB1855 + '.tempo_test', unpack=True)
def __init__(self, par, tim):
self.par = par
self.tim = tim
self.m = mb.get_model(self.par)
self.t = toa.get_TOAs(
self.tim, ephem="DE405", planets=False, include_bipm=False
)
def test_write(self):
# change parameter value
for p in self.modelB1855.params:
par = getattr(self.modelB1855, p)
# Change value for 20%
if isinstance(par.value, numbers.Number):
ov = par.value
if isinstance(par, mp.MJDParameter):
continue
else:
par.value = ov * 0.8
self.res = Residuals(self.toasB1855,
self.modelB1855,
use_weighted_mean=False).time_resids.to(u.s)
f = open(self.out_parfile, "w")
f.write(self.modelB1855.as_parfile())
f.close()
read_model = mb.get_model(self.out_parfile)
read_res = Residuals(self.toasB1855,
read_model,
use_weighted_mean=False).time_resids.to(u.s)
assert np.all(np.abs(read_res.value - self.res.value) < 1e-15
), "Output parfile did not produce same residuals."
for pp in self.modelB1855.params:
par_ori = getattr(self.modelB1855, pp)
par_read = getattr(read_model, pp)
if par_ori.uncertainty_value is not None:
unc_diff = par_ori.uncertainty_value - par_read.uncertainty_value
assert np.abs(unc_diff) < 1e-15, (
pp + "uncertainty does not keep the precision. at" +
str(np.abs(unc_diff)))
def _gen_data(par, tim):
t = toa.get_TOAs(tim, ephem="DE436")
m = mb.get_model(par)
gls = GLSFitter(t, m)
gls.fit_toas()
mjds = t.get_mjds().to(u.d).value
freqs = t.get_freqs().to(u.MHz).value
res = gls.resids.time_resids.to(u.us).value
err = m.scaled_sigma(t).to(u.us).value
info = t.get_flag_value("f")
fout = open(par + ".resids", "w")
iout = open(par + ".info", "w")
for i in range(t.ntoas):
line = "%.10f %.4f %+.8e %.3e 0.0 %s" % (
mjds[i],
freqs[i],
res[i],
err[i],
info[i],
)
fout.write(line + "\n")
iout.write(info[i] + "\n")
fout.close()
iout.close()
# Requires res_avg in path
cmd = "cat %s.resids | res_avg -r -t0.0001 -E%s -i%s.info > %s.resavg" % (
par,
par,
par,
par,
)
print(cmd)
def test_multiple_freqs():
# basic model, no EFAC or EQUAD
model = get_model(
io.StringIO(
"""
PSRJ J1234+5678
ELAT 0
ELONG 0
DM 10
F0 1
PEPOCH 58000
"""
)
)
toas = pint.simulation.make_fake_toas_uniform(
57001,
58000,
200,
model=model,
error=1 * u.us,
add_noise=False,
freq=np.array([1400, 400]) * u.MHz,
)
assert (toas.table["freq"][::2] == 1400 * u.MHz).all()
assert (toas.table["freq"][1::2] == 400 * u.MHz).all()
def check_tempo2_output(parf, timf, p, result_par):
"""Check out tempo2 output
"""
res = subprocess.check_output('tempo2 -f ' + parf + ' ' + timf +
' -norescale -newpar',
shell=True)
mpre = re.search('RMS pre-fit residual =(.+?)(us)', res)
mpost = re.search('RMS post-fit residual =(.+?)(us)', res)
mchi = re.search('Chisqr/nfree =(.+?)/', res)
m = mb.get_model(result_par)
mpostn = re.findall(r'\d+\.\d+', mpost.group(1))
try:
pre_rms = float(mpre.group(1))
except ValueError:
pre_rms = mpre.group(1)
try:
post_rms = float(mpostn[0])
except ValueError:
post_rms = mpost.group(1)
try:
chi = float(mchi.group(1)) / len(t.table)
except:
chi = mchi.group(1)
pv = getattr(m, p).value
pu = getattr(m, p).uncertainty_value
return pv, pu, post_rms, chi
def setUpClass(self):
self.parfileB1855 = 'B1855+09_polycos.par'
self.timB1855 = 'B1855_polyco.tim'
self.toasB1855 = toa.get_TOAs(self.timB1855, ephem="DE405", planets=False)
self.modelB1855 = mb.get_model(self.parfileB1855)
# Read tempo style polycos.
self.plc = Polycos()
self.plc.read_polyco_file('B1855_polyco.dat', 'tempo')
def test_ECL_to_allECL(ecl):
model_ECL = get_model(io.StringIO(modelstring_ECL))
model_ECL2 = model_ECL.as_ECL(ecl=ecl)
coords_ECL2 = model_ECL2.get_psr_coords()
assert model_ECL2.ECL.value == ecl
# note that coord.separation() will transform between frames when needed
assert np.isclose(
model_ECL.get_psr_coords().separation(coords_ECL2).arcsec, 0)
def test_infostring_in_parfile(setup_NGC6440E):
parfile = setup_NGC6440E.m.as_parfile(comment="test parfile writing")
f = io.StringIO(parfile)
newmodel = mb.get_model(f)
for p in setup_NGC6440E.m.params:
assert (
getattr(newmodel, p).value == getattr(setup_NGC6440E.m, p).value
), f"Value of {p} does not match in new par file: ({getattr(newmodel, p).value} vs. {getattr(setup_NGC6440E.m, p).value})"
def setUpClass(self):
self.parf= 'B1855+09_NANOGrav_9yv1.gls.par'
self.timf = 'B1855+09_NANOGrav_9yv1.tim'
self.toas = toa.get_TOAs(self.timf, ephem="DE421", planets=False)
self.model = mb.get_model(self.parf)
self.sort_toas = copy.deepcopy(self.toas)
self.sort_toas.table.sort('mjd_float')
self.sort_toas.table['index'] = range(self.sort_toas.ntoas)
def setUpClass(self):
self.parf = 'test_FD.par'
self.timf = 'test_FD.simulate.pint_corrected'
self.FDm = mb.get_model(self.parf)
self.toas = toa.get_TOAs(self.timf, include_bipm=False)
# libstempo result
self.ltres, self.ltbindelay = np.genfromtxt(self.parf + '.tempo_test',
unpack=True)
def setUpClass(self):
self.parf = 'B1855+09_NANOGrav_9yv1.gls.par'
self.timf = 'B1855+09_NANOGrav_9yv1.tim'
self.toas = toa.get_TOAs(self.timf, ephem="DE421", planets=False)
self.model = mb.get_model(self.parf)
self.sort_toas = copy.deepcopy(self.toas)
self.sort_toas.table.sort('mjd_float')
self.sort_toas.table['index'] = range(self.sort_toas.ntoas)
def setUpClass(cls):
os.chdir(datadir)
cls.parf = "test_FD.par"
cls.timf = "test_FD.simulate.pint_corrected"
cls.FDm = mb.get_model(cls.parf)
cls.toas = toa.get_TOAs(cls.timf, include_bipm=False)
# libstempo result
cls.ltres, cls.ltbindelay = np.genfromtxt(cls.parf + ".tempo_test", unpack=True)
def test_if_stand_alone_binary_model_get_updated_from_PINT_model(parfile):
if basename(parfile) in bad_trouble:
pytest.skip("This parfile is unclear")
try:
m = get_model(parfile)
except (ValueError, IOError, MissingParameter) as e:
pytest.skip("Existing code raised an exception {}".format(e))
verify_stand_alone_binary_parameter_updates(m)
def wls():
m = get_model(join(datadir, "NGC6440E.par"))
t = get_TOAs(join(datadir, "NGC6440E.tim"), ephem="DE421")
wls = WLSFitter(t, m)
wls.fit_toas()
return wls
def test_stand_alone_model_params_updates():
test_par_str = temp_par_str + "\n KIN 71.969 1 0.562"
m = mb.get_model(StringIO(test_par_str))
# Check if KIN exists in the pint facing object and stand alone binary
# models.
assert hasattr(m.binary_instance, "KIN")
assert hasattr(m, "KIN")
verify_stand_alone_binary_parameter_updates(m)
def wb():
m = get_model(join(datadir, "NGC6440E.par"))
t = make_fake_toas(55000, 58000, 20, model=m, freq=1400 * u.MHz, dm=10 * pint.dmu)
wb = WidebandTOAFitter(t, m)
wb.fit_toas()
return wb
def setUpClass(self):
self.parfileJ1713 = 'J1713+0747_NANOGrav_11yv0.gls.par'
self.timJ1713 = 'J1713+0747_NANOGrav_11yv0_short.tim'
self.toasJ1713 = toa.get_TOAs(self.timJ1713, ephem="DE421", planets=False)
self.toasJ1713.table.sort('index')
self.modelJ1713 = mb.get_model(self.parfileJ1713)
# libstempo result
self.ltres, self.ltbindelay = np.genfromtxt(self.parfileJ1713 + '.tempo_test', unpack=True)
def setUpClass(self):
self.parfileB1953 = 'B1953+29_NANOGrav_dfg+12_TAI_FB90.par'
self.timB1953 = 'B1953+29_NANOGrav_dfg+12.tim'
self.toasB1953 = toa.get_TOAs(self.timB1953, ephem="DE405", planets=False)
self.modelB1953 = mb.get_model(self.parfileB1953)
# tempo result
self.ltres, self.ltbindelay = np.genfromtxt(self.parfileB1953 + \
'.tempo2_test',skip_header=1, unpack=True)
print self.ltres
def setUpClass(self):
self.par = 'B1855+09_NANOGrav_9yv1.gls.par'
self.tim = 'B1855+09_NANOGrav_9yv1.tim'
self.m = mb.get_model(self.par)
self.t = toa.get_TOAs(self.tim, ephem='DE436')
self.f = GLSFitter(self.t, self.m)
# get tempo2 parameter dict
with open('B1855+09_tempo2_gls_pars.json', 'r') as fp:
self.t2d = json.load(fp)
def setUpClass(self):
self.parfileB1953 = 'B1953+29_NANOGrav_dfg+12_TAI_FB90.par'
self.timB1953 = 'B1953+29_NANOGrav_dfg+12.tim'
self.toasB1953 = toa.get_TOAs(self.timB1953, ephem="DE405", planets=False)
self.modelB1953 = mb.get_model(self.parfileB1953)
# tempo result
self.ltres, self.ltbindelay = np.genfromtxt(self.parfileB1953 + \
'.tempo2_test',skip_header=1, unpack=True)
print(self.ltres)
def setUpClass(self):
self.parfileJ0023 = 'J0023+0923_NANOGrav_11yv0.gls.par'
self.timJ0023 = 'J0023+0923_NANOGrav_11yv0.tim'
self.toasJ0023 = toa.get_TOAs(self.timJ0023, ephem="DE436",
planets=False)
self.modelJ0023 = mb.get_model(self.parfileJ0023)
# tempo result
self.ltres, self.ltbindelay = np.genfromtxt(self.parfileJ0023 + \
'.tempo2_test',skip_header=1, unpack=True)
def setUpClass(self):
self.parfileB1855 = 'B1855+09_NANOGrav_9yv1.gls.par'
self.timB1855 = 'B1855+09_NANOGrav_9yv1.tim'
self.toasB1855 = toa.get_TOAs(self.timB1855, ephem="DE421",
planets=False, include_bipm=False)
self.modelB1855 = mb.get_model(self.parfileB1855)
# tempo result
self.ltres= np.genfromtxt(self.parfileB1855 + \
'.tempo2_test',skip_header=1, unpack=True)
def test_residuals(self):
model = mb.get_model(self.parfile)
toas = toa.get_TOAs(self.tim,
ephem="DE436",
planets=False,
include_bipm=True)
r = Residuals(toas, model)
assert np.all(np.abs(r.time_resids.to(u.us)) < 800 * u.us), \
"Residuals did not computed correctly for early CHIME data."
def setUpClass(cls):
os.chdir(datadir)
cls.par = "NGC6440E.par"
cls.tim = "NGC6440E.tim"
cls.m = get_model(cls.par)
cls.t = toa.get_TOAs(cls.tim, ephem="DE421")
cls.wls = WLSFitter(cls.t, cls.m)
cls.gls = GLSFitter(cls.t, cls.m)
cls.gls_full = GLSFitter(cls.t, cls.m)
def setUpClass(cls):
os.chdir(datadir)
cls.parf = "B1855+09_NANOGrav_9yv1.gls.par"
cls.timf = "B1855+09_NANOGrav_9yv1.tim"
cls.toas = toa.get_TOAs(cls.timf, ephem="DE421", planets=False)
cls.model = mb.get_model(cls.parf)
cls.sort_toas = copy.deepcopy(cls.toas)
cls.sort_toas.table.sort("mjd_float")
cls.sort_toas.table["index"] = range(cls.sort_toas.ntoas)
def setUpClass(self):
self.parfileJ0613 = 'J0613-0200_NANOGrav_dfg+12_TAI_FB90.par'
self.timJ0613 = 'J0613-0200_NANOGrav_dfg+12.tim'
self.toasJ0613 = toa.get_TOAs(self.timJ0613, ephem="DE405",
planets=False, include_bipm=False)
self.modelJ0613 = mb.get_model(self.parfileJ0613)
# tempo result
self.ltres, self.ltbindelay = np.genfromtxt(self.parfileJ0613 + \
'.tempo2_test',skip_header=1, unpack=True)
print(self.ltres)
def setUpClass(self):
self.par = 'B1855+09_NANOGrav_dfg+12_TAI_FB90.par'
self.tim = 'B1855+09_NANOGrav_dfg+12.tim'
self.m = mb.get_model(self.par)
self.t = toa.get_TOAs(self.tim, ephem='DE405')
self.f = WlsFitter(self.t, self.m)
# set perturb parameter step
self.per_param = {'A1': 1e-05, 'DECJ': 1e-06, 'DMX_0003': 120, 'ECC': 0.2,
'F0': 1e-12, 'F1': 0.001, 'JUMP3': 10.0, 'M2': 10.0,
'OM': 1e-06, 'PB': 1e-08, 'PMDEC': 0.1, 'PMRA': 0.1,
'PX': 100, 'RAJ': 1e-08, 'SINI': -0.004075, 'T0': 1e-10}
def setUpClass(self):
self.parfileB1855 = 'B1855+09_NANOGrav_dfg+12_TAI_FB90.par'
self.timB1855 = 'B1855+09_NANOGrav_dfg+12.tim'
self.toasB1855 = toa.get_TOAs(self.timB1855, ephem="DE405",
planets=False, include_bipm=False)
self.modelB1855 = mb.get_model(self.parfileB1855)
from astropy import log as l
l.warning('%s' % self.modelB1855.components)
l.warning('%s' % self.modelB1855.params)
# tempo result
self.ltres= np.genfromtxt(self.parfileB1855 + \
'.tempo2_test',skip_header=1, unpack=True)
def test_pint_installed_correctly(self):
import pint.toa as toa
from pint.residuals import resids
import pint.models.model_builder as mb
import astropy.units as u
parfile = os.path.join(self.datadir, 'example_pint.par')
timfile = os.path.join(self.datadir, 'example_pint.tim')
toas = toa.get_TOAs(timfile, ephem="DE405",
planets=False, include_bipm=False)
model = mb.get_model(parfile)
pint_resids_us = resids(toas, model, False).time_resids.to(u.s)
# Due to the gps2utc clock correction. We are at 3e-8 seconds level.
assert np.all(np.abs(pint_resids_us.value) < 3e-6)
def check_tempo_output(parf, timf, result_par):
"""Check out tempo output
"""
a = subprocess.check_output('tempo -f '+ parf + ' '+timf, shell=True)
tempo_m = mb.get_model(result_par)
info_idx = a.index('Weighted RMS residual: pre-fit')
res = a[info_idx:-1]
mpre = re.search('pre-fit(.+?)us', res)
mpost = re.search('post-fit(.+?)us', res)
mchi = re.search('=(.+?)pre/post', res)
try:
pre_rms = float(mpre.group(1))
post_rms = float(mpost.group(1))
chi = float(mchi.group(1))
except ValueError:
pre_rms = mpre.group(1)
post_rms = mpost.group(1)
chi = mchi.group(1)
if chi.startswith('**'):
chi = 0.0
return tempo_m, pre_rms, post_rms, chi
def test_write(self):
# change parameter value
for p in self.modelB1855.params:
par = getattr(self.modelB1855, p)
# Change value for 20%
if isinstance(par.value, numbers.Number):
ov = par.value
if isinstance(par, mp.MJDParameter):
continue
else:
par.value = ov * 0.8
self.res = resids(self.toasB1855, self.modelB1855, False).time_resids.to(u.s)
f = open(self.out_parfile, 'w')
f.write(self.modelB1855.as_parfile())
f.close()
read_model = mb.get_model(self.out_parfile)
read_res = resids(self.toasB1855, read_model, False).time_resids.to(u.s)
assert np.all(np.abs(read_res.value - self.res.value) < 1e-15), 'Output parfile did not produce same residuals.'
for pp in self.modelB1855.params:
par_ori = getattr(self.modelB1855, pp)
par_read = getattr(read_model, pp)
if par_ori.uncertainty_value is not None:
unc_diff = par_ori.uncertainty_value - par_read.uncertainty_value
assert np.abs(unc_diff) < 1e-15, pp + 'uncertainty does not keep the precision. at' + str(np.abs(unc_diff))
def check_tempo2_output(parf, timf, p, result_par):
"""Check out tempo2 output
"""
res = subprocess.check_output('tempo2 -f '+ parf + ' '+timf+' -norescale -newpar', shell=True)
mpre = re.search('RMS pre-fit residual =(.+?)(us)', res)
mpost = re.search('RMS post-fit residual =(.+?)(us)', res)
mchi = re.search('Chisqr/nfree =(.+?)/', res)
m = mb.get_model(result_par)
mpostn = re.findall(r'\d+\.\d+',mpost.group(1))
try:
pre_rms = float(mpre.group(1))
except ValueError:
pre_rms = mpre.group(1)
try:
post_rms = float(mpostn[0])
except ValueError:
post_rms = mpost.group(1)
try:
chi = float(mchi.group(1))/len(t.table)
except:
chi = mchi.group(1)
pv = getattr(m, p).value
pu = getattr(m, p).uncertainty_value
return pv, pu, post_rms, chi
def testdiff(model,dy,step):
Pars = model.params
dervs = {}
for p in Pars:
if p is 'EDOT':
stepv = 1e-19
elif p is 'PBDOT':
stepv = 1e-7
else:
stepv = step
print p
c = test_diff(model,p,dy)
pv = getattr(model,p).value
numr = c.num_diff(stepv,pv)
try:
anlog = model.prtl_der(dy,p)
except:
if dy.startswith('delay'):
anlog = getattr(model,'d_delay'+dy[5]+'_d_par')(p)
else:
raise ValueError('Wrong delay')
print "Maximum error ", (numr.value - anlog.value).max()
dervs[p+'_num'] = numr
dervs[p+'_anlg'] = anlog
return dervs
ddm = mb.get_model('B1855+09_NANOGrav_dfg+12_modified.par')
t = toa.get_TOAs("B1855+09_NANOGrav_dfg+12.tim",planets = True)
ddob = ddm.get_dd_object(t.table)
diff = testdiff(ddob,'delayInverse',1e-7)
def setUpClass(self):
# This uses ELONG and ELAT
self.m1 = mb.get_model('B1855+09_NANOGrav_9yv1.gls.par')
# This uses RA and DEC
self.m2 = mb.get_model('B1855+09_NANOGrav_dfg+12_TAI_FB90.par')
self.t = 5000 * np.random.randn(100) + 49453.0
def Pulsar(*args, **kwargs):
ephem = kwargs.get('ephem', None)
planets = kwargs.get('planets', True)
sort = kwargs.get('sort', True)
drop_t2pulsar = kwargs.get('drop_t2pulsar', True)
timing_package = kwargs.get('timing_package', 'tempo2')
if pint:
toas = list(filter(lambda x: isinstance(x, toa.TOAs), args))
model = list(filter(lambda x: isinstance(x, TimingModel), args))
t2pulsar = list(filter(lambda x: isinstance(x, t2.tempopulsar), args))
parfile = list(filter(lambda x: isinstance(x, str) and
x.split('.')[-1] == 'par', args))
timfile = list(filter(lambda x: isinstance(x, str) and
x.split('.')[-1] in ['tim', 'toa'], args))
if pint and toas and model:
return PintPulsar(toas[0], model[0], sort=sort, planets=planets)
elif t2pulsar:
return Tempo2Pulsar(t2pulsar, sort=sort, drop_t2pulsar=drop_t2pulsar,
planets=planets)
elif parfile and timfile:
# Check whether the two files exist
if not os.path.isfile(parfile[0]) or not os.path.isfile(timfile[0]):
msg = 'Cannot find parfile {0} or timfile {1}!'.format(
parfile[0], timfile[0])
raise IOError(msg)
# Obtain the directory name of the timfile, and change to it
timfiletup = os.path.split(timfile[0])
dirname = timfiletup[0] or './'
reltimfile = timfiletup[-1]
relparfile = os.path.relpath(parfile[0], dirname)
# get current directory
cwd = os.getcwd()
# Change directory to the base directory of the tim-file to deal with
# INCLUDE statements in the tim-file
os.chdir(dirname)
if timing_package.lower() == 'pint':
if ephem is None:
ephem = 'DE421'
toas = toa.get_TOAs(reltimfile, ephem=ephem, planets=planets)
model = mb.get_model(relparfile)
os.chdir(cwd)
return PintPulsar(toas, model, sort=sort, planets=planets)
elif timing_package.lower() == 'tempo2':
# hack to set maxobs
maxobs = get_maxobs(reltimfile) + 100
t2pulsar = t2.tempopulsar(relparfile, reltimfile,
maxobs=maxobs, ephem=ephem)
os.chdir(cwd)
return Tempo2Pulsar(t2pulsar, sort=sort,
drop_t2pulsar=drop_t2pulsar,
planets=planets)
else:
print('Unknown arguments {}'.format(args))
def setUpClass(self):
self.parf = os.path.join(datapath,
'B1855+09_NANOGrav_dfg+12_modified.par')
self.timf = os.path.join(datapath, 'J1923+2515_NANOGrav_9yv1.tim')
self.DMXm = mb.get_model(self.parf)
self.toas = toa.get_TOAs(self.timf)
def setUpClass(self):
self.m = mb.get_model('B1855+09_NANOGrav_dfg+12_modified.par')
self.mp = mb.get_model('prefixtest.par')
def test_read_par_line(self):
test_m = mb.get_model('test_par_read.par')
self.assertEqual(test_m.F2.frozen, True)
self.assertEqual(test_m.F3.frozen, True)
self.assertTrue(
numpy.isclose(test_m.F3.value, 0.0))
self.assertTrue(
numpy.isclose(test_m.F3.uncertainty_value, 0.0))
self.assertEqual(test_m.F4.frozen, True)
self.assertTrue(
numpy.isclose(test_m.F4.value, 0.0))
self.assertTrue(
numpy.isclose(test_m.F4.uncertainty_value, 0.001))
self.assertEqual(test_m.F5.frozen, True)
self.assertTrue(
numpy.isclose(test_m.F5.value, 0.0))
self.assertTrue(
numpy.isclose(test_m.F5.uncertainty_value, 0.001))
self.assertEqual(test_m.F6.frozen, False)
self.assertTrue(
numpy.isclose(test_m.F6.value, 0.0))
self.assertTrue(
numpy.isclose(test_m.F6.uncertainty_value, 0.001))
self.assertEqual(test_m.F7.frozen, True)
self.assertTrue(
numpy.isclose(test_m.F7.value, 0.0))
self.assertTrue(
numpy.isclose(test_m.F7.uncertainty_value, 3.0))
self.assertEqual(test_m.F8.frozen, True)
self.assertTrue(
numpy.isclose(test_m.F8.value, 0.0))
self.assertTrue(
numpy.isclose(test_m.F8.uncertainty_value, 10))
self.assertEqual(test_m.JUMP1.frozen, True)
self.assertEqual(test_m.JUMP1.key, 'MJD')
self.assertTrue(
numpy.isclose(test_m.JUMP1.key_value[0].value, 52742.0, atol=1e-10))
self.assertTrue(
numpy.isclose(test_m.JUMP1.key_value[1].value, 52745.0, atol=1e-10))
self.assertTrue(
numpy.isclose(test_m.JUMP1.value, 0.2))
self.assertEqual(test_m.JUMP2.frozen, True)
self.assertTrue(
numpy.isclose(test_m.JUMP2.value, 0.1))
self.assertTrue(
numpy.isclose(test_m.JUMP2.uncertainty_value, 0.0))
self.assertTrue(
numpy.isclose(test_m.JUMP7.value, 0.1))
self.assertTrue(
numpy.isclose(test_m.JUMP7.uncertainty_value, 10.5))
self.assertTrue(
numpy.isclose(test_m.JUMP6.value, 0.1))
self.assertTrue(
numpy.isclose(test_m.JUMP6.uncertainty_value, 10.0))
self.assertEqual(test_m.JUMP12.key, '-testflag')
self.assertEqual(test_m.JUMP12.frozen, False)
self.assertEqual(test_m.JUMP12.key_value[0], 'flagvalue')
self.assertTrue(
numpy.isclose(test_m.JUMP12.value, 0.1))
self.assertTrue(
numpy.isclose(test_m.JUMP12.uncertainty_value, 2.0))
description="Reference epoch for phase = 0.0",
parse_value=lambda x: time_from_mjd_string(x, scale="tdb"),
)
print "Before assigning paramMJD value."
print "paramMJD num value is ", longdouble2string(paramMJD.num_value)
print "paramMJD value is ", paramMJD.value, "With type ", type(paramMJD.value)
print "paramMJD unit is ", paramMJD.units
print "paramMJD num unit is ", paramMJD.num_unit
paramMJD.set("54001.012345678901234")
print "After assigning paramMJD value."
print "paramMJD num value is ", longdouble2string(paramMJD.num_value)
print "paramMJD value is ", paramMJD.value, "With type ", type(paramMJD.value)
print "paramMJD unit is ", paramMJD.units
print "paramMJD num unit is ", paramMJD.num_unit
# change num_value
paramMJD.num_value = data2longdouble("54001.012345678901234")
print "After assigning paramMJD num_value."
print "paramMJD num value is ", longdouble2string(paramMJD.num_value)
print "paramMJD value is ", paramMJD.value, "With type ", type(paramMJD.value)
print "paramMJD unit is ", paramMJD.units
print "paramMJD num unit is ", paramMJD.num_unit
print "\n\n\n\n"
model = mb.get_model("J1744-1134.basic.par")
for pn in model.params:
p = getattr(model, pn)
print "Parameter name :", p.name
print "Value is ", p.value, "num_value is ", p.num_value
print "Unit is ", p.units, "num unit is ", p.num_unit
#! /usr/bin/env python
import pint.toa
import pint.models
import pint.fitter
import pint.residuals
import pint.models.model_builder as mb
import matplotlib.pyplot as plt
import astropy.units as u
import os, sys
datadir = os.path.dirname(os.path.abspath(__file__))
parfile = os.path.join(datadir, 'NGC6440E.par')
timfile = os.path.join(datadir, 'NGC6440E.tim')
# Define the timing model
m = mb.get_model(parfile)
# Read in the TOAs
t = pint.toa.get_TOAs(timfile)
# These are pre-fit residuals
rs = pint.residuals.resids(t, m).phase_resids
xt = t.get_mjds()
plt.plot(xt, rs, 'x')
plt.title("%s Pre-Fit Timing Residuals" % m.PSR.value)
plt.xlabel('MJD')
plt.ylabel('Residual (phase)')
plt.grid()
plt.show()
# Now do the fit
def test_read_par_line(self):
test_m = mb.get_model('test_par_read.par')
self.assertEqual(test_m.F2.frozen, True)
self.assertEqual(test_m.F3.frozen, True)
self.assertTrue(
numpy.isclose(test_m.F3.value, 0.0))
self.assertTrue(
numpy.isclose(test_m.F3.uncertainty_value, 0.0))
self.assertEqual(test_m.F4.frozen, True)
self.assertTrue(
numpy.isclose(test_m.F4.value, 0.0))
self.assertTrue(
numpy.isclose(test_m.F4.uncertainty_value, 0.001))
self.assertEqual(test_m.F5.frozen, True)
self.assertTrue(
numpy.isclose(test_m.F5.value, 0.0))
self.assertTrue(
numpy.isclose(test_m.F5.uncertainty_value, 0.001))
self.assertEqual(test_m.F6.frozen, False)
self.assertTrue(
numpy.isclose(test_m.F6.value, 0.0))
self.assertTrue(
numpy.isclose(test_m.F6.uncertainty_value, 0.001))
self.assertEqual(test_m.F7.frozen, True)
self.assertTrue(
numpy.isclose(test_m.F7.value, 0.0))
self.assertTrue(
numpy.isclose(test_m.F7.uncertainty_value, 3.0))
self.assertEqual(test_m.F8.frozen, True)
self.assertTrue(
numpy.isclose(test_m.F8.value, 0.0))
self.assertTrue(
numpy.isclose(test_m.F8.uncertainty_value, 10))
self.assertEqual(test_m.JUMP1.frozen, True)
self.assertEqual(test_m.JUMP1.key, 'MJD')
self.assertTrue(
numpy.isclose(test_m.JUMP1.key_value[0], 52742.0, atol=1e-10))
self.assertTrue(
numpy.isclose(test_m.JUMP1.key_value[1], 52745.0, atol=1e-10))
self.assertTrue(
numpy.isclose(test_m.JUMP1.value, 0.2))
self.assertEqual(test_m.JUMP2.frozen, True)
self.assertTrue(
numpy.isclose(test_m.JUMP2.value, 0.1))
self.assertTrue(
numpy.isclose(test_m.JUMP2.uncertainty_value, 0.0))
self.assertTrue(
numpy.isclose(test_m.JUMP7.value, 0.1))
self.assertTrue(
numpy.isclose(test_m.JUMP7.uncertainty_value, 10.5))
self.assertTrue(
numpy.isclose(test_m.JUMP6.value, 0.1))
self.assertTrue(
numpy.isclose(test_m.JUMP6.uncertainty_value, 10.0))
self.assertEqual(test_m.JUMP12.key, '-testflag')
self.assertEqual(test_m.JUMP12.frozen, False)
self.assertEqual(test_m.JUMP12.key_value[0], 'flagvalue')
self.assertTrue(
numpy.isclose(test_m.JUMP12.value, 0.1))
self.assertTrue(
numpy.isclose(test_m.JUMP12.uncertainty_value, 2.0))
self.assertTrue(
numpy.isclose(test_m.RAJ.uncertainty_value, 476.94611148516092061223))
self.assertTrue(
numpy.isclose(test_m.DECJ.uncertainty_value, 190996312986311097848351.00000000000000000000))
self.assertTrue(test_m.RAJ.uncertainty.unit, pint_units['hourangle_second'])
self.assertTrue(test_m.RAJ.uncertainty.unit, u.arcsecond)
def setUpClass(self):
self.parf = os.path.join(datadir, 'B1855+09_NANOGrav_dfg+12_DMX.par')
self.timf = os.path.join(datadir, 'B1855+09_NANOGrav_dfg+12.tim')
self.DMXm = mb.get_model(self.parf)
self.toas = toa.get_TOAs(self.timf, ephem='DE405', include_bipm=False)
