Refactor Enclosure to Class, improve other D3D functions, WIP: Class that reads D3D model folder and displays it in a human readable way

Author: JulesBlm

JulesD3D/D3DModel.py

@@ -0,0 +1,70 @@
+import matplotlib.pyplot as plt
+import matplotlib.patheffects as PathEffects
+from mpl_toolkits.mplot3d import Axes3D
+import pandas as pd
+import numpy as np
+from JulesD3D.dep import Depth
+from JulesD3D.grid import Grid
+from JulesD3D.enc import Enclosure
+from JulesD3D.bnd import Boundaries
+from os import path, walk
+from cmocean.cm import deep
+
+colormap = deep
+
+# Make this class containing objects of grid, bnd, enc, depth, mdf, sed files, bcc, bct
+
+class D3DModel(object):
+    '''
+    Read a folder containing Delft3D4-FLOW files
+    '''
+    def __init__(self, *args, **kwargs):
+        print("Ayyyyeyeyeye")
+    
+    def __repr__(self):
+        return "Reads all Delft3D files in a folder"
+    
+    @staticmethod
+    def readFolder(folderpath):
+        if not path.exists(folderpath):
+            raise Exception('Looks like read folder does not exist, aborting')
+    
+        basename = path.basename(folderpath)
+        plot_title, _ = path.splitext(basename)
+        title = basename
+
+        all_filenames = []
+
+        # Find filenames in template/read folder
+        for root, dirs, files in walk(folderpath):
+            for file in files:
+                if file.endswith('bnd'):
+                    bnd_filename = path.join(folderpath, file)
+                    all_filenames.append({"type": "Boundary", "filename": path.split(bnd_filename)[1]})
+                elif file.endswith('dep'):
+                    dep_filename =  path.join(folderpath, file)
+                    all_filenames.append({"type": "Depth", "filename": path.split(dep_filename)[1]})
+                elif file.endswith('enc'):
+                    enc_filename =  path.join(folderpath, file)
+                    all_filenames.append({"type": "Enclosure", "filename":path.split(enc_filename)[1]})
+                elif file.endswith('grd'):
+                    grid_filename = path.join(folderpath, file)
+                    all_filenames.append({"type": "Grid", "filename":path.split(grid_filename)[1]})
+
+        files_df  = pd.DataFrame(data=all_filenames)
+        display(files_df)
+        
+        self.filenames = all_filenames
+        
+    # def readGrid(self):
+        
+    #     grid = Grid.read(grid_filename)
+    #     grid.shape
+
+    #     dep = Depth.read(dep_filename, grid.shape)
+    #     depth = dep.values[0:-1,0:-1]
+        
+    #     boundary_coords = bnd.readBnd(fname=bnd_filename)
+        
+        # enclosure_x, enclosure_y = readEnc(enc_filename)
+

JulesD3D/DepthModel.py

@@ -1,12 +1,13 @@
 # TODO
+# * Not sure if this is how to Class in Python  ¯\_(ツ)_/¯
 # * Fix bank_index (center) mess!
 # * Make nice n clear repr string
 # * Smoothen slope break direction independent
 
 from JulesD3D.dep import Dep
 from JulesD3D.grid import Grid
 from JulesD3D.enc import writeEncFileWithChannel, writeSimpleEncFile
-from JulesD3D.bnd import bnd
+# from JulesD3D.bnd import Boundaries
 import bezier
 import numpy as np
 import math, os
@@ -43,7 +44,6 @@ def makeNewGrid(self):
         print("width", self.grid['width'])
         print("length", self.grid['length'])
 
-        
         if self.grid['width'] % self.grid['x_gridstep']:
             raise Exception("Width is not a multiple of x_gridstep")
         if self.grid['length'] % self.grid['y_gridstep']:        
@@ -251,13 +251,14 @@ def generateBathymetrySlopeBreak(self):
 
         return depth_matrix_with_channel.T
 
