gimu 0.4.0__py3-none-any.whl

gimu/gmf/modifier.py

@@ -0,0 +1,129 @@
+""" handle GMF's modifier files that update model inputs with meta- parameters
+
+- reads rocktype JSON and update model input
+- reads upflow JSON and update model input
+"""
+
+import json
+import os
+import sys
+
+def compute_rocktypes(rocktype_json, warn=True):
+    """ compute the derived rocktype properties and update in place
+
+    if warn, will raise exception when rules are not followed:
+        - along modifier >= 1.0
+        - across modifier <= 1.0
+
+    Example entry in rocktype_json:
+    - base rocktype
+        "A0000": {
+          "permeability": [1e-11, 1e-11, 1e-12 ],
+          "porosity": [0.25 ]
+        },
+
+    - fault modified rocktype
+        "AA000": {
+          "base": ["A0000"],
+          "fault direction": [1],
+          "modifier": {
+            "along": [1],
+            "across": [1],
+            "vertical": [1],
+            "porosity": [1]
+          },
+          "permeability": [1e-11, 1e-11, 1e-12],
+          "porosity": [0.25]
+        },
+
+    - fault interesection rocktype
+        "SVU11": {
+          "base": ["S0011"],
+          "modifier": {
+            "k1": [2.5],
+            "k2": [0.4],
+            "k3": [5],
+            "porosity": [1]
+          },
+          "permeability": [2.5000000000000004e-15, 4.0000000000000004e-16, 5.000000000000001e-15],
+          "porosity": [0.1]
+        }
+
+    """
+    for rt_name, rt in rocktype_json.items():
+        if 'base' not in rt:
+            # base rocktype
+            pass
+        else:
+            if 'fault direction' in rt:
+                fault_dir = rt['fault direction'][0]
+                if float(rt['modifier']['along'][0]) < 1.0:
+                    msg = f"Rocktype {rt_name} has fault modifier 'along' < 1.0"
+                    if warn: raise Exception(msg)
+                    else: print("Warning: " + msg)
+                if float(rt['modifier']['across'][0]) > 1.0:
+                    msg = f"Rocktype {rt_name} has fault modifier 'across' > 1.0"
+                    if warn: raise Exception(msg)
+                    else: print("Warning: " + msg)
+                if fault_dir == 1:
+                    k_modifier = [
+                        float(rt['modifier']['along'][0]),
+                        float(rt['modifier']['across'][0]),
+                        float(rt['modifier']['vertical'][0]),
+                    ]
+                elif fault_dir == 2:
+                    k_modifier = [
+                        float(rt['modifier']['across'][0]),
+                        float(rt['modifier']['along'][0]),
+                        float(rt['modifier']['vertical'][0]),
+                    ]
+                else:
+                    raise Exception(f"Fault direction {rt['fault direction'][0]} not 1 or 2 in rocktype {rt_name}")
+            else:
+                k_modifier = [
+                    float(rt['modifier']['k1'][0]),
+                    float(rt['modifier']['k2'][0]),
+                    float(rt['modifier']['k3'][0]),
+                ]
+            # update permeability in place
+            if rt['base'][0] in rocktype_json:
+                rt['permeability'] = [k * m for k, m in zip(
+                    rocktype_json[rt['base'][0]]['permeability'], k_modifier)]
+                rt['porosity'][0] = rocktype_json[rt['base'][0]]['porosity'][0] * rt['modifier']['porosity'][0]
+            else:
+                msg = f"Base rocktype {rt['base'][0]} not found for rocktype {rt_name}"
+                if warn:
+                    raise Exception(msg)
+                else:
+                    print("Warning: " + msg)
+                    rt['error'] = msg
+
+
+def update_waiwera_model_rocktypes(wjson, rtjson, skip_missing=True):
+    """ rtjson is loaded from the GMF modifier _rocktypes.json
+    """
+    for rt in wjson['rock']['types']:
+        if rt['name'] not in rtjson:
+            if skip_missing:
+                print(f"Rocktype {rt['name']} not found in _rocktypes.json... skipped")
+                continue
+            else:
+                raise Exception(f"Rocktype {rt['name']} not found in _rocktypes.json")
+        modifier = rtjson[rt['name']]
+        rt['permeability'] = modifier['permeability']
+        rt['porosity'] = modifier['porosity'][0]
+
+def update_aut2_model_rocktypes(dat, rtjson, skip_missing=True):
+    """ rtjson is loaded from the GMF modifier _rocktypes.json
+    """
+    for rt in dat.grid.rocktypelist:
+        if rt.name not in rtjson:
+            if skip_missing:
+                print(f"Rocktype {rt.name} not found in _rocktypes.json... skipped")
+                continue
+            else:
+                raise Exception(f"Rocktype {rt.name} not found in _rocktypes.json")
+        modifier = rtjson[rt.name]
+        rt.permeability = modifier['permeability']
+        rt.porosity = modifier['porosity'][0]
+

