Merge branch 'development' into 'master'

Development

See merge request socis/satnogs-orbit-determination!1

src/main/java/fr/cs/examples/estimation/DopplerRangeRateConverter.java

+package fr.cs.examples.estimation;
+
+import org.orekit.data.DataProvidersManager;
+import org.orekit.data.DirectoryCrawler;
+import org.orekit.time.AbsoluteDate;
+import org.orekit.time.TimeScale;
+import org.orekit.time.TimeScalesFactory;
+import org.orekit.utils.Constants;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.File;
+import java.io.FileWriter;
+
+/** Converter to convert the measured signal frequency to range-rate (in km/s) and to change MJD to the date in the ISO-8601 format.
+ * @author Noel Janes
+ */
+
+public class DopplerRangeRateConverter {
+
+    static double rRcalculator(String freq , double downlinkFreq, double c){
+        double f2 = Double.parseDouble(freq);
+        double dopplerFreq = f2 - downlinkFreq;
+        double rR = (-c) * (dopplerFreq / downlinkFreq);
+        rR = rR/1000;
+        return rR;
+    }
+
+    static AbsoluteDate mjdDate(String dateIn, TimeScale utc, AbsoluteDate mjdRefUTC){
+        double mjdDate = Double.parseDouble(dateIn);
+        AbsoluteDate date = new AbsoluteDate(mjdRefUTC,mjdDate* Constants.JULIAN_DAY, utc);
+        return date;
+    }
+
+
+    public static void main(String[] args) {
+
+        long startTime = System.currentTimeMillis();
+
+
+        /* Configuring data loading */
+        File home = new File(System.getProperty("user.home"));
+        File orekitData = new File(home, "orekit-data");
+        DataProvidersManager manager = DataProvidersManager.getInstance();
+        manager.addProvider(new DirectoryCrawler(orekitData));
+
+
+        /* Initial data path  */
+        File pathDataIn = new File("C:\\Users\\nolja\\Documents\\ESA Socis\\Orbit Determination\\testing2\\42778");
+
+        /* Initialising an array of filenames in the input data folder */
+        String[] fileList = pathDataIn.list();
+
+
+        /* Output data path */
+        File pathDataOut = new File("C:\\Users\\nolja\\Documents\\ESA Socis\\Orbit Determination\\orbitdetermination\\satnogs-orbit-determination\\src\\main\\resources");
+
+        //int secDay = 24*60*60 ; // Calculates the seconds in a day, used to calculate seconds between mesaurements (which are given in MJD)
+
+
+        double c = 2.998*Math.pow(10,8); // Speed of light
+        double downlinkFreq = 1.45961 * Math.pow(10, 8);  // The value of the downlink freq is taken from https://db.satnogs.org/satellite/42778/
+        System.out.println("The downlink frequency is: " + downlinkFreq + "Hz");
+
+
+        /* Setting up the initial parameters that are to be passed to the file */
+        String measType = "   RANGE_RATE";
+        //SString antennaID = "   39-CGBSAT-VHF         ";
+
+
+        TimeScale utc = TimeScalesFactory.getUTC();
+        AbsoluteDate mjdRefUTC = new AbsoluteDate(1858,11,17,utc);
+
+        BufferedReader reader;
+
+        for(String filename : fileList) {
+
+
+            if(filename.endsWith(".dat")) {
+
+                try {
+
+                    long tIn = System.currentTimeMillis();
+
+                    /* Initialising the filereader  */
+                    reader = new BufferedReader(new FileReader(pathDataIn + "\\" + filename));
+
+                    String line = reader.readLine();
+
+                    /* Initialising the filewriter */
+
+                    BufferedWriter bw = null;
+                    File file = new File(pathDataOut + "\\" + filename);
+
+                    /* This logic will make sure that the file
+                     * gets created if it is not present at the
+                     * specified location*/
+
+                    if (!file.exists()) {
+                        file.createNewFile();
+                    }
+
+                    FileWriter fw = new FileWriter(file);
+                    bw = new BufferedWriter(fw);
+
+                    System.out.println("Finished the initial setup for file: " + filename);
+
+                    while (line != null) {
+
+                        String[] columns = line.split(" ");
+
+                        line = reader.readLine();   // Required to prevent the same line being run an infite number of times
+
+
+                        if(filename.startsWith("2019-06-11T19")){
+                            String antennaID = "   39-CGBSAT-VHF-P1         ";
+                            String outputline = mjdDate(columns[0],utc,mjdRefUTC) + measType + antennaID + rRcalculator(columns[1],downlinkFreq,c) + "\n";
+                        bw.write(outputline);
+                        }
+                        else if (filename.startsWith("2019-06-11T21")){
+                            String antennaID = "   39-CGBSAT-VHF-P2         ";
+                            String outputline = mjdDate(columns[0],utc,mjdRefUTC) + measType + antennaID + rRcalculator(columns[1],downlinkFreq,c) + "\n";
+                        bw.write(outputline);
+                        }
+                        else {
+                            String antennaID = "   39-CGBSAT-VHF         ";
+                            String outputline = mjdDate(columns[0],utc,mjdRefUTC) + measType + antennaID + rRcalculator(columns[1],downlinkFreq,c) + "\n";
+                        bw.write(outputline);
+                        }
+
+
+                    }
+
+
+                    /* Closing the buffered writer */
+                    try {
+                        if (bw != null)
+                            bw.close();
+                    }
+                    catch (Exception ex) {
+                        System.out.println("Error in closing the BufferedWriter" + ex);
+                        reader.close();
+                    }
+
+
+
+                    /* Calculating the time taken for this file to be converted */
+                    long tOut = System.currentTimeMillis();
+                    double tTaken = 0.001 * (tOut - tIn);
+                    System.out.println("Conversion of file:" + filename + " completed in: " + tTaken + "s");
+
+                }
+
+                catch (IOException e) {
+                    e.printStackTrace();
+
+                }
+            }
+
+            else {
+                break;
+            }
+        }
+
+        long endTime = System.currentTimeMillis();
+
+        System.out.println("All files have been converted \n" + "Total time taken is: " + 0.001*(endTime-startTime)+"s");
+    }
+
+}

