def write_pvd_file(unstructured_grid, program_data): if is_rank_zero(): print("Writing pvd file") time_steps = program_data["time_steps"] output_prefix = program_data["paraview_output_file"] fh = open(output_prefix + ".pvd", "w") fh.write('<?xml version="1.0"?>\n') fh.write('<VTKFile type="Collection" version="0.1"\n') fh.write(' byte_order="LittleEndian"\n') fh.write(' compressor="vtkZLibDataCompressor">\n') fh.write(' <Collection> \n') array_names = get_array_names_on_unstructured_grid(unstructured_grid) if time_steps: for time in sorted(time_steps.keys()): write_pvd_time_step(fh, time, array_names, program_data) else: time = 0 write_pvd_time_step(fh, time, array_names, program_data) fh.write(' </Collection> \n') fh.write('</VTKFile> \n') fh.close() if is_rank_zero(): print("Finished writing pvd file")
def create_grid_from_grid_files(program_data): grid_file = program_data["grid_desc"]["read_grid"] time_steps = program_data["time_steps"] sgf = SpartaGridFile(grid_file) merge_points = create_merge_points(program_data) unstructured_grid = vtk.vtkUnstructuredGrid() unstructured_grid.SetPoints(merge_points.GetPoints()) init_flow_file_arrays(unstructured_grid, program_data) global_ids = {} count = 1 if is_rank_zero(): print("Started sorted grid file read") print("Creating grid") with open(get_bucket_file_name(get_rank(), program_data), 'r') as f: for cell_id in f: cell_id = cell_id.strip() cell = create_grid_cell(cell_id, sgf, program_data, merge_points) unstructured_grid.InsertNextCell(cell.GetCellType(), cell.GetPointIds()) if time_steps: lcid = sgf.get_local_cell_id_from_dashed_cell_id(cell_id) global_ids[lcid] = count - 1 insert_value_in_flow_file_arrays(0.0, unstructured_grid) if is_rank_zero() and count % 10000 == 0: print("Read " + str(count) + " cells") count += 1 if is_rank_zero(): print("Finished sorted grid file read") print("Finished creating grid") return (unstructured_grid, global_ids)
def sort_grid_file_to_files(grid_file_path): cells = get_grid_file_cells(grid_file_path) prefix = get_grid_file_prefix(grid_file_path) if is_rank_zero(): print("Started parallel sort") parallel_sort_to_file_buckets(cells, SpartaGridFile.compare_dashed_ids, prefix) if is_rank_zero(): print("Finished parallel sort")
def main(): args = parse_command_line() check_command_line(args) time_steps = get_time_steps(args) check_time_step_files(args, time_steps) grid_desc = create_grid_description(args) program_data = distribute_program_data(args, grid_desc, time_steps) (unstructured_grid, global_ids) = create_grid(program_data) write_grid(unstructured_grid, global_ids, program_data) if is_rank_zero(): write_pvd_file(unstructured_grid, program_data) barrier() if is_rank_zero(): print("grid2paraview_cells finished")
def get_time_steps(args): error_flag = False time_steps_dict = None if is_rank_zero(): result_file_list = get_time_steps_file_list(args) if result_file_list is not None: time_steps_dict = {} for f in result_file_list: try: fh = open(f, "r") except IOError: print("Unable to open SPARTA result file: ", f) error_flag = True break for line in fh: s = clean_line(line) if s.lower().replace(" ", "") == "item:timestep": for line in fh: time = int(line) if time in time_steps_dict.keys(): time_steps_dict[time].append(f) else: time_steps_dict[time] = [f] break break fh.close() else: error_flag = True if error_found_on_rank_zero(error_flag): sys.exit(1) return time_steps_dict
def parse_command_line(): args = None if is_rank_zero(): parser = argparse.ArgumentParser() parser.add_argument("sparta_grid_description_file", help="SPARTA grid description input file name") parser.add_argument("paraview_output_file", help="ParaView output file name") parser.add_argument( '-f', '--float', action='store_true', help="Use float precision for flow file data (default is double)") parser.add_argument('-v', '--variables', nargs='+', type=str, help="Flow file variable names (f_1[2] f_1[3] f_1[4] etc.) to " +\ "create (default creates all variables found in flow files)") group = parser.add_mutually_exclusive_group() group.add_argument('-r', '--result', help="Optional list of SPARTA dump result files", nargs='+') group.add_argument( '-rf', '--resultfile', help= "Optional filename containing path names of SPARTA dump result files" ) args = parser.parse_args() return args
def get_grid_file_cells(grid_file_path): sgf = SpartaGridFile(grid_file_path) sgf.set_iteration_start(get_rank()) sgf.set_iteration_skip(get_size()) if is_rank_zero(): print("Reading Sparta grid file " + grid_file_path) cells = [] count = 0 for cell in sgf: cells.append(cell) count += 1 if is_rank_zero() and count % 10000 == 0: print("Read " + str(count) + " cell(s) from grid file") if is_rank_zero(): print("Finished grid file read") return cells
def exist_grid_file_files(program_data): files_exist = True if is_rank_zero(): for rank in range(get_size()): files_exist = files_exist and \ os.path.isfile(get_bucket_file_name(rank, program_data)) return get_comm_world().bcast(files_exist, root=0)
def create_grid_description(args): error_flag = False grid_desc = None if is_rank_zero(): grid_desc = {} gdf = open(args.sparta_grid_description_file, "r") read_grid_description_file(gdf, grid_desc) gdf.close() if "dimension" not in grid_desc: print( "Error: grid description file does not have a dimension statement: ", args.sparta_grid_description_file) error_flag = True if "create_box" not in grid_desc: print( "Error: grid description file does not have a create_box statement: ", args.sparta_grid_description_file) error_flag = True if "read_grid" not in grid_desc: print( "Error: grid description file does not have a read_grid statement: ", args.sparta_grid_description_file) error_flag = True if os.path.isfile(args.paraview_output_file + '.pvd'): print("ParaView output file exists: ", args.paraview_output_file + '.pvd') error_flag = True try: sgf = SpartaGridFile(grid_desc["read_grid"]) except: error_flag = True if error_found_on_rank_zero(error_flag): sys.exit(1) if is_rank_zero(): print("Processing " + str(sgf.number_of_cells) +\ " cell(s) on " + str(get_size()) + " MPI rank(s)") os.mkdir(args.paraview_output_file) return grid_desc
def parse_command_line(): if is_rank_zero(): parser = argparse.ArgumentParser() parser.add_argument("sparta_grid_file_path", help="Sparta grid file path") args = parser.parse_args() return args else: return None
def get_grid_file_path(args): path = None if is_rank_zero(): path = args.sparta_grid_file_path path = get_comm_world().bcast(path, root = 0) else: path = get_comm_world().bcast(path, root = 0) return path
def check_grid_file(args): error_flag = False if is_rank_zero(): try: sgf = SpartaGridFile(args.sparta_grid_file_path) except: error_flag = True if error_found_on_rank_zero(error_flag): sys.exit(1)
def write_grid(unstructured_grid, global_ids, program_data): writer = vtk.vtkXMLUnstructuredGridWriter() writer.SetInputData(unstructured_grid) time_steps = program_data["time_steps"] output_prefix = program_data["paraview_output_file"] if is_rank_zero(): print("Writing grid over " + str(len(time_steps.keys())) + " time step(s)") if time_steps: for time in sorted(time_steps.keys()): read_time_step_data(time_steps[time][0], unstructured_grid, global_ids, program_data) write_grid_to_file(writer, output_prefix, time) else: write_grid_to_file(writer, output_prefix, 0) if is_rank_zero(): print("Finished writing grid")
def checkResult(self, data, sorted_data, compare=None): barrier() all_data = get_comm_world().gather(data, root=0) all_sorted_data = get_comm_world().gather(sorted_data, root=0) if is_rank_zero(): all_data = flatten_list(all_data) sort_list(all_data, compare) all_sorted_data = flatten_list(all_sorted_data) areEqual = all_data == all_sorted_data else: areEqual = None areEqual = get_comm_world().bcast(areEqual, 0) self.assertTrue(areEqual)
def read_time_step_data(file_name, unstructured_grid, global_ids, program_data): if is_rank_zero(): print("Reading Sparta flow file " + file_name) variables = program_data["variables"] fh = open(file_name, "r") array_names = get_array_names(fh) if variables is None: variables = array_names id_index = array_names.index('id') count = 1 for line in fh: s = clean_line(line) sl = s.split() if len(sl) == len(array_names): cell_id = int(sl[id_index]) if cell_id not in global_ids: continue for v in variables: array = unstructured_grid.GetCellData().GetArray(v) array.SetValue(global_ids[cell_id], float(sl[array_names.index(v)])) else: print("Error reading SPARTA result file: ", f) print("Flow data line cannot be processed: ", line) return if is_rank_zero() and count % 100000 == 0: print("Read " + str(count) + " lines from flow file") count += 1 fh.close() if is_rank_zero(): print("Finished reading Sparta flow file " + file_name)
def check_command_line(args): error_flag = False if is_rank_zero(): if not os.path.isfile(args.sparta_grid_description_file): print("Unable to open SPARTA grid description file: ", args.sparta_grid_description_file) error_flag = True if os.path.isdir(args.paraview_output_file): print("ParaView output directory exists: ", args.paraview_output_file) error_flag = True if error_found_on_rank_zero(error_flag): sys.exit(1)
def check_time_step_files(args, time_steps): error_flag = False if is_rank_zero(): if time_steps and args.variables: for time in sorted(time_steps.keys()): fh = open(time_steps[time][0], "r") array_names = get_array_names(fh) for v in args.variables: if not v in array_names: print("Error: requested flow variable " +\ v + " not in flow file " + time_steps[time][0]) error_flag = True if 'id' not in array_names: print("Error: id column not in flow file " +\ time_steps[time][0]) error_flag = True fh.close() if error_found_on_rank_zero(error_flag): sys.exit(1)
def distribute_program_data(args, grid_desc, time_steps): pd = {} if is_rank_zero(): pd["paraview_output_file"] = args.paraview_output_file pd["float"] = args.float pd["variables"] = args.variables pd["grid_desc"] = grid_desc pd["time_steps"] = time_steps else: pd["paraview_output_file"] = None pd["float"] = None pd["variables"] = None pd["grid_desc"] = None pd["time_steps"] = None pd["paraview_output_file"] = get_comm_world().bcast( pd["paraview_output_file"], root=0) pd["float"] = get_comm_world().bcast(pd["float"], root=0) pd["variables"] = get_comm_world().bcast(pd["variables"], root=0) pd["grid_desc"] = get_comm_world().bcast(pd["grid_desc"], root=0) pd["time_steps"] = get_comm_world().bcast(pd["time_steps"], root=0) return pd