laika package

Subpackages

• laika.lib package
  • Submodules
  • laika.lib.coordinates module
    • LocalCoord
      • LocalCoord.ecef2ned()
      • LocalCoord.from_ecef()
      • LocalCoord.from_geodetic()
      • LocalCoord.geodetic2ned()
      • LocalCoord.ned2ecef()
      • LocalCoord.ned2geodetic()
    • ecef2geodetic()
    • geodetic2ecef()
  • laika.lib.orientation module
    • ecef2car()
    • ecef_euler_from_ned()
    • euler2quat()
    • euler2rot()
    • euler_from_quat()
    • euler_from_rot()
    • ned_euler_from_ecef()
    • quat2euler()
    • quat2rot()
    • quat_from_euler()
    • quat_from_rot()
    • quat_product()
    • quats_from_rotations()
    • rot()
    • rot2euler()
    • rot2quat()
    • rot_from_euler()
    • rot_from_quat()
    • rot_matrix()
    • rotations_from_quats()
  • Module contents

Submodules

laika.astro_dog module

class laika.astro_dog.AstroDog(auto_update=True, cache_dir='/tmp/gnss/', dgps=False, valid_const=('GPS', 'GLONASS'), valid_ephem_types=(<EphemerisType.FINAL_ORBIT: 1>, <EphemerisType.RAPID_ORBIT: 2>, <EphemerisType.ULTRA_RAPID_ORBIT: 3>), clear_old_ephemeris=False)

Bases: object

auto_update: flag indicating whether laika should fetch files from web automatically cache_dir: directory where data files are downloaded to and cached dgps: flag indicating whether laika should use dgps (CORS)

data to calculate pseudorange corrections

valid_const: list of constellation identifiers laika will try process valid_ephem_types: set of ephemeris types that are allowed to use and download.

Default is set to use all orbit ephemeris types

clear_old_ephemeris: flag indicating if ephemeris for an individual satellite should be overwritten when new ephemeris is added.

add_navs(new_ephems: Dict[str, List[Ephemeris]])

add_orbits(new_ephems: Dict[str, List[Ephemeris]])

download_parse_orbit(gps_time: GPSTime, skip_before_epoch=None) → Dict[str, List[PolyEphemeris]]

download_parse_prediction_orbit(gps_time: GPSTime)

get_all_sat_info(time)

get_dcb(prn, time)

get_dcb_data(time)

get_delay(prn, time, rcv_pos, no_dgps=False, signal='C1C', freq=None)

get_dgps_corrections(time, recv_pos)

get_dgps_data(time, recv_pos)

get_epoch_range(new_ephems)

get_frequency(prn, time, signal='C1C')

get_glonass_channel(prn, time)

get_ionex(time) → Optional[IonexMap]

get_ionex_data(time)

get_nav(prn, time)

get_nav_data(time)

get_navs(time)

get_orbit(prn: str, time: GPSTime)

get_orbit_data(time: GPSTime, only_predictions=False)

get_orbits(time)

get_sat_info(prn, time)

get_tgd_from_nav(prn, time)

laika.constants module

laika.dcb module

class laika.dcb.DCB(prn, data)

Bases: object

get_delay(signal)

valid(time)

laika.dcb.parse_dcbs(file_name, SUPPORTED_CONSTELLATIONS)

laika.dgps module

class laika.dgps.DGPSDelay(station_id, station_pos, station_delays, station_delays_t, max_distance)

Bases: object

get_delay(prn, time, signal='C1C')

valid(time, recv_pos)

laika.dgps.download_and_parse_station_postions(cors_station_positions_path, cache_dir)

laika.dgps.get_closest_station_names(pos, k=5, max_distance=100000, cache_dir='/tmp/gnss/')

laika.dgps.get_station_position(station_id, cache_dir='/tmp/gnss/', time=GPSTime(week=2249, tow=433079.455618))

laika.dgps.load_cors_station_positions(cache_dir)

laika.dgps.mean_filter(delay)

laika.dgps.parse_dgps(station_id, station_obs_file_path, dog, max_distance=100000, required_constellations=['GPS'])

laika.downloader module

exception laika.downloader.DownloadFailed

Bases: Exception

