pygnss 2.1.2__cp314-cp314t-macosx_11_0_arm64.whl

pygnss/sinex.py

@@ -0,0 +1,121 @@
+from dataclasses import dataclass
+import datetime
+import typing
+
+TAG_SAT_PRN = "SATELLITE/PRN"
+
+
+@dataclass
+class _SatPrnItem():
+    svid: str
+    valid_from: datetime.datetime
+    valid_to: datetime.datetime
+    prn: str
+
+    def in_period(self, epoch: datetime):
+        return epoch >= self.valid_from and (self.valid_to is None or epoch <= self.valid_to)
+
+
+class _SatPrn():
+
+    def __init__(self, sat_prns: typing.List[_SatPrnItem]):
+        self.items = {}
+
+        for sat_prn in sat_prns:
+            key = sat_prn.prn
+            if key not in self.items:
+                self.items[key] = []
+
+            self.items[key].append(sat_prn)
+
+    def to_svid(self, prn: str, epoch: datetime) -> str:
+        """
+        Get the Space Vehicle ID for a given Satellite PRN assignement at a
+        specific epoch
+        """
+
+        items = self.items[prn]
+
+        for item in items:
+            if item.in_period(epoch):
+                return item.svid
+
+        raise ValueError(f'Could not find SVID for [ {prn} ] at [ {epoch} ]')
+
+
+def to_sat_prn(sinex_filename: str) -> _SatPrn:
+
+    with open(sinex_filename, 'r') as fh:
+        lines = _extract_section(fh, TAG_SAT_PRN)
+        sat_prns = []
+
+        for line in lines:
+            if line.startswith(('*', '+')):
+                continue
+            sat_prns.append(_parse_sat_prn_line(line))
+
+    return _SatPrn(sat_prns)
+
+
+def _parse_epoch(epoch_str: str) -> datetime.datetime:
+    """
+    Parse an epoch expressed in SINEX format %Y:%j:<seconds_of_day>
+
+    >>> _parse_epoch("2024:029:43200")
+    datetime.datetime(2024, 1, 29, 12, 0)
+
+    >>> _parse_epoch("0000:000:00000")
+    """
+
+    NO_EPOCH = "0000:000:00000"
+    if epoch_str == NO_EPOCH:
+        return None
+
+    fields = epoch_str.split(":")
+    if len(fields) < 3:
+        raise ValueError(f'Input [ {epoch_str} ] does not seem to conform to SINEX epoch format and cannot be parsed')
+
+    epoch = datetime.datetime.strptime(f'{fields[0]}:{fields[1]}', "%Y:%j")
+    seconds = float(fields[2])
+
+    epoch = epoch + datetime.timedelta(seconds=seconds)
+
+    return epoch
+
+
+def _parse_sat_prn_line(line: str) -> _SatPrnItem:
+    """
+    Parse a SATELLITE/PRN line and extract its fields
+
+    >>> _parse_sat_prn_line('G001 1978:053:00000 1985:199:00000 G04')
+    _SatPrnItem(svid='G001', valid_from=datetime.datetime(1978, 2, 22, 0, 0), valid_to=datetime.datetime(1985, 7, 18, 0, 0), prn='G04')
+    """
+
+    fields = line.split(' ')
+    if len(fields) < 4:
+        raise ValueError(f'The input line [ {line} ] does not seem to be a SATELLITE/PRN line')
+
+    svid, valid_from, valid_to, prn = fields[0:4]
+
+    return _SatPrnItem(svid, _parse_epoch(valid_from), _parse_epoch(valid_to), prn)
+
+
+def _extract_section(fh, tag: str) -> typing.List[str]:
+    """
+    Extract a SINEX section
+    """
+
+    lines = []
+    in_block = False
+
+    for line in fh:
+
+        if f'+{tag}' in line:
+            in_block = True
+        elif f'-{tag}' in line:
+            break
+
+        if in_block:
+            lines.append(line.strip())
+
+    return lines

pygnss/stats.py

