Ubuntu
adios2 package

adios2 2.9.2+dfsg1-13build2 source package in Ubuntu

Changelog

adios2 (2.9.2+dfsg1-13build2) noble; urgency=medium

  * No-change rebuild against libhdf5-103-1t64

 -- Steve Langasek <email address hidden>  Wed, 13 Mar 2024 17:51:38 +0000

Upload details

Uploaded by:
Steve Langasek
Uploaded to:
Noble
Original maintainer:
Ubuntu Developers
Architectures:
any all
Section:
misc
Urgency:
Medium Urgency

See full publishing history Publishing

Series Pocket Published Component Section

Downloads

File Size SHA-256 Checksum
adios2_2.9.2+dfsg1.orig.tar.xz 3.0 MiB e9f3a5c5abbf1903f2812cedd26e9b50fbf54d707cb6f92a286a3323ae1b11c4
adios2_2.9.2+dfsg1-13build2.debian.tar.xz 22.1 KiB 0a9be048bf803e66528d1c480cf9d1d702b523f34a10b8cd2db766e1d9f6b1c9
adios2_2.9.2+dfsg1-13build2.dsc 4.8 KiB ff636e200940cae892e15c3f58a6c3f77b89c3c623376ab4ab107c9aee73c4ee

View changes file

Binary packages built by this source

adios2-data: 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.

adios2-mpi-bin: 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.

adios2-mpi-bin-dbgsym: debug symbols for adios2-mpi-bin
adios2-scripts: 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.

adios2-serial-bin: 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.

adios2-serial-bin-dbgsym: debug symbols for adios2-serial-bin
libadios2-common-c++11-dev: 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.

libadios2-common-c-dev: 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.

libadios2-common-core-dev: 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.

libadios2-mpi-auxiliary-2: 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

libadios2-mpi-auxiliary-2-dbgsym: debug symbols for libadios2-mpi-auxiliary-2
libadios2-mpi-auxiliary-dev: 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

libadios2-mpi-c++11-2: 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.

libadios2-mpi-c++11-2-dbgsym: debug symbols for libadios2-mpi-c++11-2
libadios2-mpi-c++11-dev: 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.

libadios2-mpi-c-2: 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.

libadios2-mpi-c-2-dbgsym: debug symbols for libadios2-mpi-c-2
libadios2-mpi-c-dev: 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.

libadios2-mpi-core-2: 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.

libadios2-mpi-core-2-dbgsym: debug symbols for libadios2-mpi-core-2
libadios2-mpi-core-dev: 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.

libadios2-mpi-fortran-2: 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.

libadios2-mpi-fortran-2-dbgsym: debug symbols for libadios2-mpi-fortran-2
libadios2-mpi-fortran-dev: 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.

libadios2-serial-auxiliary-2: 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

libadios2-serial-auxiliary-2-dbgsym: debug symbols for libadios2-serial-auxiliary-2
libadios2-serial-auxiliary-dev: 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

libadios2-serial-c++11-2: 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.

libadios2-serial-c++11-2-dbgsym: debug symbols for libadios2-serial-c++11-2
libadios2-serial-c++11-dev: 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.

libadios2-serial-c-2: 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.

libadios2-serial-c-2-dbgsym: debug symbols for libadios2-serial-c-2
libadios2-serial-c-dev: 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.

libadios2-serial-core-2: 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.

libadios2-serial-core-2-dbgsym: debug symbols for libadios2-serial-core-2
libadios2-serial-core-dev: 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.

libadios2-serial-fortran-2: 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.

libadios2-serial-fortran-2-dbgsym: debug symbols for libadios2-serial-fortran-2
libadios2-serial-fortran-dev: 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.

python3-adios2: 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.

python3-adios2-mpi: 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.

python3-adios2-mpi-dbgsym: debug symbols for python3-adios2-mpi
python3-adios2-serial: 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.

python3-adios2-serial-dbgsym: debug symbols for python3-adios2-serial