---
# System prepended metadata

title: Issues for meeting with Kitware Europe

---

# Issues for meeting with Kitware Europe

### Catalyst Live issues

* Catalyst Live data transferral can be buggy.
* Here's a video demonstrating the problem:
    <iframe src="https://drive.google.com/file/d/1F1B8uTn-jboujSMQKVUGIj-nTsaZ7k60/preview" width="800" height="450
    " allow="autoplay">
    </iframe>
* This simulation was running on 3 dual-socket Icelake (Intel Xeon Platinum 8368Q) nodes each with 76 cores.
* The Catalyst Live connection was established over an SSH reverse tunnel using a command of the form
    ```
    ssh -R 22222:localhost:22222 <login node hostname> ssh -4 -NR 22222:localhost:22222 <first compute node hostname>
    ```
* This is the corresponding Catalyst Script:
    <details>
    <summary>Expand to show script</summary>
    
    ```python
    # script-version: 2.0
    # Catalyst state generated using paraview version 5.10.1

    #### import the simple module from the paraview
    from paraview.simple import *
    #### disable automatic camera reset on 'Show'
    paraview.simple._DisableFirstRenderCameraReset()

    # ----------------------------------------------------------------
    # setup views used in the visualization
    # ----------------------------------------------------------------

    # get the material library
    materialLibrary1 = GetMaterialLibrary()

    # Create a new 'Render View'
    renderView1 = CreateView('RenderView')
    renderView1.ViewSize = [1550, 756]
    renderView1.AxesGrid = 'GridAxes3DActor'
    renderView1.OrientationAxesVisibility = 0
    renderView1.CenterOfRotation = [384.0, 384.0, 192.0]
    renderView1.StereoType = 'Crystal Eyes'
    renderView1.CameraPosition = [368.43166445708823, 406.5118351276443, -30.50584837642911]
    renderView1.CameraFocalPoint = [435.1477552986111, 304.91901777873375, 111.25568228625204]
    renderView1.CameraViewUp = [0.282720122141052, -0.711694107763238, -0.6430869533054121]
    renderView1.CameraFocalDisk = 1.0
    renderView1.CameraParallelScale = 576.0
    renderView1.UseColorPaletteForBackground = 0
    renderView1.Background = [0.0, 0.0, 0.0]
    renderView1.EnableRayTracing = 1
    renderView1.BackEnd = 'OSPRay raycaster'
    renderView1.SamplesPerPixel = 3
    renderView1.LightScale = 2.0
    renderView1.OSPRayMaterialLibrary = materialLibrary1

    SetActiveView(None)

    # ----------------------------------------------------------------
    # setup view layouts
    # ----------------------------------------------------------------

    # create new layout object 'Layout #1'
    layout1 = CreateLayout(name='Layout #1')
    layout1.AssignView(0, renderView1)
    layout1.SetSize(1550, 756)

    # ----------------------------------------------------------------
    # restore active view
    SetActiveView(renderView1)
    # ----------------------------------------------------------------

    # ----------------------------------------------------------------
    # setup the data processing pipelines
    # ----------------------------------------------------------------

    # create a new 'VisItChomboReader'
    input = VisItChomboReader(registrationName='input', FileName=['/home/mr618/rds/rds-intel-vis-0hKvbqKpczQ/mr618/BinaryBH/CatalystTests/q2-insitu-off/hdf5/BinaryBHp_002600.3d.hdf5'])
    input.MeshStatus = ['Mesh']
    input.CellArrayStatus = ['Weyl4_Im', 'chi']

    # create a new 'Resample To Image'
    resampleToImage1 = ResampleToImage(registrationName='ResampleToImage1', Input=input)
    resampleToImage1.UseInputBounds = 0
    resampleToImage1.SamplingDimensions = [128, 128, 64]
    resampleToImage1.SamplingBounds = [352.0, 416.0, 352.0, 416.0, 0.0, 32.0]

    # create a new 'Cell Data to Point Data'
    cellDatatoPointData1 = CellDatatoPointData(registrationName='CellDatatoPointData1', Input=input)
    cellDatatoPointData1.ProcessAllArrays = 0
    cellDatatoPointData1.CellDataArraytoprocess = ['chi']

    # create a new 'Contour'
    contour1 = Contour(registrationName='Contour1', Input=cellDatatoPointData1)
    contour1.ContourBy = ['POINTS', 'chi']
    contour1.Isosurfaces = [0.25]
    contour1.PointMergeMethod = 'Uniform Binning'

    # create a new 'Reflect'
    reflect1 = Reflect(registrationName='Reflect1', Input=contour1)
    reflect1.Plane = 'Z Min'

    # ----------------------------------------------------------------
    # setup the visualization in view 'renderView1'
    # ----------------------------------------------------------------

    # show data from resampleToImage1
    resampleToImage1Display = Show(resampleToImage1, renderView1, 'UniformGridRepresentation')

    # get color transfer function/color map for 'Weyl4_Im'
    weyl4_ImLUT = GetColorTransferFunction('Weyl4_Im')
    weyl4_ImLUT.AutomaticRescaleRangeMode = 'Never'
    weyl4_ImLUT.RGBPoints = [-0.005, 0.0862745098039216, 0.00392156862745098, 0.298039215686275, -0.0046966577452812325, 0.113725, 0.0235294, 0.45098, -0.004444730053423569, 0.105882, 0.0509804, 0.509804, -0.0042699227375599304, 0.0392157, 0.0392157, 0.560784, -0.004100256624195534, 0.0313725, 0.0980392, 0.6, -0.003935732297956627, 0.0431373, 0.164706, 0.639216, -0.003699228798222999, 0.054902, 0.243137, 0.678431, -0.003385603753243035, 0.054902, 0.317647, 0.709804, -0.0030000000000000157, 0.0509804, 0.396078, 0.741176, -0.0027500000000000137, 0.0392157, 0.466667, 0.768627, -0.002500000000000012, 0.0313725, 0.537255, 0.788235, -0.0022390740874437434, 0.0313725, 0.615686, 0.811765, -0.001971722203462074, 0.0235294, 0.709804, 0.831373, -0.0017043697348541878, 0.0509804, 0.8, 0.85098, -0.0014832904272445951, 0.0705882, 0.854902, 0.870588, -0.0012776347271328853, 0.262745, 0.901961, 0.862745, -0.0010976862087699428, 0.423529, 0.941176, 0.87451, -0.000820051335163479, 0.572549, 0.964706, 0.835294, -0.0006349610296750774, 0.658824, 0.980392, 0.843137, -0.0005012850876842416, 0.764706, 0.980392, 0.866667, -0.00035732644838172133, 0.827451, 0.980392, 0.886275, -7.455007996290657e-05, 0.913725, 0.988235, 0.937255, 1.285357796892636e-05, 1.0, 1.0, 0.972549019607843, 0.00010025723590076276, 0.988235, 0.980392, 0.870588, 0.00022879197539229287, 0.992156862745098, 0.972549019607843, 0.803921568627451, 0.00032647833063581284, 0.992157, 0.964706, 0.713725, 0.0004910026568747203, 0.988235, 0.956863, 0.643137, 0.0007532133383571157, 0.980392, 0.917647, 0.509804, 0.0009742932305928939, 0.968627, 0.87451, 0.407843, 0.0012005143253279458, 0.94902, 0.823529, 0.321569, 0.0013650386515668455, 0.929412, 0.776471, 0.278431, 0.00160668393842593, 0.909804, 0.717647, 0.235294, 0.0018226220435362366, 0.890196, 0.658824, 0.196078, 0.0019999999999999983, 0.878431, 0.619608, 0.168627, 0.002249999999999997, 0.870588, 0.54902, 0.156863, 0.0024999999999999988, 0.85098, 0.47451, 0.145098, 0.002749999999999998, 0.831373, 0.411765, 0.133333, 0.003, 0.811765, 0.345098, 0.113725, 0.003250000000000002, 0.788235, 0.266667, 0.0941176, 0.0035000000000000005, 0.741176, 0.184314, 0.0745098, 0.0037500000000000007, 0.690196, 0.12549, 0.0627451, 0.003999999999999999, 0.619608, 0.0627451, 0.0431373, 0.0042339331798103225, 0.54902, 0.027451, 0.0705882, 0.0044395887063611575, 0.470588, 0.0156863, 0.0901961, 0.0046709511588868225, 0.4, 0.00392157, 0.101961, 0.005, 0.188235294117647, 0.0, 0.0705882352941176]
    weyl4_ImLUT.ColorSpace = 'Lab'
    weyl4_ImLUT.ScalarRangeInitialized = 1.0

    # get opacity transfer function/opacity map for 'Weyl4_Im'
    weyl4_ImPWF = GetOpacityTransferFunction('Weyl4_Im')
    weyl4_ImPWF.Points = [-0.005, 0.0, 0.5, 0.0, -0.004499999994412064, 0.04374999925494194, 0.5, 0.0, -0.0029999999776482576, 0.4437499940395355, 0.5, 0.0, -0.002499999972060323, 0.5, 0.5, 0.0, -0.001999999966472387, 0.4437499940395355, 0.5, 0.0, -0.0004999999497085801, 0.04374999925494194, 0.5, 0.0, -1.395528727299311e-10, 0.0, 0.5, 0.0, 0.0005000000614672892, 0.04374999925494194, 0.5, 0.0, 0.002000000078231097, 0.4437499940395355, 0.5, 0.0, 0.002500000083819032, 0.5, 0.5, 0.0, 0.0030000000894069697, 0.4437499940395355, 0.5, 0.0, 0.004500000106170773, 0.04374999925494194, 0.5, 0.0, 0.005, 0.0, 0.5, 0.0]
    weyl4_ImPWF.ScalarRangeInitialized = 1

    # trace defaults for the display properties.
    resampleToImage1Display.Representation = 'Volume'
    resampleToImage1Display.ColorArrayName = ['POINTS', 'Weyl4_Im']
    resampleToImage1Display.LookupTable = weyl4_ImLUT
    resampleToImage1Display.SelectTCoordArray = 'None'
    resampleToImage1Display.SelectNormalArray = 'None'
    resampleToImage1Display.SelectTangentArray = 'None'
    resampleToImage1Display.OSPRayScaleArray = 'Weyl4_Im'
    resampleToImage1Display.OSPRayScaleFunction = 'PiecewiseFunction'
    resampleToImage1Display.SelectOrientationVectors = 'None'
    resampleToImage1Display.ScaleFactor = 6.4
    resampleToImage1Display.SelectScaleArray = 'None'
    resampleToImage1Display.GlyphType = 'Arrow'
    resampleToImage1Display.GlyphTableIndexArray = 'None'
    resampleToImage1Display.GaussianRadius = 0.32
    resampleToImage1Display.SetScaleArray = ['POINTS', 'Weyl4_Im']
    resampleToImage1Display.ScaleTransferFunction = 'PiecewiseFunction'
    resampleToImage1Display.OpacityArray = ['POINTS', 'Weyl4_Im']
    resampleToImage1Display.OpacityTransferFunction = 'PiecewiseFunction'
    resampleToImage1Display.DataAxesGrid = 'GridAxesRepresentation'
    resampleToImage1Display.PolarAxes = 'PolarAxesRepresentation'
    resampleToImage1Display.ScalarOpacityUnitDistance = 0.9548941570397576
    resampleToImage1Display.ScalarOpacityFunction = weyl4_ImPWF
    resampleToImage1Display.OpacityArrayName = ['POINTS', 'Weyl4_Im']
    resampleToImage1Display.SliceFunction = 'Plane'
    resampleToImage1Display.Slice = 31

    # init the 'PiecewiseFunction' selected for 'ScaleTransferFunction'
    resampleToImage1Display.ScaleTransferFunction.Points = [-0.37763184487493023, 0.0, 0.5, 0.0, 0.3302112550616481, 1.0, 0.5, 0.0]

    # init the 'PiecewiseFunction' selected for 'OpacityTransferFunction'
    resampleToImage1Display.OpacityTransferFunction.Points = [-0.37763184487493023, 0.0, 0.5, 0.0, 0.3302112550616481, 1.0, 0.5, 0.0]

    # init the 'Plane' selected for 'SliceFunction'
    resampleToImage1Display.SliceFunction.Origin = [384.0, 384.0, 16.0]

    # show data from reflect1
    reflect1Display = Show(reflect1, renderView1, 'UnstructuredGridRepresentation')

    # trace defaults for the display properties.
    reflect1Display.Representation = 'Surface'
    reflect1Display.ColorArrayName = ['POINTS', '']
    reflect1Display.SelectTCoordArray = 'None'
    reflect1Display.SelectNormalArray = 'Normals'
    reflect1Display.SelectTangentArray = 'None'
    reflect1Display.OSPRayScaleArray = 'chi'
    reflect1Display.OSPRayScaleFunction = 'PiecewiseFunction'
    reflect1Display.SelectOrientationVectors = 'None'
    reflect1Display.ScaleFactor = 0.8465576171875
    reflect1Display.SelectScaleArray = 'chi'
    reflect1Display.GlyphType = 'Arrow'
    reflect1Display.GlyphTableIndexArray = 'chi'
    reflect1Display.GaussianRadius = 0.042327880859375
    reflect1Display.SetScaleArray = ['POINTS', 'chi']
    reflect1Display.ScaleTransferFunction = 'PiecewiseFunction'
    reflect1Display.OpacityArray = ['POINTS', 'chi']
    reflect1Display.OpacityTransferFunction = 'PiecewiseFunction'
    reflect1Display.DataAxesGrid = 'GridAxesRepresentation'
    reflect1Display.PolarAxes = 'PolarAxesRepresentation'
    reflect1Display.ScalarOpacityUnitDistance = 0.20243562652610303
    reflect1Display.OpacityArrayName = ['POINTS', 'chi']

    # init the 'PiecewiseFunction' selected for 'ScaleTransferFunction'
    reflect1Display.ScaleTransferFunction.Points = [0.25, 0.0, 0.5, 0.0, 0.25006103515625, 1.0, 0.5, 0.0]

    # init the 'PiecewiseFunction' selected for 'OpacityTransferFunction'
    reflect1Display.OpacityTransferFunction.Points = [0.25, 0.0, 0.5, 0.0, 0.25006103515625, 1.0, 0.5, 0.0]

    # ----------------------------------------------------------------
    # setup color maps and opacity mapes used in the visualization
    # note: the Get..() functions create a new object, if needed
    # ----------------------------------------------------------------

    # ----------------------------------------------------------------
    # setup extractors
    # ----------------------------------------------------------------

    # create extractor
    pNG1 = CreateExtractor('PNG', renderView1, registrationName='PNG1')
    # trace defaults for the extractor.
    pNG1.Enable = 0
    pNG1.Trigger = 'TimeStep'

    # init the 'PNG' selected for 'Writer'
    pNG1.Writer.FileName = 'ChiContour_GWs_{timestep:06d}{camera}.png'
    pNG1.Writer.ImageResolution = [1920, 1080]
    pNG1.Writer.Format = 'PNG'

    # ----------------------------------------------------------------
    # restore active source
    SetActiveSource(reflect1)
    # ----------------------------------------------------------------

    # ------------------------------------------------------------------------------
    # Catalyst options
    from paraview import catalyst
    options = catalyst.Options()
    options.GlobalTrigger = 'TimeStep'
    options.EnableCatalystLive = 1
    options.CatalystLiveTrigger = 'TimeStep'

    # ------------------------------------------------------------------------------
    if __name__ == '__main__':
        from paraview.simple import SaveExtractsUsingCatalystOptions
        # Code for non in-situ environments; if executing in post-processing
        # i.e. non-Catalyst mode, let's generate extracts using Catalyst options
        SaveExtractsUsingCatalystOptions(options)
    ```
    
