toughanimator 0.1.5__py3-none-any.whl → 0.1.6__py3-none-any.whl

toughanimator/run.py

@@ -3,21 +3,23 @@ import tough_classes as ta
 import pandas as pd
 import matplotlib.pyplot as plt
 
-dir_name = "unresolved" #"test_cases
-case_name = "3D five spot MINC"
+#dir_name = "unresolved" 
+dir_name = "test_cases"
+case_name = "PetraSim_2D_Conceptual"
 test_case_dir = os.path.join(os.path.dirname(os.path.dirname(__file__)), dir_name) 
 
-#case_dir = os.path.join(test_case_dir, case_name)
-case_dir = r"D:\Projects\202507\intern\P5_eco2n_1D-radial"
+case_dir = os.path.join(test_case_dir, case_name)
+
 
 #case_dir = r"D:\Projects\202504\polygonal\poly_test"
-#case_dir = r"D:\Projects\202501\toughanimator\test_cases\P5_eco2n_1D-radial"
+#case_dir = r"D:\Projects\202507\tough系列output\tough output format\TR_MINC_exe"
+#case_dir = r"D:\Projects\202508\tough_cases\WW\7_TR_MINC_petrasim2025__5spot"
+#case_dir = r"D:\Projects\202508\tough_cases\WW\6_TR_MINC_exe"
 reader = ta.vis_reader(case_dir)
 #reader.write_eleme_conne()
 #reader.write_geometry()
 #reader.write_incon()
 #reader.write_result()
-#reader.
 reader.write_all()
 
 

toughanimator/tough_classes.py

@@ -69,7 +69,7 @@ class VisVariable:
         }
 
 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", minc=False):
+    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", minc=False, selected_variables_scalar = [], selected_variables_vector = [] ):
         self.mesh_type = mesh_type
         self.out_format_type = out_format_type
         self.vis_types = vis_types
@@ -85,6 +85,8 @@ class VisSetting:
         self.debug = debug
         self.eos = eos
         self.minc = minc
+        self.selected_variables_scalar = selected_variables_scalar
+        self.selected_variables_vector = selected_variables_vector
 
 
     def setBounds(self, x_bounds, y_bounds, z_bounds):
@@ -130,6 +132,8 @@ class vis_reader:
             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,
+            selected_variables_scalar = config['selected_variables_scalar'] if 'selected_variables_scalar' in config else [],
+            selected_variables_vector = config['selected_variables_vector'] if 'selected_variables_vector' in config else []
         )
 
         # check if the project is using MINC
@@ -215,6 +219,7 @@ class vis_reader:
             self.current_out_file = output_file_path
             self.__check_TOUGH_version()
             print(f'    Version: {self.setting.tough_version.name}')
+            print(f'    EOS: {self.setting.eos}')
             if self.setting.tough_version == ToughVersion.TOUGH2:
                 self.__read_TOUGH2_CSV_outfile()
             elif self.setting.tough_version == ToughVersion.TOUGH3:
@@ -357,6 +362,7 @@ class vis_reader:
     def __write_incon_buffer(self):
         self.incon_buffer = io.StringIO()
         has_incon = False
+        self.global_incon = False
         # write temp element txt
         
         for input_file_path in self.setting.input_file_paths:
@@ -368,7 +374,7 @@ class vis_reader:
                     if line.startswith('INCON-'):
                         reading_incon = True
                         has_incon = True
-                        find_incon = True
+                        #find_incon = True
                         continue
 
                     if reading_incon:
@@ -386,9 +392,33 @@ class vis_reader:
                             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)
+
+        if has_incon == False or self.incon_buffer.tell() == 0:
+            print(f'Can\'t find INCON block in input_file_paths (or length of INCON is zero).')
+            
+            # find the fifth line of the "PARAM" block
+            reading_pram = False
+            for input_file_path in self.setting.input_file_paths:
+                line_counter = 0
+                with open(input_file_path) as f:
+                    reading_pram = False
+                    for line in f:
+                        if line.startswith('PARAM-'):
+                            reading_pram = True
+                            continue
+                        if reading_pram:
+                            line_counter += 1
+                            if self.__check_if_block_end(line, line_counter):
+                                if line_counter <5:
+                                    print(f'    Can\'t find Global INCON line in PARAM block of {input_file_path}. Please check the PARAM block.')
+                                    break
+                                
+                            if line_counter == 5:
+                                self.global_incon = True
+                                print(f'    Found Global INCON line in PARAM block of {input_file_path}')
+                                self.incon_buffer.write(line)
+                                break
+
         else:
             print(f'    Found INCON block in {found_path}')
 
@@ -418,16 +448,21 @@ class vis_reader:
             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()):
+        else:
             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)
+                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:
+                    if self.global_incon:
+                        # if global incon, use the first row
+                        value = self.__parse_float(incon_df[header][0])
+                    else:
+                        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}')
@@ -459,6 +494,9 @@ class vis_reader:
                 self.__write_scalar_result(time_step, df, csv_headers)
             elif value_type == ValueType.Vector:
                 self.__write_vector_result(time_step, df, csv_headers)
