gimu 0.1.0__py3-none-any.whl

gimu/config.py

@@ -0,0 +1,82 @@
+""" CONFIG 
+"""
+
+
+class Singleton(object):
+    __single = None # the one, true Singleton
+
+    def __new__(classtype, *args, **kwargs):
+        # Check to see if a __single exists already for this class
+        # Compare class types instead of just looking for None so
+        # that subclasses will create their own __single objects
+        if classtype != type(classtype.__single):
+            classtype.__single = object.__new__(classtype, *args, **kwargs)
+        return classtype.__single
+
+        
+#class config(Singleton):
+class config(object):
+    def __init__(self,filename=''):
+        self.empty()
+        if filename: self.read_from_file(filename)
+    def empty(self):
+        self._config_entries = {}
+        
+    def read_from_file(self,filename=None):
+        """ read config from a whole file, until [END], if filename
+            is not given, user will be prompted for a filename."""
+        if filename==None:
+            filename=raw_input(' Configuration file (.cfg) name? ')
+        print(" Reading file", filename.strip(), "for configurations...")
+        
+        cfgfile=open(filename)
+        self._read(cfgfile)    
+        cfgfile.close()
+        
+    def read_from_file_section(self,file_with_cfg):
+        """ only read config entries from the current location, 
+            file_with_cfg should be already opened, and reading will
+            be terminated once [END] is reached, the calling program 
+            can continue read the rest of the file. """
+        self._read(file_with_cfg)
+        
+    def _read(self,cfgfile):
+        finished=False
+        while not finished:
+            line = cfgfile.readline()
+            if line:
+                if line.strip()=='': continue
+                if line.strip()[0]=='!': continue
+                if line.strip()[0]=='#': continue
+                if line.strip()[0]=='[':
+                    ikeyend=line.find(']')
+                    keyword=line[1:ikeyend]
+                    if keyword=='END': break
+                    self._config_entries[keyword]=[]
+                else: 
+                    self._config_entries[keyword].append(line.rstrip('\n\r'))
+            else: finished = True
+    def add_value(self,keyword,value):
+        """ add value manually, value can be a single value, or a list, 
+            or whatever object, as long as you know what it is when you
+            get it out, if keyword exist, the value wil be appended """
+        if keyword in self._config_entries:
+            try:
+                self._config_entries[keyword].append(value)
+            except:
+                self._config_entries[keyword] = [self._config_entries[keyword], value]
+        else:
+            self._config_entries[keyword] = [value]
+        
+    def get_value(self,keyword):
+        if len(self._config_entries[keyword]) == 0:
+            return ''
+        else:
+            return self._config_entries[keyword][0]
+        
+    def get_list(self,keyword):
+        return self._config_entries[keyword]
+
+    def check_optional(self,keyword):
+        return keyword in self._config_entries.keys()
+

gimu/easy_date.py

