Initial commit

plotter/Args.py

+class Args:
+    def __init__(self, filename, func, var=[None], mval=[None], oname=[None], out=[None]):
+        self.filename = filename
+        self.var = var
+        self.mval = mval
+        self.oname = oname
+        self.out = out
+        self.func = func
+
+        self.CorrVals()
+
+    def CorrVals(self):
+        if type(self.oname) is not list:
+            self.oname = [self.oname]
+        if None in self.oname:
+            self.oname = None
+
+        if type(self.var) is not list:
+            self.var = [self.var]
+        if None in self.var:
+            self.var = None
+
+        if type(self.mval) is not list:
+            self.mval = [self.mval]
+        if None in self.mval:
+            self.mval = None
\ No newline at end of file

plotter/Plotter.py

+import numpy as np
+import matplotlib.pyplot as plt
+import os
+import sys
+import shutil
+import natsort
+import imageio
+from .ProcData import ProcData
+import copy
+
+class Plotter:
+    ani_pngs_dir = "plotter_lib_pngs/"
+
+    def __init__(self):
+        self.filename = ""
+        self.out = ""
+        self.oname = ""
+        self.var = ""
+        self.mval = ""
+        self.function = ""
+        self.variable_names = ""
+
+    def __check_arg_dim_equiv(self, args):
+        if args.var != None and args.mval != None:
+            if len(args.var) != len(args.mval):
+                print("The count of var assumed to be equal to the count of mval")
+                sys.exit(-1)
+
+    def __get_variable_names(self):
+        var_names = []
+
+        for d in self.data:
+            names = d.variable_names
+            var_names.append(np.array(names, dtype=object))
+            
+            
+        if(len(var_names) > 1):
+            for i in range(1, len(var_names)):
+                if np.equal(var_names[0], var_names[i]).any() != True:
+                    print("All files must have the same variable names")
+                    sys.exit(-1)
+        elif len(var_names) == 0:
+            print("Undefined variable names")
+            sys.exit(-1)
+                    
+        self.variable_names  = var_names[0]
+
+
+    def set(self, args, **kwargs):
+        self.__check_arg_dim_equiv(args)
+        self.filename = args.filename
+
+        pData = []
+        
+        for fname in self.filename:
+            p = ProcData(fname)
+            p.get_variable_names()
+            pData.append(p)
+
+        self.data = copy.deepcopy(pData)  
+        self.__get_variable_names()
+
+        if args.func != self.dump:
+            self.out = args.out
+            self.oname = args.oname
+            self.var = args.var
+            self.mval = args.mval
+            self.function = args.func
+            self.if_manual_plot = kwargs.get('if_manual_plot', False)
+            self.if_save_result = kwargs.get('if_save_result', True)
+
+            if args.func == self.plot or args.func == self.ani_plot:
+                ndim = 1
+                if self.var == None and len(self.variable_names) != 0:
+                    self.var = [self.variable_names[i] for i in range(ndim, len(self.variable_names))]
+                for p in self.data:
+                    p.process_file(ndim, self.var, self.mval)
+
+            elif args.func == self.plot_contour:
+                ndim = 2
+                if self.var == None and len(self.variable_names) != 0:
+                    self.var = [self.variable_names[i] for i in range(ndim, len(self.variable_names))]
+                for p in self.data:
+                    p.process_file(ndim, self.var, self.mval)
+
+            elif args.func == self.avg_plot:
+                ndim = 3
+                if self.var == None and len(self.variable_names) != 0:
+                    self.var = [self.variable_names[i] for i in range(ndim, len(self.variable_names))]
+                for p in self.data:
+                    p.process_file(ndim, self.var, self.mval)
+
+            if self.var == None:
+                self.fig_count = len(self.variable_names) - ndim
+            else:
+                self.fig_count = len(self.var)
+    
+    def __plot_plt(self):
+        os.system("mkdir -p " + self.out)
+        x_name = self.variable_names[0]
+
+        fig = plt.figure()
+
+        for y_name in self.var:
+            plt.plot(self.data[0].data[x_name], self.data[0].data[y_name], linewidth=4)
+
+        plt.legend(self.var)
+        plt.xlabel(x_name, fontsize=10, fontweight='bold')
+
+        if self.if_manual_plot: plt.show()
+        else: plt.close(fig)
+        if self.if_save_result: fig.savefig(self.out + self.oname[0])
+
+    def __ani_plot(self):
+        if self.if_save_result:
+            png_names = []
+            os.system("mkdir -p " + self.out)
+            os.system("mkdir -p " + self.ani_pngs_dir)
+
+            names = natsort.natsorted(self.filename,reverse=False)
+            x_name = self.variable_names[0]
+            data_i = 0
+
+            for datafile in names:
+                fig = plt.figure()
+
+                for y_name in self.var:
+                    plt.plot(self.data[data_i].data[x_name], self.data[data_i].data[y_name], linewidth=4)
+
+                plt.legend(self.var)
+                plt.xlabel(x_name, fontsize=10, fontweight='bold')
+
+                figname = os.path.basename(datafile)
+                plt.close(fig)
+                fig.savefig(self.ani_pngs_dir + figname.split('.')[0] + '.png')
+
+                name = self.ani_pngs_dir + figname.split('.')[0] + '.png'
+                png_names.append(name)
+                data_i = data_i + 1
+
+            images = []
+            for file_name in png_names:
+                images.append(imageio.v2.imread(file_name))
+
+            imageio.mimsave(self.oname[0], images, fps = 5)
+            shutil.rmtree(self.ani_pngs_dir)
+
+    def __plot_contour(self):
+        os.system("mkdir -p " + self.out)
+        x_name = self.variable_names[0]
+        y_name = self.variable_names[1]
+
+        if self.oname == None:
+            fig_names = self.var
+            fig_end = ".png"
+        else:
+            fig_names = self.oname
+            fig_end = ""
+        
+        for i in range(self.fig_count):
+            fig,ax=plt.subplots(1,1)
+            title = self.var[i]
+
+            X = self.data[0].data[x_name]
+            Y = self.data[0].data[y_name]
+            Z = self.data[0].data[self.var[i]]
+            
+            cp = ax.contourf(X, Y, Z)
+            fig.colorbar(cp) # Add a colorbar to a plot
+            ax.set_title(title)
+            ax.set_xlabel(x_name)
+            ax.set_ylabel(y_name)
+            
+            if self.if_manual_plot: plt.show()
+            else: plt.close(fig)
+            if self.if_save_result: fig.savefig(self.out + fig_names[i] + fig_end)
+
+    def __avg(self, data, var_name):
+        cx = data['cx']
+        cy = data['cy']
+        cz = data['cz']
+
+        flat_matrix_data = np.zeros((cx * cy * cz))
+        flat_data = data[var_name].flatten()
+    
+        for k in range(cz):
+            for j in range(cy):
+                for i in range(cx):
+                    flat_matrix_data[k * cy * cx + j * cx + i] = flat_data[k * cy * cx + j * cx + i]
+
+        matrix_data = np.reshape(flat_matrix_data, (cx, cy, cz), order='F')
+        avg_data = np.average(matrix_data, axis=(1, 0))
+        return avg_data
+
+
+    def __avg_plot(self):
+        os.system("mkdir -p " + self.out)
+        fig = plt.figure()
+        x_name = self.variable_names[2]
+        x = self.data[0].data[x_name]
+
+        for var in self.var:
+            avg_data = self.__avg(self.data[0].data, var)
+            plt.plot(x, avg_data, linewidth=4)
+
+        plt.legend(self.var)
+        plt.xlabel(x_name, fontsize=10, fontweight='bold')
+
+        if self.if_manual_plot: plt.show()
+        else: plt.close(fig)
+        if self.if_save_result: fig.savefig(self.out + self.oname[0])
+
+    def __dump(self):
+        for variable_name in self.variable_names:
+            print(variable_name, end=' ')
+        print('\n')
+
+    def dump(self):
+        self.__dump()
+
+    def plot(self):
+        self.__plot_plt()
+
+    def ani_plot(self):
+        self.__ani_plot()
+
+    def avg_plot(self):
+        self.__avg_plot()
+
+    def plot_contour(self):
+        self.__plot_contour()
\ No newline at end of file

