Source: adios2
Priority: optional
Maintainer: Debian Science Maintainers <debian-science-maintainers@lists.alioth.debian.org>
Uploaders: Drew Parsons <dparsons@debian.org>,
           Francesco Ballarin <francesco.ballarin@unicatt.it>
Build-Depends:
    architecture-is-64-bit, architecture-properties,
    debhelper-compat (= 13),
    dh-cmake,
    dh-cmake-compat (= 1),
    dh-sequence-cmake,
    dh-sequence-ctest,
    dh-sequence-python3,
    cmake,
    ninja-build,
    gfortran,
    pkgconf,
    libenet-dev,
    libpugixml-dev,
    libsodium-dev,
    libyaml-cpp-dev,
    pybind11-dev,
    libgtest-dev,
    nlohmann-json3-dev,
    python3-all-dev,
    python3-numpy,
    libblosc2-dev [!s390x],
    liblz4-dev,
    libbz2-dev,
    libpng-dev,
    libczmq-dev,
    libhdf5-serial-dev,
    libhdf5-mpi-dev,
    libfabric-dev,
    libffi-dev,
    libucx-dev [amd64 arm64],
    libzfp-dev,
    mpi-default-dev,
    python3-mpi4py
Standards-Version: 4.7.2
Section: libs
Homepage: https://github.com/ornladios/ADIOS2
Vcs-Browser: https://salsa.debian.org/science-team/adios2
Vcs-Git: https://salsa.debian.org/science-team/adios2.git

Package: adios2-data
Architecture: all
Multi-Arch: foreign
Depends: ${misc:Depends}
Description: ADIOS2 Adaptable IO system for simulations - tool data
 The Adaptable IO System (ADIOS) provides a simple, flexible way for
 scientists to describe the data in their code that may need to be
 written, read, or processed outside of the running simulation. By
 providing an external to the code XML file describing the various
 elements, their types, and how you wish to process them this run, the
 routines in the host code (either Fortran or C) can transparently
 change how they process the data.
 .
 This package contains tool data for ADIOS2.

Package: adios2-scripts
Architecture: all
Multi-Arch: foreign
Depends: ${python3:Depends}, ${misc:Depends}
Description: ADIOS2 Adaptable IO system for simulations - scripts
 The Adaptable IO System (ADIOS) provides a simple, flexible way for
 scientists to describe the data in their code that may need to be
 written, read, or processed outside of the running simulation. By
 providing an external to the code XML file describing the various
 elements, their types, and how you wish to process them this run, the
 routines in the host code (either Fortran or C) can transparently
 change how they process the data.
 .
 This package contains scripts for ADIOS2.

Package: adios2-serial-bin
Architecture: any
Depends: adios2-scripts, ${shlibs:Depends}, ${misc:Depends}
Description: ADIOS2 Adaptable IO system for simulations - binary tools (serial)
 The Adaptable IO System (ADIOS) provides a simple, flexible way for
 scientists to describe the data in their code that may need to be
 written, read, or processed outside of the running simulation. By
 providing an external to the code XML file describing the various
 elements, their types, and how you wish to process them this run, the
 routines in the host code (either Fortran or C) can transparently
 change how they process the data.
 .
 This package contains binary tools for ADIOS2.

Package: libadios2-serial-core-2.10
Architecture: any
Multi-Arch: same
Depends: ${shlibs:Depends}, ${misc:Depends},
 libadios2-serial-plugins (= ${binary:Version})
Description: ADIOS2 Adaptable IO system for simulations - core libraries (serial)
 The Adaptable IO System (ADIOS) provides a simple, flexible way for
 scientists to describe the data in their code that may need to be
 written, read, or processed outside of the running simulation. By
 providing an external to the code XML file describing the various
 elements, their types, and how you wish to process them this run, the
 routines in the host code (either Fortran or C) can transparently
 change how they process the data.
 .
 This package contains the core libraries for the serial build of
 ADIOS2.

