CONFIG: update catalyst configuration files

- relocated from
    etc/caseDicts/postProcessing/catalyst/ -> etc/caseDicts/insitu/catalyst/

- adjusted for unified catalyst function object

etc/caseDicts/postProcessing/catalyst/default.cfg → etc/caseDicts/insitu/catalyst/catalyst.cfg

@@ -5,7 +5,7 @@
 |   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/
-// Insitu processing of finiteVolume fields with ParaView Catalyst
+// Insitu processing with ParaView Catalyst
 
 type            catalyst;
 libs            ("libcatalystFoam.so");

etc/caseDicts/insitu/catalyst/printChannels.py

+from paraview.simple import *
+from paraview import coprocessing
+
+# The frequency to output everything
+outputfrequency = 1
+
+# Simply print out all channel names that our function object is producing
+
+# ----------------------- CoProcessor definition -----------------------
+
+def CreateCoProcessor():
+  def _CreatePipeline(coprocessor, datadescription):
+    class Pipeline:
+      for i in range(datadescription.GetNumberOfInputDescriptions()):
+        name = datadescription.GetInputDescriptionName(i)
+        input = coprocessor.CreateProducer(datadescription, name)
+        grid = input.GetClientSideObject().GetOutputDataObject(0)
+        print "Channel <" + name + "> is", grid.GetClassName()
+
+    return Pipeline()
+
+  class CoProcessor(coprocessing.CoProcessor):
+    def CreatePipeline(self, datadescription):
+      self.Pipeline = _CreatePipeline(self, datadescription)
+
+  return CoProcessor()
+
+#--------------------------------------------------------------
+# Global variables that will hold the pipeline for each timestep
+# Creating the CoProcessor object, doesn't actually create the ParaView pipeline.
+# It will be automatically setup when coprocessor.UpdateProducers() is called the
+# first time.
+coprocessor = CreateCoProcessor()
+
+#--------------------------------------------------------------
+# Enable Live-Visualizaton with ParaView
+coprocessor.EnableLiveVisualization(False)
+
+
+# ---------------------- Data Selection method ----------------------
+
+def RequestDataDescription(datadescription):
+    "Callback to populate the request for current timestep"
+    global coprocessor
+    if datadescription.GetForceOutput() == True or datadescription.GetTimeStep() % outputfrequency == 0:
+        # We are just going to request all fields and meshes from the simulation
+        # code/adaptor.
+        for i in range(datadescription.GetNumberOfInputDescriptions()):
+            datadescription.GetInputDescription(i).AllFieldsOn()
+            datadescription.GetInputDescription(i).GenerateMeshOn()
+        return
+
+    # setup requests for all inputs based on the requirements of the
+    # pipeline.
+    coprocessor.LoadRequestedData(datadescription)
+
+# ------------------------ Processing method ------------------------
+
+def DoCoProcessing(datadescription):
+    "Callback to do co-processing for current timestep"
+    global coprocessor
+
+    # Update the coprocessor by providing it the newly generated simulation data.
+    # If the pipeline hasn't been setup yet, this will setup the pipeline.
+    coprocessor.UpdateProducers(datadescription)
+
+    # Write output data, if appropriate.
+    coprocessor.WriteData(datadescription);

etc/caseDicts/insitu/catalyst/writeAll.py

