Updated tests for orekit 10.1

python_files/test/KlobucharModelTest.py

+# -*- coding: utf-8 -*-
+
+
+"""
+/* Copyright 2002-2019 CS Systèmes d'Information
+ * Licensed to CS Systèmes d'Information (CS) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * CS licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+ Python version translated from Java by Petrus Hyvönen, SSC 2019
+
+"""
+
+import unittest, sys, math
+
+# Python orekit specifics
+import orekit
+
+orekit.initVM()
+
+from orekit import JArray_double
+from org.orekit.data import DataProvidersManager, ZipJarCrawler
+from org.orekit.propagation.integration import PythonFieldAdditionalEquations
+from org.orekit.forces.gravity.potential import GravityFieldFactory
+from org.orekit.forces.gravity.potential import SHMFormatReader
+from java.io import File
+from java.lang import System
+
+
+from org.hipparchus.geometry.euclidean.threed import Vector3D
+from org.hipparchus import RealFieldElement
+
+from org.hipparchus.ode.nonstiff import DormandPrince853Integrator
+from org.hipparchus.ode.nonstiff import DormandPrince853FieldIntegrator
+
+from org.orekit.frames import FramesFactory
+from org.orekit.orbits import EquinoctialOrbit
+from org.orekit.orbits import OrbitType
+from org.orekit.propagation import SpacecraftState, FieldSpacecraftState
+from org.orekit.propagation.numerical import NumericalPropagator, FieldNumericalPropagator
+from org.orekit.propagation.semianalytical.dsst import DSSTPropagator
+from org.orekit.time import AbsoluteDate, FieldAbsoluteDate
+from org.orekit.utils import PVCoordinates
+from org.orekit.bodies import GeodeticPoint, FieldGeodeticPoint
+
+from org.hipparchus.util import MathArrays, Decimal64Field, FastMath, Precision
+
+from org.orekit.models.earth.ionosphere import KlobucharIonoModel, IonosphericModel
+
+
+
+
+
+class KlobucharModelTest(unittest.TestCase):
+
+    epsilon = 1e-6
+
+    # ionospheric model.
+    model = None
+
+    utc = None
+
+    def setUp(self):
+        self.model = KlobucharIonoModel([.3820e-07, .1490e-07, -.1790e-06, 0.0],
+                                        [.1430e+06, 0.0, -.3280e+06, .1130e+06])
+
+        # Initialize the data sources
+        DM = DataProvidersManager.getInstance()
+        datafile = File('resources.zip')
+        if not datafile.exists():
+            print('File :', datafile.absolutePath, ' not found')
+
+        crawler = ZipJarCrawler(datafile)
+        DM.clearProviders()
+        DM.addProvider(crawler)
+
+
+        print('Setup Finished ok')
+
+    def tearDown(self):
+        self.utc = None
+
+    def testDelay(self):
+        latitude = math.radians(45.0)
+        longitude = math.radians(2.0)
+        altitude = 500.0
+        elevation = 70.0
+        azimuth = 10.0
+
+        date = AbsoluteDate()
+
+        geo = GeodeticPoint(latitude, longitude, altitude)
+
+        delayMeters = self.model.pathDelay(date, geo,
+                                             math.radians(elevation),
+                                             math.radians(azimuth),
+                                             1575.42e6, IonosphericModel.cast_(self.model).getParameters())
+
+        self.assertTrue(Precision.compareTo(delayMeters, 12., self.epsilon) < 0)
+        self.assertTrue(Precision.compareTo(delayMeters, 0., self.epsilon) > 0)
+
+    def doTestFieldDelay(self, field):
+        zero = field.getZero();
+
+        latitude  = zero.add(FastMath.toRadians(45.0))
+        longitude = zero.add(FastMath.toRadians(2.0))
+        altitude  = zero.add(500.0)
+        elevation = zero.add(FastMath.toRadians(70.))
+        azimuth   = zero.add(FastMath.toRadians(10.))
+
+        date = FieldAbsoluteDate(field)
+
+        geo = FieldGeodeticPoint(latitude, longitude, altitude)
+
+        delayMeters = self.model.pathDelay(date, geo,
+                                        elevation, azimuth,
+                                        1575.42e6,
+                                        IonosphericModel.cast_(self.model).getParameters(field))
+
+        self.assertTrue(Precision.compareTo(delayMeters.getReal(), 12., self.epsilon) < 0)
+        self.assertTrue(Precision.compareTo(delayMeters.getReal(), 0., self.epsilon) > 0)
+
+    def testFieldDelay(self):
+        self.doTestFieldDelay(Decimal64Field.getInstance())
+
+
+if __name__ == '__main__':
+    suite = unittest.TestLoader().loadTestsFromTestCase(KlobucharModelTest)
+    ret = not unittest.TextTestRunner(verbosity=2).run(suite).wasSuccessful()
+    sys.exit(ret)

python_files/test/TransformTest.py

