cmflow 0.3.3__tar.gz → 0.3.3.dev2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cmflow
-Version: 0.3.3
+Version: 0.3.3.dev2
 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 → cmflow-0.3.3.dev2}/cmflow/conceptual_models.py

@@ -14,8 +14,6 @@ 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):
@@ -27,34 +25,6 @@ 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 LeapfrogGM(object):
     def __init__(self, geometry=''):
         super(LeapfrogGM, self).__init__()
@@ -99,170 +69,6 @@ class LeapfrogGM(object):
             print('%8s Lithology found.' % len(self.litholist))
             print('%8s Blocks allocated.' % len(self.blocklitho))
 
-    def parse_lithology_names(self):
-        """ parse Leapfrog's Lithology names and determine the faults and pure
-        lithos
-
-        Returns a list of lithology and a list of faults.
-
-        NOTE Leapfrog remove spaces from fault names, and then truncated into
-             7 characters.  (Lithology names remain.)
-
-        Observation:
-        - a string can have two parts separated by ', '
-        - if there is only a single part, then it can be pure litho OR faults
-        - 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
-        """
-        if len(self.litholist) == 0:
-            return
-
-        faults, rocks = [], []
-        self.litho_fault_combos = []
-        for lf_litho in self.litholist:
-            parts = lf_litho.split(', ')
-            if len(parts) == 1:
-                if '+' in parts[0]:
-                    fault_parts = parts[0].split('+')
-                    for fault in fault_parts:
-                        if fault not in faults:
-                            faults.append(fault)
-                    self.litho_fault_combos.append(fault_parts)
-                else:
-                    if parts[0] not in rocks:
-                        rocks.append(parts[0])
-                    self.litho_fault_combos.append([])
-
-            elif len(parts) == 2:
-                fault_parts = parts[0].split('+')
-                for fault in fault_parts:
-                    if fault not in faults:
-                        faults.append(fault)
-                self.litho_fault_combos.append(fault_parts)
-
-                if parts[1] not in rocks:
-                    rocks.append(parts[1])
-            else:
-                raise Exception("Unexpected Lithology name format: '%s'" % lf_litho)
-
-        for f in faults:
-            if f in rocks:
-                raise Exception(f"Fault {f} also found in pure litho list")
-        for r in rocks:
-            if r in faults:
-                raise Exception(f"Pure litho {r} also found in fault list")
-
-        self._lf_rocks = sorted(rocks)
-        self._lf_faults = sorted(faults)
-        return self._lf_rocks, self._lf_faults
-
-    def gmf_litho_rocktype_1L(self, litho_codes={}, chars=None, report=False):
-        """ Generates GMF style rocktype names (length of 1) based on lithologies.
-        Returns a dict of mapping from Leapfrog lithology name to GMF rocktype name.
-
-        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*.
-        """
-        if not chars:
-            chars = string.ascii_uppercase + string.ascii_lowercase + string.digits[1:]
-
-        if litho_codes:
-            # some checks and remove used characters
-            for l,c in litho_codes.items():
-                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, '')
-            # tolerate if user only specifies some of the lithologies
-            remaining_lf_rocks = [r for r in self._lf_rocks if r not in litho_codes]
-            new_litho_codes, chars = assign_chars(sorted(remaining_lf_rocks, key=natural_key), chars)
-            litho_codes.update(new_litho_codes)
-        else:
-            litho_codes, chars = assign_chars(sorted(self._lf_rocks, key=natural_key), chars)
-
-        if report:
-            print(f"{len(self.litholist):>8} Leapfrog LithoCode\n"
-                  f"{len(litho_codes):>8} Lithology\n")
-            print()
-            for name, code in litho_codes.items():
-                print(f"{code} -> {name}")
-            print()
-            print(litho_codes)
-
-        return litho_codes
-
-    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 tuple of faults to GMF rocktype name.
-
-        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*.
-
-        GMF uses:
-        - 2nd char (3rd char is zero) single fault
-        - 3rd char (combined with 2nd char as unique combination of faults)
-        """
-        if not chars:
-            chars = string.ascii_uppercase + string.ascii_lowercase
-            chars += string.digits[1:] # take out zero because it means no fault
-
-        if fault_codes:
-            # some checks and remove used characters
-            for f,c in fault_codes.items():
-                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)))
-        combinations = list({combo_id(c) for c in self.litho_fault_combos if c})
-        combinations = sorted(combinations, key=lambda x: (len(x), tuple(fault_rank[y] for y in x)))
-        if report:
-            print(f"{len(self.litho_fault_combos):>8} Leapfrog LithoCode\n"
-                  f"{len(self._lf_faults):>8} Faults\n"
-                  f"{len(combinations):>8} Fault combinations\n")
-
-        final_codes = {}
-        for ci,fid in enumerate(combinations):
-            if 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) - ci
-                    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
-            if report:
-                # print(f"{fid} -> {final_codes[fid]}")
-                print(f"{final_codes[fid]} -> ({len(fid)}) {fid}")
-
-        return final_codes
-
     def write(self, filename):
         with open(filename, 'w') as f:
             data = {