gimu 0.4.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/gmf/data.py

@@ -0,0 +1,118 @@
+""" Toolbox for accessing GIM/GMF well data
+
+Use:
+    from gmf_data import data_json
+
+    data_json.set_data_folder('/path/to/data')
+
+"""
+
+import json
+import os
+from collections import OrderedDict
+
+
+class WellData(dict):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def downhole_temperature(self, date_str):
+        """ get direct access to data without fluff """
+        try:
+            raw_data = self['Downhole_Temperature'][date_str]['Data']
+        except KeyError as e:
+            print(f"Data '{date_str}' does not exist in {self['Well_Name']}")
+            print(f"-> available data set are: {list(self['Downhole_Temperature'].keys())}")
+            raise e
+        elevs, temps = [], []
+        for elev_str, temp in raw_data.items():
+            elev = float(elev_str)
+            elevs.append(elev)
+            temps.append(temp)
+
+        # TODO takes care of units in GMF
+        return elevs, temps
+
+
+class DataJSON:
+    def __init__(self, max_cache_size=10):
+        self._data_folders = []
+        self._cache = OrderedDict()
+        self._max_cache_size = max_cache_size
+
+    def set_data_folders(self, paths):
+        self._data_folders = []
+        for path in paths:
+            self.add_data_folder(path)
+
+    def add_data_folder(self, path):
+        if not os.path.isdir(path):
+            raise ValueError(f"Path '{path}' is not a valid directory.")
+        if path not in self._data_folders:
+            self._data_folders.append(path)
+
+    def remove_data_folder(self, path):
+        if path in self._data_folders:
+            self._data_folders.remove(path)
+
+    def __getitem__(self, well_name):
+        if not self._data_folders:
+            raise RuntimeError("Data folder not set. Please call add_data_folder() or set_data_folders() first.")
+
+        if well_name in self._cache:
+            self._cache.move_to_end(well_name)
+            return self._cache[well_name]
+
+        for folder in self._data_folders:
+            file_path = os.path.join(folder, f"{well_name}_data.json")
+            if os.path.exists(file_path):
+                with open(file_path, 'r') as f:
+                    data = WellData(json.load(f))
+
+                if len(self._cache) >= self._max_cache_size:
+                    self._cache.popitem(last=False)
+
+                self._cache[well_name] = data
+                return data
+
+        msg = '\n'.join([
+            f"Well '{well_name}' not found in any of the data folders:",
+            ] + [f"    {f}" for f in self._data_folders])
+        raise KeyError(msg)
+
+    def __contains__(self, well_name):
+        if well_name in self._cache:
+            return True
+
+        for folder in self._data_folders:
+            file_path = os.path.join(folder, f"{well_name}_data.json")
+            if os.path.exists(file_path):
+                return True
+        return False
+
+    def clear_cache(self):
+        self._cache.clear()
+
+    @property
+    def data_folders(self):
+        return self._data_folders
+
+    @property
+    def cached_wells(self):
+        return list(self._cache.keys())
+
+    @property
+    def wells(self):
+        """ Returns a list of all available well names from the data folders.
+        """
+        well_names = set()
+        for folder in self._data_folders:
+            for filename in os.listdir(folder):
+                if filename.endswith('_data.json'):
+                    well_name = filename[:-len('_data.json')]
+                    well_names.add(well_name)
+        return sorted(list(well_names))
+
+
+# Singleton instance
+data_json = DataJSON()