build.md 24.7 KB
Newer Older
1
# Building ParaView
2

3
4
5
6
This page describes how to build and install ParaView. It covers building for
development, on both Unix-type systems (Linux, HP-UX, Solaris, macOS), and
Windows. Note that Unix-like environments such as Cygwin and MinGW are not
officially supported. However, patches to fix problems with these platforms
Cory Quammen's avatar
Cory Quammen committed
7
8
will be considered for inclusion. ParaView builds on x86_64, PowerPC, and ARM
architectures.
9

10
11
12
13
ParaView depends on several open source tools and libraries such as Python, Qt,
CGNS, HDF5, etc. Some of these are included in the ParaView source itself
(e.g., HDF5), while others are expected to be present on the machine on which
ParaView is being built (e.g., Python, Qt).
14

Cory Quammen's avatar
Cory Quammen committed
15
The first section is a getting started guide by OS that is very helpful if you have never
16
built ParaView before and do not know which options you need.
17
If you are looking for the generic help, please read the [Complete Compilation Guide](#complete-compilation-guide)
18
19
20
21
22

## Getting Started Guide
This is a section intended to help those that have never built ParaView before, are not
experienced with compilation in general or have no idea which option they may need when building ParaView.
If you follow this guide, you will be able to compile and run a standard version of ParaView
Cory Quammen's avatar
Cory Quammen committed
23
for your operating system. It will be built with the Python wrapping, MPI capabilities and multithreading capabilities.
24
25
26
27
28
29
30
31
32
33
34

 * If you are using a Linux distribution, please see [the Linux part](#linux),
 * If you are using Microsoft Windows, please see [the Windows part](#windows),
 * If you are using another OS, feel free to provide compilation steps.

### Linux

#### Dependencies
Please run the command in a terminal to install the following dependencies depending of your linux distribution.

##### Ubuntu 18.04 LTS / Debian 10
35
`sudo apt-get install git cmake build-essential libgl1-mesa-dev libxt-dev qt5-default libqt5x11extras5-dev libqt5help5 qttools5-dev qtxmlpatterns5-dev-tools libqt5svg5-dev python3-dev python3-numpy libopenmpi-dev libtbb-dev ninja-build`
36
37
38

##### Centos 7

39
40
###### CMake
Download and install [cmake][cmake-download]) as the packaged version is not enough considering that
41
CMake 3.12 or higher is needed.
42

43
###### Others
44
45
`sudo yum install python3-devel openmpi-devel mesa-libGL-devel libX11-devel libXt-devel qt5-qtbase-devel qt5-qtx11extras-devel qt5-qttools-devel qt5-qtxmlpatterns-devel tbb-devel ninja-build git`

Cory Quammen's avatar
Cory Quammen committed
46
###### Environment
47
```sh
Stepan Kriz's avatar
Stepan Kriz committed
48
alias ninja=ninja-build
49
50
51
52
53
54
55
56
57
58
59
60
export PATH=$PATH:/usr/lib64/openmpi/bin/
```

##### ArchLinux
`sudo pacman -S base-devel ninja openmpi tbb qt python python-numpy cmake`

##### Other distribution
If you are using another distribution, please try to adapt the package list.
Feel free to then provide it so we can integrate it in this guide by creating an [issue][paraview-issues].

#### Build

Cory Quammen's avatar
Cory Quammen committed
61
To build ParaView development version (usually refered as "master"), please run the following commands in a terminal:
62
63
64
65
```sh
git clone --recursive https://gitlab.kitware.com/paraview/paraview.git
mkdir paraview_build
cd paraview_build
66
cmake -GNinja -DPARAVIEW_USE_PYTHON=ON -DPARAVIEW_USE_MPI=ON -DVTK_SMP_IMPLEMENTATION_TYPE=TBB -DCMAKE_BUILD_TYPE=Release ../paraview
67
68
69
70
71
72
73
74
75
76
77
ninja
```

To build a specific ParaView version, eg: v5.6.0 , please run the following commands in a terminal while replacing "tag" by the version you want to build
```sh
git clone https://gitlab.kitware.com/paraview/paraview.git
mkdir paraview_build
cd paraview
git checkout tag
git submodule update --init --recursive
cd ../paraview_build
78
cmake -GNinja -DPARAVIEW_USE_PYTHON=ON -DPARAVIEW_USE_MPI=ON -DVTK_SMP_IMPLEMENTATION_TYPE=TBB -DCMAKE_BUILD_TYPE=Release ../paraview
79
80
81
82
ninja
```

#### Run
Cory Quammen's avatar
Cory Quammen committed
83
Double click on the paraview executable in the `/bin` directory or run in the previous terminal
84
85
86
87
88
89
90

```sh
./bin/paraview
```

### Windows

Cory Quammen's avatar
Cory Quammen committed
91
92
Note: the following steps concerning Visual Studio 2015 can also be applied to Visual Studio 2017 and 2019.
If so, be sure to use the msvc2017_64/msvc2019_64 Qt Version and the Developer Command Prompt for VS 2017/2019.
93

94
95
96
97
#### Dependencies
 * Download and install [git bash for windows][gitforwindows]
 * Download and install [cmake][cmake-download]
 * Download and install [Visual Studio 2015 Community Edition][visual-studio]
98
99
 * Download [ninja-build][ninja] and drop `ninja.exe` in `C:\Windows\`
 * Download and install both `msmpisetup.exe` and `msmpisdk.msi` from [Microsoft MPI][msmpi]
100
 * Download and install [Python for windows][pythonwindows], make sure to add the path to your Python installation folder to the `PATH` environnement variable.
Cory Quammen's avatar
Cory Quammen committed
101
 * Download and install [Qt 5.12.3][qt-download-5.12.3] for Windows, make sure to check the MSVC 2015 64-bit component during installation, make sure to add `C:\Qt\Qt5.12.3\5.12.3\msvc2015_64\bin` to your `PATH` environment variable.
102
103
104

#### Recover the source
 * Open git bash
Cory Quammen's avatar
Cory Quammen committed
105
 * To build ParaView development version (usually referred to as `master`), run the following commands:
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

```sh
cd C:
mkdir pv
cd pv
git clone --recursive https://gitlab.kitware.com/paraview/paraview.git
mv paraview pv
mkdir pvb
```

 * Or, to build a specific ParaView version, eg: v5.6.0 , please run the following commands while replacing "tag" by the version you want to build

```sh
cd C:
mkdir pv
cd pv
git clone https://gitlab.kitware.com/paraview/paraview.git
mv paraview pv
mkdir pvb
cd pv
git checkout tag
git submodule update --init --recursive
```

#### Build

 * Open VS2015 x64 Native Tools Command Prompt and run the following commands
```sh
cd C:\pv\pvb
135
cmake -GNinja -DPARAVIEW_USE_PYTHON=ON -DPARAVIEW_USE_MPI=ON -DVTK_SMP_IMPLEMENTATION_TYPE=OpenMP -DCMAKE_BUILD_TYPE=Release ..\pv
136
137
138
139
140
141
142
143
144
145
ninja
```

#### Run

 * Double click on the `C:\pv\pvb\bin\paraview` executable

## Complete Compilation Guide

### Obtaining the source
146

147
148
To obtain ParaView's sources locally, clone this repository using
[Git][git].
149

Ben Boeckel's avatar
Ben Boeckel committed
150
151
152
```sh
git clone --recursive https://gitlab.kitware.com/paraview/paraview.git
```
153

154
### Building
155

156
157
ParaView supports all of the common generators supported by CMake. The Ninja,
Makefiles, and Visual Studio generators are the most well-tested however.
158

159
#### Prerequisites
160

Cory Quammen's avatar
Cory Quammen committed
161
ParaView only requires a few packages to build with its basic capabilities. However,
162
163
specific features may require additional packages to be provided to ParaView's
build configuration.
164

165
Required:
166

167
  * [CMake][cmake]
168
    - Version 3.12 or newer, however, the latest version is always recommended
169
170
  * Supported compiler
    - GCC 4.8 or newer
Cory Quammen's avatar
Cory Quammen committed
171
172
    - Intel 17 or newer
    - IBM XL 16.1 or newer
173
174
175
    - Clang 4 or newer
    - Xcode 9 or newer
    - Visual Studio 2015 or newer
176

177
Optional dependencies:
178

179
  * [Python][python]
Ben Boeckel's avatar
Ben Boeckel committed
180
    - At least 3.3 is required
181
  * [Qt5][qt]
Cory Quammen's avatar
Cory Quammen committed
182
    - Version 5.12 or newer
183

184
##### Installing CMake
185

186
187
188
189
CMake is a tool that makes cross-platform building simple. On several systems
it will probably be already installed or available through system package
management utilities. If it is not, there are precompiled binaries available on
[CMake's download page][cmake-download].
190

191
##### Installing Qt
192

Cory Quammen's avatar
Cory Quammen committed
193
ParaView uses Qt to provide its graphical user interface. Precompiled binaries are available on
194
[Qt's website][qt-download].
195

196
197
Note that on Windows, the compiler used for building ParaView must match the
compiler version used to build Qt.
198

199
200
201
202
The Linux packages for Qt 5.9 use a version of protobuf that may conflict with
that used by ParaView. If, when running ParaView, error messages about a
mismatch in protobuf versions appears, moving the `libqgtk3.so` plugin out of
the `plugins/platformthemes` directory has been sufficient in the past.
203

204
#### Optional Additions
205

206
##### Download And Install ffmpeg (`.avi`) movie libraries
207

208
209
When the ability to write `.avi` files is desired, and writing these files is
not supported by the OS, ParaView can use the ffmpeg library. This is generally
Cory Quammen's avatar
Cory Quammen committed
210
true for Linux. Source code for ffmpeg can be obtained from [its
211
website][ffmpeg].
212

213
##### MPI
214

215
216
217
218
219
To run ParaView in parallel, an [MPI][mpi] implementation is required. If an
MPI implementation that exploits special interconnect hardware is provided on
your system, we suggest using it for optimal performance. Otherwise, on
Linux/Mac, we suggest either [OpenMPI][openmpi] or [MPICH][mpich]. On Windows,
[Microsoft MPI][msmpi] is required.
220

221
##### Python
222

Cory Quammen's avatar
Cory Quammen committed
223
In order to use Python scripting, [Python][python] is required (version 3.3 or later). Python
Ben Boeckel's avatar
Ben Boeckel committed
224
is also required in order to build ParaViewWeb support.
225

226
##### OSMesa
227

228
229
230
231
Off-screen Mesa can be used as a software-renderer for running ParaView on a
server without hardware OpenGL acceleration. This is usually available in
system packages on Linux. For example, the `libosmesa6-dev` package on Debian
and Ubuntu. However, for older machines, building a newer version of Mesa is
Cory Quammen's avatar
Cory Quammen committed
232
233
likely necessary for bug fixes and support for features needed by ParaView.
Its source and build instructions can be found on [its website][mesa].
234

235
### Creating the Build Environment
236

237
#### Linux (Ubuntu/Debian)
238
239
240
241
242
243
244
245
246
247

  * `sudo apt install` the following packages:
    - `build-essential`
    - `cmake`
    - `mesa-common-dev`
    - `mesa-utils`
    - `freeglut3-dev`
    - `ninja-build`
      - `ninja` is a speedy replacement for `make`, highly recommended.

248
249
250
251
*Note*: If you are using an Ubuntu-provided compiler, there is a known issue
with the optional Python linking. This case is hard to auto-detect, so if
undefined symbol errors related to Python symbols arise, setting
`vtk_undefined_symbols_allowed=OFF` may resolve the errors. If it does not,
Cory Quammen's avatar
Cory Quammen committed
252
please file a new [issue][paraview-issues].
253

254
#### Windows
255

256
  * [Visual Studio 2015 Community Edition][visual-studio]
257
258
259
260
  * Use "x64 Native Tools Command Prompt" for the installed Visual Studio
    version to configure with CMake and to build with ninja.
  * Get [ninja][ninja]. Unzip the binary and put it in `PATH`.

261
### Building
262
263
264
265
266
267

In order to build, CMake requires two steps, configure and build. ParaView
itself does not support what are known as in-source builds, so the first step
is to create a build directory.

!!! note
Cory Quammen's avatar
Cory Quammen committed
268
269
270
271
272
    On Windows, there have historically been issues if the path to the
    build directory is too long. These issues should have been addressed in
    more recent versions of ParaView's build system, but they may appear again. If you
    see errors related to header files not being found at paths on your file
    system that do exist, please report them to [the issue
273
274
275
276
277
278
279
280
281
282
283
284
    tracker][paraview-issues].

```sh
mkdir -p paraview/build
cd paraview/build
ccmake ../path/to/paraview/source # -GNinja may be added to use the Ninja generator
```

CMake's GUI has input entries for the build directory and the generator
already. Note that on Windows, the GUI must be launched from a "Native Tools
Command Prompt" available with Visual Studio in the start menu.

285
#### Build Settings
286

Utkarsh Ayachit's avatar
Utkarsh Ayachit committed
287
ParaView has a number of settings available for its build. These are categorized
Cory Quammen's avatar
Cory Quammen committed
288
as build options, capability options, feature options and miscellaneous options.
289
290


Utkarsh Ayachit's avatar
Utkarsh Ayachit committed
291
#### Build Options
292

Cory Quammen's avatar
Cory Quammen committed
293
294
Options that impact the build begin with the prefix `PARAVIEW_BUILD_`.
Common variables to modify include:
295

Utkarsh Ayachit's avatar
Utkarsh Ayachit committed
296
297
  * `PARAVIEW_BUILD_SHARED_LIBS` (default `ON`): If set, shared libraries will
    be built. This is usually what is wanted.
298
299
300

Less common, but variables which may be of interest to some:

301
  * `PARAVIEW_BUILD_EDITION` (default `CANONICAL`): Choose which features to
Utkarsh Ayachit's avatar
Utkarsh Ayachit committed
302
303
    enable in this build. This is useful to generate ParaView builds with
    limited features. More on this later.
304
  * `PARAVIEW_BUILD_EXAMPLES` (default `OFF`): If set, ParaView's example code
305
    will be added as tests to the ParaView test suite.
Utkarsh Ayachit's avatar
Utkarsh Ayachit committed
306
307
  * `PARAVIEW_BUILD_DEVELOPER_DOCUMENTATION` (default `OFF`): If set, the HTML
    documentation for ParaView's C++, Python, and proxies will be generated.
308
309
310
311
  * `PARAVIEW_BUILD_TESTING` (default `OFF`): Whether to build tests or not.
    Valid values are `OFF` (no testing), `WANT` (enable tests as possible), and
    `ON` (enable all tests; may error out if features otherwise disabled are
    required by test code).
Utkarsh Ayachit's avatar
Utkarsh Ayachit committed
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
  * `PARAVIEW_BUILD_VTK_TESTING` (default `OFF`): Whether to build tests for the
    VTK codebase built by ParaView. Valid values are same as
    `PARAVIEW_BUILD_TESTING`.

More advanced build options are:

  * `PARAVIEW_BUILD_ALL_MODULES` (default `OFF`): If set, ParaView will enable
    all modules not disabled by other features.
  * `PARAVIEW_BUILD_LEGACY_REMOVE` (default `OFF`): Remove legacy / deprecated
    code.
  * `PARAVIEW_BUILD_LEGACY_SILENT` (default `OFF`): Silence all legacy
    / deprecated code messages.
  * `PARAVIEW_BUILD_WITH_EXTERNAL` (default `OFF`): When set to `ON`, the build
    will try to use external copies of all included third party libraries unless
    explicitly overridden.
327
328
329
330
  * `PARAVIEW_BUILD_WITH_KITS` (default `OFF`; requires
    `PARAVIEW_BUILD_SHARED_LIBS`): Compile ParaView into a smaller set of
    libraries. Can be useful on platforms where ParaView takes a long time to
    launch due to expensive disk access.
331
332
333
  * `PARAVIEW_BUILD_ID` (default `""`): A build ID for the ParaView build. It
    can be any arbitrary value which can be used to indicate the provenance of
    ParaView.
334

Utkarsh Ayachit's avatar
Utkarsh Ayachit committed
335
#### Capability settings
Ben Boeckel's avatar
Ben Boeckel committed
336

Utkarsh Ayachit's avatar
Utkarsh Ayachit committed
337
338
These settings control capabitities of the build. These begin with the prefix
`PARAVIEW_USE_`. The common variables to modify include:
Ben Boeckel's avatar
Ben Boeckel committed
339

Utkarsh Ayachit's avatar
Utkarsh Ayachit committed
340
341
342
343
344
  * `PARAVIEW_USE_QT` (default `ON`): Builds the `paraview` GUI application.
  * `PARAVIEW_USE_MPI` (default `OFF`): Whether MPI support will be available
    or not.
  * `PARAVIEW_USE_PYTHON` (default `OFF`): Whether Python
    support will be available or not.
345

Utkarsh Ayachit's avatar
Utkarsh Ayachit committed
346
347
348
Less common, but potentially useful variables are:

  * `PARAVIEW_USE_VTKM` (default `ON`): Whether VTK-m based filters are enabled.
Utkarsh Ayachit's avatar
Utkarsh Ayachit committed
349
350
  * `PARAVIEW_USE_FORTRAN` (default `ON` if Fortran compiler found): Enable
     Fortran support for Catalyst libraries.
Utkarsh Ayachit's avatar
Utkarsh Ayachit committed
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365

#### Feature settings

These settings control optional features. These begin with the prefix
`PARAVIEW_ENABLE_`. The common variables to modify include:

  * `PARAVIEW_ENABLE_RAYTRACING` (default `OFF`): Enable ray-tracing support
    with OSPray and/or OptiX. Requires appropriate external libraries.
  * `PARAVIEW_ENABLE_WEB` (default `OFF`; requires `PARAVIEW_USE_PYTHON`):
    Whether ParaViewWeb support will be available or not.

More advanced / less common options include:

  * `PARAVIEW_ENABLE_VISITBRIDGE` (default `OFF`): Enable support for VisIt
    readers.
366
  * `PARAVIEW_ENABLE_NVPIPE` (default `OFF`): Use [nvpipe][nvpipe] image
Cory Quammen's avatar
Cory Quammen committed
367
    compression that uses the GPU when communicating. Requires CUDA and an NVIDIA GPU.
368
369
370
371
372
  * `PARAVIEW_ENABLE_GDAL` (default `OFF`): Enable support for reading GDAL
    files.
  * `PARAVIEW_ENABLE_LAS` (default `OFF`): Enable support for reading LAS
    files.
  * `PARAVIEW_ENABLE_OPENTURNS` (default `OFF`): Enable support for reading
Mathieu Westphal's avatar
Mathieu Westphal committed
373
    OpenTURNS files.
374
375
376
377
  * `PARAVIEW_ENABLE_PDAL` (default `OFF`): Enable support for reading PDAL
    files.
  * `PARAVIEW_ENABLE_MOTIONFX` (default `OFF`): Enable support for reading
    MotionFX files.
Dan Lipsa's avatar
Dan Lipsa committed
378
379
  * `PARAVIEW_ENABLE_MOMENTINVARIANTS` (default `OFF`): Enable
    MomentInvariants filters.
Cory Quammen's avatar
Cory Quammen committed
380
  * `PARAVIEW_ENABLE_LOOKINGGLASS` (default `OFF`): Enable support for LookingGlass displays.
381
382
383
384
385
386
387
388
389
  * `PARAVIEW_ENABLE_XDMF2` (default `OFF`): Enable support for reading Xdmf2
    files.
  * `PARAVIEW_ENABLE_XDMF3` (default `OFF`): Enable support for reading Xdmf3
    files.
  * `PARAVIEW_ENABLE_FFMPEG` (default `OFF`; not available on Windows): Enable
    FFmpeg support.
  * `PARAVIEW_ENABLE_COSMOTOOLS` (default `OFF`; requires `PARAVIEW_USE_MPI`
    and not available on Windows): Enable support for CosmoTools which includes
    GenericIO readers and writers as well as some point cloud algorithms.
Utkarsh Ayachit's avatar
Utkarsh Ayachit committed
390
391
392
393


#### Plugin settings

Cory Quammen's avatar
Cory Quammen committed
394
ParaView includes several optional plugins that can be enabled and disabled using the
Utkarsh Ayachit's avatar
Utkarsh Ayachit committed
395
396
397
398
399
400
401
402
following options:

  * `PARAVIEW_PLUGINS_DEFAULT` (default `ON`): Pass this flag to the command
    line using `-DPARAVIEW_PLUGINS_DEFAULT=OFF` before the first cmake run to
    disable all plugins by default. Note this has no impact after the first
    cmake configure and hence must be passed on the command line itself.
  * `PARAVIEW_PLUGIN_ENABLE_<name>` (default varies): Whether to enable a
    plugin or not.
403
404
405
  * `PARAVIEW_PLUGIN_AUTOLOAD_<name>` (default `OFF`): Whether to autoload a
    plugin at startup or not. Note that this affects all clients linking to
    ParaView's plugin target.
Utkarsh Ayachit's avatar
Utkarsh Ayachit committed
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421

#### Miscellaneous settings
ParaView uses VTK's module system to control its build. This infrastructure
provides a number of variables to control modules which are not otherwise
controlled by the other options provided.

  * `VTK_MODULE_USE_EXTERNAL_<name>` (default depends on
    `PARAVIEW_BUILD_WITH_EXTERNAL`): Use an external source for the named third-party
    module rather than the copy contained within the ParaView source tree.
  * `VTK_MODULE_ENABLE_<name>` (default `DEFAULT`): Change the build settings
    for the named module. Valid values are those for the module system's build
    settings (see below).
  * `VTK_GROUP_ENABLE_<name>` (default `DEFAULT`): Change the default build
    settings for modules belonging to the named group. Valid values are those
    for the module system's build settings (see below).

Cory Quammen's avatar
Cory Quammen committed
422
For variables that use the module system's build settings, the valid values are as follows:
Utkarsh Ayachit's avatar
Utkarsh Ayachit committed
423
424
425
426
427
428
429
430
431
432
433
434

  * `YES`: Require the module to be built.
  * `WANT`: Build the module if possible.
  * `DEFAULT`: Use the settings by the module's groups and
    `PARAVIEW_BUILD_ALL_MODULES`.
  * `DONT_WANT`: Don't build the module unless required as a dependency.
  * `NO`: Do not build the module.

If any `YES` module requires a `NO` module, an error is raised.

More advanced options:

435
436
  * `PARAVIEW_INITIALIZE_MPI_ON_CLIENT` (default `ON`; requires
    `PARAVIEW_USE_MPI`): Initialize MPI on client processes by default.
437
438
  * `PARAVIEW_USE_QTHELP` (default `ON`; requires `PARAVIEW_USE_QT`): Use Qt's
    help infrastructure for runtime documentation.
439
440
441
442
443
444
  * `PARAVIEW_VERSIONED_INSTALL` (default `ON`): Whether to add version numbers
    to ParaView's include and plugin directories in the install tree.
  * `PARAVIEW_CUSTOM_LIBRARY_SUFFIX` (default depends on
    `PARAVIEW_VERSIONED_INSTALL`): The custom suffix for libraries built by
    ParaView. Defaults to either an empty string or `pvX.Y` where `X` and `Y`
    are ParaView's major and minor version components, respectively.
445
446
  * `PARAVIEW_INSTALL_DEVELOPMENT_FILES` (default `ON`): If set, ParaView will
    install its headers, CMake API, etc. into its install tree for use.
447
  * `PARAVIEW_RELOCATABLE_INSTALL` (default `ON`): If set, the install tree
448
449
450
451
452
453
    will be relocatable to another path or machine. External dependencies
    needed by ParaView which are in non-standard locations may need manual
    settings in ParaView-using projects (those which share an install prefix
    with ParaView should be OK though). If unset, the install tree will include
    hints for the location of its dependencies which may include
    build-machine-specific paths in the install tree.
454
455
456
  * `PARAVIEW_SERIAL_TESTS_USE_MPIEXEC` (default `OFF`): Used on HPC to run
    serial tests on compute nodes. If set, it prefixes serial tests with
    "${MPIEXEC_EXECUTABLE}" "${MPIEXEC_NUMPROC_FLAG}" "1" ${MPIEXEC_PREFLAGS}
Ben Boeckel's avatar
Ben Boeckel committed
457

458
<!--
Ben Boeckel's avatar
Ben Boeckel committed
459
460
These variables should be documented once they're effective again.

461
462
463
464
  * `PARAVIEW_USE_EXTERNAL_VTK` (default `OFF`): Use an externally provided
    VTK. Note that ParaView has fairly narrow requirements for the VTK it can
    use, so only very recent versions are likely to work.
-->
465

466
## Building editions
Utkarsh Ayachit's avatar
Utkarsh Ayachit committed
467
468
469

A typical ParaView build includes several modules and dependencies. While these
are necessary for a fully functional application, there are cases (e.g. in situ
470
471
use-cases) where a build with limited set of features is adequate. ParaView build supports
this using the `PARAVIEW_BUILD_EDITION` setting. Supported values for this setting are:
Utkarsh Ayachit's avatar
Utkarsh Ayachit committed
472
473
474
475
476

* `CORE`: Build modules necessary for core ParaView functionality.
  This does not include rendering.
* `RENDERING`: Build modules necessary for supporting rendering including views
  and representations. This includes everything in `CORE`.
477
478
479
480
* `CATALYST`: Build all modules necessary for in situ use cases without
  rendering and optional components like NetCDF- and HDF5-based readers and
  writers.
* `CATALYST_RENDERING`: Same as `CATALYST` but with rendering supported added.
Utkarsh Ayachit's avatar
Utkarsh Ayachit committed
481
482
* `CANONICAL` (default): Build modules necessary for standard ParaView build.

483
484
485
## Debugging facilities

ParaView's build is fairly complicated, so a few debugging facilities are
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
provided.

### General CMake

CMake provides the `--trace-expand` flag which causes CMake to log all commands
that it executes with variables expanded. This can help to trace logic and data
through the configure step.

Debugging `Find` modules can be done using the `--debug-find` flag (introduced
in CMake 3.17) to determine what CMake's `find_` commands are doing.

### VTK Modules

VTK's module system debugging facilities may be controlled by using the
following flags:
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517

  * `ParaView_DEBUG_MODULE` (default `OFF`): If enabled, debugging is enabled.
    Specific portions of the module system may be debugged using the other
    flags.
  * `ParaView_DEBUG_MODULE_ALL` (default `OFF`): Enable all debugging messages.
  * `ParaView_DEBUG_MODULE_building` (default `OFF`): Log when modules are
    being built.
  * `ParaView_DEBUG_MODULE_enable` (default `OFF`): Log why modules are
    enabled.
  * `ParaView_DEBUG_MODULE_kit` (default `OFF`): Log information about
    discovered kits.
  * `ParaView_DEBUG_MODULE_module` (default `OFF`): Log information about
    discovered modules.
  * `ParaView_DEBUG_MODULE_provide` (default `OFF`): Log why a module is being
    built or not.
  * `ParaView_DEBUG_MODULE_testing` (default `OFF`): Log testing for VTK
    modules.
518

519
520
521
522
523
524
525
526
527
528
529
530
531
### ParaView Plugins

ParaView's plugin system has a similar setup:

  * `ParaView_DEBUG_PLUGINS` (default `OFF`): If enabled, debugging is enabled.
    Specific portions of the plugin system may be debugged using the other
    flags.
  * `ParaView_DEBUG_PLUGINS_ALL` (default `OFF`): Enable all debugging messages.
  * `ParaView_DEBUG_PLUGINS_building` (default `OFF`): Log when plugins are
    being built.
  * `ParaView_DEBUG_PLUGINS_plugin` (default `OFF`): Log information about
    discovered plugins.

532
### Building documentation
533
534
535
536
537
538
539

The following targets are used to build documentation for ParaView:

  * `ParaViewDoxygenDoc` - build the doxygen documentation from ParaView's C++ source files.
  * `ParaViewPythonDoc` - build the documentation from ParaView's Python source files.
  * `ParaViewDoc-TGZ` - build a gzipped tarball of ParaView documentation.

540
541
542
543
544
545
546
547
548
549
## Using spack

[Spack][spack] is a package manager for supercomputers, Linux and macOS. ParaView is one of
the packages available in Spack. To install ParaView from spack, you can use:

```
spack install paraview
```

Please refer to [Spack documentation][spack-docs] for ways of customizing the install,
Cory Quammen's avatar
Cory Quammen committed
550
including choosing the version and/or variant to build. Based on the version chosen,
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
spack will download appropriate ParaView source and build it.

To make it easier to build ParaView using spack from an existing source checkout, we have included
relevant spack `package.yaml` files within the ParaView codebase itself. This
also makes it easier to keep the spack package up-to-date with any changes to
the ParaView buildsystem. With every release (and as frequently as required), we
will push the changes to the ParaView paraview.yaml file upstream to the
official spack repository.

To build your existing source checkout of ParaView using Spack, here are the
steps:

```bash
# assuming you've installed spack as documented in spack docs
# and activate the spack environment appropriately

# add custom paraview/package.yaml
> spack repo add $PARAVIEW_SOURCE_DIR/Utilities/spack/repo

# use info to confirm that the paraview package is available
# only one version should be available
> spack info paraview

# install similar to any other spack package
# e.g. following command installs osmesa-capable ParaView
# with mpich

> spack install paraview+osmesa^mesa~glx^mpich
```

581
[cmake-download]: https://cmake.org/download
582
[cmake]: https://cmake.org
583
584
[ffmpeg]: https://ffmpeg.org
[git]: https://git-scm.org
585
[gitforwindows]: https://gitforwindows.org/
586
587
588
[mesa]: https://www.mesa3d.org
[mpi]: https://www.mcs.anl.gov/research/projects/mpi
[mpich]: https://www.mpich.org
589
590
[msmpi]: https://docs.microsoft.com/en-us/message-passing-interface/microsoft-mpi
[ninja]: https://github.com/ninja-build/ninja/releases
591
592
[nvpipe]: https://github.com/NVIDIA/NvPipe
[openmpi]: https://www.open-mpi.org
593
[paraview-issues]: https://gitlab.kitware.com/paraview/paraview/-/issues
594
[python]: https://python.org
595
[pythonwindows]: https://www.python.org/downloads/windows/
596
[qt-download]: https://download.qt.io/official_releases/qt
597
[qt]: https://qt.io
598
[qt-download-5.12.3]: https://download.qt.io/archive/qt/5.12/5.12.3/
599
600
[tbb]: https://github.com/intel/tbb/releases
[visual-studio]: https://visualstudio.microsoft.com/vs/older-downloads
601
602
[spack]: https://spack.io/
[spack-docs]: https://spack.readthedocs.io/en/latest/