pygnss 2.1.2__cp314-cp314t-macosx_11_0_arm64.whl

pygnss/__init__.py

@@ -0,0 +1 @@
+__version__ = "2.1.2"

pygnss/_c_ext/src/constants.c

@@ -0,0 +1,36 @@
+#include <limits.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+const double CONSTANT_PI  = 3.14159265358979323846;
+const double CONSTANT_TAU = 6.283185307179586476925;
+const double CONSTANT_HALFPI = 3.14159265358979323846 / 2.0;
+const double CONSTANT_LIGHTSPEED = 299792458.0;  // [m/s]
+
+const double CONSTANT_DEG2RAD = 3.14159265358979323846 / 180.0;
+
+// const double ROK_CT_TWOPI = 3.14159265358979323846 * 2.0;
+// const double ROK_CT_QUARTERPI = 3.14159265358979323846 / 4.0;
+// const double ROK_CT_RAD2DEG = 180.0 / 3.14159265358979323846;
+// const double ROK_CT_RAD2SEMI = 1.0 / 3.14159265358979323846;
+// const double ROK_CT_SEMI2RAD = 3.14159265358979323846;
+// const double ROK_CT_EARTHGM = 3.986004418e14;  // [m^3/s^2]
+// const double ROK_CT_EARTHGM_GPS = 3.986005e+14;  // [m^3/s^2]
+// const double ROK_CT_EARTHGM_GLO = 3.9860044e+14;  // [m^3/s^2]
+// const double ROK_CT_EARTHROTATION = 7.2921151467e-5;  // [rad/s]
+// const double ROK_CT_EARTHROTATION_GLO = 7.2921150e-5;  // [rad/s]
+// const double ROK_CT_EARTH_F = -4.442807633e-10;     // [s/sqrt(m)],  GPS ICD-GPS-200H, page 96
+// const double ROK_CT_WGS84_A = 6378137.0;  // [m]
+// const double ROK_CT_WGS84_E = 8.1819190842622e-2;
+// const double ROK_CT_WGS84_F = 1.0 / 298.257223563;
+// const double ROK_CT_EARTH_J2 = 1.0826257e-3;
+// const double ROK_CT_NS2M = 1.0e-9 * 299792458.0;
+// const double ROK_CT_M2NS = 1.0 / 299792458.0 / 1.0e-9;
+// const double ROK_CT_WEEK2SECONDS = 604800.0;
+// const double ROK_CT_DAY2SECONDS = 86400.0;
+// const double ROK_CT_GRAVITY = 9.80665;  // m/s^2
+// const uint16_t ROK_CT_WEEK_GALT_GPST = 1024;
+// const uint16_t ROK_CT_WEEK_BDST_GPST = 1356;
+// const size_t ROK_CT_SIZE_3D = 3 * sizeof(double);
+// const double  ROK_CT_KNOTS_TO_MPS = 0.514444444444444444;
+// const char* ROK_CT_DEF_RXNAME = "UNKN";

pygnss/_c_ext/src/hatanaka.c

