openPMD-api 0.15.2__tar.gz → 0.16.1__tar.gz

{openPMD-api-0.15.2 → openpmd_api-0.16.1}/CMakeLists.txt

@@ -1,30 +1,21 @@
 # Preamble ####################################################################
 #
-cmake_minimum_required(VERSION 3.15.0)
+cmake_minimum_required(VERSION 3.22.0)
 
-project(openPMD VERSION 0.15.2) # LANGUAGES CXX
+project(openPMD VERSION 0.16.1) # LANGUAGES CXX
 
 # the openPMD "markup"/"schema" standard version
 set(openPMD_STANDARD_VERSION 1.1.0)
 
 include(${openPMD_SOURCE_DIR}/cmake/openPMDFunctions.cmake)
 
-list(APPEND CMAKE_MODULE_PATH "${openPMD_SOURCE_DIR}/share/openPMD/cmake")
-
 
 # CMake policies ##############################################################
 #
-# Search in <PackageName>_ROOT:
-#   https://cmake.org/cmake/help/v3.12/policy/CMP0074.html
-if(POLICY CMP0074)
-    cmake_policy(SET CMP0074 NEW)
-endif()
-
-# We use simple syntax in cmake_dependent_option, so we are compatible with the
-# extended syntax in CMake 3.22+
-# https://cmake.org/cmake/help/v3.22/policy/CMP0127.html
-if(POLICY CMP0127)
-    cmake_policy(SET CMP0127 NEW)
+# CMake 3.24+ tarball download robustness
+#   https://cmake.org/cmake/help/latest/module/ExternalProject.html#url
+if(POLICY CMP0135)
+    cmake_policy(SET CMP0135 NEW)
 endif()
 
 
@@ -144,17 +135,19 @@ endfunction()
 
 openpmd_option(MPI            "Parallel, Multi-Node I/O for clusters"     AUTO)
 openpmd_option(HDF5           "HDF5 backend (.h5 files)"                  AUTO)
-openpmd_option(ADIOS1         "ADIOS1 backend (.bp files)"                 OFF)
 openpmd_option(ADIOS2         "ADIOS2 backend (.bp files)"                AUTO)
 openpmd_option(PYTHON         "Enable Python bindings"                    AUTO)
 
 option(openPMD_INSTALL               "Add installation targets"             ON)
 option(openPMD_INSTALL_RPATH         "Add RPATHs to installed binaries"     ON)
 option(openPMD_HAVE_PKGCONFIG        "Generate a .pc file for pkg-config"   ON)
-option(openPMD_USE_INTERNAL_CATCH    "Use internally shipped Catch2"        ON)
-option(openPMD_USE_INTERNAL_PYBIND11 "Use internally shipped pybind11"      ON)
-option(openPMD_USE_INTERNAL_JSON     "Use internally shipped nlohmann-json" ON)
-option(openPMD_USE_INTERNAL_TOML11   "Use internally shipped toml11"        ON)
+
+# superbuild control
+option(openPMD_SUPERBUILD            "Download & build extra dependencies"  ON)
+option(openPMD_USE_INTERNAL_CATCH    "Use internally shipped Catch2"        ${openPMD_SUPERBUILD})
+option(openPMD_USE_INTERNAL_PYBIND11 "Use internally shipped pybind11"      ${openPMD_SUPERBUILD})
+option(openPMD_USE_INTERNAL_JSON     "Use internally shipped nlohmann-json" ${openPMD_SUPERBUILD})
+option(openPMD_USE_INTERNAL_TOML11   "Use internally shipped toml11"        ${openPMD_SUPERBUILD})
 
 option(openPMD_USE_INVASIVE_TESTS "Enable unit tests that modify source code" OFF)
 option(openPMD_USE_VERIFY "Enable internal VERIFY (assert) macro independent of build type" ON)
@@ -226,6 +219,8 @@ endfunction()
 
 # Dependencies ################################################################
 #
+message(STATUS "openPMD-api superbuild: ${openPMD_SUPERBUILD}")
+
 # external library: MPI (optional)
 # Implementation quirks for BullMPI, Clang+MPI and Brew's MPICH
 #   definitely w/o MPI::MPI_C:
@@ -262,33 +257,17 @@ endif()
 
 
 # external library: nlohmann-json (required)
-if(openPMD_USE_INTERNAL_JSON)
-    set(JSON_BuildTests OFF CACHE INTERNAL "")
-    set(JSON_Install OFF CACHE INTERNAL "")  # only used PRIVATE
-    add_subdirectory("${openPMD_SOURCE_DIR}/share/openPMD/thirdParty/json")
-    message(STATUS "nlohmann-json: Using INTERNAL version '3.9.1'")
-else()
-    find_package(nlohmann_json 3.9.1 CONFIG REQUIRED)
-    message(STATUS "nlohmann-json: Found version '${nlohmann_json_VERSION}'")
-endif()
+include(${openPMD_SOURCE_DIR}/cmake/dependencies/json.cmake)
 add_library(openPMD::thirdparty::nlohmann_json INTERFACE IMPORTED)
 target_link_libraries(openPMD::thirdparty::nlohmann_json
     INTERFACE nlohmann_json::nlohmann_json)
 