plotter/ProcData.py

+import numpy as np
+import os
+import numpy as np
+from .binSubfunctions import *
+
+class ProcData:
+    def __init__(self, filename):
+        self.filename = filename
+        self.data = {}
+        self.nse_read_bin_data = {}
+        self.variable_names = ""
+
+    def __get_variable_names_plt(self):
+        with open(self.filename, "r") as file:
+            file_data = file.read().split('\n')
+        file.close()
+
+        names = [variable_name.replace(" ", "").replace('"' , "") for variable_name in file_data[1].split('=')[1].split(',')]
+        self.variable_names = np.array(names, dtype=object)
+    
+    def __get_variable_names_bin(self):
+        f = open(self.filename,'rb')
+        _ = read_int(f)
+        _ = read_int(f)
+        ndims = read_int(f)
+        data_type_size = read_int(f)
+
+        if ndims == 1:
+            self.variable_names = ['I']
+        elif ndims == 2:
+            self.variable_names = ['I', 'J']
+        elif ndims == 3:
+            self.variable_names = ['I', 'J', 'K']
+
+        if data_type_size == 4:
+            read_float = read_float32
+            read_floats = read_floats32
+            float_type = np.float32
+        elif data_type_size == 8:
+            read_float = read_float64
+            read_floats = read_floats64
+            float_type = np.float64
+        else:
+            raise Exception(f"Unknown data_type value: {data_type_size}. Must be either 4 or 8.")
+
+        for _ in range(24):
+            read_float(f)
+
+        nx = read_int(f)
+        ny = read_int(f)
+        nz = read_int(f)
+
+        # skip gap; reserved for future usage
+        for _ in range(21):
+            read_int(f)
+
+        for _ in range(2):
+            read_floats(f, num=nx)
+            read_floats(f, num=ny)
+            read_floats(f, num=nz)
+
+        read_float(f)
+
+        field_type = read_int(f)
+        if field_type == 0:
+            nvars = 1
+        elif field_type == 1:
+            nvars = ndims
+        else:
+            raise Exception(f"Unknown field_type value: {field_type}. Must be either 0 or 1")
+
+        len_varnames = []
+        for _ in range(nvars):
+            len_varnames += [read_int(f)]
+
+        varnames = []
+        for nvar in range(nvars):
+            varnames += [read_str(f, length=len_varnames[nvar])]
+                    
+        self.variable_names += varnames
+        self.variable_names = np.array(self.variable_names, dtype=object)
+    
+    def __read_plt(self, ndim):
+        with open(self.filename, "r") as file:
+            file_data = file.read().split('\n')
+        file.close()
+
+        I = int(file_data[2].split(',')[0].split('=')[1])
+
+        if ndim == 1:
+            var_begin = 1
+            J = 0
+            K = 0
+        elif ndim == 2:
+            var_begin = 2
+            J = int(file_data[2].split(',')[1].split('=')[1])
+            K = 0
+        elif ndim == 3:
+            var_begin = 3
+            J = int(file_data[2].split(',')[1].split('=')[1])
+            K = int(file_data[2].split(',')[2].split('=')[1])
+
+        file_data = np.loadtxt(self.filename, dtype = float, delimiter=' ', skiprows=3, unpack=False, ndmin=2, encoding='bytes')
+        file_data = file_data.T
+
+        if self.var == None:
+            column_names = [self.variable_names[i] for i in range(var_begin, len(self.variable_names))] 
+        else:
+            column_names = self.var
+            
+        if self.mval != None:
+            print(self.mval)
+            for col, abs_val in zip(column_names, self.mval):
+                # print(col, abs_val)
+                check_variable_idx = np.where(self.variable_names == col)[0][0]
+                idx = np.where(np.abs(file_data[check_variable_idx]) > abs_val)[0]
+                file_data[check_variable_idx][idx] = np.nan
+
+        self.data[self.variable_names[0]] = file_data[0][0:I]
+
+        if ndim == 2:
+            self.data[self.variable_names[1]] = file_data[1][: : I]
+        elif ndim == 3:
+            self.data[self.variable_names[1]] = file_data[1][: : I]
+            self.data[self.variable_names[2]] = file_data[2][: : I * J]
+
+        i = 0
+        for name in self.variable_names[ndim : ]:
+            if ndim == 1:
+                self.data[name] = file_data[ndim + i]
+            elif ndim == 2:
+                self.data[name] = file_data[ndim + i].reshape( J, I )
+            elif ndim == 3:
+                self.data[name] = file_data[ndim + i].reshape( K, J, I )
+            i += 1
+
+        self.data['cx'] = I
+        self.data['cy'] = J
+        self.data['cz'] = K
+
+    
+    def __read_bin(self):
+        f = open(self.filename,'rb')
+        fid = read_int(f)
+        grid_type = read_int(f)
+        ndims = read_int(f)
+        data_type_size = read_int(f)
+
+        if data_type_size == 4:
+            read_float = read_float32
+            read_floats = read_floats32
+            float_type = np.float32
+        elif data_type_size == 8:
+            read_float = read_float64
+            read_floats = read_floats64
+            float_type = np.float64
+        else:
+            raise Exception(f"Unknown data_type value: {data_type_size}. Must be either 4 or 8.")
+        
+        x = read_float(f)
+        y = read_float(f)
+        z = read_float(f)
+
+        xdomainsize = read_float(f)
+        ydomainsize = read_float(f)
+        zdomainsize = read_float(f)
+
+        # skip gap; reserved for future usage
+        for _ in range(18):
+            read_float(f)
+
+        nx = read_int(f)
+        ny = read_int(f)
+        nz = read_int(f)
+
+        if ndims < 3:
+            nz = 0
+        if ndims < 2:
+            ny = 0
+
+        dimsizes = ([nx, ny, nz])[0:ndims]
+
+        gcx = read_int(f)
+        gcy = read_int(f)
+        gcz = read_int(f)
+
+        # skip gap; reserved for future usage
+        for _ in range(18):
+            read_int(f)
+
+        cx = read_floats(f, num=nx)
+        cy = read_floats(f, num=ny)
+        cz = read_floats(f, num=nz)
+
+        ex = read_floats(f, num=nx)
+        ey = read_floats(f, num=ny)
+        ez = read_floats(f, num=nz)
+
+        time = read_float(f)
+
+        field_type = read_int(f)
+        if field_type == 0:
+            nvars = 1
+        elif field_type == 1:
+            nvars = ndims
+        else:
+            raise Exception(f"Unknown field_type value: {field_type}. Must be either 0 or 1")
+
+        len_varnames = []
+        for _ in range(nvars):
+            len_varnames += [read_int(f)]
+
+        varnames = []
+        for nvar in range(nvars):
+            varnames += [read_str(f, length=len_varnames[nvar])]
+
+        values = np.fromfile(f, dtype=float_type, count=np.prod(dimsizes)).reshape(dimsizes + [1])
+        for nvar in range(1,nvars):
+            vadd = np.fromfile(f, dtype=float_type, count=np.prod(dimsizes)).reshape(dimsizes + [1])
+            values = np.concatenate((values, vadd), axis=-1)
+
+        f.close()
+
+        I = nx - 2 * gcx
+        J = ny - 2 * gcy
+        K = nz - 2 * gcz
+
+        self.data['cx'] = I
+        self.data['cy'] = J
+        self.data['cz'] = K
+
+        self.variable_names = ['I', 'J', 'K']
+
+        for i in range(nvars):
+            self.variable_names.append(varnames[i][0])
+
+        self.data['I'] = cx[gcx:nx - gcx]
+        self.data['J'] = cy[gcy:ny - gcy]
+        self.data['K'] = cz[gcz:nz - gcz]
+
+        values = values.T
+
+        for i in range(ndims, ndims + nvars):
+            print(values[:, :, :, i - ndims].shape)
+            self.data[self.variable_names[i]] = values[i - ndims, gcz:nz - gcz, gcy:ny - gcy, gcx:nx - gcx]
+
+        if ndims == 1:
+            var_begin = 1
+        elif ndims == 2:
+            var_begin = 2
+        elif ndims == 3:
+            var_begin = 3
+
+        if self.var == None:
+            column_names = [self.variable_names[i] for i in range(var_begin, len(self.variable_names))] 
+        else:
+            column_names = self.var
+
+        if self.mval != None:
+            # print(self.mval)
+            for col, abs_val in zip(column_names, self.mval):
+                idx = np.where(np.abs(self.data[col]) > abs_val)
+                self.data[col][idx] = np.nan
+
+    def process_file(self, ndim, column_names, mval):
+        filename_parts = os.path.splitext(self.filename)
+        filename_extension = filename_parts[-1]
+        self.var = column_names
+        self.mval = mval
+
+        if filename_extension == '.plt':
+            self.__read_plt(ndim)
+        elif filename_extension == '.nsx':
+            self.__read_bin()
+
+    def get_variable_names(self):
+        filename_parts = os.path.splitext(self.filename)
+        filename_extension = filename_parts[-1]
+
+        if filename_extension == '.plt':
+            self.__get_variable_names_plt()
+        elif filename_extension == '.nsx':
+            self.__get_variable_names_bin()
\ No newline at end of file

