Propagators

hchome_p.gif hcnews_p.gif hcprod_p.gif hcserv_p.gif hclink_p.gif
The Propagator Library
Thinking Systems constructed and tested a library of precision numerical integrators and two body propagators under contract to Goddard Space Flight Center. This library has been released by Goddard, and is available for use by interested parties.
Sample Documentation
Sample Test Results
Thinking Systems performed tests on the delivered code designed to characterize the performance and accuracy of the code in a variety of different settings. Most of the tests were performed under Microsoft's Windows operating system, unless otherwise noted.

The test machine for the Windows based tests is a 1GHz Pentium III laptop computer running Windows 2000 Professional, Service Pack 2. The code was compiled using the C++ compiler in Visual Studio.NET unless noted differently. Performance tests were run with the computer disconnected from all external sources, and with all user accessible processes disabled.

The propagation suite has been tested for three orbital regimes using the spacecraft states listed in Table 1. Each propagator was run in both fixed and variable step modes for a thirty day orbit, using each of the implemented propagators. The results of these runs are provided in the following sections of this document.

Table 1: Orbit States Used in Tests

Low Earth Orbit Transfer Orbit Geosynchronous Orbit
X (km) 7000.0 7000.0 42165.0
Y (km) 0.0 0.0 0.0
Z (km) 1000.0 0.0 0.0
Vx (km/s) 0.0 0.0 0.0
Vy (km/s) 8.0 9.84175 3.0746
Vz (km/s) 0.0 0.0 0.9

Propagator accuracy was calculated by calculating the root sum square difference in position and velocity of the propagated state from the corresponding two body state.

Two body states depend on the accuracy of the inversion routine for Kepler's equation; for these tests, the inversion routine was set to an accuracy of one part in $10^{11}$.

Propagator performance is measured by performing a thirty day propagation multiple times with each propagator. The total wall clock time is measured for these propagations, and divided by the number of propagation runs to give the average propagation time for a thirty day orbit using a point mass force model.

Fixed Step Tests

This section tabulates the results obtained when runnning the propagators in fixed step mode with the propagation error tolerance set to one part in $10^{11}$, unless otherwise noted. Both the average and maximum RSS error was measured for each propagator, using each of the orbital states above.

Propagation Accuracy

Tables 2 and 3 tabulate the maximum and average RSS error found propagating the low earth orbit state for a thirty day span. The average error is calculated across the last day of the propagation. The two body data shows the difference between a two body propagation with the Kepler equation inverter tolerance set to $1.0*10^{-7}$.

Table 2: Maximum RSS Error Propagating the LEO State

60 sec output step 300 sec output step
Propagator RSS Position Error (m) RSS Velocity Error (m/s) RSS Position Error (m) RSS Velocity Error (m/s)
TwoBodyProp 0.12680 0.00012636 0.12680 0.00012636
RungeKutta45 4.4436 0.0044280 4.3332 0.0043136
RungeKutta89 0.041647 4.1500e-5 6.3353 0.0063068
RungeKuttaFehlberg56 0.0050270 4.4366e-6 0.0043250 2.8593e-6
PrinceDormand45 0.62371 0.00062150 0.60599 0.00060338
PrinceDormand78 0.0017524 1.7500e-6 0.18197 0.00018213
AdamsBashfordMoulton 1.6248 0.0016229 1.6241 0.0016205
BulirschStoer 0.00076092* 7.5009e-7* 17.674* 0.017613*

* Bulirsch-Stoer tests were run at a tolerance of $1.0*10^{-10}$

Table 3: Average RSS Error Propagating the LEO State

60 sec output step 300 sec output step
Propagator RSS Position Error (m) RSS Velocity Error (m/s) RSS Position Error (m) RSS Velocity Error (m/s)
TwoBodyProp 0.023137 2.0166e-5 0.023708 2.0686e-5
RungeKutta45 3.7414 0.0032430 3.6520 0.0031661
RungeKutta89 0.035033 3.0367e-5 5.3396 0.0046292
RungeKuttaFehlberg56 0.0031473 2.8339e-6 0.0031493 2.6028e-6
PrinceDormand45 0.52516 0.00045519 0.51102 0.00044301
PrinceDormand78 0.0014588 1.2636e-6 0.15539 0.00013453
AdamsBashfordMoulton 1.3440 0.0011644 1.3446 0.0011650
BulirschStoer 5.3110e-5* 4.2440e-8* 14.935* 0.012945*

