WRITE YOUR OWN SOLVER

ParaView: Open-source Post-Processor

ParaView for OpenFOAM

Disclaimer:

Excerpt from Tutorial: "ParaView is an open-source application for visualizing two- and three-dimensional data sets. The size of the data sets ParaView can handle varies widely depending on the architecture on which the application is run. The platforms supported by ParaView range from single-processor workstations to multiple-processor distributed-memory supercomputers or workstation clusters. ParaView comes with a pvpython application that allows you to automate the visualization and post-processing with Python scripting. The Visualization Toolkit (VTK) provides the basic visualization and rendering algorithms. VTK incorporates several other libraries to provide basic functionalities such as rendering, parallel processing, file I/O, and parallel rendering."

ParaView follows concept of blocks which refers to fluid zone, solid zone, boundary names. Individual surfaces are refered to as patched. It uses 'Source' and 'Filters' as post-processing operation. The tree starts with an input 'source' and filters can be added in in parallel or paralle/series sequence.

Reading Data from FLUENT and STAR-CCM+

Paraview used filters which are functional units that process the data to generate, extract or derive features from the data. Filters are attached to readers, sources or other filters to modify its data in some way. These filter connections form a visualization pipeline. Use the p key to place alternating points, Ctrl+p places at nearest mesh point. Use the numeric 1 or 2 key to place the start or end point, Ctrl+1 or Ctrl+2 places at mesh point.

Drag the endpoints: use x, y or z key to constrain to axis. Press the key again to deactive the ortho-control.

Mask Points (MaskPoints): Reduce the number of points. This filter is often used before glyphing. Generating vertices is an option. OnRatio: The value of this property specifies that every OnStride-th points will be retained in the output when not using Random (the skip or stride size for point ids). For example, if the on ratio is 3, then the output will contain every 3rd point, up to the the maximum number of points.

Cell Centers (CellCenters): Create a point (no geometry) at the center of each input cell.

Tube: Convert lines into tubes. Normals are used to avoid cracks between tube segments.

Step-1

Step-2

Step-3

Extracting Data

Compute Drag and Lift Forces due to Pressure

Extract Surface: When you apply the Extract Surface Filter, you will once again see the surface of the mesh. Although it looks like the original mesh, it is different in that this mesh is hollow whereas the original mesh was solid throughout. If you were showing the results of the contour filter, you cannot see the contour anymore (after Extract Surface was applied). However, it is still in there hidden by the surface which can be viewed by appropriately hiding filters in "Pipeline Browser".

"Generate Surface Normals" requires a vtkPolyData as input which can be generated using Filter "Extract Surface". This data is used to generate surface normals. Filter "Gradient Of Unstructured DataSet" on a scalar results in a vector. One need to compute the velocity magnitude first and store it as a variable before trying to compute the gradient. You can do this using the calculator with a function 'mag(U)' naming it something like say 'Umag', then selecting 'Umag' as input to the 'Gradient' filter.

Similarly, to compute the dot product of two vectors, in the 'Calculator' it is simply '(Normals).(gradUmag)' where gradUmag is the gradient of Umag calculated in previous step. The "Compute Derivatives" filter takes point scalars and computes the gradient in the centroid of each cell (thus producing cell data). The 'Gradient' filter can take point data and find the data at the points or take cell data and find (an estimate of) the gradient at the cell centroids.

To visualize the Lagrangian particles the case must be converted into the ParaView format. The user should run the application foamToVTK on the case containing the Lagrangian Particle Tracking (LPT). This command will generate an additional folder named VTK inside the case directory. The case can be opened clicking on the file menu, open, and selecting the VTK directory. By clicking on the *.vtk file the case will be opened. The user must then open the files contained in the lagrangian directory inside the VTK folder.

Python Script Example

from paraview.simple import *
 sphereInstance = Sphere ()
 sphereInstance.Radius = 1.0
 sphereInstance.Center [1] = 1.0
 print(sphereInstance.Center)
 sphereDisplay = Show( sphereInstance )
 view = Render()
 sphereDisplay.Opacity = 0.5
 GetDisplayProperty ("Opacity") 
 Render(view)  

Manipulate display properties

 readerRep = GetRepresentation()
 readerRep.DiffuseColor = [0, 0, 1] 
 readerRep.SpecularColor = [1, 1, 1]
 readerRep.SpecularPower = 128
 readerRep.Specular = 1
 Render() 

Manipulate view properties

 view = GetActiveView()
 view.Background = [0, 0, 0]
 view.Background2 = [0, 0, 0.6]
 view.UseGradientBackground = True
 Render() 

