toughanimator 0.1.2__py3-none-any.whl

toughanimator/tough_classes.py

@@ -0,0 +1,2336 @@
+import os
+import io
+import sys
+import re
+import shutil
+import numpy as np
+import pandas as pd
+from vtkmodules.all import *
+import pathlib
+import pyvista as pv
+import json
+from enum import Enum
+
+class MeshType(Enum):
+    RegularGrid = 1
+    StructuredGridOrth = 2
+    StructuredGridFree = 3
+    PolygonalMesh = 4
+
+class MeshPlane():
+    unknown = -1,
+    X = 1,
+    Y = 2,
+    Z = 3,
+    XZ = 4,
+    XY = 5,
+    YZ = 6,
+    XYZ = 7
+
+class OutType():
+    Unknown = 0,
+    TEC = 1, 
+    CSV = 2
+
+class VisType():
+    Tecplot = 1
+    ParaView = 2
+    MatplotLib = 3
+
+class ToughVersion(Enum):
+    Unknown = 0
+    TOUGH2 = 2
+    TOUGH3 = 3
+    TOUGHReact = 4
+
+class ValueType(Enum):
+    Unknown = 0
+    Scalar = 1
+    Vector = 3
+
+class VisTimeStep:
+    def __init__(self, time_step, iteration, time):
+        self.selected = True
+        self.time_step = time_step
+        self.iter = iteration
+        self.time = time
+        self.vtu_file_name = ""
+
+class VisVariable:
+    def __init__(self, name, value_type, number_of_components):
+        self.variable_name = name
+        self.value_type = value_type
+        self.number_of_components = number_of_components
+    def to_dict(self):
+        return {
+            "variable_name": self.variable_name,
+            "value_type": self.value_type.name,  # or .value if you prefer
+            "number_of_components": self.number_of_components  # or .value if you prefer
+        }
+
+class VisSetting:
+    def __init__(self, input_file_paths, out_file_paths, vis_dir, corners_file="unkown", out_format_type=OutType.Unknown, tough_version = ToughVersion.Unknown, vis_types=[VisType.ParaView, VisType.Tecplot], mesh_type=MeshType.RegularGrid, debug=False, eos="ECO2N"):
+        self.mesh_type = mesh_type
+        self.out_format_type = out_format_type
+        self.vis_types = vis_types
+        self.input_file_paths = input_file_paths
+        self.out_file_paths = out_file_paths
+        self.vis_dir = vis_dir
+        self.known_bounds = False
+        self.debug = debug
+        self.tough_version = tough_version
+        self.mesh_plane = MeshPlane.unknown
+        self.isReverse = False
+        self.corners_file = corners_file
+        self.debug = debug
+        self.eos = eos
+        self.minc = False
+
+
+    def setBounds(self, x_bounds, y_bounds, z_bounds):
+        self.bounds = np.concatenate((x_bounds, y_bounds, z_bounds))
+        self.known_bounds = True
+
+class vis_reader:
+    def __init__(self, case_dir):
+        self.setting = None
+        self.main_geometry = None
+        self.incon_path = None
+        #self.variable_list = []
+        self.variable_list = {}
+        self.time_steps_list = []
+        self.rock_dict = []
+        if os.path.isdir(case_dir):
+            config_path = os.path.join(case_dir, "config.json")
+            if os.path.exists(config_path):
+                with open(config_path, "r") as config_file:
+                    config = json.load(config_file)
+            else:
+                print(f"Config file:({config_path}) not found. Please create it.")
+                sys.exit(1)
+        else:
+            print(f"Case directory:({case_dir}) not found. Please check it.")
+            sys.exit(1)
+
+        
+        if "input_files" not in config:
+            print(f"Input files not found in config.json. Please check it.")
+            sys.exit(1)
+        if "output_files" not in config:
+            print(f"Output files not found in config.json. Please check it.")
+            sys.exit(1)
+
+
+
+        setting = VisSetting(
+            input_file_paths = [os.path.join(case_dir, f) for f in config["input_files"]],
+            out_file_paths = [os.path.join(case_dir, f) for f in config["output_files"]],
+            vis_dir = config["vis_dir"] if "vis_dir" in config else case_dir,
+            corners_file = os.path.join(case_dir, config["corners_file"] if "corners_file" in config else "None"),
+            debug = config['debug'] if 'debug' in config else False,
+            eos = config['EOS'] if 'EOS' in config else "ECO2N",
+            #minc = config['MINC'] if 'MINC' in config else False,
+        )
+
+        for input_file_path in setting.input_file_paths:
+            if not os.path.exists(input_file_path):
+                print(f'Can\'t find input file: ({input_file_path}). please check the path or remove it from the config.json.')
+                sys.exit(1)
+            # check if this project use MINC
+            elif input_file_path.endswith('MINC'):
+                setting.minc = True
+        for out_file_path in setting.out_file_paths:
+            if not os.path.exists(input_file_path):
+                print(f'Can\'t find output file: ({out_file_path}). please check the path or remove it from the config.json.')
+                sys.exit(1)
+                
+        if not os.path.isdir(setting.vis_dir):
+            print(f'Can\'t find directory: ({setting.vis_dir}). please check the path or remove it from the config.json.')
+            sys.exit(1)
+        else:
+            vis_path = os.path.join(setting.vis_dir, "tough_vis")
+            # delete the directory if it exists
+            if os.path.isdir(vis_path):
+                shutil.rmtree(vis_path)
+            os.mkdir(vis_path)
+            paraview_path = os.path.join(vis_path, 'paraview')
+            os.mkdir(paraview_path)
+            print(f"Visualization folder created: {vis_path}")
+            setting.vis_dir = vis_path
+        
+        self.setting = setting
+
+    def write_eleme_conne(self):
+        if self.setting ==  None:
+            print(f'Please initialize the vis_reader class with the case directory.')
+            sys.exit(1)
+        print(f'Reading input files ...')
+        self.__write_elem_buffer()
+        self.__write_conne_buffer()
+        self.__write_rocks_buffer()
+        print(f'Creating elements and connections ...')
+        self.__create_elem_conne()
+    
+    def write_geometry(self):
+        if self.setting ==  None:
+            print(f'Please initialize the vis_reader class with the case directory.')
+            sys.exit(1)
+
+        
+        if self.elem_conne_path == None:
+            print(f'Can\'t find element and connection file. Please create it first. (write_eleme_conne)')
+            sys.exit(1)
+        
+        print(f'Creating main geometry ...')
+        self.__create_main_geometry()
+          
+    def write_incon(self):
+        if self.setting ==  None:
+            print(f'Please initialize the vis_reader class with the case directory.')
+            sys.exit(1)
+        if self.main_geometry == None:
+            print(f'Can not find main geometry. Please create the main geometry first. (write_geometry)')
+            sys.exit(0)
+        print(f'Reading input files ...')
+        self.__write_incon_buffer()
+        print(f'Creating initial condition ...')
+        self.__write_initial_conditions()
+    
+    def write_result(self):
+        if self.setting ==  None:
+            print(f'Please initialize the vis_reader class with the case directory.')
+            sys.exit(1)
+        if self.main_geometry == None:
+            print(f'Can not find main geometry. Please create the main geometry first. (write_geometry)')
+            sys.exit(0)
+        
+        for output_file_path in self.setting.out_file_paths:
+            print(f'Reading output ({output_file_path}) ... ')
+            
+            self.current_out_file = output_file_path
+            self.__check_TOUGH_version()
+            print(f'    Version: {self.setting.tough_version.name}')
+            if self.setting.tough_version == ToughVersion.TOUGH2:
+                self.__read_TOUGH2_CSV_outfile()
+            elif self.setting.tough_version == ToughVersion.TOUGH3:
+                self.__read_TOUGH3_CSV_outfile()
+            elif self.setting.tough_version == ToughVersion.TOUGHReact:
+                self.__read_tough_TEC_outfile()
+                # add post calculation
+        for timestep in self.time_steps_list:
+                self.__post_process(timestep)
+        self.__write_json()
+        print(f'All files have been created in {self.setting.vis_dir}.')
+
+    def write_all(self):
+        self.write_eleme_conne()
+        self.write_geometry()
+        self.write_incon()
+        self.write_result()
+
+    # TODO: need to clean up the code
+    def __check_bounds(self):
+        if not self.setting.bounds[1] > self.setting.bounds[0]:
+            print(
+                f'Max X {self.setting.bounds[1]} must be greater than Min X {self.setting.bounds[0]}.')
+            sys.exit(1)
+        if not self.setting.bounds[3] > self.setting.bounds[2]:
+            print(
+                f'Max Y {self.setting.bounds[3]} must be greater than Min Y {self.setting.bounds[2]}.')
+            sys.exit(1)
+        if not self.setting.bounds[5] > self.setting.bounds[4]:
+            print(
+                f'Max Z {self.setting.bounds[5]} must be greater than Min Z {self.setting.bounds[4]}.')
+            sys.exit(1)
+        # print(f'Can\'t find input file: {self.setting.input_path}.')
+
+    def __read_input(self):
+        self.__write_elem_buffer()
+        self.__write_conne_buffer()
+        self.__write_rocks_buffer()
+        self.__write_incon_buffer()
+
+    def __write_elem_buffer(self):
+        self.eleme_buffer = io.StringIO()
+        # write temp element txt
+        has_elem = False
+        for input_file_path in self.setting.input_file_paths:
+            line_counter = 0
+            with open(input_file_path) as f:
+                reading_elem = False
+
+                for line in f:
+                    if line.startswith('ELEME-') or line.startswith('ELEME'):
+                        reading_elem = True
+                        has_elem = True
+                        find_elem = True
+                        continue
+                    if reading_elem:
+                        line_counter += 1
+                        if self.__check_if_block_end(line, line_counter):
+                            reading_elem = False
+                            found_path = input_file_path
+                            break
+                        else:
+                            self.eleme_buffer.write(line)
+
+        if has_elem == False:
+            print(f'Can\'t find ELEME block in input_file_paths.')
+            sys.exit(1)
+        else:
+            print(f'    Found ELEME block in {found_path}')
+
+    def __write_conne_buffer(self):
+        self.conne_buffer = io.StringIO()
+        # write temp element txt
+        has_conne = False
+        for input_file_path in self.setting.input_file_paths:
+            line_counter = 0
+            with open(input_file_path) as f:
+                
+                reading_conne = False
+                for line in f:
+                    if line.startswith('CONNE-') or line.startswith('CONNE'):
+                        reading_conne = True
+                        has_conne = True
+                        continue
+                    if reading_conne: 
+                        line_counter += 1
+                        if self.__check_if_block_end(line, line_counter):
+                            reading_conne = False
+                            found_path = input_file_path
+                            break
+                        else:
+                            self.conne_buffer.write(line)
+
+        if has_conne == False:
+            print(f'Can\'t find CONNE block in input_file_paths.')
+            sys.exit(1)
+        else:
+            print(f'    Found CONNE block in {found_path}')
+
+    def __write_rocks_buffer(self):
+        self.rocks_buffer = io.StringIO()
+        #self.rocks_sgr_buffer = io.StringIO()
+        has_rocks = False
+        
+        for input_file_path in self.setting.input_file_paths:
+            line_counter = 0
+            with open(input_file_path) as f:
+                reading_rocks = False
+                for line in f:
+                    if line.startswith('ROCKS-'):
+                        reading_rocks = True
+                        has_rocks = True
+                        continue
+
+                    if reading_rocks:
+                        line_counter+= 1
+                        if self.__check_if_block_end(line, line_counter):
+                            reading_rocks = False
+                            found_path = input_file_path
+                            break
+                        else:
+                            if 'SEED' in line:
+                                continue
+                            first_line = line.replace('\n', '').rstrip()
+                            
+                            #skip 1 lines
+                            f.readline()
+                            third_line = f.readline()
+                            new_line = f'{first_line}{third_line}'
+                            self.rocks_buffer.write(new_line)
+                            f.readline()
+
+
+        if has_rocks == False:
+            print(f'Can\'t find ROCKS block in all input_file_paths.')
+            sys.exit(1)
+        else:
+            print(f'    Found ROCKS block in {found_path}')
+
+    def __write_incon_buffer(self):
+        self.incon_buffer = io.StringIO()
+        has_incon = False
+        # write temp element txt
+        
+        for input_file_path in self.setting.input_file_paths:
+            line_counter = 0
+            with open(input_file_path) as f:
+                
+                reading_incon = False
+                for line in f:
+                    if line.startswith('INCON-'):
+                        reading_incon = True
+                        has_incon = True
+                        find_incon = True
+                        continue
+
+                    if reading_incon:
+                        line_counter += 1
+                        if self.__check_if_block_end(line, line_counter):
+                            found_path = input_file_path
+                            break
+                        #line = f.readline() # skip first line #self.number_of_elements
+                        eos = self.setting.eos
+                        num = len(line.split())
+                        if self.setting.eos == "ECO2N" and len(line.split()) == 4:
+                            self.incon_buffer.write(line)
+                        elif self.setting.eos == "EOS1":
+                            line = f.readline() # skip first line #self.number_of_elements
+                            if len(line.split()) == 2:
+                                self.incon_buffer.write(line)
+
+        if has_incon == False:
+            print(f'Can\'t find INCON block in input_file_paths.')
+            #sys.exit(1)
+        else:
+            print(f'    Found INCON block in {found_path}')
+
+    def __write_initial_conditions(self):
+
+        self.incon_vtk = self.__read_vtk_file(self.main_geometry)
+
+
+        
+        self.incon_buffer.seek(0)
+        incon_df = pd.DataFrame()
+        if self.setting.eos == "ECO2N":
+            # read incon
+            incon_colspecs = [(0, 20), (20, 40), (40, 60), (60, 80)]  # define column widths
+            incon_names = ['Pressure', 'NaCl', 'CO2', 'Temperature']
+            incon_df = pd.read_fwf(self.incon_buffer, colspecs=incon_colspecs, header=None,
+                                names=incon_names,
+                                dtype={'Pressure':float, 'NaCl':float, 'CO2':float, 'Temperature':float})
+        elif self.setting.eos == "EOS1":
+            # read incon
+            incon_colspecs = [(0, 20), (20, 40)]
+            incon_names = ['Temperature', 'Pressure']
+            incon_df = pd.read_fwf(self.incon_buffer, colspecs=incon_colspecs, header=None,
+                                names=incon_names,
+                                dtype={'Temperature':float, 'Pressure':float})
+        if len(incon_df) == 0:
+            print(f'    It is empty in INCON block.')
+            return
+        
+        for header in incon_names:
+            array = vtkDoubleArray()
+            array.SetName(header)
+            self.incon_vtk.GetCellData().AddArray(array)
+
+        for i in range(0, self.incon_vtk.GetNumberOfCells()):
+            for header in incon_names:
+                index = self.sequence_dist[i]
+                value = self.__parse_float(incon_df[header][index])
+                self.incon_vtk.GetCellData().GetArray(header).InsertNextValue(value)
+
+        extension = os.path.splitext(self.main_geometry)[1]
+        self.incon_path = os.path.join(self.setting.vis_dir, f'incon{extension}')
+        self.__write_vtk_file(self.incon_vtk, self.incon_path)
+        print(f'    ✓ Initial condition file created: {self.incon_path}')
+
+    def __read_TOUGH2_CSV_outfile(self):
+        output_buffer = io.StringIO()
+        current_time_step = None
+        tim_step_counter = 1
+        csv_headers = []
+        line_number = -1
+        reading_number = 0
+        value_type = ValueType.Unknown
+        start_index = -1
+        self.time_steps_list = []
+        with open(self.current_out_file) as f:
+            for line in f:
+                line_number = line_number + 1
+                values = line.strip().split(',')
+                if line_number == 0:
+                    csv_headers = [x.strip() for x in values]
+                    if 'ELEM' in csv_headers and 'INDEX' in csv_headers:
+                        value_type = ValueType.Scalar
+                        start_index = 3
+                        
+                    elif 'ELEM1' in csv_headers and 'ELEM2' in csv_headers:
+                        value_type = ValueType.Vector
+                        start_index = 4
+            
+                    csv_headers = csv_headers[start_index:]
+                    print(f'    Value type: {value_type.name}')
+                    continue
+
+                time = self.__parse_float(values[0].strip())
+
+                # next time step
+                if current_time_step == None or time != current_time_step.time:
+                    
+                    # when all items in this timestep have been read
+                    if value_type == ValueType.Scalar and reading_number == self.number_of_elements:
+                        output_buffer.seek(0)
+                        df = pd.read_csv(output_buffer, sep=',', header=0)
+                        
+                        self.__write_scalar_result(
+                             current_time_step, df, csv_headers)
+                        output_buffer.flush()
+                        output_buffer.close()
+                        output_buffer = io.StringIO()
+                        reading_number = 0
+                    if value_type == ValueType.Vector and reading_number == self.number_of_connections:
+                        output_buffer.seek(0)
+                        df = pd.read_csv(output_buffer, sep=',', header=0)
+                        #df.to_csv(os.path.join(self.setting.vis_dir, "timestep.csv"), index=False)
+                        self.__write_vector_result(
+                            current_time_step, df, csv_headers)
+                        output_buffer.flush()
+                        output_buffer.close()
+                        output_buffer = io.StringIO()
+                        reading_number = 0
+
+                    current_time_step = VisTimeStep(
+                        time=float(time),
+                        time_step=tim_step_counter,
+                        iteration=1
+                    )
+                    #print(f'    Reading step {current_time_step.time_step_id} : {current_time_step.time} ...')
+
+                    # Initialize buffer
+                    header_string = ','.join(csv_headers)
+                    output_buffer.write(header_string + '\n')
+                    self.time_steps_list.append(current_time_step)
+                    tim_step_counter = tim_step_counter + 1
+                    
+                    output_buffer.write(','.join(values[start_index:]) + '\n')
+                    reading_number = reading_number + 1
+                else:
+                    output_buffer.write(','.join(values[start_index:]) + '\n')
+                    reading_number = reading_number + 1
+            else:
+                # write the last time step
+                if value_type == ValueType.Scalar:
+                    output_buffer.seek(0)
+                    df = pd.read_csv(output_buffer, sep=',', header=0)
+                    self.__write_scalar_result(current_time_step, df, csv_headers)
+                if value_type == ValueType.Vector:
+                    output_buffer.seek(0)
+                    df = pd.read_csv(output_buffer, sep=',', header=0)
+                    self.__write_vector_result(current_time_step, df, csv_headers)
+                output_buffer.close()    
+
+    # TODO: find whick case is TOUGH3
+    def __read_TOUGH3_CSV_outfile(self):
+        scalar_buffer = io.StringIO()
+        current_time_step = None
+        tim_step_counter = 1
+        csv_headers = []
+        line_number = -1
+        reading_number = 0
+        value_type = ValueType.Unknown
+        start_index = -1
+        self.time_steps_list = []
+        
+        with open(self.current_out_file) as f:
+            for line in f:
+                line_number = line_number + 1
+                values = line.strip().split(',')
+                if line_number == 0:
+                    values = [x.replace('"', '') for x in values]
+                    csv_headers = [x.strip() for x in values]
+
+                    if 'ELEM' in csv_headers:
+                        value_type = ValueType.Scalar
+                        start_index = 5
+                        
+                    elif 'ELEM1' in csv_headers and 'ELEM2' in csv_headers:
+                        value_type = ValueType.Vector
+                        start_index = 5
+            
+                    csv_headers = csv_headers[start_index:]
+                    f.readline() # skip next line
+                    print(f'    Value type: {value_type.name}')
+                    continue
+
+                # Find time item
+                if len(values) == 1:
+                    time_string = values[0].replace('"', '').strip()
+                    time_string = time_string.split()[-1]
+                    time = self.__parse_float(time_string)
+
+                    # if not the first time step
+                    if value_type == ValueType.Scalar and reading_number == self.number_of_elements:
+                        scalar_buffer.seek(0)
+                        df = pd.read_csv(scalar_buffer, sep=',', header=0)
+                        self.__write_scalar_result(
+                             current_time_step, df, csv_headers)
+                        scalar_buffer.flush()
+                        scalar_buffer.close()
+                        scalar_buffer = io.StringIO()
+                        reading_number = 0
+
+                    if value_type == ValueType.Vector and reading_number == self.number_of_connections:
+                        scalar_buffer.seek(0)
+                        df = pd.read_csv(scalar_buffer, sep=',', header=0)
+                        self.__write_vector_result(
+                            current_time_step, df, csv_headers)
+                        scalar_buffer.flush()
+                        scalar_buffer.close()
+                        scalar_buffer = io.StringIO()
+                        reading_number = 0
+                    
+                    current_time_step = VisTimeStep(
+                        time=float(time),
+                        time_step=tim_step_counter,
+                        iteration=1
+                    )
+
+                    # Initialize buffer
+                    header_string = ','.join(csv_headers)
+                    scalar_buffer.write(header_string + '\n')
+                    self.time_steps_list.append(current_time_step)
+                    tim_step_counter = tim_step_counter + 1
+
+                else:
+                    scalar_buffer.write(','.join(values[start_index:]) + '\n')
+                    reading_number = reading_number + 1
+
+            else:
+                # write the last time step
+                if value_type == ValueType.Scalar:
+                    scalar_buffer.seek(0)
+                    df = pd.read_csv(scalar_buffer, sep=',', header=0)
+                    self.__write_scalar_result(current_time_step, df, csv_headers)
+                if value_type == ValueType.Vector:
+                    scalar_buffer.seek(0)
+                    df = pd.read_csv(scalar_buffer, sep=',', header=0)
+                    self.__write_vector_result(current_time_step, df, csv_headers)
+                scalar_buffer.close()    
+
+    def __read_tough_TEC_outfile(self):
+        
+        scalar_buffer = io.StringIO()
+        #vector_buffer = io.StringIO()
+        current_time_step = None
+        tim_step_counter = 1
+        reading_scalar = False
+        scalar_headers = []
+        self.time_steps_list = []
+        with open(self.current_out_file) as f:
+            for line in f:
+                if line.strip().lower().startswith('Variables'.lower()):
+                    headers_value = line.strip().split('=')[1]
+                    #scalar_headers = headers_value.replace('"', '')
+                   
+                    scalar_headers = re.split(' |,', headers_value.replace('"', '').strip())
+                    scalar_headers = [x for x in scalar_headers if x]
+                    scalar_headers.pop(0)
+                    scalar_headers.pop(0)
+                    scalar_headers.pop(0)
+                    
+                    continue
+                if line.strip().lower().startswith('Zone T'.lower()):
+                    if reading_scalar:
+                        scalar_buffer.seek(0)
+                        df = pd.read_csv(scalar_buffer, sep=',', header=0)
+                        self.__write_scalar_result(
+                            current_time_step, df, scalar_headers)
+                        
+                        scalar_buffer.flush()
+                        scalar_buffer.close()
+                        scalar_buffer = io.StringIO()
+
+                    time_values = line.split('"')
+                    time = time_values[1].split()[0]
+                    current_time_step = VisTimeStep(
+                        time=float(time),
+                        time_step=tim_step_counter,
+                        iteration=1
+                    )
+                    reading_scalar = True
+                    header_string = ','.join(scalar_headers)
+                    scalar_buffer.write(header_string + '\n')
+                    self.time_steps_list.append(current_time_step)
+                    tim_step_counter = tim_step_counter + 1
+                    continue
+                
+                if reading_scalar and len(line.split()) == len(scalar_headers)+3:
+                    csv_line = ','.join(line.split()[3:]) + '\n'
+                    scalar_buffer.write(csv_line)
+            
+            # if process to the end of file
+            else:
+                if len(scalar_buffer.getvalue()) > 0:
+                    #df = self.prepare_fixed_length_scalar_dataframe(scalar_headers, scalar_buffer)
+                    scalar_buffer.seek(0)
+                    df = pd.read_csv(scalar_buffer, sep=',', header=0)
+                    self.__write_scalar_result(
+                        current_time_step, df, scalar_headers)
+                    scalar_buffer.flush()
+                    scalar_buffer.close()
+                    scalar_buffer = io.StringIO()
+                    tim_step_counter = tim_step_counter + 1
+
+    def __post_process(self, vis_time_step):
+        time_index = self.time_steps_list.index(vis_time_step)
+        #vtr_path = os.path.join(self.setting.vis_dir, 'paraview', f'time_step_{vis_time_step.time_step}.vtr')
+
+        extension = os.path.splitext(self.main_geometry)[1]
+        vtr_path = os.path.join(self.setting.vis_dir, 'paraview', f'time_step_{vis_time_step.time_step}{extension}')
+        self.time_steps_list[time_index].vtu_file_name = vtr_path
+        scalar_vtr = self.__read_vtk_file(vtr_path)   
+        vtr = scalar_vtr
+
+        post_variable_list = []
+        # p
+        p_name = "P"
+        if vtr.GetCellData().GetArray("P (Pa)") is not None:
+            p_name = "P (Pa)"
+        if vtr.GetCellData().GetArray("P(bar)") is not None:
+            p_name = "P(bar)"
+        if vtr.GetCellData().GetArray("PRES") is not None:
+            p_name = "PRES"
+
+        if vtr.GetCellData().GetArray(p_name) is not None:
+            delPArray = vtkDoubleArray()
+            delPArray.SetName(f'del_{p_name}')
+            for i in range(0, vtr.GetNumberOfCells()):
+                p_value = vtr.GetCellData().GetArray(p_name).GetValue(i)
+                incon_p = self.incon_vtk.GetCellData().GetArray('Pressure').GetValue(i)
+                delP = p_value - incon_p
+                delPArray.InsertNextValue(delP)
+
+            vtr.GetCellData().AddArray(delPArray)
+            post_variable_list.append(VisVariable(f'del_{p_name}', ValueType.Scalar, 1))
+
+            # add toughreact variables
+        if self.setting.tough_version == ToughVersion.TOUGHReact or self.setting.tough_version == ToughVersion.TOUGH3:
+            trapHCO2_array = vtkDoubleArray()
+            trapHCO2_array.SetName('trapHCO2')
+
+            trapRCO2_array = vtkDoubleArray()
+            trapRCO2_array.SetName('trapRCO2')
+        
+            trapDCO2_array = vtkDoubleArray()
+            trapDCO2_array.SetName('trapDCO2')
+
+            trapMCO2_array = vtkDoubleArray()
+            trapMCO2_array.SetName('trapMCO2')
+
+            for index in range(0, vtr.GetNumberOfCells()):
+                trapHCO2 = 0
+                trapRCO2 = 0
+                trapDCO2 = 0
+                trapMCO2 = 0   
+                VOLX = 0
+                if vtr.GetCellData().GetArray("VOLX") is not None:
+                    VOLX = vtr.GetCellData().GetArray("VOLX").GetValue(index)
+
+                SatGas = 0
+                if vtr.GetCellData().GetArray("SatGas") is not None:
+                    SatGas = vtr.GetCellData().GetArray("SatGas").GetValue(index)
+                elif vtr.GetCellData().GetArray("SAT_G") is not None:
+                    SatGas = vtr.GetCellData().GetArray("SAT_G").GetValue(index)
+
+                Porosity = 0
+                if vtr.GetCellData().GetArray("Porosity") is not None:
+                    Porosity = vtr.GetCellData().GetArray("Porosity").GetValue(index)
+                elif vtr.GetCellData().GetArray("POR") is not None:
+                    Porosity = vtr.GetCellData().GetArray("POR").GetValue(index)
+                
+                DGas_kg_m3 = 0
+                if vtr.GetCellData().GetArray("DGas_kg/m3") is not None:
+                    DGas_kg_m3 = vtr.GetCellData().GetArray("DGas_kg/m3").GetValue(index)
+                elif vtr.GetCellData().GetArray("DEN_G") is not None:
+                    DGas_kg_m3 = vtr.GetCellData().GetArray("DEN_G").GetValue(index)
+
+                SatLiq = 0
+                if vtr.GetCellData().GetArray("SatLiq") is not None: 
+                    SatLiq = vtr.GetCellData().GetArray("SatLiq").GetValue(index)
+                elif vtr.GetCellData().GetArray("SAT_L") is not None:
+                    SatLiq = vtr.GetCellData().GetArray("SAT_L").GetValue(index)
+                
+                XCO2Liq = 0
+                if vtr.GetCellData().GetArray("XCO2Liq") is not None:
+                    XCO2Liq = vtr.GetCellData().GetArray("XCO2Liq").GetValue(index)
+                elif vtr.GetCellData().GetArray("X_CO2_L") is not None:
+                    XCO2Liq = vtr.GetCellData().GetArray("X_CO2_L").GetValue(index)
+
+                sgr = 0
+                if vtr.GetCellData().GetArray("sgr") is not None:
+                    sgr = vtr.GetCellData().GetArray("sgr").GetValue(index)
+
+
+                trapHCO2 =(SatGas-sgr)*VOLX*Porosity*DGas_kg_m3* (SatGas>sgr)
+                trapRCO2 = 0.05 * VOLX * Porosity * DGas_kg_m3* (SatGas > sgr)+ SatGas * VOLX * Porosity * DGas_kg_m3*(SatGas <= sgr)
+                trapDCO2 = SatLiq*VOLX*Porosity*DGas_kg_m3*XCO2Liq
+                trapHCO2_array.InsertNextValue(self.__fix_negative_zero(trapHCO2))
+                trapRCO2_array.InsertNextValue(self.__fix_negative_zero(trapRCO2))
+                trapDCO2_array.InsertNextValue(self.__fix_negative_zero(trapDCO2))
+
+                trapMCO2 = 0
+                if vtr.GetCellData().GetArray("calcite") is not None:
+                    calcite = vtr.GetCellData().GetArray("calcite").GetValue(index)
+                    ankerite_2 = vtr.GetCellData().GetArray("ankerite-2").GetValue(index)
+                    dawsonite = vtr.GetCellData().GetArray("dawsonite").GetValue(index)
+                    dolomite_2 = vtr.GetCellData().GetArray("dolomite-2").GetValue(index)
+                    magnesite = vtr.GetCellData().GetArray("magnesite").GetValue(index)
+                    siderite_2 = vtr.GetCellData().GetArray("siderite-2").GetValue(index)
+                    trapMCO2 =(calcite*1 + ankerite_2*2 + dawsonite*1 + dolomite_2*2 + magnesite*1 + siderite_2*1)*VOLX*Porosity*0.012
+                trapMCO2_array.InsertNextValue(self.__fix_negative_zero(trapMCO2))
+
+        
+            vtr.GetCellData().AddArray(trapHCO2_array)
+            vtr.GetCellData().AddArray(trapRCO2_array)
+            vtr.GetCellData().AddArray(trapDCO2_array)
+            vtr.GetCellData().AddArray(trapMCO2_array)
+        
+            post_variable_list.append(VisVariable('trapHCO2', ValueType.Scalar, 1))
+            post_variable_list.append(VisVariable('trapRCO2', ValueType.Scalar, 1))
+            post_variable_list.append(VisVariable('trapDCO2', ValueType.Scalar, 1))
+            post_variable_list.append(VisVariable('trapMCO2', ValueType.Scalar, 1))
+
+        
+        # Put cell-centered data into points
+        filter = vtkCellDataToPointData()
+        filter.SetInputData(vtr)
+        filter.Update()
+        vtr_cell_to_points = filter.GetOutput()
+
+        for variabl_name in ['trapHCO2', 'trapRCO2', 'trapDCO2', 'trapMCO2']:
+            vtr.GetPointData().AddArray(vtr_cell_to_points.GetPointData().GetArray(variabl_name))
+
+        if len(post_variable_list) > 0:
+            self.variable_list["psot"] = post_variable_list
+            self.__write_vtk_file(vtr, vtr_path)
+
+        
+    def __write_scalar_result(self, vis_time_step, dataframe, headers):
+        #print(f'    Writting step {vis_time_step.time_step}: {vis_time_step.time} ...')
+        index = self.time_steps_list.index(vis_time_step)
+        #vtr_path = os.path.join(self.setting.vis_dir, 'paraview', f'time_step_{vis_time_step.time_step}.vtr')
+
+        extension = os.path.splitext(self.main_geometry)[1]
+        vtr_path = os.path.join(self.setting.vis_dir, 'paraview', f'time_step_{vis_time_step.time_step}{extension}')
+        self.time_steps_list[index].vtu_file_name = vtr_path
+        #scalar_vtr = vtkRectilinearGrid()
+
+        if not os.path.exists(vtr_path):
+            #vtr_reader = vtkXMLRectilinearGridReader()
+            #vtr_reader.SetFileName(self.main_geometry)
+            #vtr_reader.Update()
+            #scalar_vtr = vtr_reader.GetOutput()
+            scalar_vtr = self.__read_vtk_file(self.main_geometry)
+
+            # add time step data
+            timesteps = vtkDoubleArray()
+            timesteps.SetName("TimeValue")
+            timesteps.SetNumberOfTuples(1)
+            timesteps.SetNumberOfComponents(1)
+            timesteps.SetTuple1(0, vis_time_step.time)
+            scalar_vtr.SetFieldData(vtkFieldData())
+            scalar_vtr.GetFieldData().AddArray(timesteps)
+         
+        else:
+            scalar_vtr = self.__read_vtk_file(vtr_path)    
+        
+
+        vtr = scalar_vtr
+
+        variable_list = []
+        for header in headers:
+            array = vtkDoubleArray()
+            array.SetName(header)
+            vtr.GetCellData().AddArray(array)
+            variable_list.append(VisVariable(header, ValueType.Scalar, 1))
+
+
+        for i in range(0, vtr.GetNumberOfCells()):
+            index = self.sequence_dist[i]
+            for header in headers:
+                value = float(self.__parse_float(dataframe[header][index]))
+                vtr.GetCellData().GetArray(header).InsertNextValue(value)
+
+
+        # update the variable list
+        if self.current_out_file not in self.variable_list:
+            self.variable_list[self.current_out_file] = variable_list
+
+        
+        # Put cell-centered data into points
+        filter = vtkCellDataToPointData()
+        filter.SetInputData(vtr)
+        filter.Update()
+        vtr_cell_to_points = filter.GetOutput()
+
+        for i in range(0, vtr_cell_to_points.GetPointData().GetNumberOfArrays()):
+            vtr.GetPointData().AddArray(vtr_cell_to_points.GetPointData().GetArray(i))
+
+        self.__write_vtk_file(vtr, vtr_path)
+        print(f'    ✓ Timestep {vis_time_step.time_step}:{vis_time_step.time} created: {vtr_path}')
+
+        if VisType.Tecplot not in self.setting.vis_types:
+            return
+        
+        # Start Tecplot generating
+        tec_name = pathlib.Path(self.setting.input_file_paths[0]).stem
+        self.tec_scalar_path = os.path.join(self.setting.vis_dir, f'{tec_name}_scalar.dat')
+        firstFile = True
+        if os.path.isfile(self.tec_scalar_path):
+            firstFile = False
+        file = open(self.tec_scalar_path, "a")
+        if firstFile:
+            file.write('TITLE = TECPLOT PLOT \n')
+            header_string = '"'+'", "'.join(headers) + '"'
+            file.write(f'VARIABLES = "X", "Y", "Z", {header_string}\n')
+        
+        tecplot_cell_type = 'BRICK'
+        
+        #time_statement = f'ZONE T ="{vis_time_step.time_step}, Time = {vis_time_step.time}", N = {vtu_cell_to_points.GetNumberOfPoints()}, E = {vtu_cell_to_points.GetNumberOfCells()}, F = FEPOINT, ET = {tecplot_cell_type}, SOLUTIONTIME = {vis_time_step.time}\n' 
+        
+        time_statement = f'ZONE T="{vis_time_step.time_step}, Time = {vis_time_step.time}", I={self.xyz_elem[0] + 1}, J={self.xyz_elem[1] + 1}, K={self.xyz_elem[2] + 1}, SOLUTIONTIME={vis_time_step.time}, DATAPACKING=BLOCK, VARLOCATION=({self.__get_varlocarion_string(headers)})'
+        if not firstFile:
+            time_statement = f'{time_statement}, D=(1,2,3,FECONNECT)'
+        #if self.setting.debug:
+            #time_statement = f'ZONE T ="{vis_time_step.time_step}, Time = {vis_time_step.time}", N = {vtu_cell_to_points.GetNumberOfPoints()}, E = {vtu_cell_to_points.GetNumberOfCells()}, F = FEPOINT, ET = {tecplot_cell_type}\n' 
+        file.write(f'{time_statement}\n')
+
+        # X, Y, Z
+        if firstFile:
+            for i in range(0, vtr.GetNumberOfPoints()):
+                point = vtr.GetPoint(i)
+                file.write(str(point[0]) + " ")
+            file.write(" \n")
+
+            for i in range(0, vtr.GetNumberOfPoints()):
+                point = vtr.GetPoint(i)
+                file.write(str(point[1]) + " ")
+            file.write(" \n")
+
+            for i in range(0, vtr.GetNumberOfPoints()):
+                point = vtr.GetPoint(i)
+                file.write(str(point[2]) + " ")
+            file.write(" \n")
+
+        # Other data
+        for header in headers:
+            array = vtr.GetCellData().GetArray(header)
+            for e in range(0, vtr.GetNumberOfCells()):
+                file.write(str(array.GetValue(e)) + " ")
+            file.write(" \n")
+ 
+        file.close()
+
+    def __get_tec_vector_headers(self, headers):
+        vector_headers = []
+        for header in headers:
+            vector_headers.append(f'{header}_X')
+            vector_headers.append(f'{header}_Y')
+            vector_headers.append(f'{header}_Z')
+        return vector_headers
+    
+    def __get_varlocarion_string(self, headers):
+        var_string = ''
+        for i in range(0, len(headers)):
+            if i == len(headers)-1:
+                var_string = f'{var_string}{str(i+4)}=CELLCENTERED'
+            else:
+                var_string = f'{var_string}{str(i+4)}=CELLCENTERED,'
+        return var_string
+    
+    # write the vector result for one timestep
+    def __write_vector_result(self, vis_time_step, dataframe, headers):
+        
+        index = self.time_steps_list.index(vis_time_step)
+        extension = os.path.splitext(self.main_geometry)[1]
+        vtr_path = os.path.join(self.setting.vis_dir, 'paraview', f'time_step_{vis_time_step.time_step}{extension}')
+        self.time_steps_list[index].vtu_file_name = vtr_path
+
+        if not os.path.exists(vtr_path):
+            vector_vtr = self.__read_vtk_file(self.main_geometry)
+            # add time step data
+            timesteps = vtkDoubleArray()
+            timesteps.SetName("TimeValue")
+            timesteps.SetNumberOfTuples(1)
+            timesteps.SetNumberOfComponents(1)
+            timesteps.SetTuple1(0, vis_time_step.time)
+            vector_vtr.SetFieldData(vtkFieldData())
+            vector_vtr.GetFieldData().AddArray(timesteps)
+         
+        else:
+            vtr_reader = vtkXMLRectilinearGridReader()
+            vtr_reader.SetFileName(vtr_path)
+            vtr_reader.Update()
+            vector_vtr = vtr_reader.GetOutput()
+
+        vtu_reader = vtkXMLUnstructuredGridReader()
+        vtu_reader.SetFileName(self.elem_conne_path)
+        vtu_reader.Update()
+        conne_vtu = vtu_reader.GetOutput()
+
+
+        variable_list = []
+        for header in headers:
+            #if not header == 'ELEM1' and not header == 'ELEM2' and not header == 'INDEX':
+            array = vtkDoubleArray()
+            array.SetName(header)
+            array.SetNumberOfComponents(3)
+            array.SetNumberOfTuples(vector_vtr.GetNumberOfCells())
+            array.FillComponent(0, 0)
+            array.FillComponent(1, 0)
+            array.FillComponent(2, 0)
+            vector_vtr.GetCellData().AddArray(array)
+            variable_list.append(VisVariable(header, ValueType.Vector, 3))
+
+        if self.current_out_file not in self.variable_list:
+            self.variable_list[self.current_out_file] = variable_list
+            
+
+        for elem_id in range(0, conne_vtu.GetNumberOfPoints()):
+            point = conne_vtu.GetPoint(elem_id)
+            cellIDs = vtkIdList()
+            conne_vtu.GetPointCells(elem_id, cellIDs)
+            next_x = -1
+            next_y = -1
+            next_z = -1
+            for i in range(0, cellIDs.GetNumberOfIds()):
+                cellID = cellIDs.GetId(i)
+                cell = conne_vtu.GetCell(cellID)
+                next_id = cell.GetPointId(1)
+
+                if next_id - elem_id == 1:
+                    next_x = cellID
+
+                elif next_id - elem_id == self.xyz_elem[0]:
+                    if self.xyz_elem[1] == 1:
+                        next_z = cellID
+                        next_y = -1
+                        break
+
+
+                    else:
+                        next_y = cellID
+
+                elif next_id - elem_id == self.xyz_elem[0] * self.xyz_elem[1]:
+                    next_z = cellID
+
+            for header in headers:
+                #if not header == 'ELEM1' and not header == 'ELEM2' and not header == 'INDEX':
+                x_value = 0 if next_x == -1 else self.__parse_float(dataframe[header][next_x])
+                y_value = 0 if next_y == -1 else self.__parse_float(dataframe[header][next_y])
+                z_value = 0 if next_z == -1 else self.__parse_float(dataframe[header][next_z])
+                vector_vtr.GetCellData().GetArray(header).SetComponent(elem_id, 0, x_value)
+                vector_vtr.GetCellData().GetArray(header).SetComponent(elem_id, 1, y_value)
+                vector_vtr.GetCellData().GetArray(header).SetComponent(elem_id, 2, z_value)
+
+        self.__write_vtk_file(
+            vector_vtr, self.time_steps_list[index].vtu_file_name)
+        print(f'    ✓ Timestep {vis_time_step.time_step}:{vis_time_step.time} created: {vtr_path}')
+
+        if VisType.Tecplot not in self.setting.vis_types:
+            return
+        
+        # Start Tecplot generating
+        tec_name = pathlib.Path(self.setting.input_file_paths[0]).stem
+        self.tec_vector_path = os.path.join(self.setting.vis_dir, f'{tec_name}_vector.dat')
+        firstFile = True
+        if os.path.isfile(self.tec_vector_path):
+            firstFile = False
+        file = open(self.tec_vector_path, "a")
+
+        vector_headers = self.__get_tec_vector_headers(headers)
+        # add header
+        if firstFile:
+            file.write('TITLE = TECPLOT PLOT \n')
+            header_string = '"'+'", "'.join(vector_headers) + '"'
+            file.write(f'VARIABLES = "X", "Y", "Z", {header_string}\n')
+        
+        time_statement = f'ZONE T="{vis_time_step.time_step}, Time = {vis_time_step.time}", I={self.xyz_elem[0] + 1}, J={self.xyz_elem[1] + 1}, K={self.xyz_elem[2] + 1}, SOLUTIONTIME={vis_time_step.time}, DATAPACKING=BLOCK, VARLOCATION=({self.__get_varlocarion_string(vector_headers)})'
+        if not firstFile:
+            time_statement = f'{time_statement}, D=(1,2,3,FECONNECT)'
+        #if self.setting.debug:
+            #time_statement = f'ZONE T ="{vis_time_step.time_step}, Time = {vis_time_step.time}", N = {vtu_cell_to_points.GetNumberOfPoints()}, E = {vtu_cell_to_points.GetNumberOfCells()}, F = FEPOINT, ET = {tecplot_cell_type}\n' 
+        file.write(f'{time_statement}\n')
+
+        # X, Y, Z
+        if firstFile:
+            for i in range(0, vector_vtr.GetNumberOfPoints()):
+                point = vector_vtr.GetPoint(i)
+                file.write(str(point[0]) + " ")
+            file.write(" \n")
+
+            for i in range(0, vector_vtr.GetNumberOfPoints()):
+                point = vector_vtr.GetPoint(i)
+                file.write(str(point[1]) + " ")
+            file.write(" \n")
+
+            for i in range(0, vector_vtr.GetNumberOfPoints()):
+                point = vector_vtr.GetPoint(i)
+                file.write(str(point[2]) + " ")
+            file.write(" \n")
+
+        # Other data
+        for header in headers:
+            array = vector_vtr.GetCellData().GetArray(header)
+
+            for e in range(0, vector_vtr.GetNumberOfCells()):
+                file.write(f'{str(array.GetComponent(e, 0))} ')
+            file.write(" \n")
+
+            for e in range(0, vector_vtr.GetNumberOfCells()):
+                file.write(f'{str(array.GetComponent(e, 1))} ')
+            file.write(" \n")
+
+            for e in range(0, vector_vtr.GetNumberOfCells()):
+                file.write(f'{str(array.GetComponent(e, 2))} ')
+            file.write(" \n")
+
+        file.close()
+
+
+    def __create_elem_conne(self):
+
+        '''
+            read elem and conn files into dataframe
+        '''
+        
+        elem_colspecs = [(0, 5), (5, 10), (10, 15), (15, 20), (20, 30), (30, 40),
+                         (40, 50), (50, 60), (60, 70), (70, 80)]  # define column widths
+        self.eleme_buffer.seek(0)
+        elem_df = pd.read_fwf(self.eleme_buffer, colspecs=elem_colspecs, header=None,
+                              names=['ELEME', 'NSEQ', 'NADD', 'MA12',
+                                     'VOLX', 'AHTX', 'PMX', 'X', 'Y', 'Z'],
+                              dtype={'ELEME': str, 'NSEQ': float, 'NADD': float, 'MA12': str, 'VOLX': float, 'AHTX': float, 'PMX': float, 'X': float, 'Y': float, 'Z': float})
+        
+        conn_colspecs = [(0, 5), (5, 10), (10, 15), (15, 20), (20, 25), (25, 30),
+                         (30, 40), (40, 50), (50, 60), (60, 70), (70, 80)]  # define column widths
+
+        self.conne_buffer.seek(0)
+        conn_df = pd.read_fwf(self.conne_buffer, colspecs=conn_colspecs, header=None,
+                              names=['ELEM_1', 'ELEM_2', 'NSEQ', 'NAD1', 'NAD2',
+                                     'ISOT', 'D1', 'D2', 'AREAX', 'BETAX', 'SIGX'],
+                              dtype={'ELEM_1': str, 'ELEM_2': str, 'NSEQ': float, 'NAD1': float, 'NAD2': float, 'ISOT': float, 'D1': float, 'D2': float, 'AREAX': float, 'BETAX': float, 'SIGX': float})
+
+        
+        elem_df['original_index'] = range(0, len(elem_df))
+        if self.__check_isReverse(elem_df):
+            #Sort all dataframes
+            elem_df = elem_df.sort_values(['Z', 'Y', 'X'], ascending = [True, True, True])
+            elem_df = elem_df.reset_index(drop=True)
+            elem_df.reset_index()
+
+
+        # create material map
+        unique_mats = elem_df['MA12'].unique()
+        # Create a dictionary mapping index -> MAT value
+        mat_mapping = {mat: i for i, mat in enumerate(unique_mats)}
+        
+        '''
+            create vtk points from elem
+        '''
+        vtk_points = vtkPoints()
+        elemIDArray = vtkStringArray()
+        elemIDArray.SetName('ELEME')
+        matArray = vtkStringArray()
+        matArray.SetName('Material')
+        matIDArray = vtkIntArray()
+        matIDArray.SetName('Material_ID')
+        pmxArray = vtkDoubleArray()
+        pmxArray.SetName('PMX')
+        volxArray = vtkDoubleArray()
+        volxArray.SetName('VOLX')
+        elem_id_dist = {}
+        self.sequence_dist = {}
+        self.number_of_elements = len(elem_df.values)
+        length = len(elem_df.values)
+        for i in range(0, len(elem_df.values)):
+            # y = elem_df['Y'][i]
+            #[x, y, z] = [elem_df['X'][i], elem_df['Y'][i], elem_df['Z'][i]]
+            vtk_points.InsertNextPoint(self.__parse_float(elem_df['X'][i]), self.__parse_float(
+                elem_df['Y'][i]), self.__parse_float(elem_df['Z'][i]))
+            elem_id = elem_df['ELEME'][i].strip()
+            elemIDArray.InsertNextValue(elem_id)
+            elem_id_dist[elem_id] = i
+            original_index = int(elem_df['original_index'][i])
+            self.sequence_dist[i] = original_index
+            volxArray.InsertNextValue(self.__parse_float(elem_df['VOLX'][i]))
+            matArray.InsertNextValue(elem_df['MA12'][i])
+            matIDArray.InsertNextValue(mat_mapping[elem_df['MA12'][i]])
+            pmxArray.InsertNextValue(self.__parse_float(elem_df['PMX'][i]))
+
+        '''
+        compute permeability
+        '''
+        rock_colspecs = [(0, 5), (30, 40), (40, 50), (50, 60), (100, 110)]  # define column widths
+        rock_names = ['MAT', 'PER_1', 'PER_2', 'PER_3', 'SGR']
+        self.rocks_buffer.seek(0)
+        rocks_df = pd.read_fwf(self.rocks_buffer, colspecs=rock_colspecs, header=None,
+                              names=rock_names,
+                              dtype={'MAT':str, 'PER_1':str, 'PER_2':str, 'PER_3':str, 'SGR':str})
+        
+        #sgr_dict = {}
+        self.rock_dict = None
+        if len(rocks_df) > 0:
+            #rock_dict = {}
+            rock_dict = []
+            for i in range(0, len(rocks_df)):
+                #rock_dict[rocks_df['MAT'][i]] = [self.parse_float(rocks_df['PER_1'][i]), self.parse_float(rocks_df['PER_2'][i]), self.parse_float(rocks_df['PER_3'][i])]
+                rock_dict.append({
+                    'id': i,
+                    'rock_name': rocks_df['MAT'][i],
+                    'per_1':self.__parse_float(rocks_df['PER_1'][i]),
+                    'per_2':self.__parse_float(rocks_df['PER_2'][i]),
+                    'per_3':self.__parse_float(rocks_df['PER_3'][i]),
+                    'sgr':self.__parse_float(rocks_df['SGR'][i])
+                })
+                #sgr_dict[rocks_df['MAT'][i]] = self.__parse_float(rocks_df['SGR'][i])
+            # compute per
+            per_array = vtkDoubleArray()
+            per_array.SetName('Permeability')
+
+            sgr_array = vtkDoubleArray()
+            sgr_array.SetName('sgr')
+            for i in range(0, len(elem_df.values)):
+                value = 0
+
+                mat = matArray.GetValue(i)
+                if self.__isInt(mat):  
+                    mat_id = int(mat)
+                    value = pmxArray.GetValue(i) * rock_dict[mat_id-1]['per_1']
+                    sgr = rock_dict[mat_id-1]['sgr']
+                else:
+                    rock_item = [rock for rock in rock_dict if rock['rock_name'] == mat]
+                    #if mat in rock_dict:
+                    value = pmxArray.GetValue(i) * rock_item[0]['per_1']
+                    sgr = rock_item[0]['sgr']
+                
+                per_array.InsertNextValue(value)
+                sgr_array.InsertNextValue(sgr)
+            self.rock_dict = rock_dict
+
+
+
+        '''
+            create connection cell array from conne
+        '''
+        d1_array = vtkDoubleArray()
+        d1_array.SetName('D1')
+        d2_array = vtkDoubleArray()
+        d2_array.SetName('D2')
+        area_array = vtkDoubleArray()
+        area_array.SetName('AREAX')
+
+        line_cell_array = vtkCellArray()
+        for i in range(0, len(conn_df.values)):
+            elem_1_id = conn_df['ELEM_1'][i].strip()
+            point_1_id = elem_id_dist[elem_1_id]
+            elem_2_id = conn_df['ELEM_2'][i].strip()
+            point_2_id = elem_id_dist[elem_2_id]
+            # elem_conne_dist[point_id]
+            cell = vtkLine()
+            cell.GetPointIds().SetNumberOfIds(2)
+            cell.GetPointIds().SetId(0, point_1_id)
+            cell.GetPointIds().SetId(1, point_2_id)
+            line_cell_array.InsertNextCell(cell)
+            d1_array.InsertNextValue(conn_df['D1'][i])
+            d2_array.InsertNextValue(conn_df['D2'][i])
+            area_array.InsertNextValue(conn_df['AREAX'][i])
+
+        '''
+            create vtu to display elem and conne 
+        '''
+        self.elem_conne_path = os.path.join(
+            self.setting.vis_dir, "elem_conne.vtu")
+        elem_conne_vtu = vtkUnstructuredGrid()
+
+        elem_conne_vtu.SetPoints(vtk_points)
+        elem_conne_vtu.GetPointData().AddArray(elemIDArray)
+        elem_conne_vtu.GetPointData().AddArray(volxArray)
+        elem_conne_vtu.GetPointData().AddArray(matArray)
+        elem_conne_vtu.GetPointData().AddArray(matIDArray)
+
+        elem_conne_vtu.SetCells(4, line_cell_array)
+        elem_conne_vtu.GetCellData().AddArray(d1_array)
+        elem_conne_vtu.GetCellData().AddArray(d2_array)
+        elem_conne_vtu.GetCellData().AddArray(area_array)
+        vtu_writer = vtkXMLUnstructuredGridWriter()
+        vtu_writer.SetFileName(self.elem_conne_path)
+        vtu_writer.SetInputData(elem_conne_vtu)
+        vtu_writer.Write()
+
+        if os.path.exists(self.elem_conne_path):
+            print(f'    ✓ Elements and connections created: {self.elem_conne_path}')
+            
+        self.number_of_connections = elem_conne_vtu.GetNumberOfCells()
+
+    def __create_main_geometry(self):
+       
+
+        '''
+            find number of elements in x, y, z directions 
+            TODO: check if vtu bound is inside user input bounds
+        '''
+       
+
+       # prepare the vtu file
+        vtu_reader = vtkXMLUnstructuredGridReader()
+        vtu_reader.SetFileName(self.elem_conne_path)
+        vtu_reader.Update()
+        elem_conne_vtu = vtu_reader.GetOutput()
+
+        d1_array = elem_conne_vtu.GetCellData().GetArray('D1')
+        d2_array = elem_conne_vtu.GetCellData().GetArray('D2')
+        elemIDArray = elem_conne_vtu.GetPointData().GetArray('ELEME')
+        volxArray = elem_conne_vtu.GetPointData().GetArray('VOLX')
+        matArray = elem_conne_vtu.GetPointData().GetArray('Material')
+        matIDArray = elem_conne_vtu.GetPointData().GetArray('Material_ID')
+        pmxArray = elem_conne_vtu.GetPointData().GetArray('PMX')
+        if self.rock_dict is not None:
+            per_array = elem_conne_vtu.GetCellData().GetArray('Permeability')
+            sgr_array = elem_conne_vtu.GetCellData().GetArray('sgr')
+        
+
+
+        # get connection bound
+        vtu_bounds = elem_conne_vtu.GetBounds()
+
+        # create array to keep x, y, z elements
+        xyz_elem = []
+        xyz_elem.append(0)  # add x eleme
+        xyz_elem.append(0)  # add y eleme
+        xyz_elem.append(0)  # add z eleme
+
+        if vtu_bounds[0] == vtu_bounds[1]:
+            xyz_elem[0] = 1
+        if vtu_bounds[2] == vtu_bounds[3]:
+            xyz_elem[1] = 1
+        if vtu_bounds[4] == vtu_bounds[5]:
+            xyz_elem[2] = 1
+
+        # find x, y , z number of  structured points
+        for i in range(0, elem_conne_vtu.GetNumberOfPoints()):
+            point = elem_conne_vtu.GetPoint(i)
+            if xyz_elem[0] == 0 and point[0] == vtu_bounds[1]:
+                xyz_elem[0] = i+1
+            if xyz_elem[1] == 0 and point[0] == vtu_bounds[1] and point[1] == vtu_bounds[3]:
+                if xyz_elem[0] != 0:
+                    xyz_elem[1] = int((i+1)/xyz_elem[0])
+                    break
+
+        if xyz_elem[1] != 0 and xyz_elem[0] != 0:
+            xyz_elem[2] = int(elem_conne_vtu.GetNumberOfPoints() / xyz_elem[0] / xyz_elem[1])
+        self.xyz_elem = xyz_elem
+
+        range_ratio = 1
+        np_xyz_elem = np.array(xyz_elem)
+        if xyz_elem[0] != 0 and xyz_elem[1] != 0 and xyz_elem[2] != 0:
+            range_ratio = np.max(np_xyz_elem)/np.min(np_xyz_elem)
+
+
+
+        if all(xyz_elem) and range_ratio < 1000:
+            if os.path.exists(self.setting.corners_file):
+                self.setting.mesh_type = MeshType.StructuredGridOrth
+            else:
+                self.setting.mesh_type = MeshType.RegularGrid
+                
+        else:
+            is_parallel = self.__checkParallel(elem_conne_vtu)
+            # check if polygonal mesh
+
+            if os.path.exists(self.setting.corners_file):
+                if is_parallel:
+                    self.setting.mesh_type = MeshType.StructuredGridFree
+                else:
+                    self.setting.mesh_type = MeshType.PolygonalMesh
+            else:
+                print('Error: Your mesh type is not supported')
+                sys.exit(1)
+
+        print(f'    Mesh type: {self.setting.mesh_type.name}')
+
+        # Read corners file to dataframe
+        if os.path.exists(self.setting.corners_file):
+            corners_buffer = io.StringIO()
+            csv_headers = []
+            line_number = -1
+            with open(self.setting.corners_file) as f:
+                for line in f:
+                    line_number = line_number + 1
+                    values = line.strip().split(',')
+                    values = [x.replace('"', '') for x in values]
+                    if line_number == 0:
+                        
+                        csv_headers = [x.strip() for x in values]
+                        csv_headers = csv_headers[:3]
+                        header_string = ','.join(csv_headers)
+                        corners_buffer.write(header_string + '\n')
+                    else:
+                        corners_buffer.write(','.join(values[:3]) + '\n')
+            corners_buffer.seek(0)
+            corners_df = pd.read_csv(corners_buffer, sep=',', header=0)
+ 
+            # Write four corners to vtu
+            all_points = vtkPoints()
+            all_cells = vtkCellArray()
+
+            for index, row in corners_df.iterrows():
+                all_points.InsertNextPoint(row["X"], row["Y"], row["Z"])
+                cell = vtkVertex()
+                cell.GetPointIds().SetNumberOfIds(1)
+                cell.GetPointIds().SetId(0, index)
+                all_cells.InsertNextCell(cell)
+            
+            corners_vtu = vtkUnstructuredGrid()
+            corners_vtu.SetPoints(all_points)
+            corners_vtu.SetCells(1, all_cells)
+            print(f'    Read corners from {self.setting.corners_file}')
+            
+            # write four corners to vtu (debugging)
+            if self.setting.debug:
+                corners_vtu_writer = vtkXMLUnstructuredGridWriter()
+                corners_vtu_writer.SetFileName(os.path.join(self.setting.vis_dir, "corners.vtu"))
+                corners_vtu_writer.SetInputData(corners_vtu)
+                corners_vtu_writer.Write()
+
+
+
+        if self.setting.mesh_type == MeshType.RegularGrid:
+            '''
+                * for RGrid from MeshMaker
+                find index for determining x, y, z index
+            '''
+            xyz_index = []
+            xyz_index.append([])  # add x index
+            xyz_index.append([])  # add y index
+            xyz_index.append([])  # add z index
+
+            for i in range(0, xyz_elem[0]):
+                xyz_index[0].append(i)
+            for i in range(0, xyz_elem[1]):
+                xyz_index[1].append(i * xyz_elem[0])
+            for i in range(0, xyz_elem[2]):
+                xyz_index[2].append(i * xyz_elem[0] * xyz_elem[1])
+                xyz_coordinates = []
+                xyz_coordinates.append([])  # add x coordinates
+                xyz_coordinates.append([])  # add y coordinates
+                xyz_coordinates.append([])  # add z coordinates
+
+            for key in range(0, len(xyz_index)):
+                for index in xyz_index[key]:
+                    point = elem_conne_vtu.GetPoint(index)
+                    cellIDs = vtkIdList()
+                    # find all cells connect to this point
+                    elem_conne_vtu.GetPointCells(index, cellIDs)
+                    d1 = 0
+                    d2 = 0
+                    find_next = False
+
+                    for i in range(0, cellIDs.GetNumberOfIds()):
+                        cellID = cellIDs.GetId(i)
+                        cell = elem_conne_vtu.GetCell(cellID)
+                        # find next id in line element
+
+                        next_id = cell.GetPointId(1)
+                        if next_id == index:
+                            next_id = cell.GetPointId(0)
+                        if next_id in xyz_index[key]:
+                            d1 = d1_array.GetValue(cellID)
+                            d2 = d2_array.GetValue(cellID)
+                            find_next = True
+                            break
+
+                    # if it has any connection to other node
+                    if find_next:
+                        # add first node
+                        if len(xyz_coordinates[key]) == 0:
+                            first_value = point[key] - d1
+                            if self.setting.known_bounds:
+                                first_value = self.setting.bounds[key*2]
+                            xyz_coordinates[key].append(first_value)
+
+                        # add current node
+                        xyz_coordinates[key].append(point[key] + d1)
+
+                        # add last node
+                        if len(xyz_coordinates[key]) == xyz_elem[key]:
+                            last_value = point[key] + d1 + (2*d2)
+                            if self.setting.known_bounds:
+                                last_value = self.setting.bounds[key*2+1]
+                            xyz_coordinates[key].append(last_value)
+
+                    # if there is only one element in this dimension
+                    elif len(xyz_index[key]) == 1:
+                        if self.setting.known_bounds:
+                            xyz_coordinates[key].append(self.setting.bounds[key*2])
+                            xyz_coordinates[key].append(
+                                self.setting.bounds[key*2+1])
+                        else:
+                            if point[key] == 0:
+                                # find max elem
+                                xyz_elem_np_array = np.array(
+                                    (xyz_elem[0], xyz_elem[1], xyz_elem[2]))
+                                max = xyz_elem_np_array.max()
+                                index = xyz_elem.index(max)
+                                guess_value = (
+                                    vtu_bounds[index*2+1] - vtu_bounds[index]) / max
+                                xyz_coordinates[key].append(-1 * guess_value)
+                                xyz_coordinates[key].append(guess_value)
+                            else:
+                                xyz_coordinates[key].append(
+                                    point[key] - abs(point[key]))
+                                xyz_coordinates[key].append(
+                                    point[key] + abs(point[key]))
+
+            '''
+                create vtk rgid and translate it to vtu
+            '''
+            # self.rgrid_vtr = os.path.join(self.setting.vis_dir, "temp_rgrid.vtr")
+            xyz_coords_array = []
+            xyz_coords_array.append(vtkDoubleArray())
+            xyz_coords_array.append(vtkDoubleArray())
+            xyz_coords_array.append(vtkDoubleArray())
+
+            for key in range(0, len(xyz_coords_array)):
+                for value in xyz_coordinates[key]:
+                    xyz_coords_array[key].InsertNextValue(value)
+
+            rGrid = vtkRectilinearGrid()
+            rGrid.SetDimensions(xyz_elem[0]+1, xyz_elem[1]+1, xyz_elem[2]+1)
+
+            rGrid.SetXCoordinates(xyz_coords_array[0])
+            rGrid.SetYCoordinates(xyz_coords_array[1])
+            rGrid.SetZCoordinates(xyz_coords_array[2])
+            rGrid.GetCellData().AddArray(elemIDArray)
+            rGrid.GetCellData().AddArray(volxArray)
+            rGrid.GetCellData().AddArray(matArray)
+
+            rGrid.GetCellData().AddArray(matIDArray)
+            if self.rock_dict is not None:
+                rGrid.GetCellData().AddArray(per_array)
+                rGrid.GetCellData().AddArray(sgr_array)
+            rGrid.GetCellData().AddArray(pmxArray)
+
+            self.main_geometry = os.path.join(
+                self.setting.vis_dir, "main_geometry.vtr")
+            self.__write_vtk_file(rGrid, self.main_geometry)
+            
+
+        if self.setting.mesh_type == MeshType.StructuredGridOrth:
+
+            #corners_df.to_csv(os.path.join(self.setting.vis_dir, "corners.csv"), index=False)
+            # Step 1: Group by `x` and `y`, and sort `z` within each group
+            corners_df = corners_df.groupby(['X', 'Y'], group_keys=False).apply(lambda group: group.sort_values(by='Z'))
+            # Step 3: Set the new index using `x` and `y` columns
+            corners_df = corners_df.set_index(['X', 'Y']).sort_index()
+
+            distinct_x = corners_df.index.get_level_values('X').unique()
+            distinct_y = corners_df.index.get_level_values('Y').unique()
+
+            vts = vtkStructuredGrid()
+            vts.SetDimensions(self.xyz_elem[0]+1, self.xyz_elem[1]+1, self.xyz_elem[2]+1)
+            vts_points = vtkPoints()
+
+            for z_index in range(0, self.xyz_elem[2]+1):
+                for y_index in range(0, len(distinct_y)):
+                    for x_index in range(0, len(distinct_x)):
+                        x = distinct_x[x_index]
+                        y = distinct_y[y_index]
+                        z_value = corners_df.loc[(x, y), 'Z'].iloc[z_index]
+                        vts_points.InsertNextPoint(x, y, z_value)
+            
+            vts.SetPoints(vts_points) 
+            vts.GetCellData().AddArray(elemIDArray)
+            vts.GetCellData().AddArray(volxArray)
+            vts.GetCellData().AddArray(matArray)
+
+            vts.GetCellData().AddArray(matIDArray)
+            if self.rock_dict is not None:
+                vts.GetCellData().AddArray(per_array)
+                vts.GetCellData().AddArray(sgr_array)
+            self.main_geometry = os.path.join(self.setting.vis_dir, "main_geometry.vts")
+            self.__write_vtk_file(vts, self.main_geometry)
+            
+        
+        if self.setting.mesh_type == MeshType.StructuredGridFree:
+            #initialize the locator
+            pointTree = vtkPointLocator()
+            pointTree.SetDataSet(corners_vtu)
+            pointTree.BuildLocator()
+            
+            cell_array = vtkCellArray()
+
+            for i in range(0, elem_conne_vtu.GetNumberOfPoints()):
+                point = elem_conne_vtu.GetPoint(i)
+                result = vtkIdList()
+                #find the closest point to the the center of each element
+                pointTree.FindClosestNPoints(8, point, result)
+                result.Sort()
+
+                cell = vtkHexahedron()
+                cell.GetPointIds().SetNumberOfIds(8)
+                # need to sort the points in the rigth order
+                points_array = []
+
+                for j in range(0, 8):
+                    points_array.append(corners_vtu.GetPoint(result.GetId(j)))
+
+                points_array = np.array(points_array)
+                result_index = self.__reorder_hexahedron(points_array)
+                
+                for j in range(0, 8):
+                    cell.GetPointIds().SetId(j, result.GetId(result_index[j]))
+                cell_array.InsertNextCell(cell)
+        
+            auto_corner_vtu = vtkUnstructuredGrid()
+            auto_corner_vtu.SetPoints(all_points)
+            auto_corner_vtu.SetCells(12, cell_array)
+            
+            # TODO: compute mesh quality and fix bad cells
+            
+            
+            auto_corner_vtu.GetCellData().AddArray(elemIDArray)
+            auto_corner_vtu.GetCellData().AddArray(volxArray)
+            auto_corner_vtu.GetCellData().AddArray(matArray)
+            if self.rock_dict is not None:
+                auto_corner_vtu.GetCellData().AddArray(per_array)
+                auto_corner_vtu.GetCellData().AddArray(sgr_array)
+            auto_corner_vtu.GetCellData().AddArray(matIDArray)
+            self.main_geometry = os.path.join(self.setting.vis_dir, "main_geometry.vtu")
+            self.__write_vtk_file(auto_corner_vtu, self.main_geometry)
+            
+
+        if self.setting.mesh_type == MeshType.PolygonalMesh:
+            
+            # == Create `distinct_points` and `labeled_temp_elem` == 
+            # Extract points from the grid
+            points = np.array([elem_conne_vtu.GetPoint(i) for i in range(elem_conne_vtu.GetNumberOfPoints())])
+            # Convert to Pandas DataFrame for easier manipulation
+            df = pd.DataFrame(points, columns=["x", "y", "z"])
+            # Round (x, y) values to avoid floating-point precision issues
+            df[["x", "y"]] = df[["x", "y"]].round(10)
+            
+            #df.to_csv(os.path.join(self.setting.vis_dir, 'all_points.csv'))
+            # Find distinct (x, y) sets and create an index mapping
+            distinct_xy = df[["x", "y"]].drop_duplicates().reset_index(drop=True)
+            distinct_xy["Elem_Index"] = distinct_xy.index  # Assign an index to each unique (x, y)
+            #distinct_xy.to_csv(os.path.join(self.setting.vis_dir, 'distinct_xy.csv'))
+
+            # add distinct_xy to a vtkpoints object
+            all_points = vtkPoints()
+            all_points.SetDataTypeToDouble()
+            for i in range(len(distinct_xy)):
+                values = distinct_xy.iloc[i].values
+                all_points.InsertNextPoint(values[0], values[1], 0)
+
+            # create a polydata object
+            distinct_points = vtkPolyData()
+            distinct_points.SetPoints(all_points)
+
+            cell_array = vtkCellArray()
+            for i in range(all_points.GetNumberOfPoints()):
+                vertex = vtkVertex()
+                vertex.GetPointIds().SetId(0, i)
+                cell_array.InsertNextCell(vertex)
+
+            distinct_points.SetVerts(cell_array)
+            xy_index_labels = distinct_xy["Elem_Index"].to_numpy()
+            elem_id_array = vtkIntArray()
+            elem_id_array.SetName("Elem_Index")
+            for i in range(len(xy_index_labels)):
+                elem_id_array.InsertNextValue(int(xy_index_labels[i]))
+            distinct_points.GetPointData().AddArray(elem_id_array)
+
+            if self.setting.debug:
+                # Write the distinct points to a VTU file for debugging
+                writer = vtkXMLPolyDataWriter()
+                writer.SetInputData(distinct_points)
+                writer.SetFileName(os.path.join(self.setting.vis_dir, 'distinct_points.vtp'))
+                writer.Write()
+
+
+            # Merge the index back to the original DataFrame
+            df = df.merge(distinct_xy, on=["x", "y"], how="left")
+
+            # Compute Z descending order within each (x, y) group
+            df["Horizon_ID"] = df.groupby(["x", "y"])["z"].rank(method="first", ascending=True).astype(int) - 1
+
+            # Convert the labels to NumPy arrays
+
+            z_order_labels = df["Horizon_ID"].to_numpy()
+            xy_index_labels = df["Elem_Index"].to_numpy()
+
+            # Add labels to the VTU file
+            xy_index_array = vtkIntArray()
+            xy_index_array.SetName("Elem_Index")
+            xy_index_array.SetNumberOfComponents(1)
+            xy_index_array.SetNumberOfTuples(len(xy_index_labels))
+
+            z_order_array = vtkIntArray()
+            z_order_array.SetName("Horizon_ID")
+            z_order_array.SetNumberOfComponents(1)
+            z_order_array.SetNumberOfTuples(len(z_order_labels))
+
+            for i, (xy_idx, z_ord) in enumerate(zip(xy_index_labels, z_order_labels)):
+                xy_index_array.SetValue(i, int(xy_idx))
+                z_order_array.SetValue(i, int(z_ord))
+
+            labeled_temp_elem = vtkUnstructuredGrid()
+            labeled_temp_elem.DeepCopy(elem_conne_vtu)
+            labeled_temp_elem.GetPointData().AddArray(xy_index_array)
+            labeled_temp_elem.GetPointData().AddArray(z_order_array)
+            # Write the modified VTU file with labels
+            if self.setting.debug:
+                writer = vtkXMLUnstructuredGridWriter()
+                writer.SetFileName(os.path.join(self.setting.vis_dir, "labeled_temp_elem.vtu"))
+                writer.SetInputData(labeled_temp_elem)
+                writer.Write()
+
+
+            # == Create a VTK 2D `voronoi` mesh ==
+            # Create a Voronoi diagram from the cell centers
+            print("crating voronoi...")
+            voro = vtkVoronoi2D()
+            voro.SetInputData(distinct_points)
+            voro.SetMaximumNumberOfTileClips(distinct_points.GetNumberOfPoints())
+            #voro.set
+            voro.Update()
+            voronoi = voro.GetOutput()
+
+            if self.setting.debug:
+                # Write the Voronoi mesh to a VTU file for debugging
+                voronoi_writer = vtkXMLPolyDataWriter()
+                voronoi_writer.SetInputData(voronoi)
+                voronoi_writer.SetFileName(os.path.join(self.setting.vis_dir, 'voronoi.vtp'))
+                voronoi_writer.Write()
+                print(f'    ✓ Main voronoi created: {os.path.join(self.setting.vis_dir, "voronoi.vtp")}')
+
+
+            # Count Layer
+            
+            number_of_layers = elem_conne_vtu.GetNumberOfPoints() // distinct_points.GetNumberOfPoints()
+            print(f'number_of_layers: {number_of_layers}')
+    
+            # == Create `distinct_corners_points` and `labeled_corners` ==
+            # Clean the grid
+            clean_filter = vtkCleanUnstructuredGrid()
+            clean_filter.SetInputData(corners_vtu)
+            clean_filter.Update()
+            labeled_corners = clean_filter.GetOutput()
+
+            # Extract points from the grid
+            points = np.array([labeled_corners.GetPoint(i) for i in range(labeled_corners.GetNumberOfPoints())])
+
+            # Convert to Pandas DataFrame for easier manipulation
+            df = pd.DataFrame(points, columns=["x", "y", "z"])
+
+            # Round (x, y) values to avoid floating-point precision issues
+            df[["x", "y"]] = df[["x", "y"]].round(6)
+
+            # Find distinct (x, y) sets and create an index mapping
+            distinct_xy = df[["x", "y"]].drop_duplicates().reset_index(drop=True)
+
+            distinct_xy["XY_Index"] = distinct_xy.index  # Assign an index to each unique (x, y)
+
+
+            # add distinct_xy to a vtkpoints object
+            index_array = vtkIntArray()
+            index_array.SetName("XY_Index")
+            all_points = vtkPoints() 
+            all_points.SetDataTypeToDouble()
+            for i in range(len(distinct_xy)):
+                values = distinct_xy.iloc[i].values
+                all_points.InsertNextPoint(values[0], values[1], 0)
+                index_array.InsertNextValue(int(values[2]))
+            # create a polydata object
+            distinct_corners_points = vtkPolyData()
+            distinct_corners_points.SetPoints(all_points)
+            distinct_corners_points.GetPointData().AddArray(index_array)
+
+            cell_array = vtkCellArray()
+            for i in range(all_points.GetNumberOfPoints()):
+                vertex = vtkVertex()
+                vertex.GetPointIds().SetId(0, i)
+                cell_array.InsertNextCell(vertex)
+
+            distinct_corners_points.SetVerts(cell_array)
+
+            if self.setting.debug:
+                # Write the distinct points to a VTU file for debugging
+                writer = vtkXMLPolyDataWriter()
+                writer.SetInputData(distinct_corners_points)
+                writer.SetFileName(os.path.join(self.setting.vis_dir, 'distinct_corners_points.vtp'))
+                writer.Write()
+
+
+
+            # Merge the index back to the original DataFrame
+            df = df.merge(distinct_xy, on=["x", "y"], how="left")
+
+            # Compute Z descending order within each (x, y) group
+            df["Z_Order"] = df.groupby(["x", "y"])["z"].rank(method="first", ascending=True).astype(int) - 1
+
+            # Convert the labels to NumPy arrays
+            xy_index_labels = df["XY_Index"].to_numpy()
+            z_order_labels = df["Z_Order"].to_numpy()
+
+            # Add labels to the VTU file
+            xy_index_array = vtkIntArray()
+            xy_index_array.SetName("XY_Index")
+            xy_index_array.SetNumberOfComponents(1)
+            xy_index_array.SetNumberOfTuples(len(xy_index_labels))
+
+            z_order_array = vtkIntArray()
+            z_order_array.SetName("Layer_ID")
+            z_order_array.SetNumberOfComponents(1)
+            z_order_array.SetNumberOfTuples(len(z_order_labels))
+
+            for i, (xy_idx, z_ord) in enumerate(zip(xy_index_labels, z_order_labels)):
+                xy_index_array.SetValue(i, int(xy_idx))
+                z_order_array.SetValue(i, int(z_ord))
+
+            # Attach the label arrays to the unstructured grid
+            labeled_corners.GetPointData().AddArray(xy_index_array)
+            labeled_corners.GetPointData().AddArray(z_order_array)
+            # Write the modified VTU file with labels
+            if self.setting.debug:
+                writer = vtkXMLUnstructuredGridWriter()
+                writer.SetFileName(os.path.join(self.setting.vis_dir, "labeled_corners.vtu"))
+                writer.SetInputData(labeled_corners)
+                writer.Write()
+
+        
+            # == Create `distinct_corners_points_voronoi` == 
+                #- use `distinct_points` as index, `voronoi` as map, search `distinct_corners_points` to recreate the correct voronoi mesh
+           
+            distinct_corners_points_locator = vtkPointLocator()
+            distinct_corners_points_locator.SetDataSet(distinct_corners_points)
+            distinct_corners_points_locator.BuildLocator()
+
+            correct_voronoi_cell_array = vtkCellArray()
+            elem_id_array = vtkIntArray()
+            elem_id_array.SetName("Elem_Index")
+            # go through each points in distinct_points
+            for i in range(distinct_points.GetNumberOfPoints()):
+                point = distinct_points.GetPoint(i)
+                voronoi_cell = voronoi.GetCell(i)
+                # go through each points in voronoi cell
+                polygon = vtkPolygon()
+                center_point_inserted = False
+                center_point_id = distinct_corners_points_locator.FindClosestPoint(point)
+                for j in range(voronoi_cell.GetNumberOfPoints()):
+                    cell_point_id = voronoi_cell.GetPointId(j)
+                    cell_point = voronoi.GetPoint(cell_point_id)
+                    dist2 = reference(0)
+                    corners_point_id = distinct_corners_points_locator.FindClosestPointWithinRadius(1, [cell_point[0],  cell_point[1], cell_point[2]], dist2)
+
+                    if corners_point_id == -1:
+                        closest_corners_point_id = distinct_corners_points_locator.FindClosestPoint(cell_point)
+                        if (not center_point_inserted) and j+1 < voronoi_cell.GetNumberOfPoints():
+                            next_cell_point_id = voronoi_cell.GetPointId(j+1)
+                            next_cell_point = voronoi.GetPoint(next_cell_point_id)
+                            dist2 = reference(0)
+                            next_corners_point_id = distinct_corners_points_locator.FindClosestPointWithinRadius(1, [next_cell_point[0],  next_cell_point[1], next_cell_point[2]], dist2)
+                            # next point on boundary, so insert the center point after this point
+                            if next_corners_point_id == -1:
+                                polygon.GetPointIds().InsertNextId(closest_corners_point_id)
+                                polygon.GetPointIds().InsertNextId(center_point_id)
+                            # next point is not on boundary, so insert the center point before this point
+                            else:
+                                polygon.GetPointIds().InsertNextId(center_point_id)
+                                polygon.GetPointIds().InsertNextId(closest_corners_point_id)
+                            center_point_inserted = True
+
+                        else:
+                            polygon.GetPointIds().InsertNextId(closest_corners_point_id)
+                            
+                    else:
+                        polygon.GetPointIds().InsertNextId(corners_point_id)
+                correct_voronoi_cell_array.InsertNextCell(polygon)
+                elem_id_array.InsertNextValue(i)
+
+            distinct_corners_points_voronoi = vtkPolyData()
+            distinct_corners_points_voronoi.SetPoints(distinct_corners_points.GetPoints())
+            distinct_corners_points_voronoi.SetPolys(correct_voronoi_cell_array)
+            distinct_corners_points_voronoi.GetCellData().AddArray(elem_id_array)
+            distinct_corners_points_voronoi.GetPointData().AddArray(distinct_corners_points.GetPointData().GetArray("XY_Index"))
+
+            if self.setting.debug:
+                # Write the Voronoi mesh to a VTU file for debugging
+                voronoi_writer = vtkXMLPolyDataWriter()
+                voronoi_writer.SetInputData(distinct_corners_points_voronoi)
+                voronoi_writer.SetFileName(os.path.join(self.setting.vis_dir, 'distinct_corners_points_voronoi.vtp'))
+                voronoi_writer.Write()
+
+            # == create the geometry == 
+            #- use `labeled_temp_elem` points as index (cell sequecne)
+            #- from layer 0 to layer max, horizon 0 to horizon max-1
+            #- use `distinct_corners_points_voronoi` as 2D polygon map to find the actual points from `labeled_corners`
+            #- create each polyhedron by adding top, buttom and side surfaces
+
+            main_geometray = vtkUnstructuredGrid()
+            main_geometray.SetPoints(labeled_corners.GetPoints())
+
+            labeled_corners_points = np.array([labeled_corners.GetPoint(i) for i in range(labeled_corners.GetNumberOfPoints())])
+            labeled_corners_df = pd.DataFrame(labeled_corners_points, columns=["x", "y", "z"])
+            for i in range(labeled_corners.GetPointData().GetNumberOfArrays()):
+                array_name = labeled_corners.GetPointData().GetArrayName(i)
+                array = labeled_corners.GetPointData().GetArray(i)
+                array_values = np.array([array.GetValue(j) for j in range(array.GetNumberOfTuples())])
+                labeled_corners_df[array_name] = array_values
+            #labeled_corners_df.describe()
+
+            horizon_id_array = labeled_temp_elem.GetPointData().GetArray("Horizon_ID")
+            elem_id_array = labeled_temp_elem.GetPointData().GetArray("Elem_Index")
+
+            for index in range(labeled_temp_elem.GetNumberOfPoints()):
+            #for index in range(10):
+                # get voronoi cell
+                voronoi_cell = distinct_corners_points_voronoi.GetCell(elem_id_array.GetValue(index))
+                cell_xy_index = [ voronoi_cell.GetPointId(i) for i in range(voronoi_cell.GetNumberOfPoints())]
+
+                horizon_id = horizon_id_array.GetValue(index)
+                # top face
+
+                polyhedron_faces = [] # top, bottom, sides
+                top_face = []
+                for xy_index in cell_xy_index:
+                    # find point in labeled_corners_df
+                    matching_indexes = labeled_corners_df.index[(labeled_corners_df["Layer_ID"] == horizon_id + 1) & (labeled_corners_df["XY_Index"] == xy_index)]
+                    top_face.append(matching_indexes[0])
+                polyhedron_faces.append(top_face)
+
+                bottom_face = []
+                for xy_index in cell_xy_index:
+                    # find point in labeled_corners_df
+                    matching_indexes = labeled_corners_df.index[(labeled_corners_df["Layer_ID"] == horizon_id) & (labeled_corners_df["XY_Index"] == xy_index)]
+                    bottom_face.append(matching_indexes[0])
+                polyhedron_faces.append(bottom_face)
+
+                for j in range(len(cell_xy_index)):
+                    if j == len(cell_xy_index) -1:
+                        side_face = [top_face[0], top_face[j], bottom_face[j], bottom_face[0]]
+                    else:
+                        side_face = [top_face[j+1], top_face[j], bottom_face[j], bottom_face[j+1]]
+                    polyhedron_faces.append(side_face)
+
+                # create a polyhedron
+                number_of_faces = voronoi_cell.GetNumberOfPoints() + 2
+                polyhedron_faces_idlist = vtkIdList()
+                # Number faces that make up the cell.
+                polyhedron_faces_idlist.InsertNextId(number_of_faces)
+                for face in polyhedron_faces:
+                    # Number of points in the face == numberOfFaceVertices
+                    polyhedron_faces_idlist.InsertNextId(len(face))
+                    # Insert the pointIds for that face.
+                    [polyhedron_faces_idlist.InsertNextId(i) for i in face]
+
+                main_geometray.InsertNextCell(VTK_POLYHEDRON, polyhedron_faces_idlist)
+                
+
+            main_geometray.GetCellData().AddArray(elemIDArray)
+            main_geometray.GetCellData().AddArray(volxArray)
+            main_geometray.GetCellData().AddArray(matArray)
+            if self.rock_dict is not None:
+                main_geometray.GetCellData().AddArray(per_array)
+                main_geometray.GetCellData().AddArray(sgr_array)
+            main_geometray.GetCellData().AddArray(matIDArray)
+            main_geometray.GetCellData().AddArray(matIDArray)
+            main_geometray.GetCellData().AddArray(horizon_id_array)
+            self.main_geometry = os.path.join(
+                self.setting.vis_dir, "main_geometry.vtu")
+            self.__write_vtk_file(main_geometray, self.main_geometry)
+        
+        if os.path.exists(self.main_geometry):
+            print(f'    ✓ Main geometry created: {self.main_geometry}')
+
+    def __reorder_hexahedron(self, points):
+        # Step 1: Sort points by Z coordinate to separate bottom and top layers
+        sorted_indices = np.argsort(points[:, 2])  # Sort indices by z-coordinate
+        bottom_indices = sorted_indices[:4]  # 4 lowest Z values
+        top_indices = sorted_indices[4:]  # 4 highest Z values
+
+        # Step 2: Compute centroid of bottom plane for angle sorting
+        centroid = np.mean(points[bottom_indices, :2], axis=0)  # Only x and y
+
+        # Step 3: Compute angles from centroid and sort counterclockwise
+        def angle_from_centroid(idx):
+            p = points[idx]
+            return np.arctan2(p[1] - centroid[1], p[0] - centroid[0])
+        
+        bottom_order = sorted(bottom_indices, key=angle_from_centroid)
+        top_order = sorted(top_indices, key=angle_from_centroid)
+
+        # Step 4: Assign correct VTK order
+        reordered_indices = np.array(bottom_order + top_order)
+
+        return reordered_indices
+
+    def __checkParallel(self, elem_conne):
+        dir1 = self.__get_direction_from_polyline(elem_conne.GetCell(0))
+        dir2 = self.__get_direction_from_polyline(elem_conne.GetCell(1))
+        if self.__are_parallel(dir1, dir2):
+            return True
+        return False
+
+    def __get_direction_from_polyline(self, polyline):
+        """
+        Given a vtkPolyLine, compute a representative normalized direction vector.
+        Here we use the vector from the first point to the last point.
+        """
+        points = polyline.GetPoints()
+        num_points = points.GetNumberOfPoints()
+        if num_points < 2:
+            return None  # Not enough points to define a direction.
+        
+        first_pt = np.array(points.GetPoint(0))
+        first_pt[2] = 0
+        last_pt = np.array(points.GetPoint(num_points - 1))
+        last_pt[2] = 0
+        direction = last_pt - first_pt
+        norm = np.linalg.norm(direction)
+        if norm == 0:
+            return None  # Degenerate polyline
+        return direction / norm
+
+    def __are_parallel(self, dir1, dir2, tol=1e-6):
+        """
+        Two vectors are parallel if their cross product is nearly zero
+        (i.e., the magnitude of the cross product is less than a tolerance)
+        """
+        cross_prod = np.cross(dir1, dir2)
+        return np.linalg.norm(cross_prod) < tol
+
+    def __check_isReverse(self, elem_df):
+        """
+        Checks if the given DataFrame has a reverse sequence and determines the mesh plane.
+        This method performs the following steps:
+        1. Checks the real plane by analyzing the standard deviation of the 'X', 'Y', and 'Z' columns.
+        2. Determines if the increasement sequence is in the order of X -> Y -> Z.
+        3. If the sequence is not in the correct order, it re-indexes.
+        Parameters:
+        elem_df (pandas.DataFrame): The DataFrame containing the elements to be checked.
+        Returns:
+        bool: True if the sequence is reversed, False otherwise.
+        """
+        describe = elem_df.describe()
+
+        #    1. check real plane
+        mesh_plane = MeshPlane.unknown
+        still_col = [1, 1, 1]
+        if describe['X']['count'] == 0 or describe['X']['std'] == 0:
+            still_col[0] = 0
+        if describe['Y']['count'] == 0 or describe['Y']['std'] == 0:
+            still_col[1] = 0
+        if describe['Z']['count'] == 0 or describe['Z']['std'] == 0:
+            still_col[2] = 0
+        
+
+        if still_col == [1, 1, 1]:
+            mesh_plane = MeshPlane.XYZ
+        elif still_col == [1, 0, 1]:
+            mesh_plane = MeshPlane.XZ
+        elif still_col == [1, 0, 0]:
+            mesh_plane = MeshPlane.X
+        elif still_col == [1, 1, 0]:
+            mesh_plane = MeshPlane.XY
+        elif still_col == [0, 1, 1]:
+            mesh_plane = MeshPlane.YZ
+        elif still_col == [0, 0, 1]:
+            mesh_plane = MeshPlane.Z
+        elif still_col == [0, 1, 0]:
+            mesh_plane = MeshPlane.Y
+
+        self.setting.mesh_plane = mesh_plane
+
+        # check increase sequence
+        map = ['X', 'Y', 'Z']
+        head = elem_df.head()
+        head_describe = head.describe()
+
+        
+        is_reverse = False
+        # find increasement in each col
+        for i in range(0, 3):
+            if still_col[i] == 1:
+                if head_describe[map[i]]['std'] == 0:
+                    is_reverse = True
+                    break
+                else:
+                    break
+        
+        #self.setting.isReverse = is_reverse
+        return is_reverse
+
+    def __write_vtk_file(self, file, file_path):
+
+        extension = os.path.splitext(self.main_geometry)[1]
+        writer = None
+        if extension == '.vtr':
+            writer = vtkXMLRectilinearGridWriter()
+
+        elif extension == '.vts':
+            writer = vtkXMLStructuredGridWriter()
+
+        elif extension == '.vtu':
+            writer = vtkXMLUnstructuredGridWriter()
+
+        writer.SetFileName(file_path)
+        writer.SetInputData(file)
+        writer.SetDataModeToBinary()
+        writer.Write()
+
+    def __read_vtk_file(self, file_path):
+        
+        extension = os.path.splitext(self.main_geometry)[1]
+        if extension == '.vtr':
+            reader = vtkXMLRectilinearGridReader()
+            reader.SetFileName(file_path)
+            reader.Update()
+            return reader.GetOutput()    
+        elif extension == '.vts':
+            reader = vtkXMLStructuredGridReader()
+            reader.SetFileName(file_path)
+            reader.Update()
+            return reader.GetOutput()
+        elif extension == '.vtu':
+            reader = vtkXMLUnstructuredGridReader()
+            reader.SetFileName(file_path)
+            reader.Update()
+            return reader.GetOutput()
+    
+    def __parse_float(self, s):
+        try:
+            value = float(s)
+            if np.isnan(value):
+                return 0
+            return value
+
+        except ValueError:
+            if '-' in s:
+                segments = s.split('-')
+                if len(segments) == 2:
+                    return float(segments[0] + 'E-' + segments[1])
+                if len(segments) == 3:
+                    return float('-0' + segments[1] + 'E-' + segments[2])
+            if '+' in s:
+                segments = s.split('+')
+                if len(segments) == 2:
+                    return float(segments[0] + 'E+' + segments[1])
+                if len(segments) == 3:
+                    return float('0' + segments[1] + 'E+' + segments[2])
+            else:
+                print(f'{s} can\'t parse to float.')
+                return 0
+            
+    def __isInt(self, s):
+        try:
+            value = int(s)
+            if np.isnan(value):
+                return False
+            return True
+
+        except ValueError:
+            return False
+        
+    def __check_TOUGH_version(self):
+        out_file_path = self.current_out_file
+        extension = os.path.splitext(out_file_path)[1].lower()
+        if extension == '.tec':
+            self.setting.out_format_type = OutType.TEC
+            self.setting.tough_version = ToughVersion.TOUGHReact
+            return
+            #return OutType.TEC
+        elif extension == '.csv':
+            self.setting.out_format_type = OutType.CSV
+            line_number = 0
+            with open(out_file_path) as f:
+                for line in f:
+                    if line_number == 0:
+                        first_col = line.split(',')[0].strip().lower()
+                        if 'time' in first_col:
+                            self.setting.tough_version = ToughVersion.TOUGH2                            
+                            return
+                    if line_number == 2:
+                        values = line.strip().split(',')
+                        if len(values) == 1 and 'time' in values[0].strip().lower():
+                            self.setting.tough_version = ToughVersion.TOUGH3
+                            return
+                        print(f'The format of your output file, {out_file_path}, is not correct. Please double-check your file.')
+                        sys.exit(1)
+                    line_number = line_number + 1
+        
+        else:
+            print(f'The format of your output file, {out_file_path}, is not supported.\nPlease use either .csv or .tec file format instead.')
+            sys.exit(1)
+
+    def __check_if_block_end(self, line, line_number):
+
+        if 'ENDCY' in line:
+            return True
+        
+        if len(line) < 10 and line_number == 1:
+            return False
+        
+        if len(line) < 10:
+            return True        
+        if line.startswith('\n') or line.startswith(' \n'):
+            return True
+        if line.startswith('\r') or line.startswith(' \r'):
+            return True
+
+        trimmed = line.lstrip()
+        if trimmed[5] == "-" and trimmed[6] == "-":
+            return True
+        return False
+
+    def __write_json(self):
+        # Convert each object to a dict
+        # Assume variable_list is a list of visVariable objects
+        variable_list_dicts = []
+        for key in self.variable_list:
+            for variable in self.variable_list[key]:
+                 variable_list_dicts.append(variable.to_dict())
+
+
+        # Write to JSON file
+        path = os.path.join(self.setting.vis_dir, "variable_list.json")
+        with open(path, "w") as f:
+            json.dump(variable_list_dicts, f, indent=2)
+
+        timestep_list_dicts = [timestep.__dict__ for timestep in self.time_steps_list]
+        
+
+        # Write to JSON file
+        path = os.path.join(self.setting.vis_dir, "timestep_list.json")
+        with open(path, "w") as f:
+            json.dump(timestep_list_dicts, f, indent=2)
+
+    def __fix_negative_zero(self, x):
+        return 0.0 if x == 0 else x
+    
+class vis_charting:
+    def __init__(self, case_dir):
+        self.vis_dir = None
+        self.variable_list = None
+        vis_dir = os.path.join(case_dir, "tough_vis", "paraview")
+        
+
+        if os.path.isdir(vis_dir):
+            print("vis_dir:", vis_dir)
+        else:
+            print(f'Case vis_dir({vis_dir}) not found.')
+            sys.exit(0)
+
+        variable_list_path = os.path.join(case_dir, "tough_vis", "variable_list.json")
+        if os.path.isfile(variable_list_path):
+            with open(variable_list_path, "r") as f:
+                self.variable_list = json.load(f)
+        else:
+            print(f'Case variable_list.json({variable_list_path}) not found.')
+            sys.exit(0)
+
+        timestep_list_path = os.path.join(case_dir, "tough_vis", "timestep_list.json")
+        if os.path.isfile(timestep_list_path):
+            with open(timestep_list_path, "r") as f:
+                self.time_steps_list = json.load(f)
+        else:
+            print(f'Case timestep_list.json({timestep_list_path}) not found.')
+            sys.exit(0)
+        
+        self.vis_dir = vis_dir
+        
+
+
+    def return_dataframe(self, element_id_list = None, scalar_variable_list = None, time_step_id_list = None, vector_variable_list = []):
+        if self.vis_dir is None:
+            print("vis_dir not set.")
+            sys.exit(0)
+        if self.variable_list is None:
+            print("variable_list not set.")
+            sys.exit(0)
+        if self.time_steps_list is None:
+            print("time_steps_list not set.")
+            sys.exit(0)
+        
+        # 1. find timesteps
+        query_time_step_list = []
+        if time_step_id_list == None:
+            query_time_step_list = self.time_steps_list
+        else:
+            for time_step in self.time_steps_list:
+                if time_step["time_step"] in time_step_id_list:
+                    query_time_step_list.append(time_step)
+        
+        # 2. find scalar variables
+        query_variables = []
+        if scalar_variable_list == None:
+            query_variables = self.variable_list
+        else:
+            for variable in self.variable_list:
+                if variable["variable_name"] in scalar_variable_list:
+                    if variable["value_type"] == "Scalar":
+                        query_variables.append(variable)
+
+        # 3. find vector variables
+
+        for variable in self.variable_list:
+            if variable["variable_name"] in vector_variable_list:
+                if variable["value_type"] == "Vector":
+                    query_variables.append(variable)
+        
+        
+        # create dataframe that contains all variables and timesteps
+        df = pd.DataFrame()
+        rows = []
+        for time_step in query_time_step_list:
+            time_step_id = time_step["time_step"]
+            time = time_step["time"]
+            vtk = self.__read_vtk_file(time_step["vtu_file_name"])
+            #print(f"Reading  time: {time_step['time']}")
+
+            for i in (range(vtk.GetNumberOfCells()) if element_id_list is None else element_id_list):
+                if i >= vtk.GetNumberOfCells():
+                    print(f"Element ID {i} is out of range for the current VTK file.")
+                    sys.exit(1)
+
+                new_row = {"element_id": i, "time_step_id": time_step_id, "time": time}
+                for variable in query_variables:
+                    variable_name = variable["variable_name"]
+                    vtk_array = vtk.GetCellData().GetArray(variable_name)
+                    if vtk_array is None:
+                        print(f"Variable '{variable_name}' not found in the VTK file.")
+                        continue
+                    if variable["value_type"] == "Scalar":
+                        new_row[variable_name] = vtk_array.GetValue(i)
+                    elif variable["value_type"] == "Vector":
+                        new_row[variable_name + "_x"] = vtk_array.GetComponent(i, 0)
+                        new_row[variable_name + "_y"] = vtk_array.GetComponent(i, 1)
+                        new_row[variable_name + "_z"] = vtk_array.GetComponent(i, 2)
+
+                #df = pd.concat([df, pd.DataFrame([new_row])], ignore_index=True)
+                rows.append(new_row)
+        
+        df = pd.DataFrame(rows)
+        return df
+            
+            
+
+
+            
+    def __read_vtk_file(self, file_path):
+        
+        extension = os.path.splitext(file_path)[1]
+        if extension == '.vtr':
+            reader = vtkXMLRectilinearGridReader()
+            reader.SetFileName(file_path)
+            reader.Update()
+            return reader.GetOutput()    
+        elif extension == '.vts':
+            reader = vtkXMLStructuredGridReader()
+            reader.SetFileName(file_path)
+            reader.Update()
+            return reader.GetOutput()
+        elif extension == '.vtu':
+            reader = vtkXMLUnstructuredGridReader()
+            reader.SetFileName(file_path)
+            reader.Update()
+            return reader.GetOutput()
+        
+
+