+# -*- coding: utf-8 -*-
+
+"""
+
+/* Copyright 2002-2019 CS Syst��mes d'Information
+ * Licensed to CS Syst��mes d'Information (CS) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * CS licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+Python version translated from Java by Petrus Hyvönen, SSC 2019
+
+ """
+
+import orekit
+
+orekit.initVM()
+from orekit.pyhelpers import setup_orekit_curdir, datetime_to_absolutedate
+
+setup_orekit_curdir()
+
+from org.orekit.time import AbsoluteDate
+import unittest
+import sys
+from datetime import datetime
+
+from java.util import ArrayList
+# import java.util.List;
+#
+# import org.hipparchus.Field;
+# import org.hipparchus.geometry.euclidean.threed.FieldVector3D;
+# import org.hipparchus.geometry.euclidean.threed.Line;
+from org.hipparchus.geometry.euclidean.threed import Rotation;
+from org.hipparchus.geometry.euclidean.threed import RotationConvention;
+from org.hipparchus.geometry.euclidean.threed import Vector3D
+# import org.hipparchus.linear.MatrixUtils;
+# import org.hipparchus.linear.RealMatrix;
+# import org.hipparchus.random.RandomGenerator;
+# import org.hipparchus.random.Well19937a;
+# import org.hipparchus.util.Decimal64;
+# import org.hipparchus.util.Decimal64Field;
+from org.hipparchus.util import FastMath
+# import org.junit.Assert;
+# import org.junit.Test;
+# import org.orekit.Utils;
+# import org.orekit.time.AbsoluteDate;
+# import org.orekit.time.FieldAbsoluteDate;
+# import org.orekit.time.TimeScale;
+# import org.orekit.time.TimeScalesFactory;
+from org.orekit.utils import CartesianDerivativesFilter
+# import org.orekit.utils.Constants;
+# import org.orekit.utils.FieldPVCoordinates;
+from org.orekit.utils import PVCoordinates
+# import org.orekit.utils.TimeStampedFieldPVCoordinates;
+from org.orekit.utils import TimeStampedPVCoordinates;
+from org.orekit.frames import Transform
+from org.orekit.frames import FramesFactory
+
+
+class TransformTest(unittest.TestCase):
+
+    def testPythonTransformType(self):
+        # Create initial TimeStampedPVCoordinates
+        pos = Vector3D(10000., 20000., 30000.)
+        vel = Vector3D(2000., 1000., 1500.)
+        date = datetime_to_absolutedate(datetime(2019, 4, 5))
+        pvt1 = TimeStampedPVCoordinates(date, pos, vel)
+        print(type(pvt1))
+
+        # Create transform
+        eme2000 = FramesFactory.getEME2000()
+        icrf = FramesFactory.getICRF()
+        transform = eme2000.getTransformTo(icrf, date)
+
+        # Transform the TimeStampedPVCoordinates
+        pvt2 = transform.transformPVCoordinates(pvt1)
+        print(type(pvt2))
+        # TimeStampedPVCoordinates.cast_(pvt2)
+        assert type(pvt2) == type(pvt1)
+
+    def evolvingTransform(self, t0, dt):
+
+        # the following transform corresponds to a frame moving along the circle r = 1
+        # with its x axis always pointing to the reference frame center
+        omega = 0.2;
+        date = t0.shiftedBy(dt);
+        cos = FastMath.cos(omega * dt);
+        sin = FastMath.sin(omega * dt);
+        return Transform(date,
+                         Transform(date,
+                                   Vector3D(-cos, -sin, 0.0),
+                                   Vector3D(omega * sin, -omega * cos, 0.0),
+                                   Vector3D(omega * omega * cos, omega * omega * sin, 0.0)),
+                         Transform(date,
+                                   Rotation(Vector3D.PLUS_K, FastMath.PI - omega * dt,
+                                            RotationConvention.VECTOR_OPERATOR),
+                                   Vector3D(omega, Vector3D.PLUS_K)));
+
+    def checkVector(self, reference, result, relativeTolerance):
+
+        refNorm = reference.getNorm()
+        resNorm = result.getNorm()
+        tolerance = relativeTolerance * (1 + FastMath.max(refNorm, resNorm))
+
+        assert -tolerance < Vector3D.distance(reference, result) < tolerance
+
+        # uassertEquals("ref = " + reference + ", res = " + result + " -> " +
+        #                    (Vector3D.distance(reference, result) / (1 + FastMath.max(refNorm, resNorm))),
+        #                    0, Vector3D.distance(reference, result), tolerance);
+
+    def testAcceleration(self):
+        initPV = PVCoordinates(Vector3D(9.0, 8.0, 7.0), Vector3D(6.0, 5.0, 4.0), Vector3D(3.0, 2.0, 1.0))
+        dt = 0.0
+        while dt < 1:
+            basePV = initPV.shiftedBy(dt)
+            transformedPV = self.evolvingTransform(AbsoluteDate.J2000_EPOCH, dt).transformPVCoordinates(basePV)
+
+            # rebuild transformed acceleration, relying only on transformed position and velocity
+            sample = ArrayList().of_(TimeStampedPVCoordinates)
+            h = 1.0e-2;
+            i = -3
+            while i < 4:
+                t = self.evolvingTransform(AbsoluteDate.J2000_EPOCH, dt + i * h);
+                pv = t.transformPVCoordinates(initPV.shiftedBy(dt + i * h))
+                item = TimeStampedPVCoordinates(t.getDate(), pv.getPosition(), pv.getVelocity(), Vector3D.ZERO)
+                sample.add(item)
+                i = i + 1
+
+            rebuiltPV = TimeStampedPVCoordinates.interpolate(AbsoluteDate.J2000_EPOCH.shiftedBy(dt),
+                                                             CartesianDerivativesFilter.USE_PV,
+                                                             sample)
+
+            self.checkVector(rebuiltPV.getPosition(), transformedPV.getPosition(), 4.0e-16)
+            self.checkVector(rebuiltPV.getVelocity(), transformedPV.getVelocity(), 2.0e-16)
+            self.checkVector(rebuiltPV.getAcceleration(), transformedPV.getAcceleration(), 9.0e-11)
+            dt += 0.01
+
+
+if __name__ == '__main__':
+    suite = unittest.TestLoader().loadTestsFromTestCase(TransformTest)
+    ret = not unittest.TextTestRunner(verbosity=2).run(suite).wasSuccessful()
+    sys.exit(ret)