+    @staticmethod
     def makeModelAtOnce(self):
         '''
         Performs all the generation steps and writing files at once in the right order
         '''
         self.makeNewGrid()
         self.writeGridFile()
-        self.generateBathymetrySlopeBreak()      
+        self.generateBathymetrySlopeBreak()
         self.writeDepFile()
 
     def plotCrossSection(self):

JulesD3D/bnd.py

@@ -1,33 +1,34 @@
 import pandas as pd
 
-class bnd():
-    '''Delft3d boundary definition file'''
-    # def __init__(self, fname=None):
-    #     self.readBnd(fname)
-    #     # self.read_bnd(fname)
+class Boundaries():
+    '''
+    Delft3D boundary definition file .bnd
+    '''
+    def __init__(self, fname=None):
+        self.readBnd(self, fname)
 
     def readBnd(fname=None): # self?
         '''Read a Delft3d boundary definition file, return list of coordinated for plotting'''
         if not fname:
-            print("No file name supplied!")
-            return
+            raise Exception("No boundary filename given!")
 
         column_names = ['name','type','forcing','m1','n1','m2','n2',
                         'reflection coefficient','vertical profile',
                         'label1','label2']
 
-        data = pd.read_csv(fname, delim_whitespace=True,
+        bnd_data = pd.read_csv(fname, delim_whitespace=True,
                         header=None, names=column_names)
 
-        display(data)
+        display(bnd_data)
 
         boundary_coords = []
-        nr_of_bounds = data.shape[0]
+        nr_of_bounds = bnd_data.shape[0]
         for i in range(nr_of_bounds):
-            boundary_coords.append(([data.m1[i], data.n1[i]], [data.m2[i], data.n2[i]]))
+            boundary_coords.append(([bnd_data.m1[i], bnd_data.n1[i]], [bnd_data.m2[i], bnd_data.n2[i]]))
 
         return boundary_coords
 
+    # for plotting boundary locations 
     def getXY(coords):
         bc_x_coords, bc_y_coords = [[], []]
         for bnd in coords:

JulesD3D/bndDemo.py

@@ -11,10 +11,7 @@ def __init__(self, fname=None):
     def read_bnd(self, fname=None):
         '''Read a Delft3d boundary definition file'''
         if not fname:
-            print("No boundary filename given!")
-            return
-        else:
-            fname = fname
+            raise Exception("No boundary filename given!")
 
         column_names = ['name','type','forcing','m1','n1','m2','n2',
                         'reflection coefficient','vertical profile',

JulesD3D/dep.py

@@ -43,31 +43,33 @@ def formatSci(floatNr):
 
 import numpy as np
 
-class Dep(object):
+class Depth(object):
     """Create a Delft3D dep file
-    # Create an dep grid
-    dep = dep()
-    # Load a dep from file
-    grid = Grid.fromfile('filename.grd')
-    dep  = Dep.read('filename.dep',grid.shape)
-    # Write dep to file
-    Dep.write(dep,'filename.dep')"""
+    Create an dep grid
+        dep = Depth()
+    
+    Load a dep from file (grid has to be loaded first)
+        grid = Grid.read('filename.grd')
+        dep  = Depth.read('filename.dep',grid.shape)
+    
+    Write dep to file
+        Depth.write(dep,'filename.dep')"""
 
     def __init__(self, *args, **kwargs):
         self.properties = {}
         self.shape = None
         self.dep   = None
 
     def copy(self):
-        copy = Dep()
+        copy = Depth()
         copy.shape = self.shape
         copy.values = self.values.copy()
 
         return copy
 
     @staticmethod
     def read(filename, gridshape, **kwargs):
-        dep = Dep()
+        dep = Depth()
         with open(filename, 'r') as f:
             strings = f.read()
 #             f.close

JulesD3D/enc.py

@@ -1,57 +1,120 @@
 import pandas as pd
+# check yDim, xDim are off by one or not
 
-# TODO turn into class with these functions as its methods
-def readEnc(filename=None):
-    '''Read a Delft3d enclosure file. Return list of x coordinates and list of y coordinates for easy plotting of enclosure'''
-    if not filename:
-        print("No file name supplied!")
-        return
-    enclosure_x = []
-    enclosure_y = []
-    with open(filename,'r') as f:
-        for i, line in enumerate(f):
-            # boy this is hacky change to list comprehension?
-            enclosure_x.append(int(line.split("   ")[1]))
-            enclosure_y.append(int(line.split("   ")[2]))
-            
-    enc_coords = {'x': enclosure_x, 'y': enclosure_y}
-    coords_df = pd.DataFrame(data=enc_coords)            
-    
-    display(coords_df)
-    
-    return enclosure_x, enclosure_y
+#  demo enc function
+# writeEncFileWithChannel(xDim, yDim, new_filename=self.filenames['enc'],
+#                         bank_left=bank_left, bank_right=bank_right+2,
+#                         channel_length_index=channel_length_index-1)
 
-# Remember: Enclosure needs to be larger than boundary locations!
+# demo make new grid
+# newGrid = Grid()
+# newGrid.x = self.grid['x_grid'] # matrix
+# newGrid.y = self.grid['y_grid'] # matrix
+# newGrid.shape = self.grid['shape'] # list
+# newGrid.properties = {'Coordinate System': 'Cartesian', 'xori': 0.0, 'yori': 0.0, 'alfori': 0.0}
+# Grid.write(newGrid, self.filenames['grid'])
 
-
-# SIMPLE ENCLOSURE FILE spanning complete domain
-def writeSimpleEncFile(xDim, yDim, new_enc_filename=None):
-    ''' Write rectangular enclosure'''
-    if not new_enc_filename:
-        print("No .enc filename specified aborting!")
+class Enclosure():
+    '''
+    Create a Delft3D enclosure file
+    Enclosure excludes gridcells from computation
+    
+    Create a new enclosure
+        enc = Enclosure()
     
-    enclosureX = [1, xDim + 1, xDim + 1, 1, 1]
-    enclosureY = [1, 1, yDim + 1, yDim + 1, 1]
+    Load a enclosure from .enc file
+        enc = Enclosure.read('channelonly.enc')
     
-    print(" ----- Writing simple rectangular enclosure -----")    
-    with open(new_enc_filename, 'w') as enclosureOutfile:
-        zipped = list(zip(enclosureX, enclosureY)) # merge x and y lists
-        enclosureLines = [('{:>6}{:>6}\n'.format(line[0], line[1])) for line in zipped] # would line for line in work as well?
-        enclosureOutfile.writelines(enclosureLines)
-
-def writeEncFileWithChannel(xDim, yDim, new_enc_filename=None, bank_left=None, bank_right=None, channel_length_index=None): # Add channel_width argument
-    ''' Write enclosure file, ignoring 'banks' around channel'''
-    if not new_enc_filename:
-        raise Exception("No enclosure file name supplied!")
+    Write enclosure to .enc file
+        Enclosure.writeSimpleEnc(enc, 'complete.enc')
     
-    print(" ----- Writing enclosure file with channel -----")
-    enclosureX = [1, bank_left, bank_left, bank_right, bank_right, xDim+1, xDim+1, 1, 1]  
-    enclosureY = [channel_length_index, channel_length_index, 1, 1, channel_length_index, channel_length_index, yDim+1, yDim+1, channel_length_index]
+    Remember: Enclosure needs to be larger than boundary locations!
+    '''
+    def __init__(self, *args, **kwargs):
+        self.dims = kwargs.get('dims')
+        if not self.dims:
+            raise Exception("No tuple of dimenstinos provided?")
+        self.filename = kwargs.get('filename')
+        xDim, yDim = self.dims
+        
+        if kwargs.get("channel_length_index"):
+            self.channel_length_index = kwargs.get("channel_length_index")
+            self.bank_left = kwargs.get('bank_left')
+            self.bank_right = kwargs.get('bank_right')
+            self.x = [1, self.bank_left, self.bank_left, self.bank_right, self.bank_right, xDim+1, xDim+1, 1, 1]
+            self.y = [self.channel_length_index, self.channel_length_index, 1, 1, self.channel_length_index, self.channel_length_index, yDim+1, yDim+1, self.channel_length_index]
+        elif kwargs.get('read_filename'):
+            self.x = kwargs.get('x') # list of x coords
+            self.y = kwargs.get('y') # list of y coords
+        else: 
+            self.x = [1, xDim + 1, xDim + 1, 1, 1]
+            self.y = [1, 1, yDim + 1, yDim + 1, 1]
+
+
+    def __repr__(self):
+        repr_string = f"New Enclosure with xDim {self.dims[0]} and yDim {self.dims[1]}"
+        
+        # if self.channel_length_index and self.bank_left and self.bank_right: # can't acces these properties if they are not arguments to Enclosure
+        #     repr_string += f" with channel at y = {self.channel_length_index} from {self.bank_left} to {self.bank_right}"
+            
+        return repr_string
 
-    with open(new_enc_filename, 'w') as enclosureOutfile:
-        zipped = list(zip(enclosureX, enclosureY))
-        enclosureLines = [('{:>6}{:>6}\n'.format(line[0], line[1])) for line in zipped] # print both padded to 6 characters wide
-#         [print(enclosureLine) for enclosureLine in enclosureLines]
-        enclosureOutfile.writelines(enclosureLines)
+    def display(self):
+        enc_coords = {'x': self.x, 'y': self.y}
+        enc_coords_df = pd.DataFrame(data=enc_coords)
+
+        return display(enc_coords_df)
+
+    @staticmethod
+    def read(filename=None):
+        '''Read a Delft3d enclosure file. Return list of x coordinates and list of y coordinates for easy plotting of enclosure'''
+        if not filename:
+            raise Exception("No file name supplied!")
+                
+        with open(filename, 'r') as f:
+            enc_coords = [(int(line.split("   ")[1]), int(line.split("   ")[2])) for line in f]
+
+            enc_x, enc_y = zip(*enc_coords) # unzip
+        
+            xDim = max(enc_x)
+            yDim = max(enc_y)
+            dims = (xDim, yDim)
+            
+            # how do i know from read file wether is has channel
+            
+            enc = Enclosure(dims=dims, read_filename=True, x=enc_x, y=enc_y)
+            
+            Enclosure.x = enc_x
+            Enclosure.y = enc_y
+
+            enc_coords = {'x': enc_x, 'y': enc_y}
+            enc_coords_df = pd.DataFrame(data=enc_coords)
+            
+            display(enc_coords_df)
+            
+            Enclosure.filename = filename
+            
+            return enc
+
+    def write(self): # Add channel_width argument
+        '''
+        Write enclosure file,
+        * with_channel: option to ignore 'banks' around channel
+        '''
+        if not self.filename:
+            raise Exception("No enclosure filename supplied!")
+        
+        if not self.channel_length_index or not self.bank_left or not self.bank_right:
+            raise Exception("bank_left, bank_right, and channel_length_index keyword arguments have to be provided when excluding areas from enclosure!")
+            print(" ----- Writing enclosure file excluding channel -----")
+        else:
+            print(" ----- Writing simple (rectangular) enclosure -----")
+        
+        with open(self.filename, 'w') as enclosureOutfile:
+            zipped = list(zip(self.x, self.y))
+            enclosureLines = [('{:>6}{:>6}\n'.format(line[0], line[1])) for line in zipped] # pad both to 6 characters wide
+            enclosureOutfile.writelines(enclosureLines)
+
+        print(" ----- Wrote new .enc file to", self.filename)
 
-    return [enclosureX, enclosureY]
+        return [self.x, self.y]