def pass_array(self):
     print('passing arrays')
     passer = vtk.vtkPassArrays()
     passer.SetInputConnection(self.mesh.GetOutputPort())
     passer.AddCellDataArray('elemTag')
     passer.Update()
     self.mesh = passer
示例#2
0
    def vtk_ascii_write(self, unstructuredgrid_object, fname):
        '''
		class method that writes a vtk unstructured grid object to a file (save the mesh)
		unstructuredgrid_object=vtk unstructured grid object
		fname=text string with path/filename target for writing mesh
		'''
        pa = vtk.vtkPassArrays()
        pa.SetInputConnection(unstructuredgrid_object.GetOutputPort())
        writer = vtk.vtkUnstructuredGridWriter()
        writer.SetFileName(fname)
        writer.SetInputConnection(pa.GetOutputPort())
        writer.Update()
        writer.Write()
示例#3
0
import vtk
import h5py

file_path1 = "/home/ksansom/caseFiles/mri/VWI_proj/case1/vmtk/dsa2mra_trans.vtp"
file_path2 = "/home/ksansom/caseFiles/mri/VWI_proj/case1/vmtk/smooth_case1_vmtk_decimate.vtp"

out_path = "/home/ksansom/caseFiles/mri/VWI_proj/case1/vmtk/dsa2mra_icp.vtp"

reader1 = vtk.vtkXMLPolyDataReader()
reader1.SetFileName(file_path1)

reader2 = vtk.vtkXMLPolyDataReader()
reader2.SetFileName(file_path2)

pass_filt = vtk.vtkPassArrays()
pass_filt.SetInputConnection(reader1.GetOutputPort())
pass_filt.Update()

# don't need this now
trans_target = vtk.vtkTransform()
trans_target.Scale(0.001, 0.001, 0.001)

trans_target_filt = vtk.vtkTransformPolyDataFilter()
trans_target_filt.SetInputConnection(reader2.GetOutputPort())
trans_target_filt.SetTransform(trans_target)
trans_target_filt.Update()