Package: libadios2-serial-plugins
Architecture: any
Multi-Arch: same
Depends: ${shlibs:Depends}, ${misc:Depends}
Replaces: libadios2-serial-core-2
Breaks: libadios2-serial-core-2
Description: ADIOS2 Adaptable IO system for simulations - core libraries (serial)
 The Adaptable IO System (ADIOS) provides a simple, flexible way for
 scientists to describe the data in their code that may need to be
 written, read, or processed outside of the running simulation. By
 providing an external to the code XML file describing the various
 elements, their types, and how you wish to process them this run, the
 routines in the host code (either Fortran or C) can transparently
 change how they process the data.
 .
 This package contains the plugin libraries for the serial build of
 ADIOS2.

Package: libadios2-serial-core-dev
Section: libdevel
Architecture: any
Multi-Arch: no
Depends: libadios2-serial-core-2.10 (= ${binary:Version}),
 libadios2-common-core-dev (= ${binary:Version}),
 libadios2-serial-auxiliary-dev (= ${binary:Version}),
 ${misc:Depends}
Description: Adaptable IO system for simulations - core development files (serial)
 The Adaptable IO System (ADIOS) provides a simple, flexible way for
 scientists to describe the data in their code that may need to be
 written, read, or processed outside of the running simulation. By
 providing an external to the code XML file describing the various
 elements, their types, and how you wish to process them this run, the
 routines in the host code (either Fortran or C) can transparently
 change how they process the data.
 .
 This package contains the core development files for the serial build
 of ADIOS2.

Package: libadios2-serial-c-2.10
Architecture: any
Multi-Arch: same
Depends: ${shlibs:Depends}, ${misc:Depends}
Description: ADIOS2 Adaptable IO system for simulations - C binding libraries (serial)
 The Adaptable IO System (ADIOS) provides a simple, flexible way for
 scientists to describe the data in their code that may need to be
 written, read, or processed outside of the running simulation. By
 providing an external to the code XML file describing the various
 elements, their types, and how you wish to process them this run, the
 routines in the host code (either Fortran or C) can transparently
 change how they process the data.
 .
 This package contains the C binding libraries for the serial build of
 ADIOS2.

Package: libadios2-serial-c-dev
Section: libdevel
Architecture: any
Multi-Arch: same
Depends:
    libadios2-serial-c-2.10 (= ${binary:Version}),
    libadios2-common-c-dev (= ${source:Version}),
    libadios2-serial-core-dev (= ${binary:Version}),
    ${misc:Depends}
Description: Adaptable IO system for simulations - C binding development files (serial)
 The Adaptable IO System (ADIOS) provides a simple, flexible way for
 scientists to describe the data in their code that may need to be
 written, read, or processed outside of the running simulation. By
 providing an external to the code XML file describing the various
 elements, their types, and how you wish to process them this run, the
 routines in the host code (either Fortran or C) can transparently
 change how they process the data.
 .
 This package contains the C binding development files for the serial
 build of ADIOS2.

Package: libadios2-serial-c++11-2.10
Architecture: any
Multi-Arch: same
Depends: ${shlibs:Depends}, ${misc:Depends}
Description: ADIOS2 Adaptable IO system for simulations - C++11 binding libraries (serial)
 The Adaptable IO System (ADIOS) provides a simple, flexible way for
 scientists to describe the data in their code that may need to be
 written, read, or processed outside of the running simulation. By
 providing an external to the code XML file describing the various
 elements, their types, and how you wish to process them this run, the
 routines in the host code (either Fortran or C) can transparently
 change how they process the data.
 .
 This package contains the C++11 binding libraries for the serial build of
 ADIOS2.

Package: libadios2-serial-c++11-dev
Section: libdevel
Architecture: any
Multi-Arch: same
Depends:
    libadios2-serial-c++11-2.10 (= ${binary:Version}),
    libadios2-common-c++11-dev (= ${source:Version}),
    libadios2-serial-core-dev (= ${binary:Version}),
    ${misc:Depends}
Description: Adaptable IO system for simulations - C++11 binding development files (serial)
 The Adaptable IO System (ADIOS) provides a simple, flexible way for
 scientists to describe the data in their code that may need to be
 written, read, or processed outside of the running simulation. By
 providing an external to the code XML file describing the various
 elements, their types, and how you wish to process them this run, the
 routines in the host code (either Fortran or C) can transparently
 change how they process the data.
 .
 This package contains the C++11 binding development files for the serial
 build of ADIOS2.