-# external library: toml11
-if(openPMD_USE_INTERNAL_TOML11)
-    set(toml11_INSTALL OFF CACHE INTERNAL "")
-    add_subdirectory("${openPMD_SOURCE_DIR}/share/openPMD/thirdParty/toml11")
-    message(STATUS "toml11: Using INTERNAL version '3.7.1'")
-else()
-    find_package(toml11 3.7.1 CONFIG REQUIRED)
-    message(STATUS "toml11: Found version '${toml11_VERSION}'")
-endif()
+# external library: toml11 (required)
+include(${openPMD_SOURCE_DIR}/cmake/dependencies/toml11.cmake)
 add_library(openPMD::thirdparty::toml11 INTERFACE IMPORTED)
 target_link_libraries(openPMD::thirdparty::toml11
     INTERFACE toml11::toml11)
 
-
 # external: CUDA (optional)
 if(openPMD_BUILD_EXAMPLES)  # currently only used in examples
     if(openPMD_USE_CUDA_EXAMPLES STREQUAL AUTO)
@@ -335,7 +314,7 @@ endif()
 string(CONCAT openPMD_HDF5_STATUS "")
 # version: lower limit
 if(openPMD_HAVE_HDF5)
-    if(HDF5_VERSION STREQUAL "")
+    if("${HDF5_VERSION}" STREQUAL "")
         message(WARNING "HDF5_VERSION is empty. Now assuming it is 1.8.13 or newer.")
     else()
         if(HDF5_VERSION VERSION_LESS 1.8.13)
@@ -380,122 +359,28 @@ if(openPMD_HDF5_STATUS)
     endif()
 endif()
 
-#   always search for a sequential lib first, so we can mock MPI
-find_package(ADIOS 1.13.1 COMPONENTS sequential QUIET)
-set(ADIOS_DEFINITIONS_SEQUENTIAL ${ADIOS_DEFINITIONS})
-set(ADIOS_LIBRARIES_SEQUENTIAL ${ADIOS_LIBRARIES})
-set(ADIOS_INCLUDE_DIRS_SEQUENTIAL ${ADIOS_INCLUDE_DIRS})
-unset(ADIOS_FOUND CACHE)
-unset(ADIOS_VERSION CACHE)
-
-#   regular logic
-set(ADIOS1_PREFER_COMPONENTS)
-if(NOT openPMD_HAVE_MPI)
-    set(ADIOS1_PREFER_COMPONENTS sequential)
-endif()
-if(openPMD_USE_ADIOS1 STREQUAL AUTO)
-    find_package(ADIOS 1.13.1 COMPONENTS ${ADIOS1_PREFER_COMPONENTS})
-    if(ADIOS_FOUND)
-        set(openPMD_HAVE_ADIOS1 TRUE)
-    else()
-        set(openPMD_HAVE_ADIOS1 FALSE)
-    endif()
-elseif(openPMD_USE_ADIOS1)
-    find_package(ADIOS 1.13.1 REQUIRED COMPONENTS ${ADIOS1_PREFER_COMPONENTS})
-    set(openPMD_HAVE_ADIOS1 TRUE)
-else()
-    set(openPMD_HAVE_ADIOS1 FALSE)
-endif()
-
-if(openPMD_HAVE_MPI AND openPMD_HAVE_ADIOS1 AND ADIOS_HAVE_SEQUENTIAL)
-    string(CONCAT openPMD_ADIOS1_STATUS
-        "Found MPI but requested ADIOS1 is serial. "
-        "Set openPMD_USE_MPI=OFF to disable MPI.\n"
-        "If you manually installed a parallel version of ADIOS1 in "
-        "a non-default path, add its installation prefix to the "
-        "environment variable CMAKE_PREFIX_PATH to find it: "
-        "https://cmake.org/cmake/help/latest/envvar/CMAKE_PREFIX_PATH.html")
-    if(openPMD_USE_ADIOS1 STREQUAL AUTO)
-        message(WARNING "${openPMD_ADIOS1_STATUS}")
-        set(openPMD_HAVE_ADIOS1 FALSE)
-    elseif(openPMD_USE_ADIOS1)
-        message(FATAL_ERROR "${openPMD_ADIOS1_STATUS}")
-    endif()
-endif()
-if(NOT openPMD_HAVE_MPI AND openPMD_HAVE_ADIOS1 AND NOT ADIOS_HAVE_SEQUENTIAL)
-    string(CONCAT openPMD_ADIOS1_STATUS
-        "Did not find MPI but requested ADIOS1 is parallel. "
-        "Set openPMD_USE_ADIOS1=OFF to disable ADIOS1.\n"
-        "If you manually installed a serial version of ADIOS1 in "
-        "a non-default path, add its installation prefix to the "
-        "environment variable CMAKE_PREFIX_PATH to find it: "
-        "https://cmake.org/cmake/help/latest/envvar/CMAKE_PREFIX_PATH.html")
-    if(openPMD_USE_ADIOS1 STREQUAL AUTO)
-        message(WARNING "${openPMD_ADIOS1_STATUS}")
-        set(openPMD_HAVE_ADIOS1 FALSE)
-    elseif(openPMD_USE_ADIOS1)
-        message(FATAL_ERROR "${openPMD_ADIOS1_STATUS}")
-    endif()
-endif()
-
 # external library: ADIOS2 (optional)