plotter/__init__.py

+__version__ = "0.1.0"
+
+from .main import dump
+from .main import plot
+from .main import ani_plot
+from .main import plot_contour
+from .main import avg_plot
+

plotter/binSubfunctions.py

+import numpy as np
+import struct 
+
+def read_int(fobj):
+    return int.from_bytes(fobj.read(4), byteorder='little')
+
+def read_float32(fobj):
+    return struct.unpack('<f', fobj.read(4))[0]
+
+def read_float64(fobj):
+    return struct.unpack('<d', fobj.read(8))[0]
+
+def read_floats32(fobj, num=1):
+    floats = []
+    for nfloat in range(num):
+        floats += [struct.unpack('<f', fobj.read(4))[0]]
+    return np.array(floats)
+
+def read_floats64(fobj, num=1):
+    floats = []
+    for nfloat in range(num):
+        floats += [struct.unpack('<d', fobj.read(8))[0]]
+    return np.array(floats)
+
+def read_str(fobj, length):
+    return fobj.read(length).decode("utf-8")
\ No newline at end of file

plotter/main.py

+from .Plotter import Plotter
+from .Args import Args
+from pathlib import PurePath 
+import natsort
+import os
+
+manual_plot=False
+save_result=True
+
+def dump(filename, var=[None], mval=[None]):
+    Plot = Plotter()
+    args = Args([filename], Plot.dump, var, mval, oname=[None], out=[None])
+
+    Plot.set(args, if_manual_plot=manual_plot, if_save_result=save_result)
+    Plot.dump()
+
+def plot(filename, out = './', oname = 'fig.png', var=[None], mval=[None]):
+    Plot = Plotter()
+    args = Args([filename], Plot.plot, var=var, mval=mval, oname=oname, out=out)
+    Plot.set(args, if_manual_plot=manual_plot, if_save_result=save_result)
+    Plot.plot()
+
+def ani_plot(filename, out = './', oname = 'fig.gif', var=[None], mval=[None]):
+    pp = str(PurePath(filename).parent) + '/'
+    name = str(PurePath(filename).name )
+    command = 'find ' + pp + ' -name ' + "'" + name + "'"
+    output_stream = os.popen(command)
+    out_res = output_stream.read().split('\n')[0:-1]
+    output_stream.close()
+    names = natsort.natsorted(out_res,reverse=False)
+
+    Plot = Plotter()
+    args = Args(names, Plot.ani_plot, var=var, mval=mval, oname=oname, out=out)
+    Plot.set(args, if_manual_plot=manual_plot, if_save_result=save_result)
+    Plot.ani_plot()
+
+def plot_contour(filename, out = './', oname = [None], var=[None], mval=[None]):
+    Plot = Plotter()
+    args = Args([filename], Plot.plot_contour, var=var, mval=mval, oname=oname, out=out)
+    Plot.set(args, if_manual_plot=manual_plot, if_save_result=save_result)
+    Plot.plot_contour()
+
+def avg_plot(filename, out = './', oname = 'fig.png', var=[None], mval=[None]):
+    Plot = Plotter()
+    args = Args([filename], Plot.avg_plot, var=var, mval=mval, oname=oname, out=out)
+    Plot.set(args, if_manual_plot=manual_plot, if_save_result=save_result)
+    Plot.avg_plot()
\ No newline at end of file

setup.py

+import setuptools
+
+if __name__ == "__main__":
+    setuptools.setup(
+        name='plotter',
+        version="0.1",
+        packages=setuptools.find_packages(
+          where='.',
+          include=['plotter*'])
+        )