corelle.engine 3.0.0__py3-none-any.whl

corelle/engine/query/cache-feature-dataset.sql

@@ -0,0 +1,37 @@
+WITH a AS (
+SELECT
+  model_id,
+  json_agg(json_build_object(
+  'id', f.id,
+  'properties', properties || jsonb_build_object(
+		'plate_id', plate_id,
+		'young_lim', coalesce(young_lim, m.min_age),
+		'old_lim', coalesce(old_lim, m.max_age)
+  ),
+  'geometry', ST_AsGeoJSON(
+    ST_Intersection(
+      ST_Buffer(p.geometry,0),
+      ST_Buffer(f.geometry, 0)
+    )
+  )::jsonb,
+  'type', 'Feature'
+  )) geojson
+FROM corelle.feature f
+JOIN corelle.plate_polygon p
+  ON p.geometry && f.geometry
+ AND ST_Intersects(p.geometry, f.geometry)
+JOIN corelle.model m
+  ON m.id = p.model_id
+WHERE dataset_id = :dataset_id
+GROUP BY model_id
+)
+INSERT INTO corelle.feature_cache (model_id, model_name, geojson, dataset_id)
+SELECT
+	model_id,
+	(SELECT name FROM corelle.model WHERE id = model_id) AS model_name,
+	geojson,
+	:dataset_id dataset_id
+FROM a
+ON CONFLICT (model_id, dataset_id)
+DO UPDATE SET
+  geojson = EXCLUDED.geojson;

corelle/engine/query/delete-extraneous-cache.sql

@@ -0,0 +1,7 @@
+DELETE
+FROM corelle.rotation_cache rc
+USING corelle.plate_polygon pp
+WHERE rc.model_id = pp.model_id
+  AND rc.plate_id = pp.plate_id
+  AND t_step > coalesce(old_lim, 2500)
+   OR t_step < coalesce(young_lim, 0);

corelle/engine/query/feature-dataset-cached.sql

@@ -0,0 +1,4 @@
+SELECT geojson
+FROM corelle.feature_cache
+WHERE model_name = :model_name
+  AND dataset_id = :dataset

corelle/engine/query/feature-dataset.sql

@@ -0,0 +1,21 @@
+SELECT
+  f.id,
+	properties || jsonb_build_object(
+		'plate_id', plate_id,
+		'young_lim', coalesce(young_lim, m.min_age),
+		'old_lim', coalesce(old_lim, m.max_age)) properties,
+	ST_AsGeoJSON(
+    ST_Intersection(
+      ST_Buffer(p.geometry,0),
+      ST_Buffer(f.geometry, 0)
+    )
+  )::json geometry,
+	'Feature' "type"
+FROM corelle.feature f
+JOIN corelle.plate_polygon p
+  ON p.geometry && f.geometry
+ AND ST_Intersects(p.geometry, f.geometry)
+JOIN corelle.model m
+  ON m.id = p.model_id
+WHERE dataset_id = :dataset
+  AND model_id = (SELECT id FROM corelle.model WHERE name = :model_name)

corelle/engine/query/modern-plate-polygons-cached.sql

@@ -0,0 +1,3 @@
+SELECT geojson
+FROM corelle.plate_polygon_cache
+WHERE model_name = :model_name

corelle/engine/query/modern-plate-polygons.sql

@@ -0,0 +1,14 @@
+SELECT
+  pp.id,
+  pp.plate_id,
+  coalesce(young_lim, 0) young_lim,
+  old_lim,
+  ST_AsGeoJSON(geometry) geometry,
+  p.name
+FROM corelle.plate_polygon pp
+JOIN corelle.plate p
+  ON pp.plate_id = p.id
+ AND pp.model_id = p.model_id
+JOIN corelle.model m
+  ON p.model_id = m.id
+WHERE m.name = :model_name

corelle/engine/query/plate-for-point.sql

@@ -0,0 +1,7 @@
+SELECT
+  plate_id
+FROM corelle.plate_polygon p
+WHERE model_id = (SELECT id FROM corelle.model WHERE name = :model_name)
+  AND ST_Intersects(p.geometry, ST_SetSRID(ST_MakePoint(:lon, :lat), 4326))
+  AND coalesce(young_lim,0) < :time
+  AND :time < old_lim

corelle/engine/query/plate-time-ranges.sql

@@ -0,0 +1,9 @@
+SELECT
+	plate_id id,
+	model_id,
+	coalesce(p.old_lim, m.max_age, 4500) old_lim,
+	coalesce(p.young_lim, m.min_age, 0) young_lim
+FROM corelle.plate_polygon p
+JOIN corelle.model m
+  ON m.id = p.model_id
+WHERE m.name = :model_name

