pygnss 2.1.2__cp314-cp314t-macosx_11_0_arm64.whl

pygnss/nequick.py

@@ -0,0 +1,57 @@
+import datetime
+import math
+from typing import List
+
+import numpy as np
+
+import nequick
+
+from pygnss import ionex
+import pygnss.iono.gim
+
+
+class GimIonexHandler(nequick.GimHandler):
+    """
+    A handler that accumulates GIMs and then generates an IONEX file
+    """
+
+    def __init__(self, coeffs: nequick.Coefficients):
+        self._coeffs = coeffs
+        self._gims: List[nequick.gim.Gim] = []
+
+    def process(self, gim: nequick.Gim):
+        """
+        Store the incoming gim for later process
+        """
+
+        # Check that the latitude and longitude values are
+        # the same as the last appended gim
+        if len(self._gims) > 0:
+            last_gim = self._gims[-1]
+            if np.array_equal(last_gim.latitudes, gim.latitudes) == False:
+                raise ValueError("Latitude values do not match")
+            if np.array_equal(last_gim.longitudes, gim.longitudes) == False:
+                raise ValueError("Longitude values do not match")
+
+        self._gims.append(gim)
+
+    def to_ionex(self, filename: str, pgm: str = "pygnss", runby: str = "pygnss") -> None:
+
+        comment_lines = [
+            "Maps computed using the NeQuick model with the following",
+            "coefficients:",
+            f"a0={self._coeffs.a0:<17.6f}a1={self._coeffs.a1:<17.8f}a2={self._coeffs.a2:<17.11f}"
+        ]
+
+        ionex.write(filename, self._gims, pygnss.iono.gim.GimType.TEC, pgm, runby,
+                    comment_lines=comment_lines)
+
+
+def to_ionex(filename: str, coeffs: nequick.Coefficients, dates: List[datetime.datetime]):
+
+    gim_handler = GimIonexHandler(coeffs)
+
+    for date in dates:
+        nequick.to_gim(coeffs, date, gim_handler=gim_handler)
+
+    gim_handler.to_ionex(filename)

pygnss/orbit/kepler.py

@@ -0,0 +1,63 @@
+from dataclasses import dataclass
+import datetime
+import math
+
+from ..constants import EARTH_GRAVITATION_PARAM_MU
+
+
+@dataclass
+class Kepler(object):
+    """
+    Data class to represent a satellite orbit in an inertial reference frame
+    """
+
+    """ Time of Ephemeris """
+    toe: datetime.datetime
+
+    """ Semi-major axis [m] """
+    a_m: float
+
+    """ Eccentricity """
+    eccentricity: float
+
+    """ Inclination [rad] """
+    inclination_rad: float
+
+    """ Right ascension of the ascending node [rad] """
+    raan_rad: float
+
+    """ Argument of the perigee [rad] """
+    arg_perigee_rad: float
+
+    """ True anomaly at the time of ephemeris [rad] """
+    true_anomaly_rad: float
+
+    delta_n_dot_rad_per_s: float = 0.0
+
+    def __repr__(self) -> str:
+        out = f"""
+        toe: {self.toe}
+        semi-major axis[deg]: {math.degrees(self.a_m)}
+        eccentricity: {self.eccentricity}
+        inclination[deg]: {math.degrees(self.inclination_rad)}
+        RAAN[deg]: {math.degrees(self.raan_rad)}
+        arg_perigee[deg]: {math.degrees(self.arg_perigee_rad)}
+        mean anomaly[deg]: {math.degrees(self.true_anomaly_rad)}
+        Delta N [deg/s]: {math.degrees(self.delta_n_dot_rad_per_s)}
+        """
+        return out
+
+
+def compute_semi_major_axis(mean_motion_rad_per_s: float) -> float:
+    """
+    Compute the semi major axis (a) in meters from the mean motion
+
+    Using the equation $$n = sqrt(mu) / (sqrt(A))^3$$
+
+    >>> mean_motion_rev_per_day = 15.5918272
+    >>> mean_motion_rad_per_s = mean_motion_rev_per_day * math.tau / 86400.0
+    >>> compute_semi_major_axis(mean_motion_rad_per_s)
+    6768158.4970976645
+    """
+
+    return math.pow(EARTH_GRAVITATION_PARAM_MU/math.pow(mean_motion_rad_per_s, 2.0), 1.0 / 3.0)

pygnss/orbit/tle.py

