gimms 0.0.2__py3-none-any.whl

gimms/__init__.py

@@ -0,0 +1,4 @@
+from .__version__ import __version__
+from .core import greet
+
+__all__ = ["__version__", "greet"]

gimms/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.0.0"

gimms/applyFaultPerms.py

@@ -0,0 +1,114 @@
+
+def apply_fault_perms(geo, dat, fault_dir):
+    """ fault_dir is expected to be like:
+        { 'A': 2,
+          'B': 2,
+          'C': 1, }
+        where 'A', 'B', ... are fault name used as part of rock type name
+    """
+
+    for lay in geo.layerlist[:0:-1]:
+        layername = lay.name
+        print(lay.name)
+        fcols = {}
+
+        for col in geo.columnlist:
+            try:
+                bstats = dat.grid.block[col.name+layername].rocktype.name
+                #print bstats
+                for flt in bstats[1:3]:
+                    if flt != '0':
+                        if flt.isdigit(): continue
+                        #print flt
+                        #hello
+                        try:
+                            fcols[flt].append(col.name)
+                        except KeyError:
+                            fcols[flt] = []
+                            fcols[flt].append(col.name)
+            except KeyError:
+                pass
+
+        #print 'Columns done'
+
+        faults1 = []
+        faults2 = []
+        for flt in fcols.keys():
+            #print flt
+            along_flt = fault_dir[flt]
+            if along_flt == 1:
+                faults1.append(flt)
+            else:
+                faults2.append(flt)
+
+        for flt in fcols.keys():
+            #print flt
+            along_flt = fault_dir[flt]
+            across_flt = along_flt%2+1
+
+            #print along_flt,across_flt
+            #hello
+
+            checkcons = []
+            checkdatcons = []
+            try:
+                for fcol in fcols[flt]:
+                    #print fcol
+                    for con in geo.column[fcol].connection:
+                        col1 = con.column[0]
+                        col2 = con.column[1]
+                        #print col1,col2
+                        try:
+                            #print 'here'
+                            datcon = dat.grid.connection[(col1.name+layername,col2.name+layername)]
+                        except KeyError:
+                            #print 'reverse'
+                            try:
+                                datcon = dat.grid.connection[(col2.name+layername,col1.name+layername)]
+                            except KeyError:
+                                #print 'no conn'
+                                continue
+                        checkcons.append(con)
+                        checkdatcons.append(datcon)
+                        #print col1.name+layername, block_faults[()][col1.name+layername], col2.name+layername, block_faults[()][col2.name+layername]
+
+                        fltpres = []
+                        bstats1 = dat.grid.block[col1.name+layername].rocktype.name
+                        bstats2 = dat.grid.block[col2.name+layername].rocktype.name
+
+                        for flt1 in bstats1[1:3]:
+                            if flt1 in faults1: fltpres.append(1)
+                            if flt1 in faults2: fltpres.append(2)
+                        for flt2 in bstats2[1:3]:
+                            if flt2 in faults1: fltpres.append(1)
+                            if flt2 in faults2: fltpres.append(2)
+                        if bstats1[1] == '0': fltpres.append(0)
+                        if bstats2[1] == '0': fltpres.append(0)
+
+                        #print bstats1,bstats2,fltpres
+                        if 1 in fltpres and 2 in fltpres:
+                            dummy = 1
+                        elif 0 in fltpres:
+                            #across fault connection
+                            flttmp = set(fltpres)
+                            flttmp.remove(0)
+                            along_flt = list(flttmp)[0]
+                            if datcon.direction == along_flt:
+                                datcon.direction = across_flt
+                        else:
+                            along_flt = list(set(fltpres))[0]
+                            across_flt = along_flt%2+1
+                            if datcon.direction == across_flt:
+                                if bstats1[1:3] == bstats2[1:3]:
+                                    datcon.direction = along_flt
+                        #print along_flt, across_flt
+            except KeyError:
+                pass
+                #print 'Plotting'
+
+                #execfile('plot_perm_angle.py')
+
+
+    dat.grid.clean_rocktypes()
+    dat.grid.sort_rocktypes()
+

gimms/applyVerticalFaultPerms.py

