1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.orekit.frames;
18
19 import java.io.Serializable;
20 import java.util.concurrent.atomic.AtomicReference;
21
22 import org.hipparchus.CalculusFieldElement;
23 import org.orekit.annotation.DefaultDataContext;
24 import org.orekit.data.DataContext;
25 import org.orekit.time.AbsoluteDate;
26 import org.orekit.time.FieldAbsoluteDate;
27 import org.orekit.time.TimeScale;
28
29
30
31
32
33
34
35
36
37
38 class VersionedITRFProvider implements EOPBasedTransformProvider {
39
40
41 private static final long serialVersionUID = 20180403L;
42
43
44 private final ITRFVersion version;
45
46
47 private final ITRFProvider rawProvider;
48
49
50 private final AtomicReference<ITRFVersion.Converter> converter;
51
52
53 private final TimeScale tt;
54
55
56
57
58
59
60 VersionedITRFProvider(final ITRFVersion version,
61 final ITRFProvider rawProvider,
62 final TimeScale tt) {
63 this.version = version;
64 this.rawProvider = rawProvider;
65 this.converter = new AtomicReference<>();
66 this.tt = tt;
67 }
68
69
70
71
72 public ITRFVersion getITRFVersion() {
73 return version;
74 }
75
76
77 @Override
78 public EOPHistory getEOPHistory() {
79 return rawProvider.getEOPHistory();
80 }
81
82
83 @Override
84 public VersionedITRFProvider getNonInterpolatingProvider() {
85 return new VersionedITRFProvider(version, rawProvider.getNonInterpolatingProvider(), tt);
86 }
87
88
89 @Override
90 public Transform getTransform(final AbsoluteDate date) {
91
92
93 final Transform rawTransform = rawProvider.getTransform(date);
94
95
96 final ITRFVersion.Converter converterForDate = getConverter(date);
97 if (converterForDate == null) {
98 return rawTransform;
99 } else {
100 return new Transform(date, rawTransform, converterForDate.getTransform(date));
101 }
102
103 }
104
105
106 @Override
107 public KinematicTransform getKinematicTransform(final AbsoluteDate date) {
108
109
110 final KinematicTransform rawTransform = rawProvider.getKinematicTransform(date);
111
112
113 final ITRFVersion.Converter converterForDate = getConverter(date);
114 if (converterForDate == null) {
115 return rawTransform;
116 } else {
117 return KinematicTransform.compose(date, rawTransform, converterForDate.getKinematicTransform(date));
118 }
119
120 }
121
122
123 @Override
124 public StaticTransform getStaticTransform(final AbsoluteDate date) {
125
126
127 final StaticTransform rawTransform = rawProvider.getStaticTransform(date);
128
129
130 final ITRFVersion.Converter converterForDate = getConverter(date);
131 if (converterForDate == null) {
132 return rawTransform;
133 } else {
134 return StaticTransform.compose(
135 date,
136 rawTransform,
137 converterForDate.getStaticTransform(date));
138 }
139
140 }
141
142
143 @Override
144 public <T extends CalculusFieldElement<T>> FieldTransform<T> getTransform(final FieldAbsoluteDate<T> date) {
145
146
147 final FieldTransform<T> rawTransform = rawProvider.getTransform(date);
148
149
150 final ITRFVersion.Converter converterForDate = getConverter(date.toAbsoluteDate());
151 if (converterForDate == null) {
152 return rawTransform;
153 } else {
154 return new FieldTransform<>(date, rawTransform, converterForDate.getTransform(date));
155 }
156
157 }
158
159
160 @Override
161 public <T extends CalculusFieldElement<T>> FieldKinematicTransform<T> getKinematicTransform(final FieldAbsoluteDate<T> date) {
162
163
164 final FieldKinematicTransform<T> rawTransform = rawProvider.getKinematicTransform(date);
165
166
167 final ITRFVersion.Converter converterForDate = getConverter(date.toAbsoluteDate());
168 if (converterForDate == null) {
169 return rawTransform;
170 } else {
171 return FieldKinematicTransform.compose(date, rawTransform, converterForDate.getKinematicTransform(date));
172 }
173
174 }
175
176
177 @Override
178 public <T extends CalculusFieldElement<T>> FieldStaticTransform<T> getStaticTransform(final FieldAbsoluteDate<T> date) {
179
180
181 final FieldStaticTransform<T> rawTransform = rawProvider.getStaticTransform(date);
182
183
184 final ITRFVersion.Converter converterForDate = getConverter(date.toAbsoluteDate());
185 if (converterForDate == null) {
186 return rawTransform;
187 } else {
188 return FieldStaticTransform.compose(
189 date,
190 rawTransform,
191 converterForDate.getStaticTransform(date));
192 }
193
194 }
195
196
197
198
199
200
201 private ITRFVersion.Converter getConverter(final AbsoluteDate date) {
202
203
204 final ITRFVersion rawVersion = getEOPHistory().getITRFVersion(date);
205 if (rawVersion == version) {
206
207 return null;
208 }
209
210 final ITRFVersion.Converter existing = converter.get();
211 if (existing != null && existing.getOrigin() == rawVersion) {
212
213 return existing;
214 }
215
216
217 final ITRFVersion.Converter newConverter =
218 ITRFVersion.getConverter(rawVersion, version, tt);
219 converter.compareAndSet(null, newConverter);
220 return newConverter;
221
222 }
223
224
225
226
227 @DefaultDataContext
228 private Object writeReplace() {
229 return new DataTransferObject(version, rawProvider);
230 }
231
232
233 @DefaultDataContext
234 private static class DataTransferObject implements Serializable {
235
236
237 private static final long serialVersionUID = 20180403L;
238
239
240 private final ITRFVersion version;
241
242
243 private final ITRFProvider rawProvider;
244
245
246
247
248
249 DataTransferObject(final ITRFVersion version, final ITRFProvider rawProvider) {
250 this.version = version;
251 this.rawProvider = rawProvider;
252 }
253
254
255
256
257 private Object readResolve() {
258 return new VersionedITRFProvider(version, rawProvider,
259 DataContext.getDefault().getTimeScales().getTT());
260 }
261
262 }
263
264 }