@@ -0,0 +1,209 @@
+""" Lazy man's easy conversion between date strings and date tuple/date objects.
+
+It's actually very easy to code it directly, plus it's better to reduce
+dependency.  This module provides very few additional functionality.  One being
+able to detect if a list of strings/date tuples are given, and act accordingly.
+Use these few lines of code instead if you are not too lazy:
+
+from datetime import datetime
+d = datetime.strptime(s, '%Y-%m-%d').date()
+
+from datetime import date
+s = str(date((1995,2,3)))
+s = str(date(*tp))
+# tp is your existing tuple, s will be string '1995-02-03'
+"""
+import unittest
+
+
+def date_tuple_to_string(tp):
+    """ Converts date integer tuple (y,m,d) into string 'yyyy-mm-dd'.  Input
+    supports both a single date-tuple as well as a list of date-tuples. """
+    from datetime import date
+    single = False
+    if len(tp) == 3:
+        if all([isinstance(i, int) for i in tp]):
+            single = True
+    if single:
+        return str(date(*tp))
+    else:
+        # assuming input is a list of date-tuples
+        return [str(date(*d)) for d in tp]
+
+def _s2d(s):
+    """ Converts a date string of format 'yyyy-mm-dd' or 'dd/mm/yyyy' into a
+    python datetime.date object. """
+    from datetime import datetime
+    if '/' in s:
+        frmt = '%d/%m/%Y'
+    elif '-' in s:
+        frmt = '%Y-%m-%d'
+    else:
+        raise Exception("Date string format only support 'yyyy-mm-dd' or 'dd/mm/yyyy'")
+    return datetime.strptime(s, frmt).date()
+
+def date_string_to_tuple(s):
+    """ Converts a date string of format 'yyyy-mm-dd' or 'dd/mm/yyyy' into a
+    tuple of integers (y,m,d).  Input supports both a single string as well as a
+    list of strings. """
+    def d2t(d):
+        return (d.year, d.month, d.day)
+    if isinstance(s, list):
+        return [d2t(_s2d(sd)) for sd in s]
+    else:
+        return d2t(_s2d(s))
+
+def date_string_to_date(s):
+    """ Converts a date string of format 'yyyy-mm-dd' or 'dd/mm/yyyy' into a
+    python datetime.date object.  Input supports both a single string as well as
+    a list of strings. """
+    from datetime import date
+    if isinstance(s, list):
+        return [_s2d(sd) for sd in s]
+    else:
+        return _s2d(s)
+
+def year_fraction_to_date(year_fraction):
+    """ Converts a decimal/float year into a python datetime.date object.
+    Input supports both a single float as well as a list of floats. """
+    from datetime import date, timedelta
+    def yf2d(yf):
+        year = int(yf)
+        fraction = yf - year
+        # assuming 365.25 days per year
+        day_of_year = int(fraction * 365.25)
+        return date(year, 1, 1) + timedelta(days=day_of_year)
+    if isinstance(year_fraction, list):
+        return [yf2d(yf) for yf in year_fraction]
+    else:
+        return yf2d(year_fraction)
+
+def year_fraction_to_date_str(year_fraction):
+    """ Converts a decimal/float year into a string of format 'dd/mm/yyyy'.
+    Input supports both a single float as well as a list of floats. """
+    dd = year_fraction_to_date(year_fraction)
+    if isinstance(dd, list):
+        return [d.strftime("%d/%m/%Y") for d in dd]
+    else:
+        return dd.strftime("%d/%m/%Y")
+
+def toYearFraction(date):
+    """ converts python datetime objects into decimal/float years
+    https://stackoverflow.com/a/6451892/2368167
+    """
+    from datetime import datetime as dt
+    import time
+    def sinceEpoch(date): # returns seconds since epoch
+        return time.mktime(date.timetuple())
+    s = sinceEpoch
+
+    year = date.year
+    startOfThisYear = dt(year=year, month=1, day=1)
+    startOfNextYear = dt(year=year+1, month=1, day=1)
+
+    yearElapsed = s(date) - s(startOfThisYear)
+    yearDuration = s(startOfNextYear) - s(startOfThisYear)
+    fraction = yearElapsed/yearDuration
+
+    return date.year + fraction
+
+def toYearFraction2(date):
+    """ converts python datetime objects into decimal/float years
+    https://stackoverflow.com/a/6451892/2368167
+
+    fix Epoch issue?
+    """
+    from datetime import datetime as dt
+    from datetime import date as dd
+    import time
+    def sinceEpoch(date): # returns seconds since epoch
+        return date - dd(1970,1,1)
+    s = sinceEpoch
+
+    year = date.year
+    startOfThisYear = dd(year=year, month=1, day=1)
+    startOfNextYear = dd(year=year+1, month=1, day=1)
+
+    yearElapsed = s(date) - s(startOfThisYear)
+    yearDuration = s(startOfNextYear) - s(startOfThisYear)
+    fraction = yearElapsed.total_seconds()/yearDuration.total_seconds()
+
+    return date.year + fraction
+
+def year_fraction(year, month, day):
+    """ https://stackoverflow.com/a/36949905/2368167
+    """
+    import datetime
+    date = datetime.date(year, month, day)
+    start = datetime.date(date.year, 1, 1).toordinal()
+    year_length = datetime.date(date.year+1, 1, 1).toordinal() - start
+    return date.year + float(date.toordinal() - start) / year_length
+
+class TestEasyDate(unittest.TestCase):
+    """docstring for TestEasyDate"""
+    def test_year_fraction(self):
+        for d,f in [
+            ((2023, 1, 1), 2023.0),
+            ((2023, 6, 30), 2023.493),
+            ((2023, 12, 31), 2023.997),
+            ((2024, 1, 1), 2024.0),
+        ]:
+            result = year_fraction(*d)
+            self.assertAlmostEqual(result, f, places=3)
+                
+    def test_year_fraction_mid_year(self):
+        """Test year_fraction for middle of the year"""
+        # Test July 1st (approximately mid-year)
+        result = year_fraction(2023, 7, 1)
+        self.assertGreater(result, 2023.4)
+        self.assertLess(result, 2023.6)
+
+    def test_year_fraction_to_date(self):
+        """ test by starting with dd/mm/yyyy, convert to fraction, then back to dd/mm/yyyy, final one should be the same as the first one """
+        ds = ['2011-03-05', '2011-3-6', '04/11/2011', '5/11/2011']
+        for d in ds:
+            dd = _s2d(d)
+            f = toYearFraction2(dd)
+            d2 = year_fraction_to_date(f)
+            self.assertEqual(dd, d2)
+        
+        ds = ['04/11/2011', '05/01/2011']
+        for d in ds:
+            dd = _s2d(d)
+            f = toYearFraction2(dd)
+            d2 = year_fraction_to_date_str(f)
+            self.assertEqual(d, d2)
+
+    def test_tuple_to_string(self):
+        s1 = (1995,10,2)
+        s2 = [1995,10,2]
+        ss = [s1, s2]
+        for s in ss:
+            self.assertEqual('1995-10-02', date_tuple_to_string(s))
+        self.assertEqual(['1995-10-02']*2, date_tuple_to_string(ss))
+
+    def test_string_to_tuple(self):
+        d1 = '2011-03-05'
+        d2 = '2011-3-5'
+        d3 = '05/03/2011'
+        d4 = '5/3/2011'
+        ds = [d1,d2,d3,d4]
+        for d in ds:
+            self.assertEqual((2011,3,5), date_string_to_tuple(d))
+        self.assertEqual([(2011,3,5)]*4, date_string_to_tuple(ds))
+
+    def test_string_to_date(self):
+        from datetime import date
+        d1 = '2011-03-05'
+        d2 = '2011-3-5'
+        d3 = '05/03/2011'
+        d4 = '5/3/2011'
+        ds = [d1,d2,d3,d4]
+        for d in ds:
+            self.assertEqual(date(2011,3,5), date_string_to_date(d))
+        self.assertEqual([date(2011,3,5)]*4, date_string_to_date(ds))
+
+
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)