Package: libadios2-serial-fortran-2.10
Architecture: any
Multi-Arch: same
Depends: ${shlibs:Depends}, ${misc:Depends}
Description: ADIOS2 Adaptable IO system for simulations - Fortran binding libraries (serial)
 The Adaptable IO System (ADIOS) provides a simple, flexible way for
 scientists to describe the data in their code that may need to be
 written, read, or processed outside of the running simulation. By
 providing an external to the code XML file describing the various
 elements, their types, and how you wish to process them this run, the
 routines in the host code (either Fortran or C) can transparently
 change how they process the data.
 .
 This package contains the Fortran binding libraries for the serial build of
 ADIOS2.

Package: libadios2-serial-fortran-dev
Section: libdevel
Architecture: any
Multi-Arch: same
Depends:
    libadios2-serial-fortran-2.10 (= ${binary:Version}),
    libadios2-serial-core-dev (= ${binary:Version}),
    ${misc:Depends}
Conflicts: libadios2-mpi-fortran-dev
Description: Adaptable IO system for simulations - Fortran binding development files (serial)
 The Adaptable IO System (ADIOS) provides a simple, flexible way for
 scientists to describe the data in their code that may need to be
 written, read, or processed outside of the running simulation. By
 providing an external to the code XML file describing the various
 elements, their types, and how you wish to process them this run, the
 routines in the host code (either Fortran or C) can transparently
 change how they process the data.
 .
 This package contains the Fortran binding development files for the serial
 build of ADIOS2.

Package: libadios2-serial-auxiliary-2.10
Architecture: any
Multi-Arch: same
Depends: ${shlibs:Depends}, ${misc:Depends}
Description: ADIOS2 Adaptable IO system for simulations - auxiliary libraries (serial)
 The Adaptable IO System (ADIOS) provides a simple, flexible way for
 scientists to describe the data in their code that may need to be
 written, read, or processed outside of the running simulation. By
 providing an external to the code XML file describing the various
 elements, their types, and how you wish to process them this run, the
 routines in the host code (either Fortran or C) can transparently
 change how they process the data.
 .
 This package contains the auxiliary thirdparty libraries required
 by the serial build of ADIOS2, which are not yet packaged separately:
  - atl
  - dill
  - EVPath
  - ffs
  - perfstubs

Package: libadios2-serial-auxiliary-dev
Section: libdevel
Architecture: any
Multi-Arch: same
Depends:
    libadios2-serial-auxiliary-2.10 (= ${binary:Version}),
    ${misc:Depends}
Description: Adaptable IO system for simulations - auxiliary development files (serial)
 The Adaptable IO System (ADIOS) provides a simple, flexible way for
 scientists to describe the data in their code that may need to be
 written, read, or processed outside of the running simulation. By
 providing an external to the code XML file describing the various
 elements, their types, and how you wish to process them this run, the
 routines in the host code (either Fortran or C) can transparently
 change how they process the data.
 .
 This package contains  binding development files for the auxiliary
 thirdparty libraryies required by the serial build of ADIOS2,
 which are not yet packaged separately:
  - atl
  - dill
  - EVPath
  - ffs
  - perfstubs

Package: python3-adios2-serial
Section: python
Architecture: any
Depends: ${python3:Depends}, ${shlibs:Depends}, ${misc:Depends}
Recommends: python3-adios2
Description: ADIOS2 Adaptable IO system for simulations - Python bindings (serial)
 The Adaptable IO System (ADIOS) provides a simple, flexible way for
 scientists to describe the data in their code that may need to be
 written, read, or processed outside of the running simulation. By
 providing an external to the code XML file describing the various
 elements, their types, and how you wish to process them this run, the
 routines in the host code (either Fortran or C) can transparently
 change how they process the data.
 .
 This package contains the Python bindings for the serial build of
 ADIOS2.

Package: adios2-mpi-bin
Architecture: any
Depends:
    adios2-scripts,
    adios2-data (= ${source:Version}),
    ${python3:Depends},
    ${shlibs:Depends},
    ${misc:Depends}