gimu/project_cli.py

@@ -0,0 +1,56 @@
+import importlib.metadata
+from pathlib import Path
+from pprint import pprint
+import sys
+
+try:
+    import tomllib  # Python ≥3.11
+except ImportError:
+    import tomli as tomllib  # Python <3.11
+
+def get_distribution():
+    top_pkg = __package__.split('.')[0] if __package__ else None
+    if top_pkg:
+        try:
+            return importlib.metadata.distribution(top_pkg)
+        except importlib.metadata.PackageNotFoundError:
+            pass
+    return None
+
+def get_project_meta():
+    """ return pyproject.toml [project] """
+    current_file = Path(__file__).resolve()
+    for parent in [current_file.parent] + list(current_file.parents):
+        pyproject = parent / "pyproject.toml"
+        if pyproject.exists():
+            with open(pyproject, "rb") as f:
+                data = tomllib.load(f)
+            return data.get("project", {})
+    return None
+
+def show_help():
+    dist = get_distribution()
+    name = dist.metadata['Name']
+    version = dist.metadata['Version']
+    description = dist.metadata['Summary']
+    commands = [ep.name for ep in dist.entry_points]
+
+    # meta = get_project_meta()
+    # name = meta['name']
+    # description = meta['description']
+
+    msg = '\n'.join([
+        f"",
+        f"    {name} - {description}",
+        f"",
+        f"    Version: {version}",
+        f"",
+        f"    Available commands:",
+    ] + ["        " + cmd for cmd in sorted(commands)] + [
+        f"",
+        f"    e.g.:",
+        f"        save2incon model_1.save model_2.incon",
+        f"",
+    ])
+    print(msg)
+

gimu/save2incon.py

@@ -0,0 +1,30 @@
+""" use: save2incon a.save b.incon [-reset_kcyc] """
+
+from sys import *
+from t2incons import *
+
+def main():
+    if len(argv) < 2:
+        print('use: save2incon a.save b.incon [-reset_kcyc] [-reset_porosity]')
+        exit(1)
+
+    readFrom = argv[1]
+    saveTo = argv[2]
+
+    if len(argv) > 3:
+        opts = argv[3:]
+    else:
+        opts = []
+    inc = t2incon(readFrom)
+
+    for opt in opts:
+        if opt == '-reset_kcyc':
+            inc.timing['kcyc'] = 1
+            inc.timing['iter'] = 1
+        if opt == '-reset_porosity':
+            inc.porosity = None
+
+    inc.write(saveTo)
+
+if __name__ == '__main__':
+    main()

gimu/t2listingh5.py