corelle/engine/query/plates-for-model.sql

@@ -0,0 +1,6 @@
+SELECT id
+FROM corelle.plate
+WHERE model_id = (
+  SELECT id
+  FROM corelle.model
+  WHERE name = :model_name)

corelle/engine/query/rotation-pairs-for-model.sql

@@ -0,0 +1,64 @@
+WITH plate_steps AS (
+/*
+Rotations for a specific plate and model id
+*/
+SELECT
+  plate_id,
+  ref_plate_id,
+  metadata,
+  t_step,
+  ARRAY[longitude, latitude, angle] rotation,
+  lag(t_step, 1) OVER (
+    ORDER BY plate_id, ref_plate_id, t_step
+  ) prev_step
+FROM corelle.rotation
+WHERE model_id = (
+    SELECT id
+    FROM corelle.model
+    WHERE name = :model_name)
+ORDER BY t_step
+),
+step_pairs AS (
+/*
+Paired steps for interpolated rotations.
+Unlike our previous attempt at the math, these
+MUST have the same ref_plate_id, because this is
+how GPlates is actually structured.
+*/
+SELECT
+  p1.plate_id,
+  p1.ref_plate_id,
+  p1.t_step r1_step,
+  p2.t_step r2_step,
+  p1.rotation r1_rotation,
+  p2.rotation r2_rotation,
+  p1.metadata r1_metadata,
+  p2.metadata r2_metadata
+FROM plate_steps p1
+JOIN plate_steps p2
+  ON p1.t_step = p2.prev_step
+ AND p1.ref_plate_id = p2.ref_plate_id
+ AND p1.plate_id = p2.plate_id
+)
+-- Get rotation that are exactly at `time`, if they exist
+SELECT
+	plate_id,
+	ref_plate_id,
+	t_step r1_step,
+	null r2_step,
+	rotation r1_rotation,
+	null r2_rotation,
+	metadata r1_metadata,
+	null r2_metadata,
+	false interpolated
+FROM plate_steps
+WHERE t_step <= :early_age
+  AND t_step >= :late_age
+UNION ALL
+-- Get rotations that are after `time`
+SELECT
+  *,
+  true interpolated
+FROM step_pairs
+WHERE r1_step <= :early_age
+  AND r2_step > :late_age

corelle/engine/query/rotation-pairs-for-time.sql

@@ -0,0 +1,63 @@
+WITH plate_steps AS (
+/*
+Rotations for a specific plate and model id
+*/
+SELECT
+  plate_id,
+  ref_plate_id,
+  metadata,
+  t_step,
+  ARRAY[longitude, latitude, angle] rotation,
+  lag(t_step, 1) OVER (
+    ORDER BY plate_id, ref_plate_id, t_step
+  ) prev_step
+FROM corelle.rotation
+WHERE model_id = (
+    SELECT id
+    FROM corelle.model
+    WHERE name = :model_name)
+ORDER BY t_step
+),
+step_pairs AS (
+/*
+Paired steps for interpolated rotations.
+Unlike our previous attempt at the math, these
+MUST have the same ref_plate_id, because this is
+how GPlates is actually structured.
+*/
+SELECT
+  p1.plate_id,
+  p1.ref_plate_id,
+  p1.t_step r1_step,
+  p2.t_step r2_step,
+  p1.rotation r1_rotation,
+  p2.rotation r2_rotation,
+  p1.metadata r1_metadata,
+  p2.metadata r2_metadata
+FROM plate_steps p1
+JOIN plate_steps p2
+  ON p1.t_step = p2.prev_step
+ AND p1.ref_plate_id = p2.ref_plate_id
+ AND p1.plate_id = p2.plate_id
+)
+-- Get rotation that are exactly at `time`, if they exist
+SELECT
+	plate_id,
+	ref_plate_id,
+	t_step r1_step,
+	null r2_step,
+	rotation r1_rotation,
+	null r2_rotation,
+	metadata r1_metadata,
+	null r2_metadata,
+	false interpolated
+FROM plate_steps
+WHERE t_step = :time
+UNION ALL
+-- Get rotations that are after `time`
+SELECT
+  *,
+  true interpolated
+FROM step_pairs
+WHERE r1_step < :time
+ AND r2_step > :time

corelle/engine/query/rotation-pairs.sql