source = vtk.vtkPolyData()
target = vtk.vtkPolyData()
source.ShallowCopy(pass_filt.GetOutput())
target.ShallowCopy(trans_target_filt.GetOutput())
示例#4
0
def Execute(args):
    print("clip centerlines")

    reader_ctr = vmtkscripts.vmtkSurfaceReader()
    reader_ctr.InputFileName = args.centerlines
    reader_ctr.Execute()

    print(args.clean_ctr)
    if (args.clean_ctr):
        cleaner = vtk.vtkCleanPolyData()
        cleaner.PointMergingOn()
        cleaner.ConvertPolysToLinesOff()
        cleaner.SetInputData(reader_ctr.Surface)
        cleaner.Update()
        centerlines = cleaner.GetOutput()
    else:
        centerlines = reader_ctr.Surface

    centerlines.BuildLinks()
    centerlines.BuildCells()

    reader_br = vmtkscripts.vmtkSurfaceReader()
    reader_br.InputFileName = args.boundary_file
    reader_br.Execute()
    boundary_reference = reader_br.Surface

    #print(pt1, pt2)
    #v =  pt2 - pt1 #pt1 - pt2
    #v_mag = np.linalg.norm(v)
    #n = v / v_mag
    #print("should be 1.0", np.linalg.norm(n), n)

    #https://en.wikipedia.org/wiki/Vector_projection
    # get starting point from centroid by projecting centroid onto normal direction
    #neck_projection = np.dot(neck_centroid-pt1, n)*n
    #neck_start_pt = pt1 + neck_projection
    new_ctr = vtk.vtkPolyData()
    new_ctr.DeepCopy(centerlines)

    locator = vtk.vtkPointLocator()
    locator.SetDataSet(new_ctr)
    locator.BuildLocator()

    cell_loc = vtk.vtkCellLocator()
    cell_loc.SetDataSet(new_ctr)
    cell_loc.BuildLocator()

    clip_ids = []
    new_points = vtk.vtkPoints()
    new_cell_array = vtk.vtkCellArray()
    scalar = vtk.vtkIntArray()
    scalar.SetNumberOfComponents(1)
    scalar.SetNumberOfTuples(new_ctr.GetNumberOfPoints())
    scalar.SetName("clipper")
    scalar.Fill(0)
    for i in range(boundary_reference.GetNumberOfPoints()):
        pt = boundary_reference.GetPoint(i)  #B
        pt_b = np.array(pt)
        #print(pt)
        #ctr_ptId = locator.FindClosestPoint(pt)
        id_list = vtk.vtkIdList()
        locator.FindClosestNPoints(2, pt, id_list)

        ctr1 = np.array(new_ctr.GetPoint(id_list.GetId(0)))  # A
        ctr2 = np.array(new_ctr.GetPoint(id_list.GetId(1)))
        #ctr3 = np.array(new_ctr.GetPoint(ctr_ptId + 1))

        n_br = np.array(boundary_reference.GetPointData().GetArray(
            "BoundaryNormals").GetTuple(i))

        n_s_2 = np.dot(pt_b - ctr2, n_br)
        n_s_1 = np.dot(pt_b - ctr1, n_br)
        if (n_s_1 < 0.0):
            proj_start = ctr2
            start_id = id_list.GetId(0)
        elif (n_s_2 < 0.0):
            proj_start = ctr1
            start_id = id_list.GetId(1)
        else:
            print("two closest points are on same side")
        #Get each vector normal to outlet
        n_ctr = np.array(new_ctr.GetPointData().GetArray(
            "FrenetTangent").GetTuple(start_id))

        if (np.dot(n_br, n_ctr) < 0.0):
            n_ctr = -1.0 * n_ctr

        #outlet centroid projected onto centerline based on FrenetTangent
        proj_vec = np.dot(n_br, pt_b - proj_start) * n_ctr
        proj_end = proj_vec + proj_start

        two_closest = vtk.vtkIdList()
        locator.FindClosestNPoints(2, proj_end, two_closest)

        vec_closest = np.array(new_ctr.GetPoints().GetPoint(
            two_closest.GetId(0))) - proj_end
        point_furthest = proj_end - vec_closest

        new_ctr.GetPoints().SetPoint(two_closest.GetId(1),
                                     tuple(point_furthest))
        #new_ctr.GetPoints().SetPoint(two_closest.GetId(0), proj_end_other)
        #new_ctr.GetPointData().GetArray("FrenetTangent").SetTuple(closest_to, tuple(n_br))

        cell_id_list = vtk.vtkIdList()
        new_ctr.GetPointCells(two_closest.GetId(0), cell_id_list)
        print("haller")
        print(cell_id_list.GetNumberOfIds())
        ctr_cell = new_ctr.GetCell(cell_id_list.GetId(0))
        #print(ctr_cell)

        print(n_s)
        if (n_s < -np.finfo(float).eps):
            start = cell_id_match + 1
            stop = ctr_cell.GetNumberOfPoints()
            step = int(1)
        else:
            start = cell_id_match - 1
            stop = int(-1)
            step = int(-1)

        new_poly_line = vtk.vtkPolyLine()

        for k in range(start, stop, step):
            old_pt_id = ctr_cell.GetPointIds().GetId(k)
            scalar.SetTuple(old_pt_id, [1])
            #new_pt_d = new_points.InsertNextPoint(new_ctr.GetPonts().GetPoint(old_pt_id)
            #new_poly_line.GetPointIds().InsertNextId(old_pt_id)

    new_ctr.GetPointData().AddArray(scalar)
    new_ctr.GetPointData().SetActiveScalars("clipper")

    pass_arrays = vtk.vtkPassArrays()
    pass_arrays.SetInputData(new_ctr)
    pass_arrays.UseFieldTypesOn()
    pass_arrays.AddArray(vtk.vtkDataObject.POINT, "clipper")
    pass_arrays.GetOutput().GetPointData().SetActiveScalars("clipper")
    pass_arrays.AddFieldType(vtk.vtkDataObject.POINT)
    pass_arrays.AddFieldType(vtk.vtkDataObject.CELL)
    pass_arrays.Update()

    clip = vtk.vtkClipPolyData()
    clip.SetValue(0.5)
    clip.SetInputConnection(pass_arrays.GetOutputPort())
    clip.InsideOutOn()
    #clip.GetOutput().GetPointData().CopyScalarsOff()
    #clip.GetOutput().GetPointData().CopyVectorsOff()
    #clip.GetOutput().GetCellData().CopyScalarsOff()
    #clip.GetOutput().GetCellData().CopyVectorsOff()
    clip.Update()

    writer = vmtkscripts.vmtkSurfaceWriter()
    writer.OutputFileName = args.out_file

    if (args.clean_ctr):
        cleaner2 = vtk.vtkCleanPolyData()
        cleaner2.PointMergingOn()
        cleaner.ConvertPolysToLinesOff()
        cleaner2.SetInputConnection(clip.GetOutputPort())
        cleaner2.Update()
        writer.Input = cleaner2.GetOutput()
    else:
        writer.Input = clip.GetOutput()

    writer.Execute()
