def testBasics(self): """Test basic functionality of Site """ for long in (54.3, -134.5): for lat in (-23.4, 12.3): for elev in (2789, 6543): site = coordConv.Site(long, lat, elev) self.assertEqual(long, site.meanLong) self.assertEqual(lat, site.meanLat) self.assertEqual(elev, site.elev) self.assertAlmostEqual(long, site.corrLong) self.assertAlmostEqual(lat, site.corrLat) site.setPoleWander(0, 0) self.assertAlmostEqual(long, site.corrLong) self.assertAlmostEqual(lat, site.corrLat) for xArcsec in (-0.3, 0, 0.3): x = xArcsec / 3600.0 for yArcsec in (-0.3, 0, 0.3): y = yArcsec / 3600.0 site.setPoleWander(x, y) # the following is an approximation given in the header of slaPolmo approxCorrLong = long + (x * coordConv.cosd(long) ) - (y * coordConv.sind(long)) approxCorrLat = lat + ( ((x * coordConv.sind(long)) + (y * coordConv.cosd(long))) * coordConv.tand(lat)) self.assertAlmostEqual(approxCorrLong, site.corrLong, 3) self.assertAlmostEqual(approxCorrLat, site.corrLat, 3) siteCopy = coordConv.Site(site) self.assertEqual(repr(site), repr(siteCopy))
def processOutput(outputVec): return ( outputVec[0], sind(outputVec[1]), cosd(outputVec[2]), outputVec[2], sind(outputVec[3]), cosd(outputVec[3]), )
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 testOffsetSmall(self): """Test offset, angularSeparation and orientationTo for small offsets not too near the pole In this regime delta-long = dist along long / cos(lat) is a reasonable approximation but I have no simple way to compute toOrient, except if dist very small then toOrient = fromOrient """ for fromPolarAng in (-40.0, 0.43, 36.7): cosPolarAng = cosd(fromPolarAng) for fromEquatAng in (0, 41.0): # should not matter fromCoord = Coord(fromEquatAng, fromPolarAng) for fromOrient in (-90, -72, -45.0, -30, 0.01, 12.5, 31, 47, 56, 68, 89): cosFromOrient = cosd(fromOrient) sinFromOrient = sind(fromOrient) for dist in (0, 1e-12, 1e-11, 1e-10, 1e-9, 1e-8, 1e-7, 1e-5, 0.001, 0.01, 0.13): predEquatAng = fromEquatAng + (dist * cosFromOrient / cosPolarAng) predPolarAng = fromPolarAng + (dist * sinFromOrient) toCoord, toOrient = fromCoord.offset(fromOrient, dist) atPole, toEquatAng, toPolarAng = toCoord.getSphPos() if abs(dist) > 0.1: places = 3 else: places = 5 if abs(dist) < 0.0001: orientPlaces = 4 else: orientPlaces = 7 self.assertAlmostEqual(toEquatAng, predEquatAng, places=places) self.assertAlmostEqual(toPolarAng, predPolarAng, places=places) fromCoord = Coord(fromEquatAng, fromPolarAng) toCoord = Coord(toEquatAng, toPolarAng) self.assertAlmostEqual( dist, fromCoord.angularSeparation(toCoord)) predFromOrient = fromCoord.orientationTo(toCoord) if numpy.isfinite(predFromOrient): self.assertAlmostEqual(fromOrient, predFromOrient, places=orientPlaces) self.assertAlmostEqual( toOrient, wrapNear( 180 + toCoord.orientationTo(fromCoord), toOrient), places=orientPlaces) else: self.assertLess(dist, 1e-7) self.assertAlmostEqual(fromEquatAng, toEquatAng) self.assertAlmostEqual(fromPolarAng, toPolarAng) self.assertAlmostEqual(fromOrient, toOrient)
def testWrap(self): for wrap in (-1000, -10, -1, 0, 1, 10, 1000): for offset in (-360, -180, -90, 0, 90, 180, 270, 360): for epsMult in (-3, -2, -1, 0, 1, 2, 3): ang = offset + (wrap * 360) ang += ang * DoubleEpsilon * epsMult sinAng = sind(ang) cosAng = cosd(ang) pvt = PVT(ang, ang, 35.0) # pick anything for vel and time posAng = wrapPos(ang) self.assertGreaterEqual(posAng, 0.0) self.assertLess(posAng, 360.0) # prove that posAng and ang are the same angle # sin and cos are a sanity check on wrapCtr self.assertAlmostEqual(wrapCtr(posAng - ang), 0) self.assertAlmostEqual(sind(posAng), sinAng) self.assertAlmostEqual(cosd(posAng), cosAng) posPvt = wrapPos(pvt) self.assertEqual(posPvt.pos, posAng) self.assertEqual(posPvt.vel, pvt.vel) self.assertEqual(posPvt.t, pvt.t) ctrAng = wrapCtr(ang) self.assertGreaterEqual(ctrAng, -180.0) self.assertLess(ctrAng, 180.0) # prove that ctrAng and ang are the same angle self.assertAlmostEqual(wrapCtr(ctrAng - ang), 0) self.assertAlmostEqual(sind(ctrAng), sinAng) self.assertAlmostEqual(cosd(ctrAng), cosAng) ctrPvt = wrapCtr(pvt) self.assertEqual(ctrPvt.pos, ctrAng) self.assertEqual(ctrPvt.vel, pvt.vel) self.assertEqual(ctrPvt.t, pvt.t) for refAngBase in (-180, 0, 180, 360): for refEpsMult in (-3, -2, -1, 0, 1, 2, 3): refAng = refAngBase refAng += refAng * refEpsMult * DoubleEpsilon nearAng = wrapNear(ang, refAng) self.assertGreaterEqual(nearAng - refAng, -180) self.assertLess(nearAng - refAng, 180) # prove that nearAng and ang are the same angle self.assertAlmostEqual(wrapCtr(nearAng - ang), 0) self.assertAlmostEqual(sind(nearAng), sinAng) self.assertAlmostEqual(cosd(nearAng), cosAng)
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 testSideA90(self): """ a = 90, B varies but not nearly 0 or 360, c fairly small but >> Eps expect: A = 180 - B, b = a + c cos(B), C ~= 0 """ side_aa = 90.0 for side_cc in (1.0e-12, 1.0e-10): for ang_B in (23, 90, 180 - Eps, 180, 180 + Eps, 256, 359): expRes = (180.0 - ang_B, side_aa + (side_cc * cosd(ang_B)), 0.0) self.checkOne((side_aa, ang_B, side_cc), expRes)
def testSideC90(self): """ a fairly small but >> Eps, B varies, c = 90 expect: C = 180 - B, b = c + a cos(B), A ~= 0 """ side_cc = 90.0 for side_aa in (1.0e-12, 1.0e-10): for ang_B in (23, 90, 180 - Eps, 180, 180 + Eps, 256, 359): expRes = (0.0, side_cc + (side_aa * cosd(ang_B)), 180.0 - ang_B) self.checkOne((side_aa, ang_B, side_cc), expRes)
def testOffsetSmall(self): """Test offset, angularSeparation and orientationTo for small offsets not too near the pole In this regime delta-long = dist along long / cos(lat) is a reasonable approximation but I have no simple way to compute toOrient, except if dist very small then toOrient = fromOrient """ for fromPolarAng in (-40.0, 0.43, 36.7): cosPolarAng = cosd(fromPolarAng) for fromEquatAng in (0, 41.0): # should not matter fromCoord = Coord(fromEquatAng, fromPolarAng) for fromOrient in (-90, -72, -45.0, -30, 0.01, 12.5, 31, 47, 56, 68, 89): cosFromOrient = cosd(fromOrient) sinFromOrient = sind(fromOrient) for dist in (0, 1e-12, 1e-11, 1e-10, 1e-9, 1e-8, 1e-7, 1e-5, 0.001, 0.01, 0.13): predEquatAng = fromEquatAng + (dist * cosFromOrient / cosPolarAng) predPolarAng = fromPolarAng + (dist * sinFromOrient) toCoord, toOrient = fromCoord.offset(fromOrient, dist) atPole, toEquatAng, toPolarAng = toCoord.getSphPos() if abs(dist) > 0.1: places = 3 else: places = 5 if abs(dist) < 0.0001: orientPlaces = 4 else: orientPlaces = 7 self.assertAlmostEqual(toEquatAng, predEquatAng, places=places) self.assertAlmostEqual(toPolarAng, predPolarAng, places=places) fromCoord = Coord(fromEquatAng, fromPolarAng) toCoord = Coord(toEquatAng, toPolarAng) self.assertAlmostEqual(dist, fromCoord.angularSeparation(toCoord)) predFromOrient = fromCoord.orientationTo(toCoord) if numpy.isfinite(predFromOrient): self.assertAlmostEqual(fromOrient, predFromOrient, places=orientPlaces) self.assertAlmostEqual(toOrient, wrapNear(180 + toCoord.orientationTo(fromCoord), toOrient), places=orientPlaces) else: self.assertLess(dist, 1e-7) self.assertAlmostEqual(fromEquatAng, toEquatAng) self.assertAlmostEqual(fromPolarAng, toPolarAng) self.assertAlmostEqual(fromOrient, toOrient)
def testTrig(self): """Test degrees-based trig functions """ for ang in (0, -1, 31.2, -235, 234324): angRad = ang * coordConv.RadPerDeg self.assertAlmostEqual(coordConv.sind(ang), math.sin(angRad)) self.assertAlmostEqual(coordConv.cosd(ang), math.cos(angRad)) self.assertAlmostEqual(coordConv.tand(ang), math.tan(angRad)) self.assertAlmostEqual(coordConv.atand(ang) * coordConv.RadPerDeg, math.atan(ang)) for ang2 in (0, 35, -364): self.assertAlmostEqual(coordConv.atan2d(ang, ang2) * coordConv.RadPerDeg, math.atan2(ang, ang2)) for val in (-1, -0.34, 0, 0.67, 1): self.assertAlmostEqual(coordConv.asind(val) * coordConv.RadPerDeg, math.asin(val)) self.assertAlmostEqual(coordConv.acosd(val) * coordConv.RadPerDeg, math.acos(val))
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 testRightTriangle(self): """ right triangle: B = 90, a and c vary but avoid poles tan C = tan c / sin a tan c = (tan a / sinA * sinb) with some tweaks to handle the other quadrants """ ang_B = 90.0 for side_aa in (1.0, 20.0, 45.0, 90, 110.0, 179.0): for side_cc in (1.0, 20.0, 45.0, 90.0, 110.0, 179.0): ang_A = atan2d(tand(side_aa), sind(side_cc)) ang_C = atan2d(tand(side_cc), sind(side_aa)) side_bb = atan2d(tand(side_aa), sind(ang_A) * cosd(side_cc)) # these tweaks handle other quadrants; they're based on what works, so are somewhat suspect if side_bb < 0: side_bb = -side_bb if ang_A < 0: ang_A = 180.0 + ang_A if ang_C < 0: ang_C = 180.0 + ang_C self.checkOne((side_aa, ang_B, side_cc), (ang_A, side_bb, ang_C))
def testBasics(self): """Check sph -> vec and back again for points not at the pole The round trip test relies on the fact that the internal representation of a coord is vector, so simply retrieving the sph info again suffices to test a round trip. Warning: the test of vector velocity is poor because the code is copied from the C++. However, two other tests will help: - Convert a coordinate system to itself with two different dates of observation and check that the expected amount of spatial motion occurs - Compare coordinate conversion results to the old TCC """ for equatAng in (0, 71, -123.4): for polarAng in (0, -75, -89.999999, 89.999999): for parallax in (0, MinParallax / 0.9000001, MinParallax / 0.8999999, 5): for equatPM in (4,): # (0, 4): for polarPM in (-7,): # (0, -7): for radVel in (0, -34): coord = Coord(equatAng, polarAng, parallax, equatPM, polarPM, radVel) self.assertFalse(coord.atPole()) self.assertEqual(coord.atInfinity(), parallax < MinParallax / 0.9) # check vector position vecPos = coord.getVecPos() dist = coord.getDistance() self.assertAlmostEqual(numpy.linalg.norm(vecPos), dist, 2) predVecPos = ( dist * cosd(polarAng) * cosd(equatAng), dist * cosd(polarAng) * sind(equatAng), dist * sind(polarAng), ) self.assertTrue(numpy.allclose(predVecPos, vecPos)) # check vector proper motion vecPM = coord.getVecPM() RadPerYear_per_ArcsecPerCentury = RadPerDeg / (ArcsecPerDeg * 100.0) SecPerYear = SecPerDay * DaysPerYear AUPerYear_per_KmPerSec = SecPerYear / KmPerAU sinEquat = sind(equatAng) cosEquat = cosd(equatAng) sinPolar = sind(polarAng) cosPolar = cosd(polarAng) # change units of proper motion from arcsec/century to au/year pmAUPerYear1 = equatPM * dist * RadPerYear_per_ArcsecPerCentury pmAUPerYear2 = polarPM * dist * RadPerYear_per_ArcsecPerCentury # change units of radial velocity from km/sec to au/year radVelAUPerYear = radVel * AUPerYear_per_KmPerSec predVecPM = ( - (pmAUPerYear2 * sinPolar * cosEquat) - (pmAUPerYear1 * cosPolar * sinEquat) + (radVelAUPerYear * cosPolar * cosEquat), - (pmAUPerYear2 * sinPolar * sinEquat) + (pmAUPerYear1 * cosPolar * cosEquat) + (radVelAUPerYear * cosPolar * sinEquat), + (pmAUPerYear2 * cosPolar) + (radVelAUPerYear * sinPolar), ) self.assertTrue(numpy.allclose(predVecPM, vecPM)) # check round trip atPole, destEquatAng, destPolarAng = coord.getSphPos() self.assertAlmostEqual(wrapPos(equatAng), destEquatAng) self.assertAlmostEqual(polarAng, destPolarAng) destParallax = coord.getParallax() predParallax = 0 if coord.atInfinity() else parallax self.assertAlmostEqual(predParallax, destParallax) atPole, destEquatPM, destPolarPM = coord.getPM() self.assertAlmostEqual(equatPM, destEquatPM, 6) self.assertAlmostEqual(polarPM, destPolarPM, 6) destRadVel = coord.getRadVel() self.assertAlmostEqual(radVel, destRadVel) coordCopy = Coord(coord) self.assertEqual(repr(coord), repr(coordCopy))
def testBasics(self): """Check sph -> vec and back again for points not at the pole The round trip test relies on the fact that the internal representation of a coord is vector, so simply retrieving the sph info again suffices to test a round trip. Warning: the test of vector velocity is poor because the code is copied from the C++. However, two other tests will help: - Convert a coordinate system to itself with two different dates of observation and check that the expected amount of spatial motion occurs - Compare coordinate conversion results to the old TCC """ for equatAng in (0, 71, -123.4): for polarAng in (0, -75, -89.999999, 89.999999): for parallax in (0, MinParallax / 0.9000001, MinParallax / 0.8999999, 5): for equatPM in (4, ): # (0, 4): for polarPM in (-7, ): # (0, -7): for radVel in (0, -34): coord = Coord(equatAng, polarAng, parallax, equatPM, polarPM, radVel) self.assertFalse(coord.atPole()) self.assertEqual(coord.atInfinity(), parallax < MinParallax / 0.9) # check vector position vecPos = coord.getVecPos() dist = coord.getDistance() self.assertAlmostEqual( numpy.linalg.norm(vecPos), dist, 2) predVecPos = ( dist * cosd(polarAng) * cosd(equatAng), dist * cosd(polarAng) * sind(equatAng), dist * sind(polarAng), ) self.assertTrue( numpy.allclose(predVecPos, vecPos)) # check vector proper motion vecPM = coord.getVecPM() RadPerYear_per_ArcsecPerCentury = RadPerDeg / ( ArcsecPerDeg * 100.0) SecPerYear = SecPerDay * DaysPerYear AUPerYear_per_KmPerSec = SecPerYear / KmPerAU sinEquat = sind(equatAng) cosEquat = cosd(equatAng) sinPolar = sind(polarAng) cosPolar = cosd(polarAng) # change units of proper motion from arcsec/century to au/year pmAUPerYear1 = equatPM * dist * RadPerYear_per_ArcsecPerCentury pmAUPerYear2 = polarPM * dist * RadPerYear_per_ArcsecPerCentury # change units of radial velocity from km/sec to au/year radVelAUPerYear = radVel * AUPerYear_per_KmPerSec predVecPM = ( -(pmAUPerYear2 * sinPolar * cosEquat) - (pmAUPerYear1 * cosPolar * sinEquat) + (radVelAUPerYear * cosPolar * cosEquat), -(pmAUPerYear2 * sinPolar * sinEquat) + (pmAUPerYear1 * cosPolar * cosEquat) + (radVelAUPerYear * cosPolar * sinEquat), +(pmAUPerYear2 * cosPolar) + (radVelAUPerYear * sinPolar), ) self.assertTrue( numpy.allclose(predVecPM, vecPM)) # check round trip atPole, destEquatAng, destPolarAng = coord.getSphPos( ) self.assertAlmostEqual(wrapPos(equatAng), destEquatAng) self.assertAlmostEqual(polarAng, destPolarAng) destParallax = coord.getParallax() predParallax = 0 if coord.atInfinity( ) else parallax self.assertAlmostEqual(predParallax, destParallax) atPole, destEquatPM, destPolarPM = coord.getPM( ) self.assertAlmostEqual(equatPM, destEquatPM, 6) self.assertAlmostEqual(polarPM, destPolarPM, 6) destRadVel = coord.getRadVel() self.assertAlmostEqual(radVel, destRadVel) coordCopy = Coord(coord) self.assertEqual(repr(coord), repr(coordCopy))
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)