* Bulirsch-Stoer tests were run at a tolerance of $1.0*10^{-10}$

Tables 4 and 5 tabulate the maximum and average RSS error found propagating the transfer orbit state for a thirty day span. The average error is calculated across the last day of the propagation.

Table 4: Maximum RSS Error Propagating the Transfer State

60 sec output step 300 sec output step
Propagator RSS Position Error (m) RSS Velocity Error (m/s) RSS Position Error (m) RSS Velocity Error (m/s)
TwoBodyProp 4.2871 0.0035287 4.2872 0.0035287
RungeKutta45 0.75419 0.00060576 0.73797 0.00059146
RungeKutta89 0.081141 6.4388e-5 2.4332 0.0019944
RungeKuttaFehlberg56 0.11594 9.1950e-5 0.099821 8.0005e-5
PrinceDormand45 0.83705 0.00067336 0.21512 0.00017243
PrinceDormand78 0.092980 7.3550e-5 0.21512 0.00017243
AdamsBashfordMoulton 10.797 0.0088757 10.797 0.0088514
BulirschStoer 0.56026** 0.00044840** 1.1908* 0.00097682*

* Tolerance set to $1.0*10^{-9}$

** Tolerance set to $1.0*10^{-8}$

Table 5: Average RSS Error Propagating the Transfer State

60 sec output step 300 sec output step
Propagator RSS Position Error (m) RSS Velocity Error (m/s) RSS Position Error (m) RSS Velocity Error (m/s)
TwoBodyProp 0.65699 0.00020819 0.65750 0.00020932
RungeKutta45 0.22188 5.8866e-5 0.21647 5.7441e-5
RungeKutta89 0.014641 3.0195e-6 0.77714 0.00020631
RungeKuttaFehlberg56 0.024561 5.2008e-6 0.023926 4.1878e-6
PrinceDormand45 0.24902 6.6072e-5 0.23926 6.3493e-5
PrinceDormand78 0.017425 3.6485e-6 0.052055 1.2877e-5
AdamsBashfordMoulton 3.5093 0.00092965 3.5090 0.00092962
BulirschStoer 0.15561** 4.1978e-5** 0.37802* 9.9466e-5*

* Tolerance set to $1.0*10^{-9}$

** Tolerance set to $1.0*10^{-8}$

Tables 6 and 7 tabulate the maximum and average RSS error found propagating the geosynchronous orbit state for a thirty day span. The average error is calculated across the last day of the propagation.

Table 6: Maximum RSS Error Propagating the GEO State

60 sec output step 300 sec output step
Propagator RSS Position Error (m) RSS Velocity Error (m/s) RSS Position Error (m) RSS Velocity Error (m/s)
TwoBodyProp 8.2016e-5 5.9806e-9 8.0555e-5 5.8741e-9
RungeKutta45 0.0036585 2.6675e-7 0.20521 1.4963e-5
RungeKutta89 0.00041404 3.0164e-8 0.00033133 2.4080e-8
RungeKuttaFehlberg56 0.00064627 4.7124e-8 0.00052143 3.7970e-8
PrinceDormand45 0.00072168 5.2610e-8 0.00018290 1.2929e-8
PrinceDormand78 0.0012536 9.1371e-8 0.00025795 1.8833e-8
AdamsBashfordMoulton 0.47864* 3.4901e-5* 0.47848* 3.4889e-5*
BulirschStoer 0.0012981** 9.4827e-8** 0.0040599** 2.9618e-7**

* Tolerance set to $1.0*10^{-9}$

** Tolerance set to$1.0*10^{-8}$

Table 7: Average RSS Error Propagating the GEO State

