TidalCorrection.java

  1. /* Copyright 2002-2013 CS Systèmes d'Information
  2.  * Licensed to CS Systèmes d'Information (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.frames;

  19. import java.util.ArrayList;
  20. import java.util.List;

  22. import org.apache.commons.math3.util.FastMath;
  23. import org.orekit.errors.OrekitException;
  24. import org.orekit.errors.TimeStampedCacheException;
  25. import org.orekit.time.AbsoluteDate;
  26. import org.orekit.time.TimeStamped;
  27. import org.orekit.utils.Constants;
  28. import org.orekit.utils.OrekitConfiguration;
  29. import org.orekit.utils.GenericTimeStampedCache;
  30. import org.orekit.utils.TimeStampedCache;
  31. import org.orekit.utils.TimeStampedGenerator;


  34. /** Compute tidal correction to the pole motion.
  35.  * <p>This class computes the diurnal and semidiurnal variations in the
  36.  * Earth orientation. It is a java translation of the fortran subroutine
  37.  * found at ftp://tai.bipm.org/iers/conv2003/chapter8/ortho_eop.f.</p>
  38.  * @author Pascal Parraud
  39.  * @author Evan Ward
  40.  * @deprecated as of 6.1 replaced by {@link org.orekit.utils.IERSConventions#getEOPTidalCorrection()}
  41.  */
  42. @Deprecated
  43. public class TidalCorrection {

  45.     /** pi;/2. */
  46.     private static final double HALF_PI = FastMath.PI / 2.0;

  48.     /** Angular units conversion factor. */
  49.     private static final double MICRO_ARC_SECONDS_TO_RADIANS = Constants.ARC_SECONDS_TO_RADIANS * 1.0e-6;

  51.     /** Time units conversion factor. */
  52.     private static final double MICRO_SECONDS_TO_SECONDS = 1.0e-6;

  54.     /** Number of interpolation points to use. */
  55.     private static final int INTERPOLATION_POINTS = 8;

  57.     /** Step size in days of the interpolation data points. */
  58.     private static final double STEP_SIZE = 3.0 / 32.0;

  60.     /** Difference in days between the modified julian day epoch and the year 1960. */
  61.     private static final double MJD_TO_1960 = 37076.5;

  63.     /** HS parameter. */
  64.     private static final double[] HS = {
  65.         -001.94, -001.25, -006.64, -001.51, -008.02,
  66.         -009.47, -050.20, -001.80, -009.54, +001.52,
  67.         -049.45, -262.21, +001.70, +003.43, +001.94,
  68.         +001.37, +007.41, +020.62, +004.14, +003.94,
  69.         -007.14, +001.37, -122.03, +001.02, +002.89,
  70.         -007.30, +368.78, +050.01, -001.08, +002.93,
  71.         +005.25, +003.95, +020.62, +004.09, +003.42,
  72.         +001.69, +011.29, +007.23, +001.51, +002.16,
  73.         +001.38, +001.80, +004.67, +016.01, +019.32,
  74.         +001.30, -001.02, -004.51, +120.99, +001.13,
  75.         +022.98, +001.06, -001.90, -002.18, -023.58,
  76.         +631.92, +001.92, -004.66, -017.86, +004.47,
  77.         +001.97, +017.20, +294.00, -002.46, -001.02,
  78.         +079.96, +023.83, +002.59, +004.47, +001.95,
  79.         +001.17
  80.     };

  82.     /** PHASE parameter. */
  83.     private static final double[] PHASE = {
  84.         +09.0899831 - HALF_PI, +08.8234208 - HALF_PI, +12.1189598 - HALF_PI,
  85.         +01.4425700 - HALF_PI, +04.7381090 - HALF_PI, +04.4715466 - HALF_PI,
  86.         +07.7670857 - HALF_PI, -02.9093042 - HALF_PI, +00.3862349 - HALF_PI,
  87.         -03.1758666 - HALF_PI, +00.1196725 - HALF_PI, +03.4152116 - HALF_PI,
  88.         +12.8946194 - HALF_PI, +05.5137686 - HALF_PI, +06.4441883 - HALF_PI,
  89.         -04.2322016 - HALF_PI, -00.9366625 - HALF_PI, +08.5427453 - HALF_PI,
  90.         +11.8382843 - HALF_PI, +01.1618945 - HALF_PI, +05.9693878 - HALF_PI,
  91.         -01.2032249 - HALF_PI, +02.0923141 - HALF_PI, -01.7847596 - HALF_PI,
  92.         +08.0679449 - HALF_PI, +00.8953321 - HALF_PI, +04.1908712 - HALF_PI,
  93.         +07.4864102 - HALF_PI, +10.7819493 - HALF_PI, +00.3137975 - HALF_PI,
  94.         +06.2894282 - HALF_PI, +07.2198478 - HALF_PI, -00.1610030 - HALF_PI,
  95.         +03.1345361 - HALF_PI, +02.8679737 - HALF_PI, -04.5128771 - HALF_PI,
  96.         +04.9665307 - HALF_PI, +08.2620698 - HALF_PI, +11.5576089 - HALF_PI,
  97.         +00.6146566 - HALF_PI, +03.9101957 - HALF_PI,
  98.         +20.6617051, +13.2808543, +16.3098310, +08.9289802, +05.0519065,
  99.         +15.8350306, +08.6624178, +11.9579569, +08.0808832, +04.5771061,
  100.         +00.7000324, +14.9869335, +11.4831564, +04.3105437, +07.6060827,
  101.         +03.7290090, +10.6350594, +03.2542086, +12.7336164, +16.0291555,
  102.         +10.1602590, +06.2831853, +02.4061116, +05.0862033, +08.3817423,
  103.         +11.6772814, +14.9728205, +04.0298682, +07.3254073, +09.1574019
  104.     };

  106.     /** FREQUENCY parameter. */
  107.     private static final double[] FREQUENCY = {
  108.         05.18688050, 05.38346657, 05.38439079, 05.41398343, 05.41490765,
  109.         05.61149372, 05.61241794, 05.64201057, 05.64293479, 05.83859664,
  110.         05.83952086, 05.84044508, 05.84433381, 05.87485066, 06.03795537,
  111.         06.06754801, 06.06847223, 06.07236095, 06.07328517, 06.10287781,
  112.         06.24878055, 06.26505830, 06.26598252, 06.28318449, 06.28318613,
  113.         06.29946388, 06.30038810, 06.30131232, 06.30223654, 06.31759007,
  114.         06.33479368, 06.49789839, 06.52841524, 06.52933946, 06.72592553,
  115.         06.75644239, 06.76033111, 06.76125533, 06.76217955, 06.98835826,
  116.         06.98928248, 11.45675174, 11.48726860, 11.68477889, 11.71529575,
  117.         11.73249771, 11.89560406, 11.91188181, 11.91280603, 11.93000800,
  118.         11.94332289, 11.96052486, 12.11031632, 12.12363121, 12.13990896,
  119.         12.14083318, 12.15803515, 12.33834347, 12.36886033, 12.37274905,
  120.         12.37367327, 12.54916865, 12.56637061, 12.58357258, 12.59985198,
  121.         12.60077620, 12.60170041, 12.60262463, 12.82880334, 12.82972756,
  122.         13.06071921
  123.     };

  125.     /** Orthotide weight factors. */
  126.     private static final double[] SP = {
  127.         0.0298,
  128.         0.1408,
  129.         0.0805,
  130.         0.6002,
  131.         0.3025,
  132.         0.1517,
  133.         0.0200,
  134.         0.0905,
  135.         0.0638,
  136.         0.3476,
  137.         0.1645,
  138.         0.0923
  139.     };

  141.     /** Orthoweights for X polar motion. */
  142.     private static final double[] ORTHOWX = {
  143.         -06.77832 * MICRO_ARC_SECONDS_TO_RADIANS,
  144.         -14.86323 * MICRO_ARC_SECONDS_TO_RADIANS,
  145.         +00.47884 * MICRO_ARC_SECONDS_TO_RADIANS,
  146.         -01.45303 * MICRO_ARC_SECONDS_TO_RADIANS,
  147.         +00.16406 * MICRO_ARC_SECONDS_TO_RADIANS,
  148.         +00.42030 * MICRO_ARC_SECONDS_TO_RADIANS,
  149.         +00.09398 * MICRO_ARC_SECONDS_TO_RADIANS,
  150.         +25.73054 * MICRO_ARC_SECONDS_TO_RADIANS,
  151.         -04.77974 * MICRO_ARC_SECONDS_TO_RADIANS,
  152.         +00.28080 * MICRO_ARC_SECONDS_TO_RADIANS,
  153.         +01.94539 * MICRO_ARC_SECONDS_TO_RADIANS,
  154.         -00.73089 * MICRO_ARC_SECONDS_TO_RADIANS
  155.     };

  157.     /** Orthoweights for Y polar motion. */
  158.     private static final double[] ORTHOWY = {
  159.         +14.86283 * MICRO_ARC_SECONDS_TO_RADIANS,
  160.         -06.77846 * MICRO_ARC_SECONDS_TO_RADIANS,
  161.         +01.45234 * MICRO_ARC_SECONDS_TO_RADIANS,
  162.         +00.47888 * MICRO_ARC_SECONDS_TO_RADIANS,
  163.         -00.42056 * MICRO_ARC_SECONDS_TO_RADIANS,
  164.         +00.16469 * MICRO_ARC_SECONDS_TO_RADIANS,
  165.         +15.30276 * MICRO_ARC_SECONDS_TO_RADIANS,
  166.         -04.30615 * MICRO_ARC_SECONDS_TO_RADIANS,
  167.         +00.07564 * MICRO_ARC_SECONDS_TO_RADIANS,
  168.         +02.28321 * MICRO_ARC_SECONDS_TO_RADIANS,
  169.         -00.45717 * MICRO_ARC_SECONDS_TO_RADIANS,
  170.         -01.62010 * MICRO_ARC_SECONDS_TO_RADIANS
  171.     };

  173.     /** Orthoweights for UT1. */
  174.     private static final double[] ORTHOWT = {
  175.         -1.76335 *  MICRO_SECONDS_TO_SECONDS,
  176.         +1.03364 *  MICRO_SECONDS_TO_SECONDS,
  177.         -0.27553 *  MICRO_SECONDS_TO_SECONDS,
  178.         +0.34569 *  MICRO_SECONDS_TO_SECONDS,
  179.         -0.12343 *  MICRO_SECONDS_TO_SECONDS,
  180.         -0.10146 *  MICRO_SECONDS_TO_SECONDS,
  181.         -0.47119 *  MICRO_SECONDS_TO_SECONDS,
  182.         +1.28997 *  MICRO_SECONDS_TO_SECONDS,
  183.         -0.19336 *  MICRO_SECONDS_TO_SECONDS,
  184.         +0.02724 *  MICRO_SECONDS_TO_SECONDS,
  185.         +0.08955 *  MICRO_SECONDS_TO_SECONDS,
  186.         +0.04726 *  MICRO_SECONDS_TO_SECONDS
  187.     };

  189.     /** Cache of computed tidal corrections. */
  190.     private final TimeStampedCache<CorrectionData> cache;

  192.     /** Simple constructor.
  193.      */
  194.     public TidalCorrection() {

  196.         // create cache
  197.         cache = new GenericTimeStampedCache<CorrectionData>(INTERPOLATION_POINTS,
  198.                                                      OrekitConfiguration.getCacheSlotsNumber(),
  199.                                                      Constants.JULIAN_YEAR, 7 * Constants.JULIAN_DAY,
  200.                                                      new Generator(), CorrectionData.class);

  202.     }

  204.     /** Get the dUT1 value.
  205.      * @param date date at which the value is desired
  206.      * @return dUT1 in seconds
  207.      */
  208.     public double getDUT1(final AbsoluteDate date) {

  210.         try {
  211.             final double t       = toDay(date);
  212.             final double tCenter = toDayQuantum(t);

  214.             final int n    = INTERPOLATION_POINTS;
  215.             final int nM12 = (n - 1) / 2;

  217.             final List<CorrectionData> corrections = cache.getNeighbors(date);

  219.             // copy points to a temporary array
  220.             final double[] dtNeville = new double[n];
  221.             for (int i = 0; i < n; i++) {
  222.                 dtNeville[i] = corrections.get(i).dt;
  223.             }

  225.             // interpolate corrections using Neville's algorithm
  226.             final double theta = (t - tCenter) / STEP_SIZE;
  227.             for (int j = 1; j < n; ++j) {
  228.                 for (int i = n - 1; i >= j; --i) {
  229.                     final double c1 = (theta + nM12 - i + j) / j;
  230.                     final double c2 = (theta + nM12 - i) / j;
  231.                     dtNeville[i] = c1 * dtNeville[i] - c2 * dtNeville[i - 1];
  232.                 }
  233.             }

  235.             return dtNeville[n - 1];
  236.         } catch (TimeStampedCacheException tce) {
  237.             // this should never happen as the generator is not bounded
  238.             throw OrekitException.createInternalError(tce);
  239.         }

  241.     }

  243.     /** Get the pole IERS Reference Pole correction.
  244.      * @param date date at which the correction is desired
  245.      * @return pole correction
  246.      */
  247.     public  PoleCorrection getPoleCorrection(final AbsoluteDate date) {

  249.         try {
  250.             final double t       = toDay(date);
  251.             final double tCenter = toDayQuantum(t);

  253.             final int n    = INTERPOLATION_POINTS;
  254.             final int nM12 = (n - 1) / 2;

  256.             final List<CorrectionData> corrections = this.cache.getNeighbors(date);

  258.             // copy points to a temporary array
  259.             final double[] dxNeville = new double[n];
  260.             final double[] dyNeville = new double[n];
  261.             for (int i = 0; i < n; i++) {
  262.                 final CorrectionData correction = corrections.get(i);
  263.                 dxNeville[i] = correction.dx;
  264.                 dyNeville[i] = correction.dy;
  265.             }

  267.             // interpolate corrections using Neville's algorithm
  268.             final double theta = (t - tCenter) / STEP_SIZE;
  269.             for (int j = 1; j < n; ++j) {
  270.                 for (int i = n - 1; i >= j; --i) {
  271.                     final double c1 = (theta + nM12 - i + j) / j;
  272.                     final double c2 = (theta + nM12 - i) / j;
  273.                     dxNeville[i] = c1 * dxNeville[i] - c2 * dxNeville[i - 1];
  274.                     dyNeville[i] = c1 * dyNeville[i] - c2 * dyNeville[i - 1];
  275.                 }
  276.             }

  278.             return new PoleCorrection(dxNeville[n - 1], dyNeville[n - 1]);
  279.         } catch (TimeStampedCacheException tce) {
  280.             // this should never happen as the generator is not bounded
  281.             throw OrekitException.createInternalError(tce);
  282.         }

  284.     }

  286.     /** Convert an {@link AbsoluteDate} to days past the epoch.
  287.      * @param date the date to convert
  288.      * @return days past the epoch, including the fractional part
  289.      */
  290.     private static double toDay(final AbsoluteDate date) {
  291.         return date.durationFrom(AbsoluteDate.MODIFIED_JULIAN_EPOCH) / Constants.JULIAN_DAY - MJD_TO_1960;
  292.     }

  294.     /** Convert days to an {@link AbsoluteDate}.
  295.      * @param t the time in days
  296.      * @return the date corresponding to {@code t}
  297.      */
  298.     private static AbsoluteDate toDate(final double t) {
  299.         return AbsoluteDate.MODIFIED_JULIAN_EPOCH.shiftedBy(Constants.JULIAN_DAY * (t + MJD_TO_1960));
  300.     }

  302.     /** Convert a day to the closest quantum in terms of {@link #STEP_SIZE}.
  303.      * @param t the day to convert
  304.      * @return the closest quantum before t, still in days
  305.      */
  306.     private static double toDayQuantum(final double t) {
  307.         return STEP_SIZE * FastMath.floor(t / STEP_SIZE);
  308.     }

  310.     /** Compute the partials of the tidal variations to the orthoweights.
  311.      * @param t offset from reference epoch in days
  312.      * @return the pole and UT1 correction
  313.      */
  314.     private static CorrectionData computeCorrections(final double t) {

  316.         // compute the time dependent potential matrix
  317.         final double d60A = t + 2;
  318.         final double d60B = t;
  319.         final double d60C = t - 2;

  321.         double anm00 = 0;
  322.         double anm01 = 0;
  323.         double anm02 = 0;
  324.         double bnm00 = 0;
  325.         double bnm01 = 0;
  326.         double bnm02 = 0;
  327.         for (int j = 0; j < 41; j++) {

  329.             final double hsj = HS[j];
  330.             final double pj  = PHASE[j];
  331.             final double fj  = FREQUENCY[j];

  333.             final double alphaA = pj + fj * d60A;
  334.             anm00 += hsj * FastMath.cos(alphaA);
  335.             bnm00 -= hsj * FastMath.sin(alphaA);

  337.             final double alphaB = pj + fj * d60B;
  338.             anm01 += hsj * FastMath.cos(alphaB);
  339.             bnm01 -= hsj * FastMath.sin(alphaB);

  341.             final double alphaC = pj + fj * d60C;
  342.             anm02 += hsj * FastMath.cos(alphaC);
  343.             bnm02 -= hsj * FastMath.sin(alphaC);

  345.         }

  347.         double anm10 = 0;
  348.         double anm11 = 0;
  349.         double anm12 = 0;
  350.         double bnm10 = 0;
  351.         double bnm11 = 0;
  352.         double bnm12 = 0;
  353.         for (int j = 41; j < HS.length; j++) {

  355.             final double hsj = HS[j];
  356.             final double pj  = PHASE[j];
  357.             final double fj  = FREQUENCY[j];

  359.             final double alphaA = pj + fj * d60A;
  360.             anm10 += hsj * FastMath.cos(alphaA);
  361.             bnm10 -= hsj * FastMath.sin(alphaA);

  363.             final double alphaB = pj + fj * d60B;
  364.             anm11 += hsj * FastMath.cos(alphaB);
  365.             bnm11 -= hsj * FastMath.sin(alphaB);

  367.             final double alphaC = pj + fj * d60C;
  368.             anm12 += hsj * FastMath.cos(alphaC);
  369.             bnm12 -= hsj * FastMath.sin(alphaC);

  371.         }

  373.         // orthogonalize the response terms ...
  374.         final double ap0 = anm02 + anm00;
  375.         final double am0 = anm02 - anm00;
  376.         final double bp0 = bnm02 + bnm00;
  377.         final double bm0 = bnm02 - bnm00;
  378.         final double ap1 = anm12 + anm10;
  379.         final double am1 = anm12 - anm10;
  380.         final double bp1 = bnm12 + bnm10;
  381.         final double bm1 = bnm12 - bnm10;

  383.         // ... and fill partials vector
  384.         final double partials0  = SP[0] * anm01;
  385.         final double partials1  = SP[0] * bnm01;
  386.         final double partials2  = SP[1] * anm01 - SP[2] * ap0;
  387.         final double partials3  = SP[1] * bnm01 - SP[2] * bp0;
  388.         final double partials4  = SP[3] * anm01 - SP[4] * ap0 + SP[5] * bm0;
  389.         final double partials5  = SP[3] * bnm01 - SP[4] * bp0 - SP[5] * am0;
  390.         final double partials6  = SP[6] * anm11;
  391.         final double partials7  = SP[6] * bnm11;
  392.         final double partials8  = SP[7] * anm11 - SP[8] * ap1;
  393.         final double partials9  = SP[7] * bnm11 - SP[8] * bp1;
  394.         final double partials10 = SP[9] * anm11 - SP[10] * ap1 + SP[11] * bm1;
  395.         final double partials11 = SP[9] * bnm11 - SP[10] * bp1 - SP[11] * am1;

  397.         // combine partials to set up corrections
  398.         final double dx =
  399.                     partials0 * ORTHOWX[0] + partials1  * ORTHOWX[1]  + partials2  * ORTHOWX[2] +
  400.                     partials3 * ORTHOWX[3] + partials4  * ORTHOWX[4]  + partials5  * ORTHOWX[5] +
  401.                     partials6 * ORTHOWX[6] + partials7  * ORTHOWX[7]  + partials8  * ORTHOWX[8] +
  402.                     partials9 * ORTHOWX[9] + partials10 * ORTHOWX[10] + partials11 * ORTHOWX[11];
  403.         final double dy =
  404.                     partials0 * ORTHOWY[0] + partials1  * ORTHOWY[1]  + partials2  * ORTHOWY[2] +
  405.                     partials3 * ORTHOWY[3] + partials4  * ORTHOWY[4]  + partials5  * ORTHOWY[5] +
  406.                     partials6 * ORTHOWY[6] + partials7  * ORTHOWY[7]  + partials8  * ORTHOWY[8] +
  407.                     partials9 * ORTHOWY[9] + partials10 * ORTHOWY[10] + partials11 * ORTHOWY[11];
  408.         final double dt =
  409.                     partials0 * ORTHOWT[0] + partials1  * ORTHOWT[1]  + partials2  * ORTHOWT[2] +
  410.                     partials3 * ORTHOWT[3] + partials4  * ORTHOWT[4]  + partials5  * ORTHOWT[5] +
  411.                     partials6 * ORTHOWT[6] + partials7  * ORTHOWT[7]  + partials8  * ORTHOWT[8] +
  412.                     partials9 * ORTHOWT[9] + partials10 * ORTHOWT[10] + partials11 * ORTHOWT[11];

  414.         return new CorrectionData(toDate(t), dx, dy, dt);

  416.     }

  418.     /** A data cache container for tidal correction data.
  419.      */
  420.     private static class CorrectionData implements TimeStamped {

  422.         /** date the correction is valid. */
  423.         private final AbsoluteDate date;

  425.         /** x component of the pole correction. */
  426.         private final double dx;

  428.         /** y component of the pole correction. */
  429.         private final double dy;

  431.         /** time component of the correction. */
  432.         private final double dt;

  434.         /** Create a new correction with the given data.
  435.          * @param date date the correction is valid
  436.          * @param dx x component of the pole correction
  437.          * @param dy y component of the pole correction
  438.          * @param dt time component of the correction
  439.          */
  440.         public CorrectionData(final AbsoluteDate date, final double dx, final double dy, final double dt) {
  441.             this.date = date;
  442.             this.dx   = dx;
  443.             this.dy   = dy;
  444.             this.dt   = dt;
  445.         }

  447.         /** {@inheritDoc} */
  448.         public AbsoluteDate getDate() {
  449.             return date;
  450.         }
  451.     }

  453.     /** Generates {@link CorrectionData} for a {@link GenericTimeStampedCache}.
  454.      */
  455.     private static class Generator implements TimeStampedGenerator<CorrectionData> {

  457.         /**
  458.          * {@inheritDoc}
  459.          * <p>
  460.          * <b>Note:</b> this {@link Generator} generates the minimum points necessary to
  461.          * cover the range (existing, date].
  462.          */
  463.         public List<CorrectionData> generate(final CorrectionData existing, final AbsoluteDate date)
  464.             throws TimeStampedCacheException {

  466.             // date in days
  467.             double tStart;
  468.             double tEnd;

  470.             if (existing == null) {
  471.                 // set tStart and tEnd so that n points are generated
  472.                 final int nM12 = (INTERPOLATION_POINTS - 1) / 2;
  473.                 // days to subtract from tStart
  474.                 final double extraBefore = STEP_SIZE * nM12;
  475.                 // days to add to tEnd
  476.                 final double extraAfter = STEP_SIZE * (INTERPOLATION_POINTS - nM12);
  477.                 tStart = toDayQuantum(toDay(date)) - extraBefore;
  478.                 tEnd   = toDayQuantum(toDay(date) + extraAfter);
  479.             } else if (existing.getDate().compareTo(date) > 0) {
  480.                 // existing is after date
  481.                 tStart = toDayQuantum(toDay(date));
  482.                 tEnd   = toDayQuantum(toDay(existing.getDate()));
  483.             } else {
  484.                 // existing is before or same as date
  485.                 tStart = toDayQuantum(toDay(existing.getDate())) + STEP_SIZE;
  486.                 tEnd   = toDayQuantum(toDay(date)) + STEP_SIZE;
  487.             }

  489.             // n is number of points to generate. (tEnd - tStart) / STEP_SIZE should
  490.             // already be *very* close to an integer
  491.             final int n = (int) FastMath.round((tEnd - tStart) / STEP_SIZE);

  493.             // list of generated points
  494.             final List<CorrectionData> generated = new ArrayList<CorrectionData>(n);

  496.             // compute new reference points in [tStart, tEnd)
  497.             for (int i = 0; i < n; ++i) {
  498.                 generated.add(computeCorrections(tStart + i * STEP_SIZE));
  499.             }

  501.             return generated;
  502.         }
  503.     }
  504. }
Created with JaCoCo 0.6.3.201306030806