@@ -0,0 +1,64 @@
+WITH plate_steps AS (
+/*
+Rotations for a specific plate and model id
+*/
+SELECT
+  plate_id,
+  ref_plate_id,
+  metadata,
+  t_step,
+  ARRAY[longitude, latitude, angle] rotation,
+  lag(t_step, 1) OVER (
+    ORDER BY plate_id, ref_plate_id, t_step
+  ) prev_step
+FROM corelle.rotation
+WHERE plate_id = :plate_id
+  AND model_id = (
+    SELECT id
+    FROM corelle.model
+    WHERE name = :model_name)
+ORDER BY t_step
+),
+step_pairs AS (
+/*
+Paired steps for interpolated rotations.
+Unlike our previous attempt at the math, these
+MUST have the same ref_plate_id, because this is
+how GPlates is actually structured.
+*/
+SELECT
+  p1.plate_id,
+  p1.ref_plate_id,
+  p1.t_step r1_step,
+  p2.t_step r2_step,
+  p1.rotation r1_rotation,
+  p2.rotation r2_rotation,
+  p1.metadata r1_metadata,
+  p2.metadata r2_metadata
+FROM plate_steps p1
+JOIN plate_steps p2
+  ON p1.t_step = p2.prev_step
+ AND p1.ref_plate_id = p2.ref_plate_id
+ AND p1.plate_id = p2.plate_id
+)
+-- Get rotation that are exactly at `time`, if they exist
+SELECT
+	plate_id,
+	ref_plate_id,
+	t_step r1_step,
+	null r2_step,
+	rotation r1_rotation,
+	null r2_rotation,
+	metadata r1_metadata,
+	null r2_metadata,
+	false interpolated
+FROM plate_steps
+WHERE t_step = :time
+UNION ALL
+-- Get rotations that are after `time`
+SELECT
+  *,
+  true interpolated
+FROM step_pairs
+WHERE r1_step < :time
+ AND r2_step > :time

corelle/engine/query/update-cache.sql

@@ -0,0 +1,9 @@
+UPDATE corelle.rotation_cache rc SET
+  proj4text = corelle.build_proj_string(rotation),
+  proj4inv = corelle.build_proj_string(corelle.invert_rotation(rotation)),
+  envelope = ST_Envelope(corelle.rotate_geometry(pp.geometry, rotation))
+FROM corelle.plate_polygon pp
+WHERE rc.model_id = :model_id
+  AND t_step = :t_step
+  AND rc.plate_id = pp.plate_id
+  AND rc.model_id = pp.model_id;

corelle/engine/rotate.py