示例#5
0
def post_proc_cfd(dir_path, vtu_input, cell_type="point",
                  vtu_output_1="calc_test_node.vtu",
                  vtu_output_2="calc_test_node_stats.vtu", N_peak=3):
    reader = vtk.vtkXMLUnstructuredGridReader()
    reader.SetFileName(os.path.join(dir_path, vtu_input))
    reader.Update()
    N = reader.GetNumberOfTimeSteps()

    print(N)
    #N = test.GetNumberOfBlocks()ls
    #block = test.GetBlock(0)

    #for i in range(N):
    #    print(i, test.GetMetaData(i).Get(vtk.vtkCompositeDataSet.NAME()))


    #grid = reader.GetOutput()
    #wallshear = grid.GetCellData().GetArray("x_wall_shear")
    #print(wallshear)
    calc1 = vtk.vtkArrayCalculator()
    calc1.SetFunction("sqrt(x_wall_shear^2+y_wall_shear^2+z_wall_shear^2)")
    calc1.AddScalarVariable("x_wall_shear", "x_wall_shear",0)
    calc1.AddScalarVariable("y_wall_shear", "y_wall_shear",0)
    calc1.AddScalarVariable("z_wall_shear", "z_wall_shear",0)
    calc1.SetResultArrayName("WSS")
    calc1.SetInputConnection(reader.GetOutputPort())
    if(cell_type == "cell"):
        calc1.SetAttributeModeToUseCellData()
        vtk_process = vtk.vtkDataObject.FIELD_ASSOCIATION_CELLS
        vtk_data_type = vtk.vtkDataObject.CELL
    else:
        calc1.SetAttributeModeToUsePointData()
        vtk_process = vtk.vtkDataObject.FIELD_ASSOCIATION_POINTS
        vtk_data_type = vtk.vtkDataObject.POINT
    calc1.SetResultArrayType(vtk.VTK_DOUBLE)

    x_WSS_grad = vtk.vtkGradientFilter()
    x_WSS_grad.SetInputConnection(calc1.GetOutputPort())
    x_WSS_grad.ComputeGradientOn()
    x_WSS_grad.FasterApproximationOff()
    x_WSS_grad.SetResultArrayName("x_WSS_grad")
    x_WSS_grad.SetInputArrayToProcess(0, 0, 0, vtk_process, "x_wall_shear")

    y_WSS_grad = vtk.vtkGradientFilter()
    y_WSS_grad.SetInputConnection(x_WSS_grad.GetOutputPort())
    y_WSS_grad.ComputeGradientOn()
    y_WSS_grad.FasterApproximationOff()
    y_WSS_grad.SetResultArrayName("y_WSS_grad")
    x_WSS_grad.SetInputArrayToProcess(0, 0, 0, vtk_process, "y_wall_shear")

    z_WSS_grad = vtk.vtkGradientFilter()
    z_WSS_grad.SetInputConnection(y_WSS_grad.GetOutputPort())
    z_WSS_grad.ComputeGradientOn()
    z_WSS_grad.FasterApproximationOff()
    z_WSS_grad.SetResultArrayName("z_WSS_grad")
    z_WSS_grad.SetInputArrayToProcess(0, 0, 0, vtk_process, "z_wall_shear")

    calc2 = vtk.vtkArrayCalculator()
    calc2.AddScalarVariable("x_component", "x_WSS_grad",0)
    calc2.AddScalarVariable("y_component", "y_WSS_grad",1)
    calc2.AddScalarVariable("z_component", "z_WSS_grad",2)
    calc2.SetFunction("sqrt(x_component^2+y_component^2+z_component^2)")
    calc2.SetResultArrayName("WSSG")
    calc2.SetInputConnection(z_WSS_grad.GetOutputPort())
    if(cell_type == "cell"):
        calc2.SetAttributeModeToUseCellData()
    else:
        calc2.SetAttributeModeToUsePointData()
    calc2.SetResultArrayType(vtk.VTK_DOUBLE)

    # initialize the output to include the peak values
    grid = vtk.vtkUnstructuredGrid()
    #N_peak = 3
    reader.SetTimeStep(N_peak)
    print("loading {0}th timestep to copy data".format(N_peak))
    calc2.Update()
    grid.DeepCopy(calc2.GetOutput())
    #grid.SetNumberOfTimeSteps(1)
    #grid.SetTimeStep(0)
    #grid.Update()

    #sqrt((ddx({Wall shear-1}))**2 + (ddy({Wall shear-2}))**2 + (ddz({Wall shear-3}))**2)'
    def init_zero(in_array, sz_array):
        for i in range(sz_array):
            in_array.SetValue(i,0.0)

    def array_sum(out_array, in_array, sz_array):
        for i in range(sz_array):
            out_array.SetValue(i, out_array.GetValue(i) + in_array.GetValue(i))

    def array_division(out_array, in_array, sz_array):
        for i in range(sz_array):
            out_array.SetValue(i, out_array.GetValue(i) / in_array.GetValue(i))

    def array_avg(out_array, N):
        float_N = float(N)
        for i in range(N):
            out_array.SetValue(i, out_array.GetValue(i) / float_N)

    reader.SetTimeStep(0)


    print("loading {0}th timestep for averaging initialization".format(0))
    reader.Update()
    calc2.Update()

    if(cell_type == "cell"):
        calc_data = calc2.GetOutput().GetCellData()
        grid_data = grid.GetCellData()
        n_sz = grid.GetNumberOfCells()
    else:
        calc_data = calc2.GetOutput().GetPointData()
        grid_data = grid.GetPointData()
        n_sz = grid.GetNumberOfPoints()

    TAWSS = vtk.vtkDoubleArray()
    TAWSS.DeepCopy(calc_data.GetArray("WSS"))
    TAWSS.SetName("TAWSS")

    TAWSSG = vtk.vtkDoubleArray()
    TAWSSG.DeepCopy(calc_data.GetArray("WSSG"))
    TAWSSG.SetName("TAWSSG")

    x_shear_avg = vtk.vtkDoubleArray()
    x_shear_avg.DeepCopy(calc_data.GetArray("x_wall_shear"))
    x_shear_avg.SetName("x_shear_avg")

    y_shear_avg = vtk.vtkDoubleArray()
    y_shear_avg.DeepCopy(calc_data.GetArray("y_wall_shear"))
    y_shear_avg.SetName("y_shear_avg")

    z_shear_avg = vtk.vtkDoubleArray()
    z_shear_avg.DeepCopy(calc_data.GetArray("z_wall_shear"))
    z_shear_avg.SetName("z_shear_avg")

    #TAWSSVector = vtk.vtkDoubleArray()
    #TAWSSVector.DeepCopy(calc_data.GetArray("z_wall_shear"))
    #TAWSSVector.SetName("TAWSSVector")
    #grid_data.AddArray(TAWSSVector)

    # def get_array_names(input):
    #     N_point_array = input.GetOutput().GetPointData().GetNumberOfArrays()
    #     N_WSS = 9999999
    #     for i in range(N_point_array):
    #         name_WSS = input.GetOutput().GetPointData().GetArrayName(i)
    #         if (name_WSS == "WSS"):
    #             N_WSS = i
    #         print(name_WSS)
    #
    # def array_sum(output, input_calc, N):
    #     for i in range(N):
    #         calc = output.GetValue(i) + input_calc.GetValue(i)
    #         output.SetValue(i, calc)

    writer = vtk.vtkXMLUnstructuredGridWriter()
    #writer.SetFileName(os.path.join(out_dir,'test_outfile.vtu'))
    writer.SetFileName(os.path.join(dir_path, vtu_output_1))
    writer.SetNumberOfTimeSteps(N)
    #writer.SetTimeStepRange(0,len(filelist)-1)
    writer.SetInputConnection(calc2.GetOutputPort())
    writer.Start()
    #avg_map = {"TAWSS":"WSS", "TAWSSG": "WSSG", "x_shear_avg":"x_wall_shear",
    #            "y_shear_avg":"y_wall_shear" , "z_shear_avg":"z_wall_shear"}

    for i in range(1,N):
        reader.SetTimeStep(i)
        print("Time step {0} for average calc".format(i))
        reader.Update()
        calc2.Update()

        if(cell_type == "cell"):
            calc_data = calc2.GetOutput().GetCellData()
        else:
            calc_data = calc2.GetOutput().GetPointData()

        #get_array_names(calc2)
        array_sum(TAWSS, calc_data.GetArray("WSS"), n_sz)
        array_sum(TAWSSG, calc_data.GetArray("WSSG"), n_sz)
        array_sum(x_shear_avg, calc_data.GetArray("x_wall_shear"), n_sz)
        array_sum(y_shear_avg, calc_data.GetArray("y_wall_shear"), n_sz)
        array_sum(z_shear_avg, calc_data.GetArray("z_wall_shear"), n_sz)

        writer.WriteNextTime(reader.GetTimeStep())

    writer.Stop()

    array_avg(TAWSS, N)
    array_avg(TAWSSG, N)
    array_avg(x_shear_avg, N)
    array_avg(y_shear_avg, N)
    array_avg(z_shear_avg, N)

    WSS_peak2mean = vtk.vtkDoubleArray()
    WSS_peak2mean.DeepCopy(grid_data.GetArray("WSS"))
    WSS_peak2mean.SetName("WSS_peak2mean")
    array_division(WSS_peak2mean, TAWSS, n_sz)

    WSSG_peak2mean = vtk.vtkDoubleArray()
    WSSG_peak2mean.DeepCopy(grid_data.GetArray("WSSG"))
    WSSG_peak2mean.SetName("WSSG_peak2mean")
    array_division(WSSG_peak2mean, TAWSSG, n_sz)

    grid_data.AddArray(TAWSS)
    grid_data.AddArray(TAWSSG)
    grid_data.AddArray(x_shear_avg)
    grid_data.AddArray(y_shear_avg)
    grid_data.AddArray(z_shear_avg)
    grid_data.AddArray(WSS_peak2mean)
    grid_data.AddArray(WSSG_peak2mean)

    print("got here")
    calc3 = vtk.vtkArrayCalculator()
    calc3.AddScalarVariable("x_shear_avg", "x_shear_avg",0)
    calc3.AddScalarVariable("y_shear_avg", "y_shear_avg",0)
    calc3.AddScalarVariable("z_shear_avg", "z_shear_avg",0)
    calc3.SetFunction("sqrt(x_shear_avg^2+y_shear_avg^2+z_shear_avg^2)")
    calc3.SetResultArrayName("TAWSSVector")
    calc3.SetInputData(grid)
    if(cell_type == "cell"):
        calc3.SetAttributeModeToUseCellData()
    else:
        calc3.SetAttributeModeToUsePointData()
    calc3.SetResultArrayType(vtk.VTK_DOUBLE)
    calc3.Update()

    calc4 = vtk.vtkArrayCalculator()
    calc4.AddScalarVariable("TAWSSVector", "TAWSSVector",0)
    calc4.AddScalarVariable("TAWSS", "TAWSS",0)
    calc4.SetFunction("0.5*(1.0-(TAWSSVector/(TAWSS)))")
    calc4.SetResultArrayName("OSI")
    calc4.SetInputConnection(calc3.GetOutputPort())
    if(cell_type == "cell"):
        calc4.SetAttributeModeToUseCellData()
    else:
        calc4.SetAttributeModeToUsePointData()
    calc4.SetResultArrayType(vtk.VTK_DOUBLE)
    calc4.Update()

    pass_filt = vtk.vtkPassArrays()
    pass_filt.SetInputConnection(calc4.GetOutputPort())
    pass_filt.AddArray(vtk_data_type, "WSS")
    pass_filt.AddArray(vtk_data_type, "WSSG")
    pass_filt.AddArray(vtk_data_type, "absolute_pressure")
    pass_filt.AddArray(vtk_data_type, "TAWSS")
    pass_filt.AddArray(vtk_data_type, "TAWSSG")
    pass_filt.AddArray(vtk_data_type, "OSI")
    pass_filt.AddArray(vtk_data_type, "WSS_peak2mean")
    pass_filt.AddArray(vtk_data_type, "WSSG_peak2mean")

    pass_filt.Update()
    #if(cell_type == "cell"):
    #    print(pass_filt.GetOutput().GetCellData().GetArray("OSI").GetValue(0))
    #else:
    #    print(pass_filt.GetOutput().GetPointData().GetArray("OSI").GetValue(0))

    writer2 = vtk.vtkXMLUnstructuredGridWriter()
    writer2.SetFileName(os.path.join(dir_path, vtu_output_2))
    writer2.SetInputConnection(pass_filt.GetOutputPort())
    writer2.Update()
