forgeo-gmlib 0.6.2__cp313-cp313-musllinux_1_2_x86_64.whl

forgeo/gmlib/__init__.py

@@ -0,0 +1,9 @@
+try:
+    from ._version import __version__, __version_tuple__, version, version_tuple
+except ImportError:
+    __version__ = version = None
+    __version_tuple__ = version_tuple = ()
+
+from .GeologicalModel3D import GeologicalModel
+
+__all__ = ["GeologicalModel"]

forgeo/gmlib/_version.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '0.6.2'
+__version_tuple__ = version_tuple = (0, 6, 2)
+
+__commit_id__ = commit_id = 'g8f2da16bc'

forgeo/gmlib/architecture/__init__.py

@@ -0,0 +1 @@
+from .core import *

forgeo/gmlib/architecture/core.py

@@ -0,0 +1,130 @@
+from dataclasses import dataclass
+
+from .pyarchitecture import *
+
+
+@dataclass
+class NodeInfo:
+    name: str
+    color: tuple = None
+
+
+def export_model_without_leaves(model):
+    """Converts a geological architecture to python dictionnary.
+    This is suboptimal because underlying functors are wrapped several times.
+    """
+
+    def build(node):
+        if node is None:
+            return None
+        interface = model.interface(node)
+        if interface is None:  # leaf
+            return None
+        return {
+            "interface": interface,
+            "below": build(model.below(node)),
+            "above": build(model.above(node)),
+        }
+
+    return build(model.root)
+
+
+def _from_GeoModeller(
+    model,
+    add_interface_node,
+    add_formation_node,
+    add_topography_node=False,
+    topography_color=None,
+    keep_info=False,  # FIXME: C++ does not store node information
+):
+    """Converts a GeoModeller model to architecture.
+    This is suboptimal because underlying functors are wrapped several times.
+    """
+    fields = model.fields
+    values = model.values
+    relations = model.relations
+    formations = model.pile_formations
+    formation_color = model.formation_colors
+    pile_reference = model.pile.reference
+    assert len(fields) == len(values)
+    assert len(fields) == len(relations)
+    assert len(fields) + 1 == len(formations)
+    assert set(relations).issubset({"onlap", "erode"})
+
+    def build_onlap_range(first, last):
+        assert 0 <= first <= last
+        # We add 1 to formations to leave 0 for the default formation (above topography)
+        node = add_formation_node(last + 1)
+        for k in range(first, last)[::-1]:
+            below = add_formation_node(k + 1)
+            name = formations[k]
+            info = (
+                NodeInfo(f"{pile_reference}-{name}", formation_color[name])
+                if keep_info
+                else None
+            )
+            node = add_interface_node(fields[k], values[k], below, node, info)
+        return node
+
+    erosions = [k for k, relation in enumerate(relations) if relation == "erode"]
+    erosions.append(len(relations))
+    node = build_onlap_range(0, erosions[0])
+    for e, next_e in zip(erosions[:-1], erosions[1:]):
+        name = formations[e]
+        info = (
+            NodeInfo(f"erosion-{pile_reference}-{name}", formation_color[name])
+            if keep_info
+            else None
+        )
+        node = add_interface_node(
+            fields[e], values[e], node, build_onlap_range(e + 1, next_e), info
+        )
+    if add_topography_node:
+        node = add_interface_node(
+            model.topography,
+            0,
+            node,
+            None,
+            NodeInfo("topography", topography_color) if keep_info else None,
+        )
+    return node
+
+
+def from_GeoModeller(model, **kwargs):
+    """Converts a GeoModeller model to architecture.
+    This is suboptimal because underlying functors are wrapped several times.
+    """
+    architecture = Model()
+
+    def add_interface(field, value, below, above, info=None):
+        return architecture.add_interface_node(Field(field), value, below, above, info)
+
+    def add_formation(formation):
+        return architecture.add_formation_node(formation)
+
+    architecture.set_root_node(
+        _from_GeoModeller(model, add_interface, add_formation, **kwargs)
+    )
+    return architecture
+
+
+@dataclass
+class ArchitectureNode:
+    interface: tuple
+    below: "typing.Callable" = None
+    above: "typing.Callable" = None
+    info: NodeInfo = None
+
+
+def simple_tree_from_GeoModeller(model, **kwargs):
+    """Converts a GeoModeller model to architecture.
+    This is suboptimal because underlying functors are wrapped several times.
+    """
+
+    def add_interface(field, value, below, above, info=None):
+        return ArchitectureNode((field, value), below, above, info)
+
+    def add_formation(formation):
+        return None
+
+    return _from_GeoModeller(model, add_interface, add_formation, **kwargs)

forgeo/gmlib/fault_network.py

