adios2 2.8.2+dfsg1-2 source package in Ubuntu
Changelog
adios2 (2.8.2+dfsg1-2) unstable; urgency=medium
* Build-Depends: architecture-is-64-bit, architecture-properties
adios2 does not support 32-bit architectures
cf. upstream docs setting_up.html#building-on-hpc-systems,
upstream issues #1823, #2704
* debian/tests: run actual tests from testing/install in
adios2-{serial,mpi}-tests and move examples to
adios2-{serial,mpi}-examples
-- Drew Parsons <email address hidden> Sun, 19 Nov 2023 12:45:41 +0100
Upload details
- Uploaded by:
- Debian Science Team
- Uploaded to:
- Sid
- Original maintainer:
- Debian Science Team
- Architectures:
- any all
- Section:
- misc
- Urgency:
- Medium Urgency
See full publishing history Publishing
| Series | Published | Component | Section |
|---|
Downloads
| File | Size | SHA-256 Checksum |
|---|---|---|
| adios2_2.8.2+dfsg1-2.dsc | 4.6 KiB | 1d0511a3e1097d7f3a5e2682d24006408b6557dbab4a9e5a1d17c700d2e943d3 |
| adios2_2.8.2+dfsg1.orig.tar.xz | 2.6 MiB | c2ad57742c744c871ef79afeff2c9994c7fd857c3e7875c3dc74a6b636d54706 |
| adios2_2.8.2+dfsg1-2.debian.tar.xz | 12.9 KiB | 589f73934e2aff08e4b64355b571d81cf886b0f5e21f2f75a7c565598eaca6fd |
Available diffs
- diff from 2.8.2+dfsg1-1 to 2.8.2+dfsg1-2 (2.6 KiB)
No changes file available.
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