示例#6
0
def Execute(args):
    print("get average along line probes")
    cell_type = "point"

    if (cell_type == "cell"):
        vtk_process = vtk.vtkDataObject.FIELD_ASSOCIATION_CELLS
        vtk_data_type = vtk.vtkDataObject.CELL
    else:
        vtk_process = vtk.vtkDataObject.FIELD_ASSOCIATION_POINTS
        vtk_data_type = vtk.vtkDataObject.POINT

    reader = vmtkscripts.vmtkMeshReader()
    reader.InputFileName = args.mesh_file
    reader.Execute()
    mesh = reader.Mesh

    pass_filt = vtk.vtkPassArrays()
    pass_filt.SetInputData(mesh)
    pass_filt.AddArray(vtk_data_type, "velocity")
    pass_filt.Update()

    surf = vmtkscripts.vmtkMeshToSurface()
    surf.Mesh = pass_filt.GetOutput()
    surf.Execute()

    normals = vmtkscripts.vmtkSurfaceNormals()
    normals.Surface = surf.Surface
    #accept defaults
    normals.Execute()

    calc1 = vtk.vtkArrayCalculator()
    calc1.SetFunction(
        "velocity_X*-Normals_X+velocity_Y*-Normals_Y+velocity_Z*-Normals_Z")
    calc1.AddScalarVariable("velocity_X", "velocity_X", 0)
    calc1.AddScalarVariable("velocity_Y", "velocity_Y", 0)
    calc1.AddScalarVariable("velocity_Z", "velocity_Z", 0)
    calc1.SetResultArrayName("vdotn")
    calc1.SetInputData(normals.Surface)
    if (cell_type == "cell"):
        calc1.SetAttributeModeToUseCellData()

    else:
        calc1.SetAttributeModeToUsePointData()
    calc1.SetResultArrayType(vtk.VTK_DOUBLE)

    integrate_attrs = vtk.vtkIntegrateAttributes()
    integrate_attrs.SetInputConnection(calc1.GetOutputPort())

    integrate_attrs.UpdateData()

    area = integrate_attrs.GetCellData().GetArray(0).GetValue(0)

    D = 2.0 * np.sqrt(area / np.pi)

    calc2 = vtk.vtkArrayCalculator()
    calc2.SetFunction("vdotn*10**6*60")
    calc2.AddScalarVariable("vdotn", "vdotn", 0)
    calc2.SetResultArrayName("Q")
    calc2.SetInputConnection(integrate_attrs.GetOutputPort())
    if (cell_type == "cell"):
        calc2.SetAttributeModeToUseCellData()
    else:
        calc2.SetAttributeModeToUsePointData()
    calc2.SetResultArrayType(vtk.VTK_DOUBLE)
    calc2.UpdateData()

    calc3 = vtk.vtkArrayCalculator()
    calc3.SetFunction("vdotn/{0}*1050.0/0.0035*{1}".format(area, D))
    calc3.AddScalarVariable("vdotn", "vdotn", 0)
    calc3.SetResultArrayName("Re")
    calc3.SetInputConnection(integrate_attrs.GetOutputPort())
    if (cell_type == "cell"):
        calc3.SetAttributeModeToUseCellData()
    else:
        calc3.SetAttributeModeToUsePointData()
    calc3.SetResultArrayType(vtk.VTK_DOUBLE)

    calc3.UpdateData()

    over_time = vtk.vtkExtractDataArraysOverTime()
    over_time.SetInputConnection(calc3.GetOutputPort())

    if (cell_type == "cell"):
        over_time.SetFieldAssociation(vtk_data_type)
    else:
        over_time.SetFieldAssociation(vtk_data_type)
    over_time.UpdateData()

    writer = vtk.vtkDelimitedTextWriter()
    writer.SetInputConnection(over_time.GetOutputPort())
    writer.SetFileName(args.file_out)
    writer.Write()