laika.downloader.download_and_cache_file(url_base, folder_path: str, cache_dir: str, filename: str, compression='', overwrite=False)

laika.downloader.download_and_cache_file_return_first_success(url_bases, folder_and_file_names, cache_dir, compression='', overwrite=False, raise_error=False)

laika.downloader.download_cors_coords(cache_dir)

laika.downloader.download_cors_station(time, station_name, cache_dir)

laika.downloader.download_dcb(time, cache_dir)

laika.downloader.download_file(url_bases, *args, **kwargs)

laika.downloader.download_files(url_bases, *args, **kwargs)

laika.downloader.download_ionex(time, cache_dir)

laika.downloader.download_nav(time: GPSTime, cache_dir, constellation: ConstellationId)

laika.downloader.download_orbits_gps(time, cache_dir, ephem_types)

laika.downloader.download_orbits_gps_cod0(time, cache_dir, ephem_types)

laika.downloader.download_orbits_russia_src(time, cache_dir, ephem_types)

laika.downloader.download_prediction_orbits_russia_src(gps_time, cache_dir)

laika.downloader.ftp_connect(url)

laika.downloader.ftp_download_file(url)

laika.downloader.ftp_download_files(url_base, folder_path, cacheDir, filenames)

Like download file, but more of them. Keeps a persistent FTP connection open to be more efficient.

laika.downloader.ftps_download_file(url)

laika.downloader.http_download_files(url_base, folder_path, cacheDir, filenames)

Similar to ftp_download_files, attempt to download multiple files faster than just downloading them one-by-one. Returns a list of filepaths instead of the raw data

laika.downloader.https_download_file(url)

laika.downloader.list_dir(url_bases, *args, **kwargs)

laika.downloader.retryable(f)

Decorator to allow us to pass multiple URLs from which to download. Automatically retry the request with the next URL on failure

laika.ephemeris module

class laika.ephemeris.Ephemeris(prn: str, data, epoch: GPSTime, eph_type: EphemerisType, healthy: bool, max_time_diff: float, file_epoch: Optional[GPSTime] = None, file_name=None)

Bases: ABC

classmethod from_json(json_dct)

get_sat_info(time: GPSTime)

Returns: (pos, vel, clock_err, clock_rate_err, ephemeris)

to_json()

valid(time)

class laika.ephemeris.EphemerisSerializer(*, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, sort_keys=False, indent=None, separators=None, default=None)

Bases: JSONEncoder

default(o)

Implement this method in a subclass such that it returns a serializable object for o, or calls the base implementation (to raise a TypeError).

For example, to support arbitrary iterators, you could implement default like this:

def default(self, o):
    try:
        iterable = iter(o)
    except TypeError:
        pass
    else:
        return list(iterable)
    # Let the base class default method raise the TypeError
    return JSONEncoder.default(self, o)

class laika.ephemeris.EphemerisType(value)

Bases: IntEnum

An enumeration.

FINAL_ORBIT = 1

NAV = 0

QCOM_POLY = 4

RAPID_ORBIT = 2

ULTRA_RAPID_ORBIT = 3

static all_orbits()

classmethod from_file_name(file_name: str)

class laika.ephemeris.GLONASSEphemeris(data, epoch, file_name=None)

Bases: Ephemeris

class laika.ephemeris.GPSEphemeris(data, epoch, file_name=None)

Bases: Ephemeris

get_tgd()

class laika.ephemeris.PolyEphemeris(prn: str, data, epoch: GPSTime, ephem_type: EphemerisType, file_epoch: Optional[GPSTime] = None, file_name: Optional[str] = None, healthy=True, tgd=0, max_time_diff: int = 3600)

Bases: Ephemeris

laika.ephemeris.convert_ublox_glonass_ephem(ublox_ephem, current_time: Optional[datetime] = None)

laika.ephemeris.convert_ublox_gps_ephem(ublox_ephem, current_time: Optional[datetime] = None)

laika.ephemeris.ephemeris_deserialize_hook(dct)

laika.ephemeris.parse_qcom_ephem(qcom_poly, current_week)

laika.ephemeris.parse_rinex_nav_msg_glonass(file_name)

laika.ephemeris.parse_rinex_nav_msg_gps(file_name)

