1   /* Copyright 2022-2025 Romain Serra
2    * Licensed to CS GROUP (CS) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * CS licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *   http://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  package org.orekit.attitudes;
18  
19  import org.hipparchus.complex.Complex;
20  import org.hipparchus.complex.ComplexField;
21  import org.hipparchus.geometry.euclidean.threed.FieldVector3D;
22  import org.hipparchus.geometry.euclidean.threed.Vector3D;
23  import org.junit.jupiter.api.Assertions;
24  import org.junit.jupiter.api.Test;
25  import org.mockito.Mockito;
26  import org.orekit.frames.Frame;
27  import org.orekit.frames.FramesFactory;
28  import org.orekit.time.AbsoluteDate;
29  import org.orekit.time.FieldAbsoluteDate;
30  import org.orekit.utils.*;
31  
32  class GroundPointingAttitudeModifierTest {
33  
34      @Test
35      void testGetTargetPosition() {
36          // GIVEN
37          final GroundPointing mockedLaw = Mockito.mock(GroundPointing.class);
38          final TestYawLaw law = new TestYawLaw(mockedLaw);
39          final PVCoordinatesProvider mockedPVProvider = Mockito.mock(PVCoordinatesProvider.class);
40          final AbsoluteDate date = AbsoluteDate.ARBITRARY_EPOCH;
41          final Frame frame = Mockito.mock(Frame.class);
42          final Vector3D expectedPosition = Vector3D.PLUS_J;
43          Mockito.when(mockedLaw.getTargetPosition(mockedPVProvider, date, frame)).thenReturn(expectedPosition);
44          // WHEN
45          final Vector3D actualPosition = law.getTargetPosition(mockedPVProvider, date, frame);
46          // THEN
47          Assertions.assertEquals(expectedPosition, actualPosition);
48      }
49  
50      @SuppressWarnings("unchecked")
51      @Test
52      void testGetTargetPositionField() {
53          // GIVEN
54          final GroundPointing mockedLaw = Mockito.mock(GroundPointing.class);
55          final TestYawLaw law = new TestYawLaw(mockedLaw);
56          final ComplexField field = ComplexField.getInstance();
57          final FieldPVCoordinatesProvider<Complex> mockedPVProvider = Mockito.mock(FieldPVCoordinatesProvider.class);
58          final FieldAbsoluteDate<Complex> date = new FieldAbsoluteDate<>(field, AbsoluteDate.ARBITRARY_EPOCH);
59          final Frame frame = Mockito.mock(Frame.class);
60          final FieldVector3D<Complex> expectedPosition = new FieldVector3D<>(field, Vector3D.PLUS_J);
61          Mockito.when(mockedLaw.getTargetPosition(mockedPVProvider, date, frame)).thenReturn(expectedPosition);
62          // WHEN
63          final FieldVector3D<Complex> actualPosition = law.getTargetPosition(mockedPVProvider, date, frame);
64          // THEN
65          Assertions.assertEquals(expectedPosition, actualPosition);
66      }
67  
68      @Test
69      void testGetTargetPV() {
70          // GIVEN
71          final GroundPointing mockedLaw = Mockito.mock(GroundPointing.class);
72          final TestYawLaw law = new TestYawLaw(mockedLaw);
73          final PVCoordinatesProvider mockedPVProvider = Mockito.mock(PVCoordinatesProvider.class);
74          final AbsoluteDate date = AbsoluteDate.ARBITRARY_EPOCH;
75          final Frame frame = Mockito.mock(Frame.class);
76          final TimeStampedPVCoordinates expectedPvCoordinates = new TimeStampedPVCoordinates(date, new PVCoordinates(Vector3D.MINUS_I,
77                  Vector3D.PLUS_J));
78          Mockito.when(mockedLaw.getTargetPV(mockedPVProvider, date, frame)).thenReturn(expectedPvCoordinates);
79          // WHEN
80          final TimeStampedPVCoordinates actualPVCoordinates = law.getTargetPV(mockedPVProvider, date, frame);
81          // THEN
82          Assertions.assertEquals(expectedPvCoordinates.getPosition(), actualPVCoordinates.getPosition());
83          Assertions.assertEquals(expectedPvCoordinates.getVelocity(), actualPVCoordinates.getVelocity());
84      }
85  
86      @SuppressWarnings("unchecked")
87      @Test
88      void testGetTargetPVField() {
89          // GIVEN
90          final GroundPointing mockedLaw = Mockito.mock(GroundPointing.class);
91          final TestYawLaw law = new TestYawLaw(mockedLaw);
92          final ComplexField field = ComplexField.getInstance();
93          final FieldPVCoordinatesProvider<Complex> mockedPVProvider = Mockito.mock(FieldPVCoordinatesProvider.class);
94          final FieldAbsoluteDate<Complex> date = new FieldAbsoluteDate<>(field, AbsoluteDate.ARBITRARY_EPOCH);
95          final Frame frame = Mockito.mock(Frame.class);
96          final TimeStampedFieldPVCoordinates<Complex> expectedPV = new TimeStampedFieldPVCoordinates<>(field,
97                  new TimeStampedPVCoordinates(date.toAbsoluteDate(), Vector3D.MINUS_I, Vector3D.MINUS_K, Vector3D.ZERO));
98          Mockito.when(mockedLaw.getTargetPV(mockedPVProvider, date, frame)).thenReturn(expectedPV);
99          // WHEN
100         final TimeStampedFieldPVCoordinates<Complex> actualPV = law.getTargetPV(mockedPVProvider, date, frame);
101         // THEN
102         Assertions.assertEquals(expectedPV.getPosition(), actualPV.getPosition());
103         Assertions.assertEquals(expectedPV.getVelocity(), actualPV.getVelocity());
104     }
105 
106     @Test
107     void testGetBaseState() {
108         // GIVEN
109         final GroundPointing mockedLaw = Mockito.mock(GroundPointing.class);
110         final TestYawLaw law = new TestYawLaw(mockedLaw);
111         final PVCoordinatesProvider mockedPVProvider = Mockito.mock(PVCoordinatesProvider.class);
112         final AbsoluteDate date = AbsoluteDate.ARBITRARY_EPOCH;
113         final Frame frame = Mockito.mock(Frame.class);
114         final Attitude mockedAttitude = Mockito.mock(Attitude.class);
115         Mockito.when(mockedLaw.getAttitude(mockedPVProvider, date, frame)).thenReturn(mockedAttitude);
116         // WHEN
117         final Attitude attitude = law.getBaseState(mockedPVProvider, date, frame);
118         // THEN
119         Assertions.assertEquals(mockedAttitude, attitude);
120     }
121 
122     @SuppressWarnings("unchecked")
123     @Test
124     void testGetBaseStateField() {
125         // GIVEN
126         final GroundPointing mockedLaw = Mockito.mock(GroundPointing.class);
127         final TestYawLaw law = new TestYawLaw(mockedLaw);
128         final ComplexField field = ComplexField.getInstance();
129         final FieldPVCoordinatesProvider<Complex> mockedPVProvider = Mockito.mock(FieldPVCoordinatesProvider.class);
130         final FieldAbsoluteDate<Complex> date = new FieldAbsoluteDate<>(field, AbsoluteDate.ARBITRARY_EPOCH);
131         final Frame frame = Mockito.mock(Frame.class);
132         final FieldAttitude<Complex> mockedAttitude = Mockito.mock(FieldAttitude.class);
133         Mockito.when(mockedLaw.getAttitude(mockedPVProvider, date, frame)).thenReturn(mockedAttitude);
134         // WHEN
135         final FieldAttitude<Complex> attitude = law.getBaseState(mockedPVProvider, date, frame);
136         // THEN
137         Assertions.assertEquals(mockedAttitude, attitude);
138     }
139 
140     private static class TestYawLaw extends GroundPointingAttitudeModifier {
141 
142         protected TestYawLaw(final GroundPointing groundPointingLaw) {
143             super(FramesFactory.getEME2000(), Mockito.mock(Frame.class), groundPointingLaw);
144         }
145 
146     }
147 
148 }