+from paraview.simple import *
+from paraview import coprocessing
+
+# The frequency to output everything
+outputfrequency = 5
+
+# This is largely identical to the Catalyst allinputsgridwriter.py example
+# but only handle vtkMultiBlockDataSet, since that is what we generate
+
+# ----------------------- CoProcessor definition -----------------------
+
+def CreateCoProcessor():
+  def _CreatePipeline(coprocessor, datadescription):
+    class Pipeline:
+      for i in range(datadescription.GetNumberOfInputDescriptions()):
+        name  = datadescription.GetInputDescriptionName(i)
+        input = coprocessor.CreateProducer(datadescription, name)
+        grid  = input.GetClientSideObject().GetOutputDataObject(0)
+        if grid.IsA('vtkMultiBlockDataSet'):
+          writer = servermanager.writers.XMLMultiBlockDataWriter(Input=input)
+          coprocessor.RegisterWriter(writer, filename=name+'_%t.vtm', freq=outputfrequency)
+
+    return Pipeline()
+
+  class CoProcessor(coprocessing.CoProcessor):
+    def CreatePipeline(self, datadescription):
+      self.Pipeline = _CreatePipeline(self, datadescription)
+
+  return CoProcessor()
+
+#--------------------------------------------------------------
+# Global variables that will hold the pipeline for each timestep
+# Creating the CoProcessor object, doesn't actually create the ParaView pipeline.
+# It will be automatically setup when coprocessor.UpdateProducers() is called the
+# first time.
+coprocessor = CreateCoProcessor()
+
+#--------------------------------------------------------------
+# Enable Live-Visualizaton with ParaView
+coprocessor.EnableLiveVisualization(False)
+
+
+# ---------------------- Data Selection method ----------------------
+
+def RequestDataDescription(datadescription):
+    "Callback to populate the request for current timestep"
+    global coprocessor
+    if datadescription.GetForceOutput() == True or datadescription.GetTimeStep() % outputfrequency == 0:
+        # We are just going to request all fields and meshes from the simulation
+        # code/adaptor.
+        for i in range(datadescription.GetNumberOfInputDescriptions()):
+            datadescription.GetInputDescription(i).AllFieldsOn()
+            datadescription.GetInputDescription(i).GenerateMeshOn()
+        return
+
+    # setup requests for all inputs based on the requirements of the
+    # pipeline.
+    coprocessor.LoadRequestedData(datadescription)
+
+# ------------------------ Processing method ------------------------
+
+def DoCoProcessing(datadescription):
+    "Callback to do co-processing for current timestep"
+    global coprocessor
+
+    # Update the coprocessor by providing it the newly generated simulation data.
+    # If the pipeline hasn't been setup yet, this will setup the pipeline.
+    coprocessor.UpdateProducers(datadescription)
+
+    # Write output data, if appropriate.
+    coprocessor.WriteData(datadescription);
+
+    # Write image capture (Last arg: rescale lookup table), if appropriate.
+    coprocessor.WriteImages(datadescription, rescale_lookuptable=False)
+
+    # Live Visualization, if enabled.
+    coprocessor.DoLiveVisualization(datadescription, "localhost", 22222)

etc/caseDicts/insitu/catalyst/writeMesh.py