@@ -0,0 +1,169 @@
+from t2data import t2data
+
+import os
+
+def apply_vertical_fault_k_dir(geo, dat, fault_dir, resetConns):
+    """ fault_dir is expected to be like:
+        { 'A': 2,
+          'B': 2,
+          'C': 1, }
+        where 'A', 'B', ... are fault name used as part of rock type name
+    """
+
+    if resetConns:
+        datnoperm  = t2data()
+        datnoperm.grid.fromgeo(geo)
+
+        print ('resetting connections')
+        for conn in dat.grid.connection.keys():
+            dat.grid.connection[conn].direction = datnoperm.grid.connection[conn].direction
+
+        print ('done reset')
+
+        dat.write('tmp.dat')
+        dat = t2data('tmp.dat')
+        os.remove('tmp.dat')
+
+
+    #block_stats = np.load(NSmodelpath+'block_fault_stats.npy')
+    #block_faults = np.load(NSmodelpath+'block_faults.npy')
+
+    fblks = {}
+
+    for blkname in geo.block_name_list:
+        rtname = dat.grid.block[blkname].rocktype.name
+        flts = []
+        if rtname[1] in fault_dir: flts.append(rtname[1])
+        if rtname[2] in fault_dir: flts.append(rtname[2])
+        #if rtname[3] in fault_index.keys(): flts.append(fault_index[rtname[3]])
+        #if len(flts) > 0: print col.name+layername,flts
+        for flt in flts:
+            if flt in fblks.keys():
+                fblks[flt].append(blkname)
+            else:
+                fblks[flt] = []
+                fblks[flt].append(blkname)
+
+        #print fblks
+        #print 'Blocks done'
+
+    faults1 = []
+    faults2 = []
+    for flt in fblks.keys():
+        #print flt
+        along_flt = fault_dir[flt]
+        if along_flt == 1:
+            faults1.append(flt)
+        else:
+            faults2.append(flt)
+
+    for flt in fblks.keys():
+        along_flt = fault_dir[flt]
+        across_flt = along_flt%2+1
+        #print flt, along_flt, across_flt
+
+        checkcons = []
+        checkdatcons = []
+        if flt in fblks.keys():
+            for fblk in fblks[flt]:
+                #print fblk
+                layername = fblk[3:5]
+                uplay = geo.layerlist[(geo.layerlist.index(geo.layer[layername])-1)]
+                upblk = fblk[0:3]+uplay.name
+                if geo.layerlist.index(geo.layer[layername]) < len(geo.layerlist)-1:
+                    dnlay = geo.layerlist[(geo.layerlist.index(geo.layer[layername])+1)]
+                    dnblk = fblk[0:3]+dnlay.name
+                else:
+                    dnblk = fblk[0:3]+'xx'
+
+                #check above
+                try:
+                    #if upblk not in fblks[flt]:
+                    if dat.grid.block[upblk].rocktype.name[1] == '0':
+                        # not above
+                        #if fblk == ' sh88': print fblk,upblk
+                        try:
+                            datcon = dat.grid.connection[(fblk,upblk)]
+                        except KeyError:
+                            #if fblk == ' sh88': print 'reverse'
+                            datcon = dat.grid.connection[(upblk,fblk)]
+
+                        checkdatcons.append(datcon)
+                        datcon.direction = across_flt
+                        #if fblk == ' sh88': print datcon
+
+                        for con in geo.column[fblk[0:3]].connection:
+                            col1 = con.column[0]
+                            col2 = con.column[1]
+                            try:
+                                #print 'here'
+                                datcon = dat.grid.connection[(col1.name+layername,col2.name+layername)]
+                            except KeyError:
+                                #print 'reverse'
+                                try:
+                                    datcon = dat.grid.connection[(col2.name+layername,col1.name+layername)]
+                                except KeyError:
+                                    #print 'no conn'
+                                    continue
+                            if ((col1.name+layername in fblks[flt]) and (col2.name+layername in fblks[flt])) :
+                                # fault to fault so use fault_dir for permeability dir
+                                #if fblk == ' sh88': print datcon, datcon.direction, across_flt
+                                if datcon.direction == across_flt:
+                                    rtname1 = dat.grid.block[col1.name+layername].rocktype.name
+                                    rtname2 = dat.grid.block[col2.name+layername].rocktype.name
+                                ## check if multiple faults
+                                    if rtname1[2] == '0' and rtname2[2] == '0':
+                                        datcon.direction = 3
+                                        checkcons.append(con)
+                                        checkdatcons.append(datcon)
+                                    #if fblk == ' sh88': print datcon
+                except KeyError:
+                    pass
+
+                #check below
+                try:
+                    #if fblk == ' pk25': fblk,dnblk
+                    #if dnblk not in fblks[flt]:
+                    if dat.grid.block[dnblk].rocktype.name[1] == '0':
+                        # not below
+                        try:
+                            datcon = dat.grid.connection[(dnblk,fblk)]
+                        except KeyError:
+                            #print 'reverse'
+                            datcon = dat.grid.connection[(fblk,dnblk)]
+
+                        checkdatcons.append(datcon)
+                        datcon.direction = across_flt
+                        #if fblk == ' pk25': print datcon
+
+                        for con in geo.column[fblk[0:3]].connection:
+                            col1 = con.column[0]
+                            col2 = con.column[1]
+                            #print col1.name, col2.name
+                            try:
+                                #print 'here'
+                                datcon = dat.grid.connection[(col1.name+layername,col2.name+layername)]
+                            except KeyError:
+                                #print 'reverse'
+                                try:
+                                    datcon = dat.grid.connection[(col2.name+layername,col1.name+layername)]
+                                except KeyError:
+                                    #print 'no conn'
+                                    continue
+                            if ((col1.name+layername in fblks[flt]) and (col2.name+layername in fblks[flt])) :
+                                # fault to fault so use fault_dir for permeability dir
+                                if datcon.direction == across_flt:
+                                    rtname1 = dat.grid.block[col1.name+layername].rocktype.name
+                                    rtname2 = dat.grid.block[col2.name+layername].rocktype.name
+                                ## check if multiple faults
+                                    if rtname1[2] == '0' and rtname2[2] == '0':
+                                        datcon.direction = 3
+                                        checkcons.append(con)
+                                        checkdatcons.append(datcon)
+                                        #if fblk == ' pk25': print datcon
+                except KeyError:
+                    pass
+                #execfile('plot_perm_angle.py')
+
+
+

