Example #1
0
    def testXYZSCH(self):
        elp = Planet("Earth").get_elp()

        elp.setSCH(30., 60., 45.)
        sch = [-50000., 200000., 1000.]
        xyz = elp.sch_to_xyz(sch)
        sch1 = elp.xyz_to_sch(xyz)
        for (s, s1) in zip(sch, sch1):
            self.assertAlmostEqual(s, s1, places=3)

        xyz = [-4.e6, 10.e6, 1.e6]
        sch = elp.xyz_to_sch(xyz)
        xyz1 = elp.sch_to_xyz(sch)
        for (x, x1) in zip(xyz, xyz1):
            self.assertAlmostEqual(x, x1, places=3)

        elp.setSCH(65., -22., -30.)
        sch = [100000., -100000., 100000.]
        xyz = elp.sch_to_xyz(sch)
        sch1 = elp.xyz_to_sch(xyz)
        for (s, s1) in zip(sch, sch1):
            self.assertAlmostEqual(s, s1, places=3)

        xyz = [-1.e6, -2.e6, 100.e6]
        sch = elp.xyz_to_sch(xyz)
        xyz1 = elp.sch_to_xyz(sch)
        for (x, x1) in zip(xyz, xyz1):
            self.assertAlmostEqual(x, x1, places=3)
Example #2
0
    def testSCH2(self):
        elp = Planet("Earth").get_elp()

        #Peg at North Pole, S path on prime meridian heading North to South
        elp.setSCH(90., 0., -90.)

        #SCH = [0.,0.,0.] => XYZ = [elp.b, 0., 0.]
        sch = [0., 0., 0.]
        xyz = elp.sch_to_xyz(sch)
        self.assertAlmostEqual(xyz[0], 0., places=3)
        self.assertAlmostEqual(xyz[1], 0., places=3)
        self.assertAlmostEqual(xyz[2], elp.b, places=3)
        sch1 = elp.xyz_to_sch(xyz)
        for (s, s1) in zip(sch, sch1):
            self.assertAlmostEqual(s, s1, places=3)

        #SCH = [pi*elp.pegRadCur, 0, elp.b+(elp.pegOV[2]-elp.pegRadCur)] =>
        #XYZ=[0., 0., -elp.b]
        sch = [
            numpy.pi * elp.pegRadCur, 0., elp.b + elp.pegOV[2] - elp.pegRadCur
        ]
        xyz = elp.sch_to_xyz(sch)
        self.assertAlmostEqual(xyz[0], 0., places=3)
        self.assertAlmostEqual(xyz[1], 0., places=3)
        self.assertAlmostEqual(xyz[2], -elp.b, places=3)
        sch1 = elp.xyz_to_sch(xyz)
        for (s, s1) in zip(sch, sch1):
            self.assertAlmostEqual(s, s1, places=3)
Example #3
0
    def testSCHDOT(self):
        elp = Planet("Earth").get_elp()

        elp.setSCH(0., 0., 90.)
        sch = [0., 0., 0.]
        schdot = [0., 0., 10.]
        xyz, xyzdot = elp.schdot_to_xyzdot(sch, schdot)
        ans = [10.0, 0.0, 0.0]
        for (x, x1) in zip(xyzdot, ans):
            self.assertAlmostEqual(x, x1, places=3)

        xyz = [elp.a, 0., 0.]
        sch1, schdot1 = elp.xyzdot_to_schdot(xyz, xyzdot)
        for (s, s1) in zip(schdot, schdot1):
            self.assertAlmostEqual(s, s1, places=3)

        elp.setSCH(30., 60., 30.)
        sch = [0., 0., 0.]
        schdot = [10., 0., 0.]
        xyz, xyzdot = elp.schdot_to_xyzdot(sch, schdot)
        ans = [-6.495190528383289, -1.2499999999999996, 7.500000000000001]
        for (x, x1) in zip(xyzdot, ans):
            self.assertAlmostEqual(x, x1, places=3)
        xyz = elp.sch_to_xyz(sch)
        sch1, schdot1 = elp.xyzdot_to_schdot(xyz, xyzdot)
        for (s, s1) in zip(schdot, schdot1):
            self.assertAlmostEqual(s, s1, places=3)
Example #4
0
    def testConvertSCH(self):
        elp = Planet("Earth").get_elp()
        elp.setSCH(66.0, -105.0, 36.0)

        #From for_ellipsoid_test.F
        #convert_sch_to_xyz, sch_to_xyz
        r_sch = [1468.0, -234.0, 7000.0]
        r_xyz = [-672788.46258740244, -2514950.4839521507, 5810769.7976823179]
        r_llh = [66.009415512068244, -104.97681810507400, 6999.9999703792855]

        posXYZ = elp.sch_to_xyz(r_sch)
        for (a, b) in zip(r_xyz, posXYZ):
            self.assertAlmostEqual(a, b, places=3)

        #convert_sch_to_xyz, xyz_to_sch
        r_xyz = [-672100.0, -2514000.0, 5811000.0]
        r_sch = [2599.1237664792707, 70.396218844576666, 6764.7576835183427]
        r_llh = [66.019224990424505, -104.96758302093188, 6764.7576984856278]
        posXYZ = elp.sch_to_xyz(r_sch)
        for (a, b) in zip(r_xyz, posXYZ):
            self.assertAlmostEqual(a, b, places=3)