@@ -0,0 +1,375 @@
+"""
+Copyright 2013, 2014 University of Auckland.
+
+This file is part of TIM (Tim Isn't Mulgraph).
+
+    TIM is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    TIM is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with TIM.  If not, see <http://www.gnu.org/licenses/>.
+"""
+
+"""
+Wrap AUTOUGH2's hdf5 output as t2listing
+"""
+
+import h5py
+import numpy as np
+
+from t2listing import *
+# from t2listing import listingtable
+from mulgrids import fix_blockname, unfix_blockname
+
+from pprint import pprint as pp
+import unittest
+
+class h5table(listingtable):
+    """ Class emulating the listingtable class in PyTOUGH.
+
+    Class for table in listing file, with values addressable by index (0-based)
+    or row name, and column name: e.g. table[i] returns the ith row (as a
+    dictionary), table[rowname] returns the row with the specified name, and
+    table[colname] returns the column with the specified name.
+
+    !!! IMPORTANT !!!
+    .index needs to be set whenever listing object changed time index
+    """
+    def __init__(self, cols, rows, h5_table,
+                 num_keys = 1, allow_reverse_keys = False,
+                 index = 0):
+        """ The row_format parameter is a dictionary with three keys,
+        'key','index' and 'values'.  These contain the positions, in each row of
+        the table, of the start of the keys, index and data fields.  The
+        row_line parameter is a list containing, for each row of the table, the
+        number of lines before it in the listing file, from the start of the
+        table.  This is needed for TOUGH2_MP listing files, in which the rows
+        are not in index order and can also be duplicated.
+
+        h5_table should be the table within the h5 file.
+        """
+        self.column_name = cols
+        self.row_name = rows
+        self.num_keys = num_keys
+        self.allow_reverse_keys = allow_reverse_keys
+        self._col = dict([(c,i) for i,c in enumerate(cols)])
+        self._row = dict([(r,i) for i,r in enumerate(rows)])
+        self._h5_table = h5_table
+        self._index = index # time index
+
+    def __repr__(self):
+        # h5 table lst._h5['element'][time index, eleme index, field index]
+        return repr(self.column_name) + '\n' + repr(self._h5_table[self._index, :, :])
+
+    def __getitem__(self, key):
+        if isinstance(key, int):
+            return dict(zip(['key'] + self.column_name, [self.row_name[key]] +
+                            list(self._h5_table[self._index, key, :])))
+        else:
+            if key in self.column_name:
+                return self._h5_table[self._index, :, self._col[key]]
+            elif key in self.row_name:
+                rowindex = self._row[key]
+                return dict(zip(['key'] + self.column_name,
+                                [self.row_name[rowindex]] +
+                                list(self._h5_table[self._index, rowindex, :])))
+            elif len(key) > 1 and self.allow_reverse_keys:
+                revkey = key[::-1] # try reversed key for multi-key tables
+                if revkey in self.row_name:
+                    rowindex = self._row[revkey]
+                    return dict(zip(['key'] + self.column_name,
+                                    [self.row_name[rowindex][::-1]] +
+                                    list(-self._h5_table[self._index, rowindex, :])))
+            else: return None
+
+    def __add__(self, other):
+        raise NotImplementedError
+        """Adds two listing tables together."""
+        if self.column_name == other.column_name and self.row_name == other.row_name:
+            from copy import copy
+            result = listingtable(copy(self.column_name), copy(self.row_name), num_keys = self.num_keys,
+                                  allow_reverse_keys = self.allow_reverse_keys)
+            result._data = self._data + other._data
+            return result
+        else: raise Exception("Incompatible tables: can't be added together.")
+
+    def __sub__(self, other):
+        raise NotImplementedError
+        """Subtracts one listing table from another."""
+        if self.column_name == other.column_name and self.row_name == other.row_name:
+            from copy import copy
+            result = listingtable(copy(self.column_name), copy(self.row_name), num_keys = self.num_keys,
+                                  allow_reverse_keys = self.allow_reverse_keys)
+            result._data = self._data - other._data
+            return result
+        else: raise Exception("Incompatible tables: can't be subtracted.")
+
+
+class t2listingh5(object):
+    def __init__(self, filename):
+        """
+        """
+        self._table = {}
+        self._h5 = h5py.File(filename, 'r')
+        self.filename = filename
+        self.setup()
+        self.simulator = 'AUTOUGH2_H5'
+
+    def setup(self):
+        self.fulltimes = self._h5['fulltimes']['TIME']
+        self.num_fulltimes = len(self.fulltimes)
+        self._index = 0 # this is the internal one
+        ### element table
+        if 'element' in self._h5:
+            cols = [str(x.decode("utf-8")) for x in self._h5['element_fields']]
+            blocks = [fix_blockname(str(x.decode("utf-8"))) for x in self._h5['element_names']]
+            table = h5table(cols, blocks, self._h5['element'], num_keys=1)
+            self._table['element'] = table
+        ### connection table
+        if 'connection' in self._h5:
+            cols = [str(x.decode("utf-8") ) for x in self._h5['connection_fields'][:]]
+            b1 = [fix_blockname(str(x.decode("utf-8"))) for x in self._h5['connection_names1'][:]]
+            b2 = [fix_blockname(str(x.decode("utf-8"))) for x in self._h5['connection_names2'][:]]
+            table = h5table(cols, [(b1,b2) for b1, b2 in zip(b1,b2)], self._h5['connection'], num_keys=2,
+                            allow_reverse_keys=True)
+            self._table['connection'] = table
+        ### generation table
+        if 'generation' in self._h5:
+            cols = [str(x.decode("utf-8")) for x in self._h5['generation_fields'][:]]
+            blocks = [fix_blockname(str(x.decode("utf-8"))) for x in self._h5['generation_eleme'][:]]
+            geners = [fix_blockname(str(x.decode("utf-8"))) for x in self._h5['generation_names'][:]]
+            table = h5table(cols, [(b,g) for b,g in zip(blocks,geners)], self._h5['generation'], num_keys=1)
+            self._table['generation'] = table
+        # makes tables in self._table accessible as attributes
+        for key,table in self._table.items():
+            setattr(self, key, table)
+        # have to be get first table ready
+        self.index = 0
+
+    def history(self, selection, short=False, start_datetime=None):
+        """
+        short is not used at the moment
+        """
+        if isinstance(selection, tuple):
+            selection = [selection]
+        results = []
+        for tbl,b,cname in selection:
+            table_name, bi, fieldi = self.selection_index(tbl, b, cname)
+            if bi < 0:
+                bi = len(self.block_name_index) + bi
+            ### important to convert cell index
+            ys = self._h5[table_name][:,bi,fieldi]
+            results.append((self.fulltimes, ys))
+        if len(results) == 1: results = results[0]
+        return results
+
+    def selection_index(self, tbl, b, field):
+        dname = {
+            'e': 'element',
+            'c': 'connection',
+            'g': 'generation',
+        }
+        def eleme_index(b):
+            if isinstance(b, str):
+                bi = self.block_name_index[b]
+            elif isinstance(b, unicode):
+                bi = self.block_name_index[str(b)]
+            elif isinstance(b, int):
+                bi = b
+            else:
+                raise Exception('.history() block must be an int or str: %s (%s)' % (str(b),str(type(b))))
+            return bi
+        def conne_index(b):
+            if isinstance(b, tuple):
+                bi = self.connection_name_index[(str(b[0]), str(b[1]))]
+            elif isinstance(b, int):
+                bi = b
+            else:
+                raise Exception('.history() conne must be an int or (str,str): %s (%s)' % (str(b),str(type(b))))
+            return bi
+        def gener_index(b):
+            if isinstance(b, tuple):
+                bi = self.generation_name_index[(str(b[0]), str(b[1]))]
+            elif isinstance(b, int):
+                bi = b
+            else:
+                raise Exception('.history() gener must be an int or (str,str): %s (%s)' % (str(b),str(type(b))))
+            return bi
+        iname = {
+            'e': eleme_index,
+            'c': conne_index,
+            'g': gener_index,
+        }
+        if not hasattr(self, 'field_index'):
+            self.field_index = {}
+            for n,nn in dname.items():
+                for i,ff in enumerate(self._h5[nn + '_fields']):
+                    self.field_index[(n,ff.decode("utf-8"))] = i
+        return dname[tbl], iname[tbl](b), self.field_index[(tbl,field)]
+
+    @property
+    def block_name_index(self):
+        if not hasattr(self, '_block_name_index'):
+            self._block_name_index = {}
+            # self._block_name_index.update({str(e):i for i,e in enumerate(self._h5['element_names'])})
+            self._block_name_index.update({fix_blockname(str(e.decode("utf-8"))):i for i,e in enumerate(self._h5['element_names'])})
+        return self._block_name_index
+
+    @property
+    def connection_name_index(self):
+        if not hasattr(self, '_connection_name_index'):
+            a = self._h5['connection_names1']
+            b = self._h5['connection_names2']
+            self._connection_name_index = {}
+            self._connection_name_index.update({(fix_blockname(str(x[0].decode("utf-8"))),fix_blockname(str(x[1].decode("utf-8")))):i for i,x in enumerate(zip(a,b))})
+        return self._connection_name_index
+
+    @property
+    def generation_name_index(self):
+        if not hasattr(self, '_generation_name_index'):
+            a = self._h5['generation_eleme']
+            b = self._h5['generation_names']
+            self._generation_name_index = {}
+            # self._generation_name_index.update({(str(x[0]),str(x[1])):i for i,x in enumerate(zip(a,b))})
+            # self._generation_name_index.update({(fix_blockname(str(x[0])),(str(x[1]))):i for i,x in enumerate(zip(a,b))})
+            # self._generation_name_index.update({((str(x[0])),fix_blockname(str(x[1]))):i for i,x in enumerate(zip(a,b))})
+            self._generation_name_index.update({(fix_blockname(str(x[0].decode("utf-8"))),fix_blockname(str(x[1].decode("utf-8")))):i for i,x in enumerate(zip(a,b))})
+        return self._generation_name_index
+
+
+    def read_tables(self):
+        """ copy values from h5 into listingtables, with slicing """
+        if 'element' in self.table_names:
+            self.element._index = self.index
+            # for i,cname in enumerate(self.element.column_name):
+            #     self.element._data[:,i] = self._h5['element'][self._index, :, i]
+        if 'connection' in self.table_names:
+            self.connection._index = self.index
+            # for i,cname in enumerate(self.connection.column_name):
+            #     self.connection._data[:,i] = self._h5['connection'][self._index, :, i]
+        if 'generation' in self.table_names:
+            self.generation._index = self.index
+            # for i,cname in enumerate(self.generation.column_name):
+            #     self.generation._data[:,i] = self._h5['generation'][self._index, :, i]
+
+    def get_index(self): return self._index
+    def set_index(self, i):
+        self._index = i
+        if self._index < 0: self._index += self.num_fulltimes
+        self.read_tables()
+    index = property(get_index, set_index)
+
+    def first(self): self.index = 0
+    def last(self): self.index = -1
+    def next(self):
+        """Find and read next set of results; returns false if at end of listing"""
+        more = self.index < self.num_fulltimes - 1
+        if more: self.index += 1
+        return more
+    def prev(self):
+        """Find and read previous set of results; returns false if at start of listing"""
+        more = self.index > 0
+        if more: self.index -= 1
+        return more
+
+    def get_table_names(self):
+        return sorted(self._table.keys())
+    table_names = property(get_table_names)
+
+    def get_time(self): return self.fulltimes[self.index]
+    def set_time(self, t):
+        if t < self.fulltimes[0]: self.index = 0
+        elif t > self.fulltimes[-1]: self.index = -1
+        else:
+            dt = np.abs(self.fulltimes - t)
+            self.index = np.argmin(dt)
+    time = property(get_time, set_time)
+
+
+class test_fivespot(unittest.TestCase):
+    def setUp(self):
+        self.lst_h = t2listingh5('fivespot.h5')
+        self.lst_t= t2listing('expected.listing')
+
+    def test_match_tables(self):
+        # check row and column names
+        def check_names(tbl):
+            tbl_h = getattr(self.lst_h, tbl)
+            tbl_t = getattr(self.lst_t, tbl)
+            self.assertEqual(tbl_h.row_name, tbl_t.row_name)
+            for i,field in enumerate(tbl_h.column_name):
+                if tbl_t.column_name[i] in field:
+                    match = True
+                else:
+                    match = False
+                self.assertEqual(match, True, '%s: column name mismatch' % tbl)
+        for tbl in ['element', 'connection', 'generation']:
+            check_names(tbl)
+        # check table values, after change index also
+        def check_tables():
+            rtol = 1.0e-5 # roughly 4~5 significant digits from text listing file
+            for field in ['Temperature', 'Pressure', 'Vapour saturation']:
+                np.testing.assert_allclose(self.lst_h.element[field],
+                                           self.lst_t.element[field], rtol=rtol)
+            for field in ['Mass flow', 'Enthalpy', 'Heat flow']:
+                np.testing.assert_allclose(self.lst_h.connection[field],
+                                           self.lst_t.connection[field], rtol=rtol)
+            for field in ['Generation rate', 'Enthalpy']:
+                np.testing.assert_allclose(self.lst_h.generation[field],
+                                           self.lst_t.generation[field], rtol=rtol)
+        check_tables()
+        self.lst_h.last(); self.lst_t.last()
+        check_tables()
+        self.lst_h.first(); self.lst_t.first()
+        check_tables()
+
+        # check table with element index
+        def check_table_by_index(i):
+            tbl_h = self.lst_h.element[i]
+            tbl_t = self.lst_t.element[i]
+            for k in tbl_h.keys():
+                if k == 'key':
+                    self.assertEqual(tbl_h[k], tbl_t[k])
+                else:
+                    np.testing.assert_approx_equal(tbl_h[k], tbl_t[k], significant=5)
+        for i in range(len(self.lst_h.element.row_name)):
+            check_table_by_index(i)
+
+        # check table with element name
+        def check_table_by_name(b):
+            tbl_h = self.lst_h.element[b]
+            tbl_t = self.lst_t.element[b]
+            for k in tbl_h.keys():
+                if k == 'key':
+                    self.assertEqual(tbl_h[k], tbl_t[k])
+                else:
+                    np.testing.assert_approx_equal(tbl_h[k], tbl_t[k], significant=5)
+        for b in self.lst_h.element.row_name:
+            check_table_by_index(b)
+
+    def test_match_history(self):
+        self.assertEqual(self.lst_h.num_fulltimes, self.lst_t.num_fulltimes)
+        np.testing.assert_allclose(self.lst_h.fulltimes, self.lst_t.fulltimes)
+        rtol = 1.0e-5
+        # seems allfield names are identical with fivespot's EOS
+        for sel in [('e', 'AA106', 'Pressure'),
+                    ('e', 'AA 66', 'Temperature'),
+                    ('c', ('AA 66', 'AA 67'), 'Mass flow'),
+                    ('g', ('AA 11', 'PRO 1'), 'Generation rate'),
+                    ('g', ('AA 11', 'PRO 1'), 'Enthalpy'),
+                    ]:
+            xs_h, ys_h = self.lst_h.history(sel)
+            xs_t, ys_t = self.lst_t.history(sel)
+            np.testing.assert_allclose(xs_h, xs_t, rtol=rtol)
+            np.testing.assert_allclose(ys_h, ys_t, rtol=rtol)
+
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)