gimms/connectSurface.py

@@ -0,0 +1,68 @@
+from t2data import rocktype
+
+def connect_surface(geo, dat, lowestSurfLayer):
+    edgeblock = {}
+    for lay in geo.layerlist[1:lowestSurfLayer]:
+        edgenodes = {}
+        for col in geo.columnlist:
+            colnghcnt = len(col.neighbour)
+            blkname = col.name+lay.name
+            try:
+                blknghs = dat.grid.block[blkname].neighbour_name
+            except KeyError:
+                continue
+            for colconn in col.connection:
+                blk1 = colconn.column[0].name+lay.name
+                blk2 = colconn.column[1].name+lay.name
+                try:
+                    testconn = dat.grid.connection[(blk1,blk2)]
+                except KeyError:
+                    try:
+                        testconn = dat.grid.connection[(blk1,blk2)]
+                    except KeyError:
+                        for nd in colconn.node:
+                            edgenodes[nd.name] = 1
+        for col in geo.columnlist:
+            blkname = col.name+lay.name
+            try:
+                testblk = dat.grid.block[blkname]
+            except KeyError:
+                continue
+            for nd in col.node:
+                try:
+                    edgetest = edgenodes[nd.name]
+                    edgeblock[col.name+lay.name] = 1
+                except KeyError:
+                    continue
+
+    surfblocks = set([])
+    for col in geo.columnlist:
+        lay = geo.column_surface_layer(col)
+        if int(lay.name) <= int(lowestSurfLayer):
+            blkname = col.name+lay.name
+            surfblocks.add(blkname)
+
+    for blkname in edgeblock.keys():
+        surfblocks.add(blkname)
+        downlay = geo.layerlist[int(blkname[3:5])+1]
+        downblkname = blkname[0:3]+downlay.name
+        surfblocks.add(downblkname)
+
+    for blockname in list(surfblocks):
+        rtname = dat.grid.block[blockname].rocktype.name
+        if rtname[3] == 'A':
+            newrtname = rtname[0:3]+'B'+rtname[4]
+        else:
+            newrtname = rtname[0:3]+'0'+rtname[4]
+        print(blockname,rtname, newrtname)
+        if newrtname not in dat.grid.rocktype.keys():
+            r0=rocktype(name=newrtname,permeability=[5.e-12,5.e-12,5.e-13])
+            r0.porosity = .25
+            r0.density = 2500
+            r0.conductivity = 2.5
+            r0.specific_heat=1000
+            dat.grid.add_rocktype(r0)
+        dat.grid.block[blockname].rocktype = dat.grid.rocktype[newrtname]
+
+    dat.grid.clean_rocktypes()
+    dat.grid.sort_rocktypes()

gimms/core.py

@@ -0,0 +1,3 @@
+def greet(name: str = "world") -> str:
+    """Return a friendly greeting."""
+    return f"Hello, {name}!"

gimms/createBackgroundHeat.py

@@ -0,0 +1,18 @@
+from t2data import t2generator
+
+def create_background_heat(geo, dat, heatperarea):
+
+    layer=geo.layerlist[-1] # bottom layer
+
+    cols=[col for col in geo.columnlist]
+
+    for col in cols:
+        blockname=geo.block_name(layer.name,col.name)
+        area = col.area
+
+        genname = col.name+'88'
+        #print area2
+
+        gen=t2generator(name=genname,block=blockname,type='HEAT',gx=heatperarea*area)
+        dat.add_generator(gen)
+