Description: ADIOS2 Adaptable IO system for simulations - binary tools (MPI)
 The Adaptable IO System (ADIOS) provides a simple, flexible way for
 scientists to describe the data in their code that may need to be
 written, read, or processed outside of the running simulation. By
 providing an external to the code XML file describing the various
 elements, their types, and how you wish to process them this run, the
 routines in the host code (either Fortran or C) can transparently
 change how they process the data.
 .
 This package contains binary tools for the MPI build of ADIOS2.

Package: libadios2-mpi-core-2.10
Architecture: any
Multi-Arch: same
Depends: ${shlibs:Depends}, ${misc:Depends},
 libadios2-mpi-plugins (= ${binary:Version})
Description: ADIOS2 Adaptable IO system for simulations - core libraries (MPI)
 The Adaptable IO System (ADIOS) provides a simple, flexible way for
 scientists to describe the data in their code that may need to be
 written, read, or processed outside of the running simulation. By
 providing an external to the code XML file describing the various
 elements, their types, and how you wish to process them this run, the
 routines in the host code (either Fortran or C) can transparently
 change how they process the data.
 .
 This package contains the core libraries for the MPI build of
 ADIOS2.

Package: libadios2-mpi-plugins
Architecture: any
Multi-Arch: same
Depends: ${shlibs:Depends}, ${misc:Depends}
Replaces: libadios2-mpi-core-2
Breaks: libadios2-mpi-core-2
Description: ADIOS2 Adaptable IO system for simulations - core libraries (MPI)
 The Adaptable IO System (ADIOS) provides a simple, flexible way for
 scientists to describe the data in their code that may need to be
 written, read, or processed outside of the running simulation. By
 providing an external to the code XML file describing the various
 elements, their types, and how you wish to process them this run, the
 routines in the host code (either Fortran or C) can transparently
 change how they process the data.
 .
 This package contains the plugin libraries for the MPI build of
 ADIOS2.

Package: libadios2-mpi-core-dev
Section: libdevel
Architecture: any
Multi-Arch: no
Depends: libadios2-mpi-core-2.10 (= ${binary:Version}),
 libadios2-common-core-dev (= ${binary:Version}),
 libadios2-mpi-auxiliary-dev (= ${binary:Version}),
 ${misc:Depends}
Description: Adaptable IO system for simulations - core development files (MPI)
 The Adaptable IO System (ADIOS) provides a simple, flexible way for
 scientists to describe the data in their code that may need to be
 written, read, or processed outside of the running simulation. By
 providing an external to the code XML file describing the various
 elements, their types, and how you wish to process them this run, the
 routines in the host code (either Fortran or C) can transparently
 change how they process the data.
 .
 This package contains the core development files for the MPI build
 of ADIOS2.

Package: libadios2-mpi-c-2.10
Architecture: any
Multi-Arch: same
Depends: ${shlibs:Depends}, ${misc:Depends}
Description: ADIOS2 Adaptable IO system for simulations - C binding libraries (MPI)
 The Adaptable IO System (ADIOS) provides a simple, flexible way for
 scientists to describe the data in their code that may need to be
 written, read, or processed outside of the running simulation. By
 providing an external to the code XML file describing the various
 elements, their types, and how you wish to process them this run, the
 routines in the host code (either Fortran or C) can transparently
 change how they process the data.
 .
 This package contains the C binding libraries for the MPI build of
 ADIOS2.

Package: libadios2-mpi-c-dev
Architecture: any
Multi-Arch: same
Depends:
    libadios2-mpi-c-2.10 (= ${binary:Version}),
    libadios2-common-c-dev (= ${source:Version}),
    libadios2-mpi-core-dev (= ${binary:Version}),
    ${misc:Depends}
Description: Adaptable IO system for simulations - C binding development files (MPI)
 The Adaptable IO System (ADIOS) provides a simple, flexible way for
 scientists to describe the data in their code that may need to be
 written, read, or processed outside of the running simulation. By
 providing an external to the code XML file describing the various
 elements, their types, and how you wish to process them this run, the
 routines in the host code (either Fortran or C) can transparently
 change how they process the data.
 .
 This package contains the C binding development files for the MPI
 build of ADIOS2.