+set(openPMD_REQUIRED_ADIOS2_COMPONENTS CXX)
+if(openPMD_HAVE_MPI)
+    list(APPEND openPMD_REQUIRED_ADIOS2_COMPONENTS MPI)
+endif()
 if(openPMD_USE_ADIOS2 STREQUAL AUTO)
-    find_package(ADIOS2 2.7.0 CONFIG)
+    find_package(ADIOS2 2.7.0 CONFIG COMPONENTS ${openPMD_REQUIRED_ADIOS2_COMPONENTS})
     if(ADIOS2_FOUND)
         set(openPMD_HAVE_ADIOS2 TRUE)
     else()
         set(openPMD_HAVE_ADIOS2 FALSE)
     endif()
 elseif(openPMD_USE_ADIOS2)
-    find_package(ADIOS2 2.7.0 REQUIRED CONFIG)
+    find_package(ADIOS2 2.7.0 REQUIRED CONFIG COMPONENTS ${openPMD_REQUIRED_ADIOS2_COMPONENTS})
     set(openPMD_HAVE_ADIOS2 TRUE)
 else()
     set(openPMD_HAVE_ADIOS2 FALSE)
 endif()
-
-# TODO: Check if ADIOS2 is parallel when openPMD_HAVE_MPI is ON
+unset(openPMD_REQUIRED_ADIOS2_COMPONENTS)
 
 # external library: pybind11 (optional)
-set(_PY_DEV_MODULE Development.Module)
-if(CMAKE_VERSION VERSION_LESS 3.18.0)
-    # over-specification needed for CMake<3.18
-    #   https://pybind11.readthedocs.io/en/latest/compiling.html#findpython-mode
-    #   https://cmake.org/cmake/help/v3.18/module/FindPython.html
-    set(_PY_DEV_MODULE Development)
-endif()
-if(openPMD_USE_PYTHON STREQUAL AUTO)
-    find_package(Python 3.8.0 COMPONENTS Interpreter ${_PY_DEV_MODULE})
-    if(Python_FOUND)
-        if(openPMD_USE_INTERNAL_PYBIND11)
-            add_subdirectory("${openPMD_SOURCE_DIR}/share/openPMD/thirdParty/pybind11")
-            set(openPMD_HAVE_PYTHON TRUE)
-            message(STATUS "pybind11: Using INTERNAL version 2.10.1")
-        else()
-            find_package(pybind11 2.10.1 CONFIG)
-            if(pybind11_FOUND)
-                set(openPMD_HAVE_PYTHON TRUE)
-                message(STATUS "pybind11: Found version '${pybind11_VERSION}'")
-            else()
-                set(openPMD_HAVE_PYTHON FALSE)
-            endif()
-        endif()
-    else()
-        set(openPMD_HAVE_PYTHON FALSE)
-    endif()
-elseif(openPMD_USE_PYTHON)
-    find_package(Python COMPONENTS Interpreter ${_PY_DEV_MODULE} REQUIRED)
-    if(openPMD_USE_INTERNAL_PYBIND11)
-        add_subdirectory("${openPMD_SOURCE_DIR}/share/openPMD/thirdParty/pybind11")
-        set(openPMD_HAVE_PYTHON TRUE)
-        message(STATUS "pybind11: Using INTERNAL version 2.10.1")
-    else()
-        find_package(pybind11 2.10.1 REQUIRED CONFIG)
-        set(openPMD_HAVE_PYTHON TRUE)
-        message(STATUS "pybind11: Found version '${pybind11_VERSION}'")
-    endif()
-else()
-    set(openPMD_HAVE_PYTHON FALSE)
-endif()
+include(${openPMD_SOURCE_DIR}/cmake/dependencies/pybind11.cmake)
 
 
 # Targets #####################################################################