</details>

* Unlike other issues I've found with ParaView, I haven't been able to create a simple reproducer (e.g. with one of the Catalyst examples in the ParaView repository).

### Passing arguments to Catalyst scripts

* It would be really helpful to be able to pass arguments or parameters to Catalyst Python scripts.
* My Catalyst adaptor is Catalyst1 (but Catalyst scripts are mostly V2).
* I posted on the [ParaView Discourse forums](https://discourse.paraview.org/t/passing-parameters-to-catalyst-pipeline-script/8931/2) and Utkarsh Ayachit replied saying it is possible with Catalyst2 but the only workaround for Catalyst1 is to use environment variables which is not ideal.
* Example use case: I want to create a "canned" Catalyst script that can take a slice through the "centre" of the grid for all sizes of grid in the code without a simulation user having to edit the script. Depending on the reflective symmetries chosen in the code, the "centre" might not be the same as the centre of the computational domain (so can't just take the centre of the `vtkOverlappingAMR` object in the Python script).

### OSPRay Module MPI distributed mode.

* We've been working with Intel (Dave Demarle and Carson Brownlee in particular) to improve support for MPI-distributed AMR datasets with OSPRay's "mpiDistributed" mode.
* Currently our modifications (see Dave Demarle's [VTK](https://gitlab.kitware.com/demarle/vtk/-/tree/catalyst_wombat_volrend_2)/[ParaView](https://gitlab.kitware.com/demarle/paraview/-/tree/catalyst_wombat_volrend_2) branches) rely on building without IceT enabled (i.e. by passing `-DVTK_MODULE_ENABLE_ParaView_icet=NO` to CMake).
* It would be great if Kitware would be able to support Dave/Carson in devloping an interface to expose the choice of parallel compositor to use (i.e. IceT or OSPRay mpiDistributed).