diff --git a/INSTALL.txt b/INSTALL.txt
deleted file mode 100644
index 4e0818df3c7f29f3a071f0ae8ba0217a80abfb20..0000000000000000000000000000000000000000
--- a/INSTALL.txt
+++ /dev/null
@@ -1,46 +0,0 @@
-INSTALLATION
-
-The python orekit wrapper requires:
-- a python installation (version 2.3-2.7)
-- The JCC tool version 2.19 or later http://lucene.apache.org/pylucene/jcc/
-- a java JDK
-
-The easiest way to install the orekit wrapper is to use pre-build packages. A recipe for a conda package for orekit is included in the repository.
-
-To build the wrapper from scratch:
-
-Place the java wrapper source file in the orekit source tree. Compile an
-orekit jar file including the wrapper.
-
-Place this jar file together with apache-commons-math jar file in the same
-directory as the provided build file, and execute the build. Note that
-the end command of the build may need to be change according to your needs,
-"install","bdist_winist" etc.
-
-Hints:
-One common failure is that the JCC package cannot reach the java virtual machine.
-The location varies on different platforms and on different java versions.
-
-Mint Linux
-----------
-for open-jdk it seems that the libjvm.so is not added to the library path by itself.
-Add the path to libjvm.so to a file in /etc/ld.conf.d/ such as java.conf
-such as:
-
- /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/server
-
-then run sudo ldconfig
-check if it is there by: ldconfig -p | grep jvm
-
-you might need to set the enviroment variable JCC_JDK. Example:
-
- export JCC_JDK=/usr/lib/jvm/java-7-openjdk-amd64
-
-Windows
--------
-Needs to set the variable JCC_JDK and include java items in the PATH. Example:
-
- set JCC_JDK=C:\Program Files (x86)\Java\jdk1.6.0_35
- set PATH=%JCC_JDK%\jre\bin\client;%JCC_JDK%\bin;%JCC_JDK%\lib;%PATH%
-
-These can be etiher set in a bat file or directly in the computer environment variable dialog in windows.
diff --git a/orekit-conda-recipe/README-conda-recipe.txt b/orekit-conda-recipe/README-conda-recipe.txt
new file mode 100644
index 0000000000000000000000000000000000000000..644a2655af69b29a7bf3f0f77c8b6677e9edf9ad
--- /dev/null
+++ b/orekit-conda-recipe/README-conda-recipe.txt
@@ -0,0 +1,2 @@
+A good source of information on how to build the wrapper is in the automated build scripts
+available at https://github.com/conda-forge/orekit-feedstock/tree/main/recipe
\ No newline at end of file
diff --git a/orekit-conda-recipe/bld.bat b/orekit-conda-recipe/bld.bat
deleted file mode 100644
index b8768ef24c160c7bb332108605ce1f78b68e683c..0000000000000000000000000000000000000000
--- a/orekit-conda-recipe/bld.bat
+++ /dev/null
@@ -1,89 +0,0 @@
-:: adding compile parameters explicitly as relocation for conda does not seem to detect JCC path under windows
-@set "JCC_JDK=%PREFIX%\Library"
-@set "JCC_INCLUDES=%PREFIX%\Library\include\win32;%PREFIX%\Library\include"
-@set "JCC_CFLAGS=/EHsc;/D_CRT_SECURE_NO_WARNINGS"
-@set "JCC_LFLAGS=/DLL;/LIBPATH:%PREFIX%\Library\lib;Ws2_32.lib;jvm.lib"
-@set "JCC_DEBUG_CFLAGS=/Od;/DDEBUG"
-@set "JCC_JAVAC=%PREFIX%\Library\bin\javac.exe"
-@set "JCC_JAVADOC=%PREFIX%\Library\bin\javadoc.exe"
-
-"%PYTHON%" -m jcc ^
---use_full_names ^
---python orekit ^
---version %PKG_VERSION% ^
---jar %SRC_DIR%\orekit-10.3.1.jar ^
---jar %SRC_DIR%\hipparchus-clustering-1.8.jar ^
---jar %SRC_DIR%\hipparchus-core-1.8.jar ^
---jar %SRC_DIR%\hipparchus-fft-1.8.jar ^
---jar %SRC_DIR%\hipparchus-filtering-1.8.jar ^
---jar %SRC_DIR%\hipparchus-fitting-1.8.jar ^
---jar %SRC_DIR%\hipparchus-geometry-1.8.jar ^
---jar %SRC_DIR%\hipparchus-migration-1.8.jar ^
---jar %SRC_DIR%\hipparchus-ode-1.8.jar ^
---jar %SRC_DIR%\hipparchus-optim-1.8.jar ^
---jar %SRC_DIR%\hipparchus-stat-1.8.jar ^
---jar %SRC_DIR%\rugged-2.2.jar ^
---package java.io ^
---package java.util ^
---package java.text ^
---package org.orekit ^
---package org.orekit.rugged ^
-java.io.BufferedReader ^
-java.io.FileInputStream ^
-java.io.FileOutputStream ^
-java.io.InputStream ^
-java.io.InputStreamReader ^
-java.io.ObjectInputStream ^
-java.io.ObjectOutputStream ^
-java.io.PrintStream ^
-java.io.StringReader ^
-java.io.StringWriter ^
-java.lang.System ^
-java.text.DecimalFormat ^
-java.text.DecimalFormatSymbols ^
-java.util.ArrayDeque ^
-java.util.ArrayList ^
-java.util.Arrays ^
-java.util.Collection ^
-java.util.Collections ^
-java.util.Date ^
-java.util.HashMap ^
-java.util.HashSet ^
-java.util.List ^
-java.util.Locale ^
-java.util.Map ^
-java.util.Set ^
-java.util.TreeSet ^
-java.util.stream.Collectors ^
-java.util.stream.Stream ^
-java.util.stream.DoubleStream ^
-java.util.function.LongConsumer ^
-java.util.function.IntConsumer ^
-java.util.function.DoubleConsumer ^
---module %SRC_DIR%\pyhelpers.py ^
---reserved INFINITE ^
---reserved ERROR ^
---reserved NAN ^
---reserved OVERFLOW ^
---reserved NO_DATA ^
---reserved min ^
---reserved max ^
---reserved mean ^
---reserved SNAN ^
---classpath %PREFIX%\Library\lib\tools.jar ^
---files 81 ^
---build ^
---install
-if errorlevel 1 exit 1
-
-:: ensure that JCC_JDK is set correctly by invoking an activate script
-set ACTIVATE_DIR=%PREFIX%\etc\conda\activate.d
-set DEACTIVATE_DIR=%PREFIX%\etc\conda\deactivate.d
-mkdir %ACTIVATE_DIR%
-mkdir %DEACTIVATE_DIR%
-
-copy %RECIPE_DIR%\scripts\activate.bat %ACTIVATE_DIR%\orekit-activate.bat
-if errorlevel 1 exit 1
-
-copy %RECIPE_DIR%\scripts\deactivate.bat %DEACTIVATE_DIR%\orekit-deactivate.bat
-if errorlevel 1 exit 1
diff --git a/orekit-conda-recipe/build.sh b/orekit-conda-recipe/build.sh
deleted file mode 100644
index d8edab0e55081bdeeddade22a85019c8450ba2cd..0000000000000000000000000000000000000000
--- a/orekit-conda-recipe/build.sh
+++ /dev/null
@@ -1,105 +0,0 @@
-#!/bin/bash
-
-if [ "$(uname)" == "Darwin" ]
-then
- export JCC_JDK=${PREFIX}
- export JCC_ARGSEP=";"
- export JCC_INCLUDES="${PREFIX}/include;${PREFIX}/include/darwin"
- export JCC_LFLAGS="-v;-L${PREFIX}/jre/lib;-ljava;-L${PREFIX}/jre/lib/server;-ljvm;-Wl,-rpath;-Wl,${PREFIX}/jre/lib;-Wl,-rpath;-Wl,${PREFIX}/jre/lib/server;-mmacosx-version-min=$MACOSX_DEPLOYMENT_TARGET"
- export JCC_CFLAGS="-fno-strict-aliasing;-Wno-write-strings;-Qunused-arguments;-mmacosx-version-min=10.9;-std=c++11;-stdlib=libc++"
- export JCC_DEBUG_CFLAGS="-O0;-g;-DDEBUG"
- export JCC_JAVAC="javac;-source;1.8;-target;1.8"
- export JCC_JAVADOC="javadoc"
-
-else
- # GNU/Linux recipe
- export JCC_JDK=${PREFIX}
- export JCC_ARGSEP=";"
- export JCC_LFLAGS="-v;-Wl,-v;-L${PREFIX}/jre/lib/amd64;-ljava;-L${PREFIX}/jre/lib/amd64/server;-ljvm;-lverify;-Wl,-rpath=${PREFIX}/jre/lib/amd64:${PREFIX}/jre/lib/amd64/server"
- export JCC_INCLUDES="${PREFIX}/include;${PREFIX}/include/linux"
- export JCC_JAVAC=${PREFIX}/bin/javac
- export JCC_CFLAGS="-v;-fno-strict-aliasing;-Wno-write-strings;-D__STDC_FORMAT_MACROS"
- export JCC_DEBUG_CFLAGS="-O0;-g;-DDEBUG"
- export JCC_JAVADOC="javadoc"
-fi
-
-printenv
-
-
-$PYTHON -m jcc \
---use_full_names \
---python orekit \
---version ${PKG_VERSION} \
---jar $SRC_DIR/orekit-10.3.1.jar \
---jar $SRC_DIR/hipparchus-clustering-1.8.jar \
---jar $SRC_DIR/hipparchus-core-1.8.jar \
---jar $SRC_DIR/hipparchus-fft-1.8.jar \
---jar $SRC_DIR/hipparchus-filtering-1.8.jar \
---jar $SRC_DIR/hipparchus-fitting-1.8.jar \
---jar $SRC_DIR/hipparchus-geometry-1.8.jar \
---jar $SRC_DIR/hipparchus-migration-1.8.jar \
---jar $SRC_DIR/hipparchus-ode-1.8.jar \
---jar $SRC_DIR/hipparchus-optim-1.8.jar \
---jar $SRC_DIR/hipparchus-stat-1.8.jar \
---jar $SRC_DIR/rugged-2.2.jar \
---package java.io \
---package java.util \
---package java.text \
---package org.orekit \
---package org.orekit.rugged \
-java.io.BufferedReader \
-java.io.FileInputStream \
-java.io.FileOutputStream \
-java.io.InputStream \
-java.io.InputStreamReader \
-java.io.ObjectInputStream \
-java.io.ObjectOutputStream \
-java.io.PrintStream \
-java.io.StringReader \
-java.io.StringWriter \
-java.lang.System \
-java.text.DecimalFormat \
-java.text.DecimalFormatSymbols \
-java.util.ArrayDeque \
-java.util.ArrayList \
-java.util.Arrays \
-java.util.Collection \
-java.util.Collections \
-java.util.Date \
-java.util.HashMap \
-java.util.HashSet \
-java.util.List \
-java.util.Locale \
-java.util.Map \
-java.util.Set \
-java.util.TreeSet \
-java.util.stream.Collectors \
-java.util.stream.Stream \
-java.util.stream.DoubleStream \
-java.util.function.LongConsumer \
-java.util.function.IntConsumer \
-java.util.function.DoubleConsumer \
---module $SRC_DIR/pyhelpers.py \
---reserved INFINITE \
---reserved ERROR \
---reserved OVERFLOW \
---reserved NO_DATA \
---reserved NAN \
---reserved min \
---reserved max \
---reserved mean \
---reserved SNAN \
---classpath $PREFIX/lib/tools.jar \
---files 81 \
---build \
---install
-
-# ensure that JCC_JDK is set correctly by invoking an activate script
-
-ACTIVATE_DIR=$PREFIX/etc/conda/activate.d
-DEACTIVATE_DIR=$PREFIX/etc/conda/deactivate.d
-mkdir -p $ACTIVATE_DIR
-mkdir -p $DEACTIVATE_DIR
-
-cp $RECIPE_DIR/scripts/activate.sh $ACTIVATE_DIR/orekit-activate.sh
-cp $RECIPE_DIR/scripts/deactivate.sh $DEACTIVATE_DIR/orekit-deactivate.sh
diff --git a/orekit-conda-recipe/meta.yaml b/orekit-conda-recipe/meta.yaml
deleted file mode 100644
index 01cfae74eb3270af732bd9a3656133008e08820f..0000000000000000000000000000000000000000
--- a/orekit-conda-recipe/meta.yaml
+++ /dev/null
@@ -1,74 +0,0 @@
-{% set name = "orekit" %}
-{% set version = "10.3.1" %}
-{% set artifact_filename = "v10_3_1_0" %}
-{% set sha256 = "9044ea7bc02e2ead2f2470dff4902f3a5f158adc7d389231313758bd8ee11f05" %} # [not osx] zip file
-{% set sha256 = "bb1c7870f5177340f1417004f4f9224d7b6fd3f6f992f06764c518606ce2b310" %} # [osx] tar.gz file
-
-
-package:
- name: {{ name|lower }}
- version: {{ version }}
-
-source:
- fn: {{ artifact_filename }}.zip # [not osx]
- url: https://github.com/petrushy/orekit_python_artifacts/archive/{{ artifact_filename }}.zip # [not osx]
-
- fn: {{ artifact_filename }}.tar.gz # [osx]
- url: https://github.com/petrushy/orekit_python_artifacts/archive/{{ artifact_filename }}.tar.gz # [osx]
- sha256: {{ sha256 }}
-
-build:
- number: 1
-
- rpaths:
- - lib/
- - jre/lib/amd64/
- - jre/lib/amd64/server/
-
-requirements:
- build:
- - {{ compiler('c') }}
- - {{ compiler('cxx') }}
- - openjdk 8
-
- host:
- - python
- - setuptools
- - jcc
- - openjdk 8
-
- run:
- - python
- - openjdk 8
-
-test:
- imports:
- - orekit
-
- source_files:
- - test/*.py
- - test/orekit-data.zip
- - test/resources.zip
- - test/resources/ccsds/*.txt
-
-about:
- home: https://www.orekit.org/forge/projects/orekit-python-wrapper
- license: Apache-2.0
- license_family: Apache
- license_file: LICENSE.txt
- summary: 'An accurate and efficient core layer for space flight dynamics applications '
-
- description:
- Orekit aims at providing accurate and efficient low level components for
- the development of flight dynamics applications. It is designed to be
- easily used in very different contexts, from quick studies up to critical operations.
- As a library, Orekit provides basic elements (orbits, dates, attitude, frames, ...) and
- various algorithms to handle them (conversions, propagations, pointing, ....).
-
- The Orekit library is written in java. This package provides a python wrapper to that library.
-
- doc_url: https://www.orekit.org/static/apidocs/
-
-extra:
- recipe-maintainers:
- - petrushy
diff --git a/orekit-conda-recipe/run_test.bat b/orekit-conda-recipe/run_test.bat
deleted file mode 100644
index e764bf218d0b275f71023e517f374fd0e3b92f86..0000000000000000000000000000000000000000
--- a/orekit-conda-recipe/run_test.bat
+++ /dev/null
@@ -1,13 +0,0 @@
-cd test
-setlocal EnableDelayedExpansion
-set error=0
-
-for %%f in (*.py) do (
- python "%%f"
- if "!errorlevel!" NEQ "0" (
- set error=1
- )
-)
-
-if %error% NEQ 0 exit /B 1
-
diff --git a/orekit-conda-recipe/run_test.sh b/orekit-conda-recipe/run_test.sh
deleted file mode 100644
index d69b809a71cbd26733040abf174859c1342654ed..0000000000000000000000000000000000000000
--- a/orekit-conda-recipe/run_test.sh
+++ /dev/null
@@ -1,14 +0,0 @@
-#!/usr/bin/env bash
-cd test
-
-ERROR=0
-
-for f in *.py; do
- if python "$f"; then
- echo "Test reported ok"
- else
- echo "Test failed"
- ERROR=1
- fi
-done
-exit $ERROR
diff --git a/orekit-conda-recipe/scripts/activate.bat b/orekit-conda-recipe/scripts/activate.bat
deleted file mode 100644
index 7649cae0f3404431e83278d88ec4a1317edc8116..0000000000000000000000000000000000000000
--- a/orekit-conda-recipe/scripts/activate.bat
+++ /dev/null
@@ -1,10 +0,0 @@
-:: Store existing env vars and set to this conda env
-:: so other installs don't pollute the environment.
-
-@if defined JCC_JDK (
- @set "_JCC_JDK_CONDA_BACKUP=%JCC_JDK%"
-)
-@set "JCC_JDK=%CONDA_PREFIX%\Library"
-
-@set "_JCC_PATH_CONDA_BACKUP=%PATH%"
-@set "PATH=%JCC_JDK%\jre\bin\server;%JCC_JDK%;%JCC_JDK%\jre\bin;%PATH%"
diff --git a/orekit-conda-recipe/scripts/activate.sh b/orekit-conda-recipe/scripts/activate.sh
deleted file mode 100644
index f568969e3abb8621adde453d8e8ed513cfc065f6..0000000000000000000000000000000000000000
--- a/orekit-conda-recipe/scripts/activate.sh
+++ /dev/null
@@ -1,2 +0,0 @@
-export _JCC_JDK_CONDA_BACKUP=${JCC_JDK:-}
-export JCC_JDK=$CONDA_PREFIX
diff --git a/orekit-conda-recipe/scripts/deactivate.bat b/orekit-conda-recipe/scripts/deactivate.bat
deleted file mode 100644
index 5fdca4c78dfa59ee4ea42b3e1a550eff2cc61ce2..0000000000000000000000000000000000000000
--- a/orekit-conda-recipe/scripts/deactivate.bat
+++ /dev/null
@@ -1,12 +0,0 @@
-:: Restore previous JCC_JDK and PATH env vars if they were set.
-
-@set "JCC_JDK="
-@if defined _JCC_JDK_CONDA_BACKUP (
- @set "JCC_JDK=%_JCC_JDK_CONDA_BACKUP%"
- @set "_JCC_JDK_CONDA_BACKUP="
-)
-
-@if defined _JCC_PATH_CONDA_BACKUP (
- @set "PATH =%_JCC_PATH_CONDA_BACKUP%"
- @set "_JCC_PATH_CONDA_BACKUP="
-)
diff --git a/orekit-conda-recipe/scripts/deactivate.sh b/orekit-conda-recipe/scripts/deactivate.sh
deleted file mode 100644
index 98c73063d4fb80f6ffb66337e43a96536b1e08b7..0000000000000000000000000000000000000000
--- a/orekit-conda-recipe/scripts/deactivate.sh
+++ /dev/null
@@ -1,8 +0,0 @@
-#!/bin/bash
-
-# Restore previous env vars if they were set.
-unset JCC_JDK
-if [[ -n "$_JCC_JDK_CONDA_BACKUP" ]]; then
- export JCC_JDK=$_JCC_JDK_CONDA_BACKUP
- unset _JCC_JDK_CONDA_BACKUP
-fi
diff --git a/python_files/pyhelpers.py b/python_files/pyhelpers.py
index 334d38cabfdd46c2092d739a9a01282a9b3f27e0..ba4bc1850ea3846d81a71a5452a77450cc307a24 100644
--- a/python_files/pyhelpers.py
+++ b/python_files/pyhelpers.py
@@ -104,7 +104,7 @@ def setup_orekit_curdir(filename='orekit-data.zip'):
print('filename ', filename, ' is neither a file nor a folder')
DM.clearProviders()
DM.clearLoadedDataNames()
- DM.clearFilters()
+ DM.resetFiltersToDefault()
DM.addProvider(crawler)
diff --git a/python_files/test/AbstractDetectorTest.py b/python_files/test/AbstractDetectorTest.py
index 64c60f15414bf1692c1b19d1c0c83aefb2097b9d..2ba32011d2064e540545d487aa45be7b3fda0dfb 100644
--- a/python_files/test/AbstractDetectorTest.py
+++ b/python_files/test/AbstractDetectorTest.py
@@ -1,6 +1,8 @@
# -*- coding: utf-8 -*-
import orekit
+from org.orekit.propagation import SpacecraftState
+
orekit.initVM()
from org.orekit.frames import FramesFactory, TopocentricFrame
@@ -10,7 +12,7 @@ from org.orekit.orbits import KeplerianOrbit
from org.orekit.utils import Constants
from org.orekit.propagation.analytical import KeplerianPropagator
from org.orekit.utils import PVCoordinates, IERSConventions
-from org.orekit.propagation.events.handlers import PythonEventHandler
+from org.orekit.propagation.events.handlers import PythonEventHandler, EventHandler
from org.hipparchus.geometry.euclidean.threed import Vector3D
from org.orekit.propagation.events import PythonAbstractDetector
from org.orekit.propagation.events.handlers import StopOnEvent
@@ -44,15 +46,15 @@ class PassCounter(PythonEventHandler):
class MyElevationDetector(PythonAbstractDetector):
- def __init__(self, elevation, topo, handler=None):
+ def __init__(self, elevation: float, topo: TopocentricFrame, handler: EventHandler = None):
self.elevation = elevation
- self.topo = topo
+ self.topo: TopocentricFrame = topo
dmax = float(PythonAbstractDetector.DEFAULT_MAXCHECK)
dthresh = float(PythonAbstractDetector.DEFAULT_THRESHOLD)
dmaxiter = PythonAbstractDetector.DEFAULT_MAX_ITER
if handler is None:
- handler = StopOnEvent().of_(MyElevationDetector)
+ handler = StopOnEvent()
super(MyElevationDetector, self).__init__(dmax, dthresh, dmaxiter, handler) #super(maxCheck, threshold, maxIter, handler);
@@ -62,10 +64,10 @@ class MyElevationDetector(PythonAbstractDetector):
def getElevation(self):
return self.elevation
- def getTopocentricFrame(self):
+ def getTopocentricFrame(self) -> TopocentricFrame:
return self.topo
- def g(self, s):
+ def g(self, s: SpacecraftState) -> float:
tmp = self.topo.getElevation(s.getPVCoordinates().getPosition(), s.getFrame(), s.getDate())-self.elevation
return tmp
@@ -104,7 +106,7 @@ class AbstractDetectorTest(unittest.TestCase):
detector = MyElevationDetector(elevation, sta1Frame)
- mycounter = PassCounter().of_(MyElevationDetector)
+ mycounter = PassCounter()
detector = detector.withHandler(mycounter)
kepler.addEventDetector(detector)
diff --git a/python_files/test/AdditionalEquationsTest.py b/python_files/test/AdditionalEquationsTest.py
deleted file mode 100644
index 6056afef80713e35ed7c01682cf79cfefeb808cd..0000000000000000000000000000000000000000
--- a/python_files/test/AdditionalEquationsTest.py
+++ /dev/null
@@ -1,160 +0,0 @@
-# -*- coding: utf-8 -*-
-
-
-"""
-/* Copyright 2002-2018 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 2018
-
-"""
-
-import unittest
-import sys
-
-# Python orekit specifics
-import orekit
-orekit.initVM()
-
-from orekit import JArray_double
-from org.orekit.data import DataProvidersManager, ZipJarCrawler, DataContext, DirectoryCrawler
-from org.orekit.propagation.integration import PythonAdditionalEquations
-from org.orekit.propagation.integration import AdditionalEquations
-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.ode.nonstiff import DormandPrince853Integrator
-
-from org.orekit.frames import FramesFactory
-from org.orekit.orbits import EquinoctialOrbit
-from org.orekit.orbits import OrbitType
-from org.orekit.propagation import SpacecraftState
-from org.orekit.propagation.numerical import NumericalPropagator
-from org.orekit.propagation.semianalytical.dsst import DSSTPropagator
-from org.orekit.time import AbsoluteDate
-from org.orekit.utils import PVCoordinates
-
-
-# The class to be the additional equation
-class InitCheckerEquations(PythonAdditionalEquations): # implements AdditionalEquations
-
- # This is the method called for object creation as in java InitCheckerEquations(self, expected)
- def __init__(self, expected):
- super(InitCheckerEquations, self).__init__()
- self.expected = expected
- self.called = False
-
- # Part of AdditionalEquations interface
- def init(self, initialState, target):
- assert (self.expected - 1.0e-15) < initialState.getAdditionalState(self.getName())[0] < (self.expected + 1.0e-15)
- self.called = True
-
- # Part of AdditionalEquations interface
- def computeDerivatives(self, s, pDot):
- pDot[0] = 1.5
- return JArray_double(6)
-
- # Part of AdditionalEquations interface
- def getName(self):
- return "linear"
-
- def wasCalled(self):
- return self.called
-
-
-class AdditionalEquationsTest(unittest.TestCase):
-
- def setUp(self):
- DM = DataContext.getDefault().getDataProvidersManager()
- datafile = File('resources')
- if not datafile.exists():
- print('File :', datafile.absolutePath, ' not found')
-
- crawler = DirectoryCrawler(datafile)
- DM.clearProviders()
- DM.addProvider(crawler)
- System.setProperty(DataProvidersManager.OREKIT_DATA_PATH, 'potential/shm-format')
- GravityFieldFactory.addPotentialCoefficientsReader(SHMFormatReader("^eigen_cg03c_coef$", False))
-
- mu = GravityFieldFactory.getUnnormalizedProvider(0, 0).getMu()
- position = Vector3D(7.0e6, 1.0e6, 4.0e6)
- velocity = Vector3D(-500.0, 8000.0, 1000.0)
- self.initDate = AbsoluteDate.J2000_EPOCH
- orbit = EquinoctialOrbit(PVCoordinates(position, velocity),
- FramesFactory.getEME2000(), self.initDate, mu)
- self.initialState = SpacecraftState(orbit)
- self.tolerance = NumericalPropagator.tolerances(0.001, orbit, OrbitType.EQUINOCTIAL)
-
- print('Setup Finished ok')
-
- def tearDown(self):
- self.initDate = None
- self.initialState = None
- self.tolerance = None
-
- # Test for issue #401 with numerical propagator
- def testInitNumerical(self):
- # setup
- reference = 1.25
- checker = InitCheckerEquations(reference)
- self.assertFalse(checker.wasCalled())
-
- # action
- integrator = DormandPrince853Integrator(0.001, 200.0, JArray_double.cast_(self.tolerance[0]),
- JArray_double.cast_(self.tolerance[1]))
- integrator.setInitialStepSize(60.0)
- propagatorNumerical = NumericalPropagator(integrator)
- propagatorNumerical.setInitialState(self.initialState.addAdditionalState(checker.getName(), reference))
- propagatorNumerical.addAdditionalEquations(checker)
- propagatorNumerical.propagate(self.initDate.shiftedBy(600.0))
-
- # verify
- self.assertTrue(checker.wasCalled())
-
- print('testInitNumerical finished ok')
-
- # Test for issue #401 with a DSST propagator
- def testInitDSST(self):
-
- # setup
- reference = 3.5
- checker = InitCheckerEquations(reference)
- self.assertFalse(checker.wasCalled())
-
- # action
- integrator = DormandPrince853Integrator(0.001, 200.0, JArray_double.cast_(self.tolerance[0]),
- JArray_double.cast_(self.tolerance[1]))
- integrator.setInitialStepSize(60.0)
-
- propagatorDSST = DSSTPropagator(integrator)
- propagatorDSST.setInitialState(self.initialState.addAdditionalState(checker.getName(), reference))
- propagatorDSST.addAdditionalEquations(checker)
- propagatorDSST.propagate(self.initDate.shiftedBy(600.0))
-
- # verify
- self.assertTrue(checker.wasCalled())
- print('testInitDSST was successfully finished')
-
-
-if __name__ == '__main__':
- suite = unittest.TestLoader().loadTestsFromTestCase(AdditionalEquationsTest)
- ret = not unittest.TextTestRunner(verbosity=2).run(suite).wasSuccessful()
- sys.exit(ret)
diff --git a/python_files/test/AltitudeDetectorTest.py b/python_files/test/AltitudeDetectorTest.py
index 623bcf55818602be254f668888d5133e52f72c34..779b51c5b72da012f3230234979f9df90de8c566 100644
--- a/python_files/test/AltitudeDetectorTest.py
+++ b/python_files/test/AltitudeDetectorTest.py
@@ -37,7 +37,7 @@ from org.orekit.bodies import CelestialBodyFactory
from org.orekit.bodies import OneAxisEllipsoid
from org.orekit.frames import FramesFactory
from org.orekit.orbits import KeplerianOrbit
-from org.orekit.orbits import PositionAngle
+from org.orekit.orbits import PositionAngleType
from org.orekit.propagation import SpacecraftState
from org.orekit.propagation.analytical import KeplerianPropagator
from org.orekit.propagation.events.handlers import StopOnEvent
@@ -59,12 +59,13 @@ class AltitudeDetectorTest(unittest.TestCase):
alt = apogee - earthRadius - 500
#// initial state is at apogee
- initialOrbit = KeplerianOrbit(a,e,0.0,0.0,0.0,FastMath.PI,PositionAngle.MEAN,EME2000,
+ initialOrbit = KeplerianOrbit(a,e,0.0,0.0,0.0,FastMath.PI,PositionAngleType.MEAN,EME2000,
initialDate,CelestialBodyFactory.getEarth().getGM())
initialState = SpacecraftState(initialOrbit)
kepPropagator = KeplerianPropagator(initialOrbit)
- altDetector = AltitudeDetector(alt,
- OneAxisEllipsoid(earthRadius, earthF, EME2000)).withHandler(StopOnEvent().of_(AltitudeDetector))
+ earth = OneAxisEllipsoid(earthRadius, earthF, EME2000)
+
+ altDetector = AltitudeDetector(alt, earth).withHandler(StopOnEvent())
# altitudeDetector should stop propagation upon reaching required altitude
kepPropagator.addEventDetector(altDetector)
diff --git a/python_files/test/BackAndForthDetectorTest.py b/python_files/test/BackAndForthDetectorTest.py
index 7cfb3dfb095fe4105e954ea991db4492704b35af..b39ac68b8759191291597e1c29a0c8d67d0ce54c 100644
--- a/python_files/test/BackAndForthDetectorTest.py
+++ b/python_files/test/BackAndForthDetectorTest.py
@@ -33,7 +33,7 @@ from org.orekit.bodies import OneAxisEllipsoid
from org.orekit.frames import TopocentricFrame
from org.orekit.orbits import KeplerianOrbit
from org.orekit.frames import FramesFactory
-from org.orekit.orbits import PositionAngle
+from org.orekit.orbits import PositionAngleType
from org.orekit.propagation.analytical import KeplerianPropagator
from org.orekit.propagation.events.handlers import EventHandler, PythonEventHandler
from org.orekit.time import AbsoluteDate
@@ -83,7 +83,7 @@ class BackAndForthDetectorTest(unittest.TestCase):
raan = math.radians(12.5)
lM = math.radians(60.)
iniOrb = KeplerianOrbit(a, e, i, w, raan, lM,
- PositionAngle.MEAN,
+ PositionAngleType.MEAN,
FramesFactory.getEME2000(), date0,
Constants.WGS84_EARTH_MU)
diff --git a/python_files/test/BrouwerLyddanePropagatorTest.py b/python_files/test/BrouwerLyddanePropagatorTest.py
index 7d455fb8a4d16211c3ee14067aa6706578dacc5a..3911df2d59d14166bcfc19e9f413a3d9bfa3cb41 100644
--- a/python_files/test/BrouwerLyddanePropagatorTest.py
+++ b/python_files/test/BrouwerLyddanePropagatorTest.py
@@ -17,7 +17,7 @@ from org.orekit.bodies import OneAxisEllipsoid
from org.orekit.frames import TopocentricFrame
from org.orekit.orbits import KeplerianOrbit
from org.orekit.frames import FramesFactory
-from org.orekit.orbits import PositionAngle, EquinoctialOrbit, OrbitType
+from org.orekit.orbits import PositionAngleType, EquinoctialOrbit, OrbitType
from org.orekit.propagation.analytical import KeplerianPropagator
from org.orekit.propagation import SpacecraftState
from org.orekit.propagation.numerical import NumericalPropagator
@@ -66,12 +66,12 @@ class BrouwerLyddanePropagatorTest(unittest.TestCase):
finalOrbit = extrapolator.propagate(initDate)
# positions velocity and semi major axis match perfectly
- self.assertAlmostEquals(0.0, Vector3D.distance(initialOrbit.getPVCoordinates().getPosition(),
+ self.assertAlmostEqual(0.0, Vector3D.distance(initialOrbit.getPVCoordinates().getPosition(),
finalOrbit.getPVCoordinates().getPosition()), delta=1.0e-8)
- self.assertAlmostEquals(0.0, Vector3D.distance(initialOrbit.getPVCoordinates().getVelocity(),
+ self.assertAlmostEqual(0.0, Vector3D.distance(initialOrbit.getPVCoordinates().getVelocity(),
finalOrbit.getPVCoordinates().getVelocity()), delta= 1.0e-11)
- self.assertAlmostEquals(0.0, finalOrbit.getA() - initialOrbit.getA(), delta=0.0)
+ self.assertAlmostEqual(0.0, finalOrbit.getA() - initialOrbit.getA(), delta=0.0)
def test_compareToNumericalPropagation(self):
@@ -86,7 +86,7 @@ class BrouwerLyddanePropagatorTest(unittest.TestCase):
omega = FastMath.toRadians(180.0) # perigee argument
raan = FastMath.toRadians(261.0) # right ascention of ascending node
lM = 0.0 # mean anomaly
- initialOrbit = KeplerianOrbit(a, e, i, omega, raan, lM, PositionAngle.TRUE,
+ initialOrbit = KeplerianOrbit(a, e, i, omega, raan, lM, PositionAngleType.TRUE,
inertialFrame, initDate, self.provider.getMu())
# Initial state definition
initialState = SpacecraftState(initialOrbit)
@@ -129,14 +129,14 @@ class BrouwerLyddanePropagatorTest(unittest.TestCase):
BLFinalState = BLextrapolator.propagate(initDate.shiftedBy(timeshift))
BLOrbit = KeplerianOrbit.cast_(OrbitType.KEPLERIAN.convertType(BLFinalState.getOrbit()))
- self.assertAlmostEquals(NumOrbit.getA(), BLOrbit.getA(), delta=0.072)
- self.assertAlmostEquals(NumOrbit.getE(), BLOrbit.getE(), delta=0.00000028)
- self.assertAlmostEquals(NumOrbit.getI(), BLOrbit.getI(), delta=0.000004)
- self.assertAlmostEquals(MathUtils.normalizeAngle(NumOrbit.getPerigeeArgument(), FastMath.PI),
+ self.assertAlmostEqual(NumOrbit.getA(), BLOrbit.getA(), delta=0.2)
+ self.assertAlmostEqual(NumOrbit.getE(), BLOrbit.getE(), delta=0.00000028)
+ self.assertAlmostEqual(NumOrbit.getI(), BLOrbit.getI(), delta=0.000004)
+ self.assertAlmostEqual(MathUtils.normalizeAngle(NumOrbit.getPerigeeArgument(), FastMath.PI),
MathUtils.normalizeAngle(BLOrbit.getPerigeeArgument(), FastMath.PI), delta=0.119)
- self.assertAlmostEquals(MathUtils.normalizeAngle(NumOrbit.getRightAscensionOfAscendingNode(), FastMath.PI),
+ self.assertAlmostEqual(MathUtils.normalizeAngle(NumOrbit.getRightAscensionOfAscendingNode(), FastMath.PI),
MathUtils.normalizeAngle(BLOrbit.getRightAscensionOfAscendingNode(), FastMath.PI), delta=0.000072)
- self.assertAlmostEquals(MathUtils.normalizeAngle(NumOrbit.getTrueAnomaly(), FastMath.PI),
+ self.assertAlmostEqual(MathUtils.normalizeAngle(NumOrbit.getTrueAnomaly(), FastMath.PI),
MathUtils.normalizeAngle(BLOrbit.getTrueAnomaly(), FastMath.PI), delta=0.12)
diff --git a/python_files/test/Context.py b/python_files/test/Context.py
index 2950981bab671f3f89e53a4c52e81024d20f7a54..3cfd342283953c488779d7db30a723eb2d2ebb84 100644
--- a/python_files/test/Context.py
+++ b/python_files/test/Context.py
@@ -36,7 +36,6 @@ from org.hipparchus.geometry.euclidean.threed import Vector3D
from org.hipparchus.ode.nonstiff import DormandPrince853Integrator
from orekit import JArray_double
from org.orekit.data import DataProvidersManager, ZipJarCrawler
-from org.orekit.propagation.integration import PythonAdditionalEquations
from org.orekit.forces.gravity.potential import GravityFieldFactory
from org.orekit.forces.gravity.potential import SHMFormatReader
from java.io import File
@@ -46,7 +45,7 @@ from org.hipparchus.geometry.euclidean.threed import Vector3D
from org.hipparchus.ode.nonstiff import DormandPrince853Integrator
from org.orekit.frames import FramesFactory
-from org.orekit.orbits import EquinoctialOrbit
+from org.orekit.orbits import EquinoctialOrbit, PositionAngleType
from org.orekit.orbits import OrbitType
from org.orekit.propagation import SpacecraftState
from org.orekit.propagation.numerical import NumericalPropagator
@@ -59,26 +58,13 @@ from java.io import File
from org.hipparchus.geometry.euclidean.threed import Rotation
from org.hipparchus.geometry.euclidean.threed import Vector3D
-from org.hipparchus.util import Decimal64Field
from org.hipparchus.util import FastMath
from org.orekit.bodies import CelestialBodyFactory
from org.orekit.frames import FramesFactory
from org.orekit.orbits import KeplerianOrbit
-from org.orekit.orbits import PositionAngle
-from org.orekit.propagation import FieldSpacecraftState
-from org.orekit.propagation import SpacecraftState
-from org.orekit.propagation.analytical import KeplerianPropagator
-from org.orekit.time import AbsoluteDate
-from org.orekit.time import DateComponents
-from org.orekit.time import FieldAbsoluteDate
-from org.orekit.time import TimeComponents
-from org.orekit.time import TimeScalesFactory
-from org.orekit.utils import AngularCoordinates
-from org.orekit.utils import PVCoordinates
-from org.orekit.utils import PVCoordinatesProvider
-from org.orekit.attitudes import CelestialBodyPointed, SpinStabilized, InertialProvider
+
# import java.util.List;
# import java.util.Map;
@@ -97,7 +83,7 @@ from org.orekit.frames import TopocentricFrame
from org.orekit.orbits import CartesianOrbit
# import org.orekit.orbits.Orbit;
# import org.orekit.orbits.OrbitType;
-# import org.orekit.orbits.PositionAngle;
+# import org.orekit.orbits.PositionAngleType;
from org.orekit.propagation.conversion import DormandPrince853IntegratorBuilder
from org.orekit.propagation.conversion import NumericalPropagatorBuilder
# import org.orekit.time.TimeScale;
@@ -126,7 +112,7 @@ class Context():
# // Map value = slave station associated
# public Map<GroundStation, GroundStation> TARstations;
- def createBuilder(self, orbitType, positionAngle, perfectStart, minStep, maxStep, dP, *forces):
+ def createBuilder(self, orbitType, positionAngle: PositionAngleType, perfectStart, minStep, maxStep, dP, *forces):
if perfectStart:
# orbit estimation will start from a perfect orbit
diff --git a/python_files/test/EphemerisEventsTest.py b/python_files/test/EphemerisEventsTest.py
new file mode 100644
index 0000000000000000000000000000000000000000..cfd3c809e6440847018c567c2c5e8b7fb05fc7fb
--- /dev/null
+++ b/python_files/test/EphemerisEventsTest.py
@@ -0,0 +1,186 @@
+# /* Copyright 2002-2023 CS GROUP
+# * Licensed to CS GROUP (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.
+# */
+# package org.orekit.propagation.analytical;
+#
+# import org.hipparchus.ode.events.Action;
+# import org.hipparchus.util.FastMath;
+# import org.junit.jupiter.api.Assertions;
+# import org.junit.jupiter.api.BeforeEach;
+# import org.junit.jupiter.api.Test;
+# import org.orekit.Utils;
+# import org.orekit.bodies.CelestialBodyFactory;
+# import org.orekit.bodies.OneAxisEllipsoid;
+# import org.orekit.errors.OrekitException;
+# import org.orekit.frames.Frame;
+# import org.orekit.frames.FramesFactory;
+# import org.orekit.orbits.KeplerianOrbit;
+# import org.orekit.orbits.Orbit;
+# import org.orekit.orbits.OrbitType;
+# import org.orekit.orbits.PositionAngleType;
+# import org.orekit.propagation.BoundedPropagator;
+# import org.orekit.propagation.Propagator;
+# import org.orekit.propagation.SpacecraftState;
+# import org.orekit.propagation.SpacecraftStateInterpolator;
+# import org.orekit.propagation.events.EclipseDetector;
+# import org.orekit.propagation.events.EventDetector;
+# import org.orekit.propagation.events.handlers.EventHandler;
+# import org.orekit.time.AbsoluteDate;
+# import org.orekit.time.DateComponents;
+# import org.orekit.time.TimeComponents;
+# import org.orekit.time.TimeInterpolator;
+# import org.orekit.time.TimeScalesFactory;
+# import org.orekit.utils.IERSConventions;
+#
+# import java.util.ArrayList;
+# import java.util.List;
+import orekit
+from org.orekit.propagation.analytical import Ephemeris, EcksteinHechlerPropagator
+
+orekit.initVM()
+import unittest
+
+
+from org.hipparchus.ode.events import Action
+from org.hipparchus.util import FastMath
+from org.orekit.bodies import CelestialBodyFactory, OneAxisEllipsoid
+from org.orekit.errors import OrekitException
+from org.orekit.frames import Frame, FramesFactory
+from org.orekit.orbits import KeplerianOrbit, Orbit, OrbitType, PositionAngleType
+from org.orekit.propagation import BoundedPropagator, Propagator, SpacecraftState, SpacecraftStateInterpolator
+from org.orekit.propagation.events import EclipseDetector, EventDetector
+from org.orekit.propagation.events.handlers import EventHandler, PythonEventHandler
+from org.orekit.time import AbsoluteDate, DateComponents, TimeComponents, TimeScalesFactory
+from org.orekit.utils import IERSConventions
+from java.util import ArrayList, List
+
+
+from orekit.pyhelpers import setup_orekit_curdir
+
+setup_orekit_curdir("resources")
+
+
+class MyEventHandler(PythonEventHandler):
+
+ orb_type = None
+ mainclass = None
+
+ def __init__(self, orb_type:OrbitType, mainclass):
+ self.orb_type = orb_type
+ self.mainclass = mainclass
+ super(MyEventHandler, self).__init__()
+
+
+ def init(self, *args):
+ self.mainclass.inEclipsecounter = 0
+ self.mainclass.outEclipsecounter = 0
+
+ def eventOccurred(self, s: SpacecraftState, eventDetector: EventDetector, increasing: bool) -> Action:
+ assert self.orb_type == s.getOrbit().getType()
+ if increasing:
+ mainclass.inEclipsecounter += 1
+ else:
+ mainclass.outEclipsecounter += 1
+ return Action.CONTINUE
+
+ def resetState(self, eventDetector, spacecraftState):
+ pass
+
+class EphemerisEventsTest(unittest.TestCase):
+
+ def testEphemKeplerian(self):
+ self.checkEphem(OrbitType.KEPLERIAN)
+
+ def testEphemCircular(self):
+ self.checkEphem(OrbitType.CIRCULAR)
+
+ def testEphemEquinoctial(self):
+ self.checkEphem(OrbitType.EQUINOCTIAL)
+
+ def testEphemCartesian(self):
+ self.checkEphem(OrbitType.CARTESIAN)
+
+ def buildEphem(self, orb_type: OrbitType):
+ mass = 2500.0
+ a = 7187990.1979844316
+ e = 0.5e-4
+ i = 1.7105407051081795
+ omega = 1.9674147913622104
+ OMEGA = FastMath.toRadians(261.0)
+ lv = 0.0
+ mu = 3.9860047e14
+ ae = 6.378137e6
+ c20 = -1.08263e-3
+ c30 = 2.54e-6
+ c40 = 1.62e-6
+ c50 = 2.3e-7
+ c60 = -5.5e-7
+
+ deltaT = self.finalDate.durationFrom(self.initDate)
+
+ frame = FramesFactory.getEME2000()
+
+ transPar = KeplerianOrbit(a, e, i, omega, OMEGA, lv, PositionAngleType.TRUE, frame, self.initDate, mu)
+
+ nbIntervals = 720
+ propagator = EcksteinHechlerPropagator(transPar, mass, ae, mu, c20, c30, c40, c50, c60)
+
+ tab = ArrayList(nbIntervals + 1)
+ for j in range(nbIntervals + 1):
+ state = propagator.propagate(self.initDate.shiftedBy((j * deltaT) / nbIntervals))
+ tab.add(SpacecraftState(orb_type.convertType(state.getOrbit()), state.getAttitude(), state.getMass()))
+
+ interpolator = SpacecraftStateInterpolator(2, frame, frame)
+
+ return Ephemeris(tab, interpolator)
+
+ def buildEclipseDetector(self, orb_type: OrbitType):
+ sunRadius = 696000000.
+ earthRadius = 6400000.
+
+ ecl = EclipseDetector(CelestialBodyFactory.getSun(), sunRadius,
+ OneAxisEllipsoid(earthRadius,
+ 0.0,
+ FramesFactory.getITRF(IERSConventions.IERS_2010, True)))
+ ecl = ecl.withMaxCheck(60.0).withThreshold(1.0e-3).withHandler(MyEventHandler(orb_type, self))
+ return ecl
+
+
+ def checkEphem(self, orb_type:OrbitType):
+ self.initDate = AbsoluteDate(DateComponents(2004, 1, 1),
+ TimeComponents.H00,
+ TimeScalesFactory.getUTC())
+
+
+ self.finalDate = AbsoluteDate(DateComponents(2004, 1, 2),
+ TimeComponents.H00,
+ TimeScalesFactory.getUTC())
+
+ ephem = self.buildEphem(orb_type)
+
+ ephem.addEventDetector(self.buildEclipseDetector(orb_type))
+
+ computeEnd = AbsoluteDate(self.finalDate, -1000.0)
+
+ Propagator.cast_(ephem).clearStepHandlers()
+ state = Propagator.cast_(ephem).propagate(computeEnd)
+ handler = ephem.getEventsDetectors().iterator().next().getHandler()
+ self.assertEqual(computeEnd, state.getDate())
+ self.assertEqual(14, self.inEclipsecounter)
+ self.assertEquals(14, self.outEclipsecounter)
+
+ def setUp(self):
+ pass
diff --git a/python_files/test/EstimationTestUtils.py b/python_files/test/EstimationTestUtils.py
index c3aee8aecfdb5e753479d2af6b78c45dc1f16af1..b8c6d08f97a7ad07135a241571fb28cbd11729b2 100644
--- a/python_files/test/EstimationTestUtils.py
+++ b/python_files/test/EstimationTestUtils.py
@@ -74,7 +74,7 @@ from org.orekit.models.earth.displacement import StationDisplacement
from org.orekit.models.earth.displacement import TidalDisplacement;
from org.orekit.orbits import KeplerianOrbit
# from org.orekit.orbits.Orbit;
-from org.orekit.orbits import PositionAngle
+from org.orekit.orbits import PositionAngleType
# from org.orekit.propagation.Propagator;
# from org.orekit.propagation.conversion.PropagatorBuilder;
# from org.orekit.propagation.numerical.NumericalPropagator;
@@ -133,7 +133,7 @@ class EstimationTestUtils():
map))
context.gravity = GravityFieldFactory.getNormalizedProvider(20, 20)
context.initialOrbit = KeplerianOrbit(15000000.0, 0.125, 1.25,
- 0.250, 1.375, 0.0625, PositionAngle.TRUE,
+ 0.250, 1.375, 0.0625, PositionAngleType.TRUE,
FramesFactory.getEME2000(),
AbsoluteDate(2000, 2, 24, 11, 35, 47.0, context.utc),
context.gravity.getMu())
@@ -159,7 +159,7 @@ class EstimationTestUtils():
# override orbital parameters
orbitArray = JArray_double(6)
propagatorBuilder.getOrbitType().mapOrbitToArray(initialOrbit,
- propagatorBuilder.getPositionAngle(),
+ propagatorBuilder.getPositionAngleType(),
orbitArray, None);
for i in range(0, len(orbitArray)-1):
propagatorBuilder.getOrbitalParametersDrivers().getDrivers().get(i).setValue(orbitArray[i])
@@ -219,7 +219,7 @@ public class EstimationTestUtils {
map));
context.gravity = GravityFieldFactory.getNormalizedProvider(20, 20);
context.initialOrbit = new KeplerianOrbit(15000000.0, 0.125, 1.25,
- 0.250, 1.375, 0.0625, PositionAngle.TRUE,
+ 0.250, 1.375, 0.0625, PositionAngleType.TRUE,
FramesFactory.getEME2000(),
new AbsoluteDate(2000, 2, 24, 11, 35, 47.0, context.utc),
context.gravity.getMu());
@@ -474,7 +474,7 @@ public class EstimationTestUtils {
*/
public static void checkKalmanFit(final Context context, final KalmanEstimator kalman,
final List<ObservedMeasurement<?>> measurements,
- final Orbit refOrbit, final PositionAngle positionAngle,
+ final Orbit refOrbit, final PositionAngleType positionAngle,
final double expectedDeltaPos, final double posEps,
final double expectedDeltaVel, final double velEps,
final double[] expectedSigmasPos,final double sigmaPosEps,
@@ -482,7 +482,7 @@ public class EstimationTestUtils {
{
checkKalmanFit(context, kalman, measurements,
new Orbit[] { refOrbit },
- new PositionAngle[] { positionAngle },
+ new PositionAngleType[] { positionAngle },
new double[] { expectedDeltaPos }, new double[] { posEps },
new double[] { expectedDeltaVel }, new double[] { velEps },
new double[][] { expectedSigmasPos }, new double[] { sigmaPosEps },
@@ -506,7 +506,7 @@ public class EstimationTestUtils {
*/
public static void checkKalmanFit(final Context context, final KalmanEstimator kalman,
final List<ObservedMeasurement<?>> measurements,
- final Orbit[] refOrbit, final PositionAngle[] positionAngle,
+ final Orbit[] refOrbit, final PositionAngleType[] positionAngle,
final double[] expectedDeltaPos, final double[] posEps,
final double[] expectedDeltaVel, final double []velEps,
final double[][] expectedSigmasPos,final double[] sigmaPosEps,
diff --git a/python_files/test/EventDetectorTest.py b/python_files/test/EventDetectorTest.py
index 334152811e5809d530e8133a91080f4d35ee862b..8fd439a656bfbd23694bb93029954209c364a016 100644
--- a/python_files/test/EventDetectorTest.py
+++ b/python_files/test/EventDetectorTest.py
@@ -23,6 +23,7 @@
"""
import orekit
+from org.orekit.propagation import SpacecraftState
orekit.initVM()
# orekit.initVM(vmargs='-Xcheck:jni,-verbose:jni,-verbose:class,-XX:+UnlockDiagnosticVMOptions')
@@ -34,10 +35,9 @@ from org.orekit.orbits import KeplerianOrbit
from org.orekit.utils import Constants
from org.orekit.propagation.analytical import KeplerianPropagator
from org.orekit.utils import PVCoordinates, IERSConventions
-from org.orekit.propagation.events.handlers import EventHandler
+from org.orekit.propagation.events.handlers import EventHandler, ContinueOnEvent, StopOnEvent, PythonEventHandler
from org.hipparchus.geometry.euclidean.threed import Vector3D
-from org.orekit.propagation.events.handlers import PythonEventHandler
-from org.orekit.propagation.events import PythonAbstractDetector, PythonEventDetector
+from org.orekit.propagation.events import PythonAbstractDetector, PythonEventDetector, PythonAdaptableInterval
from org.hipparchus.ode.events import Action
@@ -51,12 +51,34 @@ from orekit.pyhelpers import setup_orekit_curdir
setup_orekit_curdir("resources")
+class MyEventCounter(PythonEventHandler):
+ def __init__(self):
+ self.events = 0
+ super(MyEventCounter, self).__init__()
+
+ def init(self, initialstate, target, detector):
+ print(initialstate, target, detector)
+
+ def eventOccurred(self, s, detector, increasing: bool):
+ if increasing:
+ self.events += 1
+ return Action.CONTINUE
+
+ def resetState(self, detector, oldState):
+ return oldState
+
+mycounter = MyEventCounter()
+
+class MyAdaptableInterval(PythonAdaptableInterval):
+ def currentInterval(self, s):
+ return float(PythonAbstractDetector.DEFAULT_MAXCHECK)
+
class MyElevationDetector(PythonEventDetector):
passes = 0
def __init__(self, elevation, topo):
self.elevation = elevation
- self.topo = topo
+ self.topo: TopocentricFrame = topo
super(MyElevationDetector, self).__init__()
def init(self, s, T):
@@ -66,21 +88,15 @@ class MyElevationDetector(PythonEventDetector):
return float(PythonAbstractDetector.DEFAULT_THRESHOLD)
def getMaxCheckInterval(self):
- return float(PythonAbstractDetector.DEFAULT_MAXCHECK)
+ return MyAdaptableInterval()
def getMaxIterationCount(self):
return PythonAbstractDetector.DEFAULT_MAX_ITER
- def g(self, s):
+ def g(self, s: SpacecraftState):
tmp = self.topo.getElevation(s.getPVCoordinates().getPosition(), s.getFrame(), s.getDate()) - self.elevation
return tmp
- def eventOccurred(self, s, increasing):
- if increasing:
- self.passes = self.passes + 1
-
- return Action.CONTINUE
-
def resetState(self, oldState):
return oldState
@@ -90,6 +106,9 @@ class MyElevationDetector(PythonEventDetector):
def getTopocentricFrame(self):
return self.topo
+ def getHandler(self):
+ return mycounter
+
class EventDetectorTest(unittest.TestCase):
@@ -125,8 +144,8 @@ class EventDetectorTest(unittest.TestCase):
finalState = kepler.propagate(initialDate.shiftedBy(60 * 60 * 24.0 * 15))
- print(detector.passes)
- self.assertEqual(52, detector.passes)
+ print(mycounter.events)
+ self.assertEqual(52, mycounter.events)
if __name__ == '__main__':
diff --git a/python_files/test/EventHandlerTest.py b/python_files/test/EventHandlerTest.py
index 9580237d8d0c2a4e46424432a307d0d670fa0dd1..f963f746750f8f8d0463f5a2619e8214f810269f 100644
--- a/python_files/test/EventHandlerTest.py
+++ b/python_files/test/EventHandlerTest.py
@@ -24,6 +24,8 @@ Python version translated from Java by Petrus Hyvönen, SSC 2014
"""
import orekit
+from org.orekit.propagation import SpacecraftState
+
orekit.initVM()
from org.orekit.frames import FramesFactory, TopocentricFrame
@@ -34,7 +36,7 @@ from org.orekit.utils import Constants
from org.orekit.propagation.analytical import KeplerianPropagator
from org.orekit.utils import PVCoordinates, IERSConventions
from org.orekit.propagation.events import ElevationDetector
-from org.orekit.propagation.events.handlers import EventHandler, PythonEventHandler
+from org.orekit.propagation.events.handlers import PythonEventHandler
from org.hipparchus.geometry.euclidean.threed import Vector3D
from org.orekit.propagation.events import EventsLogger
from org.hipparchus.ode.events import Action
@@ -85,7 +87,7 @@ class EventHandlerTest(unittest.TestCase):
def init(self, initialstate, target, detector):
pass
- def eventOccurred(self, s, T, increasing):
+ def eventOccurred(self, s: SpacecraftState, detector, increasing):
return Action.CONTINUE
def resetState(self, detector, oldState):
@@ -93,7 +95,7 @@ class EventHandlerTest(unittest.TestCase):
#%% detectors
detector = ElevationDetector(sta1Frame).withConstantElevation(elevation)
- detector = detector.withHandler(myContinueOnEvent().of_(ElevationDetector))
+ detector = detector.withHandler(myContinueOnEvent())
logger = EventsLogger()
kepler.addEventDetector(logger.monitorDetector(detector))
diff --git a/python_files/test/FieldAdditionalEquationsTest.py b/python_files/test/FieldAdditionalEquationsTest.py
deleted file mode 100644
index 440507e84cbd88bc38afe147a3a06b173e4707b4..0000000000000000000000000000000000000000
--- a/python_files/test/FieldAdditionalEquationsTest.py
+++ /dev/null
@@ -1,151 +0,0 @@
-# -*- coding: utf-8 -*-
-
-
-"""
-/* Copyright 2002-2018 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 2018
-
-"""
-
-import unittest
-import sys
-
-# Python orekit specifics
-import orekit
-
-orekit.initVM()
-
-from orekit import JArray_double
-from org.orekit.data import DataProvidersManager, ZipJarCrawler, DataContext, DirectoryCrawler
-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 CalculusFieldElement
-
-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.hipparchus.util import MathArrays
-from org.hipparchus.util import Decimal64Field
-
-
-
-# The class to be the additional equation
-class InitCheckerEquations(PythonFieldAdditionalEquations): # implements AdditionalEquations
-
- # This is the method called for object creation as in java InitCheckerEquations(self, expected)
- def __init__(self, expected):
- super(InitCheckerEquations, self).__init__()
- self.expected = expected
- self.called = False
-
- # Part of AdditionalEquations interface
- def init(self, initialState, target):
- assert (self.expected - 1.0e-15) < initialState.getAdditionalState(self.getName())[0].getReal() < (
- self.expected + 1.0e-15)
- self.called = True
-
- # Part of AdditionalEquations interface
- def computeDerivatives(self, s, pDot):
- zerovalue = CalculusFieldElement.cast_(s.getDate().getField().getZero()) # Not completely sure why this needs casting but becomes just an "Object" otherwise
- pDot[0] = zerovalue.add(1.5)
- return MathArrays.buildArray(s.getDate().getField(), 7)
-
- # Part of AdditionalEquations interface
- def getName(self):
- return "linear"
-
- def wasCalled(self):
- return self.called
-
-
-class FieldAdditionalEquationsTest(unittest.TestCase):
- def setUp(self):
- # Initialize the data sources
- DM = DataContext.getDefault().getDataProvidersManager()
- datafile = File('resources')
- if not datafile.exists():
- print('File :', datafile.absolutePath, ' not found')
-
- crawler = DirectoryCrawler(datafile)
- DM.clearProviders()
- DM.addProvider(crawler)
- System.setProperty(DataProvidersManager.OREKIT_DATA_PATH, 'potential/shm-format')
- GravityFieldFactory.addPotentialCoefficientsReader(SHMFormatReader("^eigen_cg03c_coef$", False))
-
- mu = GravityFieldFactory.getUnnormalizedProvider(0, 0).getMu()
- position = Vector3D(7.0e6, 1.0e6, 4.0e6)
- velocity = Vector3D(-500.0, 8000.0, 1000.0)
- self.initDate = AbsoluteDate.J2000_EPOCH
- orbit = EquinoctialOrbit(PVCoordinates(position, velocity),
- FramesFactory.getEME2000(), self.initDate, mu)
- self.initialState = SpacecraftState(orbit)
- self.tolerance = NumericalPropagator.tolerances(0.001, orbit, OrbitType.EQUINOCTIAL)
-
- print('Setup Finished ok')
-
- def tearDown(self):
- self.initDate = None
- self.initialState = None
- self.tolerance = None
-
- # Test for issue #401 with numerical propagator
- def testInitNumerical(self):
- self.doTestInitNumerical(Decimal64Field.getInstance())
-
- def doTestInitNumerical(self, field):
- # setup
- reference = 1.25
- checker = InitCheckerEquations(reference)
- self.assertFalse(checker.wasCalled())
-
- # action
- integrator = DormandPrince853FieldIntegrator(field, 0.001, 200.0, JArray_double.cast_(self.tolerance[0]),
- JArray_double.cast_(self.tolerance[1]))
- integrator.setInitialStepSize(60.0)
- propagatorNumerical = FieldNumericalPropagator(field, integrator)
- propagatorNumerical.setInitialState(
- FieldSpacecraftState(field, self.initialState).addAdditionalState(checker.getName(),
- field.getZero().add(reference)))
- propagatorNumerical.addAdditionalEquations(checker)
- propagatorNumerical.propagate(FieldAbsoluteDate(field, self.initDate).shiftedBy(600.0))
-
- # verify
- self.assertTrue(checker.wasCalled())
-
- print('testInitNumerical finished ok')
-
-
-if __name__ == '__main__':
- suite = unittest.TestLoader().loadTestsFromTestCase(FieldAdditionalEquationsTest)
- ret = not unittest.TextTestRunner(verbosity=2).run(suite).wasSuccessful()
- sys.exit(ret)
diff --git a/python_files/test/FieldStopOnDecreasingTest.py b/python_files/test/FieldStopOnDecreasingTest.py
index e28f040b619519f3db705d0f180f0113acbdd106..5eee475a7521a8b63772d74603ea8a09813db0d1 100644
--- a/python_files/test/FieldStopOnDecreasingTest.py
+++ b/python_files/test/FieldStopOnDecreasingTest.py
@@ -34,9 +34,9 @@ orekit.initVM()
from org.orekit.frames import FramesFactory
from org.orekit.propagation import FieldSpacecraftState
from org.orekit.time import FieldAbsoluteDate
-from org.hipparchus.util import Decimal64Field
+from org.hipparchus.util import Binary64Field
from org.orekit.orbits import FieldKeplerianOrbit
-from org.orekit.orbits import PositionAngle
+from org.orekit.orbits import PositionAngleType
from org.orekit.utils import Constants
from org.orekit.propagation.events.handlers import FieldStopOnDecreasing
from org.orekit.propagation.events.handlers import FieldEventHandler
@@ -46,13 +46,11 @@ from org.hipparchus.ode.events import Action
class FieldStopOnDecreasingTest(unittest.TestCase):
def testNoReset(self):
- self.doTestNoReset(Decimal64Field.getInstance())
+ self.doTestNoReset(Binary64Field.getInstance())
def testIncreasing(self):
- self.doTestIncreasing(Decimal64Field.getInstance())
+ self.doTestIncreasing(Binary64Field.getInstance())
- # def testDecreasing(self):
- # self.doTestDecreasing(Decimal64Field.getInstance())
def doTestNoReset(self, field):
zero = field.getZero()
@@ -63,7 +61,7 @@ class FieldStopOnDecreasingTest(unittest.TestCase):
zero.add(3.10686),
zero.add(1.00681),
zero.add(0.048363),
- PositionAngle.MEAN,
+ PositionAngleType.MEAN,
FramesFactory.getEME2000(),
date,
zero.add(Constants.EIGEN5C_EARTH_MU)))
@@ -83,7 +81,7 @@ class FieldStopOnDecreasingTest(unittest.TestCase):
zero.add(3.10686),
zero.add(1.00681),
zero.add(0.048363),
- PositionAngle.MEAN,
+ PositionAngleType.MEAN,
FramesFactory.getEME2000(),
date,
zero.add(Constants.EIGEN5C_EARTH_MU)))
@@ -107,7 +105,7 @@ class FieldStopOnDecreasingTest(unittest.TestCase):
zero.add(3.10686),
zero.add(1.00681),
zero.add(0.048363),
- PositionAngle.MEAN,
+ PositionAngleType.MEAN,
FramesFactory.getEME2000(),
date,
Constants.EIGEN5C_EARTH_MU));
diff --git a/python_files/test/FixedRateTest.py b/python_files/test/FixedRateTest.py
new file mode 100644
index 0000000000000000000000000000000000000000..d756c2d03fe26d74ad7ef7d72611987261358e93
--- /dev/null
+++ b/python_files/test/FixedRateTest.py
@@ -0,0 +1,120 @@
+import unittest
+
+import orekit
+orekit.initVM()
+
+from org.hipparchus.geometry.euclidean.threed import Rotation, Vector3D
+from org.orekit.attitudes import Attitude, FixedRate
+from org.orekit.frames import FramesFactory
+from org.orekit.orbits import KeplerianOrbit
+from org.orekit.time import AbsoluteDate, DateComponents, TimeComponents, TimeScalesFactory
+from org.orekit.utils import PVCoordinates, AngularCoordinates
+from org.hipparchus.util import FastMath
+from org.orekit.orbits import PositionAngleType
+from org.orekit.propagation.analytical import KeplerianPropagator
+
+from java.io import File
+from org.orekit.data import DataContext, DirectoryCrawler
+
+class OrekitFixedRateTest(unittest.TestCase):
+ def setUp(self):
+ DM = DataContext.getDefault().getDataProvidersManager()
+ datafile = File('resources')
+ if not datafile.exists():
+ print('File :', datafile.absolutePath, ' not found')
+
+ crawler = DirectoryCrawler(datafile)
+ DM.clearProviders()
+ DM.addProvider(crawler)
+
+ def test_zero_rate(self):
+ date = AbsoluteDate(DateComponents(2004, 3, 2),
+ TimeComponents(13, 17, 7.865),
+ TimeScalesFactory.getUTC())
+ frame = FramesFactory.getEME2000()
+ law = FixedRate(Attitude(date, frame,
+ Rotation(0.48, 0.64, 0.36, 0.48, False),
+ Vector3D.ZERO, Vector3D.ZERO))
+ pv = PVCoordinates(Vector3D(28812595.32012577, 5948437.4640250085, 0.0),
+ Vector3D(0.0, 0.0, 3680.853673522056))
+ orbit = KeplerianOrbit(pv, frame, date, 3.986004415e14)
+ attitude0 = law.getAttitude(orbit, date, frame).getRotation()
+ self.assertAlmostEqual(0, Rotation.distance(attitude0, law.getReferenceAttitude().getRotation()), delta=1.0e-10)
+ attitude1 = law.getAttitude(orbit.shiftedBy(10.0), date.shiftedBy(10.0), frame).getRotation()
+ self.assertAlmostEqual(0, Rotation.distance(attitude1, law.getReferenceAttitude().getRotation()), delta=1.0e-10)
+ attitude2 = law.getAttitude(orbit.shiftedBy(20.0), date.shiftedBy(20.0), frame).getRotation()
+ self.assertAlmostEqual(0, Rotation.distance(attitude2, law.getReferenceAttitude().getRotation()), delta=1.0e-10)
+
+
+ def test_non_zero_rate(self):
+ date = AbsoluteDate(DateComponents(2004, 3, 2),
+ TimeComponents(13, 17, 7.865),
+ TimeScalesFactory.getUTC())
+ rate = 2 * FastMath.PI / (12 * 60)
+ frame = FramesFactory.getEME2000()
+ gcrf = FramesFactory.getGCRF()
+ law = FixedRate(Attitude(date, frame,
+ Rotation(0.48, 0.64, 0.36, 0.48, False),
+ Vector3D(rate, Vector3D.PLUS_K), Vector3D.ZERO))
+ ref = law.getReferenceAttitude().getRotation().applyTo(gcrf.getTransformTo(frame, date).getRotation())
+ pv = PVCoordinates(Vector3D(28812595.32012577, 5948437.4640250085, 0.0),
+ Vector3D(0.0, 0.0, 3680.853673522056))
+ orbit = KeplerianOrbit(pv, frame, date, 3.986004415e14)
+ attitude0 = law.getAttitude(orbit, date, gcrf).getRotation()
+ self.assertAlmostEqual(0, Rotation.distance(attitude0, ref), delta=1.0e-10)
+ attitude1 = law.getAttitude(orbit.shiftedBy(10.0), date.shiftedBy(10.0), gcrf).getRotation()
+ self.assertAlmostEqual(10 * rate, Rotation.distance(attitude1, ref), delta=1.0e-10)
+ attitude2 = law.getAttitude(orbit.shiftedBy(-20.0), date.shiftedBy(-20.0), gcrf).getRotation()
+ self.assertAlmostEqual(20 * rate, Rotation.distance(attitude2, ref), delta=1.0e-10)
+ self.assertAlmostEqual(30 * rate, Rotation.distance(attitude2, attitude1), delta=1.0e-10)
+ attitude3 = law.getAttitude(orbit.shiftedBy(0.0), date, frame).getRotation()
+ self.assertAlmostEqual(0, Rotation.distance(attitude3, law.getReferenceAttitude().getRotation()), delta=1.0e-10)
+
+
+ def test_spin(self):
+ date = AbsoluteDate(DateComponents(1970, 1, 1),
+ TimeComponents(3, 25, 45.6789),
+ TimeScalesFactory.getUTC())
+
+ rate = 2 * FastMath.PI / (12 * 60)
+ law = FixedRate(Attitude(date, FramesFactory.getEME2000(),
+ Rotation(0.48, 0.64, 0.36, 0.48, False),
+ Vector3D(rate, Vector3D.PLUS_K),
+ Vector3D.ZERO))
+
+ orbit = KeplerianOrbit(7178000.0, 1.e-4, FastMath.toRadians(50.0),
+ FastMath.toRadians(10.0), FastMath.toRadians(20.0),
+ FastMath.toRadians(30.0), PositionAngleType.MEAN,
+ FramesFactory.getEME2000(), date, 3.986004415e14)
+
+ propagator = KeplerianPropagator(orbit, law)
+
+ h = 0.01
+ s_minus = propagator.propagate(date.shiftedBy(-h))
+ s0 = propagator.propagate(date)
+ s_plus = propagator.propagate(date.shiftedBy(h))
+
+ error_angle_minus = Rotation.distance(s_minus.shiftedBy(h).getAttitude().getRotation(),
+ s0.getAttitude().getRotation())
+ evolution_angle_minus = Rotation.distance(s_minus.getAttitude().getRotation(),
+ s0.getAttitude().getRotation())
+ self.assertAlmostEqual(0.0, error_angle_minus, delta=1.0e-6 * evolution_angle_minus)
+
+ error_angle_plus = Rotation.distance(s0.getAttitude().getRotation(),
+ s_plus.shiftedBy(-h).getAttitude().getRotation())
+ evolution_angle_plus = Rotation.distance(s0.getAttitude().getRotation(),
+ s_plus.getAttitude().getRotation())
+ self.assertAlmostEqual(0.0, error_angle_plus, delta=1.0e-6 * evolution_angle_plus)
+
+ spin0 = s0.getAttitude().getSpin()
+ reference = AngularCoordinates.estimateRate(s_minus.getAttitude().getRotation(),
+ s_plus.getAttitude().getRotation(),
+ 2 * h)
+ self.assertAlmostEqual(0.0, spin0.subtract(reference).getNorm(), delta=1.0e-14)
+
+
+
+if __name__ == '__main__':
+ suite = unittest.TestLoader().loadTestsFromTestCase(OrekitFixedRateTest)
+ unittest.TextTestRunner(verbosity=2).run(suite)
+
diff --git a/python_files/test/GroundFieldOfViewDetectorTest.py b/python_files/test/GroundFieldOfViewDetectorTest.py
index b95e042dab5c51a5717da6478566b5150ca7a10b..364ead59866e93eb9d71254c5a98f61abea9cb51 100644
--- a/python_files/test/GroundFieldOfViewDetectorTest.py
+++ b/python_files/test/GroundFieldOfViewDetectorTest.py
@@ -30,7 +30,7 @@ orekit.initVM()
from org.orekit.frames import FramesFactory, TopocentricFrame
from org.orekit.bodies import OneAxisEllipsoid, GeodeticPoint
from org.orekit.time import AbsoluteDate
-from org.orekit.orbits import KeplerianOrbit, PositionAngle
+from org.orekit.orbits import KeplerianOrbit, PositionAngleType
from org.orekit.utils import Constants
from org.orekit.propagation.analytical import KeplerianPropagator
from org.orekit.utils import IERSConventions
@@ -67,7 +67,7 @@ class GroundFieldOfViewDetectorTest(unittest.TestCase):
# iss like orbit
orbit = KeplerianOrbit(
6378137.0 + 400e3, 0.0, radians(51.65), 0.0, 0.0, 0.0,
- PositionAngle.TRUE, eci, date, Constants.EGM96_EARTH_MU)
+ PositionAngleType.TRUE, eci, date, Constants.EGM96_EARTH_MU)
prop = KeplerianPropagator(orbit)
diff --git a/python_files/test/GroundPointingTest.py b/python_files/test/GroundPointingTest.py
new file mode 100644
index 0000000000000000000000000000000000000000..31a838aabbf78d45525f29f26914ee9994371979
--- /dev/null
+++ b/python_files/test/GroundPointingTest.py
@@ -0,0 +1,145 @@
+# Python orekit specifics
+import sys
+import orekit
+orekit.initVM()
+
+
+
+import unittest
+from typing import Union
+from org.orekit.data import DataProvidersManager, ZipJarCrawler, DataContext, DirectoryCrawler
+from java.io import File
+
+from orekit import JArray_double
+from orekit.pyhelpers import absolutedate_to_datetime
+from org.hipparchus import CalculusFieldElement
+from org.hipparchus.analysis.differentiation import GradientField, UnivariateDerivative1, UnivariateDerivative2
+from org.hipparchus.complex import ComplexField
+from org.hipparchus.geometry.euclidean.threed import FieldRotation, FieldVector3D, Rotation, Vector3D
+from org.hipparchus.util import Binary64Field
+from org.orekit.attitudes import GroundPointing, PythonGroundPointing
+from org.orekit.frames import FramesFactory, Frame
+from org.orekit.orbits import EquinoctialOrbit, FieldEquinoctialOrbit, PositionAngleType
+from org.orekit.time import AbsoluteDate, FieldAbsoluteDate
+from org.orekit.utils import IERSConventions, Constants, PVCoordinatesProvider, TimeStampedPVCoordinates, FieldPVCoordinatesProvider, TimeStampedFieldPVCoordinates, PVCoordinates, FieldPVCoordinates
+import unittest
+from org.hipparchus.analysis.differentiation import GradientField, UnivariateDerivative2
+
+
+# class TestGroundPointing(PythonGroundPointing):
+# def getTargetPV(self, pvProv, date, frame) -> Union[TimeStampedPVCoordinates,TimeStampedFieldPVCoordinates]:
+# if isinstance(pvProv, FieldPVCoordinatesProvider):
+# return TimeStampedFieldPVCoordinates(date, FieldPVCoordinates.getZero(date.getField()))
+
+# elif isinstance(pvProv, PVCoordinatesProvider):
+# return TimeStampedPVCoordinates(date, PVCoordinates.ZERO)
+
+# else:
+# raise RuntimeError(f'Not supported type of PVCoordinatesProvider: {type(pvProv).__name__}')
+
+
+class TestGroundPointing(PythonGroundPointing):
+ def getTargetPV(self, pvProv, date, frame) -> Union[TimeStampedPVCoordinates,TimeStampedFieldPVCoordinates]:
+ match ([pvProv, date, frame]):
+ case [FieldPVCoordinatesProvider(), _,_]:
+ return TimeStampedFieldPVCoordinates(date, FieldPVCoordinates.getZero(date.getField()))
+
+ case [PVCoordinatesProvider(), _,_]:
+ return TimeStampedPVCoordinates(date, PVCoordinates.ZERO)
+
+ case _:
+ raise RuntimeError(f'Not supported type of PVCoordinatesProvider: {type(pvProv).__name__}')
+
+
+class GroundPointingTest(unittest.TestCase):
+ INERTIAL_FRAME = None
+ OTHER_INERTIAL_FRAME = None
+ EARTH_FIXED_FRAME = None
+
+ def setUp(self):
+
+ DM = DataContext.getDefault().getDataProvidersManager()
+ datafile = File('../test/resources')
+ if not datafile.exists():
+ print('File :', datafile.absolutePath, ' not found')
+
+ crawler = DirectoryCrawler(datafile)
+ DM.clearProviders()
+ DM.addProvider(crawler)
+ self.INERTIAL_FRAME = FramesFactory.getEME2000()
+ self.OTHER_INERTIAL_FRAME = FramesFactory.getGCRF()
+ self.EARTH_FIXED_FRAME = FramesFactory.getITRF(IERSConventions.IERS_2010, True)
+
+ def createPVCoordinatesProvider(self):
+ epoch = AbsoluteDate.ARBITRARY_EPOCH
+ semiMajorAxis = 45000.0e3
+ mu = Constants.EGM96_EARTH_MU
+ return EquinoctialOrbit(semiMajorAxis, 0., 0., 0., 0., 0., PositionAngleType.ECCENTRIC, self.INERTIAL_FRAME, epoch, mu)
+
+ def templateTestGetRotation(self, frame):
+ # setup
+ groundPointing = TestGroundPointing(self.INERTIAL_FRAME, self.EARTH_FIXED_FRAME)
+ orbit = self.createPVCoordinatesProvider()
+
+ actualRotation = groundPointing.getAttitudeRotation(orbit, orbit.getDate(), frame)
+ # verify
+ attitude = groundPointing.getAttitude(orbit, orbit.getDate(), frame)
+ expectedRotation = attitude.getRotation()
+ self.assertEqual(0., Rotation.distance(expectedRotation, actualRotation))
+
+ def testtemplateTestGetRotationRateSameFrame(self):
+ self.templateTestGetRotation(self.INERTIAL_FRAME)
+
+ def testtemplateTestGetRotationRateDifferentFrame(self):
+ self.templateTestGetRotation(self.OTHER_INERTIAL_FRAME)
+
+ def testGetAttitudeRotiationFieldSameFrame(self):
+ self.templateTestGetRotationField(ComplexField.getInstance(), self.INERTIAL_FRAME)
+
+ def testGetAttitudeRotiationFieldDifferentFrame(self):
+ self.templateTestGetRotationField(UnivariateDerivative1(0., 0.).getField(), self.OTHER_INERTIAL_FRAME)
+
+ def templateTestGetRotationField(self, field, frame):
+ # GIVEN
+ groundPointing = TestGroundPointing(self.INERTIAL_FRAME, self.EARTH_FIXED_FRAME)
+ orbit = self.createPVCoordinatesProvider()
+ fieldOrbit = self.convertToField(field, orbit)
+ # WHEN
+ actualRotation = groundPointing.getAttitudeRotation(fieldOrbit, fieldOrbit.getDate(), frame)
+ # THEN
+ attitude = groundPointing.getAttitude(fieldOrbit, fieldOrbit.getDate(), frame)
+ expectedRotation = attitude.getRotation()
+ assert 0. == Rotation.distance(expectedRotation.toRotation(), actualRotation.toRotation())
+
+
+ def testGetAttitudeFieldGradient(self):
+ self.templateTestGetAttitudeField(GradientField.getField(1))
+
+ def testGetAttitudeFieldUnivariateDerivative2(self):
+ self.templateTestGetAttitudeField(UnivariateDerivative2(0., 0., 0.).getField())
+
+
+
+ def templateTestGetAttitudeField(self, field):
+ groundPointing = TestGroundPointing(self.INERTIAL_FRAME, self.EARTH_FIXED_FRAME)
+ orbit = self.createPVCoordinatesProvider()
+ fieldOrbit = self.convertToField(field, orbit)
+ actualAttitude = groundPointing.getAttitude(fieldOrbit, fieldOrbit.getDate(), self.OTHER_INERTIAL_FRAME).toAttitude()
+ expectedAttitude = groundPointing.getAttitude(orbit, orbit.getDate(), self.OTHER_INERTIAL_FRAME)
+ assert 0. == Rotation.distance(expectedAttitude.getRotation(), actualAttitude.getRotation())
+ assert str(expectedAttitude.getSpin()) == str(actualAttitude.getSpin())
+ assert str(expectedAttitude.getRotationAcceleration()) == str(actualAttitude.getRotationAcceleration())
+
+ def convertToField(self, field, orbit) -> FieldEquinoctialOrbit:
+ zero = field.getZero()
+ fieldSemiMajorAxis = zero.add(orbit.getA())
+ fieldDate = FieldAbsoluteDate(field, orbit.getDate())
+ positionAngleType = PositionAngleType.MEAN
+ fieldAngle = zero.add(orbit.getL(positionAngleType))
+ return FieldEquinoctialOrbit(fieldSemiMajorAxis, zero, zero, zero, zero, fieldAngle, positionAngleType, orbit.getFrame(), fieldDate, zero.add(orbit.getMu()))
+
+
+if __name__ == '__main__':
+ suite = unittest.TestLoader().loadTestsFromTestCase(GroundPointingTest)
+ ret = not unittest.TextTestRunner(verbosity=2).run(suite).wasSuccessful()
+ sys.exit(ret)
diff --git a/python_files/test/ImpulseManeuverTest.py b/python_files/test/ImpulseManeuverTest.py
index 1eb26c2b25300f46593e750cf0312155fef65269..179af786f48822420a95d249869cb3300bcd6312 100644
--- a/python_files/test/ImpulseManeuverTest.py
+++ b/python_files/test/ImpulseManeuverTest.py
@@ -35,7 +35,7 @@ from org.orekit.attitudes import LofOffset
from org.orekit.frames import FramesFactory
from org.orekit.frames import LOFType
from org.orekit.orbits import KeplerianOrbit
-from org.orekit.orbits import PositionAngle
+from org.orekit.orbits import PositionAngleType
from org.orekit.propagation.analytical import KeplerianPropagator
from org.orekit.propagation.events import NodeDetector
from org.orekit.time import AbsoluteDate
@@ -56,7 +56,7 @@ class ImpulseManeuverTest(unittest.TestCase):
FastMath.PI,
0.4,
2.0,
- PositionAngle.MEAN,
+ PositionAngleType.MEAN,
FramesFactory.getEME2000(),
AbsoluteDate(DateComponents(2008, 6, 23),
TimeComponents(14, 18, 37.0),
diff --git a/python_files/test/InterSatDirectViewDetectorTest.py b/python_files/test/InterSatDirectViewDetectorTest.py
index a42852574508736fba4fc073eb7cd3bbe2068086..93a74798b4cc773e2cff6a36e2b91708a156943d 100644
--- a/python_files/test/InterSatDirectViewDetectorTest.py
+++ b/python_files/test/InterSatDirectViewDetectorTest.py
@@ -35,7 +35,7 @@ setup_orekit_curdir("resources")
from org.orekit.propagation.events import EventsLogger
from org.hipparchus.util import FastMath
from org.orekit.frames import FramesFactory
-from org.orekit.orbits import PositionAngle
+from org.orekit.orbits import PositionAngleType
from org.orekit.time import AbsoluteDate
from org.orekit.time import TimeScalesFactory
from org.orekit.utils import Constants
@@ -89,6 +89,9 @@ class GrazingHandler(PythonEventHandler):
def resetState(self, detector, oldState):
pass
+ def getHandler(self):
+ pass
+
class InterSatDirectViewDetectorTest(unittest.TestCase):
@@ -99,13 +102,13 @@ class InterSatDirectViewDetectorTest(unittest.TestCase):
utc = TimeScalesFactory.getUTC()
o1 = CircularOrbit(7200000.0, 1.0e-3, 2.0e-4,
FastMath.toRadians(98.7), FastMath.toRadians(134.0),
- FastMath.toRadians(21.0), PositionAngle.MEAN, FramesFactory.getGCRF(),
+ FastMath.toRadians(21.0), PositionAngleType.MEAN, FramesFactory.getGCRF(),
AbsoluteDate("2003-02-14T01:02:03.000", utc),
Constants.EIGEN5C_EARTH_MU)
o2 = CircularOrbit(o1.getA(), 2.0e-4, 1.0e-3,
o1.getI() + 1.0e-6, o1.getRightAscensionOfAscendingNode() - 3.5e-7,
- o1.getAlphaM() + 2.2e-6, PositionAngle.MEAN, o1.getFrame(),
+ o1.getAlphaM() + 2.2e-6, PositionAngleType.MEAN, o1.getFrame(),
o1.getDate(),
Constants.EIGEN5C_EARTH_MU)
@@ -142,13 +145,13 @@ class InterSatDirectViewDetectorTest(unittest.TestCase):
utc = TimeScalesFactory.getUTC()
o1 = CircularOrbit(7200000.0, 1.0e-3, 2.0e-4,
FastMath.toRadians(50.0), FastMath.toRadians(134.0),
- FastMath.toRadians(21.0), PositionAngle.MEAN, FramesFactory.getGCRF(),
+ FastMath.toRadians(21.0), PositionAngleType.MEAN, FramesFactory.getGCRF(),
AbsoluteDate("2003-02-14T01:02:03.000", utc),
Constants.EIGEN5C_EARTH_MU)
o2 = CircularOrbit(29600000.0, 2.0e-4, 1.0e-3,
FastMath.toRadians(56.0), FastMath.toRadians(111.0),
- o1.getAlphaM() + 2.2e-6, PositionAngle.MEAN, o1.getFrame(),
+ o1.getAlphaM() + 2.2e-6, PositionAngleType.MEAN, o1.getFrame(),
o1.getDate(),
Constants.EIGEN5C_EARTH_MU)
@@ -157,7 +160,7 @@ class InterSatDirectViewDetectorTest(unittest.TestCase):
loggerA = EventsLogger()
pA.addEventDetector(loggerA.monitorDetector(InterSatDirectViewDetector(earth, o2).
withMaxCheck(10.0).
- withHandler(GrazingHandler().of_(InterSatDirectViewDetector))))
+ withHandler(GrazingHandler())))
propdate = o1.getDate().shiftedBy(4 * o1.getKeplerianPeriod())
pA.propagate(propdate)
@@ -169,7 +172,7 @@ class InterSatDirectViewDetectorTest(unittest.TestCase):
loggerB = EventsLogger()
pB.addEventDetector(loggerB.monitorDetector(InterSatDirectViewDetector(earth, o1).
withMaxCheck(10.0).
- withHandler(GrazingHandler().of_(InterSatDirectViewDetector))))
+ withHandler(GrazingHandler())))
pB.propagate(o1.getDate().shiftedBy(4 * o1.getKeplerianPeriod()))
self.assertEqual(7, loggerB.getLoggedEvents().size())
diff --git a/python_files/test/IodGibbsTest.py b/python_files/test/IodGibbsTest.py
index 5a1341af12767d7400d6f0437819ceff34b4cc3e..b81854b28a357712731f3018ffac9bdfb921328d 100644
--- a/python_files/test/IodGibbsTest.py
+++ b/python_files/test/IodGibbsTest.py
@@ -36,18 +36,10 @@ from java.io import File
# import java.util.List;
#
from org.hipparchus.geometry.euclidean.threed import Vector3D
-# import org.junit.Assert;
-# import org.junit.Test;
-# import org.orekit.estimation.Context;
-# from org.orekit.estimation import EstimationTestUtils
-# import org.orekit.estimation.measurements.ObservedMeasurement;
-# import org.orekit.estimation.measurements.PV;
-# import org.orekit.estimation.measurements.PVMeasurementCreator;
-# import org.orekit.frames.Frame;
from org.orekit.frames import FramesFactory
# import org.orekit.orbits.KeplerianOrbit;
from org.orekit.orbits import OrbitType
-from org.orekit.orbits import PositionAngle
+from org.orekit.orbits import PositionAngleType
# import org.orekit.propagation.Propagator;
# import org.orekit.propagation.conversion.NumericalPropagatorBuilder;
from org.orekit.time import AbsoluteDate, TimeScalesFactory
@@ -68,7 +60,7 @@ class IodGibbsTest(unittest.TestCase):
mu = context.initialOrbit.getMu()
frame = context.initialOrbit.getFrame()
- propagatorBuilder = context.createBuilder(OrbitType.KEPLERIAN, PositionAngle.TRUE, True, 1.0e-6, 60.0, 0.001)
+ propagatorBuilder = context.createBuilder(OrbitType.KEPLERIAN, PositionAngleType.TRUE, True, 1.0e-6, 60.0, 0.001)
# create perfect range measurements
propagator = EstimationTestUtils().createPropagator(context.initialOrbit, propagatorBuilder)
@@ -89,9 +81,9 @@ class IodGibbsTest(unittest.TestCase):
gibbs = IodGibbs(mu)
orbit = gibbs.estimate(frame, pv1, pv2, pv3)
- self.assertAlmostEquals(context.initialOrbit.getA(), orbit.getA(), delta=1.0e-9 * context.initialOrbit.getA())
- self.assertAlmostEquals(context.initialOrbit.getE(), orbit.getE(), delta=1.0e-9 * context.initialOrbit.getA())
- self.assertAlmostEquals(context.initialOrbit.getI(), orbit.getI(), delta=1.0e-9 * context.initialOrbit.getA())
+ self.assertAlmostEqual(context.initialOrbit.getA(), orbit.getA(), delta=1.0e-9 * context.initialOrbit.getA())
+ self.assertAlmostEqual(context.initialOrbit.getE(), orbit.getE(), delta=1.0e-9 * context.initialOrbit.getA())
+ self.assertAlmostEqual(context.initialOrbit.getI(), orbit.getI(), delta=1.0e-9 * context.initialOrbit.getA())
pass
@@ -123,7 +115,7 @@ class IodGibbsTest(unittest.TestCase):
posR1, dateRef, posR2, date2, posR3, date3)
# test
- self.assertAlmostEquals(0.0, orbit.getPVCoordinates().getVelocity().getNorm() - velR2.getNorm(), delta=1e-3)
+ self.assertAlmostEqual(0.0, orbit.getPVCoordinates().getVelocity().getNorm() - velR2.getNorm(), delta=1e-3)
if __name__ == '__main__':
diff --git a/python_files/test/IodLaplaceTest.py b/python_files/test/IodLaplaceTest.py
index ae9360426047422bd4c500d2c6ee77ad2ac387dc..7b218673d8660b18854ce4ddc9a55af2bd319fa4 100644
--- a/python_files/test/IodLaplaceTest.py
+++ b/python_files/test/IodLaplaceTest.py
@@ -39,20 +39,12 @@ from java.io import File
# import java.util.List;
#
from org.hipparchus.geometry.euclidean.threed import Vector3D
-# import org.junit.Assert;
-# import org.junit.Test;
-# import org.orekit.estimation.Context;
from org.hipparchus.util import FastMath
-# from org.orekit.estimation import EstimationTestUtils
-# import org.orekit.estimation.measurements.ObservedMeasurement;
-# import org.orekit.estimation.measurements.PV;
-# import org.orekit.estimation.measurements.PVMeasurementCreator;
-# import org.orekit.frames.Frame;
from org.orekit.frames import FramesFactory, TopocentricFrame
# import org.orekit.orbits.KeplerianOrbit;
from org.orekit.orbits import OrbitType, KeplerianOrbit
-from org.orekit.orbits import PositionAngle
+from org.orekit.orbits import PositionAngleType
# import org.orekit.propagation.Propagator;
from org.orekit.propagation.analytical import KeplerianPropagator
from org.orekit.propagation.analytical.tle import TLE, TLEPropagator
@@ -149,15 +141,15 @@ class IodLaplaceTest(unittest.TestCase):
date = AbsoluteDate(2019, 9, 29, 22, 0, 2.0, TimeScalesFactory.getUTC())
kep = KeplerianOrbit(6798938.970424857, 0.0021115522920270016, 0.9008866630545347,
1.8278985811406743, -2.7656136723308524,
- 0.8823034512437679, PositionAngle.MEAN, self.gcrf,
+ 0.8823034512437679, PositionAngleType.MEAN, self.gcrf,
date, Constants.EGM96_EARTH_MU)
prop = KeplerianPropagator(kep)
# With only 3 measurements, we can expect ~400 meters error in position and ~1 m/s in velocity
error = self.estimateOrbit(prop, date, 30.0, 60.0).getErrorNorm()
- self.assertAlmostEquals(0.0, error[0], delta=275.0)
- self.assertAlmostEquals(0.0, error[1], delta=0.8)
+ self.assertAlmostEqual(0.0, error[0], delta=275.0)
+ self.assertAlmostEqual(0.0, error[1], delta=0.8)
def testLaplaceKeplerian2(self):
@@ -165,14 +157,14 @@ class IodLaplaceTest(unittest.TestCase):
date = AbsoluteDate(2019, 9, 29, 22, 0, 2.0, TimeScalesFactory.getUTC())
kep = KeplerianOrbit(42165414.60406032, 0.00021743441091199163, 0.0019139259842569903,
1.8142608912728584, 1.648821262690012,
- 0.11710513241172144, PositionAngle.MEAN, self.gcrf,
+ 0.11710513241172144, PositionAngleType.MEAN, self.gcrf,
date, Constants.EGM96_EARTH_MU)
prop = KeplerianPropagator(kep)
error = self.estimateOrbit(prop, date, 60.0, 120.0).getErrorNorm()
- self.assertAlmostEquals(0.0, error[0], delta=395.0)
- self.assertAlmostEquals(0.0, error[1], delta=0.03)
+ self.assertAlmostEqual(0.0, error[0], delta=395.0)
+ self.assertAlmostEqual(0.0, error[1], delta=0.03)
def testLaplaceTLE1(self):
@@ -189,8 +181,8 @@ class IodLaplaceTest(unittest.TestCase):
# With only 3 measurements, an error of 5km in position and 10 m/s in velocity is acceptable
# because the Laplace method uses only two-body dynamics
- self.assertAlmostEquals(0.0, error[0], delta=5000.0)
- self.assertAlmostEquals(0.0, error[1], delta=10.0)
+ self.assertAlmostEqual(0.0, error[0], delta=5000.0)
+ self.assertAlmostEqual(0.0, error[1], delta=10.0)
diff --git a/python_files/test/KeplerianConverterTest.py b/python_files/test/KeplerianConverterTest.py
index c8d5d7d037dfff75c5ccfa4011f9389cb68180e3..ff1f9cb6ea97bab5e0c002135c76d6d1cf67d46e 100644
--- a/python_files/test/KeplerianConverterTest.py
+++ b/python_files/test/KeplerianConverterTest.py
@@ -34,7 +34,7 @@ from org.hipparchus.geometry.euclidean.threed import Vector3D
from org.orekit.orbits import EquinoctialOrbit
from org.orekit.orbits import Orbit
from org.orekit.orbits import OrbitType
-from org.orekit.orbits import PositionAngle
+from org.orekit.orbits import PositionAngleType
from org.orekit.utils import PVCoordinates
from org.orekit.propagation.conversion import FiniteDifferencePropagatorConverter
from org.orekit.propagation.conversion import KeplerianPropagatorBuilder
@@ -67,7 +67,7 @@ class KeplerianConverterTest(unittest.TestCase):
builder = KeplerianPropagatorBuilder(OrbitType.KEPLERIAN.convertType(orbit),
- PositionAngle.MEAN,
+ PositionAngleType.MEAN,
1.0)
fitter = FiniteDifferencePropagatorConverter(builder, threshold, 1000)
diff --git a/python_files/test/KlobucharModelTest.py b/python_files/test/KlobucharModelTest.py
index e9147e46dab928d4bd97f3449be27edc3d922b32..3281eefb01dd3e6c6866a9ad49e014d4f71c479e 100644
--- a/python_files/test/KlobucharModelTest.py
+++ b/python_files/test/KlobucharModelTest.py
@@ -32,29 +32,15 @@ orekit.initVM()
from orekit import JArray_double
from org.orekit.data import DataProvidersManager, ZipJarCrawler, DataContext, DirectoryCrawler
-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.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.hipparchus.util import MathArrays, Binary64Field, FastMath, Precision
from org.orekit.models.earth.ionosphere import KlobucharIonoModel, IonosphericModel
@@ -132,7 +118,7 @@ class KlobucharModelTest(unittest.TestCase):
self.assertTrue(Precision.compareTo(delayMeters.getReal(), 0., self.epsilon) > 0)
def testFieldDelay(self):
- self.doTestFieldDelay(Decimal64Field.getInstance())
+ self.doTestFieldDelay(Binary64Field.getInstance())
if __name__ == '__main__':
diff --git a/python_files/test/NodeDetectorTest.py b/python_files/test/NodeDetectorTest.py
index e1db903b55296c531ac3917ae50b9d7bd2585255..77c6f9c864c8a183a7c283cb0e8b2b441c766020 100644
--- a/python_files/test/NodeDetectorTest.py
+++ b/python_files/test/NodeDetectorTest.py
@@ -41,7 +41,7 @@ from org.hipparchus.ode.nonstiff import DormandPrince853Integrator
from org.hipparchus.util import FastMath
from org.orekit.frames import FramesFactory
from org.orekit.orbits import KeplerianOrbit
-from org.orekit.orbits import PositionAngle
+from org.orekit.orbits import PositionAngleType
from org.orekit.propagation import SpacecraftState
from org.orekit.propagation.events.handlers import ContinueOnEvent
from org.orekit.propagation.numerical import NumericalPropagator
@@ -64,7 +64,7 @@ class NodeDetectorTest(unittest.TestCase):
inertialFrame = FramesFactory.getEME2000()
initialDate = AbsoluteDate(2014, 1, 1, 0, 0, 0.0, TimeScalesFactory.getUTC())
finalDate = initialDate.shiftedBy(70 * 24 * 60 * 60.0)
- initialOrbit = KeplerianOrbit(a, e, i, w, raan, v, PositionAngle.TRUE, inertialFrame, initialDate,
+ initialOrbit = KeplerianOrbit(a, e, i, w, raan, v, PositionAngleType.TRUE, inertialFrame, initialDate,
Constants.WGS84_EARTH_MU)
initialState = SpacecraftState(initialOrbit, 1000.0)
@@ -81,7 +81,7 @@ class NodeDetectorTest(unittest.TestCase):
# Define 2 instances of NodeDetector:
rawDetector = NodeDetector(1e-6,
initialState.getOrbit(),
- initialState.getFrame()).withHandler(ContinueOnEvent().of_(NodeDetector))
+ initialState.getFrame()).withHandler(ContinueOnEvent())
logger1 = EventsLogger()
node1 = logger1.monitorDetector(rawDetector)
diff --git a/python_files/test/OrekitStepHandlerTest.py b/python_files/test/OrekitStepHandlerTest.py
index a4ff2e53d1119def20243ed4c2097031135b1689..37a8e8ed2406c26de3f29035f620d84511430730 100644
--- a/python_files/test/OrekitStepHandlerTest.py
+++ b/python_files/test/OrekitStepHandlerTest.py
@@ -51,7 +51,7 @@ from org.orekit.frames import Frame
from org.orekit.frames import FramesFactory
from org.orekit.orbits import KeplerianOrbit
from org.orekit.orbits import OrbitType
-from org.orekit.orbits import PositionAngle
+from org.orekit.orbits import PositionAngleType
from org.orekit.propagation import Propagator
from org.orekit.propagation import SpacecraftState
from org.orekit.propagation.analytical import KeplerianPropagator
@@ -89,7 +89,7 @@ class OrekitStepHandlerTest(unittest.TestCase):
inclination,
argPerigee, raan,
trueAnomaly,
- PositionAngle.TRUE,
+ PositionAngleType.TRUE,
inertialFrame,
initialDate, mu)
@@ -133,7 +133,7 @@ class OrekitStepHandlerTest(unittest.TestCase):
date = AbsoluteDate.J2000_EPOCH
eci = FramesFactory.getGCRF()
ic = SpacecraftState(KeplerianOrbit(6378137 + 500e3, 1e-3, 0.0, 0.0, 0.0, 0.0,
- PositionAngle.TRUE, eci, date, Constants.EIGEN5C_EARTH_MU))
+ PositionAngleType.TRUE, eci, date, Constants.EIGEN5C_EARTH_MU))
propagator.setInitialState(ic)
propagator.setOrbitType(OrbitType.CARTESIAN)
# detector triggers half way through second step
diff --git a/python_files/test/SmallManeuverAnalyticalModelTest.py b/python_files/test/SmallManeuverAnalyticalModelTest.py
index 605aae8181f89e568e39c36218849e90c700b243..f00041454db10bd2aa49ae26b225ab6db16939d2 100644
--- a/python_files/test/SmallManeuverAnalyticalModelTest.py
+++ b/python_files/test/SmallManeuverAnalyticalModelTest.py
@@ -34,6 +34,7 @@ from orekit import JArray_double, JArray
from org.orekit.forces.maneuvers import SmallManeuverAnalyticalModel, ConstantThrustManeuver
from org.hipparchus.geometry.euclidean.threed import Vector3D
+from org.hipparchus.geometry import Vector
from org.hipparchus.ode.nonstiff import DormandPrince853Integrator
from org.hipparchus.util import FastMath
from org.orekit.utils import Constants
@@ -43,7 +44,7 @@ from org.orekit.frames import FramesFactory
from org.orekit.frames import LOFType
from org.orekit.orbits import CircularOrbit
from org.orekit.orbits import KeplerianOrbit
-from org.orekit.orbits import PositionAngle
+from org.orekit.orbits import PositionAngleType
from org.orekit.propagation import SpacecraftState, Propagator
from org.orekit.propagation.numerical import NumericalPropagator
from org.orekit.time import AbsoluteDate
@@ -64,7 +65,7 @@ class SmallManeuverAnalyticalModelTest(unittest.TestCase):
leo = CircularOrbit(7200000.0, -1.0e-5, 2.0e-4,
radians(98.0),
radians(123.456),
- 0.0, PositionAngle.MEAN,
+ 0.0, PositionAngleType.MEAN,
FramesFactory.getEME2000(),
AbsoluteDate(DateComponents(2004, 1, 1),
TimeComponents(23, 30, 00.000),
@@ -107,7 +108,7 @@ class SmallManeuverAnalyticalModelTest(unittest.TestCase):
leo = CircularOrbit(7200000.0, -1.0e-5, 2.0e-4,
radians(98.0),
radians(123.456),
- 0.0, PositionAngle.MEAN,
+ 0.0, PositionAngleType.MEAN,
FramesFactory.getEME2000(),
AbsoluteDate(DateComponents(2004, 1, 1),
TimeComponents(23, 30, 00.000),
@@ -149,7 +150,7 @@ class SmallManeuverAnalyticalModelTest(unittest.TestCase):
heo = KeplerianOrbit(90000000.0, 0.92, FastMath.toRadians(98.0),
radians(12.3456),
radians(123.456),
- radians(1.23456), PositionAngle.MEAN,
+ radians(1.23456), PositionAngleType.MEAN,
FramesFactory.getEME2000(),
AbsoluteDate(DateComponents(2004, 1, 1),
TimeComponents(23, 30, 00.000),
@@ -210,7 +211,7 @@ class SmallManeuverAnalyticalModelTest(unittest.TestCase):
# set up maneuver
vExhaust = Constants.G0_STANDARD_GRAVITY * isp
dt = -(mass * vExhaust / f) * FastMath.expm1(-dV.getNorm() / vExhaust)
- maneuver = ConstantThrustManeuver(t0, dt, f, isp, dV.normalize())
+ maneuver = ConstantThrustManeuver(t0, dt, f, isp, Vector.cast_(dV).normalize())
propagator.addForceModel(maneuver)
generator = propagator.getEphemerisGenerator()
diff --git a/python_files/test/SpinStabilizedTest.py b/python_files/test/SpinStabilizedTest.py
index 4f479417a54c58fb7a34cf0eb3ccb83974692044..32fd6709453f165458d84f2924c52d12ef6004cb 100644
--- a/python_files/test/SpinStabilizedTest.py
+++ b/python_files/test/SpinStabilizedTest.py
@@ -35,14 +35,14 @@ from java.io import File
from org.hipparchus.geometry.euclidean.threed import Rotation
from org.hipparchus.geometry.euclidean.threed import Vector3D
-from org.hipparchus.util import Decimal64Field
+from org.hipparchus.util import Binary64Field
from org.hipparchus.util import FastMath
from org.orekit.bodies import CelestialBodyFactory
from org.orekit.frames import FramesFactory
from org.orekit.orbits import KeplerianOrbit
-from org.orekit.orbits import PositionAngle
+from org.orekit.orbits import PositionAngleType
from org.orekit.propagation import FieldSpacecraftState
from org.orekit.propagation import SpacecraftState
from org.orekit.propagation.analytical import KeplerianPropagator
@@ -54,7 +54,7 @@ from org.orekit.time import TimeScalesFactory
from org.orekit.utils import AngularCoordinates
from org.orekit.utils import PVCoordinates
from org.orekit.utils import PVCoordinatesProvider
-from org.orekit.attitudes import CelestialBodyPointed, SpinStabilized, InertialProvider
+from org.orekit.attitudes import CelestialBodyPointed, SpinStabilized, FrameAlignedProvider
class SpinStabilizedTest(unittest.TestCase):
@@ -88,8 +88,7 @@ class SpinStabilizedTest(unittest.TestCase):
attitude = bbq.getAttitude(kep, date, kep.getFrame())
- # Decimal64Field is The field of double precision floating-point numbers
- self.checkField(Decimal64Field.getInstance(), bbq, kep, kep.getDate(), kep.getFrame())
+ self.checkField(Binary64Field.getInstance(), bbq, kep, kep.getDate(), kep.getFrame())
xDirection = attitude.getRotation().applyInverseTo(Vector3D.PLUS_I)
sunpos = PVCoordinatesProvider.cast_(sun).getPVCoordinates(date, FramesFactory.getEME2000()).getPosition()
@@ -107,11 +106,11 @@ class SpinStabilizedTest(unittest.TestCase):
rate = 2.0 * math.pi / (12 * 60) # 12 minutes spin rate
- law = SpinStabilized(InertialProvider(Rotation.IDENTITY), date, Vector3D.PLUS_K, rate)
+ law = SpinStabilized(FrameAlignedProvider(Rotation.IDENTITY), date, Vector3D.PLUS_K, rate)
orbit = KeplerianOrbit(7178000.0, 1.e-4, FastMath.toRadians(50.),
FastMath.toRadians(10.), FastMath.toRadians(20.),
- FastMath.toRadians(30.), PositionAngle.MEAN,
+ FastMath.toRadians(30.), PositionAngleType.MEAN,
FramesFactory.getEME2000(), date, 3.986004415e14)
propagator = KeplerianPropagator(orbit, law)
diff --git a/python_files/test/TransformTest.py b/python_files/test/TransformTest.py
index a07ebb60a5f5ea9a4e0806e5138b628fdcd92e2a..3782d4db1dfc13aa7e3d94acb38169444ddc9fdc 100644
--- a/python_files/test/TransformTest.py
+++ b/python_files/test/TransformTest.py
@@ -42,7 +42,7 @@ from org.hipparchus.geometry.euclidean.threed import Vector3D
from org.hipparchus.util import FastMath
from org.orekit.utils import CartesianDerivativesFilter
from org.orekit.utils import PVCoordinates
-from org.orekit.utils import TimeStampedPVCoordinates;
+from org.orekit.utils import TimeStampedPVCoordinates, TimeStampedPVCoordinatesHermiteInterpolator
from org.orekit.frames import Transform
from org.orekit.frames import FramesFactory
@@ -116,9 +116,9 @@ class TransformTest(unittest.TestCase):
sample.add(item)
i = i + 1
- rebuiltPV = TimeStampedPVCoordinates.interpolate(AbsoluteDate.J2000_EPOCH.shiftedBy(dt),
- CartesianDerivativesFilter.USE_PV,
- sample)
+ interpolator = TimeStampedPVCoordinatesHermiteInterpolator(sample.size(), CartesianDerivativesFilter.USE_PV)
+
+ rebuiltPV = interpolator.interpolate(AbsoluteDate.J2000_EPOCH.shiftedBy(dt), sample)
self.checkVector(rebuiltPV.getPosition(), transformedPV.getPosition(), 4.0e-16)
self.checkVector(rebuiltPV.getVelocity(), transformedPV.getVelocity(), 2.0e-16)