tectonic-utils 0.1.2__py3-none-any.whl

tectonic_utils/geodesy/insar_vector_functions.py

@@ -0,0 +1,285 @@
+"""
+Useful utilities for look vectors and coordinate systems.
+"""
+
+import numpy as np
+
+
+def bearing_to_cartesian(heading):
+    """
+    Bearing (heading from North) to cartesian orientation CCW from east.
+
+    :param heading: CW from North, in degrees
+    :type heading: float
+    :returns: Cartesian direction, CCW from East, in degrees
+    :rtype: float
+    """
+    return 90 - heading
+
+
+def cartesian_to_heading(cartesian_angle):
+    """
+    Cartesian orientation (CCW from east) to heading (CW from north).
+
+    :param cartesian_angle: CCW from East, in degrees
+    :type cartesian_angle: float
+    :returns: heading direction, CW from North, in degrees
+    :rtype: float
+    """
+    return 90 - cartesian_angle
+
+
+def complement_angle(angle):
+    """
+    90 minus angle, in degrees.
+
+    :param angle: degrees
+    :returns: angle in degrees
+    """
+    return 90 - angle
+
+
+def cartesian_to_ccw_from_north(angle):
+    """
+    angle minus 90, in degrees.
+
+    :param angle: degrees
+    :returns: angle in degrees
+    """
+    return angle - 90
+
+
+def rotate_vector_by_angle(x0, y0, theta):
+    """
+    rotate a vector by an angle theta, in degrees CCW from East.
+
+    :param x0: x component of vector
+    :type x0: float
+    :param y0: y component of vector
+    :type y0: float
+    :param theta: angle to rotate by, in degrees CCW from East like the mathematical definition
+    :type theta: float
+    :returns: xprime, yprime
+    :rtype: float, float
+    """
+    x_prime = x0 * np.cos(np.deg2rad(-theta)) - y0 * np.sin(np.deg2rad(-theta))
+    y_prime = x0 * np.sin(np.deg2rad(-theta)) + y0 * np.cos(np.deg2rad(-theta))
+    return x_prime, y_prime
+
+
+def normalize_vector(lkve, lkvn, lkvu):
+    """Take a 3-component vector and normalize its components to a unit vector."""
+    east_sq = np.square(lkve)
+    north_sq = np.square(lkvn)
+    up_sq = np.square(lkvu)
+    sumarray = np.add(east_sq, north_sq)
+    sumarray = np.add(sumarray, up_sq)
+    magnitude = np.sqrt(sumarray)
+    norm_lkve = np.divide(lkve, magnitude)
+    norm_lkvn = np.divide(lkvn, magnitude)
+    norm_lkvu = np.divide(lkvu, magnitude)
+    return norm_lkve, norm_lkvn, norm_lkvu
+
+
+def get_unit_vector_from_angle(angle):
+    """
+    Get the unit vector associated with a cartesian angle (CCW from east in degrees).
+
+    :param angle: degrees CW from North
+    :returns: list of two floats, x-component and y-component of unit vector
+    """
+    xcomponent, ycomponent = np.cos(np.deg2rad(angle)), np.sin(np.deg2rad(angle))
+    return [xcomponent, ycomponent]
+
+
+def get_unit_vector_from_heading(heading):
+    """
+    Get the unit vector associated with a heading angle (CW from north in degrees).
+
+    :param heading: degrees CW from North
+    :returns: list of two floats, x-component and y-component of unit vector
+    """
+    cartesian_angle = bearing_to_cartesian(heading)
+    [xcomponent, ycomponent] = get_unit_vector_from_angle(cartesian_angle)
+    return [xcomponent, ycomponent]
+
+
+def calc_rdr_azimuth_incidence_from_lkv_plane_down(lkve, lkvn, lkvu):
+    """
+    Function especially for UAVSAR interferograms to extract the incidence angle from lkv products.
+    lkve, lkvn, lkvu describe vector from plane to ground.
+    Convention: Azimuth angle measured from North in Anti-clockwise direction, in degrees, from ground to plane.
+    Convention: Incidence angle measured from vertical at target.
+    (aka degrees from vertical at satellite) (always +ve), in degrees.
+
+    :param lkve: e component of look vector FROM PLANE TO GROUND
+    :type lkve: float
+    :param lkvn: n component of look vector FROM PLANE TO GROUND
+    :type lkvn: float
+    :param lkvu: u component of look vector FROM PLANE TO GROUND
+    :type lkvu: float
+    :returns: azimuth, incidence, angles in degrees
+    :rtype: float, float
+    """
+
+    east_sq = np.square(lkve)
+    north_sq = np.square(lkvn)
+    sumarray = np.add(east_sq, north_sq)
+    magnitude = np.sqrt(sumarray)
+    azimuth_standard = np.arctan2(-lkvn, -lkve)   # azimuth is negative the direction of look vector from plane down
+    azimuth_standard = np.rad2deg(azimuth_standard)
+    azimuth = np.add(azimuth_standard, -90)
+
+    incidence = np.arctan2(magnitude, -lkvu)
+    incidence = np.rad2deg(incidence)
+    return azimuth, incidence
+
+
+def calc_lkv_from_rdr_azimuth_incidence(azimuth, incidence):
+    """
+    Function especially for ISCE interferograms to extract the lkv from azimuth/incidence.
+    Convention: Azimuth angle measured from North in Anti-clockwise direction, in degrees, from ground to plane.
+    Convention: Incidence angle measured from vertical at target.
+    (aka degrees from vertical at satellite) (always +ve), in degrees.
+    lkve, lkvn, lkvu describe vector from ground to plane.
+
+    :param azimuth: CCW from north angle of vector from ground to plane, in degrees (ISCE LOS.RDR convention)
+    :type azimuth: float
+    :param incidence: angle from look vector to vertical, measured at the target (aka deg. from vertical at satellite)
+    :type incidence: float
+    :returns: lkve, lkvn, lkvu, unit vector from ground to plane
+    """
+
+    azimuth_standard = np.add(azimuth, 90)  # turning the CCW from N into CCW from East
+    azimuth_rad = np.deg2rad(azimuth_standard)
+    incidence_rad = np.deg2rad(incidence)
+    lkv_u = np.cos(incidence_rad)
+    lkv_n = np.sin(incidence_rad) * np.sin(azimuth_rad)
+    lkv_e = np.sin(incidence_rad) * np.cos(azimuth_rad)
+    return lkv_e, lkv_n, lkv_u
+
+
+def look_vector2flight_incidence_angles(lkv_e, lkv_n, lkv_u, look_direction='right'):
+    """
+    Compute incidence and azimuth from 3-component look vector.
+    For left-looking platform, subtract 180 from the resulting azimuth.
+    The inputs can be either scalars or numpy arrays.
+    lkv_e, lkv_n, lkv_u are the components of the look vector from ground to satellite.
+    incidence angle is angle between look vector and vertical in degrees.
+    Flight angle is clockwise from north in degrees.
+
+    :param lkv_e: e component of look vector from ground to satellite
+    :type lkv_e: float or numpy array
+    :param lkv_n: n component of look vector from ground to satellite
+    :type lkv_n: float or numpy array
+    :param lkv_u: u component of look vector from ground to satellite
+    :type lkv_u: float or numpy array
+    :param look_direction: look direction of the SAR platform, must be 'right' or 'left'
+    :type look_direction: string
+    :returns: [flight_angle, incidence_angle] in degrees
+    :rtype: list of two objects, either floats or numpy arrays
+    """
+
+    # Stack into a 3D array: shape (M, N, 3)
+    unit_lkv = np.stack((lkv_e, lkv_n, lkv_u), axis=-1)  # shape (M, N, 3)
+
+    # Normalize each 3-component vector (broadcasting norm across last axis)
+    norms = np.linalg.norm(unit_lkv, axis=-1, keepdims=True)  # shape (M, N, 1)
+    unit_lkv_normalized = unit_lkv / norms  # shape (M, N, 3)
+
+    # Dot product with vertical vector [0, 0, 1]
+    dotproduct = unit_lkv_normalized[..., 2]  # Extract just the "up" component
+
+    # Incidence and Azimuth: angle from vertical, angle on horizontal plane
+    incidence_angle = np.rad2deg(np.arccos(dotproduct))
+    lkv_horiz_angle = np.arctan2(lkv_n, lkv_e)  # cartesian angle of horiz look-vec. (negative small # for DESC)
+    heading_deg = cartesian_to_heading(np.rad2deg(lkv_horiz_angle))
+    if look_direction == 'right':
+        flight_angle = heading_deg + 90  # satellite flies 90 degrees away from look vector direction, right-looking
+    elif look_direction == 'left':
+        flight_angle = heading_deg - 90  # satellite flies 90 degrees away from look vector direction, left-looking
+    else:
+        raise (ValueError("ERROR! Provided look direction of %s must be right or left" % look_direction))
+    return [flight_angle, incidence_angle]
+
+
+def flight_incidence_angles2look_vector(flight_angle, incidence_angle, look_direction='right'):
+    """
+    Compute look vector components from azimuth and incidence.
+    lkv_e, lkv_n, lkv_u are the components of the look vector from ground to satellite.
+    The inputs can be either scalars or numpy arrays.
+
+    :param flight_angle: heading, clockwise from north, in degrees
+    :type flight_angle: float or numpy array
+    :param incidence_angle: angle between look vector and vertical, in degrees
+    :type incidence_angle: float or numpy array
+    :param look_direction: look direction of the SAR platform, must be 'right' or 'left'
+    :type look_direction: string
+    :returns: [lkv_e, lkv_n, lkv_u]
+    :rtype: list of three objects, either floats or numpy arrays
+    """
+    if look_direction == 'right':
+        lk_heading = flight_angle - 90  # heading, 90 degrees to the right of the satellite
+    elif look_direction == 'left':
+        lk_heading = flight_angle + 90  # heading, 90 degrees to the left of the satellite
+    else:
+        raise (ValueError("ERROR! Provided look direction of %s must be right or left" % look_direction))
+    horizontal_lkv = np.sin(np.deg2rad(incidence_angle))
+    lkv_u = np.cos(np.deg2rad(incidence_angle))
+    lkv_cartesian_angle = bearing_to_cartesian(lk_heading)
+    lkv_e = horizontal_lkv * np.cos(np.deg2rad(lkv_cartesian_angle))
+    lkv_n = horizontal_lkv * np.sin(np.deg2rad(lkv_cartesian_angle))
+    return [lkv_e, lkv_n, lkv_u]
+
+
+def def3D_into_LOS(U_e, U_n, U_u, flight_angle, incidence_angle, look_direction='right'):
+    r"""
+    Fialko, 2001, equation to project relative deformation into the LOS.
+
+    .. math:: d_{los} = [U_n \sin(\phi) - U_e \cos(\phi)]*\sin(\lambda) + U_u \cos(\lambda).
+
+    where
+    lambda = incidence angle,
+    phi = flight heading, and
+    [U_e, U_n, U_u] are the east, north, and up components of the deformation.
+
+    :param U_e: east component of deformation
+    :type U_e: float
+    :param U_n: north component of deformation
+    :type U_n: float
+    :param U_u: vertical component of deformation
+    :type U_u: float
+    :param flight_angle: azimuth of satellite heading vector in degrees, CW from north
+    :type flight_angle: float
+    :param incidence_angle: local incidence angle at the reflector (angle from the vertical), in degrees
+    :type incidence_angle: float
+    :param look_direction: 'left' or 'right' (default 'right')
+    :type look_direction: string
+    :returns: los deformation (in same units as U_e)
+    :rtype: float
+    """
+    phi = np.deg2rad(flight_angle)
+    lamda = np.deg2rad(incidence_angle)
+    if look_direction == 'right':
+        d_los = ((U_n * np.sin(phi) - U_e * np.cos(phi)) * np.sin(lamda) + U_u * np.cos(lamda))
+    elif look_direction == 'left':
+        d_los = (-(U_n * np.sin(phi) - U_e * np.cos(phi)) * np.sin(lamda) + U_u * np.cos(lamda))
+    else:
+        raise ValueError("Error!  parameter look_direction must be 'right' or 'left', not %s" % look_direction)
+    return d_los
+
+
+def proj_los_into_vertical_no_horiz(los, lkv):
+    """
+    Project LOS deformation into a pseudo-vertical deformation,
+    assuming horizontal deformation is zero.
+    Compute the vertical deformation needed to produce given LOS deformation.
+
+    :param los: float
+    :param lkv: list of 3 floats, normalized look vector components E, N, U
+    """
+    lkv_horizontal = np.sqrt(lkv[0]*lkv[0] + lkv[1]*lkv[1])
+    lkv_vertical = lkv[2]
+    incidence_angle = np.arctan(lkv_horizontal/lkv_vertical)  # incidence angle from the vertical
+    pseudo_vertical_disp = los / np.cos(incidence_angle)  # assuming no horizontal data contributes to LoS
+    return pseudo_vertical_disp