+            else:
+                print('Error: Your value type is not supported')
+                sys.exit(1)
             
             buffer.flush()
             buffer.close()
@@ -470,14 +508,17 @@ class vis_reader:
 
                 if line_number == 0:
                     csv_headers = [x.strip() for x in values]
+                    #replace all " with ''"
+                    csv_headers = [x.replace('"', '') for x in csv_headers]
                     if 'ELEM' in csv_headers and 'INDEX' in csv_headers:
                         value_type = ValueType.Scalar
-                        start_index = 1 # remove the first item
+                        #start_index = 1 # remove the first item
 
                     elif 'ELEM1' in csv_headers and 'ELEM2' in csv_headers:
                         value_type = ValueType.Vector
-                        start_index = 4
+                        #start_index = 1
 
+                    start_index = 1
                     # remove the first "TIME" header (to reduce the number of columns)    
                     csv_headers = csv_headers[start_index:]
 
@@ -505,7 +546,6 @@ class vis_reader:
                 process_chunk()
     
 
-
     def __read_TOUGH3_CSV_outfile(self):
         scalar_buffer = io.StringIO()
         current_time_step = None
@@ -517,6 +557,93 @@ class vis_reader:
         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 __old_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
@@ -826,6 +953,8 @@ class vis_reader:
             dataframe = dataframe.drop(columns=['INDEX'])
             headers.remove('INDEX')
         if 'ELEM' in dataframe.columns:
+            # change the data type of ELEM to string
+            dataframe['ELEM'] = dataframe['ELEM'].astype(str)
             # remove leading spaces from ELEM column
             dataframe['ELEM'] = dataframe['ELEM'].str.lstrip()
             headers.remove('ELEM')
@@ -875,6 +1004,11 @@ class vis_reader:
         if VisType.Tecplot not in self.setting.vis_types:
             return
         
+
+        if self.setting.mesh_type == MeshType.PolygonalMesh:
+            print(f'    Tecplot output for polygonal mesh is not supported yet.')
+            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')
@@ -884,10 +1018,11 @@ class vis_reader:
         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')
+            selected_header_string = '"'+'", "'.join(self.setting.selected_variables_scalar) + '"'
+            #header_string = '"'+'", "'.join(headers) + '"'
+            file.write(f'VARIABLES = "X", "Y", "Z", {selected_header_string}\n')
         
-        tecplot_cell_type = 'BRICK'
+        #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' 
         
@@ -916,7 +1051,7 @@ class vis_reader:
             file.write(" \n")
 
         # Other data
-        for header in headers:
+        for header in self.setting.selected_variables_scalar:
             array = vtr.GetCellData().GetArray(header)
 
             for e in range(0, vtr.GetNumberOfCells()):
@@ -943,8 +1078,9 @@ class vis_reader:
         return var_string
     
     # write the vector result for one timestep
-    def __write_vector_result(self, vis_time_step, dataframe, headers):
+    def __write_vector_result(self, vis_time_step, dataframe, csv_headers):
         
+        headers = csv_headers.copy()
         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}')
@@ -958,74 +1094,96 @@ class vis_reader:
             timesteps.SetNumberOfTuples(1)
             timesteps.SetNumberOfComponents(1)
             timesteps.SetTuple1(0, vis_time_step.time)
+            #timesteps.SetTuple2(1, 100000)
             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()
+            vector_vtr = self.__read_vtk_file(vtr_path) 
 
         vtu_reader = vtkXMLUnstructuredGridReader()
         vtu_reader.SetFileName(self.elem_conne_path)
         vtu_reader.Update()
         conne_vtu = vtu_reader.GetOutput()
 
+        # make sure to drop TIME and INDEX columns if they exist
+        if 'INDEX' in dataframe.columns:
+            dataframe = dataframe.drop(columns=['INDEX'])
+            headers.remove('INDEX')
+        if 'ELEM1' in dataframe.columns:
+            # remove leading spaces from ELEM column
+            dataframe['ELEM1'] = dataframe['ELEM1'].astype(str)
+            dataframe['ELEM1'] = dataframe['ELEM1'].str.lstrip()
+            headers.remove('ELEM1')
+        if 'ELEM2' in dataframe.columns:
+            # remove leading spaces from ELEM column
+            dataframe['ELEM2'] = dataframe['ELEM2'].astype(str)
+            dataframe['ELEM2'] = dataframe['ELEM2'].str.lstrip()
+            headers.remove('ELEM2')
 
         variable_list = []