Save Data and Screen-capture of Pots

 plot = PlotOverLine()
 plot.Source.Point1 = [0,0,0]
 plot.Source.Point2 = [0,0,10]
 writer = CreateWriter('⟨path⟩/plot.csv')
 writer.UpdatePipeline()
 plotView = CreateView('XYChartView')
 Show(plot)
 Render()
 SaveScreenshot('plotFile.png')

In paraview, every time you hit Apply or change a display property, the UI automatically re-renders the view. In the scripting environment, you have to do this manually by calling the Render function every time you want to re-render and look at the updated result. Render function can take in an optional view argument, otherwise it simply uses the active view.

List of Filters in ParaView

Cell Size: ComputePoint, ComputeLength, ComputeArea and ComputeVolume options can be used to specify what dimension cells to compute for. Alternatively, the ComputeHighestDimension will compute sizes for only the highest dimension cells for the vtkDataSet. The values are placed in a cell data array named ArrayName. The SumSize option will give a summation of the computed cell sizes for a vtkDataSet and for composite datasets will contain a sum of the underlying blocks.

• WrongNumberOfPoints: filters assume that a cell has access to the appropriate number of points that comprise it. This assumption is often tacit, resulting in unexpected behavior when the condition is not met. This check simply confirms that the cell has the minimum number of points needed to describe it.
• IntersectingEdges: cells that incorrectly describe the order of their points often manifest with intersecting edges or intersecting faces. Given a tolerance, this check ensures that two edges from a two-dimensional cell are separated by at least the tolerance (discounting end-to-end connections).
• IntersectingFaces: cells that incorrectly describe the order of their points often manifest with intersecting edges or intersecting faces. Given a tolerance, this check ensures that two faces from a three-dimensional cell do not intersect.
• NoncontiguousEdges: another symptom of incorrect point ordering within a cell is the presence of noncontiguous edges where contiguous edges are otherwise expected. Given a tolerance, this check ensures that edges around the perimeter of a two-dimensional cell are contiguous.
• Nonconvex: many algorithms implicitly require that all input three- dimensional cells be convex. This check uses the generic convexity checkers implemented in vtkPolygon and vtkPolyhedron to test this requirement.
• FacesAreOrientedIncorrectly: All three-dimensional cells have an implicit expectation for the orientation of their faces. While the convention is unfortunately inconsistent across cell types, it is usually required that cell faces point outward. This check tests that the faces of a cell point in the direction required by the cell type, taking into account the cell types with nonstandard orientation requirements.

Sample Python Script for Post-processing in Paraview

'''
 The code has been used from technical report titled "Scripted CFD simulations 
 and postprocessing in Fluent and ParaVIEW". The code in the PDF document has
 extra spaces in the variables names and difficult to follow the indentation.
 This script has been edited and tested to ensure no syntax error is present.
'''
# #############################################################################
# ---------------------------------Header -------------------------------------
# Author: Lukas Muttenthaler
# Date: May 2017
# Description::: This file opens the stored results of the simulations,
# imports the specified variables, creates several cutting planes, looks
# from above on this plane, sets the scalar bar and saves a *.png picture
# of this visualisation. The file does this for all simulation cases.

# #############################################################################
# ------------------------------Import Packages -------------------------------
# need to set your path variable for searching for shared libraries (i.e. 
# PATH on Windows and LD_LIBRARY_PATH on Unix/Linux/Mac). 
# In Ubuntu: export LD_LIBRARY_PATH=/usr/bin/paraview

from paraview.simple import *

import os, math
import matplotlib.cm

# #############################################################################
# -------------------------Creating a Slice Function---------------------------
def sliceWithPlane (data, sliceOrigin, sliceNormal, sliceOffset, sliceCrinkle):
  slice = Slice (Input = data)
  # Specify the Data which should be sliced
  slice.SliceType = 'Plane'
  # Specified by Plane
  # Offset
  slice.SliceOffsetValues = sliceOffset 
  
  # Point included by the Plane
  slice.SliceType.Origin = sliceOrigin
  
  # Vector Normal to the Plane
  slice.SliceType.Normal = sliceNormal 
  slice.Crinkleslice = sliceCrinkle
  # Shows an flat or crinkled Plane
  return slice

# #############################################################################
# --------------------Define Cases, Planes and FieldVars-----------------------
mainPath = "C:/ MyProject" # Define the Main Path

# Define which Cases should be loaded
caseLoadArray = ['/ Results/DoneIn2017_SimA', '/ Results/DoneIn2017_SimB', 
  '/Results/DoneIn2017_SimC']
  