gimms/createIncon_EWA_withWater.py

@@ -0,0 +1,25 @@
+
+def create_incon(geo, dat, waterCols, waterElevation, P0, S0, T0):
+
+    inc = dat.grid.incons([P0, S0+10.0, T0])
+
+    # approximate initial conditions:
+    rho = 998.
+    g = 9.81
+    for blk in dat.grid.blocklist:
+        if blk.name[3:5] == ' 0':
+            if blk.name[0:3] not in waterCols:
+                inc[blk.name] = [P0, 10.0+S0, T0]
+            else:
+                d = waterElevation-geo.column[blk.name[0:3]].surface
+                if d < 0.0:
+                    print('Error! Depth less than 0.0 for column ',blk.name[3:5])
+                P = P0 + rho * g * d
+                inc[blk.name] = [P, 1.0e-6, T0]
+        else:
+            d = geo.column[blk.name[0:3]].surface-blk.centre[2]
+            P = P0 + rho * g * d
+            T = T0 + 30.0 * d / 1000.0
+            inc[blk.name] = [P, 1.0e-6, T]
+
+    return inc

gimms/createRainfall.py

@@ -0,0 +1,20 @@
+from t2data import t2generator
+
+
+def create_rainfall(geo, dat, infil, annrainkgsm2, enthalpy, excludecols):
+    massperarea = infil*annrainkgsm2
+
+    for col in geo.columnlist:
+        if col.name in excludecols:
+            continue
+        massperarea = infil*annrainkgsm2
+        layer = geo.column_surface_layer(col)
+        blockname=geo.block_name(layer.name,col.name)
+        area = col.area
+
+        genname = col.name+'99'
+        #print area2
+
+        gen=t2generator(name=genname,block=blockname,type='MASS',gx=massperarea*area,ex=enthalpy)
+        dat.add_generator(gen)
+

gimms/createRefinedPolygonRock.py

@@ -0,0 +1,23 @@
+from t2data import rocktype
+
+def create_rock_in_polygon(geo, dat, column_poly, polygon_rock_code):
+    for col in geo.columns_in_polygon(column_poly):
+        #print col.name
+        for lay in geo.layerlist[1:]:
+            blkname = col.name+lay.name
+            try:
+                oldrtname = dat.grid.block[blkname].rocktype.name
+                newrtname = oldrtname[0:4]+polygon_rock_code
+                if newrtname not in dat.grid.rocktype.keys():
+                    r0=rocktype(name=newrtname,permeability=dat.grid.rocktype[oldrtname].permeability)
+                    r0.porosity = dat.grid.rocktype[oldrtname].porosity
+                    r0.density = dat.grid.rocktype[oldrtname].density
+                    r0.conductivity = dat.grid.rocktype[oldrtname].conductivity
+                    r0.specific_heat=dat.grid.rocktype[oldrtname].specific_heat
+                    dat.grid.add_rocktype(r0)
+                dat.grid.block[blkname].rocktype = dat.grid.rocktype[newrtname]
+            except KeyError:
+                None
+
+    dat.grid.sort_rocktypes()
+    dat.grid.clean_rocktypes()

gimms/createReservoirRock.py

@@ -0,0 +1,37 @@
+from t2data import rocktype
+
+def create_reservoir_rock(geo, dat):
+    for col in geo.columnlist:
+        belowCap = False
+        capFound = False
+        #print col.name
+        for lay in geo.layerlist[1:]:
+            blkname = col.name+lay.name
+            try:
+                oldrtname = dat.grid.block[blkname].rocktype.name
+                if not capFound:
+                    if oldrtname[3] == 'A':
+                        #print 'Cap Found = ',blkname
+                        capFound = True
+                else:
+                    if oldrtname[3] != 'A':
+                        belowCap = True
+                        #print 'Below Cap = ',blkname
+                if oldrtname[3] == '0': continue
+                if not belowCap: continue
+                if oldrtname[3] == 'A': hello
+                #print 'In Reservoir = ',blkname
+                newrtname = oldrtname[0:3]+'2'+oldrtname[4]
+                if newrtname not in dat.grid.rocktype.keys():
+                    r0=rocktype(name=newrtname,permeability=dat.grid.rocktype[oldrtname].permeability)
+                    r0.porosity = dat.grid.rocktype[oldrtname].porosity
+                    r0.density = dat.grid.rocktype[oldrtname].density
+                    r0.conductivity = dat.grid.rocktype[oldrtname].conductivity
+                    r0.specific_heat=dat.grid.rocktype[oldrtname].specific_heat
+                    dat.grid.add_rocktype(r0)
+                dat.grid.block[blkname].rocktype = dat.grid.rocktype[newrtname]
+            except KeyError:
+                None
+
+    dat.grid.sort_rocktypes()
+    dat.grid.clean_rocktypes()