src/main/java/fr/cs/examples/estimation/Iono.java

+package fr.cs.examples.estimation;
+
+import org.orekit.estimation.measurements.modifiers.RangeIonosphericDelayModifier;
+import org.orekit.estimation.measurements.modifiers.RangeRateIonosphericDelayModifier;
+import org.orekit.gnss.Frequency;
+import org.orekit.models.earth.ionosphere.IonosphericModel;
+import org.orekit.models.earth.ionosphere.KlobucharIonoCoefficientsLoader;
+import org.orekit.models.earth.ionosphere.KlobucharIonoModel;
+import org.orekit.time.AbsoluteDate;
+import org.orekit.time.DateComponents;
+import org.orekit.time.TimeScalesFactory;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class Iono {
+
+    /** Ionospheric modifiers. */
+
+    /** Flag for two-way range-rate. */
+    public final boolean twoWay;
+
+    /** Map for range modifiers. */
+    public final Map<Frequency, Map<DateComponents, RangeIonosphericDelayModifier>> rangeModifiers;
+
+    /** Map for range-rate modifiers. */
+    public final Map<Frequency, Map<DateComponents, RangeRateIonosphericDelayModifier>> rangeRateModifiers;
+
+    /** Simple constructor.
+     * @param twoWay flag for two-way range-rate
+     */
+    Iono(final boolean twoWay) {
+        this.twoWay             = twoWay;
+        this.rangeModifiers     = new HashMap<>();
+        this.rangeRateModifiers = new HashMap<>();
+    }
+
+    /** Get range modifier for a measurement.
+     * @param frequency frequency of the signal
+     * @param date measurement date
+     * @return range modifier
+     */
+    public RangeIonosphericDelayModifier getRangeModifier(final Frequency frequency,
+                                                          final AbsoluteDate date)
+    {
+        final DateComponents dc = date.getComponents(TimeScalesFactory.getUTC()).getDate();
+        ensureFrequencyAndDateSupported(frequency, dc);
+        return rangeModifiers.get(frequency).get(dc);
+    }
+
+    /** Get range-rate modifier for a measurement.
+     * @param frequency frequency of the signal
+     * @param date measurement date
+     * @return range-rate modifier
+     */
+    public RangeRateIonosphericDelayModifier getRangeRateModifier(final Frequency frequency,
+                                                                  final AbsoluteDate date)
+    {
+        final DateComponents dc = date.getComponents(TimeScalesFactory.getUTC()).getDate();
+        ensureFrequencyAndDateSupported(frequency, dc);
+        return rangeRateModifiers.get(frequency).get(dc);
+    }
+
+    /** Create modifiers for a frequency and date if needed.
+     * @param frequency frequency of the signal
+     * @param dc date for which modifiers are required
+     */
+    private void ensureFrequencyAndDateSupported(final Frequency frequency, final DateComponents dc)
+    {
+
+        if (!rangeModifiers.containsKey(frequency)) {
+            rangeModifiers.put(frequency, new HashMap<>());
+            rangeRateModifiers.put(frequency, new HashMap<>());
+        }
+
+        if (!rangeModifiers.get(frequency).containsKey(dc)) {
+
+            // load Klobuchar model for the L1 frequency
+            final KlobucharIonoCoefficientsLoader loader = new KlobucharIonoCoefficientsLoader();
+            loader.loadKlobucharIonosphericCoefficients(dc);
+            final IonosphericModel model = new KlobucharIonoModel(loader.getAlpha(), loader.getBeta());
+
+            // scale for current frequency
+            final double f = frequency.getMHzFrequency();
+
+            // create modifiers
+            rangeModifiers.get(frequency).put(dc, new RangeIonosphericDelayModifier(model, f));
+            rangeRateModifiers.get(frequency).put(dc, new RangeRateIonosphericDelayModifier(model, f, twoWay));
+
+        }
+
+    }
+}

src/main/java/fr/cs/examples/estimation/MeasurementsGeneration.java

