toschi / paraviewcatalystexamplecode Goto Github PK

This repository gives examples of how to use ParaView Catalyst (catalyst.paraview.org)
for in situ analysis and visualization. For assistance, please email the ParaView
mailing list at [email protected]. The examples show how to create VTK data
structures from native simulation code data structures, how to interface to ParaView
Catalyst and how to set up several different types of pipelines. The examples can
either be built individually or as a group. Many work in parallel as well. The tests
are very simple and just verify that the examples run -- they don't not verify
correctness of outputs. A description of the examples are:
* FortranPoissonSolver -- An example of a parallel, finite difference discretization of the Poisson equation
                          implemented in Fortran using a Conjugate Gradient solver. Instead of co-processing
                          at the end of each time step it co-processes at the end of each iteration.
* Fortran90FullExample -- An example of a simulation code written in Fortran
                          that is linked with Catalyst.
* CFullExample -- An example of a simulation code written in C. This uses some
                  methods from Catalyst for storing VTK data structures. This
                  assumes a vtkUnstructuredGrid.
* CFullExample2 -- An example of a simulation code written in C. This improves
                   upon the CFullExample by explictly storing VTK data structures.
                   This assumes a vtkUnstructuredGrid.
* CxxFullExample -- A C++ example of a simulation code interfacing with Catalyst.
                    This assumes a vtkUnstructuredGrid.
* PythonFullExample -- An example of a simulation code written in Python
                       that uses Catalyst.
* PythonDolfinExample -- An example that uses the Dolfin simulation code.
* CxxImageDataExample -- A C++ example of a simulation code interfacing with
                         Catalyst. The grid is a vtkImageData.
* CxxMultiPieceExample -- A C++ example of a simulation code interfacing with
                          Catalyst. The grid is a vtkMultiPiece data set with
                          a single vtkImageData for each process.
* CxxNonOverlappingAMRExample -- A C++ example of a simulation code interfacing with
                                 Catalyst. The grid is a vtkNonOverlappingAMR.h
                                 data set.
* CxxOverlappingAMRExample -- A C++ example of a simulation code interfacing with
                              Catalyst. The grid is a vtkOverlappingAMR.h
                              data set.
* CxxPVSMPipelineExample -- An example where we manually create a Catalyst
                            pipeline in C++ code using ParaView's server-manager.
                            This example can be run without ParaView being built
                            with Python.
* CxxVTKPipelineExample -- An example where we manually create a Catalyst
                           pipeline in C++ code using VTK filters.
                           This example can be run without ParaView being built
                           with Python.
* CxxMappedDataArrayExample -- An example of an adaptor where we use VTK mapped
                               arrays to map simulation data structures to
                               VTK data arrays to save on memory use by Catalyst.
* MPISubCommunicatorExample -- An example where only a subset of the MPI
                               processes are used for the simulation and Catalyst.

Other objects of interest:
* LICENSE.md -- The license of this software.
* SampleScripts -- A directory with some useful sample Catalyst Python pipelines.
                   Currently the only file in this is a script that writes out
                   the entire "input" grid at each time step. This can be useful
                   for creating other Catalyst Python pipelines with the
                   co-processing plugin in the ParaView GUI.
* CMakeLists.txt -- The file used to build all of the examples in a single shot.