tectonic_utils/geodesy/linear_elastic.py

@@ -0,0 +1,231 @@
+"""
+Theory: Conversion functions between the six fundamental material parameters in 3D Linear elasticity.
+Example: https://en.wikipedia.org/wiki/Elastic_modulus
+"""
+
+import numpy as np
+
+
+def get_constants_from_bulk_and_youngs(K, E):
+    """
+    Given Bulk (K) and Young's (E) moduli, what are the other elastic constants?
+
+    :param K: bulk modulus
+    :param E: young's modulus
+    :returns: [lame1, G, poisson's ratio, and p-wave modulus]
+    :rtype: list of 4 floats
+    """
+    lame1 = (3*K * (3*K - E)) / (9*K - E)
+    G = (3*K*E) / (9*K - E)
+    pr = (3*K - E) / (6*K)
+    M = (3*K * (3*K + E) ) / (9*K - E)
+    return [lame1, G, pr, M]
+
+
+def get_constants_from_bulk_and_lame1(K, lame1):
+    """
+    Given Bulk modulus (K) and lame1 (lambda), what are the other elastic constants?
+
+    :param K: bulk modulus
+    :param lame1: lame's first parameter
+    :returns: [E, G, poisson's ratio, and p-wave modulus]
+    :rtype: list of 4 floats
+    """
+    E = (9*K * (K-lame1) ) / (3*K - lame1)
+    G = (3 * (K-lame1) ) / 2
+    pr = lame1 / (3*K - lame1)
+    M = 3*K - 2*lame1
+    return [E, G, pr, M]
+
+
+def get_constants_from_bulk_and_shear(K, G):
+    """
+    Given Bulk modulus (K) and shear modulus (G), what are the other elastic constants?
+
+    :param K: bulk modulus
+    :param G: shear modulus
+    :returns: [E, lame1, poisson's ratio, and p-wave modulus]
+    :rtype: list of 4 floats
+    """
+    E = (9*K*G) / (3*K + G)
+    lame1 = K - (2*G / 3)
+    pr = (3*K - 2*G) / (2*(3*K+G))
+    M = K + (4*G / 3)
+    return [E, lame1, pr, M]
+
+
+def get_constants_from_bulk_and_pr(K, nu):
+    """
+    Given Bulk modulus (K) and poisson's ratio (nu), what are the other elastic constants?
+
+    :param K: bulk modulus
+    :param nu: poisson's ratio
+    :returns: [E, G, lame1, and p-wave modulus]
+    :rtype: list of 4 floats
+    """
+    E = 3*K*(1-2*nu)
+    lame1 = (3*K*nu)/(1+nu)
+    G = (3*K*(1-2*nu))/(2*(1+nu))
+    M = (3*K*(1-nu))/(1+nu)
+    return [E, lame1, G, M]
+
+
+def get_constants_from_bulk_and_pwave(K, M):
+    """
+    Given Bulk modulus (K) and P-wave modulus (M), what are the other elastic constants?
+
+    :param K: bulk modulus
+    :param M: p-wave modulus
+    :returns: [E, G, lame1, and poisson's ratio]
+    :rtype: list of 4 floats
+    """
+    E = (9*K*(M-K))/(3*K + M)
+    lame1 = (3*K - M) / 2
+    G = (3 * (M-K)) / 4
+    pr = (3*K - M)/(3*K + M)
+    return [E, lame1, G, pr]
+
+
+def get_constants_from_youngs_and_lame1(E, lame1):
+    """
+    Given Young's modulus (E) and lame1 (lambda), what are the other elastic constants?
+
+    :param E: Young's modulus
+    :param lame1: lame's first parameter
+    :returns: [K, G, poisson's ratio, and p-wave modulus]
+    :rtype: list of 4 floats
+    """
+    R = np.sqrt(E*E + 9*lame1*lame1 + 2*E*lame1)
+    K = (E + 3*lame1 + R) / 6
+    G = (E - 3*lame1 + R) / 4
+    pr = (2*lame1) / (E+lame1+R)
+    M = (E-lame1+R) / 2
+    return [K, G, pr, M]
+
+
+def get_constants_from_youngs_and_shear(E, G):
+    """
+    Given Young's modulus (E) and shear modulus (G), what are the other elastic constants?
+
+    :param E: Young's modulus
+    :param G: shear modulus
+    :returns: [K, lame1, poisson's ratio, and p-wave modulus]
+    :rtype: list of 4 floats
+    """
+    K = (E*G) / (3*(3*G - E))
+    lame1 = (G*(E-2*G)) / (3*G - E)
+    pr = (E/(2*G)) - 1
+    M = (G*(4*G - E)) / (3*G - E)
+    return [K, lame1, pr, M]
+
+
+def get_constants_from_youngs_and_nu(E, nu):
+    """
+    Given Young's modulus (E) and poisson's ratio (nu), what are the other elastic constants?
+
+    :param E: Young's modulus
+    :param nu: poisson's ratio
+    :returns: [K, lame1, G, and p-wave modulus]
+    :rtype: list of 4 floats
+    """
+    K = E / (3*(1-2*nu))
+    lame1 = (E*nu) / ((1+nu) * (1-2*nu))
+    G = E / (2*(1+nu))
+    M = (E*(1-nu)) / ((1+nu)*(1-2*nu))
+    return [K, lame1, G, M]
+
+
+def get_constants_from_lame1_and_shear(lame1, G):
+    """
+    Given lame1 (lambda) and shear modulus (G), what are the other elastic constants?
+
+    :param lame1: lame's first parameter
+    :param G: shear modulus
+    :returns: [K, E, poisson's ratio, and p-wave modulus]
+    :rtype: list of 4 floats
+    """
+    K = lame1 + (2*G)/3
+    E = (G * (3*lame1 + 2*G)) / (lame1 + G)
+    pr = lame1 / (2 * (lame1 + G))
+    M = lame1 + 2*G
+    return [K, E, pr, M]
+
+
+def get_constants_from_lame1_and_nu(lame1, nu):
+    """
+    Given lame1 (lambda) and poisson's ratio (nu), what are the other elastic constants?
+
+    :param lame1: lame's first parameter
+    :param nu: poisson's ratio
+    :returns: [K, E, G, and p-wave modulus]
+    :rtype: list of 4 floats
+    """
+    K = (lame1 * (1+nu)) / (3*nu)
+    E = (lame1 * (1+nu) * (1-2*nu)) / nu
+    G = (lame1 * (1-2*nu)) / (2*nu)
+    M = (lame1 * (1-nu)) / nu
+    return [K, E, G, M]
+
+
+def get_constants_from_lame1_and_pwave(lame1, M):
+    """
+    Given lame1 (lambda) and P-wave modulus (M), what are the other elastic constants?
+
+    :param lame1: lame's first parameter
+    :param M: p-wave modulus
+    :returns: [K, E, G, and poisson's ratio]
+    :rtype: list of 4 floats
+    """
+    K = (M+2*lame1) / 3
+    E = (M-lame1)*(M+2*lame1) / (M+lame1)
+    G = (M-lame1) / 2
+    pr = lame1 / (M+lame1)
+    return [K, E, G, pr]
+
+
+def get_constants_from_shear_and_nu(G, nu):
+    """
+    Given shear modulus (G) and poisson's ratio (nu), what are the other elastic constants?
+
+    :param G: shear modulus
+    :param nu: poisson's ratio
+    :returns: [K, E, lame1, and p-wave modulus]
+    :rtype: list of 4 floats
+    """
+    K = (2*G*(1+nu)) / (3 * (1-2*nu))
+    E = 2*G*(1+nu)
+    lame1 = (2*G*nu) / (1-2*nu)
+    M = (2*G*(1-nu)) / (1-2*nu)
+    return [K, E, lame1, M]
+
+
+def get_constants_from_shear_and_pwave(G, M):
+    """
+    Given shear modulus (G) and p-wave modulus (M), what are the other elastic constants?
+
+    :param G: shear modulus
+    :param M: p-wave modulus
+    :returns: [K, E, lame1, and pr]
+    :rtype: list of 4 floats
+    """
+    K = M - (4*G)/3
+    E = (G * (3*M - 4*G)) / (M-G)
+    lame1 = M - 2*G
+    pr = (M-2*G) / (2*M - 2*G)
+    return [K, E, lame1, pr]
+
+
+def get_constants_from_nu_and_pwave(nu, M):
+    """
+    Given shear modulus (G) and p-wave modulus (M), what are the other elastic constants?
+
+    :param nu: poisson's ratio
+    :param M: p-wave modulus
+    :returns: [K, E, G, and lame1]
+    :rtype: list of 4 floats
+    """
+    K = (M * (1+nu)) / (3 * (1-nu))
+    E = (M * (1+nu) * (1-2*nu)) / (1-nu)
+    lame1 = (M * nu) / (1-nu)
+    G = (M * (1-2*nu) ) / (2 * (1-nu))
+    return [K, E, G, lame1]