60 sec output step 300 sec output step
Propagator RSS Position Error (m) RSS Velocity Error (m/s) RSS Position Error (m) RSS Velocity Error (m/s)
TwoBodyProp 2.5788e-7 1.8804e-11 2.9848e-7 2.1758e-11
RungeKutta45 0.0035379 2.5799e-7 0.19845 1.4471e-5
RungeKutta89 0.00021687 1.5813e-8 0.00032473 2.3675e-8
RungeKuttaFehlberg56 0.00046760 3.4097e-8 0.00050898 3.7111e-8
PrinceDormand45 0.00054438 3.9713e-8 0.00017540 1.2513e-8
PrinceDormand78 0.0010780 7.8605e-8 0.00025473 1.8571e-8
AdamsBashfordMoulton 0.46919* 3.4213e-5* 0.46905* 3.4203e-5*
BulirschStoer 0.0011211** 8.1743e-8** 0.0039663** 2.8923e-7**

* Tolerance set to $1.0*10^{-9}$

** Tolerance set to$1.0*10^{-8}$

Propagation Performance

The test results given above characterize the accuracy of the propagators running in fixed step mode. The performance of each propagator was also measured by performing 100 30-day propagations back-to-back, and then dividing the total elapsed wall-clock time by the number of runs. The propagation was run using the point mass gravitational force defined in the PointMassForce class. Each of the test orbital states were run in this environment. The results are tabulated in tables 8 and 9.

Table 8: Propagator Performance: 60 sec. Output Steps

Average Time (s)
Propagator LEO State Transfer State GEO State
TwoBodyProp 0.095 0.175 0.062
RungeKutta45 3.13 0.93 0.23
RungeKutta89 0.98 0.99 0.89
RungeKuttaFehlberg56 2.60 0.58 0.34
PrinceDormand45 3.77 1.19 0.29
PrinceDormand78 0.71 0.72 0.68
AdamsBashfordMoulton 2.68 1.57 0.32
BulirschStoer 0.37 0.41 0.31

Table 9: Propagator Performance: 300 sec. Output Steps

Average Time (s)
Propagator LEO State Transfer State GEO State
TwoBodyProp 0.019 0.035 0.013
RungeKutta45 3.35 1.08 0.23
RungeKutta89 0.94 0.29 0.18
RungeKuttaFehlberg56 2.82 0.58 0.22
PrinceDormand45 4.02 1.34 0.29
PrinceDormand78 0.62 0.72 0.14
AdamsBashfordMoulton 2.68 1.57 0.32
BulirschStoer 0.13 0.11 0.07

Variable Step Tests

The tests described in the preceding section were run using a fixed output interval. Each of the integrators is designed to run in either fixed or variable step mode. In either case, the system maintains the propagation accuracy to the specified tolerance.

The actual accuracy of each propagator is not as straight forward as that presented here. As can be seen in Tables 2 - 7, the actual accuracy of the integrators can differ from one another by several orders of magnitude for a given specified integrator tolerance. Thinking Systems has built a basic tolerance targeter that tunes the integrator tolerance parameter to achieve a given accuracy after a specified integration period. This targeter was run to find the tolerance parameters for the variable step performance tests described below.

Targeted Propagation Accuracy

The tolerance targeter code can be found in the ToleranceTargeter folder of the delivered source code. This targeter uses a rudamentary implementation of a differential corrector to vary the tolerance on the integrator in order to achieve a desired accuracy.

The basic form of the problem solved by the targeter is given an inital set of data $V$ and a target set of conditions $G$, along with a function that maps the initial data to achieved values $A = f(V)$, to change the initial data in such a way as to get the actual achieved conditions $A$ to match the goals $G$ to within a user specified precision $P$. This is accomplished by constructing derivative information on the initial data using finite differences, and then inverting the difference equations to estimate the initial conditions that produce the desired results. More succinctly, the estimated derivative information is given by

\[{{dA}\over{dV}} \approx {{f(V + \delta V) - f(V)}\over{\delta V}}\]

The difference between the achieved values and the target values can be used with this difference equation to estimate the change required in the initial data that produces the desired result:

\[\Delta V = \left({{dA}\over{dV}}\right)^{-1} (G - A)\]

The tolerance parameter affects the accuracy of the integrator exponentially. This behavior prevent perfoming the targeting on the tolerance as the targeter variable directly; instead, the logarithm of the tolerance is used as the variable for the differential correction.

