cmflow 0.3.3.dev2__tar.gz → 0.4.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cmflow
-Version: 0.3.3.dev2
+Version: 0.4.0
 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

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

@@ -14,6 +14,8 @@ from cmflow.geom_surface_utils import geo_column_polygon
 
 import json
 import time
+import string
+import re
 
 START = [time.time()]
 def print_wall_time(msg, loop_stop=False, total=False):
@@ -25,14 +27,101 @@ 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)
+    ]
+
+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 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 +130,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 +148,263 @@ 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("\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.replace('0', '')
+
+        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, 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 characters:
+        - 2nd char (3rd char is zero) single fault
+        - 3rd char (combined with 2nd char as unique combination of faults)
+        """
+        if chars is None:
+            chars = string.ascii_uppercase + string.ascii_lowercase + string.digits[1:]
+        else:
+            chars.replace('0', '')
+
+        if fault_codes:
+            # some checks and remove used characters
+            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, '')
+            # 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)
+
+        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)))
+
+        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:
+                # three or more -> first fault code + nunique code
+                if not chars:
+                    need_more = len(combinations) - ii
+                    raise Exception(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
+
+        for litho in self.lf_lithos:
+            fid = combo_id(litho.faults)
+            litho.rocktype_fault = final_codes[fid]
+            litho.faults_sorted = fid
+
+        # create reverse index for general use (key has two characters)
+        rocktype_fault_index = {}
+        for fid, code in final_codes.items():
+            if code in rocktype_fault_index:
+                raise Exception(f"Should be unique")
+            rocktype_fault_index[code] = ", ".join(fid)
+        # sort the dict for nicer output
+        rocktype_fault_index = dict(sorted(rocktype_fault_index.items()))
+
+        # GMF contents for _dict_rocktype.json
+        rocktype_fault_gmf1, rocktype_fault_gmf2 = {'0':''}, {'0':''}
+        for fid, code in final_codes.items():
+            if len(fid) == 1:
+                rocktype_fault_gmf1[code[0]] = fid[0]
+            elif len(fid) >= 2:
+                rocktype_fault_gmf2[code[1]] = "Intersection " + ", ".join(fid[1:])
+        # sort the dict for nicer output
+        rocktype_fault_gmf1 = dict(sorted(rocktype_fault_gmf1.items()))
+        rocktype_fault_gmf2 = dict(sorted(rocktype_fault_gmf2.items()))
+        gmf_fault = {
+            "faults": {
+                "rank": [1],
+                "lengend": rocktype_fault_gmf1,
+                "direction": {f:None for f in rocktype_fault_gmf1.keys()},
+            },
+            "intersections": {
+                "rank": [2],
+                "lengend": rocktype_fault_gmf2,
+                "direction": {f:None for f in rocktype_fault_index.keys()},
+            },
+        }
+
         if report:
-            print('%8s Lithology found.' % len(self.litholist))
-            print('%8s Blocks allocated.' % len(self.blocklitho))
+            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(final_codes):>8} Total unique fault combinations found",
+                f"{len([fid for fid in final_codes.keys() if len(fid)==1]):>8} Single-fault combinations found",
+                f"{len([fid for fid in final_codes.keys() if len(fid)==2]):>8} Fault intersections found with 2 faults",
+                f"{len([fid for fid in final_codes.keys() if len(fid)>=3]):>8} Fault intersections found with 3 or more faults",
+                f"{max([len(fid) for fid in final_codes.keys()]):>8} Maximum number of fault intersect in one block",
+                ]) + "\n")
+
+        return rocktype_fault_index, gmf_fault
 
     def write(self, filename):
         with open(filename, 'w') as f:
@@ -80,6 +417,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 +429,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):