@@ -0,0 +1,94 @@
+#include <Python.h>
+#include <datetime.h>
+
+#include "hatanaka/crx2rnx.h"
+
+static char* get_crx_line(void* _args, size_t n_max, char* dst) {
+
+    FILE* input_fh = (FILE*)_args;
+    return fgets(dst, n_max, input_fh);
+
+}
+
+static bool is_eof(void* _args) {
+
+    FILE* input_fh = (FILE*)_args;
+    return (fgetc(input_fh) == EOF);
+
+}
+
+static int on_measurement(const struct gnss_meas* gnss_meas, void* _args) {
+
+    static const int N_FIELDS = 5;  // Number of fields for struct gnss_meas
+
+    int ret = -1;
+    PyObject* list = (PyObject*)_args;
+
+    if (gnss_meas == NULL) {
+        goto exit;
+    }
+
+    PyDateTime_IMPORT;
+
+    // Create Python lists for each inner list
+    PyObject* row = PyList_New(N_FIELDS);
+
+    double timestamp = (double)gnss_meas->gps_time.tv_sec + (double)gnss_meas->gps_time.tv_nsec / 1e9;
+    PyObject* time_tuple = Py_BuildValue("(d)", timestamp);
+    PyObject* date_time = PyDateTime_FromTimestamp(time_tuple);
+
+    PyList_SetItem(row, 0, date_time);
+    PyList_SetItem(row, 1, PyUnicode_FromStringAndSize(gnss_meas->satid, 3));
+    PyList_SetItem(row, 2, PyUnicode_FromStringAndSize(gnss_meas->rinex3_code, 3));
+    PyList_SetItem(row, 3, PyFloat_FromDouble(gnss_meas->value));
+    PyList_SetItem(row, 4, PyLong_FromUnsignedLong(gnss_meas->lli));
+
+    // Add inner lists to the outer list
+    PyList_Append(list, row);
+    Py_DECREF(row);  // Decrement the reference count of 'row'
+
+    ret = 0;
+exit:
+    return ret;
+}
+
+PyObject *_read_crx(PyObject* self, PyObject* args, PyObject* kwargs) {
+
+    char *filename = NULL;
+    struct crx2rnx* crx2rnx = NULL;
+    int ret = -1;
+    PyObject* list = PyList_New(0);
+
+    struct crx2rnx_callbacks callbacks = {
+        .on_measurement = on_measurement,
+        .on_measurement_args = list
+    };
+
+    // Parse the filename argument
+    if (!PyArg_ParseTuple(args, "s", &filename)) {
+        PyErr_SetString(PyExc_TypeError, "Expected a string filename");
+        goto end;
+    }
+
+    // Open the file
+    FILE* fp = fopen(filename, "r");
+    if (fp == NULL) {
+        PyErr_SetString(PyExc_IOError, "Could not open file");
+        goto end;
+    }
+
+    crx2rnx = crx2rnx__init(false, false, NULL, get_crx_line, (void*)fp, is_eof, (void*)fp, &callbacks);
+
+    ret = crx2rnx__run(crx2rnx);
+
+    if (ret < 0) {
+        PyErr_SetString(PyExc_IOError, "There was an issue processing the Hatanaka file");
+        PyList_SetSlice(list, 0, PY_SSIZE_T_MAX, NULL);  // clear the list
+    }
+
+    // Clean-up
+    fclose(fp);
+end:
+    return list;
+
+}

pygnss/_c_ext/src/helpers.c

@@ -0,0 +1,17 @@
+#include <stdlib.h>
+#include <Python.h>
+
+#include "../include/helpers.h"
+
+PyObject *convert_to_pylist(const double* array, size_t n) {
+
+    Py_ssize_t len = n;
+    PyObject* list = PyList_New(len);
+
+    for (Py_ssize_t i = 0; i < len; i++) {
+        PyObject* value = PyFloat_FromDouble(array[i]);
+        PyList_SetItem(list, i, value);
+    }
+
+    return list;
+}

pygnss/_c_ext/src/klobuchar.c