tectonic_utils/geodesy/test/test_conversion_functions.py

@@ -0,0 +1,74 @@
+# Testing code
+
+import numpy as np
+import unittest
+from .. import fault_vector_functions, xyz2llh
+
+
+class Tests(unittest.TestCase):
+
+    def test_strike(self):
+        strike = fault_vector_functions.get_strike(deltax=1.0, deltay=0.0)
+        self.assertEqual(strike, 90)
+        strike = fault_vector_functions.get_strike(deltax=-1.0, deltay=0.0)
+        self.assertEqual(strike, 270)
+        strike = fault_vector_functions.get_strike(deltax=0.0, deltay=-1.0)
+        self.assertEqual(strike, 180)
+        angle = -160
+        strike = fault_vector_functions.get_strike(deltax=np.cos(np.deg2rad(angle)), deltay=np.sin(np.deg2rad(angle)))
+        self.assertEqual(strike, 250)
+        return
+
+    def test_rake(self):
+        rake = fault_vector_functions.get_rake(rtlat_strike_slip=-1.0, dip_slip=0.5)
+        self.assertAlmostEqual(rake, 26.5650511770779)
+        return
+
+    def test_plane_normal(self):
+        plane_normal = fault_vector_functions.get_plane_normal(strike=0, dip=0)
+        self.assertTrue(np.allclose(plane_normal, [0, 0, 1]))  # the calculated answer
+        plane_normal = fault_vector_functions.get_plane_normal(strike=90, dip=89.99)
+        self.assertTrue(np.allclose(plane_normal, [0, -1, 0.0001745329]))  # the calculated answer
+        plane_normal = fault_vector_functions.get_plane_normal(strike=270, dip=89.99)
+        self.assertTrue(np.allclose(plane_normal, [0, 1, 0.0001745329]))
+        plane_normal = fault_vector_functions.get_plane_normal(strike=180, dip=1)
+        self.assertTrue(np.allclose(plane_normal, [-0.0174524064372835, 0, 0.999847695156391]))
+        return
+
+    def test_llh_xyz_conversion(self):
+        """ Testing conversion between xyz and llh coordinates """
+        print("Testing llh/enu/xyz conversion math")
+        llh_point = np.array([[-121.98765, 37.12345, 0],
+                              [-121.98765, 38.12345, 0], ])
+        xyz = xyz2llh.llh2xyz(llh_point)
+        llh_back = xyz2llh.xyz2llh(xyz)
+        self.assertTrue(np.allclose(llh_point, llh_back, atol=1e-6))
+
+        # Testing the xyz to llh conversion on values from a AC11 pos file from PBO GPS data.
+        xyz_point = np.array([[-2571637.61354, -1586307.97196,  5599086.71297], ])
+        AC11_location = np.array([[211.6682527307-360, 61.8070788863, 790.83844], ])
+        llh_point = xyz2llh.xyz2llh(xyz_point)
+        self.assertTrue(np.allclose(llh_point, AC11_location))
+        return
+
+    def test_enu_conversion(self):
+        # Testing enu local conversion for station AC11 PBO GPS data
+        # Functions can use LLH or XYZ origin
+        reference_xyz = np.array([-2571637.71108, -1586307.90018,  5599086.75442])  # 1d array from pos file
+        reference_llh = np.array([211.6682506012 - 360, 61.8070787035], )            # llh reference position
+        xyz_obs_2005 = np.array([[-2571637.61354, -1586307.97196,  5599086.71297], ])  # xyz position on 20050721
+        enu_from_pos_file = np.array([[0.11200,  0.02035,  -0.05795], ])               # enu position on 20050721
+        e_enu, _ = xyz2llh.xyz2enu(np.subtract(xyz_obs_2005, reference_xyz), reference_llh, dcov=None)
+        self.assertTrue(np.allclose(e_enu, enu_from_pos_file, atol=1e-3))
+
+        # Trying the enu to xyz coordinates
+        e_xyz, _ = xyz2llh.enu2xyz(enu_from_pos_file, reference_xyz, dcov=None)
+        self.assertTrue(np.allclose(np.add(e_xyz, reference_xyz), xyz_obs_2005, atol=1e-3))
+        # Feel-good code: check out the print statements!
+        print("pos file enu vs computed enu: ", enu_from_pos_file, e_enu)
+        print("pos_xyz_obs vs computed xyz_obs: ", xyz_obs_2005, np.add(e_xyz, reference_xyz))
+        return
+
+
+if __name__ == "__main__":
+    unittest.main()