@@ -0,0 +1,265 @@
+import numpy as N
+import quaternion as Q
+from click import secho
+from decimal import Decimal
+
+from corelle.math import cart2sph, sph2cart, euler_to_quaternion, quaternion_to_euler
+
+from .query import get_sql
+from .storage import model_id
+
+
+class RotationError(Exception):
+    pass
+
+
+class UndefinedRotationError(RotationError):
+    def __init__(self, plate_id, time):
+        super().__init__(self, f"No rotation found for plate {plate_id} at time {time}")
+        self.plate_id = plate_id
+        self.time = time
+
+
+cache = {}
+cache_list = []
+
+
+def build_cache(q, cache_args):
+    # Builds an in-memory cache of rotations
+    cache[cache_args] = q
+    cache_list.append(cache_args)
+    if len(cache_list) > 50000:
+        id = cache_list.pop(0)
+        try:
+            del cache[id]
+        except KeyError:
+            pass
+    return q
+
+
+__sql = get_sql("rotation-pairs")
+
+
+def check_model_id(conn, model_name):
+    # Make sure our model id actually exists
+    id = model_id(conn, model_name)
+    if id is None:
+        raise RotationError("Unknown model id")
+
+
+# Cache this expensive, recursive function.
+def get_rotation(
+    conn,
+    model_name,
+    plate_id,
+    time,
+    verbose=False,
+    depth=0,
+    rowset=None,
+    safe=True,
+):
+    """Core function to rotate a plate to a time by accumulating quaternions"""
+    time = float(time)
+    cache_args = (model_name, plate_id, Decimal(time))
+    if cache_args in cache:
+        return cache[cache_args]
+
+    if safe:
+        check_model_id(conn, model_name)
+
+    __cache = lambda q: build_cache(q, cache_args)
+
+    prefix = " " * depth
+    if verbose:
+        secho(prefix + str(plate_id))
+
+    if plate_id is None or plate_id == 0:
+        return __cache(N.quaternion(1, 0, 0, 0))
+
+    params = dict(plate_id=plate_id, model_name=model_name, time=time)
+
+    row = None
+    pairs = []
+    if rowset:
+        for ix, p in enumerate(rowset):
+            if p.plate_id == plate_id and p.r1_step <= time:
+                pairs = [p]
+                # Remove this row from the rowset (prevents weird recursion errors)
+                rowset = rowset[:ix] + rowset[ix + 1 :]
+                break
+    else:
+        # Fall back to fetching the data ourselves
+        pairs = conn.execute(__sql, params).fetchall()
+    if len(pairs) == 0:
+        return __cache(None)
+    if verbose:
+        for i, pair in enumerate(pairs):
+            color = "green" if i == 0 else "white"
+            secho(prefix + f"{pair.plate_id} → {pair.ref_plate_id}", fg=color)
+
+    row = pairs[0]
+
+    q1 = euler_to_quaternion(row.r1_rotation)
+
+    if not row.interpolated:
+        base = get_rotation(
+            conn,
+            model_name,
+            row.ref_plate_id,
+            row.r1_step,
+            verbose=verbose,
+            depth=depth + 1,
+            rowset=rowset,
+            safe=False,
+        )
+        if base is None:
+            return __cache(None)
+        # We have an exact match!
+        # Just a precautionary guard, this should be assured by our SQL
+        return __cache(base * q1)
+
+    # Interpolated rotations
+    base = get_rotation(
+        conn,
+        model_name,
+        row.ref_plate_id,
+        time,
+        verbose=verbose,
+        depth=depth + 1,
+        rowset=rowset,
+        safe=False,
+    )
+    if base is None:
+        return __cache(None)
+
+    q2 = euler_to_quaternion(row.r2_rotation)
+    # Calculate interpolated rotation between the two timesteps
+    res = Q.slerp(q1, q2, float(row.r1_step), float(row.r2_step), time)
+    return __cache(base * res)
+
+
+def get_plate_id(conn, point, model, time):
+    sql = get_sql("plate-for-point")
+    return conn.execute(
+        sql, dict(lon=point[0], lat=point[1], model_name=model, time=time)
+    ).scalar()
+
+
+def rotate_point(conn, point, model, time):
+    if time == 0:
+        return point
+    plate_id = get_plate_id(conn, point, model, time)
+    if plate_id is None:
+        return None
+    q = get_rotation(conn, model, plate_id, time)
+    v0 = sph2cart(*point)
+    v1 = Q.rotate_vectors(q, v0)
+    return cart2sph(v1)
+
+
+def rotate_point_with_plate(conn, point, model, time):
+    """The rotated point and its plate ID, or None for a point on no plate."""
+    plate_id = get_plate_id(conn, point, model, time)
+    if plate_id is None:
+        return None
+    q = get_rotation(conn, model, plate_id, time)
+    v1 = Q.rotate_vectors(q, sph2cart(*point))
+    return cart2sph(v1), plate_id
+
+
+__tstep_rotation_pairs = get_sql("rotation-pairs-for-time")
+__model_rotation_pairs = get_sql("rotation-pairs-for-model")
+__active_plates_sql = get_sql("active-plates-at-time")
+__model_plates_sql = get_sql("plates-for-model")
+__plate_time_ranges = get_sql("plate-time-ranges")
+
+
+def plates_for_model(conn, model):
+    """Returns a list of plate IDs for a given model"""
+    return [k[0] for k in conn.execute(__model_plates_sql, dict(model_name=model))]
+
+
+def get_all_rotations(
+    conn,
+    model,
+    time,
+    verbose=False,
+    active_only=True,
+    plates=None,
+    safe=True,
+    rowset=None,
+):
+    """Get all rotations for a model and a timestep
+
+    Parameters
+    ----------
+    model : str
+            The rotation model to use
+    time : float
+           The time to rotate to, in Myr before present.
+
+    Yields
+    ------
+    dict
+    """
+    if plates is None:
+        if active_only:
+            res = conn.execute(__active_plates_sql, dict(time=time, model_name=model))
+            plates = [p[0] for p in res]
+        else:
+            plates = plates_for_model(conn, model)
+
+    if rowset is None:
+        _rowset = conn.execute(
+            __tstep_rotation_pairs, dict(time=time, model_name=model)
+        ).fetchall()
+    else:
+        _rowset = [
+            r
+            for r in rowset
+            if (r.r1_step == time and r.r2_step is None)
+            or (r.r1_step < time and (r.r2_step or -1) > time)
+        ]
+
+    if safe:
+        check_model_id(conn, model)
+    for plate_id in plates:
+        q = get_rotation(
+            conn, model, plate_id, time, verbose=verbose, rowset=_rowset, safe=False
+        )
+        if q is None:
+            continue
+        if N.isnan(q.w):
+            continue
+        yield plate_id, q
+
+
+def get_rotation_series(conn, model, *times, **kwargs):
+    # Pre-compute plates for speed...
+    # LOL this actually makes things slower
+    check_model_id(conn, model)
+
+    plate_ages = conn.execute(
+        __plate_time_ranges,
+        dict(model_name=model),
+    ).fetchall()
+
+    rowset = conn.execute(
+        __model_rotation_pairs,
+        dict(
+            model_name=model,
+            early_age=float(max(times)),
+            late_age=float(min(times)),
+        ),
+    ).fetchall()
+    for t in times:
+        t = float(t)
+        plates = [p.id for p in plate_ages if p.old_lim > t and p.young_lim < t]
+        kwargs["plates"] = plates
+        r = get_all_rotations(conn, model, t, safe=False, rowset=rowset, **kwargs)
+        yield dict(rotations=list(r), time=t)
+
+
+def get_plate_rotations(conn, model, plate_id, verbose=False):
+    time_steps = range(0, 500, 1)
+    return ((get_rotation(conn, model, plate_id, t), t) for t in time_steps)