@@ -0,0 +1,313 @@
+#include <Python.h>
+#include <math.h>
+#include <string.h>
+
+#include "constants.h"
+
+#include "klobuchar.h"
+
+
+/** \brief Structure to hold the 8-parameters for the Klobuchar model */
+struct klobuchar {
+    double alphas[4];
+    double betas[4];
+};
+
+
+typedef struct {
+    PyObject_HEAD
+    struct klobuchar klobuchar;
+} Klobuchar;
+
+
+static double compute_klobuchar(const double tow,
+                         const double longitude_rad, const double latitude_rad,
+                         const double el_rad, const double az_rad,
+                         const struct klobuchar* klobuchar) {
+
+    double el_semicircles;
+    double psi;
+    double phi_I;
+    double lambda_I;
+    double phi_m;
+    double t;
+    double phi_m_n[4];
+    double amplitude_I;
+    double period_I;
+    double phase_I;
+    double slant_factor;
+    double iono_delay_l1;
+
+    // Convert elevation from radians to semicircles
+    el_semicircles = el_rad / CONSTANT_PI;
+
+    // Earth-centered angle (psi)
+    psi = 0.0137 / (el_semicircles + 0.11) - 0.022;
+
+    // Latitude of the ionosphere pierce point (semicircles)
+    phi_I = (latitude_rad / CONSTANT_PI) + (psi * cos(az_rad));
+    if (phi_I > 0.416) {
+        phi_I = 0.416;
+    } else if (phi_I < -0.416) {
+        phi_I = -0.416;
+    } else {
+    }
+
+    // Longitude of the ionosphere pierce point (semicircles)
+    lambda_I = (longitude_rad / CONSTANT_PI) + (psi * sin(az_rad) / cos(phi_I * CONSTANT_PI));
+
+    // Geomagnetic latitude_rad of the ionosphere pierce point
+    phi_m = phi_I + (0.064 * cos((lambda_I - 1.617) * CONSTANT_PI));
+
+    // Local time at the IPP
+    t = fmod((43200.0 * lambda_I) + tow, 86400);
+    if (t < 0.0) {
+        t += 86400.0;
+    } else if (t >= 86400.0) {
+        t -= 86400.0;
+    } else {
+    }
+
+    // Compute powers of phi_m for later usage
+    for (int i = 0; i < 4; i++) {
+        phi_m_n[i] = pow(phi_m, (double)i);
+    }
+
+    // Compute the *amplitude* of the ionospheric delay (seconds)
+    // Alpha coefficients are being used for this amount
+    //
+    // amplitude_I = \sum_{n=0}^3 \alpha_n \cdot \phi_m^n
+    //
+    amplitude_I = 0.0;
+    for (int i = 0; i < 4; i++) {
+        amplitude_I += klobuchar->alphas[i] * phi_m_n[i];
+    }
+    if (amplitude_I < 0.0) {
+        amplitude_I = 0.0;
+    }
+
+    // Compute the *period* of the ionospheric delay (seconds)
+    //
+    // period_I = \sum_{n=0}^3 \beta_n \cdot \phi_m^n
+    //
+    period_I = 0.0;
+    for (int i = 0; i < 4; i++) {
+        period_I += klobuchar->betas[i] * phi_m_n[i];
+    }
+    if (period_I < 72000.0) {
+        period_I = 72000.0;
+    }
+
+    // Compute the phase of the ionospheric delay (radians)
+    phase_I = CONSTANT_TAU * (t - 50400.0) / period_I;
+
+    // Compute the slant factor (elevation in semicircles)
+    slant_factor = 1.0 + (16.0 * pow(0.53 - el_semicircles, 3));
+
+    // Compute the ionospheric time delay (L1)
+    iono_delay_l1 = 5.0e-9;
+    if (fabs(phase_I) <= CONSTANT_HALFPI) {
+        iono_delay_l1 = iono_delay_l1
+            + (amplitude_I * (1.0 - (pow(phase_I, 2) / 2.0) + (pow(phase_I, 4) / 24.0)));
+    }
+    iono_delay_l1 = iono_delay_l1 * slant_factor;
+
+    return iono_delay_l1 * CONSTANT_LIGHTSPEED;
+}
+
+double compute_klobuchar_stec(const double tow,
+    const double longitude_rad, const double latitude_rad,
+    const double elevation_rad, const double azimuth_rad,
+    const struct klobuchar* klobuchar) {
+
+    static const double INV_ALPHA_1_TECU = 154.0 * 154.0 * 10.23e6 * 10.23e6 / 40.3 * 1.0e-16; /* f_1^2 / 40.3 (in TECU) */
+
+    double delay = compute_klobuchar(tow, longitude_rad, latitude_rad, elevation_rad, azimuth_rad, klobuchar);
+    double stec_tecu = delay * INV_ALPHA_1_TECU;
+
+    return stec_tecu;
+
+}
+
+
+static PyObject* new(PyTypeObject *type, PyObject *args, PyObject *kwds) {
+
+    Klobuchar *self;
+    self = (Klobuchar *) type->tp_alloc(type, 0);
+    if (self != NULL) {
+        memset(&self->klobuchar, 0, sizeof(struct klobuchar));
+    }
+    return (PyObject *) self;
+}
+
+static void dealloc(Klobuchar *self) {
+
+    Py_TYPE(self)->tp_free((PyObject *) self);
+}
+
+static int init(Klobuchar *self, PyObject *args, PyObject *kwds) {
+
+    static char *kwlist[] = {"alpha0", "alpha1", "alpha2", "alpha3",
+                             "beta0", "beta1", "beta2", "beta3", NULL};
+
+    struct klobuchar* klob = &self->klobuchar;
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "dddddddd", kwlist,
+                                     &klob->alphas[0], &klob->alphas[1], &klob->alphas[2], &klob->alphas[3],
+                                     &klob->betas[0], &klob->betas[1], &klob->betas[2], &klob->betas[3]))
+        return -1;
+    return 0;
+}
+
+static PyObject* Klobuchar_ionospheric_delay(Klobuchar *self, PyObject *args) {
+
+    double tow, lat_deg, lon_deg, az_deg, el_deg;
+    if (!PyArg_ParseTuple(args, "ddddd", &tow, &lat_deg, &lon_deg, &az_deg, &el_deg))
+        return NULL;
+
+    double lat_rad = lat_deg * CONSTANT_DEG2RAD;
+    double lon_rad = lon_deg * CONSTANT_DEG2RAD;
+    double az_rad = az_deg * CONSTANT_DEG2RAD;
+    double el_rad = el_deg * CONSTANT_DEG2RAD;
+    double delay = compute_klobuchar(tow, lon_rad, lat_rad, el_rad, az_rad, &self->klobuchar);
+
+    return PyFloat_FromDouble(delay);
+}
+
+static PyObject* Klobuchar_compute_stec(Klobuchar *self, PyObject *args) {
+
+    double tow, lat_deg, lon_deg, az_deg, el_deg;
+    if (!PyArg_ParseTuple(args, "ddddd", &tow, &lat_deg, &lon_deg, &az_deg, &el_deg))
+        return NULL;
+
+    double lat_rad = lat_deg * CONSTANT_DEG2RAD;
+    double lon_rad = lon_deg * CONSTANT_DEG2RAD;
+    double az_rad = az_deg * CONSTANT_DEG2RAD;
+    double el_rad = el_deg * CONSTANT_DEG2RAD;
+    double stec_tecu = compute_klobuchar_stec(tow, lon_rad, lat_rad, el_rad, az_rad, &self->klobuchar);
+
+    return PyFloat_FromDouble(stec_tecu);
+}
+
+
+static PyObject* Klobuchar_compute_map(Klobuchar *self, PyObject *args, PyObject* kwargs) {
+
+    static char* arguments[] = {"" /*tow*/, "n_lats", "n_lons", NULL};
+
+    double tow;
+    int n_lats = 72;
+    int n_lons = 72;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "d|ii", arguments, &tow, &n_lats, &n_lons))
+        return NULL;
+
+    double* map = calloc(n_lats * n_lons, sizeof(double));
+    if (map == NULL)
+        return NULL;
+
+    /* compute the map */
+    double dlat = 180.0 / n_lats;
+    double dlon = 360.0 / n_lons;
+
+    for (int i = 0; i < n_lats; i ++) {
+        double lat_rad = (+90 - (i + 0.5) * dlat) * CONSTANT_DEG2RAD;
+        for (int j = 0; j < n_lons; j++) {
+            double lon_rad = (-180 + (j + 0.5) * dlon) * CONSTANT_DEG2RAD;
+
+            map[i * n_lons + j] = compute_klobuchar_stec(tow, lon_rad, lat_rad, CONSTANT_HALFPI, 0, &self->klobuchar);
+        }
+    }
+
+    /* store the result into a list of lists*/
+    PyObject* matrix = PyList_New(n_lats);
+
+    // Fill the Python list of lists with sublists
+    for (int i = 0; i < n_lats; ++i) {
+        PyObject* sublist = PyList_New(n_lons);
+        for (int j = 0; j < n_lons; ++j) {
+            double value = map[i * n_lons + j];
+            PyObject* float_obj = PyFloat_FromDouble(value);
+            PyList_SET_ITEM(sublist, j, float_obj);
+        }
+        PyList_SET_ITEM(matrix, i, sublist);
+    }
+
+    free(map);
+
+    return matrix;
+}
+
+
+static PyMethodDef methods[] = {
+{"compute_slant_delay", (PyCFunction) Klobuchar_ionospheric_delay, METH_VARARGS,
+    "Compute ionospheric delay.\n\n"
+    ":param tow: Time of the Week (in seconds)\n"
+    ":param lat_deg: Latitude (in degrees)\n"
+    ":param lon_deg: Longitude (in degrees)\n"
+    ":param az_deg: Azimuth (in degrees)\n"
+    ":param el_deg: Elevation (in degrees)\n\n"
+    ":return: Delay in meters for the GPS L1 frequency\n\n"
+    },
+{"compute_stec", (PyCFunction) Klobuchar_compute_stec, METH_VARARGS,
+    "Compute Slant Total Electron Content\n\n"
+    ":param tow: Time of the Week (in seconds)\n"
+    ":param lat_deg: Latitude (in degrees)\n"
+    ":param lon_deg: Longitude (in degrees)\n"
+    ":param az_deg: Azimuth (in degrees)\n"
+    ":param el_deg: Elevation (in degrees)\n\n"
+    ":return: Slant Total Electron Content (in TEC Units)\n\n"},
+{"compute_vtec_map", (PyCFunction) Klobuchar_compute_map, METH_VARARGS | METH_KEYWORDS,
+    "Compute a VTEC global ionospheric map\n\n"
+    ":param tow: Time of the Week (in seconds)\n"
+    ":param n_lats: Number of latitude bins (defaults to 72)\n"
+    ":param n_lons: Number of longitude bins (defaults to 72)\n\n"
+    ":return: Array of arrays containing VTEC values (n_lats rows * n_lons columns) (TECU)\n\n"},
+{NULL} /* Sentinel */
+};
+
+static PyTypeObject Type = {
+    PyVarObject_HEAD_INIT(NULL, 0)
+    "pyrcore.Klobuchar", /* tp_name */
+    sizeof(Klobuchar), /* tp_basicsize */
+    0, /* tp_itemsize */
+    (destructor) dealloc, /* tp_dealloc */
+    0, /* tp_print */
+    0, /* tp_getattr */
+    0, /* tp_setattr */
+    0, /* tp_reserved */
+    0, /* tp_repr */
+    0, /* tp_as_number */
+    0, /* tp_as_sequence */
+    0, /* tp_as_mapping */
+    0, /* tp_hash */
+    0, /* tp_call */
+    0, /* tp_str */
+    0, /* tp_getattro */
+    0, /* tp_setattro */
+    0, /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT, /* tp_flags */
+    "Klobuchar class\n\n"
+    ">>> from pyrcore import Klobuchar\n"
+    ">>> alphas = [.3820e-07, .1490e-07,  -.1790e-06, .0000e-00]\n"
+    ">>> betas = [.1430e+06, .0000e+00,  -.3280e+06, .1130e+06]\n"
+    ">>> klobuchar = Klobuchar(*alphas, *betas)\n"
+    ">>> delay_L1 = klobuchar.delay(593100, 40, 260, 210, 20)", /* tp_doc */
+    0, /* tp_traverse */
+    0, /* tp_clear */
+    0, /* tp_richcompare */
+    0, /* tp_weaklistoffset */
+    0, /* tp_iter */
+    0, /* tp_iternext */
+    methods, /* tp_methods */
+    0, /* tp_members */
+    0, /* tp_getset */
+    0, /* tp_base */
+    0, /* tp_dict */
+    0, /* tp_descr_get */
+    0, /* tp_descr_set */
+    0, /* tp_dictoffset */
+    (initproc)init,/* tp_init */
+    0,                         /* tp_alloc */
+    new,                 /* tp_new */
+};
+
+PyTypeObject* KlobucharType = &Type;