+/* Copyright 2002-2019 CS Systèmes d'Information
+ * Licensed to CS Systèmes d'Information (CS) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * CS licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package fr.cs.examples;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.util.Locale;
+import java.util.SortedSet;
+
+import org.hipparchus.geometry.euclidean.threed.Vector3D;
+import org.hipparchus.linear.MatrixUtils;
+import org.hipparchus.linear.RealMatrix;
+import org.hipparchus.ode.ODEIntegrator;
+import org.hipparchus.ode.nonstiff.DormandPrince853Integrator;
+import org.hipparchus.random.CorrelatedRandomVectorGenerator;
+import org.hipparchus.random.GaussianRandomGenerator;
+import org.hipparchus.random.RandomGenerator;
+import org.hipparchus.random.Well19937c;
+import org.hipparchus.util.FastMath;
+import org.orekit.bodies.CelestialBodyFactory;
+import org.orekit.bodies.GeodeticPoint;
+import org.orekit.bodies.OneAxisEllipsoid;
+import org.orekit.data.DataProvidersManager;
+import org.orekit.data.DirectoryCrawler;
+import org.orekit.errors.OrekitException;
+import org.orekit.estimation.measurements.GroundStation;
+import org.orekit.estimation.measurements.ObservableSatellite;
+import org.orekit.estimation.measurements.ObservedMeasurement;
+import org.orekit.estimation.measurements.RangeRate;
+import org.orekit.estimation.measurements.generation.EventBasedScheduler;
+import org.orekit.estimation.measurements.generation.Generator;
+import org.orekit.estimation.measurements.generation.RangeRateBuilder;
+import org.orekit.estimation.measurements.generation.Scheduler;
+import org.orekit.estimation.measurements.generation.SignSemantic;
+import org.orekit.estimation.measurements.modifiers.Bias;
+import org.orekit.estimation.measurements.modifiers.RangeRateTroposphericDelayModifier;
+import org.orekit.forces.drag.DragForce;
+import org.orekit.forces.drag.IsotropicDrag;
+import org.orekit.forces.gravity.HolmesFeatherstoneAttractionModel;
+import org.orekit.forces.gravity.ThirdBodyAttraction;
+import org.orekit.forces.gravity.potential.GravityFieldFactory;
+import org.orekit.forces.gravity.potential.NormalizedSphericalHarmonicsProvider;
+import org.orekit.frames.Frame;
+import org.orekit.frames.FramesFactory;
+import org.orekit.frames.TopocentricFrame;
+import org.orekit.models.AtmosphericRefractionModel;
+import org.orekit.models.earth.EarthITU453AtmosphereRefraction;
+import org.orekit.models.earth.atmosphere.Atmosphere;
+import org.orekit.models.earth.atmosphere.DTM2000;
+import org.orekit.models.earth.atmosphere.NRLMSISE00;
+import org.orekit.models.earth.atmosphere.data.MarshallSolarActivityFutureEstimation;
+import org.orekit.models.earth.troposphere.DiscreteTroposphericModel;
+import org.orekit.models.earth.troposphere.ViennaModelCoefficientsLoader;
+import org.orekit.models.earth.troposphere.ViennaModelType;
+import org.orekit.models.earth.troposphere.ViennaThreeModel;
+import org.orekit.orbits.CartesianOrbit;
+import org.orekit.orbits.OrbitType;
+import org.orekit.propagation.SpacecraftState;
+import org.orekit.propagation.analytical.tle.TLE;
+import org.orekit.propagation.analytical.tle.TLEPropagator;
+import org.orekit.propagation.events.ElevationDetector;
+import org.orekit.propagation.events.EventDetector;
+import org.orekit.propagation.events.handlers.ContinueOnEvent;
+import org.orekit.propagation.numerical.NumericalPropagator;
+import org.orekit.time.AbsoluteDate;
+import org.orekit.time.DateComponents;
+import org.orekit.time.DatesSelector;
+import org.orekit.time.FixedStepSelector;
+import org.orekit.time.TimeScale;
+import org.orekit.time.TimeScalesFactory;
+import org.orekit.utils.Constants;
+import org.orekit.utils.IERSConventions;
+import org.orekit.utils.TimeStampedPVCoordinates;
+
+/** Measurements generation for checking consistency of observed Doppler conversion.
+ * @author Luc Maisonobe
+ */
+public class MeasurementsGeneration {
+
+    /** Program entry point.
+     * @param args program arguments (unused here)
+     */
+    public static void main(String[] args) {
+        try {
+
+            // configures Orekit
+            File home       = new File(System.getProperty("user.home"));
+            File orekitData = new File(home, "orekit-data");
+            if (!orekitData.exists()) {
+                System.err.format(Locale.US, "Failed to find %s folder%n",
+                                  orekitData.getAbsolutePath());
+                System.err.format(Locale.US, "You need to download %s from %s, unzip it in %s and rename it 'orekit-data' for this tutorial to work%n",
+                                  "orekit-data-master.zip", "https://gitlab.orekit.org/orekit/orekit-data/-/archive/master/orekit-data-master.zip",
+                                  home.getAbsolutePath());
+                System.exit(1);
+            }
+
+            DataProvidersManager manager = DataProvidersManager.getInstance();
+            manager.addProvider(new DirectoryCrawler(orekitData));
+            /*
+            // beware TLE model is not suitable for propagation more than a few days
+            // we have to select the correct TLE for the dates we will generate measurements
+            final TLE tle20190611 = new TLE("1 42778U 17036P   19162.69113096  .00000749  00000-0  35781-4 0  9997",
+                    "2 42778  97.3549 220.5119 0010756 245.3704 114.6412 15.21997549109170");
+            final TLE tle20190612 = new TLE("1 42778U 17036P   19163.74305518  .00000728  00000-0  34875-4 0  9996",
+                    "2 42778  97.3548 221.5408 0010807 241.2329 118.7822 15.21999132109334");
+            final TLE tle20190617 = new TLE("1 42778U 17036P   19168.73968312  .00000624  00000-0  30313-4 0  9995",
+                    "2 42778  97.3544 226.4276 0011195 221.3881 138.6508 15.22005879110094");
+            */
+
+
+
+            // Imports the International Terrestrial Reference Frame (ITRF) which is defined by the IERS and
+            // defines the geodesic model of the Earth based on the ITRF files
+            final Frame            itrf     = FramesFactory.getITRF(IERSConventions.IERS_2010, true);
+            final OneAxisEllipsoid earth    = new OneAxisEllipsoid(Constants.WGS84_EARTH_EQUATORIAL_RADIUS,
+                    Constants.WGS84_EARTH_FLATTENING,
+                    itrf);   //
+
+
+            // Input to define the location of the ground station and it's name
+            final GeodeticPoint    location = new GeodeticPoint(FastMath.toRadians(55.860916),
+                    FastMath.toRadians(-4.251433),
+                    49);
+            final GroundStation    station  = new GroundStation(new TopocentricFrame(earth, location, "GU-virt"));
+
+
+            // measurements generation parameters
+            final double       minElevation = FastMath.toRadians(1.0);
+            final double       timeStep     = 5.0;
+            final TimeScale    utc          = TimeScalesFactory.getUTC();
+            final AbsoluteDate t0           = new AbsoluteDate("2019-06-11T00:00:00.000", utc);
+            final double       duration     = Constants.JULIAN_DAY;  // Sets the duration to be the length of a Julian day
+
+
+            //*
+            // atmosphere model for drag
+            MarshallSolarActivityFutureEstimation msafe =
+                    new MarshallSolarActivityFutureEstimation(MarshallSolarActivityFutureEstimation.DEFAULT_SUPPORTED_NAMES,
+                            MarshallSolarActivityFutureEstimation.StrengthLevel.AVERAGE);
+            manager.feed(msafe.getSupportedNames(), msafe);
+            //Atmosphere atmosphere = new DTM2000(msafe, CelestialBodyFactory.getSun(), earth);
+            Atmosphere atmosphere = new NRLMSISE00(msafe, CelestialBodyFactory.getSun(), earth);
+
+            // this orbit is a dummy one, close to the first results from orbit determination from Max Valier satellite
+            final NormalizedSphericalHarmonicsProvider gravity = GravityFieldFactory.getNormalizedProvider(12, 12);
+            final AbsoluteDate             tOrb      = new AbsoluteDate("2019-06-11T16:35:29.149", utc);
+            final TimeStampedPVCoordinates pvt       = new TimeStampedPVCoordinates(tOrb,
+                    new Vector3D(-5253194.0, -4400295.0, 80075.0),
+                    new Vector3D(-559.0, 764.0, 7585.0));
+            final CartesianOrbit orbit      = new CartesianOrbit(pvt, FramesFactory.getEME2000(), gravity.getMu());
+            final OrbitType type       = OrbitType.CARTESIAN;
+
+            // set up numerical propagator
+            final double[][]               tol        = NumericalPropagator.tolerances(10.0, orbit, type);
+            final ODEIntegrator integrator = new DormandPrince853Integrator(0.001, 300.0, tol[0], tol[1]);
+            final NumericalPropagator      propagator = new NumericalPropagator(integrator);
+            propagator.setOrbitType(type);
+
+            propagator.setInitialState(new SpacecraftState(orbit,  16.0)); // the second argument is the spacecraft mass
+
+
+
+            // add a few realistic force models
+            final double  cd          = 2.0;
+            final double  area        = 0.25;
+            propagator.addForceModel(new HolmesFeatherstoneAttractionModel(itrf, gravity));
+            propagator.addForceModel(new ThirdBodyAttraction(CelestialBodyFactory.getSun()));
+            propagator.addForceModel(new ThirdBodyAttraction(CelestialBodyFactory.getMoon()));
+            propagator.addForceModel(new DragForce(atmosphere, new IsotropicDrag(cd, area)));
+
+            //*/
+
+            // set up some correction models
+            // coefficients files for Vienna Model 3 can be found at
+            // http://vmf.geo.tuwien.ac.at/trop_products/GRID/1x1/VMF3/VMF3_OP/2019/
+            final ViennaModelCoefficientsLoader loader = new ViennaModelCoefficientsLoader(location.getLatitude(),
+                                                                                           location.getLongitude(),
+                                                                                           ViennaModelType.VIENNA_THREE);
+            loader.loadViennaCoefficients(t0.getComponents(utc));
+            final DiscreteTroposphericModel  tropo      = new ViennaThreeModel(loader.getA(),
+                                                                               loader.getZenithDelay(),
+                                                                               location.getLatitude(),
+                                                                               location.getLongitude());
+            final AtmosphericRefractionModel refraction = new EarthITU453AtmosphereRefraction(location.getAltitude());
+
+            // set up measurements generation, with realistic models
+            final Generator            generator    = new Generator();
+            //final ObservableSatellite  os           = generator.addPropagator(TLEPropagator.selectExtrapolator(tle20190611));
+            final ObservableSatellite  os           = generator.addPropagator(propagator);
+
+            /*
+            Range rate builder
+             */
+
+            final double               sigma        = 40; // the value we will tune
+            final RealMatrix covariance   = MatrixUtils.createRealDiagonalMatrix(new double[] { sigma * sigma });
+
+            final RandomGenerator  random = new Well19937c(0x9e9409e2520c1fc3l); // you can change this seed as you like, it's just a seed
+
+            final CorrelatedRandomVectorGenerator crvg =
+                    new CorrelatedRandomVectorGenerator(covariance,
+                            1.0e-10,
+                            new GaussianRandomGenerator(random));
+            final RangeRateBuilder     builder      = new RangeRateBuilder(crvg, station, false, sigma, 1.0, os);//*/
+
+            final double rangeRateBias = 375.0;
+            builder.addModifier(new Bias<RangeRate>(new String[] { station.getBaseFrame().getName() + "-range-rate-bias" },
+                    new double[] { rangeRateBias },
+                    new double[] { 1.0 },
+                    new double[] { Double.NEGATIVE_INFINITY },
+                    new double[] { Double.POSITIVE_INFINITY }));
+
+
+            builder.addModifier(new RangeRateTroposphericDelayModifier(tropo, false));
+            final DatesSelector        selector     = new FixedStepSelector(timeStep, utc);
+            final EventDetector        detector     = new ElevationDetector(station.getBaseFrame()).
+                                                      withConstantElevation(minElevation).
+                                                      withRefraction(refraction).
+                                                      withHandler(new ContinueOnEvent<>());
+            final Scheduler<RangeRate> scheduler    = new EventBasedScheduler<>(builder, selector, generator.getPropagator(os), detector,
+                                                                                SignSemantic.FEASIBLE_MEASUREMENT_WHEN_POSITIVE);
+            generator.addScheduler(scheduler);
+
+            // generate measurements
+            final SortedSet<ObservedMeasurement<?>> measurements = generator.generate(t0, t0.shiftedBy(duration));
+            System.out.println("generated " + measurements.size() + " measurements");
+            System.out.println("first measurement at " + measurements.first().getDate());
+            System.out.println("last  measurement at " + measurements.last().getDate());
+
+
+            // save measurement in a file
+            AbsoluteDate mjdRefUTC = new AbsoluteDate(DateComponents.MODIFIED_JULIAN_EPOCH, utc);
+            try (PrintWriter out = new PrintWriter(new File(home, "generated-doppler-"+station.getBaseFrame().getName()+"-sd0-25.dat"))) {
+                measurements.
+                stream().
+                        forEach(m ->  out.format(Locale.US, "%s %s %s %12.6f%n",   // Without MJD coloumn
+                                m.getDate(),
+                                "RANGE_RATE",
+                                station.getBaseFrame().getName(),
+                                (m.getObservedValue()[0]/1000)));
+                // Uncomment to get mjd column
+                /*forEach(m ->  out.format(Locale.US, "%s %14.8f %s %s %12.6f%n",
+                                         m.getDate(),
+                                         m.getDate().offsetFrom(mjdRefUTC, utc) / Constants.JULIAN_DAY,
+                                         "RANGE-RATE",
+                                         station.getBaseFrame().getName(),
+                                         m.getObservedValue()[0]));*/
+            }
+
+
+        } catch (IOException ioe) {
+            System.err.println(ioe.getLocalizedMessage());
+            System.exit(1);
+        } catch (OrekitException oe) {
+            System.err.println(oe.getLocalizedMessage());
+            System.exit(1);
+        }
+    }
+
+}