gimu/waiwera_copy.py

@@ -0,0 +1,43 @@
+
+import json
+import sys
+from pathlib import Path
+
+def main():
+    """
+    Duplicates a JSON file, adding a postfix to the filename and updating
+    an internal value.
+    """
+    if len(sys.argv) != 3:
+        print("Usage: make_waiwera_copy <input.json> <postfix>")
+        sys.exit(1)
+
+    input_path = Path(sys.argv[1])
+    postfix = sys.argv[2]
+
+    if not input_path.exists() or input_path.suffix != '.json':
+        print(f"Error: Input file '{input_path}' does not exist or is not a .json file.")
+        sys.exit(1)
+
+    # Construct output path
+    output_path = input_path.with_name(f"{input_path.stem}{postfix}{input_path.suffix}")
+
+    # Read and modify JSON content
+    with open(input_path, 'r') as f:
+        data = json.load(f)
+
+    if "output" in data and "filename" in data["output"]:
+        h5_path = Path(data["output"]["filename"])
+        new_h5_filename = f"{h5_path.stem}{postfix}{h5_path.suffix}"
+        data["output"]["filename"] = new_h5_filename
+    else:
+        print("Warning: ['output']['filename'] key not found in the JSON file. No change made to content.")
+
+    # Write new JSON file
+    with open(output_path, 'w') as f:
+        json.dump(data, f, indent=2)
+
+    print(f"Successfully created '{output_path}'")
+
+if __name__ == "__main__":
+    main()