+from paraview.simple import *
+from paraview import coprocessing
+
+# The frequency to output everything
+outputfrequency = 5
+
+# As per writeAll, but only for "/mesh" sub-channels.
+
+# ----------------------- CoProcessor definition -----------------------
+
+def CreateCoProcessor():
+  def _CreatePipeline(coprocessor, datadescription):
+    class Pipeline:
+      for i in range(datadescription.GetNumberOfInputDescriptions()):
+        name = datadescription.GetInputDescriptionName(i)
+        if not name.endswith('/mesh'):
+          continue
+        input = coprocessor.CreateProducer(datadescription, name)
+        grid  = input.GetClientSideObject().GetOutputDataObject(0)
+        if grid.IsA('vtkMultiBlockDataSet'):
+          writer = servermanager.writers.XMLMultiBlockDataWriter(Input=input)
+          coprocessor.RegisterWriter(writer, filename=name+'_%t.vtm', freq=outputfrequency)
+
+    return Pipeline()
+
+  class CoProcessor(coprocessing.CoProcessor):
+    def CreatePipeline(self, datadescription):
+      self.Pipeline = _CreatePipeline(self, datadescription)
+
+  return CoProcessor()
+
+#--------------------------------------------------------------
+# Global variables that will hold the pipeline for each timestep
+# Creating the CoProcessor object, doesn't actually create the ParaView pipeline.
+# It will be automatically setup when coprocessor.UpdateProducers() is called the
+# first time.
+coprocessor = CreateCoProcessor()
+
+#--------------------------------------------------------------
+# Enable Live-Visualizaton with ParaView
+coprocessor.EnableLiveVisualization(False)
+
+
+# ---------------------- Data Selection method ----------------------
+
+def RequestDataDescription(datadescription):
+    "Callback to populate the request for current timestep"
+    global coprocessor
+    if datadescription.GetForceOutput() == True or datadescription.GetTimeStep() % outputfrequency == 0:
+        # We are just going to request all fields and meshes from the simulation
+        # code/adaptor.
+        for i in range(datadescription.GetNumberOfInputDescriptions()):
+            datadescription.GetInputDescription(i).AllFieldsOn()
+            datadescription.GetInputDescription(i).GenerateMeshOn()
+        return
+
+    # setup requests for all inputs based on the requirements of the
+    # pipeline.
+    coprocessor.LoadRequestedData(datadescription)
+
+# ------------------------ Processing method ------------------------
+
+def DoCoProcessing(datadescription):
+    "Callback to do co-processing for current timestep"
+    global coprocessor
+
+    # Update the coprocessor by providing it the newly generated simulation data.
+    # If the pipeline hasn't been setup yet, this will setup the pipeline.
+    coprocessor.UpdateProducers(datadescription)
+
+    # Write output data, if appropriate.
+    coprocessor.WriteData(datadescription);
+
+    # Write image capture (Last arg: rescale lookup table), if appropriate.
+    coprocessor.WriteImages(datadescription, rescale_lookuptable=False)
+
+    # Live Visualization, if enabled.
+    coprocessor.DoLiveVisualization(datadescription, "localhost", 22222)

etc/caseDicts/insitu/catalyst/writePatches.py

+from paraview.simple import *
+from paraview import coprocessing
+
+# The frequency to output everything
+outputfrequency = 5
+
+# As per writeAll, but only for "/patches" sub-channels.
+
+# ----------------------- CoProcessor definition -----------------------
+
+def CreateCoProcessor():
+  def _CreatePipeline(coprocessor, datadescription):
+    class Pipeline:
+      for i in range(datadescription.GetNumberOfInputDescriptions()):
+        name = datadescription.GetInputDescriptionName(i)
+        if not name.endswith('/patches'):
+          continue
+        input = coprocessor.CreateProducer(datadescription, name)
+        grid  = input.GetClientSideObject().GetOutputDataObject(0)
+        if grid.IsA('vtkMultiBlockDataSet'):
+          writer = servermanager.writers.XMLMultiBlockDataWriter(Input=input)
+          coprocessor.RegisterWriter(writer, filename=name+'_%t.vtm', freq=outputfrequency)
+
+    return Pipeline()
+
+  class CoProcessor(coprocessing.CoProcessor):
+    def CreatePipeline(self, datadescription):
+      self.Pipeline = _CreatePipeline(self, datadescription)
+
+  return CoProcessor()
+
+#--------------------------------------------------------------
+# Global variables that will hold the pipeline for each timestep
+# Creating the CoProcessor object, doesn't actually create the ParaView pipeline.
+# It will be automatically setup when coprocessor.UpdateProducers() is called the
+# first time.
+coprocessor = CreateCoProcessor()
+
+#--------------------------------------------------------------
+# Enable Live-Visualizaton with ParaView
+coprocessor.EnableLiveVisualization(False)
+
+
+# ---------------------- Data Selection method ----------------------
+
+def RequestDataDescription(datadescription):
+    "Callback to populate the request for current timestep"
+    global coprocessor
+    if datadescription.GetForceOutput() == True or datadescription.GetTimeStep() % outputfrequency == 0:
+        # We are just going to request all fields and meshes from the simulation
+        # code/adaptor.
+        for i in range(datadescription.GetNumberOfInputDescriptions()):
+            datadescription.GetInputDescription(i).AllFieldsOn()
+            datadescription.GetInputDescription(i).GenerateMeshOn()
+        return
+
+    # setup requests for all inputs based on the requirements of the
+    # pipeline.
+    coprocessor.LoadRequestedData(datadescription)
+
+# ------------------------ Processing method ------------------------
+
+def DoCoProcessing(datadescription):
+    "Callback to do co-processing for current timestep"
+    global coprocessor
+
+    # Update the coprocessor by providing it the newly generated simulation data.
+    # If the pipeline hasn't been setup yet, this will setup the pipeline.
+    coprocessor.UpdateProducers(datadescription)
+
+    # Write output data, if appropriate.
+    coprocessor.WriteData(datadescription);
+
+    # Write image capture (Last arg: rescale lookup table), if appropriate.
+    coprocessor.WriteImages(datadescription, rescale_lookuptable=False)
+
+    # Live Visualization, if enabled.
+    coprocessor.DoLiveVisualization(datadescription, "localhost", 22222)