gimu/geo_common.py

@@ -0,0 +1,222 @@
+from mulgrids import *
+import string
+
+def quick_enthalpy(t_or_p,ph='liq'):
+    """ Return enthalpy J/kg ('liq', 'vap', or 'dif') of water at specified 
+        temperature (<=500.0 in degC) or pressu (>500.0 in Pa) """
+    import t2thermo
+    def enth(t,p,f):
+        d,u = f(t,p)
+        return u + p/d
+    def hlhs(t,p):
+        return enth(t,p,t2thermo.cowat), enth(t,p,t2thermo.supst)
+    def sat_tp(t_or_p):
+        if t_or_p > 500.0:
+            return t2thermo.tsat(t_or_p), t_or_p
+        else:
+            return t_or_p, t2thermo.sat(t_or_p)
+    (hl,hs) = hlhs(*sat_tp(t_or_p))
+    # xxxx
+    return {'liq': hl,'vap': hs,'dif': hs-hl}[ph]
+
+class RelativePermeability:
+    """ Class to calculate linear relative permeability, this is used in
+        TOUGH2 for the linear relative permeability model.  The class has a
+        single method, which takes the saturation and returns the relative
+        permeability. """
+    def __init__(self, wj_object=None):
+        if wj_object is None:
+            wj_object = {
+                "type": "linear",
+                "liquid": [0.0, 1.0],
+                "vapour": [0.0, 1.0]
+            }
+        self.setting = wj_object
+        self.func = {
+            "linear": self.linear,
+        }
+
+    def calc(self, vapour_saturation):
+        """ return (kr_liquid, kr_vapour) """
+        return self.func[self.setting['type']](vapour_saturation)
+
+    def linear(self, vapour_saturation):
+        liq_limits = self.setting['liquid']
+        vap_limits = self.setting['vapour']
+        liquid_saturation = 1.0 - vapour_saturation
+        kr_liq = np.interp(liquid_saturation, liq_limits, [0., 1.], left=0.0, right=1.0)
+        kr_vap = np.interp(vapour_saturation, vap_limits, [0., 1.], left=0.0, right=1.0)
+        return kr_liq, kr_vap
+
+def flowing_enthalpy(lst, wj, block):
+    """ calculate flowing enthalpy of a given block if producing from waiwera h5
+
+    NOTE use values from waiwera h5 at current time
+    """
+    phases = ['liquid', 'vapour']
+    rp = RelativePermeability(wj['rock']['relative_permeability'])
+    vapour_saturation = lst.element[block][f'fluid_vapour_saturation']
+    rel_perm = rp.calc(vapour_saturation)
+    fluid = lst.element[block]
+    # mobility
+    mobility, sum_mobility = {}, 0.0
+    for iph, phase in enumerate(phases):
+        density = fluid[f'fluid_{phase}_density']
+        viscosity = fluid[f'fluid_{phase}_viscosity']
+        if viscosity == 0.0:
+            mobility[phase] = 0.0
+        else:
+            mobility[phase] = rel_perm[iph] * density / viscosity
+        sum_mobility += mobility[phase]
+    # flow fraction
+    flow_frac = {}
+    for phase in phases:
+        flow_frac[phase] = mobility[phase] / sum_mobility
+    # enthalpy
+    enthalpy = 0.0
+    for phase in phases:
+        enthalpy += flow_frac[phase] * fluid[f'fluid_{phase}_specific_enthalpy']
+    # breakpoint()
+    return enthalpy
+
+def bottomhole_pressure(depth, temperature=20.0, whp=1.0e5, division=100, 
+                        min_depth_interval=10.0):
+    """ Calculate the pressure at the bottom of a well, given the wellhead
+        pressure (whp) in pascal, temperature in degC, and division in m. The
+        pressure is calculated as: pressure = whp + rho * G * depth where rho is
+        the density of water at the given temperature, G is the gravitational
+        acceleration (9.81 m/s^2), and depth is the depth of the well divided by
+        division.
+
+        What tis code does is then divide the depth into inv=tervals.  Then the
+        pressure is accumulated, this allows the density calculation to use the
+        actual pressure at the depth.  For liquid water, it is quite
+        incompressible, so the result won't be that different to the easy
+        rho*G*depth method.        
+    """
+    import t2thermo
+    # divide well depth to intervals, use larger of the min interval and division
+    interval = max(min_depth_interval, depth/float(division))
+    d = 0.0
+    pressure = whp
+    while d < depth:
+        rho, u = t2thermo.cowat(temperature, pressure)
+        pressure += rho * 9.81 * interval
+        d += interval
+    rho, u = t2thermo.cowat(temperature, pressure)
+    pressure += rho * 9.81 * (depth - d)
+    return pressure
+
+def block_depth(block, geo):
+    """ Return the depth of a block in a geo object, this is the depth of the
+        centre of the block.  This also work for Waiwera cell if block is an
+        integer number.
+    """
+    if isinstance(block, int):
+        block = geo.block_name_list(block + geo.num_atmosphere_blocks)
+    lay, col = geo.layer_name(block), geo.column_name(block)
+    return geo.column[col].surface - geo.block_centre(lay, col)[2]
+
+def xyz2fit(fn):
+    data = np.fromfile(fn,sep=" ")
+    nrow = np.size(data) / 3
+    data= data.reshape(nrow,3)
+    return data
+
+def find_all_cols_below(geo,level,surfer_file=None):
+    if surfer_file is not None: outfile = file(surfer_file,'w')
+    cols = []
+    for col in geo.columnlist:
+        surf = col.surface
+        if surf < level:
+            #print(col.name, str(surf))
+            cols.append([col.centre[0], col.centre[1], surf, col.name])
+            if surfer_file is not None: outfile.write(
+                str(col.centre[0])+' '+str(col.centre[1])+' '+str(surf)+' '+
+                col.name + '\n')
+    if surfer_file is not None:
+        outfile.close()
+        print(' -- file: ', surfer_file, ' is written.')
+
+def t2_strict_name(n):
+    """ convert any name into the common TOUGH style 5 character name """
+    import string
+    def make_number(c):
+        """ change a character into a single number, mostly 'A' or 'a' will 
+            become a '1' """
+        if len(c.strip()) == 0: return ' '
+        d = c.lower().strip()[:1]
+        i = string.ascii_lowercase.find(d)+1
+        if i == 0: return ' '
+        else: return str(i%10)
+    newn = list(n.strip())
+    if len(newn) <= 3:
+        return "".join(newn).strip()[:5].ljust(5)
+    for i in range(3,len(newn)):
+        if newn[i] not in '0123456789':
+            newn[i] = make_number(newn[i])
+    return "".join(newn).strip()[:5].ljust(5)
+
+def is_leap_year(y):
+    if   int(y)%400 == 0: return True
+    elif int(y)%100 == 0: return False
+    elif int(y)%4   == 0: return True
+    else:                 return False
+
+def days_in_month(month, leap_year=False):
+    if leap_year:
+        d_month = [  31 , 29 , 31 , 30 , 31 , 30 , 31 , 31 , 30 , 31 , 30 , 31  ]
+    else:
+        d_month = [  31 , 28 , 31 , 30 , 31 , 30 , 31 , 31 , 30 , 31 , 30 , 31  ]
+    return d_month[month - 1]
+
+def date2str(d,m,y):
+    ds, ms, ys = str(d), str(m), str(y)
+    while len(ds) < 2: ds = '0'+ds
+    while len(ms) < 2: ms = '0'+ms
+    while len(ys) < 4: ys = '0'+ys
+    return ds+'/'+ms+'/'+ys
+
+def date2num(enddate):
+            
+    d,m,y = enddate.split('/')
+    months    = [ '01','02','03','04','05','06','07','08','09','10','11','12' ]
+    d_month   = [  31 , 28 , 31 , 30 , 31 , 30 , 31 , 31 , 30 , 31 , 30 , 31  ]
+    d_month_l = [  31 , 29 , 31 , 30 , 31 , 30 , 31 , 31 , 30 , 31 , 30 , 31  ]
+    acum_ds   = [sum(d_month[:i]) for i in range(12)]
+    acum_ds_l = [sum(d_month[:i]) for i in range(12)]
+    ad_m   = dict(zip(months, acum_ds)) # accumulated days before this month
+    ad_m_l = dict(zip(months, acum_ds_l)) # accumulated days before this month
+    ds_m   = dict(zip(months, d_month)) # maximum days in this month
+    ds_m_l = dict(zip(months, d_month_l)) # maximum days in this month
+    # check and process d and m, this depends on data
+    if m not in months:
+        print(' Error, unable to convert ', enddate, ' to numeric format. check month.')
+        sys.exit()
+    if is_leap_year:
+        if int(d) not in range(1,ds_m_l[m]+1):
+            print(' Error, unable to convert ', enddate, ' to numeric format. check day.')
+            sys.exit()
+        num = float(y) + ((float(d) + float(ad_m_l[m]))/float(sum(d_month_l)))
+    else:
+        if int(d) not in range(1,ds_m[m]+1):
+            print(' Error, unable to convert ', enddate, ' to numeric format. check day.')
+            sys.exit()
+        num = float(y) + ((float(d) + float(ad_m[m]))/float(sum(d_month)))
+    return num
+
+
+def identifier(x, chars='abcdefghijklmnopqrstuvwxyz', width=5):
+    """ creates a character-based unique identifier from a given integer,
+        both chars and width are customisable, output is space filled and
+        right aligned """
+    output = []
+    base = len(chars)
+    while x:
+        output.append(chars[x % base])
+        x /= base
+    final = ''.join(reversed(output))
+    if len(final) > width:
+        raise Exception('identifier() failed, not enough width.')
+    return ('%' + str(width) + 's') % final
+

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()