Table 10 lists the tolerance settings used in the variable step performance tests for each of the integrators. The targeter was set to achieve a maximum observed root sum square error in position of 1 meter (within 1 cm) after 5 days of propagation for the LEO and transfer orbit tests. The GEO orbit was more constrained: the targeter was set to achieve a maximum observed error of 1 cm after 30 days, to within 5mm. This selection was made because the GEO orbit is very circular, and has a period that allows for just over 30 cycles during the test timespan.

Table 10: Propagator Tolerance Settings for Variable Step Tests

Tolerance Setting
Propagator LEO State Transfer State GEO State
RungeKutta45 5.66495e-11 2.5586e-10 6.66363e-10
RungeKutta89 4.94398e-11 1.20183e-10 9.70114e-10
RungeKuttaFehlberg56 2.28235e-9 2.93201e-10 1.96121e-8
PrinceDormand45 2.73178e-10 2.35402e-10 4.61156e-8
PrinceDormand78 2.67873e-10 1.01805e-9 3.68614e-9
AdamsBashfordMoulton 1.0e-8* 1.0e-8* 1.0e-8*
BulirschStoer 2.66032e-11 2.33112e-11 1.0e-6**

* The Adams-Bashford-Moulton Integrator was not targeted

** The Bulirsch-Stoer Integrator was too accurate at all settings for the GEO case

Variable Step Propagation Performance

The tolerance values specified in Table 10 were used to run the integrators in variable step mode in order to characterize the integration performance for similar precision runs with different algorithms. The performance results for these runs are tabulated in Table 11. Each value in the table was obtained by running the integrator in variable step mode for a duration on 30 days. This interval was run 100 times back-to-back for each integrator. The wall clock time was measured for this sequence of runs. The value reported in the table is the average wall clock time elapsed for runs performed using the initial states listed in Table 1.

Table 11: Propagator Performance: Variable Step Tests

Propagation Time (s)
Propagator LEO State Transfer State GEO State
RungeKutta45 0.94 0.25 0.05
RungeKutta89 0.39 0.13 0.03
RungeKuttaFehlberg56 0.45 0.16 0.03
PrinceDormand45 0.86 0.31 0.01
PrinceDormand78 0.26 0.09 0.02
AdamsBashfordMoulton 1.23 0.54 0.07
BulirschStoer 0.32 0.09 0.01

Forward and Backward Propagation

Various propagation problems require the ability to solve the equations of motion for past states of spacecraft as well as future states. This requirement necessitates the ability of the propagators to perform backwards propagation in time. A test was coded that runs the integration out for a user specified duration (typically set to thirty days) and then back to the starting epoch in order to test this capability. The test measures the difference between the initial state and the state after running the forward and backwards propagation in variable step mode, using the targeted tolerance values reported in Table 10. The results of these tests are reported in Table 12.

Table 12: Forward and Backward Propagation Tests

Position Difference (m)
Propagator LEO state Transfer state GEO state
RungeKutta45 73.408 69.956 72.081
RungeKutta89 73.894 69.767 71.038
RungeKuttaFehlberg56 109.14 113.68 38.597
PrinceDormand45 74.295 70.101 21.779
PrinceDormand78 76.873 88.255 74.025
AdamsBashfordMoulton 371.25 45.157 1.6680
BulirschStoer 2.3010 13.644 1.1236

Borland C++ and the VAL PhysicalModel

Goddard Space Flight Center is building a system, the Goddard Mission Analysis Tool (GMAT), as a flexible framework for testing mission analysis models and frameworks. A piece of this tool is the Virtual Almanac (VAL), consisting of force model components designed to model satellite orbits in the solar system. In its current form, VAL is built as a dynamic link library (dll) using Borland C++ 5.02. This library was provided to Thinking Systems as a source model for forces used by the propagators.

Thinking Systems recompiled the performance test code and linked it to the VAL system using the ValForceModel PhysicalModel. The model was set to use the Earth point mass force as the only acceleration source. Performance data for this build is provided in Tables 13 and 14. Accuracy data is comparable to the accuracy for the build under Visual C++; representative data is given in Table 15.

Table 13: Propagator Performance with VAL: 60 sec. Output Steps

