TLE.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.propagation.analytical.tle;

  19. import java.io.Serializable;
  20. import java.text.DecimalFormat;
  21. import java.text.DecimalFormatSymbols;
  22. import java.util.Locale;
  23. import java.util.regex.Pattern;

  25. import org.apache.commons.math3.util.FastMath;
  26. import org.orekit.errors.OrekitException;
  27. import org.orekit.errors.OrekitMessages;
  28. import org.orekit.time.AbsoluteDate;
  29. import org.orekit.time.DateComponents;
  30. import org.orekit.time.TimeComponents;
  31. import org.orekit.time.TimeScale;
  32. import org.orekit.time.TimeScalesFactory;
  33. import org.orekit.time.TimeStamped;
  34. import org.orekit.utils.Constants;

  36. /** This class is a container for a single set of TLE data.
  37.  *
  38.  * <p>TLE sets can be built either by providing directly the two lines, in
  39.  * which case parsing is performed internally or by providing the already
  40.  * parsed elements.</p>
  41.  * <p>TLE are not transparently convertible to {@link org.orekit.orbits.Orbit Orbit}
  42.  * instances. They are significant only with respect to their dedicated {@link
  43.  * TLEPropagator propagator}, which also computes position and velocity coordinates.
  44.  * Any attempt to directly use orbital parameters like {@link #getE() eccentricity},
  45.  * {@link #getI() inclination}, etc. without any reference to the {@link TLEPropagator
  46.  * TLE propagator} is prone to errors.</p>
  47.  * <p>More information on the TLE format can be found on the
  48.  * <a href="http://www.celestrak.com/">CelesTrak website.</a></p>
  49.  * @author Fabien Maussion
  50.  * @author Luc Maisonobe
  51.  */
  52. public class TLE implements TimeStamped, Serializable {

  54.     /** Identifier for default type of ephemeris (SGP4/SDP4). */
  55.     public static final int DEFAULT = 0;

  57.     /** Identifier for SGP type of ephemeris. */
  58.     public static final int SGP = 1;

  60.     /** Identifier for SGP4 type of ephemeris. */
  61.     public static final int SGP4 = 2;

  63.     /** Identifier for SDP4 type of ephemeris. */
  64.     public static final int SDP4 = 3;

  66.     /** Identifier for SGP8 type of ephemeris. */
  67.     public static final int SGP8 = 4;

  69.     /** Identifier for SDP8 type of ephemeris. */
  70.     public static final int SDP8 = 5;

  72.     /** Pattern for line 1. */
  73.     private static final Pattern LINE_1_PATTERN =
  74.         Pattern.compile("1 [ 0-9]{5}U [ 0-9]{5}[ A-Z]{3} [ 0-9]{5}[.][ 0-9]{8} [ +-][.][ 0-9]{8} " +
  75.                         "[ +-][ 0-9]{5}[+-][ 0-9] [ +-][ 0-9]{5}[+-][ 0-9] [ 0-9] [ 0-9]{4}[ 0-9]");

  77.     /** Pattern for line 2. */
  78.     private static final Pattern LINE_2_PATTERN =
  79.         Pattern.compile("2 [ 0-9]{5} [ 0-9]{3}[.][ 0-9]{4} [ 0-9]{3}[.][ 0-9]{4} [ 0-9]{7} " +
  80.                         "[ 0-9]{3}[.][ 0-9]{4} [ 0-9]{3}[.][ 0-9]{4} [ 0-9]{2}[.][ 0-9]{13}[ 0-9]");

  82.     /** International symbols for parsing. */
  83.     private static final DecimalFormatSymbols SYMBOLS =
  84.         new DecimalFormatSymbols(Locale.US);

  86.     /** Serializable UID. */
  87.     private static final long serialVersionUID = -1596648022319057689L;

  89.     /** The satellite number. */
  90.     private final int satelliteNumber;

  92.     /** Classification (U for unclassified). */
  93.     private final char classification;

  95.     /** Launch year. */
  96.     private final int launchYear;

  98.     /** Launch number. */
  99.     private final int launchNumber;

  101.     /** Piece of launch (from "A" to "ZZZ"). */
  102.     private final String launchPiece;

  104.     /** Type of ephemeris. */
  105.     private final int ephemerisType;

  107.     /** Element number. */
  108.     private final int elementNumber;

  110.     /** the TLE current date. */
  111.     private final AbsoluteDate epoch;

  113.     /** Mean motion (rad/s). */
  114.     private final double meanMotion;

  116.     /** Mean motion first derivative (rad/s<sup>2</sup>). */
  117.     private final double meanMotionFirstDerivative;

  119.     /** Mean motion second derivative (rad/s<sup>3</sup>). */
  120.     private final double meanMotionSecondDerivative;

  122.     /** Eccentricity. */
  123.     private final double eccentricity;

  125.     /** Inclination (rad). */
  126.     private final double inclination;

  128.     /** Argument of perigee (rad). */
  129.     private final double pa;

  131.     /** Right Ascension of the Ascending node (rad). */
  132.     private final double raan;

  134.     /** Mean anomaly (rad). */
  135.     private final double meanAnomaly;

  137.     /** Revolution number at epoch. */
  138.     private final int revolutionNumberAtEpoch;

  140.     /** Ballistic coefficient. */
  141.     private final double bStar;

  143.     /** First line. */
  144.     private String line1;

  146.     /** Second line. */
  147.     private String line2;

  149.     /** Simple constructor from unparsed two lines.
  150.      * <p>The static method {@link #isFormatOK(String, String)} should be called
  151.      * before trying to build this object.<p>
  152.      * @param line1 the first element (69 char String)
  153.      * @param line2 the second element (69 char String)
  154.      * @exception OrekitException if some format error occurs or lines are inconsistent
  155.      */
  156.     public TLE(final String line1, final String line2) throws OrekitException {

  158.         // identification
  159.         satelliteNumber = parseInteger(line1, 2, 5);
  160.         final int satNum2 = parseInteger(line2, 2, 5);
  161.         if (satelliteNumber != satNum2) {
  162.             throw new OrekitException(OrekitMessages.TLE_LINES_DO_NOT_REFER_TO_SAME_OBJECT,
  163.                                       line1, line2);
  164.         }
  165.         classification  = line1.charAt(7);
  166.         launchYear      = parseYear(line1, 9);
  167.         launchNumber    = parseInteger(line1, 11, 3);
  168.         launchPiece     = line1.substring(14, 17).trim();
  169.         ephemerisType   = parseInteger(line1, 62, 1);
  170.         elementNumber   = parseInteger(line1, 64, 4);

  172.         // Date format transform (nota: 27/31250 == 86400/100000000)
  173.         final int    year      = parseYear(line1, 18);
  174.         final int    dayInYear = parseInteger(line1, 20, 3);
  175.         final long   df        = 27l * parseInteger(line1, 24, 8);
  176.         final int    secondsA  = (int) (df / 31250l);
  177.         final double secondsB  = (df % 31250l) / 31250.0;
  178.         epoch = new AbsoluteDate(new DateComponents(year, dayInYear),
  179.                                  new TimeComponents(secondsA, secondsB),
  180.                                  TimeScalesFactory.getUTC());

  182.         // mean motion development
  183.         // converted from rev/day, 2 * rev/day^2 and 6 * rev/day^3 to rad/s, rad/s^2 and rad/s^3
  184.         meanMotion                 = parseDouble(line2, 52, 11) * FastMath.PI / 43200.0;
  185.         meanMotionFirstDerivative  = parseDouble(line1, 33, 10) * FastMath.PI / 1.86624e9;
  186.         meanMotionSecondDerivative = Double.parseDouble((line1.substring(44, 45) + '.' +
  187.                                                          line1.substring(45, 50) + 'e' +
  188.                                                          line1.substring(50, 52)).replace(' ', '0')) *
  189.                                      FastMath.PI / 5.3747712e13;

  191.         eccentricity = Double.parseDouble("." + line2.substring(26, 33).replace(' ', '0'));
  192.         inclination  = FastMath.toRadians(parseDouble(line2, 8, 8));
  193.         pa           = FastMath.toRadians(parseDouble(line2, 34, 8));
  194.         raan         = FastMath.toRadians(Double.parseDouble(line2.substring(17, 25).replace(' ', '0')));
  195.         meanAnomaly  = FastMath.toRadians(parseDouble(line2, 43, 8));

  197.         revolutionNumberAtEpoch = parseInteger(line2, 63, 5);
  198.         bStar = Double.parseDouble((line1.substring(53, 54) + '.' +
  199.                                     line1.substring(54, 59) + 'e' +
  200.                                     line1.substring(59, 61)).replace(' ', '0'));

  202.         // save the lines
  203.         this.line1 = line1;
  204.         this.line2 = line2;

  206.     }

  208.     /** Simple constructor from already parsed elements.
  209.      * @param satelliteNumber satellite number
  210.      * @param classification classification (U for unclassified)
  211.      * @param launchYear launch year (all digits)
  212.      * @param launchNumber launch number
  213.      * @param launchPiece launch piece
  214.      * @param ephemerisType type of ephemeris
  215.      * @param elementNumber element number
  216.      * @param epoch elements epoch
  217.      * @param meanMotion mean motion (rad/s)
  218.      * @param meanMotionFirstDerivative mean motion first derivative (rad/s<sup>2</sup>)
  219.      * @param meanMotionSecondDerivative mean motion second derivative (rad/s<sup>3</sup>)
  220.      * @param e eccentricity
  221.      * @param i inclination (rad)
  222.      * @param pa argument of perigee (rad)
  223.      * @param raan right ascension of ascending node (rad)
  224.      * @param meanAnomaly mean anomaly (rad)
  225.      * @param revolutionNumberAtEpoch revolution number at epoch
  226.      * @param bStar ballistic coefficient
  227.      */
  228.     public TLE(final int satelliteNumber, final char classification,
  229.                final int launchYear, final int launchNumber, final String launchPiece,
  230.                final int ephemerisType, final int elementNumber, final AbsoluteDate epoch,
  231.                final double meanMotion, final double meanMotionFirstDerivative,
  232.                final double meanMotionSecondDerivative, final double e, final double i,
  233.                final double pa, final double raan, final double meanAnomaly,
  234.                final int revolutionNumberAtEpoch, final double bStar) {

  236.         // identification
  237.         this.satelliteNumber = satelliteNumber;
  238.         this.classification  = classification;
  239.         this.launchYear      = launchYear;
  240.         this.launchNumber    = launchNumber;
  241.         this.launchPiece     = launchPiece;
  242.         this.ephemerisType   = ephemerisType;
  243.         this.elementNumber   = elementNumber;

  245.         // orbital parameters
  246.         this.epoch                      = epoch;
  247.         this.meanMotion                 = meanMotion;
  248.         this.meanMotionFirstDerivative  = meanMotionFirstDerivative;
  249.         this.meanMotionSecondDerivative = meanMotionSecondDerivative;
  250.         this.inclination                = i;
  251.         this.raan                       = raan;
  252.         this.eccentricity               = e;
  253.         this.pa                         = pa;
  254.         this.meanAnomaly                = meanAnomaly;

  256.         this.revolutionNumberAtEpoch = revolutionNumberAtEpoch;
  257.         this.bStar                   = bStar;

  259.         // don't build the line until really needed
  260.         this.line1 = null;
  261.         this.line2 = null;

  263.     }

  265.     /** Get the first line.
  266.      * @return first line
  267.      * @exception OrekitException if UTC conversion cannot be done
  268.      */
  269.     public String getLine1()
  270.         throws OrekitException {
  271.         if (line1 == null) {
  272.             buildLine1();
  273.         }
  274.         return line1;
  275.     }

  277.     /** Get the second line.
  278.      * @return second line
  279.      */
  280.     public String getLine2() {
  281.         if (line2 == null) {
  282.             buildLine2();
  283.         }
  284.         return line2;
  285.     }

  287.     /** Build the line 1 from the parsed elements.
  288.      * @exception OrekitException if UTC conversion cannot be done
  289.      */
  290.     private void buildLine1()
  291.         throws OrekitException {

  293.         final StringBuffer buffer = new StringBuffer();
  294.         final DecimalFormat f38  = new DecimalFormat("000.00000000", SYMBOLS);

  296.         buffer.append('1');

  298.         buffer.append(' ');
  299.         buffer.append(addPadding(satelliteNumber, '0', 5, true));
  300.         buffer.append(classification);

  302.         buffer.append(' ');
  303.         buffer.append(addPadding(launchYear % 100, '0', 2, true));
  304.         buffer.append(addPadding(launchNumber, '0', 3, true));
  305.         buffer.append(addPadding(launchPiece, ' ', 3, false));

  307.         buffer.append(' ');
  308.         final TimeScale utc = TimeScalesFactory.getUTC();
  309.         final int year = epoch.getComponents(utc).getDate().getYear();
  310.         buffer.append(addPadding(year % 100, '0', 2, true));
  311.         final double day = 1.0 + epoch.durationFrom(new AbsoluteDate(year, 1, 1, utc)) / Constants.JULIAN_DAY;
  312.         buffer.append(f38.format(day));

  314.         buffer.append(' ');
  315.         final double n1 = meanMotionFirstDerivative * 1.86624e9 / FastMath.PI;
  316.         final String sn1 = addPadding(new DecimalFormat(".00000000", SYMBOLS).format(n1), ' ', 10, true);
  317.         buffer.append(sn1);

  319.         buffer.append(' ');
  320.         final double n2 = meanMotionSecondDerivative * 5.3747712e13 / FastMath.PI;
  321.         buffer.append(addPadding(formatExponentMarkerFree(n2, 5), ' ', 8, true));

  323.         buffer.append(' ');
  324.         buffer.append(addPadding(formatExponentMarkerFree(bStar, 5), ' ', 8, true));

  326.         buffer.append(' ');
  327.         buffer.append(ephemerisType);

  329.         buffer.append(' ');
  330.         buffer.append(addPadding(elementNumber, ' ', 4, true));

  332.         buffer.append(Integer.toString(checksum(buffer)));

  334.         line1 = buffer.toString();

  336.     }

  338.     /** Format a real number without 'e' exponent marker.
  339.      * @param d number to format
  340.      * @param mantissaSize size of the mantissa (not counting initial '-' or ' ' for sign)
  341.      * @return formatted number
  342.      */
  343.     private String formatExponentMarkerFree(final double d, final int mantissaSize) {
  344.         final double dAbs = FastMath.abs(d);
  345.         int exponent = (dAbs < 1.0e-9) ? -9 : (int) FastMath.ceil(FastMath.log10(dAbs));
  346.         final long mantissa = FastMath.round(dAbs * FastMath.pow(10.0, mantissaSize - exponent));
  347.         if (mantissa == 0) {
  348.             exponent = 0;
  349.         }
  350.         final String sMantissa = addPadding((int) mantissa, '0', mantissaSize, true);
  351.         final String sExponent = Integer.toString(FastMath.abs(exponent));
  352.         return (d <  0 ? '-' : ' ') + sMantissa + (exponent <= 0 ? '-' : '+') + sExponent;
  353.     }

  355.     /** Build the line 2 from the parsed elements.
  356.      */
  357.     private void buildLine2() {

  359.         final StringBuffer buffer = new StringBuffer();
  360.         final DecimalFormat f34   = new DecimalFormat("##0.0000", SYMBOLS);
  361.         final DecimalFormat f211  = new DecimalFormat("#0.00000000", SYMBOLS);

  363.         buffer.append('2');

  365.         buffer.append(' ');
  366.         buffer.append(addPadding(satelliteNumber, '0', 5, true));

  368.         buffer.append(' ');
  369.         buffer.append(addPadding(f34.format(FastMath.toDegrees(inclination)), ' ', 8, true));
  370.         buffer.append(' ');
  371.         buffer.append(addPadding(f34.format(FastMath.toDegrees(raan)), ' ', 8, true));
  372.         buffer.append(' ');
  373.         buffer.append(addPadding((int) FastMath.rint(eccentricity * 1.0e7), '0', 7, true));
  374.         buffer.append(' ');
  375.         buffer.append(addPadding(f34.format(FastMath.toDegrees(pa)), ' ', 8, true));
  376.         buffer.append(' ');
  377.         buffer.append(addPadding(f34.format(FastMath.toDegrees(meanAnomaly)), ' ', 8, true));

  379.         buffer.append(' ');
  380.         buffer.append(addPadding(f211.format(meanMotion * 43200.0 / FastMath.PI), ' ', 11, true));
  381.         buffer.append(addPadding(revolutionNumberAtEpoch, ' ', 5, true));

  383.         buffer.append(Integer.toString(checksum(buffer)));

  385.         line2 = buffer.toString();

  387.     }

  389.     /** Add padding characters before an integer.
  390.      * @param k integer to pad
  391.      * @param c padding character
  392.      * @param size desired size
  393.      * @param rightJustified if true, the resulting string is
  394.      * right justified (i.e. space are added to the left)
  395.      * @return padded string
  396.      */
  397.     private String addPadding(final int k, final char c,
  398.                               final int size, final boolean rightJustified) {
  399.         return addPadding(Integer.toString(k), c, size, rightJustified);
  400.     }

  402.     /** Add padding characters to a string.
  403.      * @param string string to pad
  404.      * @param c padding character
  405.      * @param size desired size
  406.      * @param rightJustified if true, the resulting string is
  407.      * right justified (i.e. space are added to the left)
  408.      * @return padded string
  409.      */
  410.     private String addPadding(final String string, final char c,
  411.                               final int size, final boolean rightJustified) {

  413.         final StringBuffer padding = new StringBuffer();
  414.         for (int i = 0; i < size; ++i) {
  415.             padding.append(c);
  416.         }

  418.         if (rightJustified) {
  419.             final String concatenated = padding + string;
  420.             final int l = concatenated.length();
  421.             return concatenated.substring(l - size, l);
  422.         }

  424.         return (string + padding).substring(0, size);

  426.     }

  428.     /** Parse a double.
  429.      * @param line line to parse
  430.      * @param start start index of the first character
  431.      * @param length length of the string
  432.      * @return value of the double
  433.      */
  434.     private double parseDouble(final String line, final int start, final int length) {
  435.         return Double.parseDouble(line.substring(start, start + length).replace(' ', '0'));
  436.     }

  438.     /** Parse an integer.
  439.      * @param line line to parse
  440.      * @param start start index of the first character
  441.      * @param length length of the string
  442.      * @return value of the integer
  443.      */
  444.     private int parseInteger(final String line, final int start, final int length) {
  445.         return Integer.parseInt(line.substring(start, start + length).replace(' ', '0'));
  446.     }

  448.     /** Parse a year written on 2 digits.
  449.      * @param line line to parse
  450.      * @param start start index of the first character
  451.      * @return value of the year
  452.      */
  453.     private int parseYear(final String line, final int start) {
  454.         final int year = 2000 + parseInteger(line, start, 2);
  455.         return (year > 2056) ? (year - 100) : year;
  456.     }

  458.     /** Get the satellite id.
  459.      * @return the satellite number
  460.      */
  461.     public int getSatelliteNumber() {
  462.         return satelliteNumber;
  463.     }

  465.     /** Get the classification.
  466.      * @return classification
  467.      */
  468.     public char getClassification() {
  469.         return classification;
  470.     }

  472.     /** Get the launch year.
  473.      * @return the launch year
  474.      */
  475.     public int getLaunchYear() {
  476.         return launchYear;
  477.     }

  479.     /** Get the launch number.
  480.      * @return the launch number
  481.      */
  482.     public int getLaunchNumber() {
  483.         return launchNumber;
  484.     }

  486.     /** Get the launch piece.
  487.      * @return the launch piece
  488.      */
  489.     public String getLaunchPiece() {
  490.         return launchPiece;
  491.     }

  493.     /** Get the type of ephemeris.
  494.      * @return the ephemeris type (one of {@link #DEFAULT}, {@link #SGP},
  495.      * {@link #SGP4}, {@link #SGP8}, {@link #SDP4}, {@link #SDP8})
  496.      */
  497.     public int getEphemerisType() {
  498.         return ephemerisType;
  499.     }

  501.     /** Get the element number.
  502.      * @return the element number
  503.      */
  504.     public int getElementNumber() {
  505.         return elementNumber;
  506.     }

  508.     /** Get the TLE current date.
  509.      * @return the epoch
  510.      */
  511.     public AbsoluteDate getDate() {
  512.         return epoch;
  513.     }

  515.     /** Get the mean motion.
  516.      * @return the mean motion (rad/s)
  517.      */
  518.     public double getMeanMotion() {
  519.         return meanMotion;
  520.     }

  522.     /** Get the mean motion first derivative.
  523.      * @return the mean motion first derivative (rad/s<sup>2</sup>)
  524.      */
  525.     public double getMeanMotionFirstDerivative() {
  526.         return meanMotionFirstDerivative;
  527.     }

  529.     /** Get the mean motion second derivative.
  530.      * @return the mean motion second derivative (rad/s<sup>3</sup>)
  531.      */
  532.     public double getMeanMotionSecondDerivative() {
  533.         return meanMotionSecondDerivative;
  534.     }

  536.     /** Get the eccentricity.
  537.      * @return the eccentricity
  538.      */
  539.     public double getE() {
  540.         return eccentricity;
  541.     }

  543.     /** Get the inclination.
  544.      * @return the inclination (rad)
  545.      */
  546.     public double getI() {
  547.         return inclination;
  548.     }

  550.     /** Get the argument of perigee.
  551.      * @return omega (rad)
  552.      */
  553.     public double getPerigeeArgument() {
  554.         return pa;
  555.     }

  557.     /** Get Right Ascension of the Ascending node.
  558.      * @return the raan (rad)
  559.      */
  560.     public double getRaan() {
  561.         return raan;
  562.     }

  564.     /** Get the mean anomaly.
  565.      * @return the mean anomaly (rad)
  566.      */
  567.     public double getMeanAnomaly() {
  568.         return meanAnomaly;
  569.     }

  571.     /** Get the revolution number.
  572.      * @return the revolutionNumberAtEpoch
  573.      */
  574.     public int getRevolutionNumberAtEpoch() {
  575.         return revolutionNumberAtEpoch;
  576.     }

  578.     /** Get the ballistic coefficient.
  579.      * @return bStar
  580.      */
  581.     public double getBStar() {
  582.         return bStar;
  583.     }

  585.     /** Get a string representation of this TLE set.
  586.      * <p>The representation is simply the two lines separated by the
  587.      * platform line separator.</p>
  588.      * @return string representation of this TLE set
  589.      */
  590.     public String toString() {
  591.         try {
  592.             return getLine1() + System.getProperty("line.separator") + getLine2();
  593.         } catch (OrekitException oe) {
  594.             throw OrekitException.createInternalError(oe);
  595.         }
  596.     }

  598.     /** Check the lines format validity.
  599.      * @param line1 the first element
  600.      * @param line2 the second element
  601.      * @return true if format is recognized (non null lines, 69 characters length,
  602.      * line content), false if not
  603.      * @exception OrekitException if checksum is not valid
  604.      */
  605.     public static boolean isFormatOK(final String line1, final String line2)
  606.         throws OrekitException {

  608.         if (line1 == null || line1.length() != 69 ||
  609.             line2 == null || line2.length() != 69) {
  610.             return false;
  611.         }

  613.         if (!(LINE_1_PATTERN.matcher(line1).matches() &&
  614.               LINE_2_PATTERN.matcher(line2).matches())) {
  615.             return false;
  616.         }

  618.         // check sums
  619.         final int checksum1 = checksum(line1);
  620.         if (Integer.parseInt(line1.substring(68)) != (checksum1 % 10)) {
  621.             throw new OrekitException(OrekitMessages.TLE_CHECKSUM_ERROR,
  622.                                       1, line1.substring(68) ,
  623.                                       checksum1 % 10, line1);
  624.         }

  626.         final int checksum2 = checksum(line2);
  627.         if (Integer.parseInt(line2.substring(68)) != (checksum2 % 10)) {
  628.             throw new OrekitException(OrekitMessages.TLE_CHECKSUM_ERROR,
  629.                                       2, line2.substring(68) ,
  630.                                           checksum2 % 10, line2);
  631.         }

  633.         return true;

  635.     }

  637.     /** Compute the checksum of the first 68 characters of a line.
  638.      * @param line line to check
  639.      * @return checksum
  640.      */
  641.     private static int checksum(final CharSequence line) {
  642.         int sum = 0;
  643.         for (int j = 0; j < 68; j++) {
  644.             final char c = line.charAt(j);
  645.             if (Character.isDigit(c)) {
  646.                 sum += Character.digit(c, 10);
  647.             } else if (c == '-') {
  648.                 ++sum;
  649.             }
  650.         }
  651.         return sum % 10;
  652.     }

  654. }
Created with JaCoCo 0.6.3.201306030806