@@ -0,0 +1,75 @@
+import argparse
+import sys
+from typing import Iterable, Tuple
+
+import numpy as np
+
+
+def cdf_cli():
+    argParser = argparse.ArgumentParser(description=__doc__,
+                                        formatter_class=argparse.RawDescriptionHelpFormatter)  # verbatim
+
+    argParser.add_argument('--n-bins', '-n', metavar='<int>', type=int,
+                           help='Number of bins', default=10)
+
+    args = argParser.parse_args()
+
+    samples = []
+
+    for sample in sys.stdin:
+        try:
+            _ = float(sample)
+        except ValueError:
+            continue
+
+        samples.append(float(sample))
+
+    pdf, edges = np.histogram(samples, bins=args.n_bins, density=True)
+    binwidth = edges[1] - edges[0]
+
+    pdf = np.array(pdf) * binwidth
+    cdf = np.cumsum(pdf)
+
+    for i in range(args.n_bins):
+        print(f"{edges[i]} {pdf[i]} {cdf[i]}")
+
+
+
+def compute_robust(data:Iterable) -> Tuple[float, float]:
+    """
+    Compute the robust statistics for the input data set. These robust
+    statistics are:
+    - median
+    - Median Absolute Deviation (MAD) (https://en.wikipedia.org/wiki/Median_absolute_deviation)
+
+    :param data: input data (array-like)
+    :return: the median and mad
+
+    Example (extracted from http://kldavenport.com/absolute-deviation-around-the-median/)
+    >>> data = [2, 6, 6, 12, 17, 25 ,32]
+    >>> median, mad = compute_robust(data)
+    >>> np.allclose(median, 12)
+    True
+    >>> np.allclose(mad, 6)
+    True
+    """
+
+    if len(data) == 0:
+        raise ValueError("Unable to compute the robust statistics for an empty list or array")
+
+    median = np.median(data)
+
+    mad = np.median(np.abs(data - median))
+
+    return median, mad
+
+
+def rms(values: Iterable) -> float:
+    """
+    Compute the Root Mean Square of an array of values
+
+    >>> array = [1, 2, 3, 4, 5]
+    >>> rms(array)
+    3.3166247903554
+    """
+    return np.sqrt(np.mean(np.square(values)))

pygnss/tensorial.py

@@ -0,0 +1,50 @@
+"""
+This script is used to compare two files so that they are put side by
+side.
+
+Usage:
+      cat file1 file2 | tensorial.py -c col1 [col2 [col3]] ...
+
+
+
+Examples:
+  (a) Join two files using the label in column 1 as a reference
+        cat f1.txt f2.txt | tensorial.py -c 1
+"""
+import argparse
+import sys
+
+
+def entry_point():
+    argParser = argparse.ArgumentParser(description=__doc__,
+                                        formatter_class=argparse.RawDescriptionHelpFormatter)  # for verbatim
+
+    argParser.add_argument('--column', '-c', metavar='<int>', type=int, nargs='+',
+                           help='Column that contains the reference label used to join the lines. '
+                                'This option is repeatable and, if not present, defaults to 1. '
+                                'Columns are expressed as 1-based.')
+
+    args = argParser.parse_args()
+
+    # Retrieve the columns that will be used to make the index
+    if len(args.column) == 0:
+        idxes = [0]
+    else:
+        idxes = [v - 1 for v in args.column]
+
+    lines = {}
+    for line in sys.stdin:
+        values = line.split()
+
+        # Build the index
+        try:
+            index = ' '.join([values[i] for i in idxes])
+        except IndexError:
+            sys.stderr.write("FATAL  : Not enough columns to build the index in the current line\n    %s\n" % line)
+            sys.exit(1)
+
+        # Store the line based on the index, or print it
+        if index in lines:
+            sys.stdout.write("{0} {1}\n".format(lines[index], line[:-1]))
+        else:
+            lines[index] = line[:-1]

pygnss/time.py