Average Time (s)
Propagator LEO State Transfer State GEO State
TwoBodyProp 0.32 0.58 0.20
RungeKutta45 39.8 12.8 3.6
RungeKutta89 8.8 9.4 9.2
RungeKuttaFehlberg56 30.4 7.2 4.6
PrinceDormand45 41.0 13.0 3.4
PrinceDormand78 6.8 7.2 7.0
AdamsBashfordMoulton 25.4 15.4 2.6
BulirschStoer 13.0 9.6 6.6

Table 14: Propagator Performance with VAL: 300 sec. Output Steps

Average Time (s)
Propagator LEO State Transfer State GEO State
TwoBodyProp 0.08 0.12 0.04
RungeKutta45 42.8 15.2 3.4
RungeKutta89 8.4 2.8 1.8
RungeKuttaFehlberg56 34.2 7.4 2.8
PrinceDormand45 44.2 15.0 3.4
PrinceDormand78 6.2 2.8 1.4
AdamsBashfordMoulton 25.6 15.4 3.2
BulirschStoer 4.8 2.8 1.2

Table 15: Maximum RSS Error Propagating the LEO State with VAL

60 sec output step 300 sec output step
Propagator RSS Position Error (m) RSS Velocity Error (m/s) RSS Position Error (m) RSS Velocity Error (m/s)
TwoBodyProp 0.12680 0.00012636 0.12680 0.00012636
RungeKutta45 4.4434 0.0044278 4.3325 0.0043130
RungeKutta89 0.042218 4.2069e-5 6.3355 0.0063070
RungeKuttaFehlberg56 0.0060967 5.5021e-6 0.0048788 3.5195e-6
PrinceDormand45 0.62357 0.00062136 0.60276 0.00060016
PrinceDormand78 0.0030593 3.0529e-6 0.18244 0.00018261
AdamsBashfordMoulton 1.6094 0.0016075 1.6087 0.0016051
BulirschStoer 12.534* 0.012470* 86.440* 0.085985*

* Bulirsch-Stoer tests were run at a tolerance of $1.0*10^{-8}$

Linux Tests

The primary focus of the work performed here is a suite of propagators that run efficiently under Windows. The code needs to be flexible and usable in other operating environments as well. Thinking Systems rebuilt a subset of the code base under the Linux operating system to validate platform independence for the code in the library.

The test machine for this build is a dual processor Pentium III workstation running with 1GHz processors. The tests run as a single process on this platform, unthreaded, so only one processor is used in the test. The test machine runs Scyld Linux, version 27cz-8. The results of tests on this build are presented in the following sections.

GCC Compiler settings

The Linux version of the executable files was built using the C++ compiler shipped with the operating system; for the data presented here, the compiler is the GNU Compiler Collection (gcc), version 2.91.66 running under Scyld Beowulf. The code was also compiled using gcc version 2.96-108.7.2, running on Red Hat Linux 7.2. The results under Red Hat 7.2 are not reported in this document because the Red Hat platform at Thinking Systems is an older machine running as a file server. The hardware on this machine is not comparable to the hardware used for the other tests.

The code for the Linux tests is compiled using the following optimization flags:

g++ -O9 -funroll-loops -ffast-math -malign-double -mcpu=pentiumpro -march=pentiumpro -fomit-frame-pointer -fno-exceptions

Performance under Linux

The performance test described above was recompiled and run under Linux. Results from this tests are presented in Table 16.

Table 16: Propagator Performance under Linux: Variable Step Tests

Propagation Time (s)
Propagator LEO State Transfer State GEO State
RungeKutta45 1.02 0.25 0.04
RungeKutta89 0.40 0.12 0.03
RungeKuttaFehlberg56 0.49 0.15 0.02
PrinceDormand45 0.90 0.30 0.02
PrinceDormand78 0.24 0.08 0.02
AdamsBashfordMoulton 1.29 0.55 0.07
BulirschStoer 0.36 0.10 0.02

Forward and Backward Propagation Accuracy under Linux

The forward and backward propagation test described above was repeated on the Linux platform. The results of these tests are reported in Table 17.

Table 17: Linux Based Forward and Backward Propagation Tests