src/main/java/fr/cs/examples/estimation/PVData.java

+package fr.cs.examples.estimation;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintStream;
+import java.io.UnsupportedEncodingException;
+import java.net.URISyntaxException;
+import java.text.ParseException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.SortedSet;
+import java.util.TreeSet;
+import java.util.regex.Pattern;
+
+import org.hipparchus.exception.LocalizedCoreFormats;
+import org.hipparchus.geometry.euclidean.threed.Vector3D;
+import org.hipparchus.linear.QRDecomposer;
+import org.hipparchus.optim.nonlinear.vector.leastsquares.GaussNewtonOptimizer;
+import org.hipparchus.optim.nonlinear.vector.leastsquares.LeastSquaresOptimizer;
+import org.hipparchus.optim.nonlinear.vector.leastsquares.LeastSquaresProblem;
+import org.hipparchus.optim.nonlinear.vector.leastsquares.LevenbergMarquardtOptimizer;
+import org.hipparchus.stat.descriptive.StreamingStatistics;
+import org.hipparchus.util.FastMath;
+import org.hipparchus.util.Precision;
+import org.orekit.attitudes.AttitudeProvider;
+import org.orekit.attitudes.BodyCenterPointing;
+import org.orekit.attitudes.LofOffset;
+import org.orekit.attitudes.NadirPointing;
+import org.orekit.attitudes.YawCompensation;
+import org.orekit.attitudes.YawSteering;
+import org.orekit.bodies.CelestialBody;
+import org.orekit.bodies.CelestialBodyFactory;
+import org.orekit.bodies.GeodeticPoint;
+import org.orekit.bodies.OneAxisEllipsoid;
+import org.orekit.data.DataProvidersManager;
+import org.orekit.data.DirectoryCrawler;
+import org.orekit.errors.OrekitException;
+import org.orekit.errors.OrekitMessages;
+import org.orekit.estimation.leastsquares.BatchLSEstimator;
+import org.orekit.estimation.leastsquares.BatchLSObserver;
+import org.orekit.estimation.measurements.AngularAzEl;
+import org.orekit.estimation.measurements.EstimatedMeasurement;
+import org.orekit.estimation.measurements.EstimationsProvider;
+import org.orekit.estimation.measurements.GroundStation;
+import org.orekit.estimation.measurements.ObservableSatellite;
+import org.orekit.estimation.measurements.ObservedMeasurement;
+import org.orekit.estimation.measurements.PV;
+import org.orekit.estimation.measurements.Range;
+import org.orekit.estimation.measurements.RangeRate;
+import org.orekit.estimation.measurements.modifiers.AngularRadioRefractionModifier;
+import org.orekit.estimation.measurements.modifiers.Bias;
+import org.orekit.estimation.measurements.modifiers.OnBoardAntennaRangeModifier;
+import org.orekit.estimation.measurements.modifiers.OutlierFilter;
+import org.orekit.estimation.measurements.modifiers.RangeIonosphericDelayModifier;
+import org.orekit.estimation.measurements.modifiers.RangeRateIonosphericDelayModifier;
+import org.orekit.estimation.measurements.modifiers.RangeTroposphericDelayModifier;
+import org.orekit.forces.PolynomialParametricAcceleration;
+import org.orekit.forces.drag.DragForce;
+import org.orekit.forces.drag.DragSensitive;
+import org.orekit.forces.drag.IsotropicDrag;
+import org.orekit.forces.gravity.HolmesFeatherstoneAttractionModel;
+import org.orekit.forces.gravity.OceanTides;
+import org.orekit.forces.gravity.Relativity;
+import org.orekit.forces.gravity.SolidTides;
+import org.orekit.forces.gravity.ThirdBodyAttraction;
+import org.orekit.forces.gravity.potential.GravityFieldFactory;
+import org.orekit.forces.gravity.potential.NormalizedSphericalHarmonicsProvider;
+import org.orekit.forces.radiation.IsotropicRadiationSingleCoefficient;
+import org.orekit.forces.radiation.RadiationSensitive;
+import org.orekit.forces.radiation.SolarRadiationPressure;
+import org.orekit.frames.EOPHistory;
+import org.orekit.frames.Frame;
+import org.orekit.frames.FramesFactory;
+import org.orekit.frames.LOFType;
+import org.orekit.frames.TopocentricFrame;
+import org.orekit.gnss.Frequency;
+import org.orekit.gnss.MeasurementType;
+import org.orekit.gnss.ObservationData;
+import org.orekit.gnss.ObservationDataSet;
+import org.orekit.gnss.RinexLoader;
+import org.orekit.gnss.SatelliteSystem;
+import org.orekit.models.AtmosphericRefractionModel;
+import org.orekit.models.earth.EarthITU453AtmosphereRefraction;
+import org.orekit.models.earth.atmosphere.Atmosphere;
+import org.orekit.models.earth.atmosphere.DTM2000;
+import org.orekit.models.earth.atmosphere.data.MarshallSolarActivityFutureEstimation;
+import org.orekit.models.earth.displacement.OceanLoading;
+import org.orekit.models.earth.displacement.OceanLoadingCoefficientsBLQFactory;
+import org.orekit.models.earth.displacement.StationDisplacement;
+import org.orekit.models.earth.displacement.TidalDisplacement;
+import org.orekit.models.earth.ionosphere.IonosphericModel;
+import org.orekit.models.earth.ionosphere.KlobucharIonoCoefficientsLoader;
+import org.orekit.models.earth.ionosphere.KlobucharIonoModel;
+import org.orekit.models.earth.troposphere.DiscreteTroposphericModel;
+import org.orekit.models.earth.troposphere.EstimatedTroposphericModel;
+import org.orekit.models.earth.troposphere.GlobalMappingFunctionModel;
+import org.orekit.models.earth.troposphere.MappingFunction;
+import org.orekit.models.earth.troposphere.NiellMappingFunctionModel;
+import org.orekit.models.earth.troposphere.SaastamoinenModel;
+import org.orekit.orbits.CartesianOrbit;
+import org.orekit.orbits.CircularOrbit;
+import org.orekit.orbits.EquinoctialOrbit;
+import org.orekit.orbits.KeplerianOrbit;
+import org.orekit.orbits.Orbit;
+import org.orekit.orbits.PositionAngle;
+import org.orekit.propagation.SpacecraftState;
+import org.orekit.propagation.analytical.tle.TLE;
+import org.orekit.propagation.analytical.tle.TLEPropagator;
+import org.orekit.propagation.conversion.DormandPrince853IntegratorBuilder;
+import org.orekit.propagation.conversion.NumericalPropagatorBuilder;
+import org.orekit.time.AbsoluteDate;
+import org.orekit.time.DateComponents;
+import org.orekit.time.TimeScalesFactory;
+import org.orekit.utils.Constants;
+import org.orekit.utils.IERSConventions;
+import org.orekit.utils.PVCoordinates;
+import org.orekit.utils.ParameterDriver;
+import org.orekit.utils.ParameterDriversList;
+
+import fr.cs.examples.KeyValueFileParser;
+
+public class PVData {
+
+    /** Container for Position-velocity data. */
+
+    /** Container for Position-velocity data. */
+
+    /** Position sigma. */
+    public final double positionSigma;
+
+    /** Velocity sigma. */
+    public final double velocitySigma;
+
+    /** Simple constructor.
+     * @param positionSigma position sigma
+     * @param velocitySigma velocity sigma
+     */
+    public PVData(final double positionSigma, final double velocitySigma) {
+        this.positionSigma = positionSigma;
+        this.velocitySigma = velocitySigma;
+    }
+
+}