gimms/execfile3.py

@@ -0,0 +1,27 @@
+import sys
+
+if sys.version_info[0] >= 3:
+
+    def execfile3(filepath, globals=None, locals=None):
+
+        if globals is None:
+
+            globals = {}
+
+        globals.update({
+
+            "__file__": filepath,
+
+            "__name__": "__main__",
+
+        })
+
+        with open(filepath, 'rb') as file:
+
+            exec(compile(file.read(), filepath, 'exec'), globals, locals)
+
+else:
+
+    def execfile3(filepath, globals=None, locals=None):
+
+        execfile(filepath,globals)

gimms/plotAllFaultPerms.py

@@ -0,0 +1,103 @@
+
+
+import numpy as np
+from matplotlib import pyplot as plt
+from PyPDF2 import PdfWriter, PdfReader
+
+import os
+from pathlib import Path
+
+# Creating a routine that appends files to the output file
+def append_pdf(input,output):
+    [output.add_page(input.pages[page_num]) for page_num in range(len(input.pages))]
+
+
+def plot_fault_perms(geo, dat):
+
+    outputpath = 'Reports/'
+    Path(outputpath).mkdir(parents=True, exist_ok=True)
+
+    # Creating an object where pdf pages are appended to
+    output = PdfWriter()
+
+    infiles = []
+
+    fblks = {}
+
+    for lay in geo.layerlist[:0:-1]:
+        layername = lay.name
+        #print lay.name
+
+        fcols = []
+        porout = []
+        connscolour = {}
+
+        for col in geo.columnlist:
+            if col.name+layername in geo.block_name_list:
+                rtname = dat.grid.block[col.name+layername].rocktype.name
+                if rtname == '0ATM1':
+                    porout.append(0.8)
+                elif rtname[1] == '0':
+                    porout.append(0.5)
+                else:
+                    fcols.append(col.name)
+                    porout.append(0.0)
+            else:
+                porout.append(1.0)
+
+        #print 'Columns done'
+
+        checkcons = []
+        checkdatcons = []
+
+        for fcol in fcols:
+            for con in geo.column[fcol].connection:
+                col1 = con.column[0]
+                col2 = con.column[1]
+                try:
+                    datcon = dat.grid.connection[(col1.name+layername,col2.name+layername)]
+                except KeyError:
+                    try:
+                        datcon = dat.grid.connection[(col1.name+layername,col2.name+layername)]
+                    except KeyError:
+                        continue
+                checkcons.append(con)
+                checkdatcons.append(datcon)
+        #print 'Plotting'
+
+        plt.gcf()
+        plt.clf()
+        plt.rc('font',size=6)
+
+        geo.layer_plot(plt=plt,layer=layername, variable=porout ,colourmap='binary',colourbar_limits=[0.0,1.0],linewidth=0.1)
+        for con,datcon in zip(checkcons,checkdatcons):
+            permdir = datcon.direction
+            if permdir == 1:
+                connscolour[con] = [[con.node[0].pos[0],con.node[1].pos[0]],[con.node[0].pos[1],con.node[1].pos[1]],'b-']
+                #plt.plot([con.node[0].pos[0],con.node[1].pos[0]],[con.node[0].pos[1],con.node[1].pos[1]],'b-')
+            elif permdir == 2:
+                connscolour[con] = [[con.node[0].pos[0],con.node[1].pos[0]],[con.node[0].pos[1],con.node[1].pos[1]],'r-']
+            else:
+                connscolour[con] = [[con.node[0].pos[0],con.node[1].pos[0]],[con.node[0].pos[1],con.node[1].pos[1]],'lime']
+                #plt.plot([con.node[0].pos[0],con.node[1].pos[0]],[con.node[0].pos[1],con.node[1].pos[1]],'r-')
+            #print col1, col2
+
+        for cc in connscolour:
+            plt.plot(connscolour[cc][0],connscolour[cc][1],connscolour[cc][2],linewidth=0.2)
+
+        filename = outputpath+'all_perm_dir_'+layername+'.pdf'
+        plt.savefig(filename,dpi=600,orientation='portrait')
+        infile = open(filename,'rb')
+        append_pdf(PdfReader(infile),output)
+        infiles.append(infile)
+        #plt.show()
+
+        # Writing all the collected pages to a file
+    output.write(open(outputpath+'all_perm_dir.pdf','wb'))
+
+    for i in infiles:
+        i.close()
+    for lay in geo.layerlist[:0:-1]:
+        layername = lay.name
+        filename = outputpath+'all_perm_dir_'+layername+'.pdf'
+        os.remove(filename)