@@ -0,0 +1,350 @@
+from collections import namedtuple
+import datetime
+import math
+import enum
+from typing import List, Tuple
+import numpy as np
+import pandas as pd
+
+GPS_TIME_START = datetime.datetime(1980, 1, 6, 0, 0, 0)
+J2000_TIME_START = datetime.datetime(2000, 1, 1, 12, 0, 0)
+SECONDS_IN_DAY = 24 * 60 * 60
+SECONDS_IN_WEEK = 86400 * 7
+GPS_AS_J2000 = -630763200
+
+WeekTow = namedtuple('WeekTow', 'week tow day_of_week')
+
+
+class TimeScale(enum.Enum):
+    GPS = enum.auto()
+    UTC = enum.auto()
+
+
+def get_gps_leapseconds(utc_date: datetime.datetime) -> datetime.timedelta:
+
+    if utc_date >= datetime.datetime(2017, 1, 1):
+        return datetime.timedelta(seconds=18)
+    elif utc_date >= datetime.datetime(2015, 7, 1):
+        return datetime.timedelta(seconds=17)
+    elif utc_date >= datetime.datetime(2012, 7, 1):
+        return datetime.timedelta(seconds=16)
+    elif utc_date >= datetime.datetime(2009, 1, 1):
+        return datetime.timedelta(seconds=15)
+    elif utc_date >= datetime.datetime(2006, 1, 1):
+        return datetime.timedelta(seconds=14)
+    elif utc_date >= datetime.datetime(1999, 1, 1):
+        return datetime.timedelta(seconds=13)
+
+    raise ValueError('No Leap second information for epochs prior to 1999-01-01')
+
+
+class Timespan:
+    def __init__(self, start: datetime.datetime, end: datetime.datetime):
+        self.start = start
+        self.end = end
+
+    def __str__(self):
+        return f"{self.start} - {self.end}"
+
+    def is_overlaping(self, other: 'Timespan') -> bool:
+        return (self.start <= other.end) and (self.end >= other.start)
+
+    def duration(self) -> datetime.timedelta:
+        return self.end - self.start
+
+    def duration_seconds(self) -> int:
+        return int((self.duration()).total_seconds())
+
+    def duration_minutes(self) -> float:
+        return self.duration_seconds() / 60
+
+    def duration_hours(self) -> float:
+        return self.duration_minutes() / 60
+
+    def duration_days(self) -> float:
+        return self.duration_hours() / 24
+
+    def overlap(self, other: 'Timespan') -> 'Timespan':
+        if not self.is_overlaping(other):
+            raise ValueError('Timespans are not overlaped')
+
+        start = max(self.start, other.start)
+        end = min(self.end, other.end)
+        return Timespan(start, end)
+
+    def as_tuple(self) -> tuple:
+        return (self.start, self.end)
+
+    def __repr__(self) -> str:
+        return self.__str__
+
+
+def to_week_tow(epoch: datetime.datetime, timescale: TimeScale = TimeScale.GPS) -> WeekTow:
+    """
+    Convert from datetime to GPS week (asumes datetime in GPS Timescale)
+
+    >>> to_week_tow(datetime.datetime(1980, 1, 6))
+    WeekTow(week=0, tow=0.0, day_of_week=0)
+    >>> to_week_tow(datetime.datetime(2005, 1, 28, 13, 30))
+    WeekTow(week=1307, tow=480600.0, day_of_week=5)
+
+    Conversion method based on algorithm provided in this link
+    http://www.novatel.com/support/knowledge-and-learning/published-papers-and-documents/unit-conversions/
+    """
+
+    timedelta = epoch - GPS_TIME_START
+    leap_delta = get_gps_leapseconds(epoch) if timescale == TimeScale.UTC else datetime.timedelta(0)
+    gpsw = int(timedelta.days / 7)
+    day = timedelta.days - 7 * gpsw
+    tow = timedelta.microseconds * 1e-6 + timedelta.seconds + day * SECONDS_IN_DAY + leap_delta.total_seconds()
+
+    return WeekTow(gpsw, tow, day)
+
+
+def from_week_tow(week: int, tow: float, timescale: TimeScale = TimeScale.GPS) -> datetime.datetime:
+    """
+    Convert from week tow to datetime in GPS scale
+
+    >>> from_week_tow(0, 0.0)
+    datetime.datetime(1980, 1, 6, 0, 0)
+    >>> from_week_tow(1307, 480600.0)
+    datetime.datetime(2005, 1, 28, 13, 30)
+    """
+
+    delta = datetime.timedelta(weeks=week, seconds=tow)
+
+    gps_epoch = GPS_TIME_START + delta
+
+    leap_delta = get_gps_leapseconds(gps_epoch) if timescale == TimeScale.UTC else datetime.timedelta(0)
+
+    return gps_epoch - leap_delta
+
+
+def weektow_to_datetime(tow: float, week: int) -> datetime.datetime:
+    import warnings
+    warnings.warn("This function will be replaced by 'from_week_tow'", DeprecationWarning, stacklevel=2)
+    return from_week_tow(week, tow)
+
+
+def weektow_to_j2000(tow: float, week: int) -> float:
+    """
+    Convert from GPS week and time of the week (in seconds) to j2000 seconds
+
+    The week and tow values can be vectors, and thus it will return a vector of
+    tuples.
+
+    >>> weektow_to_j2000(0, 0.0)
+    -630763200.0
+    """
+
+    j2000s = week * SECONDS_IN_WEEK
+    j2000s += tow
+
+    # Rebase seconds from GPS start origin to J2000 start origin
+    j2000s += GPS_AS_J2000
+
+    return j2000s
+
+
+def to_j2000(epoch: datetime.datetime) -> float:
+    """
+    Convert from datetime toj2000 seconds
+
+    >>> to_j2000(datetime.datetime(2005, 1, 28, 13, 30))
+    160191000.0
+    """
+    week_tow = to_week_tow(epoch)
+    return weektow_to_j2000(week_tow.tow, week_tow.week)
+
+
+def from_j2000(j2000s: int, fraction_of_seconds: float = 0.0) -> datetime.datetime:
+    """
+    Convert from J2000 epoch to datetime
+
+    >>> from_j2000(160191000)
+    datetime.datetime(2005, 1, 28, 13, 30)
+
+    >>> from_j2000(160191000, fraction_of_seconds = 0.1)
+    datetime.datetime(2005, 1, 28, 13, 30, 0, 100000)
+    """
+
+    microseconds = int(fraction_of_seconds * 1.0e6)
+    epoch = J2000_TIME_START + datetime.timedelta(seconds=j2000s, microseconds=microseconds)
+    return epoch
+
+
+def epoch_range(start_epoch, end_epoch, interval_s):
+    """
+    Iterate between 2 epochs with a given interval
+
+    >>> import datetime
+    >>> st = datetime.datetime(2015, 10, 1,  0,  0,  0)
+    >>> en = datetime.datetime(2015, 10, 1,  0, 59, 59)
+    >>> interval_s = 15 * 60
+    >>> ','.join([str(d) for d in epoch_range(st, en, interval_s)])
+    '2015-10-01 00:00:00,2015-10-01 00:15:00,2015-10-01 00:30:00,2015-10-01 00:45:00'
+    >>> st = datetime.datetime(2015, 10, 1,  0,  0,  0)
+    >>> en = datetime.datetime(2015, 10, 1,  1,  0,  0)
+    >>> interval_s = 15 * 60
+    >>> ','.join([str(d) for d in epoch_range(st, en, interval_s)])
+    '2015-10-01 00:00:00,2015-10-01 00:15:00,2015-10-01 00:30:00,2015-10-01 00:45:00,2015-10-01 01:00:00'
+    """
+
+    total_seconds = (end_epoch - start_epoch).total_seconds() + interval_s / 2.0
+    n_intervals_as_float = total_seconds / interval_s
+    n_intervals = int(n_intervals_as_float)
+    if math.fabs(n_intervals - n_intervals_as_float) >= 0.5:
+        n_intervals = n_intervals + 1
+
+    for q in range(n_intervals):
+        yield start_epoch + datetime.timedelta(seconds=interval_s * q)
+
+
+def round_to_interval(epoch: datetime, interval: int) -> datetime:
+    """
+        >>> dt = datetime.datetime(2023, 4, 20, 10, 48, 52, 794000)
+        >>> interval = 0.1
+        >>> round_to_interval(dt, interval)
+        datetime.datetime(2023, 4, 20, 10, 48, 52, 800000)
+
+        >>> interval = 1.0
+        >>> round_to_interval(dt, interval)
+        datetime.datetime(2023, 4, 20, 10, 48, 53)
+
+        >>> interval = 0.5
+        >>> round_to_interval(dt, interval)
+        datetime.datetime(2023, 4, 20, 10, 48, 53)
+
+        >>> interval = 2.0
+        >>> round_to_interval(dt, interval)
+        datetime.datetime(2023, 4, 20, 10, 48, 52)
+
+        >>> interval = 0.05
+        >>> round_to_interval(dt, interval)
+        datetime.datetime(2023, 4, 20, 10, 48, 52, 800000)
+
+        >>> interval = 0.01
+        >>> round_to_interval(dt, interval)
+        datetime.datetime(2023, 4, 20, 10, 48, 52, 790000)
+    """
+    timestamp = epoch.timestamp()
+    rounded_timestamp = round(timestamp / interval) * interval
+    return datetime.datetime.fromtimestamp(rounded_timestamp)
+
+
+def get_interval(epochs: List[datetime.datetime], target_intervals: Tuple[float] = (2.0, 1.0, 0.5, 0.1, 0.05, 0.01)) -> float:
+    """
+    Finds the closest possible interval from a predefined set of intervals to the computed inteval
+    from the pvt.
+
+    Args:
+        epochs: List of datetimes
+        interval: The target intervals for which the closest possible interval is to be found.
+
+    Returns:
+        The closest possible interval from the predefined set.
+
+    >>> t0 = datetime.datetime(2023, 6, 1, 12, 0, 0)
+    >>> epochs = [t0, datetime.datetime(2023, 6, 1, 12, 0, 2), datetime.datetime(2023, 6, 1, 12, 0, 3)]
+    >>> get_interval(epochs)
+    2.0
+
+    >>> t2 = datetime.datetime(2023, 6, 1, 12, 0, 1)
+    >>> epochs = [t0, t2, datetime.datetime(2023, 6, 1, 12, 0, 2)]
+    >>> get_interval(epochs)
+    1.0
+
+    >>> t1 = datetime.datetime(2023, 6, 1, 12, 0, 0, 500000)
+    >>> epochs = [t0, t1, t2]
+    >>> get_interval(epochs)
+    0.5
+
+    >>> t1 = datetime.datetime(2023, 6, 1, 12, 0, 0, 100000)
+    >>> t2 = datetime.datetime(2023, 6, 1, 12, 0, 0, 200000)
+    >>> epochs = [t0, t1, t2]
+    >>> get_interval(epochs)
+    0.1
+
+    >>> t1 = datetime.datetime(2023, 6, 1, 12, 0, 0, 10000)
+    >>> t2 = datetime.datetime(2023, 6, 1, 12, 0, 0, 11000)
+    >>> epochs = [t0, t1, t2]
+    >>> get_interval(epochs)
+    0.01
+
+    """
+    interval = np.median(np.ediff1d(epochs))
+    differences = [abs(interval.total_seconds() - target_interval) for target_interval in target_intervals]
+    return target_intervals[differences.index(min(differences))]
+
+
+def to_julian_date(epoch: datetime.datetime) -> float:
+    """
+    Convert an epoch to Julian Date
+
+    >>> to_julian_date(datetime.datetime(2024, 2, 11))
+    2460351.5
+    >>> round(to_julian_date(datetime.datetime(2019, 1, 1, 8)), 2)
+    2458484.83
+    """
+
+    # Convert datetime object to Julian Date
+    dt = epoch - datetime.datetime(2000, 1, 1, 12, 0, 0)
+    julian_date = 2451545.0 + dt.total_seconds() / 86400.0
+
+    return julian_date
+
+
+def seconds_of_day(epoch: datetime.datetime) -> float:
+    """
+    Compute the seconds of the day
+
+    >>> seconds_of_day(datetime.datetime(2024, 4, 1))
+    0.0
+    >>> seconds_of_day(datetime.datetime(2024, 4, 1, 23, 59, 59))
+    86399.0
+    """
+
+    return epoch.hour * 3600 + epoch.minute * 60 + epoch.second + epoch.microsecond / 1.0e6
+
+
+def gmst(epoch: datetime.datetime) -> float:
+    """
+    Compute the Greenwich Mean Sidereal Time (in hours)
+
+    https://astronomy.stackexchange.com/questions/21002/how-to-find-greenwich-mean-sideral-time
+
+
+    >>> round(gmst(datetime.datetime(2019, 1, 1, 8)), 6)
+    14.712605
+    >>> gmst_hour = gmst(datetime.datetime(2024, 2, 11))
+    >>> round(gmst_hour * math.tau / 24, 9)
+    2.453307616
+    """
+
+    julian_date = to_julian_date(epoch)
+
+    midnight = math.floor(julian_date) + 0.5
+    days_since_midnight = julian_date - midnight
+    hours_since_midnight = days_since_midnight * 24.0
+    days_since_epoch = julian_date - 2451545.0
+    centuries_since_epoch = days_since_epoch / 36525
+    whole_days_since_epoch = midnight - 2451545.0
+
+    GMST_hours = 6.697374558 + 0.06570982441908 * whole_days_since_epoch \
+        + 1.00273790935 * hours_since_midnight \
+        + 0.000026 * centuries_since_epoch**2
+
+    return GMST_hours % 24
+
+
+def compute_elapsed_seconds(epochs: pd.Series) -> pd.Series:
+    return (epochs - epochs.iloc[0]).dt.total_seconds()
+
+
+def compute_decimal_hours(epochs: pd.Series) -> pd.Series:
+    return epochs.apply(lambda x: x.hour + x.minute / 60 + x.second / 3600)
+
+
+if __name__ == "__main__":
+    import doctest
+    doctest.testmod()