# Specifiy which Format should be loaded
caseFileExtension = '.encas'

# Define the naming of the Pictures , that are created
caseSavingArray = ['/Analysis/DoneIn2017_SimA', '/Analysis/DoneIn2017_SimB', 
'/Analysis/DoneIn2017_SimC']

# Specifiy which Picture Formats should be stored
picSavingFileExtension = ['.png'] 

# Slicing Planes
planeArray = ['A100_XZPlaneBigPort', 'A110_XYPlaneSmallPort', 
'A100_XYPlaneConnection'] 

# Variables of that Pictures should be stored
fieldVarArray = ['viscosity_lam', 'viscosity_turb', 'turb_diss_rate']

# Naming of the Variables in the Pictures
fieldVarArrayOtherNamings = ['visc_lam', 'visc_turb', 'turb_diss_rate'] 

# #############################################################################
# -------------------------Loop Simulation Results ----------------------------

for iCase in range (0, len(caseLoadArray) ):
  
  # -------------------Load Data and set Field Variables ----------------------
  # Load Data
  data1 = EnSightReader(CaseFileName = mainPath + "/" + caseLoadArray[iCase]
    + caseFileExtension)
  
  # Specify which Cell -Based Field Variables are loaded
  data1.CellArrays = []
  
  # Specify which Point -Based Field Variables are loaded
  data1PointArrays = fieldVarArray 

  # --------------------Define Origin Points and Vectors ----------------------
  # ---Definition of Origin Points of Cutting Planes
  middleBigPort = [-0.08, 0.0, 0.06]
  middleSmallPort = [-0.08, 0.0, 0.02]
  middleConnection = [-0.08, 0.2, 0.00]

  # ---Definition of Vectors: yz, zx and xy planes respectively
  vectorX = [1.0, 0.0, 0.0]
  vectorY = [0.0, 1.0, 0.0]
  vectorZ = [0.0, 0.0, 1.0]

  # Offset of the plane
  sliceOffset = 0.0
  
  # Showing Crinkles or not ?
  sliceCrinkle = False 

  # ###########################################################################
  # --------------------------Loop Cutting Planes -----------------------------
  for iPlane in range(0, len(planeArray)):

    # --------------------------Define Cutting Planes -------------------------
    if iPlane == 0:
      slice1 = sliceWithPlane(data1, middleBigPort, vectorY, sliceOffset,
                            sliceCrinkle )
      camPosition = [0, -1,  0]
      camViewUp =   [0,  0, -1]
    
    elif iPlane == 1:
      slice1 = sliceWithPlane(data1, middleSmallPort, vectorZ, sliceOffset,
                           sliceCrinkle )
      camPosition = [0, 0, -1]
      camViewUp =   [0, 1,  0]
    
    elif iPlane == 2:
      slice1 = sliceWithPlane(data1, middleConnection, vectorZ, sliceOffset,
                           sliceCrinkle )
      camPosition = [0, 0, -1]
      camViewUp =   [0, 1,  0]
    Hide(data1)
    Show(slice1 )

    # ----------Specify the Viewing Parameters and Display Properties ---------
    # Get current View
    view1 = GetActiveView()
  
    # White
    view1.Background = [1, 1, 1] 
  
    # Visibility of Orientation Axes?
    view1.OrientationAxesVisibility = True
  
    # Black Colored Label
    view1.OrientationAxesLabelColor = (0, 0, 0) 
  
    # Width and Height in Pixels
    view1.ViewSize = [1920, 1200]

    # --------------------------Get Display Properties ------------------------
    # Get the properties of current Display
    dp1 = GetDisplayProperties() 
  
    # ----------------------Specify the Camera Parameters ---------------------
    camera = GetActiveCamera()
    camera.SetFocalPoint (0, 0, 0)
    camera.SetPosition(camPosition)
    camera.SetViewUp(camViewUp)
    camera.SetViewAngle(30)
   
    # Hides the Slicing Plane
    Hide3DWidgets(proxy = slice1.SliceType) 
 
    view1.ResetCamera()

    # #########################################################################
    # --------------------------Loop Field Variables --------------------------
    for iFieldVar in range (0, len(fieldVarArray)):
     
      # Set Scalar Coloring
      ColorBy(dp1, ('POINTS', fieldVarArray[iFieldVar])) 

      # Rescale Color and / or Opacity Maps used to include current Data Range
      dp1.RescaleTransferFunctionToDataRange(True, False) 
  
      # Show Color Bar
      dp1.SetScalarBarVisibility(view1, True )

      colorMap1 = GetColorTransferFunction(fieldVarArray[iFieldVar])

      # --------------------Specify the Color Map Parameters ------------------
      [minRange1, maxRange1] = slice1.GetDataInformation().\
      GetPointDataInformation().GetArrayInformation(fieldVarArray[iFieldVar]).\
      GetComponentRange(0)

      # Color Map Specification
      colorMap1 = GetColorTransferFunction(fieldVarArray[iFieldVar])
      colorMap1.Discretize = 0
      colorMap1.UseLogScale = 0
      colorMap1.LockDataRange = 0

      # "Rainbow" Colormap from matplotlib
      N = 10
      stepWidth = 1
      cmap = matplotlib.cm.get_cmap('rainbow')
      colorMap1.ColorSpace = "RGB"
      RGB1 = [None]*4*(N+1)

      # Create Array with specified Points in the Color Map
      for ii in xrange (0, N + stepWidth, stepWidth):
  
        # Colormap is normalized to Values from 0 to 1
        RGBA1 = cmap (ii / float (N)) 
    
        # Write Scalar Points to the Array
        RGB1[4*ii] = minRange1 + ii*(maxRange1 - minRange1) / float(N)
        # Write RGB -Values to the Array
        RGB1[4*ii + 1:4*ii + 4] = RGBA1[0:3] 
  
      colorMap1.RGBPoints = RGB1
  
      # -------------------Specify the Scalar Bar Parameters ------------------
      # Get current Bar
      scalarBar1 = GetScalarBar(colorMap1, view1 ) 
 
      # Show Scalar Bar
      dp1.SetScalarBarVisibility(view1, True)

      # Title
      scalarBar1.Title = fieldVarArrayOtherNamings[iFieldVar]
  
      # Additional Text to the Title
      scalarBar1.ComponentTitle = " "
  
      # Color of the title: Black
      scalarBar1.TitleColor = [0.0, 0.0, 0.0] 
  
      # Font Size of the Title of the Legend
      scalarBar1.TitleFontSize = 10
  
      # Annotation for NaN?
      scalarBar1.DrawNanAnnotation = False 
  
      # Width of the Color Bar
      scalarBar1.AspectRatio = 20

      # Auto Format of Labels?
      scalarBar1.AutomaticLabelFormat = False
  
      # Label Format of the First and Last Value 
      scalarBar1.RangeLabelFormat = "%#-3.5e"
  
      # Label Format except the First and Last Value
      scalarBar1.LabelFormat = "%#-3.5e"

      # Fontsize
      scalarBar1.LabelFontSize = 8

      # Show Main Tick Marks?
      scalarBar1.DrawTickMarks = True
  
      # Show Sub Tick Marks?
      scalarBar1.DrawSubTickMarks = False
  
      # Show Labels of the Main Tick Marks?
      scalarBar1.DrawTickLabels = True
 
      # Color of the Labels: Black
      scalarBar1.LabelColor = [0.0, 0.0, 0.0]
  
      # Number of Ticks
      scalarBar1.NumberOfLabels = 7

      # Rel. Position of the Bar: Left, Bottom Corner
      scalarBar1.Position =  [0.025, 0.225] 
  
      # Rel. Position of the Bar : Right, Top Corner
      scalarBar1.Position2 = [0.200, 0.750]

      # Orientation
      scalarBar1.Orientation = "Vertical"
  
      # Alignment of Title: Left, Centered and Right 
      scalarBar1.TitleJustification = "Right"
  
      # Show or Hide Scalar Bar
      scalarBar1.Visibility = 1
  
      # Update View
      Render() 

      # ----------------------Create Subfolder if necessary -------------------
      try:
        os.stat(mainPath + "/" + subDirArray[iCase])
      except :
        os.mkdir(mainPath + "/" + subDirArray[iCase])
      # ------------------------------Save Pictures ---------------------------
  
      # Store Screenshot to specified Path
      SaveScreenshot(mainPath + "/" + caseSavingArray [iCase] + "_" +   \
      planeArray[iPlane] + "_" + fieldVarArrayOtherNamings[iFieldVar] + \
      picSavingFileExtension[0]) 

      # Show Color Bar
      dp1.SetScalarBarVisibility(view1, False ) 

    # Hide Slice Plane
    Hide(slice1)

    # Update View
    Render()

    # Delete Slice after completing a specific Viewing 
    Delete(slice1)

    # Delete the Variable
    del slice1

  # Delete Data after Postprocessing of each Simulation Result
  Delete(data1) 

  # Delete the Variable
  del data1

# -----------------------------END OF SCRIPT ---------------------------------#