gimms/plotAllFaultVertPermDir.py

@@ -0,0 +1,96 @@
+
+from matplotlib import pyplot as plt
+from PyPDF2 import PdfWriter, PdfReader
+from matplotlib.colors import ListedColormap
+
+import os
+import json
+
+# Creating a routine that appends files to the output file
+def append_pdf(input,output):
+    [output.add_page(input.pages[page_num]) for page_num in range(len(input.pages))]
+
+def plot_fault_vert_perm_dir(geo, dat):
+
+    blkrtnames = {}
+
+    outputpath = 'Reports/'
+
+    # Creating an object where pdf pages are appended to
+    output = PdfWriter()
+
+    infiles = []
+
+    fblks = {}
+
+    cmapTemp = ListedColormap([
+    'white', # not dug
+    'blue', #  10
+    'red', #  20
+    'lime', #  30
+    'grey', #  40
+    ])
+
+    for lay in geo.layerlist[:0:-1]:
+        layername = lay.name
+        print (lay.name)
+        uplayer = geo.layerlist[(geo.layerlist.index(lay)-1)]
+        print (uplayer.name)
+
+        fcols = []
+        porout = []
+        connscolour = {}
+
+        for col in geo.columnlist:
+            try:
+                rtname = dat.grid.block[col.name+layername].rocktype.name
+                if rtname[1] != '0':
+                    permdir = 3
+                    try:
+                        datcon = dat.grid.connection[(col.name+layername,col.name+uplayer.name)]
+                        permdir = datcon.direction
+                    except KeyError:
+                        try:
+                            datcon = dat.grid.connection[(col.name+uplayer.name,col.name+layername)]
+                            permdir = datcon.direction
+                        except KeyError:
+                            pass
+                    #print rtname, col.name, layername, uplayer.name, permdir
+                    if permdir == 1:
+                        porout.append(0.3)
+                    elif permdir == 2:
+                        porout.append(0.5)
+                    else:
+                        porout.append(0.7)
+                else:
+                    porout.append(0.1)
+            except KeyError:
+                porout.append(1.0)
+
+        print ('Columns done')
+
+        print ('Plotting')
+
+        plt.gcf()
+        plt.clf()
+        plt.rc('font',size=6)
+
+        geo.layer_plot(plt=plt,layer=layername, variable=porout ,colourmap=cmapTemp,title='Layer '+layername+': '+str(lay.bottom)+' to '+str(lay.top),colourbar_limits=[0.0,1.0])#,plot_limits=((6000,12000),(2000,8000)))
+
+        filename = 'all_vperm_dir_'+layername+'.pdf'
+        plt.savefig(filename,dpi=600,orientation='portrait')
+        infile = open(filename,'rb')
+        append_pdf(PdfReader(infile),output)
+        infiles.append(infile)
+        #plt.show()
+
+        # Writing all the collected pages to a file
+    output.write(open(outputpath+'all_vert_perm_dir.pdf','wb'))
+
+    for i in infiles:
+        i.close()
+
+    for lay in geo.layerlist[:0:-1]:
+        layername = lay.name
+        filename = 'all_vperm_dir_'+layername+'.pdf'
+        os.remove(filename)

gimms/renameAlterationfromDat.py

@@ -0,0 +1,30 @@
+from mulgrids import *
+from t2data import *
+from collections import Counter
+
+def most_common(lst):
+    data = Counter(lst)
+    return data.most_common(1)[0][0]
+    
+def rename_alteration(geo, dat, datf, geof):
+    qtree = geo.column_quadtree()
+
+    for blkname in geof.block_name_list[1:]:
+        if datf.grid.block[blkname].rocktype.name[0:4] == '000A':
+            frt = datf.grid.block[blkname].rocktype.name
+            newblk = geo.block_name_containing_point(datf.grid.block[blkname].centre,qtree=qtree)
+            if not newblk: continue
+            currt = dat.grid.block[newblk].rocktype.name
+            newrtname = currt[0:3]+'A'+currt[4]
+            if newrtname not in dat.grid.rocktype.keys():
+                r0=rocktype(name=newrtname,permeability=[1.e-16,1.e-16,1.e-16])
+                r0.porosity = .1
+                r0.density = 2500
+                r0.conductivity = 2.5
+                r0.specific_heat=1000
+                dat.grid.add_rocktype(r0)
+            dat.grid.block[newblk].rocktype = dat.grid.rocktype[newrtname]
+
+    dat.grid.clean_rocktypes()
+    dat.grid.sort_rocktypes()
+