src/main/java/fr/cs/examples/estimation/PVParser.java

+package fr.cs.examples.estimation;
+
+import org.hipparchus.geometry.euclidean.threed.Vector3D;
+import org.orekit.estimation.measurements.ObservableSatellite;
+import org.orekit.estimation.measurements.PV;
+import org.orekit.estimation.measurements.Range;
+import org.orekit.estimation.measurements.modifiers.Bias;
+
+import java.util.Map;
+
+public class PVParser extends OrbitDetermination.MeasurementsParser<PV> {
+
+    /** Parser for PV measurements. */
+    @Override
+    public PV parseFields(final String[] fields,
+                          final Map<String, StationData> stations,
+                          final PVData pvData,
+                          final ObservableSatellite satellite,
+                          final Bias<Range> satRangeBias,
+                          final Weights weights,
+                          final String line,
+                          final int lineNumber,
+                          final String fileName) {
+        // field 2, which corresponds to stations in other measurements, is ignored
+        // this allows the measurements files to be columns aligned
+        // by inserting something like "----" instead of a station name
+        checkFields(9, fields, line, lineNumber, fileName);
+        return new org.orekit.estimation.measurements.PV(getDate(fields[0], line, lineNumber, fileName),
+                new Vector3D(Double.parseDouble(fields[3]) * 1000.0,
+                        Double.parseDouble(fields[4]) * 1000.0,
+                        Double.parseDouble(fields[5]) * 1000.0),
+                new Vector3D(Double.parseDouble(fields[6]) * 1000.0,
+                        Double.parseDouble(fields[7]) * 1000.0,
+                        Double.parseDouble(fields[8]) * 1000.0),
+                pvData.positionSigma,
+                pvData.velocitySigma,
+                weights.pvBaseWeight,
+                satellite);
+    }
+}