@@ -0,0 +1,186 @@
+import datetime
+import math
+from typing import List, Union, IO
+
+from ..gnss.types import ConstellationId, Satellite
+
+from .kepler import Kepler, compute_semi_major_axis
+
+REV_PER_DAY_TO_RAD_PER_S = math.tau / 86400.0
+
+
+def parse_decimal_point(number: str) -> float:
+    """
+    Parse float numers with decimal point assumed and exponent
+
+    >>> parse_decimal_point("0006703")
+    0.0006703
+    >>> f'{parse_decimal_point("-11606-4"):.4e}'
+    '-1.1606e-05'
+    >>> f'{parse_decimal_point("-11606+4"):.4e}'
+    '-1.1606E+03'
+    >>> f'{parse_decimal_point(" 11606-4"):.4e}'
+    '1.1606e-05'
+    """
+
+    has_exponent = number[-2] == '-' or number[-2] == '+'
+
+    if has_exponent:
+        power = math.pow(10, int(number[-2:]))
+        n = len(number[1:-2])
+        return float(number[0:-2]) * math.pow(10, -n) * power
+    else:
+        power = math.pow(10, -len(number))
+        return float(number) * power
+
+
+def calculate_checksum(line: str) -> int:
+    checksum = 0
+
+    for character in line:
+        if character.isdigit():
+            checksum += int(character)
+        elif character == '-':
+            checksum += 1
+
+    return checksum % 10
+
+
+class TLE(object):
+
+    def __init__(self, line1: str, line2: str, label=None) -> 'TLE':
+
+        # Check integrity of TLE input
+        id_1 = line1[2:7]
+        id_2 = line2[2:7]
+        if id_1 != id_2:
+            raise RuntimeError(f'TLE lines correspond to different satellite catalog numbers {id_1} == {id_2}')
+
+        chk = calculate_checksum(line1[:-1])
+        chk_expected = int(line1[-1])
+        if chk != chk_expected:
+            raise RuntimeError(f'Invalid checksum for TLE line 1, got {chk}, expected {chk_expected}')
+        chk = calculate_checksum(line2[:-1])
+        chk_expected = int(line2[-1])
+        if chk != chk_expected:
+            raise RuntimeError(f'Invalid checksum for TLE line 2, got {chk}, expected {chk_expected}')
+
+        self.label = label
+        self.id = int(id_1)
+
+        line = line1
+
+        # Epoch
+        year = int(line[18:20]) + 2000
+        day_of_year = float(line[20:32])
+        doy = int(day_of_year)
+        fraction_of_day = day_of_year - doy
+        f_hour = 24 * fraction_of_day
+        hour = int(f_hour)
+        f_min = 60 * (f_hour - hour)
+        min = int(f_min)
+        f_sec = 60 * (f_min - min)
+        sec = int(f_sec)
+        fraction_of_second = f_sec - sec
+        datetime_str = f'{year} {doy} {hour} {min} {sec}'
+        epoch = datetime.datetime.strptime(datetime_str, '%Y %j %H %M %S')
+        offset = datetime.timedelta(seconds=fraction_of_second)
+        self.toe = epoch + offset
+
+        # Mean motion
+        self.n_dot_rad_per_s = float(line[33:43]) * REV_PER_DAY_TO_RAD_PER_S
+        self.n_dot_dot_rad_per_s2 = parse_decimal_point(line[44:52]) * REV_PER_DAY_TO_RAD_PER_S / 86400.0
+
+        # Atmospheric drag coefficient
+        self.bstar = parse_decimal_point(line[53:61])
+
+        line = line2
+
+        self.inclination_rad = math.radians(float(line[8:16]))
+        self.RAAN_rad = math.radians(float(line[17:25]))
+        self.eccentricity = parse_decimal_point(line[26:33])
+        self.arg_perigee_rad = math.radians(float(line[34:42]))
+        self.mean_anomaly_rad = math.radians(float(line[43:51]))
+        self.mean_motion_rad_per_s = float(line[52:63]) * REV_PER_DAY_TO_RAD_PER_S
+
+    def __repr__(self) -> str:
+        out = f"""
+        label: {self.label}
+        id: {self.id}
+        toe: {self.toe}
+        n_dot[rad/s]: {self.n_dot_rad_per_s}
+        n_dot_dot[rad/s^2]: {self.n_dot_dot_rad_per_s2}
+        b*: {self.bstar}
+        inclination[deg]: {math.degrees(self.inclination_rad)}
+        RAAN[deg]: {math.degrees(self.RAAN_rad)}
+        eccentricity: {self.eccentricity}
+        arg_perigee[deg]: {math.degrees(self.arg_perigee_rad)}
+        mean anomaly[deg]: {math.degrees(self.mean_anomaly_rad)}
+        mean motion[rad/s]: {self.mean_motion_rad_per_s}
+        """
+        return out
+
+    def get_satellite(self) -> Satellite:
+
+        constellation = get_constellation_from_label(self.label)
+        prn = self.id
+
+        return Satellite(constellation, prn)
+
+    def to_kepler(self) -> Kepler:
+        """
+        Rough mapping of the Two Line Element set into Keplerian parameters
+
+        Use this method at your own risk, TLE elements cannot be considered
+        classical orbital elements
+
+        Based on https://blog.hardinglabs.com/tle-to-kep.html
+        """
+
+        a_m = compute_semi_major_axis(self.mean_motion_rad_per_s)
+        return Kepler(self.toe,
+                      a_m,  self.eccentricity, self.inclination_rad, self.RAAN_rad,
+                      self.arg_perigee_rad, self.mean_anomaly_rad,
+                      delta_n_dot_rad_per_s=self.n_dot_rad_per_s)
+
+
+def read_celestrak(tle_source: Union[str, IO]) -> List[TLE]:
+    """
+    Read a NORAD General Perturbations (GP) file in TLE format, that can be found
+    at https://celestrak.org/NORAD/elements/
+    """
+    tles = []
+
+    # Check if tle_source is a string (filename) or a file handler
+    if isinstance(tle_source, str):
+        with open(tle_source, "r") as fh:
+            _read_celestrak_from_stream(fh, tles)
+    else:
+        _read_celestrak_from_stream(tle_source, tles)
+
+    return tles
+
+
+def _read_celestrak_from_stream(file_handle: IO[str], tles: List[TLE]) -> None:
+
+    while True:
+        lines = [next(file_handle, None) for _ in range(3)]
+        if any(line is None for line in lines):
+            break
+
+        lines = [line.strip() for line in lines]
+        tles.append(TLE(lines[1], lines[2], label=lines[0]))
+
+
+def get_constellation_from_label(label: str) -> ConstellationId:
+
+    out = ConstellationId.UNKNOWN
+
+    if 'ONEWEB' in label:
+        out = ConstellationId.ONEWEB
+    elif 'LEMUR' in label:
+        out = ConstellationId.SPIRE
+    elif 'STARLINK' in label:
+        out = ConstellationId.STARLINK
+
+    return out

