1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.orekit.estimation.measurements;
18
19 import java.util.Map;
20
21 import org.hipparchus.analysis.differentiation.Gradient;
22 import org.hipparchus.geometry.euclidean.threed.FieldVector3D;
23 import org.hipparchus.geometry.euclidean.threed.Vector3D;
24 import org.orekit.estimation.measurements.model.RaDecModel;
25 import org.orekit.frames.Frame;
26 import org.orekit.propagation.SpacecraftState;
27 import org.orekit.signal.FieldSignalReceptionCondition;
28 import org.orekit.signal.SignalReceptionCondition;
29 import org.orekit.signal.SignalTravelTimeModel;
30 import org.orekit.time.AbsoluteDate;
31 import org.orekit.time.FieldAbsoluteDate;
32 import org.orekit.utils.FieldPVCoordinatesProvider;
33 import org.orekit.utils.PVCoordinatesProvider;
34 import org.orekit.utils.TimeStampedFieldPVCoordinates;
35 import org.orekit.utils.TimeStampedPVCoordinates;
36
37
38
39
40
41
42
43
44
45 public class AngularRaDec extends AngularMeasurement<AngularRaDec> {
46
47
48 public static final String MEASUREMENT_TYPE = "AngularRaDec";
49
50
51 private final Frame referenceFrame;
52
53
54 private final Observer observer;
55
56
57 private final RaDecModel measurementModel;
58
59
60
61
62
63
64
65
66
67
68
69 public AngularRaDec(final Observer observer, final Frame referenceFrame, final AbsoluteDate date,
70 final double[] angular, final double[] sigma, final double[] baseWeight,
71 final ObservableSatellite satellite) {
72 this(observer, referenceFrame, date, angular, new MeasurementQuality(sigma, baseWeight), new SignalTravelTimeModel(), satellite);
73 }
74
75
76
77
78
79
80
81
82
83
84
85
86 public AngularRaDec(final Observer observer, final Frame referenceFrame, final AbsoluteDate date,
87 final double[] angular, final MeasurementQuality measurementQuality,
88 final SignalTravelTimeModel signalTravelTimeModel, final ObservableSatellite satellite) {
89 super(date, angular, measurementQuality, signalTravelTimeModel, satellite);
90 this.referenceFrame = referenceFrame;
91 this.measurementModel = new RaDecModel(referenceFrame, getSignalTravelTimeModel().getWarmedUpModel());
92 this.observer = observer;
93 observer.getParametersDrivers().forEach(this::addParameterDriver);
94 }
95
96
97
98
99
100
101 public Observer getObserver() {
102 return observer;
103 }
104
105
106
107
108
109
110 @Deprecated
111 public GroundStation getStation() {
112 if (observer instanceof GroundStation station) {
113 return station;
114 } else {
115 return null;
116 }
117 }
118
119
120
121
122 public Frame getReferenceFrame() {
123 return referenceFrame;
124 }
125
126
127 @Override
128 protected EstimatedMeasurementBase<AngularRaDec> theoreticalEvaluationWithoutDerivatives(final int iteration,
129 final int evaluation,
130 final SpacecraftState[] states) {
131
132 final AbsoluteDate receptionDate = observer.getCorrectedReceptionDate(getDate());
133 final PVCoordinatesProvider receiver = observer.getPVCoordinatesProvider();
134 final SpacecraftState state = states[0];
135 final PVCoordinatesProvider emitter = AbstractParticipant.extractPVCoordinatesProvider(state, state.getPVCoordinates());
136 final Frame frame = state.getFrame();
137 final TimeStampedPVCoordinates receiverPV = receiver.getPVCoordinates(receptionDate, frame);
138 final SignalReceptionCondition receptionCondition = new SignalReceptionCondition(receptionDate,
139 receiverPV.getPosition(), frame);
140 final AbsoluteDate emissionDate = computeEmissionDate(receptionCondition, emitter);
141
142
143 final double[] raDec = measurementModel.value(receptionCondition, emitter, emissionDate);
144
145
146 final double shift = emissionDate.durationFrom(state);
147 final SpacecraftState shiftedState = state.shiftedBy(shift);
148 final EstimatedMeasurementBase<AngularRaDec> estimated = new EstimatedMeasurementBase<>(this, iteration, evaluation,
149 new SpacecraftState[] { shiftedState },
150 new TimeStampedPVCoordinates[] { shiftedState.getPVCoordinates(), receiverPV });
151 estimated.setEstimatedValue(wrapFirstAngle(raDec[0]), raDec[1]);
152 return estimated;
153 }
154
155
156 @Override
157 protected EstimatedMeasurement<AngularRaDec> theoreticalEvaluation(final int iteration, final int evaluation,
158 final SpacecraftState[] states) {
159
160
161
162
163
164
165
166
167
168
169 final Map<String, Integer> paramIndices = getParameterIndices(states);
170 final int nbParams = 6 * states.length + paramIndices.size();
171 final SpacecraftState state = states[0];
172 final TimeStampedFieldPVCoordinates<Gradient> pva = AbstractMeasurement.getCoordinates(state, 0, nbParams);
173
174
175 final FieldAbsoluteDate<Gradient> receptionDate = observer.getCorrectedReceptionDateField(getDate(), nbParams, paramIndices);
176 final FieldPVCoordinatesProvider<Gradient> receiver = observer.getFieldPVCoordinatesProvider(nbParams, paramIndices);
177 final FieldPVCoordinatesProvider<Gradient> emitter = AbstractParticipant.extractFieldPVCoordinatesProvider(state, pva);
178 final Frame frame = states[0].getFrame();
179 final FieldVector3D<Gradient> receiverPosition = receiver.getPosition(receptionDate, frame);
180 final FieldAbsoluteDate<Gradient> emissionDate = computeEmissionDateField(referenceFrame, receiverPosition, receptionDate, emitter);
181
182
183 final FieldSignalReceptionCondition<Gradient> receptionCondition = new FieldSignalReceptionCondition<>(receptionDate,
184 receiverPosition, frame);
185 final Gradient[] raDec = measurementModel.value(receptionCondition, emitter, emissionDate);
186
187
188 final double shift = emissionDate.toAbsoluteDate().durationFrom(state);
189 final SpacecraftState shiftedState = state.shiftedBy(shift);
190 final EstimatedMeasurement<AngularRaDec> estimated = new EstimatedMeasurement<>(this, iteration, evaluation,
191 new SpacecraftState[] { shiftedState },
192 new TimeStampedPVCoordinates[] { shiftedState.getPVCoordinates(),
193 getObserver().getPVCoordinatesProvider().getPVCoordinates(receptionDate.toAbsoluteDate(), frame)});
194 fillEstimatedMeasurement(raDec[0], raDec[1], paramIndices, estimated);
195 return estimated;
196 }
197
198
199
200
201
202
203 public Vector3D getObservedLineOfSight(final Frame outputFrame) {
204 return referenceFrame.getStaticTransformTo(outputFrame, getDate())
205 .transformVector(new Vector3D(getObservedValue()[0], getObservedValue()[1]));
206 }
207 }