示例#7
0
def post_proc_cfd_diff(parameter_list):

    dir_path = parameter_list[0]
    vtu_input = parameter_list[1]
    cell_type = parameter_list[1]
    vtu_output_1 = parameter_list[3]
    vtu_output_2 = parameter_list[4]
    N_peak = parameter_list[5]

    reader = vtk.vtkXMLUnstructuredGridReader()
    reader.SetFileName(os.path.join(dir_path, vtu_input))
    reader.Update()
    N = reader.GetNumberOfTimeSteps()

    print(N)

    if (cell_type == "cell"):
        vtk_process = vtk.vtkDataObject.FIELD_ASSOCIATION_CELLS
        vtk_data_type = vtk.vtkDataObject.CELL
    else:
        vtk_process = vtk.vtkDataObject.FIELD_ASSOCIATION_POINTS
        vtk_data_type = vtk.vtkDataObject.POINT

    pass_arr = vtk.vtkPassArrays()
    pass_arr.SetInputConnection(reader.GetOutputPort())
    pass_arr.AddArray(vtk_data_type, "absolute_pressure")
    pass_arr.AddArray(vtk_data_type, "x_wall_shear")
    pass_arr.AddArray(vtk_data_type, "y_wall_shear")
    pass_arr.AddArray(vtk_data_type, "z_wall_shear")

    calc1 = vtk.vtkArrayCalculator()
    calc1.SetFunction("sqrt(x_wall_shear^2+y_wall_shear^2+z_wall_shear^2)")
    calc1.AddScalarVariable("x_wall_shear", "x_wall_shear", 0)
    calc1.AddScalarVariable("y_wall_shear", "y_wall_shear", 0)
    calc1.AddScalarVariable("z_wall_shear", "z_wall_shear", 0)
    calc1.SetResultArrayName("WSS")
    calc1.SetInputConnection(pass_arr.GetOutputPort())
    if (cell_type == "cell"):
        calc1.SetAttributeModeToUseCellData()
    else:
        calc1.SetAttributeModeToUsePointData()
    calc1.SetResultArrayType(vtk.VTK_DOUBLE)

    x_WSS_grad = vtk.vtkGradientFilter()
    x_WSS_grad.SetInputConnection(calc1.GetOutputPort())
    x_WSS_grad.ComputeGradientOn()
    x_WSS_grad.FasterApproximationOff()
    x_WSS_grad.ComputeDivergenceOff()
    x_WSS_grad.ComputeVorticityOff()
    x_WSS_grad.ComputeQCriterionOff()
    x_WSS_grad.SetResultArrayName("x_WSS_grad")
    x_WSS_grad.SetInputArrayToProcess(0, 0, 0, vtk_process, "x_wall_shear")

    y_WSS_grad = vtk.vtkGradientFilter()
    y_WSS_grad.SetInputConnection(x_WSS_grad.GetOutputPort())
    y_WSS_grad.ComputeGradientOn()
    y_WSS_grad.FasterApproximationOff()
    y_WSS_grad.ComputeDivergenceOff()
    y_WSS_grad.ComputeVorticityOff()
    y_WSS_grad.ComputeQCriterionOff()
    y_WSS_grad.SetResultArrayName("y_WSS_grad")
    y_WSS_grad.SetInputArrayToProcess(0, 0, 0, vtk_process, "y_wall_shear")

    z_WSS_grad = vtk.vtkGradientFilter()
    z_WSS_grad.SetInputConnection(y_WSS_grad.GetOutputPort())
    z_WSS_grad.ComputeGradientOn()
    z_WSS_grad.FasterApproximationOff()
    z_WSS_grad.ComputeDivergenceOff()
    z_WSS_grad.ComputeVorticityOff()
    z_WSS_grad.ComputeQCriterionOff()
    z_WSS_grad.SetResultArrayName("z_WSS_grad")
    z_WSS_grad.SetInputArrayToProcess(0, 0, 0, vtk_process, "z_wall_shear")

    calc2 = vtk.vtkArrayCalculator()
    calc2.AddScalarVariable("x_component", "x_WSS_grad", 0)
    calc2.AddScalarVariable("y_component", "y_WSS_grad", 1)
    calc2.AddScalarVariable("z_component", "z_WSS_grad", 2)
    calc2.SetFunction("sqrt(x_component^2+y_component^2+z_component^2)")
    calc2.SetResultArrayName("WSSG")
    calc2.SetInputConnection(z_WSS_grad.GetOutputPort())
    if (cell_type == "cell"):
        calc2.SetAttributeModeToUseCellData()
    else:
        calc2.SetAttributeModeToUsePointData()
    calc2.SetResultArrayType(vtk.VTK_DOUBLE)

    # initialize the output to include the peak values
    grid = vtk.vtkUnstructuredGrid()
    #N_peak = 3
    reader.SetTimeStep(N_peak)
    calc2.Update()
    print("loading peak: {0} timestep to copy data".format(
        reader.GetTimeStep()))
    grid.DeepCopy(calc2.GetOutput())

    reader.SetTimeStep(0)
    #reader.Update()
    calc2.Update()
    print("loading {0}th timestep for averaging initialization".format(
        reader.GetTimeStep()))

    stats = vtk.vtkTemporalStatistics()

    stats.SetInputConnection(calc2.GetOutputPort())
    stats.ComputeMaximumOff()
    stats.ComputeMinimumOff()
    stats.ComputeStandardDeviationOff()
    stats.ComputeAverageOn()
    stats.Update()

    print("what's the time step after stats :{0}".format(reader.GetTimeStep()))
    grid_out = vtk.vtkUnstructuredGrid()
    grid_out.DeepCopy(stats.GetOutput())

    if (cell_type == "cell"):
        out_data = grid_out.GetCellData()
        grid_data = grid.GetCellData()
    else:
        out_data = grid_out.GetPointData()
        grid_data = grid.GetPointData()

    print("update names")
    out_data.AddArray(grid_data.GetArray("WSS"))
    out_data.GetArray("WSS").SetName("WSS_peak")
    out_data.AddArray(grid_data.GetArray("WSSG"))
    out_data.GetArray("WSSG").SetName("WSSG_peak")
    out_data.AddArray(grid_data.GetArray("absolute_pressure"))
    out_data.GetArray("absolute_pressure").SetName("pressure_peak")

    out_data.GetArray("WSS_average").SetName("TAWSS")
    out_data.GetArray("WSSG_average").SetName("TAWSSG")
    out_data.GetArray("absolute_pressure_average").SetName("pressure_average")

    print("TAWSSVector")
    calc3 = vtk.vtkArrayCalculator()
    calc3.AddScalarVariable("x_wall_shear_average", "x_wall_shear_average", 0)
    calc3.AddScalarVariable("y_wall_shear_average", "y_wall_shear_average", 0)
    calc3.AddScalarVariable("z_wall_shear_average", "z_wall_shear_average", 0)
    calc3.SetFunction(
        "sqrt(x_wall_shear_average^2+y_wall_shear_average^2+z_wall_shear_average^2)"
    )
    calc3.SetResultArrayName("TAWSSVector")
    calc3.SetInputData(grid_out)
    if (cell_type == "cell"):
        calc3.SetAttributeModeToUseCellData()
    else:
        calc3.SetAttributeModeToUsePointData()
    calc3.SetResultArrayType(vtk.VTK_DOUBLE)
    calc3.Update()

    print("OSI")
    calc4 = vtk.vtkArrayCalculator()
    calc4.AddScalarVariable("TAWSSVector", "TAWSSVector", 0)
    calc4.AddScalarVariable("TAWSS", "TAWSS", 0)
    calc4.SetFunction("0.5*(1.0-(TAWSSVector/(TAWSS)))")
    calc4.SetResultArrayName("OSI")
    calc4.SetInputConnection(calc3.GetOutputPort())
    if (cell_type == "cell"):
        calc4.SetAttributeModeToUseCellData()
    else:
        calc4.SetAttributeModeToUsePointData()
    calc4.SetResultArrayType(vtk.VTK_DOUBLE)
    #calc4.Update()

    # peak ratios
    calc5 = vtk.vtkArrayCalculator()
    calc5.AddScalarVariable("WSS_peak", "WSS_peak", 0)
    calc5.AddScalarVariable("TAWSS", "TAWSS", 0)
    calc5.SetFunction("WSS_peak/TAWSS")
    calc5.SetResultArrayName("WSS_peak_q_TAWSS")
    calc5.SetInputConnection(calc4.GetOutputPort())
    if (cell_type == "cell"):
        calc5.SetAttributeModeToUseCellData()
    else:
        calc5.SetAttributeModeToUsePointData()
    calc5.SetResultArrayType(vtk.VTK_DOUBLE)
    #calc5.Update()

    calc6 = vtk.vtkArrayCalculator()
    calc6.AddScalarVariable("WSSG_peak", "WSSG_peak", 0)
    calc6.AddScalarVariable("TAWSSG", "TAWSSG", 0)
    calc6.SetFunction("WSSG_peak/TAWSSG")
    calc6.SetResultArrayName("WSSG_peak_q_TAWSSG")
    calc6.SetInputConnection(calc5.GetOutputPort())
    if (cell_type == "cell"):
        calc6.SetAttributeModeToUseCellData()
    else:
        calc6.SetAttributeModeToUsePointData()
    calc6.SetResultArrayType(vtk.VTK_DOUBLE)

    calc7 = vtk.vtkArrayCalculator()
    calc7.AddScalarVariable("pressure_peak", "pressure_peak", 0)
    calc7.AddScalarVariable("pressure_average", "pressure_average", 0)
    calc7.SetFunction("pressure_peak/pressure_average")
    calc7.SetResultArrayName("pressure_peak_q_pressure_average")
    calc7.SetInputConnection(calc6.GetOutputPort())
    if (cell_type == "cell"):
        calc7.SetAttributeModeToUseCellData()
    else:
        calc7.SetAttributeModeToUsePointData()
    calc7.SetResultArrayType(vtk.VTK_DOUBLE)

    pass_filt = vtk.vtkPassArrays()
    pass_filt.SetInputConnection(calc7.GetOutputPort())
    pass_filt.AddArray(vtk_data_type, "WSS_peak")
    pass_filt.AddArray(vtk_data_type, "WSSG_peak")
    pass_filt.AddArray(vtk_data_type, "pressure_peak")
    pass_filt.AddArray(vtk_data_type, "pressure_average")
    pass_filt.AddArray(vtk_data_type, "TAWSS")
    pass_filt.AddArray(vtk_data_type, "TAWSSG")
    pass_filt.AddArray(vtk_data_type, "OSI")
    pass_filt.AddArray(vtk_data_type, "WSS_peak_q_TAWSS")
    pass_filt.AddArray(vtk_data_type, "WSSG_peak_q_TAWSSG")
    pass_filt.AddArray(vtk_data_type, "pressure_peak_q_pressure_average")

    pass_filt.Update()
    #if(cell_type == "cell"):
    #    print(pass_filt.GetOutput().GetCellData().GetArray("OSI").GetValue(0))
    #else:
    #    print(pass_filt.GetOutput().GetPointData().GetArray("OSI").GetValue(0))

    writer2 = vtk.vtkXMLUnstructuredGridWriter()
    writer2.SetFileName(os.path.join(dir_path, vtu_output_2))
    writer2.SetInputConnection(pass_filt.GetOutputPort())
    writer2.Update()