diff --git a/002-Methods/003-Visualization/001-InSitu/001-Catalyst/.gitignore b/002-Methods/003-Visualization/001-InSitu/001-Catalyst/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..0b4378c4e6ec7ca7774362234933e31298e53299
--- /dev/null
+++ b/002-Methods/003-Visualization/001-InSitu/001-Catalyst/.gitignore
@@ -0,0 +1,6 @@
+.ipynb_checkpoints/*
+CatalystEnabledSimulation/.ipynb_checkpoints/*
+CatalystEnabledSimulation/__pycache__/
+
+fullgrid*
+slice*
diff --git a/002-Methods/003-Visualization/001-InSitu/001-Catalyst/CatalystEnabledSimulation/README.md b/002-Methods/003-Visualization/001-InSitu/001-Catalyst/CatalystEnabledSimulation/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..b4b71e3131ed4805d55f870960951cec57c4a09e
--- /dev/null
+++ b/002-Methods/003-Visualization/001-InSitu/001-Catalyst/CatalystEnabledSimulation/README.md
@@ -0,0 +1,2 @@
+This example is based on https://github.com/Kitware/ParaView/tree/v5.8.0/Examples/Catalyst/PythonFullExample
+with only small changes to their code.
\ No newline at end of file
diff --git a/002-Methods/003-Visualization/001-InSitu/001-Catalyst/CatalystEnabledSimulation/coprocessor.py b/002-Methods/003-Visualization/001-InSitu/001-Catalyst/CatalystEnabledSimulation/coprocessor.py
new file mode 100644
index 0000000000000000000000000000000000000000..c8c5d0719c8c1187ed60eae8bf5b77a43150707c
--- /dev/null
+++ b/002-Methods/003-Visualization/001-InSitu/001-Catalyst/CatalystEnabledSimulation/coprocessor.py
@@ -0,0 +1,88 @@
+coProcessor = None
+
+def initialize():
+ global coProcessor
+ import paraview
+ from vtk import vtkParallelCore
+ import paraview.servermanager as pvsm
+ import vtk
+ from mpi4py import MPI
+ import os, sys
+
+ paraview.options.batch = True
+ paraview.options.symmetric = True
+ from paraview.modules import vtkRemotingServerManager as CorePython
+ from paraview.modules.vtkRemotingApplication import vtkInitializationHelper
+
+ if not pvsm.vtkProcessModule.GetProcessModule():
+ pvoptions = None
+ if paraview.options.batch:
+ pvoptions = CorePython.vtkPVOptions();
+ pvoptions.SetProcessType(CorePython.vtkPVOptions.PVBATCH)
+ if paraview.options.symmetric:
+ pvoptions.SetSymmetricMPIMode(True)
+ vtkInitializationHelper.Initialize(sys.executable, pvsm.vtkProcessModule.PROCESS_BATCH, pvoptions)
+
+
+ # we need ParaView 4.2 since ParaView 4.1 doesn't properly wrap
+ # vtkPVPythonCatalyst
+ if pvsm.vtkSMProxyManager.GetVersionMajor() < 4 or (pvsm.vtkSMProxyManager.GetVersionMajor() == 4 and pvsm.vtkSMProxyManager.GetVersionMinor() < 2):
+ print('Must use ParaView v4.2 or greater')
+ sys.exit(0)
+
+ import numpy
+ from paraview.modules import vtkPVCatalyst as catalyst
+ from paraview.modules import vtkPVPythonCatalyst as pythoncatalyst
+ import paraview.simple
+ import paraview.vtk as vtk
+ from paraview.vtk.util import numpy_support
+ paraview.options.batch = True
+ paraview.options.symmetric = True
+
+ coProcessor = catalyst.vtkCPProcessor()
+ pm = paraview.servermanager.vtkProcessModule.GetProcessModule()
+ from mpi4py import MPI
+
+def finalize():
+ global coProcessor
+ coProcessor.Finalize()
+ # if we are running through Python we need to finalize extra stuff
+ # to avoid memory leak messages.
+ import sys, ntpath
+ if ntpath.basename(sys.executable) == 'python':
+ from paraview.modules.vtkRemotingApplication import vtkInitializationHelper
+ vtkInitializationHelper.Finalize()
+
+def addscript(name):
+ global coProcessor
+ from paraview.modules import vtkPVPythonCatalyst as pythoncatalyst
+ pipeline = pythoncatalyst.vtkCPPythonScriptPipeline()
+ pipeline.Initialize(name)
+ coProcessor.AddPipeline(pipeline)
+
+def coprocess(time, timeStep, grid, attributes):
+ global coProcessor
+ import vtk
+ from paraview.modules import vtkPVCatalyst as catalyst
+ import paraview
+ from paraview.vtk.util import numpy_support
+ dataDescription = catalyst.vtkCPDataDescription()
+ dataDescription.SetTimeData(time, timeStep)
+ dataDescription.AddInput("input")
+
+ if coProcessor.RequestDataDescription(dataDescription):
+ import fedatastructures
+ imageData = vtk.vtkImageData()
+ imageData.SetExtent(grid.XStartPoint, grid.XEndPoint, 0, grid.NumberOfYPoints-1, 0, grid.NumberOfZPoints-1)
+ imageData.SetSpacing(grid.Spacing)
+
+ velocity = numpy_support.numpy_to_vtk(attributes.Velocity)
+ velocity.SetName("velocity")
+ imageData.GetPointData().AddArray(velocity)
+
+ pressure = numpy_support.numpy_to_vtk(attributes.Pressure)
+ pressure.SetName("pressure")
+ imageData.GetCellData().AddArray(pressure)
+ dataDescription.GetInputDescriptionByName("input").SetGrid(imageData)
+ dataDescription.GetInputDescriptionByName("input").SetWholeExtent(0, grid.NumberOfGlobalXPoints-1, 0, grid.NumberOfYPoints-1, 0, grid.NumberOfZPoints-1)
+ coProcessor.CoProcess(dataDescription)
diff --git a/002-Methods/003-Visualization/001-InSitu/001-Catalyst/CatalystEnabledSimulation/cpscript.py b/002-Methods/003-Visualization/001-InSitu/001-Catalyst/CatalystEnabledSimulation/cpscript.py
new file mode 100644
index 0000000000000000000000000000000000000000..b115bf4b155132e389551358d1f14c9038039337
--- /dev/null
+++ b/002-Methods/003-Visualization/001-InSitu/001-Catalyst/CatalystEnabledSimulation/cpscript.py
@@ -0,0 +1,93 @@
+from paraview.simple import *
+from paraview import coprocessing
+
+#--------------------------------------------------------------
+# Code generated from cpstate.py to create the CoProcessor.
+
+
+# ----------------------- CoProcessor definition -----------------------
+
+def CreateCoProcessor():
+ def _CreatePipeline(coprocessor, datadescription):
+ class Pipeline:
+ filename_6_pvti = coprocessor.CreateProducer( datadescription, "input" )
+
+ # create a new 'Parallel ImageData Writer'
+ imageDataWriter1 = servermanager.writers.XMLPImageDataWriter(Input=filename_6_pvti)
+
+ # register the writer with coprocessor
+ # and provide it with information such as the filename to use,
+ # how frequently to write the data, etc.
+ coprocessor.RegisterWriter(imageDataWriter1, filename="fullgrid_%t.pvti", freq=10000)
+
+ Slice1 = Slice( Input=filename_6_pvti, guiName="Slice1", Crinkleslice=0, SliceOffsetValues=[0.0], Triangulatetheslice=1, SliceType="Plane" )
+ Slice1.SliceType.Offset = 0.0
+ Slice1.SliceType.Origin = [9.0, 11.0, 9.0]
+ Slice1.SliceType.Normal = [1.0, 0.0, 0.0]
+
+ # create a new 'Parallel PolyData Writer'
+ parallelPolyDataWriter1 = servermanager.writers.XMLPPolyDataWriter(Input=Slice1)
+
+ # register the writer with coprocessor
+ # and provide it with information such as the filename to use,
+ # how frequently to write the data, etc.
+ coprocessor.RegisterWriter(parallelPolyDataWriter1, filename='slice_%t.pvtp', freq=1000)
+
+ return Pipeline()
+
+ class CoProcessor(coprocessing.CoProcessor):
+ def CreatePipeline(self, datadescription):
+ self.Pipeline = _CreatePipeline(self, datadescription)
+
+ coprocessor = CoProcessor()
+ freqs = {'input': [10, 100]}
+ coprocessor.SetUpdateFrequencies(freqs)
+ 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(True, 1)
+
+
+# ---------------------- Data Selection method ----------------------
+
+def RequestDataDescription(datadescription):
+ "Callback to populate the request for current timestep"
+ global coprocessor
+ if datadescription.GetForceOutput() == True:
+ # 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)
diff --git a/002-Methods/003-Visualization/001-InSitu/001-Catalyst/CatalystEnabledSimulation/fedatastructures.py b/002-Methods/003-Visualization/001-InSitu/001-Catalyst/CatalystEnabledSimulation/fedatastructures.py
new file mode 100644
index 0000000000000000000000000000000000000000..b4b2424dca04a236dfceb137373ab1fd035bdeae
--- /dev/null
+++ b/002-Methods/003-Visualization/001-InSitu/001-Catalyst/CatalystEnabledSimulation/fedatastructures.py
@@ -0,0 +1,44 @@
+import numpy
+
+class GridClass:
+ """
+ We are working with a uniform grid which will be
+ represented as a vtkImageData in Catalyst. It is partitioned
+ in the x-direction only.
+ """
+ def __init__(self, pointDimensions, spacing):
+ from mpi4py import MPI
+ comm = MPI.COMM_WORLD
+ rank = comm.Get_rank()
+ size = comm.Get_size()
+
+ self.XStartPoint = int(pointDimensions[0]*rank/size)
+ self.XEndPoint = int(pointDimensions[0]*(rank+1)/size)
+ if rank+1 != size:
+ self.XEndPoint += 1
+ else:
+ self.XEndPoint = pointDimensions[0]-1
+ self.NumberOfYPoints = pointDimensions[1]
+ self.NumberOfZPoints = pointDimensions[2]
+ self.NumberOfGlobalXPoints = pointDimensions[0]
+
+ self.PointDimensions = pointDimensions
+ self.Spacing = spacing
+
+ def GetNumberOfPoints(self):
+ return (self.XEndPoint-self.XStartPoint+1)*self.PointDimensions[1]*self.PointDimensions[2]
+
+ def GetNumberOfCells(self):
+ return (self.XEndPoint-self.XStartPoint)*(self.PointDimensions[1]-1)*(self.PointDimensions[2]-1)
+
+class AttributesClass:
+ """
+ We have velocity point data and pressure cell data.
+ """
+ def __init__(self, grid):
+ self.Grid = grid
+
+ def Update(self, time):
+ self.Velocity = numpy.zeros((self.Grid.GetNumberOfPoints(), 3))
+ self.Velocity = self.Velocity + time
+ self.Pressure = numpy.random.rand(self.Grid.GetNumberOfCells())
diff --git a/002-Methods/003-Visualization/001-InSitu/001-Catalyst/CatalystEnabledSimulation/fedriver.py b/002-Methods/003-Visualization/001-InSitu/001-Catalyst/CatalystEnabledSimulation/fedriver.py
new file mode 100644
index 0000000000000000000000000000000000000000..929628c4345fbb1fcc509ef03ab96006c71663a5
--- /dev/null
+++ b/002-Methods/003-Visualization/001-InSitu/001-Catalyst/CatalystEnabledSimulation/fedriver.py
@@ -0,0 +1,47 @@
+"""
+A simple example of a Python simulation code working with Catalyst.
+It depends on numpy and mpi4py being available. The environment
+variables need to be set up properly to find Catalyst when running directly
+from python. For Linux
+and Mac machines they should be:
+export LD_LIBRARY_PATH=${LD_LIBRARY_PATH}:<Catalyst build dir>/lib
+export PYTHONPATH=<Catalyst build dir>/lib:<Catalyst build dir>/lib/site-packages
+
+Alternatively, pvbatch or pvpython can be used which will automatically set up
+system paths for using Catalyst.
+
+When running, Catalyst scripts must be added in on the command line. For example:
+</path/to/pvpython> fedriver.py cpscript.py
+mpirun -np 4 </path/to/pvbatch> -sym fedriver.py cpscript.py
+"""
+from time import sleep
+
+import numpy
+import sys
+from mpi4py import MPI
+
+comm = MPI.COMM_WORLD
+rank = comm.Get_rank()
+
+import fedatastructures
+
+grid = fedatastructures.GridClass([10, 12, 10], [2, 2, 2])
+attributes = fedatastructures.AttributesClass(grid)
+doCoprocessing = True
+
+if doCoprocessing:
+ import coprocessor
+ coprocessor.initialize()
+ for i in sys.argv[1:]:
+ if rank == 0:
+ print('Using Catalyst script', i)
+ coprocessor.addscript(i)
+
+for i in range(10000):
+ sleep(0.5)
+ attributes.Update(i)
+ if doCoprocessing:
+ coprocessor.coprocess(i, i, grid, attributes)
+
+if doCoprocessing:
+ coprocessor.finalize()
diff --git a/002-Methods/003-Visualization/001-InSitu/001-Catalyst/Catalyst_Example.ipynb b/002-Methods/003-Visualization/001-InSitu/001-Catalyst/Catalyst_Example.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..772dc7f2fc4a045a8e0223e2770e684a234d1185
--- /dev/null
+++ b/002-Methods/003-Visualization/001-InSitu/001-Catalyst/Catalyst_Example.ipynb
@@ -0,0 +1,433 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Using Catalyst and ParaView in Jupyter Notebook"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "This is the full Version, a less complex example can be seen in [Catalyst_Example_minimal](Catalyst_Example_minimal.ipynb).\n",
+ "\n",
+ "This is setting up all components visible in the grafik below. Therefore giving you a notebook, that can issue ParaView commands to the pvserver, that is connected to a small sample simulation. The visualisation will be done in the notebook and is visible in your webbrowser.\n",
+ "\n",
+ "<img src=\"img/Communication.png\" width=\"400\">"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Table of contents\n",
+ "\n",
+ "- Start pvserver\n",
+ "- Start Catalyst enabled simulation\n",
+ "- Setup Render Window in Browser\n",
+ "- Show logging output in Jupyter notebook\n",
+ "- Establish Catalyst Connection\n",
+ "- Setup render pipeline using ParaView Python Commands\n",
+ "- Additional usefull functions for using Catalyst in Notebook"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Start pvserver\n",
+ "Here we will start the pvserver on the same node as the notebook. It is possible to start the pvserver somewhere else, but then that will have to be done outside the notebook. Or using slurm, but then it is not known when the pvserver will be started (and where)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "%%script bash --bg --proc server_process\n",
+ "export OMP_NUM_THREADS=1\n",
+ "pvserver --server-port=11223 > ${JUPYTER_LOG_DIR}/pvserver.log 2>&1"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Start Catalyst enabled simulation\n",
+ "Here a small sample simulation is started, that will run on the same node, and send random pressure data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "%%script bash --bg --proc catalyst_process\n",
+ "export OMP_NUM_THREADS=1\n",
+ "pvpython CatalystEnabledSimulation/fedriver.py CatalystEnabledSimulation/cpscript.py > ${JUPYTER_LOG_DIR}/simulation.log 2>&1"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Setup Render Window in Browser\n",
+ "- loading needed python modules\n",
+ "- Get URL to access this jupyter Lab\n",
+ "- Using pvlink connect with the websocket provided by ParaView. Here using a connection to a pvserver as well. Additional examples and info for pvlink can be found [here](https://gitlab.version.fz-juelich.de/jupyter4jsc/j4j_extras/pvlink/-/blob/master/examples/Examples.ipynb \"pvlink Examples\").\n",
+ "- displaying the render window in a box, to get control over the size of the render window"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from paraview import simple\n",
+ "from pvlink import RemoteRenderer\n",
+ "from ipywidgets import Box\n",
+ "from os import environ\n",
+ "\n",
+ "Jupyter_URL = \"jupyter-jsc.fz-juelich.de\" + environ.get('JUPYTERHUB_SERVICE_PREFIX', '/')\n",
+ "renderer = RemoteRenderer(pvserverHost=\"localhost\", pvserverPort = 11223, baseURL=Jupyter_URL, useJupyterServerProxyHttps=True, disableExternalPort=True)\n",
+ "\n",
+ "Box(children=[renderer], layout={\"height\": \"800px\"})"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Setup a view, that will be used by ParaView, setting up parameters for smooth rendering in this setup (forcing the use of the pvserver to render, and not the client)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from pvlink.utility import SetRecommendedRenderSettings, ResetCamera\n",
+ "\n",
+ "# Cerate a view\n",
+ "view = simple.FindViewOrCreate(\"test\", \"RenderView\")\n",
+ "SetRecommendedRenderSettings(view)\n",
+ "renderer.update_render()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Show logging output in Jupyter notebook\n",
+ "\n",
+ "Not all errors and warnings are visible in the notebook, by calling the ParaView functions. For example, opening a file, that is not avaiable (on the remote machine running pvserver), will not lead to an error on the call to the function. Only after the call to update/render the pipeline, accessing the file will be tried. An error/warning will then be noted in the log. In this example, we write logfiles for the simulation and pvserver, by simply redirecting their output into files. The output of the ParaView client can be enabled to write into a file using the following command. Afterwards we start a thread for each logfile we want to watch, that watches for changes and writes them as output to the last used Jupyter cell."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from paraview.servermanager import vtk\n",
+ "vtk.vtkLogger.LogToFile((environ.get('JUPYTER_LOG_DIR') + \"/paraview_client.log\"), vtk.vtkLogger.TRUNCATE, vtk.vtkLogger.VERBOSITY_WARNING) "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import tailer\n",
+ "from threading import Thread\n",
+ "\n",
+ "def tail(fileName, printPrefix=\"\"):\n",
+ " file = open(fileName, 'r')\n",
+ " for line in tailer.follow(file):\n",
+ " print(printPrefix + line)\n",
+ "\n",
+ "def tailInThread(fileName, printPrefix=\"\"):\n",
+ " thread = Thread(target=tail, kwargs=dict(fileName=str(fileName), printPrefix=str(printPrefix)))\n",
+ " thread.daemon=True\n",
+ " thread.start()\n",
+ "\n",
+ "tailInThread(environ.get('JUPYTER_LOG_DIR') + \"/pvserver.log\", \"pvserver: \")\n",
+ "tailInThread(environ.get('JUPYTER_LOG_DIR') + \"/paraview_client.log\", \"paraview client: \")\n",
+ "tailInThread(environ.get('JUPYTER_LOG_DIR') + \"/simulation.log\", \"simulation: \")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Establish Catalyst Connection\n",
+ "Create the Object handeling the connection, before extracting data from the Simulation. Waiting is necessary, Because extracting the data does not work, unless the simulation is connected and one update has been performed since updating"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "catalyst = simple.CatalystConnection()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# open port for catalyst connection\n",
+ "catalyst.Start()\n",
+ "catalyst.AddUpdateFunction(renderer.update_render)\n",
+ "catalyst.BlockTillConnected();"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# wait till simulation connected\n",
+ "catalyst.BlockTillConnected()\n",
+ "# extract data from simulation\n",
+ "# supplying a source name, that can be used to find the ParaView source.\n",
+ "# In case of different named input, or multiple input ports, alows to choose the desired input, that should be extracted\n",
+ "extract = catalyst.Extract(\"extract\")\n",
+ "# block till there is an update for the simulation data\n",
+ "catalyst.BlockTillNextUpdate()\n",
+ "# display simulation data\n",
+ "simple.SetActiveSource(extract)\n",
+ "extractDisplay = simple.Show(extract, view)\n",
+ "\n",
+ "#ResetCamera(view, renderer)\n",
+ "view.ResetCamera()\n",
+ "view.CenterOfRotation = view.GetActiveCamera().GetFocalPoint()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Connection has been established, and the simulation output is now visible above in the render window"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Setup render pipeline using ParaView Python Commands\n",
+ "To get the wished visualisation we need to setup the ParaView pipeline, to tell it what it is supposed to do with the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# set scalar coloring\n",
+ "simple.ColorBy(extractDisplay, (\"CELLS\", \"pressure\"))\n",
+ "\n",
+ "# rescale color and/or opacity maps used to include current data range\n",
+ "extractDisplay.RescaleTransferFunctionToDataRange(True, False)\n",
+ "\n",
+ "# show color bar/color legend\n",
+ "extractDisplay.SetScalarBarVisibility(view, True)\n",
+ "\n",
+ "# get color transfer function/color map for 'pressure'\n",
+ "pressureLUT = simple.GetColorTransferFunction(\"pressure\")\n",
+ "pressureLUT.RescaleTransferFunction(0.0, 1.0)\n",
+ "\n",
+ "# get opacity transfer function/opacity map for 'pressure'\n",
+ "pressurePWF = simple.GetOpacityTransferFunction(\"pressure\")\n",
+ "pressurePWF.RescaleTransferFunction(0.0, 1.0)\n",
+ "\n",
+ "# change representation type, for example wireframe or volume rendering\n",
+ "#extractDisplay.SetRepresentationType(\"Wireframe\")\n",
+ "extractDisplay.SetRepresentationType(\"Volume\");"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Additional usefull functions for using Catalyst in Notebook\n",
+ "it s possible to test for an establised connection yourself, allowing you to do other stuff while waiting for the connection, checking if it is still running..."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(catalyst.IsConnected())"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "see if the simulation is paused by catalyst right now"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(catalyst.IsPaused())"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Check the last time step the simulation transmitted"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(catalyst.GetTimeStep())"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Pause the simulation on the next time step.\n",
+ "To prevent accidential activation, you need to uncomment it before using it."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#catalyst.SetPauseSimulation(True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Let the simulation continue running\n",
+ "To prevent accidential activation, you need to uncomment it before using it."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#from time import sleep\n",
+ "#sleep(3)\n",
+ "#catalyst.SetPauseSimulation(False)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Pause the Simulation on specified time step\n",
+ "To prevent accidential activation, you need to uncomment it before using it."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#catalyst.BlockTillTimeStepAndPause(275)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "To see all sources that are supplied by the simulation to ParaView, call this function"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#print(catalyst.GetCatalystSources())"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Get help for one function, or see the list of all avaiable functions"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "catalyst.IsPaused?"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "help(catalyst)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "PyParaView-5.8",
+ "language": "python",
+ "name": "pyparaview-5.8"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.6.8"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/002-Methods/003-Visualization/001-InSitu/001-Catalyst/Catalyst_Example_minimal.ipynb b/002-Methods/003-Visualization/001-InSitu/001-Catalyst/Catalyst_Example_minimal.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..74eadb9d0e6e57201b66097931ef652c51de8cc5
--- /dev/null
+++ b/002-Methods/003-Visualization/001-InSitu/001-Catalyst/Catalyst_Example_minimal.ipynb
@@ -0,0 +1,218 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Using Catalyst and ParaView in Jupyter Notebook"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "This is the minimal Version, just shortly showing, what you need in any case. A complete example can be seen in [Catalyst_Example](Catalyst_Example.ipynb).\n",
+ "\n",
+ "This is setting up all components visible in the grafik below. Therefore giving you a notebook, that can use ParaView commands and is connected to a small sample simulation. The visualisation will be done in the notebook and is visible in your webbrowser.\n",
+ "\n",
+ "<img src=\"img/Communication_minimal.png\" width=\"400\">"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Table of contents\n",
+ "\n",
+ "- Start Catalyst enabled simulation\n",
+ "- Setup Render Window in Browser\n",
+ "- Establish Catalyst Connection\n",
+ "- Setup render pipeline using ParaView Python Commands"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Start Catalyst enabled simulation\n",
+ "Here a small sample simulation is started, that will run on the same node, and send random pressure data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "%%script bash --bg --proc catalyst_process\n",
+ "export OMP_NUM_THREADS=1\n",
+ "pvpython CatalystEnabledSimulation/fedriver.py CatalystEnabledSimulation/cpscript.py > ${JUPYTER_LOG_DIR}/simulation.log 2>&1"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Setup Render Window in Browser\n",
+ "- loading needed python modules\n",
+ "- Get URL to access this jupyter Lab\n",
+ "- Using pvlink connect with the websocket provided by ParaView. Additional examples and info for pvlink can be found [here](https://gitlab.version.fz-juelich.de/jupyter4jsc/j4j_extras/pvlink/-/blob/master/examples/Examples.ipynb \"pvlink Examples\").\n",
+ "- displaying the render window in a box, to get control over the size of the render window"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from paraview import simple\n",
+ "from pvlink import RemoteRenderer\n",
+ "from ipywidgets import Box\n",
+ "from os import environ\n",
+ "\n",
+ "Jupyter_URL = \"jupyter-jsc.fz-juelich.de\" + environ.get('JUPYTERHUB_SERVICE_PREFIX', '/')\n",
+ "renderer = RemoteRenderer(baseURL=\"jupyter-jsc.fz-juelich.de\" + environ.get('JUPYTERHUB_SERVICE_PREFIX', '/'), useJupyterServerProxyHttps=True, disableExternalPort=True)\n",
+ "\n",
+ "Box(children=[renderer], layout={\"height\": \"800px\"})"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Setup a view, that will be used by ParaView, setting up parameters for smooth rendering in this setup."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from pvlink.utility import SetRecommendedRenderSettings, ResetCamera\n",
+ "\n",
+ "# Cerate a view\n",
+ "view = simple.FindViewOrCreate(\"test\", \"RenderView\")\n",
+ "SetRecommendedRenderSettings(view)\n",
+ "renderer.update_render()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Establish Catalyst Connection\n",
+ "Create the Object handeling the connection, before extracting data from the Simulation. Waiting is necessary, Because extracting the data does not work, unless the simulation is connected and one update has been performed since updating"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "catalyst = simple.CatalystConnection()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# open port for catalyst connection\n",
+ "catalyst.Start()\n",
+ "catalyst.AddUpdateFunction(renderer.update_render)\n",
+ "catalyst.BlockTillConnected();"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# wait till simulation connected\n",
+ "catalyst.BlockTillConnected()\n",
+ "# extract data from simulation\n",
+ "# supplying a source name, that can be used to find the ParaView source.\n",
+ "# In case of different named input, or multiple input ports, alows to choose the desired input, that should be extracted\n",
+ "extract = catalyst.Extract(\"extract\")\n",
+ "# block till there is an update for the simulation data\n",
+ "catalyst.BlockTillNextUpdate()\n",
+ "# display simulation data\n",
+ "simple.SetActiveSource(extract)\n",
+ "extractDisplay = simple.Show(extract, view)\n",
+ "\n",
+ "#ResetCamera(view, renderer)\n",
+ "view.ResetCamera()\n",
+ "view.CenterOfRotation = view.GetActiveCamera().GetFocalPoint()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Connection has been established, and the simulation output is now visible above in the render window"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Setup render pipeline using ParaView Python Commands\n",
+ "To get the wished visualisation we need to setup the ParaView pipeline, to tell it what it is supposed to do with the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# set scalar coloring\n",
+ "simple.ColorBy(extractDisplay, (\"CELLS\", \"pressure\"))\n",
+ "\n",
+ "# rescale color and/or opacity maps used to include current data range\n",
+ "extractDisplay.RescaleTransferFunctionToDataRange(True, False)\n",
+ "\n",
+ "# show color bar/color legend\n",
+ "extractDisplay.SetScalarBarVisibility(view, True)\n",
+ "\n",
+ "# get color transfer function/color map for 'pressure'\n",
+ "pressureLUT = simple.GetColorTransferFunction(\"pressure\")\n",
+ "pressureLUT.RescaleTransferFunction(0.0, 1.0)\n",
+ "\n",
+ "# get opacity transfer function/opacity map for 'pressure'\n",
+ "pressurePWF = simple.GetOpacityTransferFunction(\"pressure\")\n",
+ "pressurePWF.RescaleTransferFunction(0.0, 1.0)\n",
+ "\n",
+ "# change representation type, for example wireframe or volume rendering\n",
+ "#extractDisplay.SetRepresentationType(\"Wireframe\")\n",
+ "extractDisplay.SetRepresentationType(\"Volume\");"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "PyParaView-5.8",
+ "language": "python",
+ "name": "pyparaview-5.8"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.6.8"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/002-Methods/003-Visualization/001-InSitu/001-Catalyst/build_ParaViewKernel.sh b/002-Methods/003-Visualization/001-InSitu/001-Catalyst/build_ParaViewKernel.sh
new file mode 100755
index 0000000000000000000000000000000000000000..3fd97b4ee035e2df8d576a4646bb6a487c373397
--- /dev/null
+++ b/002-Methods/003-Visualization/001-InSitu/001-Catalyst/build_ParaViewKernel.sh
@@ -0,0 +1,119 @@
+# INPUT NEEDED:
+export KERNEL_NAME="paraviewkernel5.8"
+export KERNEL_TYPE="private" # private or project
+export KERNEL_VENVS_DIR=~/jupyter/kernels
+export LOAD_PARAVIEW_COMMAND="module load ParaView/5.8.0-EGL-opengl-Python-3.6.8"
+export LOAD_JUPYTER_COMMAND="module load Jupyter/2019a-devel-Python-3.6.8"
+export UNLOAD_VTK_COMMAND="module unload VTK"
+
+
+echo "Kernel Name:"
+echo ${KERNEL_NAME}
+echo "Kernel Type:"
+echo ${KERNEL_TYPE}
+echo "Kernel venvs dir:"
+echo ${KERNEL_VENVS_DIR} # double check
+
+
+###################
+# private kernel
+if [ ${KERNEL_TYPE} == "private" ]; then
+ export KERNEL_SPECS_PREFIX=${HOME}/.local
+ echo "private kernel"
+# project kernel
+else
+ export KERNEL_SPECS_PREFIX=${PROJECT}/.local
+ echo "project kernel"
+fi
+export KERNEL_SPECS_DIR=${KERNEL_SPECS_PREFIX}/share/jupyter/kernels
+
+# check if kernel name is unique
+if [ -d "${KERNEL_SPECS_DIR}/${KERNEL_NAME}" ]; then
+ echo "ERROR: Kernel already exists in ${KERNEL_SPECS_DIR}/${KERNEL_NAME}"
+ echo " Rename kernel name or remove directory."
+fi
+
+echo ${KERNEL_SPECS_DIR}/${KERNEL_NAME} # double check
+
+
+
+###################
+mkdir -p ${KERNEL_VENVS_DIR}
+if [ ${KERNEL_TYPE} != "private" ]; then
+ echo "Please check the permissions and ensure your project partners have read/execute permissions:"
+ namei -l ${KERNEL_VENVS_DIR}
+fi
+
+
+module -q purge
+module -q use $OTHERSTAGES
+module -q load Stages/Devel-2019a 2> /dev/null # any stage can be used
+module -q load GCCcore/.8.3.0 2> /dev/null
+module -q load Python/3.6.8 # only Python is required
+#module -q load GCC/8.3.0
+#module -q load ParaStationMPI/5.2.2-1
+#module -q load ParaView/5.7.0-EGL-opengl-Python-3.6.8
+
+module list # double check
+
+
+python -m venv --system-site-packages ${KERNEL_VENVS_DIR}/${KERNEL_NAME}
+source ${KERNEL_VENVS_DIR}/${KERNEL_NAME}/bin/activate
+export PYTHONPATH=${VIRTUAL_ENV}/lib/python3.6/site-packages:${PYTHONPATH}
+echo ${VIRTUAL_ENV} # double check
+
+which pip
+#pip install --ignore-installed ipykernel
+ls ${VIRTUAL_ENV}/lib/python3.6/site-packages/ # double check
+
+
+echo "#!/bin/bash
+
+# Load required modules
+module purge
+module use "'$OTHERSTAGES'"
+module load Stages/Devel-2019a
+module load GCCcore/.8.3.0
+module load Python/3.6.8
+
+# Load extra modules you need for your kernel (as you did in step 1.2)
+module load GCC/8.3.0
+module load ParaStationMPI/5.2.2-1
+${LOAD_PARAVIEW_COMMAND}
+${LOAD_JUPYTER_COMMAND}
+${UNLOAD_VTK_COMMAND}
+module list
+
+# Activate your Python virtual environment
+source ${KERNEL_VENVS_DIR}/${KERNEL_NAME}/bin/activate
+
+# Ensure python packages installed in the virtual environment are always prefered
+export PYTHONPATH=${VIRTUAL_ENV}/lib/python3.6/site-packages:"'${PYTHONPATH}'"
+echo ${PYTHONPATH}
+
+exec python -m ipykernel "'$@' > ${VIRTUAL_ENV}/kernel.sh
+chmod +x ${VIRTUAL_ENV}/kernel.sh
+
+python -m ipykernel install --name=${KERNEL_NAME} --prefix ${VIRTUAL_ENV}
+export VIRTUAL_ENV_KERNELS=${VIRTUAL_ENV}/share/jupyter/kernels
+
+mv ${VIRTUAL_ENV_KERNELS}/${KERNEL_NAME}/kernel.json ${VIRTUAL_ENV_KERNELS}/${KERNEL_NAME}/kernel.json.orig
+
+echo '{
+ "argv": [
+ "'${KERNEL_VENVS_DIR}/${KERNEL_NAME}/kernel.sh'",
+ "-m",
+ "ipykernel_launcher",
+ "-f",
+ "{connection_file}"
+ ],
+ "display_name": "'${KERNEL_NAME}'",
+ "language": "python"
+}' > ${VIRTUAL_ENV_KERNELS}/${KERNEL_NAME}/kernel.json
+
+cd ${KERNEL_SPECS_DIR}
+ln -s ${VIRTUAL_ENV_KERNELS}/${KERNEL_NAME} .
+ls ${KERNEL_SPECS_DIR} # double check
+
+
+deactivate
diff --git a/002-Methods/003-Visualization/001-InSitu/001-Catalyst/img/Communication.drawio b/002-Methods/003-Visualization/001-InSitu/001-Catalyst/img/Communication.drawio
new file mode 100644
index 0000000000000000000000000000000000000000..0ae1581a436f6819e3574f60162e38763e49ce49
--- /dev/null
+++ b/002-Methods/003-Visualization/001-InSitu/001-Catalyst/img/Communication.drawio
@@ -0,0 +1 @@
+<mxfile host="app.diagrams.net" modified="2020-03-17T12:35:51.936Z" agent="Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Firefox/68.0" etag="gMOJMtI6yr1qRrk2KARI" version="12.8.5" type="device"><diagram name="Page-1" id="74b105a0-9070-1c63-61bc-23e55f88626e">7Vnbcqs2FP0aPybDHfzo2Mk50/Y0mXGnp3nqKCAb1QJRIWzTr68EwiCQ7STHJOmkLwl767722ksXT+x5sv9CQRZ/IxHEE8uI9hN7MbEszw34X+Eoa4crLOFYUxTVLrN1LNE/UDoN6S1QBHOlIiMEM5SpzpCkKQyZ4gOUkp1abUWwOmoG1nDgWIYAN95rt/V/RxGLpd/0pm3BV4jWsRw8sLy64AmEmzUlRSpHTEkK65IENN3IVeYxiMiu47JvJ/acEsLqr2Q/h1jg2mDWtGNlM9GJfROzBHPD5J9V8d2RxuZzGvN1UZiy7nDH+kt+M1z/Dm+o4c+t/Z+3TrG4v5Jx3wJcNIP0R62wgZEcdRcjBpcZCEXpjpNJndQKYTwnmNCqrb1aQS8MuT9nlGxgpyTyp0+GoV2GXPgWUgb3HZdc1hdIEshoyasc6CuBluw1G+B3HSY0deIOCQ5OIPm3PvTdAsk/JJZ6XLMZjReuk/w8u7/f/bq8e0TfjCt3ACOMOGOlSSiLyZqkAN+23hsV6LbOL4Rk0vkXZKyU6QcKRnSMEAP1cmWAbU4KGsITvGgSmwG6huxURUsfGgoxYGirzuRHYD45zbH4G7kwiBwdfwPryfa8y/DXMVT+2v5b8vdEWEcEFsBgpRUGLwzg02ocYfgIwE41wHqYj3sToa0CsPd3IXaWmxVJ2VVeJf2MVzC9bN8W8q+1+P9TkZUMUl6+gTQVu3vdKZ9k1W9daxBDDiRTA6UGpNoN1ehJF8BonXITw5XoQQQF8Q15Jt0JiqJK1XS8aJljyPVJTTO9xpZTPC5hL2GB1RwPmg3C1vDAcYc8sMaigaUTrpfToIp/jwlLlBRCe0n6PwdaiTV7ShBoGGBqlGA8BpgDBmTbHNKtSOJPGCHPdc9HyHrLCDWCcCxH63R6ABRcHcu0Qe3fEdzxLh9Kfri7VH52T9PHzt8ND0IeIE6wD80E3+qptWbX9jRECMYigjsU62yLUbr59KHyvI8WquG5dQ4YwGXOPqWqur667zmaq7E/kqhqL8bDa8QbXIw5frT8Q0JeGY/CuOZCI+3Fvlu6KBtrj1jV7noqrbqhK622mTC6rR4gRRwxkcCL9pnjIndz77l380BPjWdfzaumM0pB2amQEZSyfMCDQ/+vp4b9LtSQETaV+PqnA/wewXSNcaMpe34Qjo7AW6p+WE7vkfFcfdPoUaWewWuJcxLDU48VeQyyigEhE0p+9rmip8s9xb+AMjuWr26d7lCZp95Qmc3RpNk5jyJMo5l4rhfHEwzyHIX6bGoV8rFTckQtD+J87SryfEab1dS/YEo25/5Xv312Iqh7XGp8L8vcYarZvVSb9ohRL1S2OpWzgT7HDx3VQAw6eqmW+P0bnnlaS/r3APvCWqJNguHzXMxYlv9XD48DPdKkxPHDo2WrEjV958OjOXwz2eWfNDZOL2nHO9hzs/2Ns86z9kdk+/Zf</diagram></mxfile>
\ No newline at end of file
diff --git a/002-Methods/003-Visualization/001-InSitu/001-Catalyst/img/Communication.png b/002-Methods/003-Visualization/001-InSitu/001-Catalyst/img/Communication.png
new file mode 100644
index 0000000000000000000000000000000000000000..b78736e60e9a4c0d1511e8408b9627b8ba26eba1
Binary files /dev/null and b/002-Methods/003-Visualization/001-InSitu/001-Catalyst/img/Communication.png differ
diff --git a/002-Methods/003-Visualization/001-InSitu/001-Catalyst/img/Communication_minimal.drawio b/002-Methods/003-Visualization/001-InSitu/001-Catalyst/img/Communication_minimal.drawio
new file mode 100644
index 0000000000000000000000000000000000000000..5f2aa759f11f835d25de5cf7be99c4e78187d8ec
--- /dev/null
+++ b/002-Methods/003-Visualization/001-InSitu/001-Catalyst/img/Communication_minimal.drawio
@@ -0,0 +1 @@
+<mxfile host="app.diagrams.net" modified="2020-03-17T12:36:41.785Z" agent="Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Firefox/68.0" etag="-DgWVZ5rqkiH6Oo3Vvdd" version="12.8.5" type="device"><diagram name="Page-1" id="74b105a0-9070-1c63-61bc-23e55f88626e">7Vnbcps6FP0aP6bDxQj70XGSdnpLZtw55+Spo4AMqgWiQtimX38kkAzikstMSNpJXxL20n2vtbe0k5m7To7vGcziLzREZOZY4XHmXswcB3gL8VMCZQ140pJAxHBYQ3YDbPAvpEBLoQUOUW505JQSjjMTDGiaooAbGGSMHsxuW0rMVTMYoR6wCSDR6Duvwf/FIY8VboNl0/AB4ShWiy8cUDfcwWAXMVqkasWUpqhuSaCeRp0yj2FIDy3IvZy5a0Ypr7+S4xoR6VftMz2Ol3qjM/c85gkRhi0+q+arkcH2YwaLczGU8vZyY/Ml3yzPvyI7Zvlr5/j9cl5cXJ8p3veQFHqR7qqVb1CoVj3EmKNNBgPZehBiMje1xYSsKaGsGututwgEgcBzzugOtVpCf3lnWYPHUAffI8bRsQWpY71HNEGclaLLSb7K0Uq9tnb8oaUE3SduieAEQqW/6DR340jxoXw57NdsxeILb558Wl1fH75urm7xF+vM67kRhUKxyqSMxzSiKSSXDXpuOrrp85nSTIE/EOelCj9YcGo6X3iQlf8Jw3rnu64GbitgAXwNXEi3WSerbFs3iGHhAcQUWB9D7r0Tfj26clqwAN0jNZ0rOGQR4g9psk82QwRyvDc3MkScGnpDsdjiqEjmc8+cot6XGtWh/7SNRyni3uNPFWqhhxbhfCjUFs6dC8DzhNrcMr3o+i8ZasOOXQ44FhCx7nmI94aDwc9C5urzLU35WV6F0Up0sEF2bBrFVyR/fyyyUgaCY+0QS+V9WU8qNlnNW/fqcSgcyU2iTEKq+8VkT0GQ4CgVJkFbOYMkBYsrbqXgBIdhlSeGdNEox1LnU1nCBtpWWxyP4KckXEdfuDrlugM60BHW1oEzlQycofh6ugwq/jtK2OCkkLmHpn810GQCu5MJFgMKsAcywWQK0HIbU0BN1g1k8GyMx17vfzA6iClvSnEZPxf77dfP2HtJ6yAQBMnL+HdWgu90csHAnQAGhLCYSghePxVke4LT3ZunCoDfjSqnR9UackjKnL/JrArmnVfqQCnjT5RUBwuZ/iP1RQsZs4gRieaBGuaIeV0ALZVVD/SU1QyTRnvUhIUPeNHCZ8UYLFsdMlnQ5D0dPK2iGZSG+yrSUAzbBr/+/QS/BpmeNS2bI1WuY+YPZ975o9BD/W2rI5V6B89aCoNHlMJ5DLNKAQGXmfzBYriTlzsZ/zneu45vXp1ePzMvQT8z25Ol5n7dG3Oe5X/qvdmjYoCwUXY8xzXZWb7yvWnbPXYO+RvlpvOmcaZ70wiz+XN8na6a/3e4l/8D</diagram></mxfile>
\ No newline at end of file
diff --git a/002-Methods/003-Visualization/001-InSitu/001-Catalyst/img/Communication_minimal.png b/002-Methods/003-Visualization/001-InSitu/001-Catalyst/img/Communication_minimal.png
new file mode 100644
index 0000000000000000000000000000000000000000..8ad5639a961b8f75003b5d47192539ed8b07f7db
Binary files /dev/null and b/002-Methods/003-Visualization/001-InSitu/001-Catalyst/img/Communication_minimal.png differ