etc/caseDicts/postProcessing/catalyst/area.cfg

-/*--------------------------------*- C++ -*----------------------------------*\
-| =========                 |                                                 |
-| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  plus                                  |
-|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
-|    \\/     M anipulation  |                                                 |
-\*---------------------------------------------------------------------------*/
-// Insitu processing of finiteArea fields with ParaView Catalyst
-
-type            catalyst::area;
-libs            ("libcatalystFoam.so");
-
-executeControl  timeStep;
-writeControl    none;
-
-// ************************************************************************* //

etc/caseDicts/postProcessing/catalyst/cloud.cfg

-/*--------------------------------*- C++ -*----------------------------------*\
-| =========                 |                                                 |
-| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  plus                                  |
-|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
-|    \\/     M anipulation  |                                                 |
-\*---------------------------------------------------------------------------*/
-// Insitu processing of lagrangian clouds with ParaView Catalyst
-
-type            catalyst::cloud;
-libs            ("libcatalystFoam.so");
-
-executeControl  timeStep;
-writeControl    none;
-
-// ************************************************************************* //

tutorials/incompressible/overPimpleDyMFoam/twoSimpleRotors/system/catalyst

@@ -4,19 +4,23 @@ functions
 {
     catalyst
     {
-        #includeEtc "caseDicts/postProcessing/catalyst/default.cfg"
-
-        mkdir "<case>/insitu";
-
-        // Selected fields (words or regex). Must have cellMask for overset!
-        fields      ( cellMask U p );
+        #includeEtc "caseDicts/insitu/catalyst/catalyst.cfg"
 
         scripts
         (
-            "<system>/scripts/overset.py"
-            "<system>/scripts/writeOverset.py"
+            "<system>/scripts/pressure.py"
+            // "<system>/scripts/vorticity.py"
+            // "<etc>/caseDicts/insitu/catalyst/writeMesh.py"
         );
 
+        inputs
+        {
+            region
+            {
+                // Selected fields (words or regex).
+                fields      ( U p );
+            }
+        }
     }
 }
 

tutorials/incompressible/overPimpleDyMFoam/twoSimpleRotors/system/scripts/overset.py → tutorials/incompressible/overPimpleDyMFoam/twoSimpleRotors/system/scripts/pressure.py

@@ -10,11 +10,13 @@ from paraview import coprocessing
 imageFileNamePadding=4
 rescale_lookuptable=False
 
+
 # ----------------------- CoProcessor definition -----------------------
 
 def CreateCoProcessor():
   def _CreatePipeline(coprocessor, datadescription):
     class Pipeline:
+      # state file generated using paraview version 5.5.0
 
       # ----------------------------------------------------------------
       # setup views used in the visualization
@@ -27,16 +29,15 @@ def CreateCoProcessor():
 
       # Create a new 'Render View'
       renderView1 = CreateView('RenderView')
-      renderView1.ViewSize = [1077, 763]
+      renderView1.ViewSize = [1091, 766]
       renderView1.AxesGrid = 'GridAxes3DActor'