Position Difference (m)
Propagator LEO state Transfer state GEO state
RungeKutta45 73.405 69.947 72.081
RungeKutta89 73.900 69.741 71.016
RungeKuttaFehlberg56 109.14 113.69 38.594
PrinceDormand45 74.273 70.093 21.887
PrinceDormand78 76.916 88.266 73.991
AdamsBashfordMoulton 463.097 270.22 1.6588
BulirschStoer 2.2888 12.640 1.1238

Formation Tests

Each propagator is designed to allow for propagation of state vectors of user specified size. For satellite problems, this capability allows users to construct PhysicalModels that simulate the orbit of a single satellite, a group of satellites flying in either close formation or a constellation, or configurations that model both the orbit an attitude simultaneously. In this section, two formation configurations are defined and tested for performance both as a single state vector propagating all spacecraft simultaneously and as a set of propagators and state vectors running in parallel.

Formation Configuration

Two separate close formations of spacecraft were configured and tested for performance. In the first configuration, four spacecraft are placed on the vertices of a tetrahedron and propagated for thirty days. The spacecraft velocity is set so that the semimajor axis of each spacecraft is identical at the initial state. The velocity vectors are initially parallel. The position of each spacecraft is offset from the center of the tetrahedron by 200 km.

The second formation consists of eight spacecraft placed at the vertices of a cube, and propagated for 30 days. The spacecraft velocity is set so that the semimajor axis of each spacecraft is identical at the initial state. The velocity vectors are initially parallel. The position of each spacecraft is offset from the center of the cube by 200 km.

For both configurations, the initial geometric figure is rotated about three axes to break symmetry from the configuration routine.

Formation Configuration Performance

The performance of the propagators running these formations was measured in two different modes. The propagators were designed to handle vectors of arbitrary size. In the first test mode, all of the spacecraft states are placed in a single vector (that is, a vector of 24 elements for the tetrahedral configuration, and 48 elements for the cubic configuration) and propagated simultaneously. In the second mode, each spacecraft is assigned its own propagator and run sequentially. This case is the "Multiple Vectors" case in the tables below. In both cases, the propagation was performed in fixed output step mode with a five minute output stepsize.

The results for the tetrahedral formation are presented in Table 18. The cubic configuration performance results are listed in Table 19. In all cases where the equations of motion are integrated, the single vector propagation outperforms the multiple vector propagation, usually by better than 20%. The two-body propagator does not make calls into a force model, and for that case the performances are comparable between the two propagation setups.

Table 18: Tetrahedron Formation Propagation Tests

Average Time (s)
Propagator Single Vector Multiple Vectors Difference
TwoBodyProp 0.76 0.76 0.0%
RungeKutta45 10.04 12.08 20.3%
RungeKutta89 2.64 3.32 25.8%
RungeKuttaFehlberg56 8.52 10.36 21.6%
PrinceDormand45 12.56 14.92 18.8%
PrinceDormand78 1.84 2.28 23.9%
AdamsBashfordMoulton
BulirschStoer 0.64 0.76 18.8%

Table 19: Cubic Formation Propagation Tests

Average Time (s)
Propagator Single Vector Multiple Vectors Difference
TwoBodyProp 1.44 1.52 5.6%
RungeKutta45 19.36 24.08 24.4%
RungeKutta89 5.12 6.64 29.7%
RungeKuttaFehlberg56 16.64 20.68 24.3%
PrinceDormand45 24.96 29.96 20.0%
PrinceDormand78 3.56 4.56 28.1%
AdamsBashfordMoulton
BulirschStoer 1.20 1.48 23.3%

Multiple Processor Tests

Thinking Systems has an in-house Beowulf cluster consisting of a dual processor master node and two dual processor compute nodes. Each processor is a 1.0 GHz Pentium III, running with a 133 MHz front side bus. An MPI based application was constructed that uses Thinking Systems' Distributed Modeling Environment (DME) to run formations of spacecraft in a distributed manner. This application was run on the cluster with various configurations of the compute nodes.

Formation Propagation Performance on a Cluster

The test run on the Beowulf cluster measured the performance of the cluster for various different size formations of spacecraft propagating in low Earth orbit. Each spacecraft propagates for 30 days. The cluster keeps the spacecraft states synchronized through messages between the computational processes and the process driving the system. This test used the Prince-Dormand 7(8) integrator for all propagation.