Example #5
0
    def testSCH1(self):
        elp = Planet("Earth").get_elp()

        #S path on Earth equator West to East, origin at y=z=0
        elp.setSCH(0., 0., 90.)

        #SCH = [0.,0.,0.] => XYZ = [elp.a, 0., 0.]
        sch = [0., 0., 0.]
        xyz = elp.sch_to_xyz(sch)
        self.assertAlmostEqual(xyz[0], elp.a, places=3)
        self.assertAlmostEqual(xyz[1], 0., places=3)
        self.assertAlmostEqual(xyz[2], 0., places=3)
        sch1 = elp.xyz_to_sch(xyz)
        for (s, s1) in zip(sch, sch1):
            self.assertAlmostEqual(s, s1, places=3)

        #SCH = [(pi/2)*elp.a, 0, 0] => XYZ=[0., elp.a, 0.]
        sch = [numpy.pi * elp.a / 2., 0., 0.]
        xyz = elp.sch_to_xyz(sch)
        self.assertAlmostEqual(xyz[0], 0., places=3)
        self.assertAlmostEqual(xyz[1], elp.a, places=3)
        self.assertAlmostEqual(xyz[2], 0., places=3)
        sch1 = elp.xyz_to_sch(xyz)
        for (s, s1) in zip(sch, sch1):
            self.assertAlmostEqual(s, s1, places=3)

        #SCH = [pi*elp.a, 0, 0] => XYZ=[-elp.a, 0., 0.]
        sch = [numpy.pi * elp.a, 0., 0.]
        xyz = elp.sch_to_xyz(sch)
        self.assertAlmostEqual(xyz[0], -elp.a, places=3)
        self.assertAlmostEqual(xyz[1], 0., places=3)
        self.assertAlmostEqual(xyz[2], 0., places=3)
        # Round off causes degenerate case where lon = -180 and lon=180 are the same
        # point and xyz(-sch) = xyz(+sch), but -sch != sch
        #
        #        sch1 = elp.xyz_to_sch(xyz)
        #        print(sch1)
        #        for (s,s1) in zip(sch, sch1):
        #            self.assertAlmostEqual(s, s1, places=3)

        #SCH = [(3pi/2)*elp.a, 0, 0] => XYZ=[0., -elp.a, 0.]
        sch = [3 * numpy.pi * elp.a / 2., 0., 0.]
        xyz = elp.sch_to_xyz(sch)
        self.assertAlmostEqual(xyz[0], 0., places=3)
        self.assertAlmostEqual(xyz[1], -elp.a, places=3)
        self.assertAlmostEqual(xyz[2], 0., places=3)
        #        sch1 = elp.xyz_to_sch(xyz)
        #        for (s,s1) in zip(sch, sch1):
        #            self.assertAlmostEqual(s, s1, places=3)

        #SCH = [2pi*elp.a, 0, 0] => XYZ=[elp.a, 0., 0.]
        sch = [2. * numpy.pi * elp.a, 0., 0.]
        xyz = elp.sch_to_xyz(sch)
        self.assertAlmostEqual(xyz[0], elp.a, places=3)
        self.assertAlmostEqual(xyz[1], 0., places=3)
        self.assertAlmostEqual(xyz[2], 0., places=3)
        #Another sch degeneracy due to angle branch cut
        #        sch1 = elp.xyz_to_sch(xyz)
        #        for (s,s1) in zip(sch, sch1):
        #            self.assertAlmostEqual(s, s1, places=3)

        #SCH = [0., (pi/2)*elp.a, elp.b-elp.a] => XYZ = [0., 0., elp.b]
        sch = [0., numpy.pi * elp.a / 2., elp.b - elp.a]
        xyz = elp.sch_to_xyz(sch)
        self.assertAlmostEqual(xyz[0], 0., places=3)
        self.assertAlmostEqual(xyz[1], 0., places=3)
        self.assertAlmostEqual(xyz[2], elp.b, places=3)
        #        sch1 = elp.xyz_to_sch(xyz)
        #        for (s,s1) in zip(sch, sch1):
        #            self.assertAlmostEqual(s, s1, places=3)

        #SCH = [0., pi*elp.a, 0.] => XYZ = [-elp.a, 0., 0.]
        sch = [0., numpy.pi * elp.a, 0.]
        xyz = elp.sch_to_xyz(sch)
        self.assertAlmostEqual(xyz[0], -elp.a, places=3)
        self.assertAlmostEqual(xyz[1], 0., places=3)
        self.assertAlmostEqual(xyz[2], 0., places=3)

        #SCH = [0., (3pi/2)*elp.a, elp.b-elp.a] => XYZ = [0., 0., -elp.b]
        sch = [0., 3. * numpy.pi * elp.a / 2., elp.b - elp.a]
        xyz = elp.sch_to_xyz(sch)
        self.assertAlmostEqual(xyz[0], 0., places=3)
        self.assertAlmostEqual(xyz[1], 0., places=3)
        self.assertAlmostEqual(xyz[2], -elp.b, places=3)