@@ -521,9 +406,9 @@ set(CORE_SOURCE
         src/auxiliary/Date.cpp
         src/auxiliary/Filesystem.cpp
         src/auxiliary/JSON.cpp
+        src/auxiliary/Mpi.cpp
         src/backend/Attributable.cpp
         src/backend/BaseRecordComponent.cpp
-        src/backend/Container.cpp
         src/backend/MeshRecordComponent.cpp
         src/backend/PatchRecord.cpp
         src/backend/PatchRecordComponent.cpp
@@ -544,31 +429,9 @@ set(IO_SOURCE
         src/IO/JSON/JSONIOHandlerImpl.cpp
         src/IO/JSON/JSONFilePosition.cpp
         src/IO/ADIOS/ADIOS2IOHandler.cpp
+        src/IO/ADIOS/ADIOS2File.cpp
         src/IO/ADIOS/ADIOS2Auxiliary.cpp
-        src/IO/ADIOS/ADIOS2PreloadAttributes.cpp
         src/IO/InvalidatableFile.cpp)
-set(IO_ADIOS1_SEQUENTIAL_SOURCE
-        src/auxiliary/Filesystem.cpp
-        src/auxiliary/JSON.cpp
-        src/IO/AbstractIOHandlerImpl.cpp
-        src/ChunkInfo.cpp
-        src/Datatype.cpp
-        src/Error.cpp
-        src/IO/IOTask.cpp
-        src/IO/ADIOS/CommonADIOS1IOHandler.cpp
-        src/IO/ADIOS/ADIOS1IOHandler.cpp
-        src/IO/IOTask.cpp)
-set(IO_ADIOS1_SOURCE
-        src/auxiliary/Filesystem.cpp
-        src/auxiliary/JSON.cpp
-        src/IO/AbstractIOHandlerImpl.cpp
-        src/ChunkInfo.cpp
-        src/Datatype.cpp
-        src/Error.cpp
-        src/IO/IOTask.cpp
-        src/IO/ADIOS/CommonADIOS1IOHandler.cpp
-        src/IO/ADIOS/ParallelADIOS1IOHandler.cpp
-        src/IO/IOTask.cpp)
 
 # library
 if(openPMD_BUILD_SHARED_LIBS)
@@ -635,18 +498,10 @@ target_include_directories(openPMD PUBLIC
 
 # Catch2 for unit tests
 if(openPMD_BUILD_TESTING)
+    include(${openPMD_SOURCE_DIR}/cmake/dependencies/catch.cmake)
     add_library(openPMD::thirdparty::Catch2 INTERFACE IMPORTED)
-    if(openPMD_USE_INTERNAL_CATCH)
-        target_include_directories(openPMD::thirdparty::Catch2 SYSTEM INTERFACE
-            $<BUILD_INTERFACE:${openPMD_SOURCE_DIR}/share/openPMD/thirdParty/catch2/include>
-        )
-        message(STATUS "Catch2: Using INTERNAL version '2.13.10'")
-    else()
-        find_package(Catch2 2.13.10 REQUIRED CONFIG)
-        target_link_libraries(openPMD::thirdparty::Catch2
+    target_link_libraries(openPMD::thirdparty::Catch2
             INTERFACE Catch2::Catch2)
-        message(STATUS "Catch2: Found version '${Catch2_VERSION}'")
-    endif()
 endif()
 
 if(openPMD_HAVE_MPI)
@@ -660,149 +515,13 @@ target_include_directories(openPMD SYSTEM PRIVATE
     $<TARGET_PROPERTY:openPMD::thirdparty::toml11,INTERFACE_INCLUDE_DIRECTORIES>)
 
 # HDF5 Backend
+#   TODO: Once we require CMake 3.20+, simply link hdf5::hdf5 C lib target
 if(openPMD_HAVE_HDF5)
-    target_link_libraries(openPMD PRIVATE ${HDF5_LIBRARIES})
+    target_link_libraries(openPMD PUBLIC ${HDF5_LIBRARIES})
     target_include_directories(openPMD SYSTEM PRIVATE ${HDF5_INCLUDE_DIRS})
     target_compile_definitions(openPMD PRIVATE ${HDF5_DEFINITIONS})
 endif()
 
-# ADIOS1 Backend
-if(openPMD_HAVE_ADIOS1)
-    add_library(openPMD.ADIOS1.Serial SHARED ${IO_ADIOS1_SEQUENTIAL_SOURCE})
-    add_library(openPMD.ADIOS1.Parallel SHARED ${IO_ADIOS1_SOURCE})
-    openpmd_cxx_required(openPMD.ADIOS1.Serial)
-    openpmd_cxx_required(openPMD.ADIOS1.Parallel)
-    target_compile_options(openPMD.ADIOS1.Serial PUBLIC ${_msvc_options})
-    target_compile_options(openPMD.ADIOS1.Parallel PUBLIC ${_msvc_options})
-
-    target_include_directories(openPMD.ADIOS1.Serial PRIVATE
-        ${openPMD_SOURCE_DIR}/include ${openPMD_BINARY_DIR}/include)
-    target_include_directories(openPMD.ADIOS1.Parallel PRIVATE
-        ${openPMD_SOURCE_DIR}/include ${openPMD_BINARY_DIR}/include)
-
-    target_include_directories(openPMD.ADIOS1.Serial SYSTEM PRIVATE
-        $<TARGET_PROPERTY:openPMD::thirdparty::nlohmann_json,INTERFACE_INCLUDE_DIRECTORIES>
-        $<TARGET_PROPERTY:openPMD::thirdparty::toml11,INTERFACE_INCLUDE_DIRECTORIES>)
-    target_include_directories(openPMD.ADIOS1.Parallel SYSTEM PRIVATE
-        $<TARGET_PROPERTY:openPMD::thirdparty::nlohmann_json,INTERFACE_INCLUDE_DIRECTORIES>
-        $<TARGET_PROPERTY:openPMD::thirdparty::toml11,INTERFACE_INCLUDE_DIRECTORIES>)
-
-    set_target_properties(openPMD.ADIOS1.Serial PROPERTIES
-        COMPILE_PDB_NAME openPMD.ADIOS1.Serial
-        ARCHIVE_OUTPUT_DIRECTORY ${openPMD_ARCHIVE_OUTPUT_DIRECTORY}
-        LIBRARY_OUTPUT_DIRECTORY ${openPMD_LIBRARY_OUTPUT_DIRECTORY}
-        RUNTIME_OUTPUT_DIRECTORY ${openPMD_RUNTIME_OUTPUT_DIRECTORY}
-        PDB_OUTPUT_DIRECTORY ${openPMD_PDB_OUTPUT_DIRECTORY}
-        COMPILE_PDB_OUTPUT_DIRECTORY ${openPMD_COMPILE_PDB_OUTPUT_DIRECTORY}
-
-        POSITION_INDEPENDENT_CODE ON
-        CXX_VISIBILITY_PRESET hidden
-        VISIBILITY_INLINES_HIDDEN ON
-    )
-    # note: same as above, but for Multi-Config generators
-    if(isMultiConfig)
-        foreach(CFG IN LISTS CMAKE_CONFIGURATION_TYPES)
-            string(TOUPPER "${CFG}" CFG_UPPER)
-            set_target_properties(openPMD.ADIOS1.Serial PROPERTIES
-                COMPILE_PDB_NAME_${CFG_UPPER} openPMD.ADIOS1.Serial
-                ARCHIVE_OUTPUT_DIRECTORY_${CFG_UPPER} ${openPMD_ARCHIVE_OUTPUT_DIRECTORY}/${CFG}
-                LIBRARY_OUTPUT_DIRECTORY_${CFG_UPPER} ${openPMD_LIBRARY_OUTPUT_DIRECTORY}/${CFG}
-                RUNTIME_OUTPUT_DIRECTORY_${CFG_UPPER} ${openPMD_RUNTIME_OUTPUT_DIRECTORY}/${CFG}
-                PDB_OUTPUT_DIRECTORY_${CFG_UPPER} ${openPMD_PDB_OUTPUT_DIRECTORY}/${CFG}
-                COMPILE_PDB_OUTPUT_DIRECTORY_${CFG_UPPER} ${openPMD_COMPILE_PDB_OUTPUT_DIRECTORY}/${CFG}
-            )
-        endforeach()
-    endif()
-    if("${CMAKE_SYSTEM_NAME}" MATCHES "Linux")
-        set_target_properties(openPMD.ADIOS1.Serial PROPERTIES
-            LINK_FLAGS "-Wl,--exclude-libs,ALL")
-    elseif("${CMAKE_SYSTEM_NAME}" MATCHES "Darwin")
-        set_target_properties(openPMD.ADIOS1.Serial PROPERTIES
-            XCODE_ATTRIBUTE_STRIP_STYLE "non-global"
-            XCODE_ATTRIBUTE_DEPLOYMENT_POSTPROCESSING "YES"
-            XCODE_ATTRIBUTE_SEPARATE_STRIP "YES"
-        )
-    endif()
-    foreach(adlib ${ADIOS_LIBRARIES_SEQUENTIAL})
-        target_link_libraries(openPMD.ADIOS1.Serial PRIVATE ${adlib})
-    endforeach()
-    target_include_directories(openPMD.ADIOS1.Serial SYSTEM PRIVATE ${ADIOS_INCLUDE_DIRS_SEQUENTIAL})
-    target_compile_definitions(openPMD.ADIOS1.Serial PRIVATE "${ADIOS_DEFINITIONS_SEQUENTIAL}")
-    target_compile_definitions(openPMD.ADIOS1.Serial PRIVATE openPMD_HAVE_ADIOS1=1)
-    target_compile_definitions(openPMD.ADIOS1.Serial PRIVATE openPMD_HAVE_MPI=0)
-    target_compile_definitions(openPMD.ADIOS1.Serial PRIVATE _NOMPI)  # ADIOS header
-
-    if(openPMD_HAVE_MPI)
-        set_target_properties(openPMD.ADIOS1.Parallel PROPERTIES
-            COMPILE_PDB_NAME openPMD.ADIOS1.Parallel
-            ARCHIVE_OUTPUT_DIRECTORY ${openPMD_ARCHIVE_OUTPUT_DIRECTORY}
-            LIBRARY_OUTPUT_DIRECTORY ${openPMD_LIBRARY_OUTPUT_DIRECTORY}
-            RUNTIME_OUTPUT_DIRECTORY ${openPMD_RUNTIME_OUTPUT_DIRECTORY}
-            PDB_OUTPUT_DIRECTORY ${openPMD_PDB_OUTPUT_DIRECTORY}
-            COMPILE_PDB_OUTPUT_DIRECTORY ${openPMD_COMPILE_PDB_OUTPUT_DIRECTORY}
-
-            POSITION_INDEPENDENT_CODE ON
-            CXX_VISIBILITY_PRESET hidden
-            VISIBILITY_INLINES_HIDDEN 1
-        )
-        # note: same as above, but for Multi-Config generators
-        if(isMultiConfig)
-            foreach(CFG IN LISTS CMAKE_CONFIGURATION_TYPES)
-                string(TOUPPER "${CFG}" CFG_UPPER)
-                set_target_properties(openPMD.ADIOS1.Parallel PROPERTIES
-                    COMPILE_PDB_NAME_${CFG_UPPER} opemPMD.ADIOS1.Parallel
-                    ARCHIVE_OUTPUT_DIRECTORY_${CFG_UPPER} ${openPMD_ARCHIVE_OUTPUT_DIRECTORY}/${CFG}
-                    LIBRARY_OUTPUT_DIRECTORY_${CFG_UPPER} ${openPMD_LIBRARY_OUTPUT_DIRECTORY}/${CFG}
-                    RUNTIME_OUTPUT_DIRECTORY_${CFG_UPPER} ${openPMD_RUNTIME_OUTPUT_DIRECTORY}/${CFG}
-                    PDB_OUTPUT_DIRECTORY_${CFG_UPPER} ${openPMD_PDB_OUTPUT_DIRECTORY}/${CFG}
-                    COMPILE_PDB_OUTPUT_DIRECTORY_${CFG_UPPER} ${openPMD_COMPILE_PDB_OUTPUT_DIRECTORY}/${CFG}
-                )
-            endforeach()
-        endif()
-        if("${CMAKE_SYSTEM_NAME}" MATCHES "Linux")
-            set_target_properties(openPMD.ADIOS1.Parallel PROPERTIES
-                LINK_FLAGS "-Wl,--exclude-libs,ALL")
-        elseif("${CMAKE_SYSTEM_NAME}" MATCHES "Darwin")
-            set_target_properties(openPMD.ADIOS1.Parallel PROPERTIES
-                XCODE_ATTRIBUTE_STRIP_STYLE "non-global"
-                XCODE_ATTRIBUTE_DEPLOYMENT_POSTPROCESSING "YES"
-                XCODE_ATTRIBUTE_SEPARATE_STRIP "YES"
-            )
-        endif()
-        foreach(adlib ${ADIOS_LIBRARIES})
-            target_link_libraries(openPMD.ADIOS1.Parallel PRIVATE ${adlib})
-        endforeach()
-        target_link_libraries(openPMD.ADIOS1.Parallel PUBLIC ${openPMD_MPI_TARGETS})
-
-        target_include_directories(openPMD.ADIOS1.Parallel SYSTEM PRIVATE ${ADIOS_INCLUDE_DIRS})
-        target_compile_definitions(openPMD.ADIOS1.Parallel PRIVATE "${ADIOS_DEFINITIONS}")
-        target_compile_definitions(openPMD.ADIOS1.Parallel PRIVATE openPMD_HAVE_ADIOS1=1)
-        target_compile_definitions(openPMD.ADIOS1.Parallel PRIVATE openPMD_HAVE_MPI=1)
-    else()
-        target_compile_definitions(openPMD.ADIOS1.Parallel PRIVATE openPMD_HAVE_ADIOS1=0)
-        target_compile_definitions(openPMD.ADIOS1.Parallel PRIVATE openPMD_HAVE_MPI=0)
-        target_compile_definitions(openPMD.ADIOS1.Parallel PRIVATE _NOMPI)  # ADIOS header
-    endif()
-    # This ensures that the ADIOS1 targets don't ever include Error.hpp
-    # To avoid incompatible error types in weird compile configurations
-    target_compile_definitions(openPMD.ADIOS1.Parallel PRIVATE OPENPMD_ADIOS1_IMPLEMENTATION)
-
-    # Runtime parameter and API status checks ("asserts")
-    if(openPMD_USE_VERIFY)
-        target_compile_definitions(openPMD.ADIOS1.Serial PRIVATE openPMD_USE_VERIFY=1)
-        target_compile_definitions(openPMD.ADIOS1.Parallel PRIVATE openPMD_USE_VERIFY=1)
-    else()
-        target_compile_definitions(openPMD.ADIOS1.Serial PRIVATE openPMD_USE_VERIFY=0)
-        target_compile_definitions(openPMD.ADIOS1.Parallel PRIVATE openPMD_USE_VERIFY=0)
-    endif()
-
-    target_link_libraries(openPMD PUBLIC openPMD.ADIOS1.Serial)
-    target_link_libraries(openPMD PUBLIC openPMD.ADIOS1.Parallel)
-else()
-    # add stubs to prevent missing symbols in Clang ASAN/UBSAN
-    target_sources(openPMD PRIVATE ${IO_ADIOS1_SEQUENTIAL_SOURCE} ${IO_ADIOS1_SOURCE})
-endif()
-
 # ADIOS2 Backend
 if(openPMD_HAVE_ADIOS2)
     if(openPMD_HAVE_MPI)
@@ -825,10 +544,8 @@ if(openPMD_HAVE_PYTHON)
         src/binding/python/openPMD.cpp
         src/binding/python/Access.cpp
         src/binding/python/Attributable.cpp
-        src/binding/python/BaseRecord.cpp
         src/binding/python/BaseRecordComponent.cpp
         src/binding/python/ChunkInfo.cpp
-        src/binding/python/Container.cpp
         src/binding/python/Dataset.cpp
         src/binding/python/Datatype.cpp
         src/binding/python/Error.cpp
@@ -857,14 +574,8 @@ if(openPMD_HAVE_PYTHON)
         endif()
     endif()
     message(STATUS "Python LTO/IPO: ${_USE_PY_LTO}")
-    if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.18)
-        set_target_properties(openPMD.py PROPERTIES
-            INTERPROCEDURAL_OPTIMIZATION ${_USE_PY_LTO})
-    else()
-        if(_USE_PY_LTO)
-            target_link_libraries(openPMD.py PRIVATE pybind11::lto)
-        endif()
-    endif()
+    set_target_properties(openPMD.py PROPERTIES
+        INTERPROCEDURAL_OPTIMIZATION ${_USE_PY_LTO})
     unset(_USE_PY_LTO)
 
     if(EMSCRIPTEN)
@@ -1196,6 +907,8 @@ if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
         #                     /usr/lib/llvm-6.0/lib/clang/6.0.0/lib/linux/libclang_rt.ubsan_minimal-x86_64.so
         # at runtime when used with symbol-hidden code (e.g. pybind11 module)
 
+        set(CMAKE_CXX_FLAGS "-Wall -Wextra -Wpedantic -Wshadow -Woverloaded-virtual -Wextra-semi -Wunreachable-code -Wsign-compare ${CMAKE_CXX_FLAGS}")
+    elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "AppleClang")
         set(CMAKE_CXX_FLAGS "-Wall -Wextra -Wpedantic -Wshadow -Woverloaded-virtual -Wextra-semi -Wunreachable-code -Wsign-compare ${CMAKE_CXX_FLAGS}")
     elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Intel")
         set(CMAKE_CXX_FLAGS "-w3 -wd193,383,1572 ${CMAKE_CXX_FLAGS}")
@@ -1273,11 +986,6 @@ write_basic_package_version_file("openPMDConfigVersion.cmake"
 if(openPMD_INSTALL)
     set(openPMD_INSTALL_TARGET_NAMES openPMD)
 
-    if(openPMD_HAVE_ADIOS1)
-        list(APPEND openPMD_INSTALL_TARGET_NAMES
-            openPMD.ADIOS1.Serial openPMD.ADIOS1.Parallel)
-    endif()
-
     if(openPMD_BUILD_CLI_TOOLS)
         foreach(toolname ${openPMD_CLI_TOOL_NAMES})
             list(APPEND openPMD_INSTALL_TARGET_NAMES openpmd-${toolname})
@@ -1361,11 +1069,6 @@ if(openPMD_INSTALL)
             ${openPMD_BINARY_DIR}/openPMDConfigVersion.cmake
         DESTINATION ${openPMD_INSTALL_CMAKEDIR}
     )
-    install(
-        FILES
-            ${openPMD_SOURCE_DIR}/share/openPMD/cmake/FindADIOS.cmake
-        DESTINATION ${openPMD_INSTALL_CMAKEDIR}/Modules
-    )
     # pkg-config .pc file for depending legacy projects
     #   This is for projects that do not use a build file generator, e.g.
     #   because they compile manually on the command line or write their
@@ -1572,7 +1275,7 @@ if(openPMD_BUILD_TESTING)
         # openpmd-pipe (python) test
         if( NOT WIN32
             AND openPMD_HAVE_HDF5
-            AND (openPMD_HAVE_ADIOS2 OR openPMD_HAVE_ADIOS1)
+            AND openPMD_HAVE_ADIOS2
             AND EXAMPLE_DATA_FOUND
         )
             if( openPMD_HAVE_MPI )
@@ -1584,18 +1287,25 @@ if(openPMD_BUILD_TESTING)
                 add_test(NAME CLI.pipe.py
                     COMMAND sh -c
                         "${MPI_TEST_EXE} ${Python_EXECUTABLE}                      \
-                            ${openPMD_RUNTIME_OUTPUT_DIRECTORY}/openpmd-pipe         \
+                            ${openPMD_RUNTIME_OUTPUT_DIRECTORY}/openpmd-pipe       \
                             --infile ../samples/git-sample/data%T.h5               \
                             --outfile ../samples/git-sample/data%T.bp &&           \
                                                                                    \
                         ${MPI_TEST_EXE} ${Python_EXECUTABLE}                       \
-                            ${openPMD_RUNTIME_OUTPUT_DIRECTORY}/openpmd-pipe         \
+                            ${openPMD_RUNTIME_OUTPUT_DIRECTORY}/openpmd-pipe       \
+                            --infile ../samples/git-sample/data00000100.h5         \
+                            --outfile                                              \
+                                ../samples/git-sample/single_iteration_%T.bp &&    \
+                                                                                   \
+                        ${MPI_TEST_EXE} ${Python_EXECUTABLE}                       \
+                            ${openPMD_RUNTIME_OUTPUT_DIRECTORY}/openpmd-pipe       \
                             --infile ../samples/git-sample/thetaMode/data%T.h5     \
-                            --outfile ../samples/git-sample/thetaMode/data.bp &&   \
+                            --outfile                                              \
+                                ../samples/git-sample/thetaMode/data_%T.bp &&      \
                                                                                    \
-                        ${Python_EXECUTABLE}                                       \
-                            ${openPMD_RUNTIME_OUTPUT_DIRECTORY}/openpmd-pipe         \
-                            --infile ../samples/git-sample/thetaMode/data.bp       \
+                        ${MPI_TEST_EXE} ${Python_EXECUTABLE}                       \
+                            ${openPMD_RUNTIME_OUTPUT_DIRECTORY}/openpmd-pipe       \
+                            --infile ../samples/git-sample/thetaMode/data_%T.bp    \
                             --outfile ../samples/git-sample/thetaMode/data%T.json  \
                         "
                     WORKING_DIRECTORY ${openPMD_RUNTIME_OUTPUT_DIRECTORY}
@@ -1604,17 +1314,17 @@ if(openPMD_BUILD_TESTING)
                 add_test(NAME CLI.pipe.py
                     COMMAND sh -c
                         "${Python_EXECUTABLE}                                      \
-                            ${openPMD_RUNTIME_OUTPUT_DIRECTORY}/openpmd-pipe         \
+                            ${openPMD_RUNTIME_OUTPUT_DIRECTORY}/openpmd-pipe       \
                             --infile ../samples/git-sample/data%T.h5               \
                             --outfile ../samples/git-sample/data%T.bp &&           \
                                                                                    \
                         ${Python_EXECUTABLE}                                       \
-                            ${openPMD_RUNTIME_OUTPUT_DIRECTORY}/openpmd-pipe         \
+                            ${openPMD_RUNTIME_OUTPUT_DIRECTORY}/openpmd-pipe       \
                             --infile ../samples/git-sample/thetaMode/data%T.h5     \
                             --outfile ../samples/git-sample/thetaMode/data%T.bp && \
                                                                                    \
                         ${Python_EXECUTABLE}                                       \
-                            ${openPMD_RUNTIME_OUTPUT_DIRECTORY}/openpmd-pipe         \
+                            ${openPMD_RUNTIME_OUTPUT_DIRECTORY}/openpmd-pipe       \
                             --infile ../samples/git-sample/thetaMode/data%T.bp     \
                             --outfile ../samples/git-sample/thetaMode/data%T.json  \
                         "
@@ -1672,7 +1382,6 @@ if(openPMD_BUILD_TESTING)
     endif()
 endif()
 
-
 # Status Message for Build Options ############################################
 #
 openpmd_print_summary()