gimu-0.1.0.dist-info/METADATA

@@ -0,0 +1,84 @@
+Metadata-Version: 2.4
+Name: gimu
+Version: 0.1.0
+Summary: A toolkit and python library for modelling at Geothermal Institute, University of Auckland.
+Project-URL: Documentation, https://github.com/cyeh015/gimu/blob/main/README.md
+Project-URL: Issues, https://github.com/cyeh015/gimu/issues
+Project-URL: Source, https://github.com/cyeh015/gimu
+Author-email: Angus Yeh <a.yeh@auckland.ac.nz>
+License-Expression: MIT
+License-File: LICENSE.txt
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.8
+Requires-Dist: h5py
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: pint
+Requires-Dist: pytough
+Requires-Dist: scipy
+Description-Content-Type: text/markdown
+
+# gimu
+
+A minimal toolkit and python library for modelling at Geothermal Institute, University of Auckland.
+
+-----
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Commands](#Commands)
+- [Related Packages](#related-packages)
+- [License](#license)
+- [Developer](#Developer)
+
+## Installation
+
+```console
+pip install -U gimu
+```
+
+If you use conda, use the supplied `environment.yml` to create `py311-gimu`.  This installs packages using conda as much as possible before installing packages from PyPI.
+
+```console
+conda env create -f environment.yml
+```
+
+## Commands
+
+### Convert SAVE file to INCON file
+
+```console
+save2incon a.save b.incon
+```
+
+NOTE this command is used during the scenario run.
+
+## License
+
+`gimu` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
+
+## Developer
+
+### Build and Publish
+
+To bump version, create a tag, eg. `v0.1.0`
+
+PyPI token is expected in ~/.pypirc
+
+Publish to PyPI:
+
+```console
+hatch build
+hatch publish
+```
+
+### TODO
+

gimu-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+gimu/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gimu/config.py,sha256=W3dNfdJzsszPySx7T4ereIOR76mPQuBWq5eNp79WEQk,3089
+gimu/easy_date.py,sha256=Aq7RW94cdvEcrJ4sXq7aG91KMqZyNFCQywE6scyiQzk,7162
+gimu/geo_common.py,sha256=7U5hmT4cCuFBAx5cm_pxNu2owz4wNrQGW0zpINHG7fU,8678
+gimu/project_cli.py,sha256=GBi6SHuRzcsuTgAfZ58oOP8RAK1jw7KN7KdypyAGqfU,1541
+gimu/save2incon.py,sha256=mAVnTqkFSDXSc5Nt0U6M6_5zFSVyX21CuchXxsUsv3k,630
+gimu/t2listingh5.py,sha256=sepCah3lV6etWr-aJ_Tc9d3Rubio7DitEn0SQP2oJ2E,16628
+gimu/waiwera_copy.py,sha256=G84UQWbVq--cfkETCs_jpcquTL-x5SftAFNNNs3GfJs,1286
+gimu-0.1.0.dist-info/METADATA,sha256=2Yrir90xi_3GIAsEjLJGp0HiWf-jK8BUtwwQ5ZZ0XFc,2065
+gimu-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+gimu-0.1.0.dist-info/entry_points.txt,sha256=FbtLXv_XXn6Wh2DXRsqJpTp85lxEvJiE36TTUTa0e1o,129
+gimu-0.1.0.dist-info/licenses/LICENSE.txt,sha256=pGRJUqv1E2xL4lfPHMkmmqp868-cgtiVfDzTWDtcUiM,1121
+gimu-0.1.0.dist-info/RECORD,,

gimu-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

gimu-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+gimu = gimu.project_cli:show_help
+make_waiwera_copy = gimu.waiwera_copy:main
+save2incon = gimu.save2incon:main

gimu-0.1.0.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2025-present Angus Yeh, University of Auckland <a.yeh@auckland.ac.nz>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.