def testEqu2gal(self):
"""tpm.equ2gal => convert Galactic to FK4 equatorial."""
v6 = tpm.V6S(r=1e9,alpha=tpm.d2r(120.0), delta=tpm.d2r(90.0))
v6 = v6.s2c()
v6 = tpm.gal2equ(v6)
self.verify(v6.c2s(), tpm.V6S(r=1e9, alpha=tpm.d2r(192.25),
delta=tpm.d2r(27.4)))
def testEqu2gal(self):
"""tpm.equ2gal => convert FK4 equatorial to Galactic."""
v6 = tpm.V6S(r=1e9,alpha=tpm.d2r(192.25), delta=tpm.d2r(27.4))
v6 = v6.s2c()
v6 = tpm.equ2gal(v6)
v6 = v6.c2s()
self.verify(v6, tpm.V6S(r=1e9, alpha=tpm.d2r(120.866),
delta=tpm.d2r(90.0)))
def testLdelfect(self):
"""tpm.ldeflect => apply GR light deflection."""
v6h = tpm.evp(tpm.J2000)[1]
v6 = tpm.V6S(r=1, alpha=tpm.d2r(34.56), delta=tpm.d2r(46.19))
v6 = v6.s2c()
v6 = tpm.ldeflect(v6, v6h, 1)
self.verify(v6.c2s(), tpm.V6S(r=1.0, alpha=0.6031857970,
delta=0.8061675815))
def testFk425(self):
"""tpm.fk425 => B1950 FK4 to J2000 FK5."""
v6 = tpm.V6S(r=1e9, alpha=tpm.d2r(23.15678), delta=
tpm.d2r(54.3892))
v6 = v6.s2c()
v6 = tpm.fk425(v6)
v6 = v6.c2s()
# Why does R change?
self.verify(v6, tpm.V6S(r=1000000000.0008671284,
alpha=tpm.d2r(23.9534903408),
delta=tpm.d2r(54.6442824316)))
def testFk524(self):
"""tpm.fk524 => J2000 FK5 to B1950 FK4."""
v6 = tpm.V6S(r=1e9,
alpha=tpm.d2r(23.9534903408),
delta=tpm.d2r(54.6442824316))
v6 = v6.s2c()
v6 = tpm.fk524(v6)
v6 = v6.c2s()
# Why does R change?
self.verify(v6, tpm.V6S(r=1e9, alpha=tpm.d2r(23.15678), delta=
tpm.d2r(54.3892)))
def testPrecess(self):
"""tpm.precess => precess V6 in inertial frame."""
v6 = tpm.V6S(r=1e9, alpha=tpm.d2r(34.1592),
delta=tpm.d2r(12.9638), rdot=-0.123,
alphadot=0.382, deltadot=1.0)
v6 = v6.s2c()
v6 = tpm.precess(tpm.J2000, tpm.J1984, v6, tpm.PRECESS_FK5)
v6 = v6.c2s()
self.verify(v6,tpm.V6S(r=1e9, alpha=0.5924126644,
delta=0.2249726697,rdot=-0.1229999560,
alphadot=0.3809705204,
deltadot=1.0003321415))
def test_slalib_hip_galeq(self):
"""convertv6(x,s1=4,s=6) + PM <=> SLALIB galeq HIP"""
v6l = []
for r, d in zip(self.hip_tab['glon'], self.hip_tab['glat']):
v6 = tpm.V6S()
v6.r = 1e9
v6.alpha = tpm.d2r(r)
v6.delta = tpm.d2r(d)
v6l.append(v6.s2c())
# The epoch of galactic data is J2000. But in SLALIB
# the input is taken to be B1950.0. I can't apply proper_motion
# from J2000 to B1950 before input to SLALIB since, I don't
# have galactic velocities. In essence, the SLALIB input has a
# proper_motion for the period B1950 to J2000, which is also
# present in the output. By setting
# epoch=tpm.B1950 PyTPM will return FK5 values at eq. J2000
# but at epoch B1950, which should match the results from
# SLALIB. The velocities for this conversion show up during
# FK4-FK5 frame conversion.
v6o = convert.convertv6(v6l, s1=4, s2=6, epoch=tpm.B1950)
cat = (tpm.v62cat(v, tpm.CJ) for v in v6o)
tab = get_sla("slalib_hip_galeq.txt")
for v, s in zip(cat, tab):
ra = math.degrees(tpm.r2r(v['alpha']))
dec = math.degrees(v['delta'])
ra_diff = abs(ra - s[0]) * 3600.0
dec_diff = abs(dec - s[1]) * 3600.0
self.assertTrue(ra_diff <= 0.001)
self.assertTrue(dec_diff <= 0.001)
def test_slalib_hip_eqgal(self):
"""convertv6(x,s1=6,s=4) + PM <=> SLALIB eqgal HIP"""
v6l = []
for r, d in zip(self.hip_tab['raj2'], self.hip_tab['decj2']):
v6 = tpm.V6S()
v6.r = 1e9
v6.alpha = tpm.d2r(r)
v6.delta = tpm.d2r(d)
v6l.append(v6.s2c())
v6o = convert.convertv6(v6l, s1=6, s2=4)
# The galactic coordinates are at epoch J2000. But SLALIB
# results are for B1950. So apply proper motion here.
v6o = convert.proper_motion(v6o, tpm.B1950, tpm.J2000)
cat = (tpm.v62cat(v, tpm.CJ) for v in v6o)
tab = get_sla("slalib_hip_eqgal.txt")
for v, s in zip(cat, tab):
ra = math.degrees(tpm.r2r(v['alpha']))
dec = math.degrees(v['delta'])
ra_diff = abs(ra - s[0]) * 3600.0
dec_diff = abs(dec - s[1]) * 3600.0
self.assertTrue(ra_diff <= 0.001)
self.assertTrue(dec_diff <= 0.001)
def test_slalib_nwdfs_fk54z(self):
"""convertv6(x,s1=6,s=5) + PM <=> SLALIB FK5-FK4 (fk54z) NDWFS"""
v6l = []
for r, d in zip(self.ndwfs_tab['raj2'], self.ndwfs_tab['decj2']):
v6 = tpm.V6S()
v6.r = 1e9
v6.alpha = tpm.d2r(r)
v6.delta = tpm.d2r(d)
v6l.append(v6.s2c())
v6o = convert.convertv6(v6l, s1=6, s2=5)
v6o = convert.proper_motion(v6o, tpm.B1950, tpm.J2000)
cat = (tpm.v62cat(v, tpm.CB) for v in v6o)
tab = get_sla("slalib_ndwfs_fk54z.txt")
for v, s in zip(cat, tab):
ra = math.degrees(tpm.r2r(v['alpha']))
dec = math.degrees(v['delta'])
# arcsec/cent to milli-arcsec/year.
pma = v['pma'] * 1000.0 / 100.0
pmd = v['pmd'] * 1000.0 / 100.0
ra_diff = abs(ra - s[0]) * 3600.0
dec_diff = abs(dec - s[1]) * 3600.0
pma_diff = abs(pma - s[2])
pmd_diff = abs(pmd - s[3])
self.assertTrue(ra_diff <= 0.0001)
self.assertTrue(dec_diff <= 0.0001)
self.assertTrue(pma_diff <= 1)
self.assertTrue(pmd_diff <= 1)
def testazel2hadec(self):
"""tpm.azel2hadec => (AZ,EL) to (HA,DEC)"""
v6 = tpm.V6S(r=1e9)
for i,j,k,l in zip(self.az,self.el,self.ha_c,self.dec_c):
v6.alpha = tpm.d2r(i)
v6.delta = tpm.d2r(j)
v61 = tpm.azel2hadec(v6.s2c(), tpm.d2r(self.lat))
v6 = v61.c2s()
self.assertAlmostEqual(tpm.r2d(tpm.r2r(v6.alpha)), k, 8)
self.assertAlmostEqual(tpm.r2d(tpm.r2r(v6.delta)), l, 8)
def testSetGetInitValues(self):
"""V6S(**vals) => set V6S fields at init."""
t = dict(r=1234.56,
alpha=2.345,
delta=-6.456,
rdot=-123.89,
alphadot=0.123,
deltadot=-0.54)
v6s = tpm.V6S(**t)
self.checkv6(v6s, t)
def testEllab(self):
"""tpm.ellab => apply elliptic aberration."""
# pytpm/tests/c_tests/ellab_test.c
v6 = tpm.V6S(r=1e9, alpha=tpm.h2r(20), delta=tpm.d2r(40.0))
v6 = v6.s2c()
v6 = tpm.ellab(tpm.J2000, v6, -1)
v6 = v6.c2s()
self.assertAlmostEqual(v6.r, 1e9,5)
self.assertAlmostEqual(tpm.r2h(tpm.r2r(v6.alpha)), 20.000007838,8)
self.assertAlmostEqual(tpm.r2d(tpm.r2r(v6.delta)), 39.999987574,8)
def testHadec2azel(self):
"""tpm.hadec2azel => (HA,DEC) to (AZ,EL)"""
v6 = tpm.V6S(r=1e9)
for i,j,k,l in zip(self.az,self.el,self.ha_c,self.dec_c):
j = tpm.r2d(tpm.r2r(tpm.d2r(j)))
v6.alpha = tpm.d2r(k)
v6.delta = tpm.d2r(l)
v61 = tpm.hadec2azel(v6.s2c(), tpm.d2r(self.lat))
v6 = v61.c2s()
self.assertAlmostEqual(tpm.r2d(tpm.r2r(v6.alpha)),
i, 8)
self.assertAlmostEqual(tpm.r2d(tpm.r2r(v6.delta)), j, 8)
def testEcl2equ(self):
"""tpm.ecl2equ => Ecliptic to FK5 equatorial."""
v6 = tpm.V6S(r=1.0,alpha=tpm.M_PI/4.0,delta=tpm.M_PI/4.0)
v6 = v6.s2c()
v6.xdot = -0.034
v6.ydot = -0.12
v6.zdot = -0.9
v6 = tpm.ecl2equ(v6, tpm.d2r(23.7))
self.verify(v6, tpm.V6C(x=0.5, y=0.173611298, z=0.848445117,
xdot=-0.034000000, ydot=0.251873488,
zdot=-0.872330067))
def testCreate(self):
"""V6S() => create a V6S class."""
v6s = tpm.V6S()
self.assertEqual(type(v6s), tpm.V6S)
# Access default init values.
self.assertAlmostEqual(v6s.ctype, tpm.SPHERICAL)
self.assertAlmostEqual(v6s.r, 0.0)
self.assertAlmostEqual(v6s.alpha, 0.0)
self.assertAlmostEqual(v6s.delta, 0.0)
self.assertAlmostEqual(v6s.rdot, 0.0)
self.assertAlmostEqual(v6s.alphadot, 0.0)
self.assertAlmostEqual(v6s.deltadot, 0.0)
# ctype is read only.
def f(x):
x.ctype = tpm.CARTESIAN
self.assertRaises(AttributeError, f, v6s)
def testV6S2C(self):
"""V6S.s2c() => V6C to V6C i.e., spherical to Cartesian."""
tn = dict(x=1123.4556,
y=4556.1123,
z=9876.1267,
xdot=2.3456,
ydot=6.7891,
zdot=7.8912)
t = dict(r=10934.26679617,
alpha=1.32903712,
delta=1.12723066,
rdot=10.19744374,
alphadot=-0.00013894,
deltadot=-0.00028117)
v6s = tpm.V6S(**t)
v6c = v6s.s2c()
self.assertEqual(v6c.ctype, tpm.CARTESIAN)
self.assertAlmostEqual(v6c.x, tn['x'], 4)
self.assertAlmostEqual(v6c.y, tn['y'], 4)
self.assertAlmostEqual(v6c.z, tn['z'], 4)
self.assertAlmostEqual(v6c.xdot, tn['xdot'], 4)
self.assertAlmostEqual(v6c.ydot, tn['ydot'], 4)
self.assertAlmostEqual(v6c.zdot, tn['zdot'], 4)
def test_slalib_nwdfs_eqecl(self):
"""convertv6(x,s1=6,s=3) <=> SLALIB eqecl NDWFS"""
v6l = []
for r, d in zip(self.ndwfs_tab['raj2'], self.ndwfs_tab['decj2']):
v6 = tpm.V6S()
v6.r = 1e9
v6.alpha = tpm.d2r(r)
v6.delta = tpm.d2r(d)
v6l.append(v6.s2c())
v6o = convert.convertv6(v6l, s1=6, s2=3)
cat = (tpm.v62cat(v, tpm.CJ) for v in v6o)
tab = get_sla("slalib_ndwfs_eqecl.txt")
for v, s in zip(cat, tab):
ra = math.degrees(tpm.r2r(v['alpha']))
dec = math.degrees(v['delta'])
ra_diff = abs(ra - s[0]) * 3600.0
dec_diff = abs(dec - s[1]) * 3600.0
self.assertTrue(ra_diff <= 0.001)
self.assertTrue(dec_diff <= 0.001)
def test_slalib_hip_ecleq(self):
"""convertv6(x,s1=3,s=6) <=> SLALIB ecleq HIP"""
v6l = []
for r, d in zip(self.hip_tab['elon2'], self.hip_tab['elat2']):
v6 = tpm.V6S()
v6.r = 1e9
v6.alpha = tpm.d2r(r)
v6.delta = tpm.d2r(d)
v6l.append(v6.s2c())
v6o = convert.convertv6(v6l, s1=3, s2=6)
cat = (tpm.v62cat(v, tpm.CJ) for v in v6o)
tab = get_sla("slalib_hip_ecleq.txt")
for v, s in zip(cat, tab):
ra = math.degrees(tpm.r2r(v['alpha']))
dec = math.degrees(v['delta'])
ra_diff = abs(ra - s[0]) * 3600.0
dec_diff = abs(dec - s[1]) * 3600.0
self.assertTrue(ra_diff <= 0.001)
self.assertTrue(dec_diff <= 0.001)
def test_slalib_nwdfs_fk45z(self):
"""convertv6(x,s1=5,s=6) <=> SLALIB FK4-FK5 (fk45z) NDWFS"""
v6l = []
for r, d in zip(self.ndwfs_tab['rab1'], self.ndwfs_tab['decb1']):
v6 = tpm.V6S()
v6.r = 1e9
v6.alpha = tpm.d2r(r)
v6.delta = tpm.d2r(d)
v6l.append(v6.s2c())
v6o = convert.convertv6(v6l, s1=5, s2=6)
v6o = convert.proper_motion(v6o, tpm.J2000, tpm.B1950)
cat = (tpm.v62cat(v, tpm.CJ) for v in v6o)
tab = get_sla("slalib_ndwfs_fk45z.txt")
for v, s in zip(cat, tab):
ra = math.degrees(tpm.r2r(v['alpha']))
dec = math.degrees(v['delta'])
ra_diff = abs(ra - s[0]) * 3600.0
dec_diff = abs(dec - s[1]) * 3600.0
self.assertTrue(ra_diff <= 0.5)
self.assertTrue(dec_diff <= 0.5)
def testTPM(self):
"""tpm.tpm() => coordinate conversion."""
# M100 FK5 J2000 from SIMBAD.
# See pytpm/tests/c_tests/test_conversion.c.
results = [
dict(ra_dd=-175.00, ra_mm=43.0, ra_ss=43.4850,
de_dd=15.00, de_mm=49.00, de_ss=20.5700),
dict(ra_dd=-175.00, ra_mm=43.00, ra_ss=42.3616,
de_dd=15.00, de_mm=49.00, de_ss=20.4480),
dict(ra_dd=-175.00, ra_mm=43.00, ra_ss=43.4850,
de_dd=15.00, de_mm=49.00, de_ss=20.5700),
dict(ra_dd=178.00, ra_mm=46.00, ra_ss=57.2326,
de_dd=16.00, de_mm=45.00, de_ss=34.9209),
dict(ra_dd=-89.00, ra_mm=8.00, ra_ss=10.1024,
de_dd=76.00, de_mm=53.00, de_ss=55.9283),
dict(ra_dd=-175.00, ra_mm=5.00, ra_ss=44.0262,
de_dd=16.00, de_mm=5.00, de_ss=58.0246 ),
dict(ra_dd=-175.00, ra_mm=43.00, ra_ss=43.4850,
de_dd=15.00, de_mm=49.00, de_ss=20.5700 ),
dict(ra_dd=-175.00, ra_mm=43.00, ra_ss=43.4852,
de_dd=15.00, de_mm=49.00, de_ss=20.5699 ),
dict(ra_dd=-175.00, ra_mm=43.00, ra_ss=43.4819,
de_dd=15.00, de_mm=49.00, de_ss=20.5712 ),
dict(ra_dd=-175.00, ra_mm=43.00, ra_ss=44.9349,
de_dd=15.00, de_mm=49.00, de_ss=13.4744 ),
dict(ra_dd=-175.00, ra_mm=43.00, ra_ss=44.9350,
de_dd=15.00, de_mm=49.00, de_ss=13.4743 ),
dict(ra_dd=-175.00, ra_mm=43.00, ra_ss=30.6891,
de_dd=15.00, de_mm=49.00, de_ss=19.5611 ),
dict(ra_dd=-175.00, ra_mm=43.00, ra_ss=43.4852,
de_dd=15.00, de_mm=49.00, de_ss=20.5699 ),
dict(ra_dd=-175.00, ra_mm=43.00, ra_ss=43.4819,
de_dd=15.00, de_mm=49.00, de_ss=20.5712 ),
dict(ra_dd=-175.00, ra_mm=43.00, ra_ss=45.2053,
de_dd=15.00, de_mm=49.00, de_ss=13.4529 ),
dict(ra_dd=-175.00, ra_mm=43.00, ra_ss=45.2054,
de_dd=15.00, de_mm=49.00, de_ss=13.4528 ),
dict(ra_dd=-175.00, ra_mm=43.00, ra_ss=30.9595,
de_dd=15.00, de_mm=49.00, de_ss=19.5396 ),
dict(ra_dd=-17.00, ra_mm=8.00, ra_ss=52.8721,
de_dd=15.00, de_mm=49.00, de_ss=19.5396 ),
dict(ra_dd=132.00, ra_mm=32.00, ra_ss=57.5676,
de_dd=67.00, de_mm=45.00, de_ss=9.6836 ),
dict(ra_dd=132.00, ra_mm=32.00, ra_ss=57.5676,
de_dd=67.00, de_mm=45.00, de_ss=34.3714 ),
dict(ra_dd=-17.00, ra_mm=9.00, ra_ss=9.5430,
de_dd=15.00, de_mm=49.00, de_ss=38.3077 ),
dict(ra_dd=-17.00, ra_mm=14.00, ra_ss=6.8699,
de_dd=-15.00, de_mm=10.00, de_ss=13.0062 )
]
ra = tpm.h2r(12+22/60.0+54.899/3600.0)
de = tpm.d2r(15+49/60.0+20.57/3600.0)
ep = tpm.J2000
eq = tpm.J2000
s1 = tpm.TPM_S06
s2 = tpm.TPM_S00
tstate = tpm.TSTATE()
pvec = tpm.PVEC()
for i in range(tpm.N_TPM_STATES):
tpm.tpm_data(tstate, tpm.TPM_INIT)
tstate.utc = tpm.J2000
tstate.lon = tpm.d2r(-111.598333)
tstate.lat = tpm.d2r(31.956389)
tstate.alt = 2093.093
tstate.delta_ut = tpm.delta_UT(tstate.utc)
tpm.tpm_data(tstate, tpm.TPM_ALL)
v6 = tpm.V6S()
v6.r = 1e9
v6.alpha = ra
v6.delta = de
pvec[s1] = v6.s2c()
s2 = i
tpm.tpm(pvec, s1, s2, ep, eq, tstate)
v6 = pvec[s2].c2s()
ra1 = v6.alpha
de1 = v6.delta
ra_dms = tpm.DMS(r=ra1)
de_dms = tpm.DMS(r=de1)
ra_dms.normalize()
de_dms.normalize()
self.assertAlmostEqual(ra_dms.dd, results[i]['ra_dd'], 4)
self.assertAlmostEqual(ra_dms.mm, results[i]['ra_mm'], 4)
self.assertAlmostEqual(ra_dms.ss, results[i]['ra_ss'], 4)
self.assertAlmostEqual(de_dms.dd, results[i]['de_dd'], 4)
self.assertAlmostEqual(de_dms.mm, results[i]['de_mm'], 4)
self.assertAlmostEqual(de_dms.ss, results[i]['de_ss'], 4)
def verify(t, t_norm):
v6s = tpm.V6S(**t)
a = v6s.ndelta
self.assertAlmostEqual(a, t_norm)
def f(pvec):
pvec[tpm.TPM_S03] = tpm.V6S()