-      renderView1.CenterOfRotation = [0.00784385809674859, 0.005000000004656613, 0.004999999888241291]
+      renderView1.CenterOfRotation = [0.009999999776482582, 0.004999999888241291, 0.004999999888241291]
       renderView1.StereoType = 0
-      renderView1.CameraPosition = [0.0072242101003740155, 0.0002877833685303474, 0.035060283710920806]
-      renderView1.CameraFocalPoint = [0.00868966107678934, 0.004150999005211765, 0.0049322758242629034]
-      renderView1.CameraViewUp = [0.3542102656908786, 0.9252429122682538, 0.135869941401907]
-      renderView1.CameraParallelScale = 0.00787069031419879
+      renderView1.CameraPosition = [0.009999999776482582, 0.004999999888241291, 0.04819751509880177]
+      renderView1.CameraFocalPoint = [0.009999999776482582, 0.004999999888241291, 0.004999999888241291]
+      renderView1.CameraParallelScale = 0.011180339637598877
       renderView1.CameraParallelProjection = 1
-      renderView1.Background = [0.32, 0.34, 0.43]
+      renderView1.Background = [0, 0, 0]
 
       # init the 'GridAxes3DActor' selected for 'AxesGrid'
       renderView1.AxesGrid.XTitleFontFile = ''
@@ -50,7 +51,7 @@ def CreateCoProcessor():
       # and provide it with information such as the filename to use,
       # how frequently to write the images, etc.
       coprocessor.RegisterView(renderView1,
-          filename='insitu/image_%t.png', freq=1, fittoscreen=0, magnification=1, width=1077, height=763, cinema={})
+          filename='press_%t.png', freq=1, fittoscreen=0, magnification=1, width=1091, height=766, cinema={})
       renderView1.ViewTime = datadescription.GetTime()
 
       # ----------------------------------------------------------------
@@ -62,89 +63,101 @@ def CreateCoProcessor():
       # setup the data processing pipelines
       # ----------------------------------------------------------------
 
-      # a producer from a simulation input
-      input1 = coprocessor.CreateProducer(datadescription, 'mesh')
+      # create a new 'XML MultiBlock Data Reader'
+      # create a producer from a simulation input
+      regionmesh = coprocessor.CreateProducer(datadescription, 'region/mesh')
+
+      # create a new 'Slice'
+      slice1 = Slice(Input=regionmesh)
+      slice1.SliceType = 'Plane'
+      slice1.SliceOffsetValues = [0.0]
 
-      # cellMask [0,1]
-      threshold1 = Threshold(Input=input1)
-      threshold1.Scalars = ['CELLS', 'cellMask']
-      threshold1.ThresholdRange = [0.9, 1.1]
+      # init the 'Plane' selected for 'SliceType'
+      slice1.SliceType.Origin = [0.01, 0.005, 0.005]
+      slice1.SliceType.Normal = [0.0, 0.0, 1.0]
 
       # ----------------------------------------------------------------
       # setup the visualization in view 'renderView1'
       # ----------------------------------------------------------------
 
-      # show data from threshold1
-      threshold1Display = Show(threshold1, renderView1)
-
-      # get color transfer function/color map for 'cellTypes'
-      cellTypesLUT = GetColorTransferFunction('cellTypes')
-      cellTypesLUT.RGBPoints = [0.0, 0.231373, 0.298039, 0.752941, 1.000244140625, 0.865003, 0.865003, 0.865003, 2.00048828125, 0.705882, 0.0156863, 0.14902]
-      cellTypesLUT.ScalarRangeInitialized = 1.0
+      # show data from slice1
+      slice1Display = Show(slice1, renderView1)
 