tectonic_utils/geodesy/test/test_euler_poles.py

@@ -0,0 +1,33 @@
+# Testing code
+
+import unittest
+import numpy as np
+from .. import euler_pole
+
+
+def flush_euler_vector_to_euler_pole(euler_pole_start):
+    """ Convert an euler pole to an euler vector and back. """
+    euler_vector = euler_pole.euler_pole_to_euler_vector(euler_pole_start)
+    euler_pole_returned = euler_pole.euler_vector_to_euler_pole(euler_vector)
+    return euler_pole_returned
+
+
+class Tests(unittest.TestCase):
+
+    def test_euler_vector_and_pole(self):
+        """Test the math converting euler poles and euler vectors"""
+        euler_pole_start = [-120, 40, 0.22]
+        euler_pole_returned = flush_euler_vector_to_euler_pole(euler_pole_start)
+        self.assertTrue(np.allclose(list(euler_pole_start), list(euler_pole_returned)))
+        euler_pole_start = [-120, 40, -0.22]
+        euler_pole_returned = flush_euler_vector_to_euler_pole(euler_pole_start)
+        euler_pole_returned = euler_pole.get_opposite_ep(euler_pole_returned)
+        self.assertTrue(np.allclose(list(euler_pole_start), list(euler_pole_returned)))
+        euler_pole_start = [-120, -40, -0.22]
+        euler_pole_returned = flush_euler_vector_to_euler_pole(euler_pole_start)
+        euler_pole_returned = euler_pole.get_opposite_ep(euler_pole_returned)
+        self.assertTrue(np.allclose(list(euler_pole_start), list(euler_pole_returned)))
+
+
+if __name__ == "__main__":
+    unittest.main()