laika.ephemeris.parse_sp3_orbits(file_names, supported_constellations, skip_until_epoch: Optional[GPSTime] = None) → Dict[str, List[PolyEphemeris]]

laika.ephemeris.read4(f, rinex_ver)

laika.ephemeris.read_prn_data(data, prn, deg=16, deg_t=1)

laika.gps_time module

class laika.gps_time.GPSTime(week, tow)

Bases: object

GPS time class to add and subtract [week, tow]

as_datetime()

as_unix_timestamp()

property day

classmethod from_datetime(datetime)

classmethod from_glonass(cycle, days, tow)

classmethod from_meas(meas)

class laika.gps_time.TimeSyncer(mono_time, gps_time)

Bases: object

Converts logmonotime to gps_time and vice versa

classmethod from_datetime(datetime)

classmethod from_logs(raw_qcom_measurement_report, clocks)

gps2mono(gps_time)

mono2gps(mono_time)

laika.gps_time.datetime_to_tow(t)

Convert a Python datetime object to GPS Week and Time Of Week. Does not convert from UTC to GPST. Fractional seconds are supported.

Parameters

tdatetime

A time to be converted, on the GPST timescale.

mod1024bool, optional

If True (default), the week number will be output in 10-bit form.

Returns

week, towtuple (int, float)

The GPS week number and time-of-week.

laika.gps_time.get_leap_seconds(time)

laika.gps_time.gpst_to_utc(t_gpst)

laika.gps_time.tow_to_datetime(tow, week)

Convert a GPS Week and Time Of Week to Python datetime object. Does not convert from GPST to UTC. Fractional seconds are supported.

Parameters

tow : time of week in seconds

weeks : gps week

Returns

tdatetime

Python datetime

laika.gps_time.utc_to_gpst(t_utc)

laika.helpers module

class laika.helpers.ConstellationId(value)

Bases: IntEnum

An enumeration.

BEIDOU = 3

GALILEO = 2

GLONASS = 6

GPS = 0

IMES = 4

IRNSS = 7

QZNSS = 5

SBAS = 1

classmethod from_qcom_source(report_source: int)

classmethod from_rinex_char(c: str)

to_rinex_char() → str

class laika.helpers.TimeRangeHolder

Bases: object

Class to support test if date is in any of the multiple, sparse ranges

add(start_time, end_time)

laika.helpers.get_closest(time, candidates, recv_pos=None)

laika.helpers.get_constellation(prn: str)

laika.helpers.get_constellation_and_sv_id(nmea_id)

laika.helpers.get_el_az(pos, sat_pos)

laika.helpers.get_nmea_id_from_constellation_and_svid(constellation: ConstellationId, sv_id: int)

laika.helpers.get_nmea_id_from_prn(prn: str)

laika.helpers.get_prn_from_nmea_id(nmea_id: int)

laika.helpers.rinex3_obs_from_rinex2_obs(observable)

laika.iono module

class laika.iono.IonexMap(exp, data1, data2)

Bases: object

static find_nearest(lst, val)

get_TEC(pos, time)

Returns TEC in a position pos of ionosphere :param pos: (lat, lon) [deg, deg] :return:

get_delay(rcv_pos, az, el, sat_pos, time, freq)

static round_to_grid(number, base)

valid(time)

laika.iono.closest_in_list(lst, val, num=2)

Returns two (num in general) closest values of val in list lst

laika.iono.compute_grid_lats_lons(data)

laika.iono.get_header_body(file_path)

Opens file_path, reads file and returns header and body separated with “END OF HEADER” :param file_path: path to RINEX-like file :return: header, body (arrays of lines)

laika.iono.get_header_line(headr, proprty)

Parameters

• headr – the header of the RINEX-file

• proprty – string-like property to search for (e.g. ‘delta-utc’)

Returns

the string of the headr containing property

laika.iono.get_int_from_header(hdr, seq)

Returns the first int from the line that contains seq of lines hdr. In fact, _header_ here may not be header of RINEX/IONEX, just some set of lines.

laika.iono.klobuchar(pos, az, el, time, iono_coeffs)