gimms/renameFaultsfromDat.py

@@ -0,0 +1,33 @@
+from mulgrids import *
+from t2data import *
+from collections import Counter
+
+def most_common(lst):
+    data = Counter(lst)
+    return data.most_common(1)[0][0]
+    
+def rename_faults(geo, dat, datf, geof):
+    qtree = geo.column_quadtree()
+
+    for blkname in geof.block_name_list[1:]:
+        if datf.grid.block[blkname].rocktype.name not in ['00001','atmos']:
+            frt = datf.grid.block[blkname].rocktype.name
+            newblk = geo.block_name_containing_point(datf.grid.block[blkname].centre,qtree=qtree)
+            if not newblk: continue
+            currt = dat.grid.block[newblk].rocktype.name
+            newrtname = currt[0]+frt[0:2]+currt[3:5]
+            if newrtname not in dat.grid.rocktype.keys():
+                if newrtname[3] == 'A':
+                    r0=rocktype(name=newrtname,permeability=[1.e-16,1.e-16,1.e-16])
+                else:
+                    r0=rocktype(name=newrtname,permeability=[1.e-15,1.e-15,1.e-15])
+                r0.porosity = .1
+                r0.density = 2500
+                r0.conductivity = 2.5
+                r0.specific_heat=1000
+                dat.grid.add_rocktype(r0)
+            dat.grid.block[newblk].rocktype = dat.grid.rocktype[newrtname]
+
+    dat.grid.clean_rocktypes()
+    dat.grid.sort_rocktypes()
+

gimms/renameUnknown.py

@@ -0,0 +1,15 @@
+
+
+def rename_unknown_rock(geo, dat):
+    for blkname in geo.block_name_list:
+        if dat.grid.block[blkname].rocktype.name == 'UNK 1':
+            #print blkname
+            dlay = geo.layer[(' '+str(int(blkname[3:5])+1))[-2:]]
+            dblkname = blkname[0:3]+dlay.name
+            rtbelowname = dat.grid.block[dblkname].rocktype.name
+            #print dblkname, rtbelowname
+            dat.grid.block[blkname].rocktype = dat.grid.rocktype[rtbelowname]
+            #print blkname, oldrtname, newrtname, len(rtlist)
+
+    dat.grid.clean_rocktypes()
+    dat.grid.sort_rocktypes()

gimms/set_AUTOUGH2_EWA_standard_pararmeters.py

@@ -0,0 +1,50 @@
+
+def set_standard_parameters(dat):
+
+    print ("   *** Setting up Simulation Parameters ***")
+    #Parameters
+    dat.parameter['max_iterations'] = 0
+    dat.parameter['print_level'] = 3
+    dat.parameter['max_timesteps'] = 9999
+    dat.parameter['max_duration'] = 0
+    dat.parameter['print_interval'] = 9999
+    dat.parameter['tstart'] = 0.0
+    dat.parameter['tstop'] = 1e16
+    dat.parameter['const_timestep'] = 1000.
+    dat.parameter['timestep_reduction'] = 5.0
+
+    dat.parameter['gravity'] = 9.81
+    dat.parameter['option'][1] = 1
+    dat.parameter['option'][11] = 2
+    dat.parameter['option'][12] = 2
+    dat.parameter['option'][16] = 5
+    dat.parameter['option'][18] = 2
+    dat.parameter['option'][24] = 2
+    dat.parameter['default_incons'] = [1.04395e5, 9.8087e-7, 25]
+
+    dat.start = False
+
+    print ("   *** Setting up RPCAP Parameters  ***")
+    #RPCAP
+    dat.relative_permeability['type'] = 1.0
+    dat.relative_permeability['parameters'] = [0.5, 0.0, 1.0, 0.5]
+    dat.capillarity['type'] = 1
+    dat.capillarity['parameters'] = [0.0, 0.0, 1.0]
+
+    print ("   *** Linear Equation Solver Parameters  ***")
+    #LINEQ
+    dat.lineq['type'] = 2
+    dat.lineq['epsilon'] = 1e-11
+    dat.lineq['max_iterations'] = 999
+    dat.lineq['num_orthog'] = 100
+    dat.lineq['gauss'] = 1
+
+    print ("   *** EOS Configuration  ***")
+    #MULTI
+    dat.multi['num_components'] = 2
+    dat.multi['num_equations'] = 3
+    dat.multi['num_phases'] = 2
+    dat.multi['num_secondary_parameters'] = 6
+    dat.multi['eos'] = 'EWA'
+
+    dat.simulator = 'AUTOUGH2.2EWA'