pygnss/parsers/rtklib/stats.py

@@ -0,0 +1,166 @@
+import datetime
+import numpy as np
+import pandas as pd
+
+from pygnss import logger
+from pygnss.file import grep_lines
+from pygnss.time import from_week_tow
+from pygnss.gnss.residuals import Residuals
+from pygnss.gnss.types import TrackingChannel, INVALID_TRACKING_CHANNEL
+
+
+def parse(filename: str) -> Residuals:
+    """
+    Loads $SAT lines of a.stat file from a rtklib solution
+    The format of those files are the following:
+    Residuals of pseudorange and carrier-phase observables. The format
+    of a record is as follows.
+    $SAT,week,tow,sat,frq,az,el,resp,resc,vsat,snr,fix,slip,lock,outc,slipc,rejc,icbias,bias,bias_var,lambda
+       - week/tow : gps week no/time of week (s)
+       - sat/frq : satellite id/frequency (1:L1,2:L2,3:L5,...)
+       - az/el : azimuth/elevation angle (deg)
+       - resp : pseudorange residual (m)
+       - resc : carrier-phase residual (m)
+       - vsat : valid data flag (0:invalid,1:valid)
+       - snr : signal strength (dbHz)
+       - fix : ambiguity flag (0:no data,1:not part of AR set,2:part of AR set,3:part of hold set)
+       - slip : cycle-slip flag (bit1:slip,bit2:parity unknown)
+       - lock : carrier-lock count
+       - outc : data outage count
+       - slipc : cycle-slip count
+       - rejc : data reject (outlier) count
+       - icbias : interchannel bias (GLONASS)
+       - bias : phase bias
+       - bias_var : variance of phase bias
+       - lambda : wavelength
+
+
+    Example:
+    $SAT,2215,152783.000,G03,1,82.8,35.9,16.3975,0.0018,1,36,0,0,0,0,0,0,-117643836.98,182.318392,0.00000
+
+    Args:
+        stat_file (str): .stat file path
+
+    Returns:
+        np.array: A numpy array with the content of the file
+    """
+
+    DTYPE = [
+        ('week', 'i8'),
+        ('tow', 'f8'),
+        ('sat', 'S3'),
+        ('freq', 'i8'),
+        ('az', 'f8'),
+        ('el', 'f8'),
+        ('res_code_m', 'f8'),
+        ('res_phase_m', 'f8'),
+        ('vsat', 'i8'),
+        ('snr_dbHz', 'f8'),
+        ('fix', 'f8'),
+        ('slip', 'f8'),
+        ('lock', 'f8'),
+        ('outc', 'f8'),
+        ('slipc', 'f8'),
+        ('rejc', 'f8'),
+        # ('icbias', 'f8'),
+        # ('bias', 'f8'),
+        # ('bias_var', 'f8'),
+        # ('lambda', 'f8'),
+    ]
+
+    USECOLS = list(range(1, len(DTYPE) + 1))
+
+    generator = grep_lines(filename, "$SAT")
+
+    data = np.loadtxt(generator, delimiter=',', usecols=USECOLS, dtype=DTYPE)
+
+    data = __add_field_in_numpy_array(data, [('epoch', datetime.datetime)])
+    data['epoch'] = [from_week_tow(int(row['week']), float(row['tow'])) for row in data]
+
+    data = __add_field_in_numpy_array(data, [('processing_direction', 'S8')])
+    data_length = len(data)
+    data['processing_direction'] = ['forward'] * data_length
+    if (np.unique(data['epoch']).size > 1) and (data['epoch'][0] == data['epoch'][-1]):
+        data['processing_direction'][int(data_length / 2):] = 'backward'
+    df = pd.DataFrame(data)
+    df['sat'] = df['sat'].str.decode('utf-8')
+    df['processing_direction'] = df['processing_direction'].str.decode('utf-8')
+    df['constellation'] = df['sat'].str[0]
+    df['channel'] = [__compute_channel(constellation, frequency)
+                     for constellation, frequency in zip(df['constellation'], df['freq'])]
+    df['signal'] = [str(sat) + str(channel) for sat, channel in zip(df['sat'], df['channel'])]
+
+    return Residuals(df)
+
+
+def __compute_channel(constellation: str, frequency: int) -> TrackingChannel:
+
+    CHANNEL_1C = TrackingChannel(1, 'C')
+    CHANNEL_2C = TrackingChannel(2, 'C')
+    CHANNEL_5Q = TrackingChannel(5, 'Q')
+
+    conversion_rule = {
+        'G': {
+            1: CHANNEL_1C,
+            2: CHANNEL_2C,
+            3: CHANNEL_5Q,
+        },
+        'E': {
+            1: CHANNEL_1C,
+            2: TrackingChannel(7, 'Q'),
+            3: CHANNEL_5Q,
+        },
+        'C': {
+            1: TrackingChannel(2, 'I'),
+            2: TrackingChannel(6, 'I'),
+            3: TrackingChannel(7, 'I'),
+        },
+        'R': {
+            1: CHANNEL_1C,
+            2: CHANNEL_2C,
+            3: INVALID_TRACKING_CHANNEL,
+        },
+        'J': {
+            1: CHANNEL_1C,
+            2: CHANNEL_2C,
+            3: CHANNEL_5Q,
+        }
+    }
+
+    try:
+        return conversion_rule[constellation][frequency]
+    except Exception:
+        logger.debug(f"Unknown channel for {constellation} with frequency {frequency}")
+        return INVALID_TRACKING_CHANNEL
+
+
+def __add_field_in_numpy_array(a: np.array, descr) -> np.array:
+    """Return a new array that is like "a", but has additional fields.
+
+    Arguments:
+      a     -- a structured numpy array
+      descr -- a numpy type description of the new fields
+
+    The contents of "a" are copied over to the appropriate fields in
+    the new array, whereas the new fields are uninitialized.  The
+    arguments are not modified.
+
+    >>> sa = numpy.array([(1, 'Foo'), (2, 'Bar')], dtype=[('id', '<i8'), ('name', '|S3')])
+    >>> sa.dtype.descr
+    [('id', '<i8'), ('name', '|S3')]
+
+    >>> sb = __add_field_in_numpy_array(sa, [('score', '<f8')])
+    >>> sb.dtype.descr
+    [('id', '<i8'), ('name', '|S3'), ('score', '<f8')]
+
+    >>> numpy.all(sa['id'] == sb['id'])
+    True
+    >>> numpy.all(sa['name'] == sb['name'])
+    True
+    """
+    if a.dtype.fields is None:
+        raise ValueError("'A' must be a structured numpy array")
+    b = np.empty(a.shape, dtype=a.dtype.descr + descr)
+    for name in a.dtype.names:
+        b[name] = a[name]
+    return b