1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.orekit.propagation;
18
19 import org.hipparchus.CalculusFieldElement;
20 import org.hipparchus.geometry.euclidean.threed.Vector3D;
21 import org.hipparchus.util.Binary64;
22 import org.junit.jupiter.api.Assertions;
23 import org.junit.jupiter.api.Test;
24 import org.mockito.Mockito;
25 import org.orekit.orbits.CartesianOrbit;
26 import org.orekit.orbits.FieldCartesianOrbit;
27 import org.orekit.time.AbsoluteDate;
28 import org.orekit.utils.AbsolutePVCoordinates;
29 import org.orekit.utils.FieldAbsolutePVCoordinates;
30 import org.orekit.utils.PVCoordinates;
31 import org.orekit.utils.TimeStampedPVCoordinates;
32
33 import java.util.Arrays;
34
35 class CartesianToleranceProviderTest {
36
37 @Test
38 void testOfdP() {
39
40 final double dP = 1.;
41 final CartesianToleranceProvider toleranceProvider = CartesianToleranceProvider.of(dP);
42
43 final double[][] tolerances = toleranceProvider.getTolerances(Mockito.mock(Vector3D.class),
44 Mockito.mock(Vector3D.class));
45
46 Assertions.assertEquals(dP, tolerances[0][0]);
47 Assertions.assertEquals(dP, tolerances[0][1]);
48 Assertions.assertEquals(dP, tolerances[0][2]);
49 Assertions.assertEquals(CartesianToleranceProvider.DEFAULT_ABSOLUTE_MASS_TOLERANCE, tolerances[0][6]);
50 for (int i = 0; i < tolerances[0].length; ++i) {
51 Assertions.assertTrue(tolerances[1][i] > 0.);
52 }
53 }
54
55 @Test
56 void testOfdPdVdM() {
57
58 final double dP = 1.;
59 final double dV = 2.;
60 final double dM = 3.;
61 final CartesianToleranceProvider toleranceProvider = CartesianToleranceProvider.of(dP, dV, dM);
62 final Vector3D unitVector = Vector3D.MINUS_I;
63
64 final double[][] tolerances = toleranceProvider.getTolerances(unitVector, unitVector);
65
66 Assertions.assertEquals(dP, tolerances[0][0]);
67 Assertions.assertEquals(dP, tolerances[0][1]);
68 Assertions.assertEquals(dP, tolerances[0][2]);
69 Assertions.assertEquals(dV, tolerances[0][3]);
70 Assertions.assertEquals(dV, tolerances[0][4]);
71 Assertions.assertEquals(dV, tolerances[0][5]);
72 Assertions.assertEquals(dM, tolerances[0][6]);
73 for (int i = 0; i < 6; ++i) {
74 Assertions.assertEquals(tolerances[1][i], tolerances[0][i]);
75 }
76 Assertions.assertTrue(tolerances[1][6] > 0.);
77 }
78
79 @Test
80 void testGetTolerancesCartesianOrbit() {
81
82 final double[] absoluteTolerances = new double[7];
83 Arrays.fill(absoluteTolerances, 1.);
84 final double[] relativeTolerances = new double[7];
85 Arrays.fill(relativeTolerances, 2.);
86 final CartesianToleranceProvider mockedProvider = new TestProvider(absoluteTolerances, relativeTolerances);
87 final CartesianOrbit mockedOrbit = mockOrbit();
88
89 final double[][] actualTolerances = mockedProvider.getTolerances(mockedOrbit);
90
91 Assertions.assertArrayEquals(absoluteTolerances, actualTolerances[0]);
92 Assertions.assertArrayEquals(relativeTolerances, actualTolerances[1]);
93 }
94
95 @Test
96 void testGetTolerancesFieldCartesianOrbit() {
97
98 final double[] absoluteTolerances = new double[7];
99 Arrays.fill(absoluteTolerances, 1.);
100 final double[] relativeTolerances = new double[7];
101 Arrays.fill(relativeTolerances, 2.);
102 final CartesianToleranceProvider mockedProvider = new TestProvider(absoluteTolerances, relativeTolerances);
103 final FieldCartesianOrbit<Binary64> mockedOrbit = mockFieldOrbit();
104
105 final double[][] actualTolerances = mockedProvider.getTolerances(mockedOrbit);
106
107 Assertions.assertArrayEquals(absoluteTolerances, actualTolerances[0]);
108 Assertions.assertArrayEquals(relativeTolerances, actualTolerances[1]);
109 }
110
111 private static CartesianOrbit mockOrbit() {
112 final CartesianOrbit mockedOrbit = Mockito.mock(CartesianOrbit.class);
113 Mockito.when(mockedOrbit.getPosition()).thenReturn(Mockito.mock(Vector3D.class));
114 Mockito.when(mockedOrbit.getPVCoordinates()).thenReturn(new TimeStampedPVCoordinates(AbsoluteDate.ARBITRARY_EPOCH, new PVCoordinates()));
115 return mockedOrbit;
116 }
117
118 @SuppressWarnings("unchecked")
119 private static <T extends CalculusFieldElement<T>> FieldCartesianOrbit<T> mockFieldOrbit() {
120 final FieldCartesianOrbit<T> mockedFieldOrbit = Mockito.mock(FieldCartesianOrbit.class);
121 final CartesianOrbit mockedOrbit = mockOrbit();
122 Mockito.when(mockedFieldOrbit.toOrbit()).thenReturn(mockedOrbit);
123 return mockedFieldOrbit;
124 }
125
126 @Test
127 void testGetTolerancesAbsolutePV() {
128
129 final double[] absoluteTolerances = new double[7];
130 Arrays.fill(absoluteTolerances, 1.);
131 final double[] relativeTolerances = new double[7];
132 Arrays.fill(relativeTolerances, 2.);
133 final CartesianToleranceProvider mockedProvider = new TestProvider(absoluteTolerances, relativeTolerances);
134 final AbsolutePVCoordinates mockedPV = mockPV();
135
136 final double[][] actualTolerances = mockedProvider.getTolerances(mockedPV);
137
138 Assertions.assertArrayEquals(absoluteTolerances, actualTolerances[0]);
139 Assertions.assertArrayEquals(relativeTolerances, actualTolerances[1]);
140 }
141
142 @Test
143 void testGetTolerancesFieldPV() {
144
145 final double[] absoluteTolerances = new double[7];
146 Arrays.fill(absoluteTolerances, 1.);
147 final double[] relativeTolerances = new double[7];
148 Arrays.fill(relativeTolerances, 2.);
149 final CartesianToleranceProvider mockedProvider = new TestProvider(absoluteTolerances, relativeTolerances);
150 final FieldAbsolutePVCoordinates<Binary64> mockedFieldPV = mockFieldPV();
151
152 final double[][] actualTolerances = mockedProvider.getTolerances(mockedFieldPV);
153
154 Assertions.assertArrayEquals(absoluteTolerances, actualTolerances[0]);
155 Assertions.assertArrayEquals(relativeTolerances, actualTolerances[1]);
156 }
157
158 private static AbsolutePVCoordinates mockPV() {
159 final AbsolutePVCoordinates mockedPV = Mockito.mock(AbsolutePVCoordinates.class);
160 Mockito.when(mockedPV.getPosition()).thenReturn(Mockito.mock(Vector3D.class));
161 Mockito.when(mockedPV.getPVCoordinates()).thenReturn(new TimeStampedPVCoordinates(AbsoluteDate.ARBITRARY_EPOCH, new PVCoordinates()));
162 return mockedPV;
163 }
164
165 @SuppressWarnings("unchecked")
166 private static <T extends CalculusFieldElement<T>> FieldAbsolutePVCoordinates<T> mockFieldPV() {
167 final FieldAbsolutePVCoordinates<T> mockedFieldPV = Mockito.mock(FieldAbsolutePVCoordinates.class);
168 final AbsolutePVCoordinates mockedPV = mockPV();
169 Mockito.when(mockedFieldPV.toAbsolutePVCoordinates()).thenReturn(mockedPV);
170 return mockedFieldPV;
171 }
172
173 private static class TestProvider implements CartesianToleranceProvider {
174 private final double[] absoluteTolerances;
175 private final double[] relativeTolerances;
176 TestProvider(final double[] absoluteTolerances, final double[] relativeTolerances) {
177 this.absoluteTolerances = absoluteTolerances;
178 this.relativeTolerances = relativeTolerances;
179 }
180 @Override
181 public double[][] getTolerances(final Vector3D position, final Vector3D velocity) {
182 return new double[][] {
183 absoluteTolerances, relativeTolerances
184 };
185 }
186 }
187
188 }