pygnss/_c_ext/src/mtable_init.c

@@ -0,0 +1,50 @@
+#include <Python.h>
+
+#include "hatanaka.h"
+#include "klobuchar.h"
+
+static PyMethodDef module_methods[] = {
+    { "_read_crx",         (PyCFunction)_read_crx, METH_VARARGS | METH_KEYWORDS,
+      "Read a Hatanaka (gzip uncompressed) file and generate a numpy array\n\n"
+      ":param filename: Name of the Hatanaka file to process\n"
+      ":return: Numpy array\n\n"},
+      {NULL, NULL, 0, NULL},  /* Sentinel */
+};
+
+/*----------------------------------------------------------------------------*/
+
+static struct PyModuleDef module = {
+    PyModuleDef_HEAD_INIT,
+    "_c_ext", /* name of the module*/
+    "C extension methods",
+    -1,  // size of per-interpreter state of the module,
+         // or -1 if the module keeps state in global variables.
+    module_methods
+};
+
+
+PyMODINIT_FUNC PyInit__c_ext(void) {
+
+    PyObject* m = NULL;
+
+//     // Classes
+//     if (PyType_Ready(HatanakaReaderType) < 0) {
+//         goto end;
+//     }
+    if (PyType_Ready(KlobucharType) < 0)
+        return NULL;
+
+    m = PyModule_Create(&module);
+    if (m == NULL) {
+        goto end;
+    }
+
+    Py_INCREF(KlobucharType);
+    PyModule_AddObject(m, "Klobuchar", (PyObject *)KlobucharType);
+
+//     Py_INCREF(HatanakaReaderType);
+//     PyModule_AddObject(m, "HatanakaReader", (PyObject*)HatanakaReaderType);
+
+end:
+    return m;
+}