@@ -0,0 +1,171 @@
+#
+# This file is part of gmlib. It is free software.
+# You can redistribute it and/or modify it under the terms of the GNU Affero General Public License version 3.
+#
+
+from collections import namedtuple
+from itertools import product
+
+import numpy as np
+
+Fault_node = namedtuple("Fault_node", ["fault", "negative", "positive"])
+
+
+def _build_family_tree(limits):
+    nbf = len(limits)
+    assert all(all(fk < nbf for fk in limit) for limit in limits)
+    fault_ancestors = [set() for _ in range(nbf)]
+    fault_progeny = [set() for _ in range(nbf)]
+    for fk, data in enumerate(zip(limits, fault_ancestors)):
+        stops_on, ancestors = data
+        for limit in stops_on:
+            ancestors.add(limit)
+            fault_progeny[limit].add(fk)
+    progenyless = [k for k, progeny in enumerate(fault_progeny) if not progeny]
+    ancestorless = [k for k, ancestors in enumerate(fault_ancestors) if not ancestors]
+
+    # FIXME: we do not check there are no cycles
+    # OPTIMIZE: this may not be usefull...
+    # we complete the set of all ancestors to eventually keep only direct ancestors
+    # the problem is that we don't have the guarantee the set of all ancestors
+    # and complete progeny are correct from the begining
+    # here are the big recursive loops :-(
+    def add_progeny(progeny, ancestors):
+        for ancestor in ancestors:
+            family = fault_progeny[ancestor]
+            family |= progeny
+            add_progeny(family, fault_ancestors[ancestor])
+
+    def add_ancestors(ancestors, progeny):
+        for descendant in progeny:
+            family = fault_ancestors[descendant]
+            family |= ancestors
+            add_ancestors(family, fault_progeny[descendant])
+
+    for alone in progenyless:
+        assert not fault_progeny[alone]
+        add_progeny({alone}, fault_ancestors[alone])
+    for orphan in ancestorless:
+        assert not fault_ancestors[orphan]
+        add_ancestors({orphan}, fault_progeny[orphan])
+
+    # we now keep only direct links
+    def test_set_intersection(S1, S2):
+        return any(x in S1 for x in S2)
+
+    for descendant in range(nbf):
+        ancestors = fault_ancestors[descendant]
+        all_ancestors = list(ancestors)
+        for ancestor in all_ancestors:
+            if test_set_intersection(ancestors, fault_progeny[ancestor]):
+                fault_progeny[ancestor].remove(descendant)
+                ancestors.remove(ancestor)
+    return fault_progeny, fault_ancestors
+
+
+def _build_fault_node(faults, fk, progeny):
+    fault = faults[fk]
+    assert fk not in progeny
+    positive = []
+    negative = []
+    for fl in progeny:
+        # FIXME: this is a legacy test which is bugprone
+        gravity_center = faults[fl].data_centroid()
+        if fault(gravity_center) > 0:
+            positive.append(fl)
+        else:
+            negative.append(fl)
+    return Fault_node(fault, tuple(sorted(negative)), tuple(sorted(positive)))
+
+
+def _build_fault_nodes(faults, limits):
+    assert all(all(fk < len(faults) for fk in limit) for limit in limits)
+    fault_progeny, fault_ancestors = _build_family_tree(limits)
+    ancestorless = [k for k, ancestors in enumerate(fault_ancestors) if not ancestors]
+    nodes = [
+        _build_fault_node(faults, k, progeny) for k, progeny in enumerate(fault_progeny)
+    ]
+    roots = tuple(sorted(ancestorless))
+    return nodes, roots
+
+
+def build(faults, limits):
+    assert len(faults) == len(limits)
+    if not faults:
+        return None
+    nodes, roots = _build_fault_nodes(faults, limits)
+    assert roots
+    # TODO: all of the following could be grouped into a iterator class
+    # yielding evaluation values
+    nbf = len(faults)
+    evaluations = []
+    evaluation = np.zeros(nbf, dtype=np.int8)
+    check = np.zeros(nbf, dtype=bool)
+    level = nbf
+    iterators = []
+    exploration = [roots]
+
+    # NB: we use numpy.put method because given an array a
+    #     a[tuple()] = 1 will set all the array to one
+    #     whereas a.pu(tuple(), 1) will do nothing wich
+    #     is the expected behavior here
+    def explore_progeny(progeny, sides, level):
+        for fk, side in zip(progeny, sides):
+            nk = nodes[fk]
+            if side < 0:
+                deeper = nk.negative
+                nullify = nk.positive
+            else:
+                assert side == 1
+                deeper = nk.positive
+                nullify = nk.negative
+            assert not (nullify and np.any(check[nullify]))
+            if nullify:
+                check.put(nullify, True)
+                evaluation.put(nullify, 0)
+                level -= len(nullify)
+                iterators.append((nullify, iter([])))
+            if deeper:
+                exploration.append(deeper)
+        return level
+
+    while iterators or exploration:
+        if level == 0:
+            assert not exploration
+            assert np.all(check)
+            faults, it = iterators.pop()
+            while True:
+                try:
+                    evaluations.append(np.copy(evaluation))
+                    evaluation.put(faults, next(it))
+                except StopIteration:
+                    break
+            check.put(faults, False)
+            level += len(faults)
+            while iterators:
+                faults, it = iterators[-1]
+                try:
+                    assert faults
+                    assert np.all(check[faults])
+                    sides = next(it)
+                    evaluation.put(faults, sides)
+                    level = explore_progeny(faults, sides, level)
+                    break
+                except StopIteration:
+                    check.put(faults, False)
+                    level += len(faults)
+                    iterators.pop()
+        while exploration:
+            explore = exploration.pop()
+            it = iter(product((-1, 1), repeat=len(explore)))
+            sides = next(it)
+            assert explore
+            assert not np.any(check[explore])
+            check.put(explore, True)
+            evaluation.put(explore, sides)
+            iterators.append((explore, it))
+            level -= len(explore)
+            level = explore_progeny(explore, sides, level)
+        assert level in (0, nbf)
+        assert np.all(check) or np.all(np.logical_not(check))
+    return nodes, roots, evaluations