corelle/engine/schema/00-init.sql

@@ -0,0 +1,2 @@
+CREATE EXTENSION IF NOT EXISTS postgis;
+CREATE SCHEMA IF NOT EXISTS corelle;

corelle/engine/schema/01-schema.sql

@@ -0,0 +1,88 @@
+CREATE TABLE IF NOT EXISTS corelle.model (
+  id serial PRIMARY KEY,
+  name text UNIQUE NOT NULL,
+  min_age numeric DEFAULT 0,
+  max_age numeric
+);
+
+CREATE TABLE IF NOT EXISTS corelle.plate (
+  id integer,
+  model_id integer NOT NULL REFERENCES corelle.model(id),
+  parent_id integer,
+  name text,
+  cotid text,
+  coid text,
+  PRIMARY KEY (id, model_id),
+  FOREIGN KEY (parent_id, model_id)
+    REFERENCES corelle.plate (id, model_id)
+    ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS corelle.plate_polygon (
+  id serial PRIMARY KEY,
+  plate_id integer NOT NULL,
+  model_id integer NOT NULL,
+  young_lim numeric,
+  old_lim numeric,
+  geometry geometry(MultiPolygon, 4326),
+  FOREIGN KEY (plate_id, model_id)
+    REFERENCES corelle.plate (id, model_id)
+    ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS
+  corelle_plate_polygon_model_id_idx
+  ON corelle.plate_polygon (plate_id, model_id);
+
+CREATE INDEX
+IF NOT EXISTS corelle_plate_polygon_geometry_idx
+ON corelle.plate_polygon
+USING gist (geometry);
+
+CREATE TABLE IF NOT EXISTS corelle.rotation (
+  id serial PRIMARY KEY,
+  plate_id integer NOT NULL,
+  model_id integer NOT NULL,
+  t_step numeric NOT NULL,
+  latitude numeric NOT NULL,
+  longitude numeric NOT NULL,
+  angle numeric NOT NULL,
+  ref_plate_id integer NOT NULL,
+  metadata text,
+  UNIQUE (plate_id, model_id, t_step, ref_plate_id),
+  FOREIGN KEY (plate_id, model_id)
+    REFERENCES corelle.plate (id, model_id)
+    ON DELETE CASCADE,
+  FOREIGN KEY (ref_plate_id, model_id)
+    REFERENCES corelle.plate (id, model_id)
+    ON DELETE CASCADE
+);
+
+-- Features that can be clipped by plate IDs and returned
+CREATE TABLE IF NOT EXISTS corelle.feature (
+  id serial PRIMARY KEY,
+  dataset_id text NOT NULL,
+  geometry geometry(Geometry, 4326),
+  properties jsonb
+);
+
+/* Cache of features pre-converted to GeoJSON (probably should be deprecated!)*/
+CREATE TABLE IF NOT EXISTS corelle.feature_cache (
+  model_id integer NOT NULL REFERENCES corelle.model(id),
+  model_name text NOT NULL REFERENCES corelle.model(name),
+  dataset_id text NOT NULL,
+  geojson json NOT NULL,
+  PRIMARY KEY (model_id, dataset_id)
+);
+
+/* Cache of rotations at various time steps */
+CREATE TABLE IF NOT EXISTS corelle.rotation_cache (
+  model_id integer NOT NULL REFERENCES corelle.model(id),
+  plate_id integer NOT NULL,
+  t_step decimal NOT NULL,
+  rotation numeric[],
+  PRIMARY KEY (model_id, plate_id, t_step),
+  FOREIGN KEY (plate_id, model_id)
+    REFERENCES corelle.plate (id, model_id)
+    ON DELETE CASCADE
+);