ODMParser.java
/* Copyright 2002-2016 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 org.orekit.files.ccsds;
import org.hipparchus.util.FastMath;
import org.orekit.errors.OrekitException;
import org.orekit.errors.OrekitInternalError;
import org.orekit.errors.OrekitMessages;
import org.orekit.files.general.OrbitFile;
import org.orekit.time.AbsoluteDate;
import org.orekit.time.DateTimeComponents;
import org.orekit.time.TimeScalesFactory;
import org.orekit.utils.Constants;
import org.orekit.utils.IERSConventions;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* Base class for all CCSDS Orbit Data Message parsers.
*
* <p> This base class is immutable, and hence thread safe. When parts must be
* changed, such as reference date for Mission Elapsed Time or Mission Relative
* Time time systems, or the gravitational coefficient or the IERS conventions,
* the various {@code withXxx} methods must be called, which create a new
* immutable instance with the new parameters. This is a combination of the <a
* href="https://en.wikipedia.org/wiki/Builder_pattern">builder design
* pattern</a> and a <a href="http://en.wikipedia.org/wiki/Fluent_interface">fluent
* interface</a>.
*
* @author Luc Maisonobe
* @since 6.1
*/
public abstract class ODMParser {
/** Pattern for international designator. */
private static final Pattern INTERNATIONAL_DESIGNATOR = Pattern.compile("(\\p{Digit}{4})-(\\p{Digit}{3})(\\p{Upper}{1,3})");
/** Reference date for Mission Elapsed Time or Mission Relative Time time systems. */
private final AbsoluteDate missionReferenceDate;
/** Gravitational coefficient. */
private final double mu;
/** IERS Conventions. */
private final IERSConventions conventions;
/** Indicator for simple or accurate EOP interpolation. */
private final boolean simpleEOP;
/** Launch Year. */
private int launchYear;
/** Launch number. */
private int launchNumber;
/** Piece of launch (from "A" to "ZZZ"). */
private String launchPiece;
/** Complete constructor.
* @param missionReferenceDate reference date for Mission Elapsed Time or Mission Relative Time time systems
* @param mu gravitational coefficient
* @param conventions IERS Conventions
* @param simpleEOP if true, tidal effects are ignored when interpolating EOP
* @param launchYear launch year for TLEs
* @param launchNumber launch number for TLEs
* @param launchPiece piece of launch (from "A" to "ZZZ") for TLEs
*/
protected ODMParser(final AbsoluteDate missionReferenceDate, final double mu,
final IERSConventions conventions, final boolean simpleEOP,
final int launchYear, final int launchNumber, final String launchPiece) {
this.missionReferenceDate = missionReferenceDate;
this.mu = mu;
this.conventions = conventions;
this.simpleEOP = simpleEOP;
this.launchYear = launchYear;
this.launchNumber = launchNumber;
this.launchPiece = launchPiece;
}
/** Set initial date.
* @param newMissionReferenceDate mission reference date to use while parsing
* @return a new instance, with mission reference date replaced
* @see #getMissionReferenceDate()
*/
public abstract ODMParser withMissionReferenceDate(final AbsoluteDate newMissionReferenceDate);
/** Get initial date.
* @return mission reference date to use while parsing
* @see #withMissionReferenceDate(AbsoluteDate)
*/
public AbsoluteDate getMissionReferenceDate() {
return missionReferenceDate;
}
/** Set gravitational coefficient.
* @param newMu gravitational coefficient to use while parsing
* @return a new instance, with gravitational coefficient date replaced
* @see #getMu()
*/
public abstract ODMParser withMu(final double newMu);
/** Get gravitational coefficient.
* @return gravitational coefficient to use while parsing
* @see #withMu(double)
*/
public double getMu() {
return mu;
}
/** Set IERS conventions.
* @param newConventions IERS conventions to use while parsing
* @return a new instance, with IERS conventions replaced
* @see #getConventions()
*/
public abstract ODMParser withConventions(final IERSConventions newConventions);
/** Get IERS conventions.
* @return IERS conventions to use while parsing
* @see #withConventions(IERSConventions)
*/
public IERSConventions getConventions() {
return conventions;
}
/** Set EOP interpolation method.
* @param newSimpleEOP if true, tidal effects are ignored when interpolating EOP
* @return a new instance, with EOP interpolation method replaced
* @see #isSimpleEOP()
*/
public abstract ODMParser withSimpleEOP(final boolean newSimpleEOP);
/** Get EOP interpolation method.
* @return true if tidal effects are ignored when interpolating EOP
* @see #withSimpleEOP(boolean)
*/
public boolean isSimpleEOP() {
return simpleEOP;
}
/** Set international designator.
* <p>
* This method may be used to ensure the launch year number and pieces are
* correctly set if they are not present in the CCSDS file header in the
* OBJECT_ID in the form YYYY-NNN-P{PP}. If they are already in the header,
* they will be parsed automatically regardless of this method being called
* or not (i.e. header information override information set here).
* </p>
* @param newLaunchYear launch year
* @param newLaunchNumber launch number
* @param newLaunchPiece piece of launch (from "A" to "ZZZ")
* @return a new instance, with TLE settings replaced
*/
public abstract ODMParser withInternationalDesignator(final int newLaunchYear,
final int newLaunchNumber,
final String newLaunchPiece);
/** Get the launch year.
* @return launch year
*/
public int getLaunchYear() {
return launchYear;
}
/** Get the launch number.
* @return launch number
*/
public int getLaunchNumber() {
return launchNumber;
}
/** Get the piece of launch.
* @return piece of launch
*/
public String getLaunchPiece() {
return launchPiece;
}
/** Parse a CCSDS Orbit Data Message.
* @param fileName name of the file containing the message
* @return parsed orbit
* @exception OrekitException if orbit message cannot be parsed
*/
public ODMFile parse(final String fileName)
throws OrekitException {
InputStream stream = null;
try {
stream = new FileInputStream(fileName);
return parse(stream, fileName);
} catch (FileNotFoundException e) {
throw new OrekitException(OrekitMessages.UNABLE_TO_FIND_FILE, fileName);
} finally {
try {
if (stream != null) {
stream.close();
}
} catch (IOException e) {
// ignore
}
}
}
/** Parse a CCSDS Orbit Data Message.
* @param stream stream containing message
* @return parsed orbit
* @exception OrekitException if orbit message cannot be parsed
*/
public ODMFile parse(final InputStream stream)
throws OrekitException {
return parse(stream, "<unknown>");
}
/** Parse a CCSDS Orbit Data Message.
* @param stream stream containing message
* @param fileName name of the file containing the message (for error messages)
* @return parsed orbit
* @exception OrekitException if orbit message cannot be parsed
*/
public abstract ODMFile parse(final InputStream stream, final String fileName)
throws OrekitException;
/** Parse a comment line.
* @param keyValue key=value pair containing the comment
* @param comment placeholder where the current comment line should be added
* @return true if the line was a comment line and was parsed
*/
protected boolean parseComment(final KeyValue keyValue, final List<String> comment) {
if (keyValue.getKeyword() == Keyword.COMMENT) {
comment.add(keyValue.getValue());
return true;
} else {
return false;
}
}
/** Parse an entry from the header.
* @param keyValue key = value pair
* @param odmFile instance to update with parsed entry
* @param comment previous comment lines, will be emptied if used by the keyword
* @return true if the keyword was a header keyword and has been parsed
* @exception OrekitException if UTC time scale cannot be retrieved to parse creation date
*/
protected boolean parseHeaderEntry(final KeyValue keyValue,
final ODMFile odmFile, final List<String> comment)
throws OrekitException {
switch (keyValue.getKeyword()) {
case CREATION_DATE:
if (!comment.isEmpty()) {
odmFile.setHeaderComment(comment);
comment.clear();
}
odmFile.setCreationDate(new AbsoluteDate(keyValue.getValue(), TimeScalesFactory.getUTC()));
return true;
case ORIGINATOR:
odmFile.setOriginator(keyValue.getValue());
return true;
default:
return false;
}
}
/** Parse a meta-data key = value entry.
* @param keyValue key = value pair
* @param metaData instance to update with parsed entry
* @param comment previous comment lines, will be emptied if used by the keyword
* @return true if the keyword was a meta-data keyword and has been parsed
* @exception OrekitException if center body or frame cannot be retrieved
*/
protected boolean parseMetaDataEntry(final KeyValue keyValue,
final ODMMetaData metaData, final List<String> comment)
throws OrekitException {
switch (keyValue.getKeyword()) {
case OBJECT_NAME:
if (!comment.isEmpty()) {
metaData.setComment(comment);
comment.clear();
}
metaData.setObjectName(keyValue.getValue());
return true;
case OBJECT_ID: {
metaData.setObjectID(keyValue.getValue());
final Matcher matcher = INTERNATIONAL_DESIGNATOR.matcher(keyValue.getValue());
if (matcher.matches()) {
metaData.setLaunchYear(Integer.parseInt(matcher.group(1)));
metaData.setLaunchNumber(Integer.parseInt(matcher.group(2)));
metaData.setLaunchPiece(matcher.group(3));
}
return true;
}
case CENTER_NAME:
metaData.setCenterName(keyValue.getValue());
final String canonicalValue;
if (keyValue.getValue().equals("SOLAR SYSTEM BARYCENTER") || keyValue.getValue().equals("SSB")) {
canonicalValue = "SOLAR_SYSTEM_BARYCENTER";
} else if (keyValue.getValue().equals("EARTH MOON BARYCENTER") || keyValue.getValue().equals("EARTH-MOON BARYCENTER") ||
keyValue.getValue().equals("EARTH BARYCENTER") || keyValue.getValue().equals("EMB")) {
canonicalValue = "EARTH_MOON";
} else {
canonicalValue = keyValue.getValue();
}
for (final CenterName c : CenterName.values()) {
if (c.name().equals(canonicalValue)) {
metaData.setHasCreatableBody(true);
metaData.setCenterBody(c.getCelestialBody());
metaData.getODMFile().setMuCreated(c.getCelestialBody().getGM());
}
}
return true;
case REF_FRAME:
metaData.setRefFrame(parseCCSDSFrame(keyValue.getValue()).getFrame(getConventions(), isSimpleEOP()));
return true;
case REF_FRAME_EPOCH:
metaData.setFrameEpochString(keyValue.getValue());
return true;
case TIME_SYSTEM:
final OrbitFile.TimeSystem timeSystem = OrbitFile.TimeSystem.valueOf(keyValue.getValue());
metaData.setTimeSystem(timeSystem);
if (metaData.getFrameEpochString() != null) {
metaData.setFrameEpoch(parseDate(metaData.getFrameEpochString(), timeSystem));
}
return true;
default:
return false;
}
}
/** Parse a general state data key = value entry.
* @param keyValue key = value pair
* @param general instance to update with parsed entry
* @param comment previous comment lines, will be emptied if used by the keyword
* @return true if the keyword was a meta-data keyword and has been parsed
* @exception OrekitException if center body or frame cannot be retrieved
*/
protected boolean parseGeneralStateDataEntry(final KeyValue keyValue,
final OGMFile general, final List<String> comment)
throws OrekitException {
switch (keyValue.getKeyword()) {
case EPOCH:
general.setEpochComment(comment);
comment.clear();
general.setEpoch(parseDate(keyValue.getValue(), general.getTimeSystem()));
return true;
case SEMI_MAJOR_AXIS:
general.setKeplerianElementsComment(comment);
comment.clear();
general.setA(keyValue.getDoubleValue() * 1000);
general.setHasKeplerianElements(true);
return true;
case ECCENTRICITY:
general.setE(keyValue.getDoubleValue());
return true;
case INCLINATION:
general.setI(FastMath.toRadians(keyValue.getDoubleValue()));
return true;
case RA_OF_ASC_NODE:
general.setRaan(FastMath.toRadians(keyValue.getDoubleValue()));
return true;
case ARG_OF_PERICENTER:
general.setPa(FastMath.toRadians(keyValue.getDoubleValue()));
return true;
case TRUE_ANOMALY:
general.setAnomalyType("TRUE");
general.setAnomaly(FastMath.toRadians(keyValue.getDoubleValue()));
return true;
case MEAN_ANOMALY:
general.setAnomalyType("MEAN");
general.setAnomaly(FastMath.toRadians(keyValue.getDoubleValue()));
return true;
case GM:
general.setMuParsed(keyValue.getDoubleValue() * 1e9);
return true;
case MASS:
comment.addAll(0, general.getSpacecraftComment());
general.setSpacecraftComment(comment);
comment.clear();
general.setMass(keyValue.getDoubleValue());
return true;
case SOLAR_RAD_AREA:
comment.addAll(0, general.getSpacecraftComment());
general.setSpacecraftComment(comment);
comment.clear();
general.setSolarRadArea(keyValue.getDoubleValue());
return true;
case SOLAR_RAD_COEFF:
comment.addAll(0, general.getSpacecraftComment());
general.setSpacecraftComment(comment);
comment.clear();
general.setSolarRadCoeff(keyValue.getDoubleValue());
return true;
case DRAG_AREA:
comment.addAll(0, general.getSpacecraftComment());
general.setSpacecraftComment(comment);
comment.clear();
general.setDragArea(keyValue.getDoubleValue());
return true;
case DRAG_COEFF:
comment.addAll(0, general.getSpacecraftComment());
general.setSpacecraftComment(comment);
comment.clear();
general.setDragCoeff(keyValue.getDoubleValue());
return true;
case COV_REF_FRAME:
general.setCovarianceComment(comment);
comment.clear();
final CCSDSFrame covFrame = parseCCSDSFrame(keyValue.getValue());
if (covFrame.isLof()) {
general.setCovRefLofType(covFrame.getLofType());
} else {
general.setCovRefFrame(covFrame.getFrame(getConventions(), isSimpleEOP()));
}
return true;
case CX_X:
general.createCovarianceMatrix();
general.setCovarianceMatrixEntry(0, 0, keyValue.getDoubleValue() * 1.0e6);
return true;
case CY_X:
general.setCovarianceMatrixEntry(0, 1, keyValue.getDoubleValue() * 1.0e6);
return true;
case CY_Y:
general.setCovarianceMatrixEntry(1, 1, keyValue.getDoubleValue() * 1.0e6);
return true;
case CZ_X:
general.setCovarianceMatrixEntry(0, 2, keyValue.getDoubleValue() * 1.0e6);
return true;
case CZ_Y:
general.setCovarianceMatrixEntry(1, 2, keyValue.getDoubleValue() * 1.0e6);
return true;
case CZ_Z:
general.setCovarianceMatrixEntry(2, 2, keyValue.getDoubleValue() * 1.0e6);
return true;
case CX_DOT_X:
general.setCovarianceMatrixEntry(0, 3, keyValue.getDoubleValue() * 1.0e6);
return true;
case CX_DOT_Y:
general.setCovarianceMatrixEntry(1, 3, keyValue.getDoubleValue() * 1.0e6);
return true;
case CX_DOT_Z:
general.setCovarianceMatrixEntry(2, 3, keyValue.getDoubleValue() * 1.0e6);
return true;
case CX_DOT_X_DOT:
general.setCovarianceMatrixEntry(3, 3, keyValue.getDoubleValue() * 1.0e6);
return true;
case CY_DOT_X:
general.setCovarianceMatrixEntry(0, 4, keyValue.getDoubleValue() * 1.0e6);
return true;
case CY_DOT_Y:
general.setCovarianceMatrixEntry(1, 4, keyValue.getDoubleValue() * 1.0e6);
return true;
case CY_DOT_Z:
general.setCovarianceMatrixEntry(2, 4, keyValue.getDoubleValue() * 1.0e6);
return true;
case CY_DOT_X_DOT:
general.setCovarianceMatrixEntry(3, 4, keyValue.getDoubleValue() * 1.0e6);
return true;
case CY_DOT_Y_DOT:
general.setCovarianceMatrixEntry(4, 4, keyValue.getDoubleValue() * 1.0e6);
return true;
case CZ_DOT_X:
general.setCovarianceMatrixEntry(0, 5, keyValue.getDoubleValue() * 1.0e6);
return true;
case CZ_DOT_Y:
general.setCovarianceMatrixEntry(1, 5, keyValue.getDoubleValue() * 1.0e6);
return true;
case CZ_DOT_Z:
general.setCovarianceMatrixEntry(2, 5, keyValue.getDoubleValue() * 1.0e6);
return true;
case CZ_DOT_X_DOT:
general.setCovarianceMatrixEntry(3, 5, keyValue.getDoubleValue() * 1.0e6);
return true;
case CZ_DOT_Y_DOT:
general.setCovarianceMatrixEntry(4, 5, keyValue.getDoubleValue() * 1.0e6);
return true;
case CZ_DOT_Z_DOT:
general.setCovarianceMatrixEntry(5, 5, keyValue.getDoubleValue() * 1.0e6);
return true;
case USER_DEFINED_X:
general.setUserDefinedParameters(keyValue.getKey(), keyValue.getValue());
return true;
default:
return false;
}
}
/** Parse a CCSDS frame.
* @param frameName name of the frame, as the value of a CCSDS key=value line
* @return CCSDS frame corresponding to the name
*/
protected CCSDSFrame parseCCSDSFrame(final String frameName) {
return CCSDSFrame.valueOf(frameName.replaceAll("-", ""));
}
/** Parse a date.
* @param date date to parse, as the value of a CCSDS key=value line
* @param timeSystem time system to use
* @return parsed date
* @exception OrekitException if some time scale cannot be retrieved
*/
protected AbsoluteDate parseDate(final String date, final OrbitFile.TimeSystem timeSystem)
throws OrekitException {
switch (timeSystem) {
case GMST:
return new AbsoluteDate(date, TimeScalesFactory.getGMST(conventions, false));
case GPS:
return new AbsoluteDate(date, TimeScalesFactory.getGPS());
case TAI:
return new AbsoluteDate(date, TimeScalesFactory.getTAI());
case TCB:
return new AbsoluteDate(date, TimeScalesFactory.getTCB());
case TDB:
return new AbsoluteDate(date, TimeScalesFactory.getTDB());
case TCG:
return new AbsoluteDate(date, TimeScalesFactory.getTCG());
case TT:
return new AbsoluteDate(date, TimeScalesFactory.getTT());
case UT1:
return new AbsoluteDate(date, TimeScalesFactory.getUT1(conventions, false));
case UTC:
return new AbsoluteDate(date, TimeScalesFactory.getUTC());
case MET: {
final DateTimeComponents clock = DateTimeComponents.parseDateTime(date);
final double offset = clock.getDate().getYear() * Constants.JULIAN_YEAR +
clock.getDate().getDayOfYear() * Constants.JULIAN_DAY +
clock.getTime().getSecondsInUTCDay();
return missionReferenceDate.shiftedBy(offset);
}
case MRT: {
final DateTimeComponents clock = DateTimeComponents.parseDateTime(date);
final double offset = clock.getDate().getYear() * Constants.JULIAN_YEAR +
clock.getDate().getDayOfYear() * Constants.JULIAN_DAY +
clock.getTime().getSecondsInUTCDay();
return missionReferenceDate.shiftedBy(offset);
}
default:
throw new OrekitInternalError(null);
}
}
}