Package: libadios2-mpi-c++11-2.10
Architecture: any
Multi-Arch: same
Depends: ${shlibs:Depends}, ${misc:Depends}
Description: ADIOS2 Adaptable IO system for simulations - C++11 binding libraries (MPI)
 The Adaptable IO System (ADIOS) provides a simple, flexible way for
 scientists to describe the data in their code that may need to be
 written, read, or processed outside of the running simulation. By
 providing an external to the code XML file describing the various
 elements, their types, and how you wish to process them this run, the
 routines in the host code (either Fortran or C) can transparently
 change how they process the data.
 .
 This package contains the C++11 binding libraries for the MPI build of
 ADIOS2.

Package: libadios2-mpi-c++11-dev
Architecture: any
Multi-Arch: same
Depends:
    libadios2-mpi-c++11-2.10 (= ${binary:Version}),
    libadios2-common-c++11-dev (= ${source:Version}),
    libadios2-mpi-core-dev (= ${binary:Version}),
    ${misc:Depends}
Description: Adaptable IO system for simulations - C++11 binding development files (MPI)
 The Adaptable IO System (ADIOS) provides a simple, flexible way for
 scientists to describe the data in their code that may need to be
 written, read, or processed outside of the running simulation. By
 providing an external to the code XML file describing the various
 elements, their types, and how you wish to process them this run, the
 routines in the host code (either Fortran or C) can transparently
 change how they process the data.
 .
 This package contains the C++11 binding development files for the MPI
 build of ADIOS2.

Package: libadios2-mpi-fortran-2.10
Architecture: any
Multi-Arch: same
Depends: ${shlibs:Depends}, ${misc:Depends}
Description: ADIOS2 Adaptable IO system for simulations - Fortran binding libraries (MPI)
 The Adaptable IO System (ADIOS) provides a simple, flexible way for
 scientists to describe the data in their code that may need to be
 written, read, or processed outside of the running simulation. By
 providing an external to the code XML file describing the various
 elements, their types, and how you wish to process them this run, the
 routines in the host code (either Fortran or C) can transparently
 change how they process the data.
 .
 This package contains the Fortran binding libraries for the MPI build of
 ADIOS2.

Package: libadios2-mpi-fortran-dev
Architecture: any
Multi-Arch: same
Depends:
    libadios2-mpi-fortran-2.10 (= ${binary:Version}),
    libadios2-mpi-core-dev (= ${binary:Version}),
    ${misc:Depends}
Conflicts: libadios2-serial-fortran-dev
Description: Adaptable IO system for simulations - Fortran binding development files (MPI)
 The Adaptable IO System (ADIOS) provides a simple, flexible way for
 scientists to describe the data in their code that may need to be
 written, read, or processed outside of the running simulation. By
 providing an external to the code XML file describing the various
 elements, their types, and how you wish to process them this run, the
 routines in the host code (either Fortran or C) can transparently
 change how they process the data.
 .
 This package contains the Fortran binding development files for the MPI
 build of ADIOS2.

Package: libadios2-mpi-auxiliary-2.10
Architecture: any
Multi-Arch: same
Depends: ${shlibs:Depends}, ${misc:Depends}
Description: ADIOS2 Adaptable IO system for simulations - auxiliary libraries (MPI)
 The Adaptable IO System (ADIOS) provides a simple, flexible way for
 scientists to describe the data in their code that may need to be
 written, read, or processed outside of the running simulation. By
 providing an external to the code XML file describing the various
 elements, their types, and how you wish to process them this run, the
 routines in the host code (either Fortran or C) can transparently
 change how they process the data.
 .
 This package contains the auxiliary thirdparty libraries required
 by the MPI build of ADIOS2, which are not yet packaged separately:
  - atl
  - dill
  - EVPath
  - ffs
  - perfstubs

Package: libadios2-mpi-auxiliary-dev
Architecture: any
Multi-Arch: same
Depends:
    libadios2-mpi-auxiliary-2.10 (= ${binary:Version}),
    ${misc:Depends}