-      # get opacity transfer function/opacity map for 'cellTypes'
-      cellTypesPWF = GetOpacityTransferFunction('cellTypes')
-      cellTypesPWF.Points = [0.0, 0.0, 0.5, 0.0, 2.00048828125, 1.0, 0.5, 0.0]
-      cellTypesPWF.ScalarRangeInitialized = 1
+      # get color transfer function/color map for 'p'
+      pLUT = GetColorTransferFunction('p')
+      pLUT.RGBPoints = [-0.2227432131767273, 0.231373, 0.298039, 0.752941, 0.0011433586478233337, 0.865003, 0.865003, 0.865003, 0.22502993047237396, 0.705882, 0.0156863, 0.14902]
+      pLUT.ScalarRangeInitialized = 1.0
 
       # trace defaults for the display properties.
-      threshold1Display.Representation = 'Surface With Edges'
-      threshold1Display.ColorArrayName = ['CELLS', 'cellTypes']
-      threshold1Display.LookupTable = cellTypesLUT
-      threshold1Display.OSPRayScaleArray = 'U'
-      threshold1Display.OSPRayScaleFunction = 'PiecewiseFunction'
-      threshold1Display.SelectOrientationVectors = 'None'
-      threshold1Display.ScaleFactor = 0.0019999999552965165
-      threshold1Display.SelectScaleArray = 'None'
-      threshold1Display.GlyphType = 'Arrow'
-      threshold1Display.GlyphTableIndexArray = 'None'
-      threshold1Display.GaussianRadius = 9.999999776482583e-05
-      threshold1Display.SetScaleArray = ['POINTS', 'U']
-      threshold1Display.ScaleTransferFunction = 'PiecewiseFunction'
-      threshold1Display.OpacityArray = ['POINTS', 'U']
-      threshold1Display.OpacityTransferFunction = 'PiecewiseFunction'
-      threshold1Display.DataAxesGrid = 'GridAxesRepresentation'
-      threshold1Display.SelectionCellLabelFontFile = ''
-      threshold1Display.SelectionPointLabelFontFile = ''
-      threshold1Display.PolarAxes = 'PolarAxesRepresentation'
-      threshold1Display.ScalarOpacityFunction = cellTypesPWF
-      threshold1Display.ScalarOpacityUnitDistance = 0.0017065741933059136
+      slice1Display.Representation = 'Surface'
+      slice1Display.ColorArrayName = ['POINTS', 'p']
+      slice1Display.LookupTable = pLUT
+      slice1Display.OSPRayScaleArray = 'U'
+      slice1Display.OSPRayScaleFunction = 'PiecewiseFunction'
+      slice1Display.SelectOrientationVectors = 'None'
+      slice1Display.ScaleFactor = 0.0019999999552965165
+      slice1Display.SelectScaleArray = 'None'
+      slice1Display.GlyphType = 'Arrow'
+      slice1Display.GlyphTableIndexArray = 'None'
+      slice1Display.GaussianRadius = 9.999999776482583e-05
+      slice1Display.SetScaleArray = ['POINTS', 'U']
+      slice1Display.ScaleTransferFunction = 'PiecewiseFunction'
+      slice1Display.OpacityArray = ['POINTS', 'U']
+      slice1Display.OpacityTransferFunction = 'PiecewiseFunction'
+      slice1Display.DataAxesGrid = 'GridAxesRepresentation'
+      slice1Display.SelectionCellLabelFontFile = ''
+      slice1Display.SelectionPointLabelFontFile = ''
+      slice1Display.PolarAxes = 'PolarAxesRepresentation'
 
       # init the 'PiecewiseFunction' selected for 'ScaleTransferFunction'
-      threshold1Display.ScaleTransferFunction.Points = [-0.2505497634410858, 0.0, 0.5, 0.0, 0.3270378112792969, 1.0, 0.5, 0.0]
+      slice1Display.ScaleTransferFunction.Points = [-0.2436095029115677, 0.0, 0.5, 0.0, 0.2753259241580963, 1.0, 0.5, 0.0]
 
       # init the 'PiecewiseFunction' selected for 'OpacityTransferFunction'