+    
+        # find max number of cell connections of a element
+        num_of_components = 3
+        for elem_id in range(0, conne_vtu.GetNumberOfPoints()):
+            cellIDs = vtkIdList()
+            conne_vtu.GetPointCells(elem_id, cellIDs)
+            if cellIDs.GetNumberOfIds() > num_of_components:
+                num_of_components = cellIDs.GetNumberOfIds() 
+
+
+        # create double array for each header
         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.SetNumberOfComponents(num_of_components)
             array.SetNumberOfTuples(vector_vtr.GetNumberOfCells())
-            array.FillComponent(0, 0)
-            array.FillComponent(1, 0)
-            array.FillComponent(2, 0)
+            for i in range(0, num_of_components):
+                # set the default value to 0
+                array.FillComponent(i, 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
-            
+                
+
+        # prepare cell data array for cells in conne_vtu
+        for header in headers:
+            array = vtkDoubleArray()
+            array.SetName(header)
+            conne_vtu.GetCellData().AddArray(array)
 
+        # add celldata to cells in elem_conn
+        for cell_id in range(0, conne_vtu.GetNumberOfCells()):
+            for header in headers:
+                    value = dataframe.loc[cell_id, header]
+                    conne_vtu.GetCellData().GetArray(header).InsertNextValue(value)
+        #self.__write_vtk_file(
+            #conne_vtu, self.elem_conne_path)
+
+        # create the vector data
         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
+                for header in headers:
+                    #value = dataframe.loc[next_id, header]
+                    value = conne_vtu.GetCellData().GetArray(header).GetValue(cellID)
+                    vector_vtr.GetCellData().GetArray(header).SetComponent(elem_id, i, value)
 
+        # Put cell-centered data into points
+        filter = vtkCellDataToPointData()
+        filter.SetInputData(vector_vtr)
+        filter.Update()
+        vtr_cell_to_points = filter.GetOutput()
 
-                    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)
+        for i in range(0, vtr_cell_to_points.GetPointData().GetNumberOfArrays()):
+            vector_vtr.GetPointData().AddArray(vtr_cell_to_points.GetPointData().GetArray(i))
 
         self.__write_vtk_file(
             vector_vtr, self.time_steps_list[index].vtu_file_name)
@@ -1343,8 +1501,8 @@ class vis_reader:
         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:
@@ -1824,6 +1982,7 @@ class vis_reader:
                 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)
@@ -2186,7 +2345,7 @@ class vis_reader:
             return True
 
         trimmed = line.lstrip()
-        if trimmed[5] == "-" and trimmed[6] == "-":
+        if len(trimmed)>6 and trimmed[5] == "-" and trimmed[6] == "-":
             return True
         return False
 

{toughanimator-0.1.5.dist-info → toughanimator-0.1.6.dist-info}/METADATA

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: toughanimator
-Version: 0.1.5
+Version: 0.1.6
 Summary: A tool for visualizing TOUGH simulation outputs.
 Home-page: https://github.com/scarletref/toughanimator
-Author: Your Name
-Author-email: your.email@example.com
+Author: scarletref
+Author-email: scarletreflection@gmail.com
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent

toughanimator-0.1.6.dist-info/RECORD

@@ -0,0 +1,7 @@
+toughanimator/__init__.py,sha256=m1f3fJ1SNGLNKxHlS0pLNHwaHlN6UUTh5GpS_8hC8kw,30
+toughanimator/run.py,sha256=YmoiVElHRCo9BzMmBuB53zGy_h8AEQddllQJsqN3tV4,771
+toughanimator/tough_classes.py,sha256=qD67posVPMDRaHjM5lGjYkQNPEHxirU9qZVNAp3PPE0,111115
+toughanimator-0.1.6.dist-info/METADATA,sha256=-SOWX53-MaW8Vz4KtAlJ6NTa62jzYWuzt72vVChjTng,4563
+toughanimator-0.1.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+toughanimator-0.1.6.dist-info/top_level.txt,sha256=pAT-UflvbjT4lTmBdzHqApZGWbywkSM3Y_qsHyLi4pU,14
+toughanimator-0.1.6.dist-info/RECORD,,

toughanimator-0.1.5.dist-info/RECORD

@@ -1,7 +0,0 @@
-toughanimator/__init__.py,sha256=m1f3fJ1SNGLNKxHlS0pLNHwaHlN6UUTh5GpS_8hC8kw,30
-toughanimator/run.py,sha256=EayWtDf_PrpYg8vfsyEm38XLb2-E4nF_y57TT_cdGzQ,671
-toughanimator/tough_classes.py,sha256=1SX1CttjeBkAlk6Ynw4EyIWfOKd15uWCpFvqUQo_wp8,103275
-toughanimator-0.1.5.dist-info/METADATA,sha256=EvR_7WeGK7hE8oD8h6QlFjcyBRfQ7svAS-G5AnbEcD4,4557
-toughanimator-0.1.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-toughanimator-0.1.5.dist-info/top_level.txt,sha256=pAT-UflvbjT4lTmBdzHqApZGWbywkSM3Y_qsHyLi4pU,14
-toughanimator-0.1.5.dist-info/RECORD,,