1   /* Copyright 2002-2021 CS GROUP
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.estimation.measurements.generation;
18  
19  import java.util.ArrayList;
20  import java.util.List;
21  import java.util.SortedSet;
22  import java.util.TreeSet;
23  
24  import org.orekit.estimation.measurements.ObservableSatellite;
25  import org.orekit.estimation.measurements.ObservedMeasurement;
26  import org.orekit.propagation.Propagator;
27  import org.orekit.propagation.PropagatorsParallelizer;
28  import org.orekit.propagation.SpacecraftState;
29  import org.orekit.propagation.sampling.MultiSatStepHandler;
30  import org.orekit.propagation.sampling.OrekitStepInterpolator;
31  import org.orekit.time.AbsoluteDate;
32  
33  
34  /** Main generator for {@link ObservedMeasurement observed measurements}.
35   * @author Luc Maisonobe
36   * @since 9.3
37   */
38  public class Generator {
39  
40      /** Propagators. */
41      private final List<Propagator> propagators;
42  
43      /** Sequences generators. */
44      private final List<Scheduler<?>> schedulers;
45  
46      /** Build a generator with no sequences generator.
47       */
48      public Generator() {
49          this.propagators = new ArrayList<>();
50          this.schedulers  = new ArrayList<>();
51      }
52  
53      /** Add a propagator.
54       * @param propagator to add
55       * @return satellite satellite propagated by the propagator
56       */
57      public ObservableSatellite addPropagator(final Propagator propagator) {
58          propagators.add(propagator);
59          return new ObservableSatellite(propagators.size() - 1);
60      }
61  
62      /** Get a registered propagator.
63       * @param satellite satellite propagated by the propagator {@link #addPropagator(Propagator)}
64       * @return propagator corresponding to satellite
65       */
66      public Propagator getPropagator(final ObservableSatellite satellite) {
67          return propagators.get(satellite.getPropagatorIndex());
68      }
69  
70      /** Add a sequences generator for a specific measurement type.
71       * @param scheduler sequences generator to add
72       * @param <T> the type of the measurement
73       */
74      public <T extends ObservedMeasurement<T>> void addScheduler(final Scheduler<T> scheduler) {
75          schedulers.add(scheduler);
76      }
77  
78      /** Generate measurements.
79       * @param start start of the measurements time span
80       * @param end end of the measurements time span
81       * @return generated measurements
82       */
83      public SortedSet<ObservedMeasurement<?>> generate(final AbsoluteDate start, final AbsoluteDate end) {
84  
85          // initialize schedulers
86          for (final Scheduler<?> scheduler : schedulers) {
87              scheduler.init(start, end);
88          }
89  
90          // set up parallelized propagators
91          final GeneratorHandler handler = new GeneratorHandler(schedulers);
92          final PropagatorsParallelizer parallelizer = new PropagatorsParallelizer(propagators, handler);
93  
94          // generate the measurements
95          parallelizer.propagate(start, end);
96  
97          return handler.getMeasurements();
98  
99      }
100 
101     /** Handler for measurements generation steps. */
102     private static class GeneratorHandler implements MultiSatStepHandler {
103 
104         /** Sequences generators. */
105         private final List<Scheduler<?>> schedulers;
106 
107         /** Set for holding measurements. */
108         private final SortedSet<ObservedMeasurement<?>> measurements;
109 
110         /** Simple constructor.
111          * @param schedulers sequences generators
112          */
113         GeneratorHandler(final List<Scheduler<?>> schedulers) {
114             this.schedulers   = schedulers;
115             this.measurements = new TreeSet<>();
116         }
117 
118         /** {@inheritDoc} */
119         @Override
120         public void init(final List<SpacecraftState> states0, final AbsoluteDate t) {
121             for (final Scheduler<?> scheduler : schedulers) {
122                 scheduler.init(states0.get(0).getDate(), t);
123             }
124         }
125 
126         /** {@inheritDoc} */
127         @Override
128         public void handleStep(final List<OrekitStepInterpolator> interpolators) {
129             for (final Scheduler<?> scheduler : schedulers) {
130                 measurements.addAll(scheduler.generate(interpolators));
131             }
132         }
133 
134         /** Get the generated measurements.
135          * @return generated measurements
136          */
137         public SortedSet<ObservedMeasurement<?>> getMeasurements() {
138             return measurements;
139         }
140 
141     }
142 
143 }