cmflow 0.3.3.dev2__tar.gz → 0.4.1__tar.gz

{cmflow-0.3.3.dev2 → cmflow-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cmflow
-Version: 0.3.3.dev2
+Version: 0.4.1
 Summary: Building TOUGH2/Waiwera models from layers of conceptual models
 Project-URL: Homepage, https://github.com/cyeh015/cmflow
 Project-URL: Source Code, https://github.com/cyeh015/cmflow
@@ -38,6 +38,94 @@ On Linux (Ubuntu shown here) these can be installed via apt-get:
     sudo apt-get install -y python-shapely
     sudo apt-get install -y python-rtree
 
+# Using Leapfrog Geological Models
+
+In Leapfrog Energy, it ispossible to generate rocktype in a Flow Model using a
+Geological Model.  This allows user to `Export Block Rock Types`, which
+generates a .csv file, containing block by block lithology and faults.  This
+csv file can be imported into a LeapfrogGM object.  These objects provide
+useful ways to access model block's lithology and faults as generated by
+Leapfrog Energy:
+
+```python
+from cmflow.conceptual_models import LeapfrogGM
+
+gm = LeapfrogGM()
+gm.import_leapfrog_csv('gAB12345_rocktypes.csv', report=True)
+
+litho = gm.lf_block['xyz12'] # Leapfrog assignment for block, as LeapfrogLitho
+print(litho.litho_name) # name used in Leapfrog .csv
+print(litho.faults) # faults that crosses the block
+print(litho.rock) # pure lithology/formation name
+
+```
+
+## Faults from Leapfrog
+
+It is also possible to automatically generate rocktype naming to be used in
+AUT2/Waiwera based on certain rules.  Here is an example that generate TWO
+letter codes that represents either no fault, single fault or multiple faults
+crossed a block.  By calling `.gmf_fault_rocktype_2L()`, a rocktype naming of
+faults are generated.
+
+This also adds extra LeapfrogLitho object properties such as `.rocktype_fault`
+and `.faults_sorted`.  They contain the TWO letter code and list of crossing
+faults respectively.
+
+```python
+gmf_fault = gm.gmf_fault_rocktype_2L(gm_def["faults"], report=True)
+
+code = gm.lf_block['xyz12'].rocktype_fault
+# TWO character code that can be used as part of the rocktype naming
+```
+
+The method `.gmf_fault_rocktype_2L()` also generates a `FaultRocktypes` object.
+FaultRocktypes serves as a central registry for the fault related rocktype
+naming convention.  This can be saved and loaded for alter use.  Ideally each
+fault should have a preset direction.  This can be done by `.set_directions
+()` which expects a mapping between the original Leapfrog Fault name
+(from .csv) and their directions.
+
+Now the object can workout any rocktype's fault direction by working through the
+faults exists ina particular rocktype.  If all faults going through a rocktype
+are with the same direction, that direction is used.  Otherwise it returns
+None.  The `FaultRocktypes` object can keep user specified directions.
+
+```python
+
+# sets single fault directions
+gmf_fault.set_directions({
+    "F1": 1,
+    "F2": 1,
+    "F3": 1,
+    "F4": 2,
+})
+
+print(gmf_fault.rocktype_faults)
+
+# {
+#     "A0": ("F1"),
+#     "AB": ("F1", "F2"),
+#     "AX": ("F1", "F2", "F3"),
+#     "AY": ("F1", "F2", "F4"),
+#     "D0": ("F4"),
+#     ...
+# }
+
+print(gmf_fault['AB'].faults)    # ('F1', 'F2')
+
+print(gmf_fault['A0'].direction) # 1
+print(gmf_fault['AX'].direction) # 1, because all faults uses 1
+print(gmf_fault['D0'].direction) # 2
+print(gmf_fault['AY'].direction) # None
+
+gmf_fault.set_rock_fault_dir('AY', 1) # user decides that this fault combo should be 1 anyways
+
+print(gmf_fault['AY'].direction) # 1
+
+```
+
+
 # Example
 
 Creates BMStats that can be used later, from Leapfrog Geology:

{cmflow-0.3.3.dev2 → cmflow-0.4.1}/README.md

@@ -15,6 +15,94 @@ On Linux (Ubuntu shown here) these can be installed via apt-get:
     sudo apt-get install -y python-shapely
     sudo apt-get install -y python-rtree
 
+# Using Leapfrog Geological Models
+
+In Leapfrog Energy, it ispossible to generate rocktype in a Flow Model using a
+Geological Model.  This allows user to `Export Block Rock Types`, which
+generates a .csv file, containing block by block lithology and faults.  This
+csv file can be imported into a LeapfrogGM object.  These objects provide
+useful ways to access model block's lithology and faults as generated by
+Leapfrog Energy:
+
+```python
+from cmflow.conceptual_models import LeapfrogGM
+
+gm = LeapfrogGM()
+gm.import_leapfrog_csv('gAB12345_rocktypes.csv', report=True)
+
+litho = gm.lf_block['xyz12'] # Leapfrog assignment for block, as LeapfrogLitho
+print(litho.litho_name) # name used in Leapfrog .csv
+print(litho.faults) # faults that crosses the block
+print(litho.rock) # pure lithology/formation name
+
+```
+
+## Faults from Leapfrog
+
+It is also possible to automatically generate rocktype naming to be used in
+AUT2/Waiwera based on certain rules.  Here is an example that generate TWO
+letter codes that represents either no fault, single fault or multiple faults
+crossed a block.  By calling `.gmf_fault_rocktype_2L()`, a rocktype naming of
+faults are generated.
+
+This also adds extra LeapfrogLitho object properties such as `.rocktype_fault`
+and `.faults_sorted`.  They contain the TWO letter code and list of crossing
+faults respectively.
+
+```python
+gmf_fault = gm.gmf_fault_rocktype_2L(gm_def["faults"], report=True)
+
+code = gm.lf_block['xyz12'].rocktype_fault
+# TWO character code that can be used as part of the rocktype naming
+```
+
+The method `.gmf_fault_rocktype_2L()` also generates a `FaultRocktypes` object.
+FaultRocktypes serves as a central registry for the fault related rocktype
+naming convention.  This can be saved and loaded for alter use.  Ideally each
+fault should have a preset direction.  This can be done by `.set_directions
+()` which expects a mapping between the original Leapfrog Fault name
+(from .csv) and their directions.
+
+Now the object can workout any rocktype's fault direction by working through the
+faults exists ina particular rocktype.  If all faults going through a rocktype
+are with the same direction, that direction is used.  Otherwise it returns
+None.  The `FaultRocktypes` object can keep user specified directions.
+
+```python
+
+# sets single fault directions
+gmf_fault.set_directions({
+    "F1": 1,
+    "F2": 1,
+    "F3": 1,
+    "F4": 2,
+})
+
+print(gmf_fault.rocktype_faults)
+
+# {
+#     "A0": ("F1"),
+#     "AB": ("F1", "F2"),
+#     "AX": ("F1", "F2", "F3"),
+#     "AY": ("F1", "F2", "F4"),
+#     "D0": ("F4"),
+#     ...
+# }
+
+print(gmf_fault['AB'].faults)    # ('F1', 'F2')
+
+print(gmf_fault['A0'].direction) # 1
+print(gmf_fault['AX'].direction) # 1, because all faults uses 1
+print(gmf_fault['D0'].direction) # 2
+print(gmf_fault['AY'].direction) # None
+
+gmf_fault.set_rock_fault_dir('AY', 1) # user decides that this fault combo should be 1 anyways
+
+print(gmf_fault['AY'].direction) # 1
+
+```
+
+
 # Example
 
 Creates BMStats that can be used later, from Leapfrog Geology:

{cmflow-0.3.3.dev2 → cmflow-0.4.1}/cmflow/conceptual_models.py

@@ -12,8 +12,11 @@ from cmflow.geom_3dface_utils import Face3D
 from cmflow.geom_surface_utils import get_columns_intersect_polygon
 from cmflow.geom_surface_utils import geo_column_polygon
 
+from dataclasses import dataclass
 import json
 import time
+import string
+import re
 
 START = [time.time()]
 def print_wall_time(msg, loop_stop=False, total=False):
@@ -25,14 +28,346 @@ def print_wall_time(msg, loop_stop=False, total=False):
     if loop_stop:
         START.append(t)
 
+def assign_chars(names, chars=string.ascii_uppercase):
+    """ Assign unique characters to each name.
+
+    Returns
+    -------
+    tuple(dict, str)
+        A mapping from name to assigned character, and the remaining
+        unused characters.
+    """
+    if len(names) > len(chars):
+        raise Exception("Not enough characters for names")
+    name_index = {n: chars[i] for i, n in enumerate(names)}
+    remaining_chars = chars[len(names):]
+    return name_index, remaining_chars
+
+def natural_key(text):
+    """ Convert text chunks and number chunks into a tuple of string
+    and int, useful for sorting strings naturally. eg.
+
+      data = ["F24", "F8", "F2", "F10"]
+      sorted_data = sorted(data, key=natural_key)
+      print(sorted_data)  # Output: ['F2', 'F8', 'F10', 'F24']
+    """
+    return [
+        int(c) if c.isdigit() else c.lower()
+        for c in re.split(r'(\d+)', text)
+    ]
+
+def remove_duplicate_chars(text: str) -> str:
+    """ Removes duplicate characters while preserving their original order. """
+    return "".join(dict.fromkeys(text))
+
+def unique_names(length, chars=None):
+    """ Generate fixed-length unique names using chars in their specified order
+    """
+    if length < 1:
+        raise ValueError("length must be positive")
+    if not chars:
+        chars = string.digits + string.ascii_uppercase + string.ascii_lowercase
+        chars.replace('0', '')
+
+    indices = [0] * length
+    while True:
+        yield ''.join(chars[i] for i in indices)
+
+        for i in reversed(range(length)):
+            indices[i] += 1
+            if indices[i] < len(chars):
+                break
+            indices[i] = 0
+        else:
+            return
+
+class LeapfrogLitho():
+    """ Block Lithology Output generated by Leapfrog Energy """
+    def __init__(self, litho_code, litho_name):
+        self.litho_code = litho_code # Leapfrog LithoCode
+        self.litho_name = litho_name # Leapfrog Lithology, exported name
+        # as parsed from .litho_name
+        self.faults = []
+        self.rock = None # pure formation/lithology name
+        self.parseLithoName()
+
+    def __repr__(self):
+        return f"LeapfrogLitho(code={self.litho_code}, name='{self.litho_name}', faults={self.faults}, rock='{self.rock}')"
+
+    def parseLithoName(self):
+        """ parse Leapfrog's Lithology names and determine the faults and pure
+        lithos
+
+        NOTE Leapfrog remove spaces from fault names, and then truncated into
+             7 characters, not counting other non-ASCII characters.  Lithology
+             names remain as they are in the Leapfrog project.
+
+        Observation:
+        - a string can have two parts separated by ', '
+        - if there is only a single part, then is pure litho (to be confirmed!?)
+        - if there are two parts, then they are faults and pure litho
+        - faults are one or more faults joined by '+'
+        - fault names are shorteded by removing spaces
+        """
+        parts = self.litho_name.split(', ')
+        if len(parts) == 1:
+            # As of 9 Aug 2026, I have never found any single part litho_name
+            # that contains a single fault by itself.  It is always:
+            #   - a pure rock lithi OR
+            #   - multiple faults joined by '+'
+            if '+' in parts[0]:
+                self.faults = parts[0].split('+')
+            else:
+                self.rock = parts[0]
+        elif len(parts) == 2:
+            self.faults = parts[0].split('+')
+            self.rock = parts[1]
+        else:
+            raise Exception("Unexpected Lithology name format: '%s'" % lf_litho)
+
+
+class MethodProxy:
+    """ A reusable proxy that maps dictionary syntax to any Python method.
+
+    eg.
+        For a class with methods get_value(key) and set_value(key, value), you
+        can create a proxy like this:
+            @property
+            def rock(self):
+                return MethodProxy(getter_method=self.get_rock,
+                                   setter_method=self.set_rock)
+        This enables use:
+            obj.rock['AB'] = 4
+            print(obj.rock['AB'])
+    """
+    def __init__(self, getter_method, setter_method=None,):
+        self._getter = getter_method
+        self._setter = setter_method
+
+    def __getitem__(self, key):
+        # Calls the passed-in getter method dynamically
+        return self._getter(key)
+
+    def __setitem__(self, key, value):
+        if self._setter is None:
+            raise TypeError("This property is read-only")
+        self._setter(key, value)
+
+@dataclass
+class FaultRocktype:
+    name: str
+    faults: tuple[str, ...] = () # tuple of zero or more Leapfrog fault names
+    direction: int | None = None  # 1 or 2 or None
+
+class FaultRocktypes:
+    """ obj that keeps fault info of created rocktypes (usually 2 chars in GMF)
+
+    As more information is loaded, the registery becomes more useful.
+
+    leapfrog name - names Leapfrog uses in the exported rocktype .csv
+    display name - user can have custom full name for display
+    rocktype name - characters (usually 2 in GMF) is the key used as part of rocktype naming
+
+    .set_rocktypes() expects a rocktype code map to tuples of fault leapfrog names
+    .set_directions() expects a dict mapping fault leapfrog names to int direction (or None)
+    .set_display_names() expects a dict mapping fault leapfrog names to display/full names
+    """
+    def __init__(self, leapfrog_names):
+        # initialise with a list of fault full names (as in)
+        self.lf_faults = leapfrog_names
+
+        self.display_name = {}
+        self.rocktype_faults = {}
+        self.fault_dir = {}
+
+        # normally rocktype fault direction are worked out using individual
+        # fault direction of faults in this rocktype, here user can overwrite
+        # specific rocktype direction
+        self.user_rocktype_dir = {} # user overwrite fault dir for combos
+
+    def __getitem__(self, rocktype_name):
+        """ convenience function to get a FaultRocktype object by rocktype name
+
+        Use:
+            a_faultrocktype['AB'].faults
+            a_faultrocktype['AB'].directions
+
+        """
+        if rocktype_name not in self.rocktype_faults:
+            raise KeyError(f"Rocktype {rocktype_name} not found in FaultRocktypes.")
+        return FaultRocktype(
+            name=rocktype_name,
+            faults=self.rocktype_faults[rocktype_name],
+            direction=self.get_rock_fault_dir(rocktype_name)
+        )
+
+    @property
+    def faults(self):
+        """ a list of leapfrog fault names """
+        return self.lf_faults
+
+    @property
+    def rocktypes(self):
+        """ a list rocktype names """
+        return list(self.rocktype_faults.keys())
+
+    @property
+    def fault_direction(self):
+        """ a dict of all leapfrog faults and their direction """
+        return self.fault_dir
+
+    def set_display_names(self, display_name):
+        """ display_name is a dict mapping leapfrog names to display/full names
+        """
+        self.display_name = display_name
+
+    def set_rocktypes(self, rock_table):
+        """ rock_table is dict mapping rocktype code to tuple of leapfrog fault names
+
+        This is usually constructed within something like .gmf_fault_rocktype_2L()
+        from LeapfrogGM object.
+        """
+        self.rocktype_faults = rock_table
+
+    def set_directions(self, fault_dir):
+        """ fault_dir is a dict mapping leapfrog names to int direction (or None)
+
+        Usually user should setup these manually.
+        """
+        for r,d in fault_dir.items():
+            if r not in self.lf_faults:
+                raise Exception(f"Fault {r} not found in FaultRocktypes.")
+            if d not in [1,2]:
+                raise Exception(f"Fault direction {d} for {r} must be 1 or 2.")
+        for f in self.lf_faults:
+            if f not in fault_dir:
+                raise Exception(f"Fault {f} not found in fault_dir, must specify direction.")
+        self.fault_dir = fault_dir
+
+    def get_rock_faults(self, rocktype_name, warn=False):
+        if not self.rocktype_faults and warn:
+            raise Exception("Fault table not set, see .set_rocktypes()")
+        return self.rocktype_faults.get(rocktype_name, None)
+
+    def set_rock_fault_dir(self, rocktype_name, direction):
+        """ update the direction of a rocktype
+
+        NOTE this is different from setting Leapfrog faults directions, see:
+             .set_directions()
+        """
+        if rocktype_name not in self.rocktype_faults:
+            raise Exception(f"Rocktype {rocktype_name} not found in FaultRocktypes.")
+        self.user_rocktype_dir[rocktype_name] = direction
+
+    def get_rock_fault_dir(self, rocktype_name, warn=False):
+        """ return the rocktype fault direction (computed)
+
+        Working out direction if not overwritten with self.user_rocktype_dir:
+          if single fault -> fault dir
+          if all faults same dir -> fault dir
+          if some faults not specified -> None
+          if intersected by faults with multiple direction -> None
+        """
+        if not self.fault_dir and warn:
+            raise Exception("Fault direction not set, see .set_directions()")
+        if not self.rocktype_faults and warn:
+            raise Exception("Fault table not set, see .set_rocktypes()")
+
+        # return user specified if specified
+        try:
+            return self.user_rocktype_dir[rocktype_name]
+        except KeyError:
+            pass
+
+        # otherwise work out by using individual faults
+        directions = [self.fault_dir.get(f, None) for f in self.rocktype_faults[rocktype_name]]
+        if len(directions) == 1:
+            return directions[0]
+        elif len(set(directions)) == 1:
+            return next(iter(directions))
+        else:
+            return None
+
+    def export_gmf_v0(self):
+        """ export a section of the GMF _dict_rocktypes.json that deals with
+            faults
+        """
+        # GMF contents for _dict_rocktype.json
+        gmf1, gmf2 = {'0':''}, {'0':''}
+        for rocktype, faults in self.rocktype_faults.items():
+            if len(faults) == 1:
+                gmf1[rocktype[0]] = faults[0]
+            elif len(faults) >= 2:
+                gmf2[rocktype[1]] = "Intersection " + ", ".join(rocktype[1:])
+        # sort the dict for nicer output
+        gmf1 = dict(sorted(gmf1.items()))
+        gmf2 = dict(sorted(gmf2.items()))
+        gmf_fault = {
+            "faults": {
+                "rank": [1],
+                "legend": gmf1,
+                "direction": {f:None for f in gmf1.keys()},
+                "color": {rt[:1]: None for rt, fs in self.rocktype_faults.items() if len(fs)==1},
+            },
+            "intersections": {
+                "rank": [2],
+                "legend": gmf2,
+                "direction": {rt:self.get_rock_fault_dir(
+                    rt, warn=False) for rt in self.rocktype_faults.keys()},
+            },
+        }
+        return gmf_fault
+
+    def export_gmf_convention(self, rank=[1, 2]):
+        """ export a section of the GMF _dict_rocktypes.json that deals with
+            faults
+
+        NOTE This is a proposed new _dict_rocktype.json format.  I think this
+             has a few advantages over the orginal (v0) format:
+             + less assumptions is made about convention
+             + flexibility for change in convention less likely to break toolchain
+             + more information can be logically stored
+        """
+        gmf_fault = {
+            "faults": {
+                "rank": rank, # default to [1,2] ie. 2nd and 3rd character
+                # WIP
+                "data": {
+                    "leapfrog_names": self.lf_faults,
+                    "display_names": self.display_name,
+                    "rocktype_faults": self.rocktype_faults,
+                    "fault_dir": self.fault_dir,
+                },
+                # framework needs extras
+                "legend": {rt: ", ".join(fs) for rt, fs in self.rocktype_faults.items()},
+                "color": {rt: None for rt, fs in self.rocktype_faults.items() if len(fs)==1},
+            },
+        }
+        return gmf_fault
+
+
 class LeapfrogGM(object):
+    """ Tough2 Block Lithology Output generated by Leapfrog Energy (.csv)
+
+    .lithocodes is a list of leapfrog litho codes as ordered in the .csv
+    .litholist is a list of leapfrog litho names as ordered in the .csv
+    .blocklist is a dict of blocks with value of index for accessing .litholist
+
+    """
     def __init__(self, geometry=''):
         super(LeapfrogGM, self).__init__()
+        self.lithocodes = []
         self.litholist = []
         self.blocklitho = {}
         self.import_from = '' # optional, if imported from leapfrog
         self.geometry = geometry # optional, matching mulgrid geometry file
 
+        # the following provides parsed info of the Leapfrog GM
+        self.lf_lithos = [] # list of LeapfrogLitho objects (ordered as litholist)
+        self.lf_block = {} # access LeapfrogLitho objects by block name
+        self.rocks = [] # sorted pure lithos found
+        self.faults = [] # sorted faults found
+
     def import_leapfrog_csv(self, filename, report=False):
         """ load geology info from Leapfrog's 'Generate rock types' feature.  The
         .csv file from Leapfrog usually starts with a table of 'LithoCode,Lithology'
@@ -41,9 +376,11 @@ class LeapfrogGM(object):
         import csv
         f = open(filename,'r')
         allrows = csv.reader(f)
-        lithocodes, self.litholist = {}, []
+        self.lithocodes = []
+        self.litholist = []
         self.blocklitho = {}
         # TODO: this file reading is ugly, need work
+        code_index = {}
         read_litho_name, read_block_litho = False, False
         for row in allrows:
             if len(row) == 1: continue
@@ -57,17 +394,275 @@ class LeapfrogGM(object):
                     read_block_litho = True
                     continue
             if read_litho_name:
-                if not row[0] == '#': raise Exception
+                if row[0] != '#': raise Exception
+                self.lithocodes.append(row[1])
                 self.litholist.append(row[2])
-                lithocodes[int(row[1])] = len(self.litholist)-1
+                code_index[int(row[1])] = len(self.litholist)-1
             if read_block_litho:
                 if len(row) != 2: break
-                self.blocklitho[row[0]] = lithocodes[int(row[1])]
+                self.blocklitho[row[0]] = code_index[int(row[1])]
         f.close()
         self.import_from = filename
+
+        self.parse_lithology()
+
         if report:
-            print('%8s Lithology found.' % len(self.litholist))
-            print('%8s Blocks allocated.' % len(self.blocklitho))
+            print("\n".join([
+                f"Loaded from file: {self.import_from}:",
+                f"{len(self.lf_lithos):>8} Leapfrog LithoCode",
+                f"{len(self.lf_block):>8} Blocks allocated",
+                f"{len(self.lf_faults):>8} Faults found",
+                f"{len(self.lf_rocks):>8} Pure rocks (lithos) found",
+                ]) + "\n")
+
+    def parse_lithology(self):
+        """ parse Leapfrog's Lithology names and determine the faults and pure
+        lithos
+
+        Returns a list of lithology and a list of faults.
+
+        """
+        self.lf_lithos = [] # list of LeapfrogLitho objects (ordered as litholist)
+        self.lf_block = {} # access LeapfrogLitho objects by block name
+        for code, name in zip(self.lithocodes, self.litholist):
+            lf_litho = LeapfrogLitho(code, name)
+            self.lf_lithos.append(lf_litho)
+        for block, idx in self.blocklitho.items():
+            self.lf_block[block] = self.lf_lithos[idx]
+
+        # compile lists of faults and pure (litho) rocks
+        rocks, faults = set(), set()
+        for litho in self.lf_lithos:
+            if litho.rock is not None:
+                rocks.add(litho.rock)
+            faults.update(litho.faults)
+        self.lf_rocks = sorted(rocks, key=natural_key)
+        self.lf_faults = sorted(faults, key=natural_key)
+
+        for f in self.lf_faults:
+            if f in self.lf_rocks:
+                raise Exception(f"Fault {f} also found in pure litho list")
+        for r in self.lf_rocks:
+            if r in self.lf_faults:
+                raise Exception(f"Pure litho {r} also found in fault list")
+
+        return self.lf_rocks, self.lf_faults
+
+    def gmf_litho_rocktype_1L(self, litho_codes={}, chars=None, ignore=None,
+        report=False):
+        """ Generates GMF style rocktype names (length of 1) based on lithologies.
+        Returns a dict of mapping from GMF rocktype name to Leapfrog lithology(s).
+
+        litho_codes is a user-defined dict with keys and values a single char.
+        The order is important, will affect how the final names are sorted.
+        If not specified, the names will be sorted *naturally*.  Multiple litho
+        names mapping to the same code is allowed (i.e. merging rocktypes).
+
+        chars is a string containing possible characters to use.  NOTE '0' is
+        special in GMF and is reserved, it will be removed from user's chars.
+
+        It is possible to ignore certain lithology by sepcifying names in ignore
+        list.  Note that they will produce GMF rocktype '0'.  There is a default
+        set of ignored litho names, if you want to include them, you will have
+        to set ignore=[].
+
+        Each block's rocktype code (length=1) can be accessed by:
+            GM.lf_block[block_name].rocktype_litho
+        """
+        if chars is None:
+            chars = string.ascii_uppercase + string.ascii_lowercase + string.digits[1:]
+        else:
+            chars = chars.replace('0', '')
+            chars = remove_duplicate_chars(chars)
+
+        default_ignore = [None, 'Water', 'Unknown', 'Outside Geological Model']
+        if ignore is None:
+            ignore = [ig for ig in default_ignore if ig in self.lf_rocks]
+        else:
+            ignore = [ig for ig in ignore if ig in self.lf_rocks]
+
+        if litho_codes:
+            # some checks and remove used characters
+            for l,c in litho_codes.items():
+                if l in ignore and c != '0':
+                    print(f"Warning: ignoring lithology {l}, "
+                          f"overwrite user-defined litho_codes '{c}' -> '0'")
+                if len(c) != 1:
+                    raise Exception(f"Lithology code for {l} must be a single character")
+                if l not in self.lf_rocks:
+                    raise Exception(f"Lithology {l} not found in Leapfrog lithologies list")
+                chars = chars.replace(c, '')
+
+        for ig in ignore:
+            litho_codes[ig] = '0'
+
+        # deal with all other rocks not specified by user
+        remaining_rocks = [r for r in self.lf_rocks if r not in litho_codes]
+        new_litho_codes, chars = assign_chars(sorted(remaining_rocks, key=natural_key), chars)
+        litho_codes.update(new_litho_codes)
+
+        # keep as a property of LeapfrogLitho object
+        for litho in self.lf_lithos:
+            if litho.rock is None:
+                litho.rocktype_litho = '0'
+            else:
+                litho.rocktype_litho = litho_codes[litho.rock]
+
+        # create reverse index for GMF
+        rocktype_litho_index = {}
+        for name, rt in litho_codes.items():
+            if rt not in rocktype_litho_index:
+                rocktype_litho_index[rt] = name
+            else:
+                rocktype_litho_index[rt] += ", " + name
+        # sort the dict for nicer output
+        rocktype_litho_index = dict(sorted(rocktype_litho_index.items()))
+
+        # GMF contents for _dict_rocktype.json
+        gmf_litho = {
+            "rank": [0],
+            "legend": rocktype_litho_index,
+        }
+
+        if report:
+            print()
+            for code, names in rocktype_litho_index.items():
+                print(f"{code} -> {names}")
+            print()
+
+        return rocktype_litho_index, gmf_litho
+
+    def gmf_fault_rocktype_2L(self, fault_codes={}, chars=None,
+        arbitrary_if_3plus=False, report=False):
+        """ Generates GMF style rocktype names (length of 2) based on faults.
+        Returns a dict of mapping from GMF rocktype name to tuple of faults.
+
+        fault_code is a user-defined dict with keys and values a single char.
+        The order is important, will affect how the final names are sorted.
+        If not specified, the names will be sorted *naturally*.
+
+        chars is a string containing possible characters to use.  NOTE '0' is
+        special in GMF and is reserved, it will be removed from user's chars.
+
+        GMF uses two chars (usually 2nd and 3rd in the TOUGH-style 5 chars name)
+        - 2nd char (3rd char is zero) single fault
+        - 3rd char (combined with 2nd char as unique combination of faults)
+
+        It may be tricky to have descriptive naming when there are many
+        combinations with more than 3 faults.  By default, attempt is made by
+        keeping the first character as the first fault code, and the second
+        character is a unique char that is not used by any single fault.
+        However there may not be enough available charactrers.  In that case,
+        arbitrary_if_3plus can be set to True or a list of chars to use for
+        generating arbitrary 2-char unique names.
+        """
+        if chars is None:
+            chars = string.ascii_uppercase + string.ascii_lowercase + string.digits[1:]
+        else:
+            chars = chars.replace('0', '')
+            chars = remove_duplicate_chars(chars)
+
+        if fault_codes:
+            # some checks and remove used characters
+            used = []
+            for f,c in fault_codes.items():
+                if c == '0':
+                    raise Exception(f"Fault code for {f} cannot be '0'")
+                if len(c) != 1:
+                    raise Exception(f"Fault code for {f} must be a single character")
+                if f not in fault_codes:
+                    raise Exception(f"Fault {f} not found in Leapfrog faults list")
+                chars = chars.replace(c, '')
+                if c in used:
+                    raise Exception(f"Fault code '{c}' for {f} is already used")
+                used.append(c)
+            # tolerate if user only specifies some of the faults
+            remaining_lf_faults = [f for f in self.lf_faults if f not in fault_codes]
+            new_fault_codes, chars = assign_chars(sorted(remaining_lf_faults, key=natural_key), chars=chars)
+            fault_codes.update(new_fault_codes)
+        else:
+            fault_codes, chars = assign_chars(sorted(self.lf_faults, key=natural_key), chars=chars)
+
+        name_generator = None
+        if arbitrary_if_3plus:
+            if arbitrary_if_3plus is True:
+                arbitrary_if_3plus = string.digits[1:] + string.ascii_lowercase + string.ascii_uppercase
+            arbitrary_if_3plus = arbitrary_if_3plus.replace('0', '')
+            # remove already used fault-specific codes
+            for c in fault_codes.values():
+                chars = chars.replace(c, '')
+            name_generator = unique_names(length=2, chars=arbitrary_if_3plus)
+
+        fault_rank = {name: idx for idx, name in enumerate(fault_codes)}
+
+        # sort combinations: by num of faults, then by ranking of 1st fault, then 2nd...
+        def combo_id(items):
+            # id (a tuple of faults) is also ordered by rank
+            return tuple(sorted(items, key=lambda x: fault_rank.get(x, 0)))
+        # sorting the faults to ensure unique fault sets
+        combinations = list({combo_id(c.faults) for c in self.lf_lithos})
+        # sort by combo length, then by rank sequentially in combo
+        combinations = sorted(combinations, key=lambda x: (len(x), tuple(fault_rank[y] for y in x)))
+
+        if report:
+            print("\n".join([
+                f"Generating GMF fault names:",
+                f"{len(self.lf_lithos):>8} Leapfrog LithoCode",
+                f"{len(self.lf_faults):>8} Faults found",
+                f"{len(combinations):>8} Total unique fault combinations found",
+                f"{len([c for c in combinations if len(c)==1]):>8} Single-fault combinations found",
+                f"{len([c for c in combinations if len(c)==2]):>8} Fault intersections found with 2 faults",
+                f"{len([c for c in combinations if len(c)>=3]):>8} Fault intersections found with 3 or more faults",
+                f"{max([len(c) for c in combinations]):>8} Maximum number of fault intersect in one block",
+                ]) + "\n")
+
+        final_codes = {}
+        for ii,fid in enumerate(combinations):
+            if len(fid) == 0:
+                final_codes[fid] = '00'
+            elif len(fid) == 1:
+                # single item ones first -> fault code + '0'
+                final_codes[fid] = fault_codes[fid[0]] + '0'
+            elif len(fid) == 2:
+                # two items combo -> first + second
+                final_codes[fid] = ''
+                for fault in fid:
+                    final_codes[fid] += fault_codes[fault]
+            else:
+                if name_generator:
+                    # use arbitrary/opaque names for 3 or more faults (allow many more combos)
+                    try:
+                        final_codes[fid] = next(name_generator)
+                    except StopIteration:
+                        raise RuntimeError("Not enough characters for remaining fault combinations,")
+                else:
+                    # three or more -> first fault code + nunique code
+                    if not chars:
+                        need_more = len(combinations) - ii
+                        raise RuntimeError(f"Not enough characters for remaining fault combinations,"
+                                           f" need {need_more} more.")
+                    code = chars[0]
+                    chars = chars[1:]
+                    final_codes[fid] = fault_codes[fid[0]] + code
+
+        # useful properties added to LeapfrogLitho objects
+        for litho in self.lf_lithos:
+            fid = combo_id(litho.faults)
+            litho.rocktype_fault = final_codes[fid] # eg. 'AB', 'A0', '00'
+            litho.faults_sorted = fid # eg. ('Fault1', 'Fault2')
+
+        # create reverse index for general use (key has two characters)
+        rocktype_index = {}
+        for faults, rocktype_name in final_codes.items():
+            if rocktype_name in rocktype_index:
+                raise Exception(f"Rocktype Name should be unique, {rocktype_name} repeated")
+            rocktype_index[rocktype_name] = faults
+
+        # create FaultRocktypes object to return
+        fault_rocktypes = FaultRocktypes(self.lf_faults)
+        fault_rocktypes.set_rocktypes(rocktype_index)
+
+        return fault_rocktypes
 
     def write(self, filename):
         with open(filename, 'w') as f:
@@ -80,6 +675,8 @@ class LeapfrogGM(object):
                 "geometry" : self.geometry,
                 "zones": self.litholist,
                 "blocks": self.blocklitho,
+                # Non standard field, for LeapfrogGM only
+                "import_litho_codes": self.lithocodes,
             }
             json.dump(data, f, indent=4, sort_keys=True)
 
@@ -90,6 +687,9 @@ class LeapfrogGM(object):
             self.geometry = data['geometry']
             self.litholist = data['zones']
             self.blocklitho = data['blocks']
+            # Non standard field, for LeapfrogGM only
+            self.lithocodes = data["import_litho_codes"]
+            self.parse_lithology()
 
 class CM(object):
     def populate_model(self, np_dtype):

{cmflow-0.3.3.dev2 → cmflow-0.4.1}/cmflow/t2data_utils.py

@@ -296,7 +296,7 @@ def update_rocktype_bycopy(dat, blk_names, to_rocktype, convention='++***'):
         else:
             dat.grid.block[b].rocktype = dat.grid.rocktype[r_name]
 
-def update_block_geology(dat, blk_name, rock_name):
+def update_block_geology(dat, blk_name, rock_name, report=False):
     """ only updates the block's rocktype name.  rock_name is a 5 chars string,
     can contain '+' character to indicate preservin that part of name.  If the
     final rocktype name does not exist in dat.grid, it will be created by
@@ -322,7 +322,8 @@ def update_block_geology(dat, blk_name, rock_name):
         new_rock.name = new_rock_name
         dat.grid.add_rocktype(new_rock)
         dat.grid.block[blk_name].rocktype = new_rock
-        print('      new rocktype added: ', new_rock_name)
+        if report:
+            print('      new rocktype added: ', new_rock_name)
     return new_rock_name
 
 def setup_rockless(grid, base_rocktype=None, atm_rocktype=None):