-      threshold1Display.OpacityTransferFunction.Points = [-0.2505497634410858, 0.0, 0.5, 0.0, 0.3270378112792969, 1.0, 0.5, 0.0]
+      slice1Display.OpacityTransferFunction.Points = [-0.2436095029115677, 0.0, 0.5, 0.0, 0.2753259241580963, 1.0, 0.5, 0.0]
 
       # init the 'GridAxesRepresentation' selected for 'DataAxesGrid'
-      threshold1Display.DataAxesGrid.XTitleFontFile = ''
-      threshold1Display.DataAxesGrid.YTitleFontFile = ''
-      threshold1Display.DataAxesGrid.ZTitleFontFile = ''
-      threshold1Display.DataAxesGrid.XLabelFontFile = ''
-      threshold1Display.DataAxesGrid.YLabelFontFile = ''
-      threshold1Display.DataAxesGrid.ZLabelFontFile = ''
+      slice1Display.DataAxesGrid.XTitleFontFile = ''
+      slice1Display.DataAxesGrid.YTitleFontFile = ''
+      slice1Display.DataAxesGrid.ZTitleFontFile = ''
+      slice1Display.DataAxesGrid.XLabelFontFile = ''
+      slice1Display.DataAxesGrid.YLabelFontFile = ''
+      slice1Display.DataAxesGrid.ZLabelFontFile = ''
 
       # init the 'PolarAxesRepresentation' selected for 'PolarAxes'
-      threshold1Display.PolarAxes.PolarAxisTitleFontFile = ''
-      threshold1Display.PolarAxes.PolarAxisLabelFontFile = ''
-      threshold1Display.PolarAxes.LastRadialAxisTextFontFile = ''
-      threshold1Display.PolarAxes.SecondaryRadialAxesTextFontFile = ''
+      slice1Display.PolarAxes.PolarAxisTitleFontFile = ''
+      slice1Display.PolarAxes.PolarAxisLabelFontFile = ''
+      slice1Display.PolarAxes.LastRadialAxisTextFontFile = ''
+      slice1Display.PolarAxes.SecondaryRadialAxesTextFontFile = ''
 
       # setup the color legend parameters for each legend in this view
 
-      # get color legend/bar for cellTypesLUT in view renderView1
-      cellTypesLUTColorBar = GetScalarBar(cellTypesLUT, renderView1)
-      cellTypesLUTColorBar.Title = 'cellTypes'
-      cellTypesLUTColorBar.ComponentTitle = ''
-      cellTypesLUTColorBar.TitleFontFile = ''
-      cellTypesLUTColorBar.LabelFontFile = ''
+      # get color legend/bar for pLUT in view renderView1
+      pLUTColorBar = GetScalarBar(pLUT, renderView1)
+      pLUTColorBar.Title = 'p'
+      pLUTColorBar.ComponentTitle = ''
+      pLUTColorBar.TitleFontFile = ''
+      pLUTColorBar.LabelFontFile = ''
 
       # set color bar visibility
-      cellTypesLUTColorBar.Visibility = 1
+      pLUTColorBar.Visibility = 1
 
       # show color legend
-      threshold1Display.SetScalarBarVisibility(renderView1, True)
+      slice1Display.SetScalarBarVisibility(renderView1, True)
 
+      # ----------------------------------------------------------------
+      # setup color maps and opacity mapes used in the visualization
+      # note: the Get..() functions create a new object, if needed
+      # ----------------------------------------------------------------
+
+      # get opacity transfer function/opacity map for 'p'
+      pPWF = GetOpacityTransferFunction('p')
+      pPWF.Points = [-0.2227432131767273, 0.0, 0.5, 0.0, 0.22502993047237396, 1.0, 0.5, 0.0]
+      pPWF.ScalarRangeInitialized = 1
+
+      # ----------------------------------------------------------------
+      # finally, restore active source
+      SetActiveSource(slice1)
+      # ----------------------------------------------------------------
     return Pipeline()
 
   class CoProcessor(coprocessing.CoProcessor):