def testAddSubtractScalar(self): """Test pvt + scalar, pvt += scalar, pvt - scalar and pvt -= scalar """ for pvt in ( coordConv.PVT(1.0, 2.0, 3.0), coordConv.PVT(-1.5, -3.0, 4.0) ): for val in (-1.234e97, -25.3, -1.0e-13, 0.0, 1.0e13, 39.6, 1.34e99): addPVT = pvt + val self.assertAlmostEqual(addPVT.pos, pvt.pos + val) self.assertEqual(addPVT.vel, pvt.vel) self.assertEqual(addPVT.t, pvt.t) inPlaceAddPVT = coordConv.PVT(pvt.pos, pvt.vel, pvt.t) inPlaceAddPVT += val self.assertEqual(inPlaceAddPVT.pos, addPVT.pos) self.assertEqual(inPlaceAddPVT.vel, addPVT.vel) self.assertEqual(inPlaceAddPVT.t, addPVT.t) subPVT = pvt - val self.assertAlmostEqual(subPVT.pos, pvt.pos - val) self.assertEqual(subPVT.vel, pvt.vel) self.assertEqual(subPVT.t, pvt.t) inPlaceSubPVT = coordConv.PVT(pvt.pos, pvt.vel, pvt.t) inPlaceSubPVT -= val self.assertEqual(inPlaceSubPVT.pos, subPVT.pos) self.assertEqual(inPlaceSubPVT.vel, subPVT.vel) self.assertEqual(inPlaceSubPVT.t, subPVT.t)
def testMultDivScalar(self): """Test pvt * scalar, pvt *= scalar, pvt / scalar and pvt /= scalar """ for pvt in ( coordConv.PVT(1.0, 2.0, 3.0), coordConv.PVT(-1.5, -3.0, 4.0) ): for val in (-1.234e97, -25.3, -1.0e-13, 0.0, 1.0e13, 39.6, 1.34e99): multPVT = pvt * val self.assertAlmostEqual(multPVT.pos, pvt.pos * val) self.assertEqual(multPVT.vel, pvt.vel * val) self.assertEqual(multPVT.t, pvt.t) inPlaceMultPVT = coordConv.PVT(pvt.pos, pvt.vel, pvt.t) inPlaceMultPVT *= val self.assertEqual(inPlaceMultPVT.pos, multPVT.pos) self.assertEqual(inPlaceMultPVT.vel, multPVT.vel) self.assertEqual(inPlaceMultPVT.t, multPVT.t) if val != 0.0: divPVT = pvt / val self.assertAlmostEqual(divPVT.pos, pvt.pos / val) self.assertEqual(divPVT.vel, pvt.vel / val) self.assertEqual(divPVT.t, pvt.t) inPlaceDivPVT = coordConv.PVT(pvt.pos, pvt.vel, pvt.t) inPlaceDivPVT /= val self.assertEqual(inPlaceDivPVT.pos, divPVT.pos) self.assertEqual(inPlaceDivPVT.vel, divPVT.vel) self.assertEqual(inPlaceDivPVT.t, divPVT.t)
def testAddPVT(self): """Test pvt + pvt """ pvt1 = coordConv.PVT(1.0, 2.0, 3.0) pvt2 = coordConv.PVT(-1.5, -3.0, 4.0) pvt3 = pvt1 + pvt2 predPos3 = pvt1.pos + refGetPos(pvt2, pvt1.t) self.assertAlmostEqual(pvt3.pos, predPos3) self.assertAlmostEqual(pvt3.vel, -1.0) self.assertAlmostEqual(pvt3.t, 3.0)
def testPVTsAlmostEqual(self): for (posPlaces, velPlaces, tPlaces) in ( (5, 6, 7), (6, 7, 5), ): maxPosErr = 10**-posPlaces maxVelErr = 10**-velPlaces maxTErr = 10**-tPlaces for pvt1 in ( coordConv.PVT(5, 0.2, 3543), coordConv.PVT(386, -230.3, 5923402.22), ): for nWrap in (0, -3, 1): if nWrap == 0: doWrapList = (False, True) else: doWrapList = (True, ) wrappedPVT = pvt1.copy() wrappedPVT.pos += 360.0 * nWrap posEps = wrappedPVT.pos * 1e-14 velEps = pvt1.vel * 1e-14 tEps = pvt1.t * 1e-14 for deltaPos in (maxPosErr - posEps, maxPosErr + posEps): for deltaVel in (maxVelErr - velEps, maxVelErr + velEps): for deltaT in (maxTErr - tEps, maxTErr + tEps): pvt2 = wrappedPVT.copy() pvt2.pos += deltaPos pvt2.vel += deltaVel pvt2.t += deltaT for doWrap in doWrapList: if abs(deltaPos) <= maxPosErr \ and abs(deltaVel) <= maxVelErr \ and abs(deltaT) <= maxTErr: coordConv.assertPVTsAlmostEqual( pvt1, pvt2, doWrap=doWrap, posPlaces=posPlaces, velPlaces=velPlaces, tPlaces=tPlaces, ) else: self.assertRaises( AssertionError, coordConv.assertPVTsAlmostEqual, pvt1, pvt2, doWrap=doWrap, posPlaces=posPlaces, velPlaces=velPlaces, tPlaces=tPlaces, )
def testUnaryMinus(self): """Test -pvt """ for pvt in ( coordConv.PVT(1.0, 2.0, 3.0), coordConv.PVT(-1.5, -3.0, 4.0) ): negPVT = -pvt self.assertEqual(negPVT.t, pvt.t) self.assertEqual(negPVT.pos, -pvt.pos) self.assertEqual(negPVT.vel, -pvt.vel)
def pvtCoordIter(): for equatAng in (0, 71, -123.4): for polarAng in (0, -75, -89.9, 89.9): for equatVel in (0, 0.023): for polarVel in (0, -math.copysign(0.012, polarAng)): for tai in (4889100000.5, 1000.1): equatPVT = coordConv.PVT( equatAng, equatVel, tai) polarPVT = coordConv.PVT( polarAng, polarVel, tai) yield coordConv.PVTCoord(equatPVT, polarPVT)
def testConstructors(self): """Test PVT constructors """ pvt = coordConv.PVT(1.0, 2.0, 3.0) self.assertEquals(pvt.pos, 1.0) self.assertEquals(pvt.vel, 2.0) self.assertEquals(pvt.t, 3.0) pvtCopy = coordConv.PVT(pvt) self.assertEquals(pvt.pos, pvtCopy.pos) self.assertEquals(pvt.vel, pvtCopy.vel) self.assertEquals(pvt.t, pvtCopy.t)
def offPVTIter(pvtCoord): """return a sequence of (offOrientPVT, offDistPVT)""" tai = pvtCoord.getTAI() for offOrient in (0, -72): for offOrientVel in (0, 0.1): for offOrientTAI in (tai, tai + 10): offOrientPVT = coordConv.PVT(offOrient, offOrientVel, offOrientTAI) for offDist in (0, 0.1, 1): for offDistVel in (0, 0.3): for offDistTAI in (tai, tai - 5): offDistPVT = coordConv.PVT( offDist, offDistVel, offDistTAI) yield offOrientPVT, offDistPVT
def testSubtractPVT(self): """Test pvt - pvt """ pvt1 = coordConv.PVT(1.0, 2.0, 3.0) pvt2 = coordConv.PVT(-1.5, -3.0, 4.0) pvt3 = pvt1 - pvt2 predPos3 = pvt1.pos - refGetPos(pvt2, pvt1.t) self.assertAlmostEqual(pvt3.pos, predPos3) self.assertAlmostEqual(pvt3.vel, 5.0) self.assertAlmostEqual(pvt3.t, 3.0) pvt1 -= pvt2 self.assertAlmostEqual(pvt1.pos, predPos3) self.assertAlmostEqual(pvt1.vel, 5.0) self.assertAlmostEqual(pvt1.t, 3.0)
def testGetPos(self): """Test pvt.getPos """ pvt = coordConv.PVT(1.1, 2.2, 12345.0) for dt in (1235.5, -123.3): newt = pvt.t + dt self.assertAlmostEqual(pvt.getPos(newt), refGetPos(pvt, newt))
def makePVTFromPair(posPair, tai, deltaT, isAngle): pos = posPair[0] if (isAngle): vel = coordConv.wrapCtr(posPair[1] - posPair[0]) / deltaT else: vel = (posPair[1] - posPair[0]) / deltaT return coordConv.PVT(pos, vel, tai)
def testLunarVel(self): """Sanity-check lunar tracking velocity This checks for an issue we had with tracking close objects: position was right, but velocity was not. This was because Apparent Geocentric date was not being updated inside the PVTCoord version of CoordSys.convertFrom. """ tai = 4914602887 dt = 0.1 site = coordConv.Site(-105.822616, 32.780988, 2788) geoCoordSys = coordConv.AppGeoCoordSys() topoCoordSys = coordConv.AppTopoCoordSys() geoCoord = coordConv.Coord(0, 75, 82505922) topoPVTList = [] for evalTAI in (tai, tai + dt): geoPVTCoord = coordConv.PVTCoord(geoCoord, geoCoord, evalTAI, 0.01) topoPVTCoord = topoCoordSys.convertFrom(geoCoordSys, geoPVTCoord, site) topoPVTPair = [coordConv.PVT() for i in range(2)] topoPVTCoord.getSphPVT(topoPVTPair[0], topoPVTPair[1]) topoPVTList.append(topoPVTPair) for i in range(2): pvt0 = topoPVTList[0][i] pvt1 = topoPVTList[1][i] coordConv.assertPVTsAlmostEqual(pvt0.copy(pvt1.t), pvt1)
def testOffset(self): """Test PVTCoord.offset """ def pvtCoordIter(): for equatAng in (0, 71, -123.4): for polarAng in (0, -75, -89.99, 89.99, -90, 90): for equatVel in (0, 0.023): for polarVel in (0, -math.copysign(0.012, polarAng)): for tai in (4889100000.5, 1000.1): equatPVT = coordConv.PVT( equatAng, equatVel, tai) polarPVT = coordConv.PVT( polarAng, polarVel, tai) yield coordConv.PVTCoord(equatPVT, polarPVT) def offPVTIter(pvtCoord): """return a sequence of (offOrientPVT, offDistPVT)""" tai = pvtCoord.getTAI() for offOrient in (0, -72): for offOrientVel in (0, 0.1): for offOrientTAI in (tai, tai + 10): offOrientPVT = coordConv.PVT(offOrient, offOrientVel, offOrientTAI) for offDist in (0, 0.1, 1): for offDistVel in (0, 0.3): for offDistTAI in (tai, tai - 5): offDistPVT = coordConv.PVT( offDist, offDistVel, offDistTAI) yield offOrientPVT, offDistPVT numAtPole = 0 numNotAtPole = 0 toOrientPVT = coordConv.PVT() for pvtCoord in pvtCoordIter(): tai = pvtCoord.getTAI() for offOrientPVT, offDistPVT in offPVTIter(pvtCoord): if pvtCoord.getCoord().atPole(): numAtPole += 1 self.assertRaises(RuntimeError, pvtCoord.offset, toOrientPVT, offOrientPVT, offDistPVT) else: numNotAtPole += 1 offPVTCoord = pvtCoord.offset(toOrientPVT, offOrientPVT, offDistPVT) self.assertTrue(offPVTCoord.isfinite()) offOrientAtTAI = offOrientPVT.getPos(tai) offDistAtTAI = offDistPVT.getPos(tai) toOrientAtTAI = toOrientPVT.getPos(tai) offCoordAtTAI = offPVTCoord.getCoord(tai) coordAtTAI = pvtCoord.getCoord(tai) predOffCoord, predToOrient = coordAtTAI.offset( offOrientAtTAI, offDistAtTAI) self.assertAlmostEqual(toOrientAtTAI, predToOrient) self.assertAlmostEqual( offCoordAtTAI.angularSeparation(predOffCoord), 0) self.assertGreater(numNotAtPole, 100) self.assertGreater(numAtPole, 100)
def testInvalidate(self): """Test pvt.invalidate """ pvt = coordConv.PVT(1, 2, 3) self.assertTrue(pvt.isfinite()) pvt.invalidate() self.assertFalse(pvt.isfinite()) self.assertFalse(numpy.isfinite(pvt.pos)) self.assertFalse(numpy.isfinite(pvt.vel)) self.assertFalse(numpy.isfinite(pvt.t)) pvt2 = coordConv.PVT(-2, -4, 6) pvt2.invalidate(5) self.assertFalse(pvt2.isfinite()) self.assertFalse(numpy.isfinite(pvt2.pos)) self.assertFalse(numpy.isfinite(pvt2.vel)) self.assertEqual(pvt2.t, 5.0)
def testConvertFromVel(self): """Test velocity of convertFrom """ taiDate = 4889900000.205 site = coordConv.Site(-105.822616, 32.780988, 2788) icrsCoordSys = coordConv.ICRSCoordSys() appTopoCoordSys = coordConv.AppTopoCoordSys() # find ICRS coordinate of a sidereal point on the equator along the meridion appTopoCoord = coordConv.Coord(0, 90 - site.meanLat) icrsCoord = icrsCoordSys.convertFrom(appTopoCoordSys, appTopoCoord, site, taiDate) icrsPVTCoord = coordConv.PVTCoord(icrsCoord, icrsCoord, taiDate, 0.001) appTopoPVTCoord = appTopoCoordSys.convertFrom(icrsCoordSys, icrsPVTCoord, site) equatPVT = coordConv.PVT() polarPVT = coordConv.PVT() appTopoPVTCoord.getSphPVT(equatPVT, polarPVT) self.assertEqual(equatPVT.t, taiDate) self.assertEqual(polarPVT.t, taiDate) equatSpaceVel = equatPVT.vel * coordConv.cosd(polarPVT.pos) self.assertAlmostEqual(polarPVT.vel, 0, places=3) self.assertAlmostEqual(equatSpaceVel, -1 / 240.0, places=3) # 360 deg/day # check round trip of scale and orientation for fromDir in (0, 45): for fromVel in (0, 0.01): fromDirPVT = coordConv.PVT(fromDir, fromVel, taiDate) toDirPVT = coordConv.PVT() fromDir2PVT = coordConv.PVT() at2PVTCoord, scaleChange = appTopoCoordSys.convertFrom( toDirPVT, icrsCoordSys, icrsPVTCoord, fromDirPVT, site) icrs2PVTCoord, scaleChange2 = icrsCoordSys.convertFrom( fromDir2PVT, appTopoCoordSys, at2PVTCoord, toDirPVT, site) self.assertAlmostEqual(scaleChange, 1.0 / scaleChange2, places=7) coordConv.assertPVTsAlmostEqual(fromDirPVT, fromDir2PVT, doWrap=True, velPlaces=6)
def refOrientTo(pvtCoord0, pvtCoord1): """Compute orientation from pvtCoord0 to pvtCoord1 using Coord.orientationTo """ tai = pvtCoord0.getTAI() DeltaT = 0.01 posList = [] for tempTAI in (tai, tai + DeltaT): coord0 = pvtCoord0.getCoord(tempTAI) coord1 = pvtCoord1.getCoord(tempTAI) posList.append(coord0.orientationTo(coord1)) if numpy.all(numpy.isfinite(posList)): return makePVTFromPair(posList, tai, DeltaT, True) elif numpy.isfinite(posList[0]): return coordConv.PVT(posList[0], 0, tai) elif numpy.isfinite(posList[1]): return coordConv.PVT(posList[1], 0, tai) else: return coordConv.PVT()
def refPolarFromXY(x, y, tai): """Reference implementation of PVT.polarFromXY """ atPole = False rArr = [] thetaArr = [] for testTAI in (tai, tai + DeltaT): ap, r, theta = coordConv.polarFromXY(x.getPos(testTAI), y.getPos(testTAI)) rArr.append(r) thetaArr.append(theta) atPole = atPole or ap rPVT = coordConv.PVT() rPVT.pos = rArr[0] rPVT.vel = (rArr[1] - rArr[0]) / DeltaT rPVT.t = tai thetaPVT = coordConv.PVT() thetaPVT.pos = thetaArr[0] thetaPVT.vel = coordConv.wrapCtr(thetaArr[1] - thetaArr[0]) / DeltaT thetaPVT.t = tai return atPole, rPVT, thetaPVT
def timeAppTopoToFK5(alt, niter): """Time apparent topocentric to FK5 at the specified altitude @param[in] alt initial altitude (degrees) @param[in] niter number of iterations The coordinate conversion code presently does not have a special branch for zero proper motion, so no attempt is made to provide proper motion. Use the approximation that TAI = UTC, which is plenty close enough for timing. Increment TAI by 0.1 seconds per iteration, which is reasonable for a control loop. """ fk5Sys = coordConv.FK5CoordSys(1980) currTAI = utcFromPySec(time.time()) appTopoSys = coordConv.AppTopoCoordSys() appTopoCoord = coordConv.Coord(120, alt) site = makeSite() startTime = time.time() fromDir = 5.0 for i in range(niter): tai = currTAI + (i * 0.1) fk5Coord, toDir, scaleChange = fk5Sys.convertFrom( appTopoSys, appTopoCoord, fromDir, site, tai) duration = time.time() - startTime print "AppTopo To FK5 Coord with dir: %0.1f conversions/second (%d conversions in %0.2f sec) at alt=%0.1f" % ( niter / duration, niter, duration, alt) startTime = time.time() appTopoPVTCoord = coordConv.PVTCoord(appTopoCoord, appTopoCoord, currTAI, 0.01) toPVTDir = coordConv.PVT() fromPVTDir = coordConv.PVT(5, 0, tai) for i in range(niter): tai = currTAI + (i * 0.1) fk5PVTCoord, scaleChange = fk5Sys.convertFrom(toPVTDir, appTopoSys, appTopoPVTCoord, fromPVTDir, site) duration = time.time() - startTime print "AppTopo To FK5 PVTCoord with dir: %0.1f conversions/second (%d conversions in %0.2f sec) at alt=%0.1f" % ( niter / duration, niter, duration, alt)
def testRot2D(self): """Test rot2D """ def pvtIter(): for pos in (5, -3): for vel in (0.1, 0, -0.3): for tai in (500, 999): yield coordConv.PVT(pos, vel, tai) for fromPVTX in pvtIter(): for fromPVTY in pvtIter(): for ang in (0, 21, -75.5): for rotTAI in (fromPVTX.t - 200, fromPVTX.t + 5000): toPVTX = coordConv.PVT() toPVTY = coordConv.PVT() coordConv.rot2D(toPVTX, toPVTY, fromPVTX, fromPVTY, ang, rotTAI) for testTAI in (rotTAI, rotTAI + 1010): fromX = fromPVTX.getPos(testTAI) fromY = fromPVTY.getPos(testTAI) predToX, predToY = coordConv.rot2D(fromX, fromY, ang) self.assertAlmostEqual(predToX, toPVTX.getPos(testTAI)) self.assertAlmostEqual(predToY, toPVTY.getPos(testTAI))
def testCopy(self): """Test PVT.copy() and PVT.copy(t) """ pvt1 = coordConv.PVT(1.0, -2.0, 3.0) pvt2 = pvt1.copy() pvt3 = pvt1.copy(5.0) pvt1 *= 2 # modify pvt1 and make sure pvt2 and pvt3 are not affected self.assertAlmostEqual(pvt1.pos, 2.0) self.assertAlmostEqual(pvt1.vel, -4.0) self.assertEqual(pvt1.t, 3.0) self.assertEqual(pvt2.pos, 1.0) self.assertEqual(pvt2.vel, -2.0) self.assertEqual(pvt2.t, 3.0) self.assertEqual(pvt3.pos, -3.0) self.assertEqual(pvt3.vel, -2.0) self.assertEqual(pvt3.t, 5.0)
def testIsValid(self): """Test pvt.isfinite """ pvt = coordConv.PVT(1, 2, 3) self.assertTrue(pvt.isfinite()) pvt.pos = numpy.nan self.assertFalse(pvt.isfinite()) pvt.pos = 1.0 self.assertTrue(pvt.isfinite()) pvt.vel = numpy.nan self.assertFalse(pvt.isfinite()) pvt.vel = 1.0 self.assertTrue(pvt.isfinite()) pvt.t = numpy.nan self.assertFalse(pvt.isfinite()) pvt.t = 0.0 self.assertTrue(pvt.isfinite())
def testPolarFromXY(self): """Test polarFromXY and xyFromPolar """ for xPos, yPos, predAtPole in ( ( 1, 0, False), (-1, 0, False), ( 0, 1, False), ( 0, -1, False), ( 1, 1, False), ( 1, -1, False), (-1, 1, False), (-1, -1, False), (-123.45, -123.45, False), (0, 0, True), ): for xVel in (-1, 0, 1): for yVel in (-1, 0, 1): x = coordConv.PVT(xPos, xVel, 10) y = coordConv.PVT(yPos, yVel, 10) r = coordConv.PVT() theta = coordConv.PVT() for endTime in (5, 10, 15): atPole = coordConv.polarFromXY(r, theta, x, y, endTime) refAtPole, refR, refTheta = refPolarFromXY(x, y, endTime) self.assertEqual(atPole, refAtPole) self.assertEqual(r.t, endTime) self.assertEqual(refR.t, endTime) self.assertEqual(theta.t, endTime) self.assertEqual(refTheta.t, endTime) self.assertTrue(numpy.allclose( (r.pos, r.vel, theta.pos, theta.vel), (refR.pos, refR.vel, refTheta.pos, refTheta.vel), )) refX = coordConv.PVT() refY = coordConv.PVT() coordConv.xyFromPolar(refX, refY, r, theta, endTime) self.assertTrue(numpy.allclose( (x.pos, x.vel, y.pos, y.vel), (refX.getPos(10), refX.vel, refY.getPos(10), refY.vel), ))
def testFile(self): """Test file of coordinate conversions from TCC (data/masscc_out.dat) Known issues: - radVel does not match; the TCC seems to zero radVel if at infinity, but why? Also, the TCC seems to be able to round trip RadVel even if at infinity, but how, if it zeros it when at infinity? Once I resolve this, update the testCoord.py accordingly, as well as this code. - Other problems await at other coordinate systems. """ site = None numErrors = 0 with file(DataFile, "rU") as f: gotSiteData = False startTime = time.time() nTested = 0 for lineInd, line in enumerate(f): line = line.strip() if not line or line.startswith("#"): continue if not gotSiteData: meanLat, meanLong, elevation, ut1_tai, poleX, poleY = [ float(val) for val in line.split() ] site = coordConv.Site(meanLong, meanLat, elevation) site.setPoleWander(poleX, poleY) site.ut1_tai = ut1_tai gotSiteData = True continue dataList = line.split() fromSysCode, fromDate, fromPos1, fromPos2, fromPM1, fromPM2, fromParallax, fromRadVel, fromDir, refCoA, refCoB, \ toSysCode, toDate, refToPos1, refToPos2, refToPM1, refToPM2, refToParallax, refToRadVel, \ refToDir, refScaleChange, refAtInf, refAtPole, isOK, tai, last \ = [cnvFunc(val) for val, cnvFunc in itertools.izip(dataList, CnvList)] if not isOK: print "Skipping line %s: %s; isOK false" % (lineInd + 1, line) if (fromSysCode == 1) and (fromRadVel != 0) and ( fromPM1 == 0) and (fromPM2 == 0): print "Skipping line %s; FK4 with zero PM and nonzero radVel" % ( lineInd + 1, ) continue nTested += 1 fromCoord = coordConv.Coord(fromPos1, fromPos2, fromParallax, fromPM1, fromPM2, fromRadVel) fromPVTCoord = coordConv.PVTCoord(fromCoord, fromCoord, tai, 0.01) fromPVTDir = coordConv.PVT(fromDir, 0, tai) fromCoordSys = getCoordSys(fromSysCode, fromDate, tai) toCoordSys = getCoordSys(toSysCode, toDate, tai) site.refCoA = refCoA site.refCoB = refCoB try: toCoord, toDir, scaleChange = toCoordSys.convertFrom( fromCoordSys, fromCoord, fromDir, site) toPVTDir = coordConv.PVT() toPVTCoord, scaleChange2 = toCoordSys.convertFrom( toPVTDir, fromCoordSys, fromPVTCoord, fromPVTDir, site) except Exception: print "Failed on line %s: %s\n" % (lineInd + 1, line) raise atPole, toPos1, toPos2 = toCoord.getSphPos() toParallax = toCoord.getParallax() atPole, toPM1, toPM2 = toCoord.getPM() toRadVel = toCoord.getRadVel() if toCoord.atInfinity( ): # emulate something the TCC does that I don't think my code can do toRadVel = fromRadVel predList = (toParallax, toPM1, toPM2, toRadVel) refList = (refToParallax, refToPM1, refToPM2, refToRadVel) refToCoord = coordConv.Coord(refToPos1, refToPos2, refToParallax, refToPM1, refToPM2, refToRadVel) try: self.assertEqual(toCoord.atPole(), refAtPole) self.assertEqual(toCoord.atInfinity(), refAtInf) if (fromSysCode > 0) and (toSysCode > 0): atol = 1e-7 elif (fromSysCode < -1) and (toSysCode < -1): atol = 1e-7 else: # the sla_Mappa in the old TCC is giving slightly different answers # thatn the latest slaMappa and that appears to explain a small discrepancy # when converting to/from apparent geocentric coordinates; # the error is most noticeable for the precession/nutation matrix. atol = 1e-3 self.assertLess(toCoord.angularSeparation(refToCoord), atol) self.assertLess( toPVTCoord.getCoord(tai).angularSeparation(refToCoord), atol) maxPxDelta = refToParallax * 1000.0 self.assertAlmostEqual(toParallax, refToParallax, delta=maxPxDelta) self.assertTrue( numpy.allclose(predList[1:], refList[1:], atol=atol)) self.assertAlmostEqual(refToDir, coordConv.wrapNear(toDir, refToDir), places=2) self.assertAlmostEqual(refToDir, coordConv.wrapNear( toPVTDir.getPos(tai), refToDir), places=2) # scale change bears very little resemblance between old and new. # I believe this is a bug in the old TCC, since mean->mean should be 1.0 # and the new code is significantly closer to 1.0 than the old code. # self.assertAlmostEqual(refScaleChange, scaleChange, places=5) self.assertAlmostEqual(scaleChange, scaleChange2, places=5) if (fromSysCode > 0) and (toSysCode > 0): self.assertAlmostEqual(scaleChange, 1.0, places=5) if toCoordSys.getDateType() == coordConv.DateType_TAI: # "to" system uses tai as its time; try various strategies that remove proper motion to the given tai date # test the removePM function (which removes proper motion and radial velocity, but not parallax) zpmFromCoord = fromCoordSys.removePM(fromCoord, tai) if fromCoordSys.getName() != "fk4": # FK4 coordinates have fictitious space motion zpmFromAtPole, zpmFromPM1, zpmFromPM2 = zpmFromCoord.getPM( ) self.assertEqual(fromCoord.atPole(), zpmFromAtPole) self.assertEqual(zpmFromPM1, 0) self.assertEqual(zpmFromPM2, 0) zpmFromRadVel = zpmFromCoord.getRadVel() self.assertEqual(zpmFromRadVel, 0) # zpmFromAtPole, zpmFromPM1, zpmFromPM2 = zpmFromCoord.getPM() # self.assertEqual(fromCoord.atPole(), zpmFromAtPole) # zpmFromRadVel = zpmFromCoord.getRadVel() # self.assertEqual(zpmFromPM1, 0) # self.assertEqual(zpmFromPM2, 0) # self.assertEqual(zpmFromRadVel, 0) zpmToCoord, zpmToDir, zpmScaleChange = toCoordSys.convertFrom( fromCoordSys, zpmFromCoord, fromDir, site) zpmToAtPole, zpmToPos1, zpmToPos2 = zpmToCoord.getSphPos( ) self.assertEqual(atPole, zpmToAtPole) zpmToAtPole, zpmToPM1, zpmToPM2 = zpmToCoord.getPM() self.assertEqual(atPole, zpmToAtPole) zpmToRadVel = zpmToCoord.getRadVel() self.assertAlmostEqual(toDir, zpmToDir, places=2) # why so poor? self.assertAlmostEqual(scaleChange, zpmScaleChange, places=6) self.assertLess(toCoord.angularSeparation(zpmToCoord), 1e-7) self.assertEqual(zpmToPM1, 0) self.assertEqual(zpmToPM2, 0) self.assertEqual(zpmToRadVel, 0) except Exception as e: if ContinueOnError: print print str(e) print "Failed on line %s: %s" % (lineInd + 1, line) print "fromCoordSys=(%s, %s); toCoordSys=(%s, %s)" % ( fromCoordSys.getName(), fromCoordSys.getDate(), toCoordSys.getName(), toCoordSys.getDate()) print "toSphPos= ", toPos1, toPos2 print "refToSphPos=", refToPos1, refToPos2 print "angular sep=", toCoord.angularSeparation( refToCoord) * 3600.0, "arcsec" print "pred parallax, PM and radVel=", predList print "ref parallax, PM and radVel=", refList print "from parallax, PM and radVel=", (fromParallax, fromPM1, fromPM2, fromRadVel) print "from vec pos, vel=", fromCoord.getVecPos( ), fromCoord.getVecPM() print "to vec pos, vel=", toCoord.getVecPos( ), toCoord.getVecPM() if not ContinueOnError: raise numErrors += 1 duration = time.time() - startTime print "Tested %d conversions in %0.2f seconds: %0.0f conversions/second" % \ (nTested, duration, nTested/duration) self.assertEqual(numErrors, 0, "%s errors" % (numErrors, ))
def pvtIter(): for pos in (-1.1, 0, 1.1, numpy.nan): for vel in (-0.1, 0, 0.1, numpy.nan): for t in (0, 1, 2, numpy.nan): yield coordConv.PVT(pos, vel, t)
def testTwoPVTConstructors(self): """Test both two-PVT constructors: PVTCoord(equatPVT, polarPVT, tai, distPVT) PVTCoord(equatPVT, polarPVT, tai, distPVT, equatPM, polarPM, radVel, defOrient) """ for equatAng in (0, 71, -123.4): for polarAng in (0, -75, -89.99, 89.99): for orient in (0, -45, 31.23): sinOrient = coordConv.sind(orient) cosOrient = coordConv.cosd(orient) for vel in (0, 0.1, 0.23): for tai in (500.5, 10001.3): # coord0 = coordConv.Coord(equatAng, polarAng) polarVel = vel * sinOrient equatVel = vel * cosOrient / coordConv.cosd( polarAng) equatPVT = coordConv.PVT(equatAng, equatVel, tai) polarPVT = coordConv.PVT(polarAng, polarVel, tai) pvtCoord = coordConv.PVTCoord(equatPVT, polarPVT) self.assertAlmostEqual(pvtCoord.getTAI(), tai) self.assertTrue(pvtCoord.isfinite()) gotEquatPVT = coordConv.PVT() gotPolarPVT = coordConv.PVT() pvtCoord.getSphPVT(gotEquatPVT, gotPolarPVT) coordConv.assertPVTsAlmostEqual(equatPVT, gotEquatPVT, doWrap=True) coordConv.assertPVTsAlmostEqual(polarPVT, gotPolarPVT, doWrap=False) for parallax in (0, 0.012): dist = coordConv.distanceFromParallax(parallax) for distVel in (0, 10000): distPVT = coordConv.PVT(dist, distVel, tai) for equatPM in (0, 0.11): for polarPM in (0, -0.12): for radVel in (0, 0.13): pvtCoordPM = coordConv.PVTCoord( equatPVT, polarPVT, distPVT, equatPM, polarPM, radVel) self.assertAlmostEqual( pvtCoordPM.getTAI(), tai) self.assertTrue( pvtCoordPM.isfinite()) gotEquatPVT = coordConv.PVT() gotPolarPVT = coordConv.PVT() pvtCoordPM.getSphPVT( gotEquatPVT, gotPolarPVT) coordConv.assertPVTsAlmostEqual( equatPVT, gotEquatPVT, doWrap=True) coordConv.assertPVTsAlmostEqual( polarPVT, gotPolarPVT, doWrap=False) coordToCheck = pvtCoordPM.getCoord( ) self.assertAlmostEqual( radVel, coordToCheck.getRadVel()) atPole, checkEquatPM, checkPolarPM = coordToCheck.getPM( ) if not atPole: self.assertAlmostEqual( equatPM, checkEquatPM) self.assertAlmostEqual( polarPM, checkPolarPM) self.assertAlmostEqual( parallax, coordToCheck.getParallax()) if parallax != 0: self.assertAlmostEqual( dist, coordToCheck. getDistance(), places=5) coordConv.assertPVTsAlmostEqual( distPVT, pvtCoordPM.getDistance( ), velPlaces=5, posPlaces=5)
def pvtIter(): for pos in (5, -3): for vel in (0.1, 0, -0.3): for tai in (500, 999): yield coordConv.PVT(pos, vel, tai)