src/main/java/fr/cs/examples/estimation/RangeParser.java

+package fr.cs.examples.estimation;
+
+
+import java.util.Map;
+
+import org.orekit.estimation.measurements.ObservableSatellite;
+import org.orekit.estimation.measurements.Range;
+import org.orekit.estimation.measurements.modifiers.Bias;
+
+
+public class RangeParser extends OrbitDetermination.MeasurementsParser<Range> {
+
+    /** Parser for range measurements */
+    /** {@inheritDoc} */
+    @Override
+    public Range parseFields(final String[] fields,
+                             final Map<String, StationData> stations,
+                             final PVData pvData,
+                             final ObservableSatellite satellite,
+                             final Bias<Range> satRangeBias,
+                             final Weights weights,
+                             final String line,
+                             final int lineNumber,
+                             final String fileName) {
+        checkFields(4, fields, line, lineNumber, fileName);
+        final StationData stationData = getStationData(fields[2], stations, line, lineNumber, fileName);
+        final Range range = new Range(stationData.station, true,
+                getDate(fields[0], line, lineNumber, fileName),
+                Double.parseDouble(fields[3]) * 1000.0,
+                stationData.rangeSigma,
+                weights.rangeBaseWeight,
+                satellite);
+        if (stationData.rangeBias != null) {
+            range.addModifier(stationData.rangeBias);
+        }
+        if (satRangeBias != null) {
+            range.addModifier(satRangeBias);
+        }
+        if (stationData.rangeTroposphericCorrection != null) {
+            range.addModifier(stationData.rangeTroposphericCorrection);
+        }
+        return range;
+    }
+
+}