pygnss/cl.py

@@ -0,0 +1,148 @@
+"""
+Program to perform various columnar operations on inputs
+
+All indicators have this format
+
+ 'x0'
+
+where 'x' can be one of the following
+
+- 'c' - Select column
+- 'd' - diff column relative to the previous value
+- 'f' - diff column relative to the first value of the column
+- 'm' - Compute the minutes elapsed since the first value (divide column by 60,
+        as it assumes that the values are in seconds))
+- 'h' - Compute the hours elapsed since the first value (divide column by 3600,
+        as it assumes that the values are in seconds))
+
+and '0' is the column number (1 based)
+
+Examples:
+
+(a) Select columns with the indicated order (first output 5th column and then the
+    first column)
+        cat file.txt | cl c5 c1
+
+(b) Select 6th column and output 1st column relative to the first one
+        cat file.txt | cl c6 f1
+
+(c) Make a diff of the third column relative to the first value
+        cat file.txt | cl f3
+"""
+import argparse
+import sys
+
+
+class ColumnProcess:
+    """
+    Class that manages the processing of a set of fields based on some criteria
+    """
+
+    def __init__(self, colprocstr):
+        """
+        Class initialization. This method receives a string defining the type
+        of operation to be performed
+        """
+
+        if len(colprocstr) < 2:
+            raise ValueError(f"Do not know how to interpret [ {colprocstr} ], "
+                             "column selector should be of the form 'n0', with "
+                             "'n' being a character and '0' a column number")
+
+        self.process_type = colprocstr[0]
+
+        # Obtain the column number, taking into account that the indices must
+        # be translated from 1-based to 0-based
+        self.process_column = int(colprocstr[1:]) - 1
+
+        self.previous_value = None
+        self.first_value = None
+
+    def process(self, fields):
+        """
+        Process a set of fields. Raise an exception if
+        """
+
+        if self.process_column >= len(fields):
+            raise IndexError(f"Unable to fecth column [ {self.process_column + 1} ] (1-based) "
+                             f"in line with [ {len(fields)} ] fields. "
+                             f"Offending line [ {' '.join(fields)} ]\n")
+
+        column_value = fields[self.process_column]
+
+        if self.process_type == 'c':
+
+            return column_value
+
+        elif self.process_type == 'f' or self.process_type == 'm' or self.process_type == 'h':
+
+            incoming_value = float(column_value)
+
+            if self.first_value is None:
+                self.first_value = incoming_value
+
+            value = incoming_value - self.first_value
+
+            if self.process_type == 'm':
+                value = value / 60.0
+            elif self.process_type == 'h':
+                value = value / 3600.0
+
+            return str(value)
+
+        elif self.process_type == 'd':
+
+            incoming_value = float(column_value)
+
+            if self.previous_value is None:
+                self.previous_value = incoming_value
+
+            value = incoming_value - self.previous_value
+
+            # Update internal value only if the process method is the difference
+            # relative to the previous value
+            if self.process_type == 'd':
+                self.previous_value = incoming_value
+
+            return str(value)
+
+        else:
+            raise ValueError("Do not know what process type is '%c'" % self.process_type)
+
+    def __str__(self):
+
+        return self.__repr__()
+
+    def __repr__(self):
+
+        return "Process type [ %s ], process column [ %d ]\n" % (self.process_type, self.process_column)
+
+
+def entry_point():
+
+    # Process the options of the executable
+
+    parser = argparse.ArgumentParser(description=__doc__,
+                                     formatter_class=argparse.RawDescriptionHelpFormatter)
+
+    parser.add_argument('columns', metavar='<selector>', type=str, nargs='+',
+                        help="Set of column selectors and operators")
+
+    args = parser.parse_args()
+
+    # Make an array of objects that will take care of processing the fields
+    colprocs = [ColumnProcess(colproc) for colproc in args.columns]
+
+    for line in sys.stdin:
+
+        # If line is empty, print an empty line
+        if len(line.strip()) == 0:
+            sys.stdout.write("\n")
+            continue
+
+        fields = line.strip().split()
+
+        # Process each column
+        newfields = [cp.process(fields) for cp in colprocs]
+
+        sys.stdout.write(" ".join(newfields) + "\n")

pygnss/constants.py

@@ -0,0 +1,4 @@
+SPEED_OF_LIGHT = 299792458  # in vacuum [m/s]
+
+EARTH_GRAVITATION_PARAM_MU = 3.986005e14
+EARTH_ROTATION_RATE = 7.2921151466999996e-05