AstronomicalAmplitudeReader.java

/* Copyright 2002-2018 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.forces.gravity.potential;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.hipparchus.util.FastMath;
import org.orekit.data.DataLoader;
import org.orekit.errors.OrekitException;
import org.orekit.errors.OrekitMessages;

/**
 * Parser for tides astronomical amplitude H<sub>f</sub>.
 * @author Luc Maisonobe
 * @since 6.1
 */
public class AstronomicalAmplitudeReader implements DataLoader {

    /** Pattern for optional fields (either nothing or non-space characters). */
    private static final String  OPTIONAL_FIELD_PATTERN = "\\S*";

    /** Pattern for fields with Doodson number. */
    private static final String  DOODSON_TYPE_PATTERN = "\\p{Digit}{2,3}[.,]\\p{Digit}{3}";

    /** Pattern for fields with real type. */
    private static final String  REAL_TYPE_PATTERN =
            "[-+]?(?:(?:\\p{Digit}+(?:\\.\\p{Digit}*)?)|(?:\\.\\p{Digit}+))(?:[eE][-+]?\\p{Digit}+)?";

    /** Regular expression for supported files names. */
    private final String supportedNames;

    /** Pattern for regular data lines. */
    private final Pattern regularLinePattern;

    /** Doodson number column. */
    private final int columnDoodson;

    /** H<sub>f</sub> column. */
    private final int columnHf;

    /** Scaling factor for astronomical amplitude. */
    private final double scale;

    /** Amplitudes map. */
    private final Map<Integer, Double> amplitudesMap;

    /** Simple constructor.
     * @param supportedNames regular expression for supported files names
     * @param columns number of columns
     * @param columnDoodson Doodson number column (counting from 1)
     * @param columnHf H<sub>f</sub> column (counting from 1)
     * @param scale scaling factor for astronomical amplitude
     */
    public AstronomicalAmplitudeReader(final String supportedNames, final int columns,
                                       final int columnDoodson, final int columnHf,
                                       final double scale) {

        // build the pattern for the regular data lines
        final StringBuilder builder = new StringBuilder("^\\p{Space}*");
        for (int i = 1; i <= columns; ++i) {
            builder.append("(");
            if (i == columnDoodson) {
                builder.append(DOODSON_TYPE_PATTERN);
            } else if (i == columnHf) {
                builder.append(REAL_TYPE_PATTERN);
            } else {
                builder.append(OPTIONAL_FIELD_PATTERN);
            }
            builder.append(")");
            builder.append(i < FastMath.max(columnDoodson, columnHf) ? "\\p{Space}+" : "\\p{Space}*");
        }
        builder.append('$');
        this.regularLinePattern = Pattern.compile(builder.toString());

        this.supportedNames = supportedNames;
        this.columnDoodson  = columnDoodson;
        this.columnHf       = columnHf;
        this.scale          = scale;

        this.amplitudesMap  = new HashMap<Integer, Double>();

    }

    /** Get the regular expression for supported files names.
     * @return regular expression for supported files names
     */
    public String getSupportedNames() {
        return supportedNames;
    }

    /** {@inheritDoc} */
    @Override
    public boolean stillAcceptsData() {
        return amplitudesMap.isEmpty();
    }

    /** {@inheritDoc} */
    @Override
    public void loadData(final InputStream input, final String name)
        throws OrekitException, IOException {

        // parse the file
        final BufferedReader r = new BufferedReader(new InputStreamReader(input, "UTF-8"));
        int lineNumber      = 0;
        for (String line = r.readLine(); line != null; line = r.readLine()) {
            ++lineNumber;

            try {

                // replace unicode minus sign ('−') by regular hyphen ('-') for parsing
                // such unicode characters occur in tables that are copy-pasted from PDF files
                line = line.replace('\u2212', '-');

                final Matcher regularMatcher = regularLinePattern.matcher(line);
                if (regularMatcher.matches()) {
                    // we have found a regular data line
                    final int    doodson = Integer.parseInt(regularMatcher.group(columnDoodson).replaceAll("[.,]", ""));
                    final double hf      = scale * Double.parseDouble(regularMatcher.group(columnHf));
                    amplitudesMap.put(doodson, hf);
                }

            } catch (NumberFormatException nfe) {
                throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
                                          lineNumber, name, line);
            }

        }

        if (amplitudesMap.isEmpty()) {
            throw new OrekitException(OrekitMessages.NOT_A_SUPPORTED_IERS_DATA_FILE, name);
        }

    }

    /** Get astronomical amplitudes map.
     * @return an unmodifiable map containing astronomical amplitudes H<sub>f</sub>
     * from a Doodson number key
     */
    public Map<Integer, Double> getAstronomicalAmplitudesMap() {
        return Collections.unmodifiableMap(amplitudesMap);
    }

}