One note on the compilation is in order here. The MPI library was not compiled with the same optimization flags as indicated for the previous Linux tests. Since the purpose of this test is to demonstrate performance in a distributed environment, the optimization flags were kept minimal for the Beowulf-DME build. The performance results presented here should not be compared directly to the results in the preceding section; this build of the code will run more slowly than the previous build.

Performance results for the distributed processing runs are presented in Table 20.

Table 20: Beowulf Performance Data

Satellite Count Master Node Compute Node 0 Compute Node 1 Average Time (s)
1 Online Offline Offline 0.80
2 Online Offline Offline 0.84
3 Online Offline Offline 1.61
4 Online Offline Offline 2.10
8 Online Offline Offline 4.99
1 Online Online Offline 0.80
2 Online Online Offline 0.80
3 Online Online Offline 1.59
4 Online Online Offline 1.61
8 Online Online Offline 3.21
1 Online Online Online 0.80
2 Online Online Online 0.79
3 Online Online Online 0.81
4 Online Online Online 0.81
5 Online Online Online 1.58
8 Online Online Online 1.61

Copyright © 2002, United States Government
Prepared by Thinking Systems, Inc.
Used with permission.

This section describes the development environment and some general features of the propagator suite development process. In it you'll find information about how to start using the code for your projects, and some high level information about the step size options and error control.

The Development Environment

The propagator libraries and associated executables were developed in generic ANSI C++. The source code was originally developed using the Microsoft Visual Studio.NET development environment. The libraries have also been compiled using GNU's gcc compiler suite, Borland C++ 5.02, and the Scyld Beowulf compatible gcc compiler and libraries.

Physical System Models -- Getting Started

Users of the propagation suite may need to change the equations of motion to match their problems of interest. This task is performed by creating a new C++ class derived from the PhysicalModel class. This interface provides the integrators with pointers to the input and output state vectors, information about the system being integrated, and a class method that provides derivative information for use by the integrators.

Thinking Systems has developed three separate physical model classes that are provided with this code. The simplest of these classes is the Lorenz class; it provides an implementation of the Lorenz strange attractor, and is a useful starting point for users that want to learn the basics of the interface.

The PointMassForce class is the class that is used for all of the orbit model tests described in this document. It provides an implementation of Earth point mass gravity modeling, used for spacecraft orbit propagation. This model has an exact solution, implemented in the TwoBodyProp propagator, that is used as a reference model for the integration in order to evaluate the accuracy of each integrator. This class is a useful example if you need to implement a derivative model from scratch that uses one or more of the propagators.

The final physical model delivered with this code is an interface into Goddard Space Flight Center's Virtual Almanac (VAL). The VAL implementation as of this writing is compiled under the Borland C++ compiler, version 5.02. Libraries compiled under that version of the compiler are not compatible with code built under Microsoft Visual C++; hence the VAL interface class is provided in a separate directory, in the ValForceModel class. The ValForceModel class shows how to interface existing C or C++ code to the propagator suite.

Thinking Systems is also available to help integrate your physical model into the propagator suite. Inquiries can be made to info@thinksysinc.com for additional information about this support.

Modes

Each of the integrators provided in this suite can be run in either variable or fixed step mode. In either case, the integration step is controlled to the specified tolerance. This control is used to set the step size for variable step propagation, using the error estimate as described in the next section. When the integrator is run in fixed step mode, the integration is executed one or more times to propagate the state vector across the desired time interval. Multiple steps are taken if a single step provides too much error.

Error Control

All of the integrators provided in this suite include techniques used to estimate the local error encountered when propagating from state $\vec r(t_i)$ to a state $\vec r(t_{i+1})$. The details of the error estimate depend on the algorithm. The implementation provided here estimates the absolute error for each component of the state vector, and then divides this estimate by the change in the component. This produces a relative estimate of the error $\vec \epsilon$ in the propagation, given by

\[\epsilon_j = {{\Delta_j(t_{i+1})}\over {\vec r_j(t_{i+1}) - \vec r_j(t_i)}}\]

where $\Delta_j(t_{i+1})$ is the algorithm specific estimate of the absolute error in the jth component of the propagation.

Copyright © 2002, United States Government
Prepared by Thinking Systems, Inc.
Used with permission.
aboutus.gif