Details are taken from [5]: IS-GPS-200H, Fig. 20-4 Note: result is referred to the GPS L₁ frequency; if the user is operating on the GPS L₂ frequency, the correction term must be multiplied by γ = f₂²/f₁¹ = 0.6071850227694382 :param pos: [lat, lon, alt] in radians and meters

laika.iono.parse_ionex(ionex_file)

Parameters

ionex_file – path to the IONEX file

Returns

TEC interpolation function f( (lat,lon), datetime )

laika.opt module

laika.opt.calc_pos_fix(measurements, posfix_functions=None, x0=None, no_weight=False, signal='C1C', min_measurements=6)

Calculates gps fix using gauss newton method To solve the problem a minimal of 4 measurements are required.

If Glonass is included 5 are required to solve for the additional free variable.

returns: 0 -> list with positions 1 -> pseudorange errs

laika.opt.calc_vel_fix(measurements, est_pos, velfix_function=None, v0=None, no_weight=False, signal='D1C', min_measurements=6)

Calculates gps velocity fix using gauss newton method returns: 0 -> list with velocities 1 -> pseudorange_rate errs

laika.opt.gauss_newton(fun, b, xtol=1e-08, max_n=25)

laika.opt.get_posfix_sympy_fun(constellation)

laika.opt.get_velfix_sympy_func()

laika.opt.pr_residual(measurements: List[GNSSMeasurement], posfix_functions=None, signal='C1C', no_weight=False, no_nans=False)

laika.opt.prr_residual(measurements: List[GNSSMeasurement], est_pos, velfix_function=None, signal='D1C', no_weight=False, no_nans=False)

laika.raw_gnss module

class laika.raw_gnss.GNSSMeasurement(constellation_id: ConstellationId, sv_id: int, recv_time_week: int, recv_time_sec: float, observables: Dict[str, float], observables_std: Dict[str, float], glonass_freq: Optional[Union[int, float]] = None)

Bases: object

GLONASS_FREQ = 3

PR = 4

PRN = 0

PRR = 6

PRR_STD = 7

PR_STD = 5

RECV_TIME_SEC = 2

RECV_TIME_WEEK = 1

SAT_POS = slice(8, 11, None)

SAT_VEL = slice(11, 14, None)

as_array(only_corrected=True)

correct(est_pos, dog)

get_nmea_id()

process(dog)

laika.raw_gnss.array_from_normal_meas(meas)

laika.raw_gnss.correct_measurements(measurements: List[GNSSMeasurement], est_pos, dog) → List[GNSSMeasurement]

laika.raw_gnss.get_DOP(recv_pos, sat_positions)

laika.raw_gnss.get_HDOP(recv_pos, sat_positions)

laika.raw_gnss.get_PDOP(recv_pos, sat_positions)

laika.raw_gnss.get_Q(recv_pos, sat_positions)

laika.raw_gnss.get_TDOP(recv_pos, sat_positions)

laika.raw_gnss.get_VDOP(recv_pos, sat_positions)

laika.raw_gnss.group_measurements_by_epoch(measurements)

laika.raw_gnss.group_measurements_by_sat(measurements)

laika.raw_gnss.normal_meas_from_array(arr)

laika.raw_gnss.process_measurements(measurements: List[GNSSMeasurement], dog) → List[GNSSMeasurement]

laika.raw_gnss.read_raw_qcom(report)

laika.raw_gnss.read_raw_ublox(report) → List[GNSSMeasurement]

laika.raw_gnss.read_rinex_obs(obsdata) → List[List[GNSSMeasurement]]

laika.rinex_file module

exception laika.rinex_file.DownloadError

Bases: Exception

class laika.rinex_file.RINEXFile(filename, rate=None)

Bases: object

laika.rinex_file.digitorzero(x)

laika.rinex_file.floatornan(x)

laika.rinex_file.padline(l, n=16)

laika.trop module

laika.trop.saast(pos, el, humi=0.75, temp0=15.0)

Function from RTKlib: https://github.com/tomojitakasu/RTKLIB/blob/master/src/rtkcmn.c#L3362-3362

with no changes

Parameters

• time – time

• pos – receiver position {ecef} m)

• el – azimuth/elevation angle {az,el} (rad) – we do not use az

• humi – relative humidity

• temp0 – temperature (Celsius)

Returns

tropospheric delay (m)

Module contents