forgeo/gmlib/geomodeller_data.py

@@ -0,0 +1,101 @@
+"""
+Created on Mon Apr 16 09:58:12 2018
+
+@author: lopez
+"""
+
+from collections import namedtuple
+
+import numpy as np
+
+
+class NotImplemented(Exception):
+    pass
+
+
+GradientData = namedtuple("GradientData", ["locations", "values"])
+
+
+class PotentialData:
+    pass
+
+
+class FaultData:
+    def __init__(self, name):
+        self.name = name
+        self.infinite = True
+        self.center_type = None
+        self.influence_radius = None
+        self.lateral_extent = None
+        self.vertical_extent = None
+        self.stops_on = []
+        self.potential_data = None
+        self.color = None
+
+
+class SeriesData:
+    def __init__(self, name):
+        self.name = name
+        self.formations = None
+        self.relation = None
+        self.influenced_by_fault = None
+        self.potential_data = None
+
+
+class Pile:
+    def __init__(self, reference):
+        assert reference in {"top", "base"}
+        self.reference = reference
+        self.all_series = None
+
+    def __repr__(self):
+        lines = []
+        lines.append("pile (reference " + self.reference + ")")
+        for serie in self.all_series[::-1]:
+            lines.append(serie.name + " (" + serie.relation + ") ")
+            for formation in serie.formations[::-1]:
+                lines.append(" " * 2 + formation)
+        return "\n".join(lines)
+
+
+class CovarianceModel:
+    def __init__(self, xml_node, box):
+        """
+        Here's the magic.
+
+        In GeoModeller interpolation are performed in a rescaled box.
+        This affects the gradient nugget effect.
+        The variance used to compute the model is not exactly the one given by
+        the user...
+        42 is the Answer to the Ultimate Question of Life, the Universe,
+        and Everything but only for cubic covariances!
+        """
+        L = max(box[s + "max"] - box[s + "min"] for s in ("X", "Y", "Z"))
+        assert L > 0
+        d = xml_node.attrib  # attributes dictionnary
+        self.anisotropy_angles = np.array(
+            [np.double(d[s]) for s in ["anisotropyA1", "anisotropyA2", "anisotropyA3"]]
+        )
+        self.anisotropy_values = np.array(
+            [np.double(d[s]) for s in ["anisotropyV1", "anisotropyV2", "anisotropyV3"]]
+        )
+        # Type de covariance (cf. Potentiel.cdl)
+        self.covariance_model = {
+            0: "gauss",
+            1: "cubique",
+            2: "h4log",
+            3: "h3",
+            4: "penta",
+        }[int(d["covarianceModel"])]
+        assert self.covariance_model == "cubique", (
+            "Only cubic covariance models are handled!"
+        )
+        self.drift_order = int(d["degreDrift"])
+        self.isotropic = {"true": True, "false": False}[d["isotropic"]]
+        self.gradient_nugget = float(d["nuggetGradient"]) * (1 / L) ** 2
+        self.potential_nugget = float(d["nuggetPotentiel"])
+        self.range = R = float(d["range"])
+        gvar = float(d["gradient"])
+        assert gvar > 0
+        self.gradient_variance = ((R / L) ** 2 * gvar) / 42.0
+        self.tangent_variance = float(d["tangentVariance"])