Description: Adaptable IO system for simulations - auxiliary development files (MPI)
 The Adaptable IO System (ADIOS) provides a simple, flexible way for
 scientists to describe the data in their code that may need to be
 written, read, or processed outside of the running simulation. By
 providing an external to the code XML file describing the various
 elements, their types, and how you wish to process them this run, the
 routines in the host code (either Fortran or C) can transparently
 change how they process the data.
 .
 This package contains  binding development files for the auxiliary
 thirdparty libraryies required by the MPI build of ADIOS2,
 which are not yet packaged separately:
  - atl
  - dill
  - EVPath
  - ffs
  - perfstubs

Package: python3-adios2-mpi
Section: python
Architecture: any
Multi-Arch: same
Depends: ${python3:Depends}, ${shlibs:Depends}, ${misc:Depends}
Recommends: python3-adios2
Description: ADIOS2 Adaptable IO system for simulations - Python bindings (MPI)
 The Adaptable IO System (ADIOS) provides a simple, flexible way for
 scientists to describe the data in their code that may need to be
 written, read, or processed outside of the running simulation. By
 providing an external to the code XML file describing the various
 elements, their types, and how you wish to process them this run, the
 routines in the host code (either Fortran or C) can transparently
 change how they process the data.
 .
 This package contains the Python bindings for the MPI build of
 ADIOS2.

Package: python3-adios2
Section: python
Architecture: all
Depends: python3-adios2-serial | python3-adios2-mpi,
 python3-numpy,
 ${python3:Depends}, ${misc:Depends}
Description: ADIOS2 Adaptable IO system for simulations - Python bindings
 The Adaptable IO System (ADIOS) provides a simple, flexible way for
 scientists to describe the data in their code that may need to be
 written, read, or processed outside of the running simulation. By
 providing an external to the code XML file describing the various
 elements, their types, and how you wish to process them this run, the
 routines in the host code (either Fortran or C) can transparently
 change how they process the data.
 .
 This is a dependency package raquiring either the serial or MPI build
 of the ADIOS2 Python bindings.

Package: libadios2-common-core-dev
Section: libdevel
Architecture: any
Multi-Arch: no
Depends: ${misc:Depends}
Recommends: libadios2-serial-core-dev (= ${binary:Version}) | libadios2-mpi-core-dev (= ${binary:Version}),
Description: Adaptable IO system for simulations - core include files (common)
 The Adaptable IO System (ADIOS) provides a simple, flexible way for
 scientists to describe the data in their code that may need to be
 written, read, or processed outside of the running simulation. By
 providing an external to the code XML file describing the various
 elements, their types, and how you wish to process them this run, the
 routines in the host code (either Fortran or C) can transparently
 change how they process the data.
 .
 This package contains the common core include files for ADIOS2.

Package: libadios2-common-c-dev
Architecture: all
Multi-Arch: foreign
Depends: ${misc:Depends}
Recommends: libadios2-serial-c-dev (= ${binary:Version}) | libadios2-mpi-c-dev (= ${binary:Version})
Description: Adaptable IO system for simulations - C binding include files (common)
 The Adaptable IO System (ADIOS) provides a simple, flexible way for
 scientists to describe the data in their code that may need to be
 written, read, or processed outside of the running simulation. By
 providing an external to the code XML file describing the various
 elements, their types, and how you wish to process them this run, the
 routines in the host code (either Fortran or C) can transparently
 change how they process the data.
 .
 This package contains the common C binding include files for ADIOS2.

Package: libadios2-common-c++11-dev
Architecture: all
Multi-Arch: foreign
Depends: ${misc:Depends}
Recommends: libadios2-serial-c++11-2.10 (= ${binary:Version}) | libadios2-mpi-c++11-2.10 (= ${binary:Version})
Description: Adaptable IO system for simulations - C++11 binding include files (common)
 The Adaptable IO System (ADIOS) provides a simple, flexible way for
 scientists to describe the data in their code that may need to be
 written, read, or processed outside of the running simulation. By
 providing an external to the code XML file describing the various
 elements, their types, and how you wish to process them this run, the
 routines in the host code (either Fortran or C) can transparently
 change how they process the data.
 .
 This package contains the common C++11 binding include files for ADIOS2.