tectonic_utils/geodesy/test/test_insar_vector_functions.py

@@ -0,0 +1,36 @@
+# Testing code
+
+import numpy as np
+import unittest
+from .. import insar_vector_functions
+
+
+class Tests(unittest.TestCase):
+
+    def test_lkv_conversion(self):
+        """ Test that look vectors are converted to azimuth/incidence, for scalar and numpy array operation"""
+        [lkv_e, lkv_n, lkv_u] = insar_vector_functions.flight_incidence_angles2look_vector(190, 30)
+        [out_flight, out_inc] = insar_vector_functions.look_vector2flight_incidence_angles(lkv_e, lkv_n, lkv_u)
+        self.assertAlmostEqual(190, out_flight)
+        self.assertAlmostEqual(30, out_inc)
+
+        incidence_grd = np.multiply(37, np.ones((10, 10)))  # in degrees
+        azimuth_grd = np.multiply(190, np.ones((10, 10)))  # in degrees
+        e_grd, n_grd, u_grd = insar_vector_functions.flight_incidence_angles2look_vector(azimuth_grd, incidence_grd)
+        azimuth_ret, incidence_ret = insar_vector_functions.look_vector2flight_incidence_angles(e_grd, n_grd, u_grd)
+        np.testing.assert_allclose(azimuth_grd, azimuth_ret)
+        np.testing.assert_allclose(incidence_grd, incidence_ret)
+        return
+
+    def test_proj_into_vertical_no_horizontal(self):
+        # LKV 45 degree test case:
+        semivert = insar_vector_functions.proj_los_into_vertical_no_horiz(1, [0.7, 0, 0.7])
+        self.assertAlmostEqual(semivert, 1.41421356)
+        # LKV vertical test case:
+        semivert = insar_vector_functions.proj_los_into_vertical_no_horiz(1, [0, 0, 1])
+        self.assertAlmostEqual(semivert, 1.0)
+        return
+
+
+if __name__ == "__main__":
+    unittest.main()