gimms-0.0.2.dist-info/METADATA

@@ -0,0 +1,38 @@
+Metadata-Version: 2.4
+Name: gimms
+Version: 0.0.2
+Summary: A Python package for setting up TOUGH2 model from Leapfrog, based on JPO's script..
+Author-email: Angus Yeh <a.yeh@auckland.ac.nz>, John O'Sullivan <jp.osullivan@auckland.ac.nz>
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.8
+Requires-Dist: matplotlib
+Requires-Dist: pypdf2
+Requires-Dist: pytough
+Description-Content-Type: text/markdown
+
+gimms
+=====
+
+A minimal Python package scaffold for the gimms package.
+
+Usage:
+
+    pip install .
+
+Run tests with pytest.
+
+
+## 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

gimms-0.0.2.dist-info/RECORD

@@ -0,0 +1,22 @@
+gimms/__init__.py,sha256=Cf-VaLaSUHANyIbAZLawrVM8Q7bBgebP5hAIXnNxYKk,97
+gimms/__version__.py,sha256=ShXQBVjyiSOHxoQJS2BvNG395W4KZfqMxZWBAR0MZrE,22
+gimms/applyFaultPerms.py,sha256=B8sNToIDA6WmYRqDRVMv5QwdbuXdiShSnPHliNNIM2I,4486
+gimms/applyVerticalFaultPerms.py,sha256=HuOk_N0GLYbaimsTHpTHk7cNDHMMIO66k1Y4f9tbZ9w,7468
+gimms/connectSurface.py,sha256=TSfyr02UIDNbBDh_h31YgpF1Jz4JhW7b2Ib049JO_gE,2553
+gimms/core.py,sha256=NsR4e25xFWIdeQtI3HXlZ8b_BZmj4nxq8y0Rzk3vtPE,106
+gimms/createBackgroundHeat.py,sha256=j2w6AiUqXt0OPlVuOQLuyZ6NDVb725q0b56r6GGPCq8,460
+gimms/createIncon_EWA_withWater.py,sha256=ts4exRYrX53mPNtqfBAufPIOWb2G0AYFZcDayz3RJJ8,863
+gimms/createRainfall.py,sha256=ElsgxrOiNijRdGEiARvDOWjZYiAsVIsIeG60iDtn49o,604
+gimms/createRefinedPolygonRock.py,sha256=QLaWllIMB8HgzsiafGHVx-OUdOAJBaxnen-BtYEctck,1125
+gimms/createReservoirRock.py,sha256=2-7ju0rYUw2MHJFv1Kaaj8J5mu0VCZvsOv4HziSZxFQ,1651
+gimms/execfile3.py,sha256=ETTn2T4JAv-wogKeuZZ3xdEYjLKWEJiwZIr-JlM5e8w,481
+gimms/plotAllFaultPerms.py,sha256=_if_ORqX6kIiMRQD6fi-F19XfgEuH7CwV2HUxJTLtLE,3645
+gimms/plotAllFaultVertPermDir.py,sha256=6fwNx_w40wjAqWovEUluSEUHXztt7JZOWU5tmL2_tyw,3007
+gimms/renameAlterationfromDat.py,sha256=tjlfYVtKS2NvcGPpnTvCSXxPue5k36LjsQ5tKYvhRso,1143
+gimms/renameFaultsfromDat.py,sha256=vbzd-MBE0fq7Qm7_l4NFe5kp35j9VxQg7VReqnhib8U,1307
+gimms/renameUnknown.py,sha256=D4qveL-OG0Vhs4OOqJhUAjbyRb-9i_cbqu7qAd6dYMo,600
+gimms/set_AUTOUGH2_EWA_standard_pararmeters.py,sha256=CXEVm-t7u5s2QQFQRGxo2zK-tICCWg5gelqQrX9MKI0,1620
+gimms-0.0.2.dist-info/METADATA,sha256=OAAbyDV8z55sXputjzKoM6sHb146Fxi2XvRjdy0rom0,703
+gimms-0.0.2.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+gimms-0.0.2.dist-info/licenses/LICENSE,sha256=v2spsd7N1pKFFh2G8wGP_45iwe5S0DYiJzG4im8Rupc,1066
+gimms-0.0.2.dist-info/RECORD,,

gimms-0.0.2.dist-info/WHEEL

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

gimms-0.0.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Your Name
+
+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.