src/main/java/fr/cs/examples/estimation/RangeRateParser.java

+package fr.cs.examples.estimation;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintStream;
+import java.io.UnsupportedEncodingException;
+import java.net.URISyntaxException;
+import java.text.ParseException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.SortedSet;
+import java.util.TreeSet;
+import java.util.regex.Pattern;
+
+import org.hipparchus.exception.LocalizedCoreFormats;
+import org.hipparchus.geometry.euclidean.threed.Vector3D;
+import org.hipparchus.linear.QRDecomposer;
+import org.hipparchus.optim.nonlinear.vector.leastsquares.GaussNewtonOptimizer;
+import org.hipparchus.optim.nonlinear.vector.leastsquares.LeastSquaresOptimizer;
+import org.hipparchus.optim.nonlinear.vector.leastsquares.LeastSquaresProblem;
+import org.hipparchus.optim.nonlinear.vector.leastsquares.LevenbergMarquardtOptimizer;
+import org.hipparchus.stat.descriptive.StreamingStatistics;
+import org.hipparchus.util.FastMath;
+import org.hipparchus.util.Precision;
+import org.orekit.attitudes.AttitudeProvider;
+import org.orekit.attitudes.BodyCenterPointing;
+import org.orekit.attitudes.LofOffset;
+import org.orekit.attitudes.NadirPointing;
+import org.orekit.attitudes.YawCompensation;
+import org.orekit.attitudes.YawSteering;
+import org.orekit.bodies.CelestialBody;
+import org.orekit.bodies.CelestialBodyFactory;
+import org.orekit.bodies.GeodeticPoint;
+import org.orekit.bodies.OneAxisEllipsoid;
+import org.orekit.data.DataProvidersManager;
+import org.orekit.data.DirectoryCrawler;
+import org.orekit.errors.OrekitException;
+import org.orekit.errors.OrekitMessages;
+import org.orekit.estimation.leastsquares.BatchLSEstimator;
+import org.orekit.estimation.leastsquares.BatchLSObserver;
+import org.orekit.estimation.measurements.AngularAzEl;
+import org.orekit.estimation.measurements.EstimatedMeasurement;
+import org.orekit.estimation.measurements.EstimationsProvider;
+import org.orekit.estimation.measurements.GroundStation;
+import org.orekit.estimation.measurements.ObservableSatellite;
+import org.orekit.estimation.measurements.ObservedMeasurement;
+import org.orekit.estimation.measurements.PV;
+import org.orekit.estimation.measurements.Range;
+import org.orekit.estimation.measurements.RangeRate;
+import org.orekit.estimation.measurements.modifiers.AngularRadioRefractionModifier;
+import org.orekit.estimation.measurements.modifiers.Bias;
+import org.orekit.estimation.measurements.modifiers.OnBoardAntennaRangeModifier;
+import org.orekit.estimation.measurements.modifiers.OutlierFilter;
+import org.orekit.estimation.measurements.modifiers.RangeIonosphericDelayModifier;
+import org.orekit.estimation.measurements.modifiers.RangeRateIonosphericDelayModifier;
+import org.orekit.estimation.measurements.modifiers.RangeTroposphericDelayModifier;
+import org.orekit.forces.PolynomialParametricAcceleration;
+import org.orekit.forces.drag.DragForce;
+import org.orekit.forces.drag.DragSensitive;
+import org.orekit.forces.drag.IsotropicDrag;
+import org.orekit.forces.gravity.HolmesFeatherstoneAttractionModel;
+import org.orekit.forces.gravity.OceanTides;
+import org.orekit.forces.gravity.Relativity;
+import org.orekit.forces.gravity.SolidTides;
+import org.orekit.forces.gravity.ThirdBodyAttraction;
+import org.orekit.forces.gravity.potential.GravityFieldFactory;
+import org.orekit.forces.gravity.potential.NormalizedSphericalHarmonicsProvider;
+import org.orekit.forces.radiation.IsotropicRadiationSingleCoefficient;
+import org.orekit.forces.radiation.RadiationSensitive;
+import org.orekit.forces.radiation.SolarRadiationPressure;
+import org.orekit.frames.EOPHistory;
+import org.orekit.frames.Frame;
+import org.orekit.frames.FramesFactory;
+import org.orekit.frames.LOFType;
+import org.orekit.frames.TopocentricFrame;
+import org.orekit.gnss.Frequency;
+import org.orekit.gnss.MeasurementType;
+import org.orekit.gnss.ObservationData;
+import org.orekit.gnss.ObservationDataSet;
+import org.orekit.gnss.RinexLoader;
+import org.orekit.gnss.SatelliteSystem;
+import org.orekit.models.AtmosphericRefractionModel;
+import org.orekit.models.earth.EarthITU453AtmosphereRefraction;
+import org.orekit.models.earth.atmosphere.Atmosphere;
+import org.orekit.models.earth.atmosphere.DTM2000;
+import org.orekit.models.earth.atmosphere.data.MarshallSolarActivityFutureEstimation;
+import org.orekit.models.earth.displacement.OceanLoading;
+import org.orekit.models.earth.displacement.OceanLoadingCoefficientsBLQFactory;
+import org.orekit.models.earth.displacement.StationDisplacement;
+import org.orekit.models.earth.displacement.TidalDisplacement;
+import org.orekit.models.earth.ionosphere.IonosphericModel;
+import org.orekit.models.earth.ionosphere.KlobucharIonoCoefficientsLoader;
+import org.orekit.models.earth.ionosphere.KlobucharIonoModel;
+import org.orekit.models.earth.troposphere.DiscreteTroposphericModel;
+import org.orekit.models.earth.troposphere.EstimatedTroposphericModel;
+import org.orekit.models.earth.troposphere.GlobalMappingFunctionModel;
+import org.orekit.models.earth.troposphere.MappingFunction;
+import org.orekit.models.earth.troposphere.NiellMappingFunctionModel;
+import org.orekit.models.earth.troposphere.SaastamoinenModel;
+import org.orekit.orbits.CartesianOrbit;
+import org.orekit.orbits.CircularOrbit;
+import org.orekit.orbits.EquinoctialOrbit;
+import org.orekit.orbits.KeplerianOrbit;
+import org.orekit.orbits.Orbit;
+import org.orekit.orbits.PositionAngle;
+import org.orekit.propagation.SpacecraftState;
+import org.orekit.propagation.analytical.tle.TLE;
+import org.orekit.propagation.analytical.tle.TLEPropagator;
+import org.orekit.propagation.conversion.DormandPrince853IntegratorBuilder;
+import org.orekit.propagation.conversion.NumericalPropagatorBuilder;
+import org.orekit.time.AbsoluteDate;
+import org.orekit.time.DateComponents;
+import org.orekit.time.TimeScalesFactory;
+import org.orekit.utils.Constants;
+import org.orekit.utils.IERSConventions;
+import org.orekit.utils.PVCoordinates;
+import org.orekit.utils.ParameterDriver;
+import org.orekit.utils.ParameterDriversList;
+
+import fr.cs.examples.KeyValueFileParser;
+
+
+public class RangeRateParser extends OrbitDetermination.MeasurementsParser<RangeRate> {
+
+    /** Parser for range rate measurements. */
+    /** {@inheritDoc} */
+    @Override
+    public RangeRate parseFields(final String[] fields,
+                                 final Map<String, StationData> stations,
+                                 final PVData pvData,
+                                 final ObservableSatellite satellite,
+                                 final Bias<Range> satRangeBias,
+                                 final Weights weights,
+                                 final String line,
+                                 final int lineNumber,
+                                 final String fileName) {
+        checkFields(4, fields, line, lineNumber, fileName);
+        final StationData stationData = getStationData(fields[2], stations, line, lineNumber, fileName);
+        final RangeRate rangeRate = new RangeRate(stationData.station,
+                getDate(fields[0], line, lineNumber, fileName),
+                Double.parseDouble(fields[3]) * 1000.0,
+                stationData.rangeRateSigma,
+                weights.rangeRateBaseWeight,
+                true, satellite);
+        if (stationData.rangeRateBias != null) {
+            rangeRate.addModifier(stationData.rangeRateBias);
+        }
+        return rangeRate;
+    }
+
+}