diff --git a/.gitlab-ci/CMakeLists.txt b/.gitlab-ci/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/.gitlab/CMakeLists.txt b/.gitlab/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..22911ef71f701bc1e623c34d377d50b800596bd5 --- /dev/null +++ b/.gitlab/CMakeLists.txt @@ -0,0 +1,2 @@ +add_subdirectory(issue_templates) +add_subdirectory(merge_request_templates) diff --git a/.gitlab/issue_templates/CMakeLists.txt b/.gitlab/issue_templates/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/.gitlab/merge_request_templates/CMakeLists.txt b/.gitlab/merge_request_templates/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/bin/CMakeLists.txt b/bin/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..95260002b0b12a9a0b0502c2d5aed211757b4013 --- /dev/null +++ b/bin/CMakeLists.txt @@ -0,0 +1,5 @@ +add_subdirectory(doc) +add_subdirectory(extractmodule) +add_subdirectory(postprocessing) +add_subdirectory(testing) +add_subdirectory(util) diff --git a/bin/doc/CMakeLists.txt b/bin/doc/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/bin/extractmodule/CMakeLists.txt b/bin/extractmodule/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..a8f0f0c98c9b3106fd19e24c5da51a4bfed461d3 --- /dev/null +++ b/bin/extractmodule/CMakeLists.txt @@ -0,0 +1 @@ +add_subdirectory(__pycache__) diff --git a/bin/postprocessing/CMakeLists.txt b/bin/postprocessing/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/bin/util/CMakeLists.txt b/bin/util/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..a8f0f0c98c9b3106fd19e24c5da51a4bfed461d3 --- /dev/null +++ b/bin/util/CMakeLists.txt @@ -0,0 +1 @@ +add_subdirectory(__pycache__) diff --git a/cmake/CMakeLists.txt b/cmake/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..8e2019b6e601d27f86b92e0f043ff65cf59be701 --- /dev/null +++ b/cmake/CMakeLists.txt @@ -0,0 +1 @@ +add_subdirectory(modules) diff --git a/cmake/modules/CMakeLists.txt b/cmake/modules/CMakeLists.txt index 27a97a8fdf9d5b50337c8b57e6ccba597edb6d7f..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644 --- a/cmake/modules/CMakeLists.txt +++ b/cmake/modules/CMakeLists.txt @@ -1,12 +0,0 @@ -set(modules - AddGstatFileLinks.cmake - AddInputFileLinks.cmake - DumuxDoxygen.cmake - DumuxMacros.cmake - DumuxTestMacros.cmake - FindGLPK.cmake - FindGstat.cmake - FindNLOPT.cmake - FindPVPython.cmake) -include(GNUInstallDirs) -install(FILES ${modules} DESTINATION ${DUNE_INSTALL_MODULEDIR}) diff --git a/doc/CMakeLists.txt b/doc/CMakeLists.txt index 2a9b713384bba69e9f80aa5924dd908fddbf4532..0c9d0732a7cd4a16df16eaf0c6fa7809b5cc6e79 100644 --- a/doc/CMakeLists.txt +++ b/doc/CMakeLists.txt @@ -1,2 +1,4 @@ +add_subdirectory(docextra) add_subdirectory(doxygen) add_subdirectory(handbook) +add_subdirectory(logo) diff --git a/doc/docextra/3dmpfa/CMakeLists.txt b/doc/docextra/3dmpfa/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..870397bac8caf85a4b4e906d80ee8ca73e116dce --- /dev/null +++ b/doc/docextra/3dmpfa/CMakeLists.txt @@ -0,0 +1 @@ +add_subdirectory(Tikz) diff --git a/doc/docextra/3dmpfa/Tikz/CMakeLists.txt b/doc/docextra/3dmpfa/Tikz/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/doc/docextra/CMakeLists.txt b/doc/docextra/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..bd0ed5acd17825158dde85ea579b99205cd8fee9 --- /dev/null +++ b/doc/docextra/CMakeLists.txt @@ -0,0 +1,2 @@ +add_subdirectory(3dmpfa) +add_subdirectory(staggered) diff --git a/doc/docextra/staggered/CMakeLists.txt b/doc/docextra/staggered/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..b1ee606d9baf9cf398a4e7760d33f7734c3891d7 --- /dev/null +++ b/doc/docextra/staggered/CMakeLists.txt @@ -0,0 +1 @@ +add_subdirectory(pictures) diff --git a/doc/docextra/staggered/pictures/CMakeLists.txt b/doc/docextra/staggered/pictures/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/doc/doxygen/CMakeLists.txt b/doc/doxygen/CMakeLists.txt index 9f66c1ba47a600577308610f1d7ce17840c7fbdd..3b6fcda5816f0fbfb26974dadbb62d5006ed27d7 100644 --- a/doc/doxygen/CMakeLists.txt +++ b/doc/doxygen/CMakeLists.txt @@ -1,2 +1,2 @@ -# shortcut for creating the Doxyfile.in and Doxyfile -add_dumux_doxygen_target() +add_subdirectory(extradoc) +add_subdirectory(images) diff --git a/doc/doxygen/extradoc/CMakeLists.txt b/doc/doxygen/extradoc/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/doc/doxygen/images/CMakeLists.txt b/doc/doxygen/images/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/doc/handbook/CMakeLists.txt b/doc/handbook/CMakeLists.txt index 95a0d105bcbd50514f761c1265d43461194ed599..574f5dba4cdc16f8a6482ddde7a2793fc5dca81a 100644 --- a/doc/handbook/CMakeLists.txt +++ b/doc/handbook/CMakeLists.txt @@ -1,5 +1,3 @@ -# use latexmk -dune_add_latex_document( - SOURCE 0_dumux-handbook.tex - FATHER_TARGET doc - INSTALL ${CMAKE_INSTALL_DOCDIR}/doc/handbook) +add_subdirectory(pdf) +add_subdirectory(png) +add_subdirectory(svg) diff --git a/doc/handbook/pdf/CMakeLists.txt b/doc/handbook/pdf/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/doc/handbook/png/CMakeLists.txt b/doc/handbook/png/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/doc/handbook/svg/CMakeLists.txt b/doc/handbook/svg/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/doc/logo/CMakeLists.txt b/doc/logo/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/docker/CMakeLists.txt b/docker/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/examples/1protationsymmetry/CMakeLists.txt b/examples/1protationsymmetry/CMakeLists.txt index 03acc84bdb3f15e1bc6861af0f42903b21a90723..67940ab531d3fb2030333f2f4806d2f3bdeb726a 100644 --- a/examples/1protationsymmetry/CMakeLists.txt +++ b/examples/1protationsymmetry/CMakeLists.txt @@ -1,10 +1,6 @@ -dune_symlink_to_source_files(FILES "params.input") +add_subdirectory(doc) +add_subdirectory(img) -dumux_add_test(NAME example_1p_rotationsymmetry - LABELS porousmediumflow 1p example - SOURCES main.cc - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/example_rotationsymmetry-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/example_rotationsymmetry-00000.vtp - --command "${CMAKE_CURRENT_BINARY_DIR}/example_1p_rotationsymmetry params.input -Problem.Name example_rotationsymmetry") +file(GLOB DUMUX_EXAMPLES_1PROTATIONSYMMETRY_HEADERS *.hh *.inc) +install(FILES ${DUMUX_EXAMPLES_1PROTATIONSYMMETRY_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/examples/1protationsymmetry) diff --git a/examples/1protationsymmetry/doc/CMakeLists.txt b/examples/1protationsymmetry/doc/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/examples/1protationsymmetry/img/CMakeLists.txt b/examples/1protationsymmetry/img/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/examples/1ptracer/CMakeLists.txt b/examples/1ptracer/CMakeLists.txt index 1f21b1686fa128bcac5d1a5534e9a1f2c46a0e52..153ee5052261763411bc4adaed20a5e7344a4338 100644 --- a/examples/1ptracer/CMakeLists.txt +++ b/examples/1ptracer/CMakeLists.txt @@ -1,12 +1,6 @@ -dune_symlink_to_source_files(FILES "params.input") +add_subdirectory(doc) +add_subdirectory(img) -dumux_add_test(NAME example_1ptracer - LABELS porousmediumflow tracer example - SOURCES main.cc - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1ptracer_transport-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/example_1ptracer-00010.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_1ptracer_pressure-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/1p.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/example_1ptracer params.input -Problem.Name example_1ptracer") +file(GLOB DUMUX_EXAMPLES_1PTRACER_HEADERS *.hh *.inc) +install(FILES ${DUMUX_EXAMPLES_1PTRACER_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/examples/1ptracer) diff --git a/examples/1ptracer/doc/CMakeLists.txt b/examples/1ptracer/doc/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/examples/1ptracer/img/CMakeLists.txt b/examples/1ptracer/img/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/examples/2pinfiltration/CMakeLists.txt b/examples/2pinfiltration/CMakeLists.txt index 2bf75a5c9f550d244c6803bd5a0ecd421a8d2184..2ee622e2cbea6aac4bedc61cb83b858300ba76ae 100644 --- a/examples/2pinfiltration/CMakeLists.txt +++ b/examples/2pinfiltration/CMakeLists.txt @@ -1,13 +1,6 @@ -dune_symlink_to_source_files(FILES "params.input") -dune_symlink_to_source_files(FILES "initialsolutioncc.txt") +add_subdirectory(doc) +add_subdirectory(img) -# using tpfa and point source -dumux_add_test(NAME example_2p_pointsource_adaptive - LABELS porousmediumflow 2p example - SOURCES main.cc - CMAKE_GUARD dune-alugrid_FOUND - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy --zeroThreshold {"pc":0.1} - --files ${CMAKE_SOURCE_DIR}/test/references/example-2padaptive-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/example_2p_pointsource_adaptive-00006.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/example_2p_pointsource_adaptive params.input -TimeLoop.TEnd 100 -TimeLoop.DtInitial 10 -Problem.Name example_2p_pointsource_adaptive") +file(GLOB DUMUX_EXAMPLES_2PINFILTRATION_HEADERS *.hh *.inc) +install(FILES ${DUMUX_EXAMPLES_2PINFILTRATION_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/examples/2pinfiltration) diff --git a/examples/2pinfiltration/doc/CMakeLists.txt b/examples/2pinfiltration/doc/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/examples/2pinfiltration/img/CMakeLists.txt b/examples/2pinfiltration/img/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt index bc4148e17c4b6b288a23dad6c12eeda8408a4cb1..067f0beb3a613cb4c3934c40a8b3a8a0bc34152c 100644 --- a/examples/CMakeLists.txt +++ b/examples/CMakeLists.txt @@ -1,8 +1,8 @@ -add_subdirectory(2pinfiltration) +add_subdirectory(1protationsymmetry) add_subdirectory(1ptracer) +add_subdirectory(2pinfiltration) add_subdirectory(biomineralization) -add_subdirectory(shallowwaterfriction) add_subdirectory(freeflowchannel) -add_subdirectory(1protationsymmetry) add_subdirectory(liddrivencavity) add_subdirectory(porenetwork_upscaling) +add_subdirectory(shallowwaterfriction) diff --git a/examples/biomineralization/CMakeLists.txt b/examples/biomineralization/CMakeLists.txt index 7ac1d9345f6cc9ef5104cc929e75ee8558fb23c2..7453f3618dd64e0e8cfdfca5dea09c150787d960 100644 --- a/examples/biomineralization/CMakeLists.txt +++ b/examples/biomineralization/CMakeLists.txt @@ -1,12 +1,7 @@ -dune_symlink_to_source_files(FILES injection_checkpoints.dat injection_type.dat params.input) +add_subdirectory(doc) +add_subdirectory(img) +add_subdirectory(material) -# compile MICP simplified chemistry column setup -dumux_add_test(NAME example_biomineralization - LABELS porousmediumflow example - TIMEOUT 3600 - SOURCES main.cc - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/example_biomineralization-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/example_biomineralization-00018.vtp - --command "${CMAKE_CURRENT_BINARY_DIR}/example_biomineralization params.input -Problem.Name example_biomineralization") +file(GLOB DUMUX_EXAMPLES_BIOMINERALIZATION_HEADERS *.hh *.inc) +install(FILES ${DUMUX_EXAMPLES_BIOMINERALIZATION_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/examples/biomineralization) diff --git a/examples/biomineralization/doc/CMakeLists.txt b/examples/biomineralization/doc/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/examples/biomineralization/img/CMakeLists.txt b/examples/biomineralization/img/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/examples/biomineralization/material/CMakeLists.txt b/examples/biomineralization/material/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..4c85c663a8de9ee78efc2b5d200e49dd49865368 --- /dev/null +++ b/examples/biomineralization/material/CMakeLists.txt @@ -0,0 +1,7 @@ +add_subdirectory(components) +add_subdirectory(fluidsystems) +add_subdirectory(solidsystems) + +file(GLOB DUMUX_EXAMPLES_BIOMINERALIZATION_MATERIAL_HEADERS *.hh *.inc) +install(FILES ${DUMUX_EXAMPLES_BIOMINERALIZATION_MATERIAL_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/examples/biomineralization/material) diff --git a/examples/biomineralization/material/components/CMakeLists.txt b/examples/biomineralization/material/components/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..443c61f8f50d3e196239b1830d81f69c2494ca16 --- /dev/null +++ b/examples/biomineralization/material/components/CMakeLists.txt @@ -0,0 +1,3 @@ +file(GLOB DUMUX_EXAMPLES_BIOMINERALIZATION_MATERIAL_COMPONENTS_HEADERS *.hh *.inc) +install(FILES ${DUMUX_EXAMPLES_BIOMINERALIZATION_MATERIAL_COMPONENTS_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/examples/biomineralization/material/components) diff --git a/examples/biomineralization/material/fluidsystems/CMakeLists.txt b/examples/biomineralization/material/fluidsystems/CMakeLists.txt index 5b7ccac5a747b9f295a82abe0a7329b9ab02daa2..8eb3bb0e340420aef8bcb617cdfef3eac414c2d2 100644 --- a/examples/biomineralization/material/fluidsystems/CMakeLists.txt +++ b/examples/biomineralization/material/fluidsystems/CMakeLists.txt @@ -1,5 +1,3 @@ -#install headers -install(FILES -biominsimplechemistry.hh -icpcomplexsalinitybrine.hh -DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/material/fluidsystems) +file(GLOB DUMUX_EXAMPLES_BIOMINERALIZATION_MATERIAL_FLUIDSYSTEMS_HEADERS *.hh *.inc) +install(FILES ${DUMUX_EXAMPLES_BIOMINERALIZATION_MATERIAL_FLUIDSYSTEMS_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/examples/biomineralization/material/fluidsystems) diff --git a/examples/biomineralization/material/solidsystems/CMakeLists.txt b/examples/biomineralization/material/solidsystems/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..fb342c8ad968badba0413596dbcab756c4ce495a --- /dev/null +++ b/examples/biomineralization/material/solidsystems/CMakeLists.txt @@ -0,0 +1,3 @@ +file(GLOB DUMUX_EXAMPLES_BIOMINERALIZATION_MATERIAL_SOLIDSYSTEMS_HEADERS *.hh *.inc) +install(FILES ${DUMUX_EXAMPLES_BIOMINERALIZATION_MATERIAL_SOLIDSYSTEMS_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/examples/biomineralization/material/solidsystems) diff --git a/examples/freeflowchannel/CMakeLists.txt b/examples/freeflowchannel/CMakeLists.txt index 62093a0e271d6c0d32bd0a9e3b4c097bdec3a016..68b45f6a620d1dfd3d25bd4d3c8be3645146f26f 100644 --- a/examples/freeflowchannel/CMakeLists.txt +++ b/examples/freeflowchannel/CMakeLists.txt @@ -1,11 +1,6 @@ -dune_symlink_to_source_files(FILES "params.input") +add_subdirectory(doc) +add_subdirectory(img) -dumux_add_test(NAME example_freeflow_channel_navierstokes - LABELS freeflow navierstokes example - SOURCES main.cc - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/example_ff_channel-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/example_ff_channel-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/example_freeflow_channel_navierstokes params.input -Problem.Name example_ff_channel") +file(GLOB DUMUX_EXAMPLES_FREEFLOWCHANNEL_HEADERS *.hh *.inc) +install(FILES ${DUMUX_EXAMPLES_FREEFLOWCHANNEL_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/examples/freeflowchannel) diff --git a/examples/freeflowchannel/doc/CMakeLists.txt b/examples/freeflowchannel/doc/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/examples/freeflowchannel/img/CMakeLists.txt b/examples/freeflowchannel/img/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/examples/liddrivencavity/CMakeLists.txt b/examples/liddrivencavity/CMakeLists.txt index 008e2b11786a8fc0d477dee3061c740827d2f7ec..688e4395212f2000fa793626d76bbcb417f797fe 100644 --- a/examples/liddrivencavity/CMakeLists.txt +++ b/examples/liddrivencavity/CMakeLists.txt @@ -1,41 +1,7 @@ +add_subdirectory(doc) +add_subdirectory(img) add_subdirectory(reference_data) -dune_symlink_to_source_files(FILES "params_re1.input" "params_re1000.input" "run_and_plot.py") -# set the test guard for the following tests (only enable test if UMFPack is available) -set(DUMUX_EXAMPLE_LDC_CMAKE_GUARD "( HAVE_UMFPACK )") - -dumux_add_test(NAME example_ff_liddrivencavity - SOURCES main.cc - LABELS freeflow navierstokes example - CMAKE_GUARD ${DUMUX_EXAMPLE_LDC_CMAKE_GUARD} - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_navierstokes_closedsystem_ldc_re1-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/example_ff_liddrivencavity_re1-00002.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/example_ff_liddrivencavity params_re1.input - -Grid.Cells \"64 64\"") - -dumux_add_test(NAME example_ff_liddrivencavity_re1000 - TARGET example_ff_liddrivencavity - LABELS freeflow navierstokes example - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_navierstokes_closedsystem_ldc_re1000-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/example_ff_liddrivencavity_re1000-00009.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/example_ff_liddrivencavity params_re1000.input - -Grid.Cells \"64 64\" -TimeLoop.TEnd 50") - -# test plot script (only if the guard enables to TRUE, i.e. all preconditions for the above tests are met) -dumux_evaluate_cmake_guard(DUMUX_ENABLE_LDC_PLOT_TEST - CMAKE_GUARD ${DUMUX_EXAMPLE_LDC_CMAKE_GUARD}) - -if (DUMUX_ENABLE_LDC_PLOT_TEST) - dumux_add_test(NAME example_ff_liddrivencavity_plot - TARGET example_ff_liddrivencavity - COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/run_and_plot.py - CMD_ARGS -s -n) - - set_tests_properties(example_ff_liddrivencavity_plot - PROPERTIES LABELS example - DEPENDS "example_ff_liddrivencavity;example_ff_liddrivencavity_re1000") -endif() +file(GLOB DUMUX_EXAMPLES_LIDDRIVENCAVITY_HEADERS *.hh *.inc) +install(FILES ${DUMUX_EXAMPLES_LIDDRIVENCAVITY_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/examples/liddrivencavity) diff --git a/examples/liddrivencavity/doc/CMakeLists.txt b/examples/liddrivencavity/doc/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/examples/liddrivencavity/img/CMakeLists.txt b/examples/liddrivencavity/img/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/examples/liddrivencavity/reference_data/CMakeLists.txt b/examples/liddrivencavity/reference_data/CMakeLists.txt index 17622e6865167abb74c2933b5f9686fc0109f812..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644 --- a/examples/liddrivencavity/reference_data/CMakeLists.txt +++ b/examples/liddrivencavity/reference_data/CMakeLists.txt @@ -1 +0,0 @@ -dune_symlink_to_source_files(FILES "ghia_x.csv" "ghia_y.csv" "v_x_exp.csv" "v_y_exp.csv" "v_x_num.csv" "v_y_num.csv") diff --git a/examples/porenetwork_upscaling/CMakeLists.txt b/examples/porenetwork_upscaling/CMakeLists.txt index 03925f1192758bc69a9d17c42f31789561225f95..9775628ca3f5914bd6c465067311cdf5360c8e86 100644 --- a/examples/porenetwork_upscaling/CMakeLists.txt +++ b/examples/porenetwork_upscaling/CMakeLists.txt @@ -1,9 +1,6 @@ -dune_symlink_to_source_files(FILES "params.input") +add_subdirectory(doc) +add_subdirectory(img) -dumux_add_test(NAME example_pnm1p_permeabilityupscaling - LABELS porenetwork example - SOURCES main.cc - CMAKE_GUARD HAVE_UMFPACK dune-foamgrid_FOUND - COMMAND ${CMAKE_CURRENT_BINARY_DIR}/example_pnm1p_permeabilityupscaling - CMD_ARGS -Problem.ReferenceData "2.95910919e-13 2.91015548e-13 2.71752264e-13" - -Problem.TestEpsilon 1e-7) +file(GLOB DUMUX_EXAMPLES_PORENETWORK_UPSCALING_HEADERS *.hh *.inc) +install(FILES ${DUMUX_EXAMPLES_PORENETWORK_UPSCALING_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/examples/porenetwork_upscaling) diff --git a/examples/porenetwork_upscaling/doc/CMakeLists.txt b/examples/porenetwork_upscaling/doc/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/examples/porenetwork_upscaling/img/CMakeLists.txt b/examples/porenetwork_upscaling/img/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/examples/shallowwaterfriction/CMakeLists.txt b/examples/shallowwaterfriction/CMakeLists.txt index 12e4adb261ed75771fc6a30345e8bb520fb4ceea..f385792ec9da4171886771bf1eedf2473ee0e9be 100644 --- a/examples/shallowwaterfriction/CMakeLists.txt +++ b/examples/shallowwaterfriction/CMakeLists.txt @@ -1,13 +1,6 @@ -dune_symlink_to_source_files(FILES "params.input") +add_subdirectory(doc) +add_subdirectory(img) -dumux_add_test(NAME example_shallowwaterfriction - LABELS shallowwater example - TIMEOUT 3600 - SOURCES main.cc - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/example_shallowwaterfriction-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/example_shallowwaterfriction-00001.vtu - --zeroThreshold {"velocityY":1e-14} - --command "${CMAKE_CURRENT_BINARY_DIR}/example_shallowwaterfriction params.input - -Problem.Name example_shallowwaterfriction") +file(GLOB DUMUX_EXAMPLES_SHALLOWWATERFRICTION_HEADERS *.hh *.inc) +install(FILES ${DUMUX_EXAMPLES_SHALLOWWATERFRICTION_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/examples/shallowwaterfriction) diff --git a/examples/shallowwaterfriction/doc/CMakeLists.txt b/examples/shallowwaterfriction/doc/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/examples/shallowwaterfriction/img/CMakeLists.txt b/examples/shallowwaterfriction/img/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/patches/CMakeLists.txt b/patches/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/patches/dune-common_uncommitted.patch b/patches/dune-common_uncommitted.patch new file mode 100644 index 0000000000000000000000000000000000000000..a54662ac2280543cd50cebf649086841216e13ef --- /dev/null +++ b/patches/dune-common_uncommitted.patch @@ -0,0 +1,16631 @@ +diff --git a/dune/python/CMakeLists.txt b/dune/python/CMakeLists.txt +deleted file mode 100644 +index 5075c1706..000000000 +--- a/dune/python/CMakeLists.txt ++++ /dev/null +@@ -1,3 +0,0 @@ +-add_subdirectory(common) +-add_subdirectory(test) +-add_subdirectory(pybind11) +diff --git a/dune/python/common/CMakeLists.txt b/dune/python/common/CMakeLists.txt +deleted file mode 100644 +index ddf7a70be..000000000 +--- a/dune/python/common/CMakeLists.txt ++++ /dev/null +@@ -1,21 +0,0 @@ +-set(HEADERS +- densematrix.hh +- densevector.hh +- dimrange.hh +- dynmatrix.hh +- dynvector.hh +- fmatrix.hh +- fvecmatregistry.hh +- fvector.hh +- getdimension.hh +- logger.hh +- mpihelper.hh +- numpycommdatahandle.hh +- numpyvector.hh +- pythonvector.hh +- string.hh +- typeregistry.hh +- vector.hh +-) +- +-install(FILES ${HEADERS} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dune/python/common) +diff --git a/dune/python/common/densematrix.hh b/dune/python/common/densematrix.hh +deleted file mode 100644 +index a480f9bf7..000000000 +--- a/dune/python/common/densematrix.hh ++++ /dev/null +@@ -1,74 +0,0 @@ +-#ifndef DUNE_PYTHON_COMMON_DENSEMATRIX_HH +-#define DUNE_PYTHON_COMMON_DENSEMATRIX_HH +- +-#include +-#include +-#include +-#include +- +-#include +-#include +-#include +- +-namespace Dune +-{ +- +- namespace Python +- { +- +- // registerDenseMatrix +- // ------------------- +- +- template< class Matrix > +- void registerDenseMatrix ( pybind11::class_< Matrix > cls ) +- { +- typedef typename Matrix::field_type field_type; +- typedef typename Matrix::row_type row_type; +- typedef typename Matrix::row_reference row_reference; +- +- cls.def( "__getitem__", [] ( Matrix &self, std::size_t i ) -> row_reference { +- if( i < self.mat_rows() ) +- return self[ i ]; +- else +- throw pybind11::index_error(); +- }, (std::is_reference< row_reference >::value ? pybind11::return_value_policy::reference : pybind11::return_value_policy::move), pybind11::keep_alive< 0, 1 >() ); +- +- cls.def( "__setitem__", [] ( Matrix &self, std::size_t i, pybind11::object l ) { +- if( i < self.mat_rows() ) +- { +- row_type v = l.cast< row_type >(); +- std::size_t size = std::min( self.mat_cols(), v.size() ); +- +- for( std::size_t j = 0; j < size; ++j ) +- self[ i ][ j ] = v[ j ]; +- } +- else +- throw pybind11::index_error(); +- } ); +- +- cls.def( "__len__", [] ( const Matrix &self ) -> std::size_t { return self.size(); } ); +- +- cls.def( "invert", [] ( Matrix &self ) { self.invert(); } ); +- +- cls.def( pybind11::self += pybind11::self ); +- cls.def( pybind11::self -= pybind11::self ); +- cls.def( pybind11::self *= field_type() ); +- cls.def( pybind11::self /= field_type() ); +- +- cls.def( pybind11::self == pybind11::self ); +- cls.def( pybind11::self != pybind11::self ); +- +- cls.def_property_readonly( "frobenius_norm", [] ( const Matrix &self ) { return self.frobenius_norm(); } ); +- cls.def_property_readonly( "frobenius_norm2", [] ( const Matrix &self ) { return self.frobenius_norm2(); } ); +- cls.def_property_readonly( "infinity_norm", [] ( const Matrix &self ) { return self.infinity_norm(); } ); +- cls.def_property_readonly( "infinity_norm_real", [] ( const Matrix &self ) { return self.infinity_norm_real(); } ); +- +- cls.def_property_readonly( "rows", [] ( const Matrix &self ) { return self.mat_rows(); } ); +- cls.def_property_readonly( "cols", [] ( const Matrix &self ) { return self.mat_cols(); } ); +- } +- +- } // namespace Python +- +-} // namespace Dune +- +-#endif // #ifndef DUNE_PYTHON_COMMON_DENSEMATRIX_HH +diff --git a/dune/python/common/densevector.hh b/dune/python/common/densevector.hh +deleted file mode 100644 +index c879ab908..000000000 +--- a/dune/python/common/densevector.hh ++++ /dev/null +@@ -1,180 +0,0 @@ +-// -*- tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- +-// vi: set et ts=4 sw=2 sts=2: +-#ifndef DUNE_PYTHON_COMMON_DENSEVECTOR_HH +-#define DUNE_PYTHON_COMMON_DENSEVECTOR_HH +- +-#include +-#include +-#include +-#include +- +-#include +-#include +-#include +- +-namespace Dune +-{ +- +- namespace Python +- { +- +- namespace detail +- { +- +- // registerScalarCopyingDenseVectorMethods +- // --------------------------------------- +- +- template< class T, class... options > +- inline static std::enable_if_t< std::is_copy_constructible< T >::value && (T::dimension == 1) > +- registerScalarCopyingDenseVectorMethods ( pybind11::class_< T, options... > cls, PriorityTag< 2 > ) +- { +- using ValueType = typename T::value_type; +- +- cls.def( "__add__", [] ( const T &self, int a ) { T *copy = new T( self ); (*copy)[ 0 ] += ValueType( a ); return copy; } ); +- cls.def( "__add__", [] ( const T &self, const ValueType &a ) { T *copy = new T( self ); (*copy)[ 0 ] += a; return copy; } ); +- cls.def( "__sub__", [] ( const T &self, int a ) { T *copy = new T( self ); (*copy)[ 0 ] -= ValueType( a ); return copy; } ); +- cls.def( "__sub__", [] ( const T &self, const ValueType &a ) { T *copy = new T( self ); (*copy)[ 0 ] -= a; return copy; } ); +- +- cls.def( "__radd__", [] ( const T &self, int a ) { T *copy = new T( self ); (*copy)[ 0 ] = ValueType( a ) + (*copy)[ 0 ]; return copy; } ); +- cls.def( "__radd__", [] ( const T &self, const ValueType &a ) { T *copy = new T( self ); (*copy)[ 0 ] = a + (*copy)[ 0 ]; return copy; } ); +- cls.def( "__rsub__", [] ( const T &self, int a ) { T *copy = new T( self ); (*copy)[ 0 ] = ValueType( a ) - (*copy)[ 0 ]; return copy; } ); +- cls.def( "__rsub__", [] ( const T &self, const ValueType &a ) { T *copy = new T( self ); (*copy)[ 0 ] = a - (*copy)[ 0 ]; return copy; } ); +- } +- +- template< class T, class... options > +- inline static std::enable_if_t< std::is_copy_constructible< T >::value > +- registerScalarCopyingDenseVectorMethods ( pybind11::class_< T, options... > cls, PriorityTag< 1 > ) +- { +- using ValueType = typename T::value_type; +- +- cls.def( "__add__", [] ( pybind11::object self, int a ) { +- if( a != 0 ) +- throw pybind11::value_error( "Cannot add " + std::to_string( a ) + " to multidimensional dense vector." ); +- return self; +- } ); +- cls.def( "__sub__", [] ( pybind11::object self, int a ) { +- if( a != 0 ) +- throw pybind11::value_error( "Cannot subtract " + std::to_string( a ) + " from multidimensional dense vector." ); +- return self; +- } ); +- +- cls.def( "__radd__", [] ( pybind11::object self, int a ) { +- if( a != 0 ) +- throw pybind11::value_error( "Cannot add multidimensional dense vector to " + std::to_string( a ) + "." ); +- return self; +- } ); +- cls.def( "__rsub__", [] ( const T &self, int a ) { +- if( a != 0 ) +- throw pybind11::value_error( "Cannot subtract multidimensional dense vector from " + std::to_string( a ) + "." ); +- T *copy = new T( self ); *copy *= ValueType( -1 ); return copy; +- } ); +- } +- +- template< class T, class... options > +- inline static void registerScalarCopyingDenseVectorMethods ( pybind11::class_< T, options... > cls, PriorityTag< 0 > ) +- {} +- +- template< class T, class... options > +- inline static void registerScalarCopyingDenseVectorMethods ( pybind11::class_< T, options... > cls ) +- { +- registerScalarCopyingDenseVectorMethods ( cls, PriorityTag< 42 >() ); +- } +- +- +- +- +- // registerCopyingDenseVectorMethods +- // --------------------------------- +- +- template< class T, class... options > +- inline static std::enable_if_t< std::is_copy_constructible< T >::value > +- registerCopyingDenseVectorMethods ( pybind11::class_< T, options... > cls, PriorityTag< 1 > ) +- { +- using ValueType = typename T::value_type; +- +- using pybind11::operator""_a; +- +- cls.def( "__pos__", [] ( pybind11::object self ) { return self; } ); +- cls.def( "__neg__", [] ( T &self ) { T *copy = new T( self ); *copy *= ValueType( -1 ); return copy; } ); +- +- cls.def( pybind11::self + pybind11::self ); +- cls.def( pybind11::self - pybind11::self ); +- +- cls.def( "__add__", [] ( T &self, pybind11::list x ) { return self + x.cast< T >(); }, "x"_a ); +- cls.def( "__sub__", [] ( T &self, pybind11::list x ) { return self - x.cast< T >(); }, "x"_a ); +- +- cls.def( "__radd__", [] ( T &self, pybind11::list x ) { return x.cast< T >() + self; }, "x"_a ); +- cls.def( "__rsub__", [] ( T &self, pybind11::list x ) { return x.cast< T >() - self; }, "x"_a ); +- +- cls.def( "__mul__", [] ( const T &self, ValueType x ) { T *copy = new T( self ); *copy *= x; return copy; }, "x"_a ); +- cls.def( "__div__", [] ( const T &self, ValueType x ) { T *copy = new T( self ); *copy /= x; return copy; }, "x"_a ); +- cls.def( "__truediv__", [] ( const T &self, ValueType x ) { T *copy = new T( self ); *copy /= x; return copy; }, "x"_a ); +- +- cls.def( "__rmul__", [] ( const T &self, ValueType x ) { T *copy = new T( self ); *copy *= x; return copy; }, "x"_a ); +- } +- +- template< class T, class... options > +- inline static void registerCopyingDenseVectorMethods ( pybind11::class_< T, options... > cls, PriorityTag< 0 > ) +- {} +- +- template< class T, class... options > +- inline static void registerCopyingDenseVectorMethods ( pybind11::class_< T, options... > cls ) +- { +- registerCopyingDenseVectorMethods ( cls, PriorityTag< 42 >() ); +- } +- +- } // namespace detail +- +- +- +- // registerDenseVector +- // ------------------- +- +- template< class T, class... options > +- inline static void registerDenseVector ( pybind11::class_< T, options... > cls ) +- { +- using ValueType = typename T::value_type; +- +- using pybind11::operator""_a; +- +- cls.def( "assign", [] ( T &self, const T &x ) { self = x; }, "x"_a ); +- +- cls.def( "__getitem__", [] ( const T &self, std::size_t i ) -> ValueType { +- if( i < self.size() ) +- return self[ i ]; +- else +- throw pybind11::index_error(); +- }, "i"_a ); +- +- cls.def( "__setitem__", [] ( T &self, std::size_t i, ValueType x ) { +- if( i < self.size() ) +- self[ i ] = x; +- else +- throw pybind11::index_error(); +- }, "i"_a, "x"_a ); +- +- cls.def( "__len__", [] ( const T &self ) -> std::size_t { return self.size(); } ); +- +- cls.def( pybind11::self += pybind11::self ); +- cls.def( pybind11::self -= pybind11::self ); +- +- cls.def( pybind11::self == pybind11::self ); +- cls.def( pybind11::self != pybind11::self ); +- +- cls.def( pybind11::self += ValueType() ); +- cls.def( pybind11::self -= ValueType() ); +- cls.def( pybind11::self *= ValueType() ); +- cls.def( pybind11::self /= ValueType() ); +- +- detail::registerOneTensorInterface( cls ); +- detail::registerCopyingDenseVectorMethods( cls ); +- detail::registerScalarCopyingDenseVectorMethods( cls ); +- +- pybind11::implicitly_convertible< pybind11::list, T >(); +- } +- +- } // namespace Python +- +-} // namespace Dune +- +-#endif // #ifndef DUNE_PYTHON_COMMON_DENSEVECTOR_HH +diff --git a/dune/python/common/dimrange.hh b/dune/python/common/dimrange.hh +deleted file mode 100644 +index 85dc00530..000000000 +--- a/dune/python/common/dimrange.hh ++++ /dev/null +@@ -1,105 +0,0 @@ +-#ifndef DUNE_PYTHON_COMMON_DIMRANGE_HH +-#define DUNE_PYTHON_COMMON_DIMRANGE_HH +- +-#include +- +-#include +-#include +-#include +- +-#if HAVE_DUNE_TYPETREE +-#include +-#include +-#endif // #if HAVE_DUNE_TYPETREE +- +-#include +-#include +- +-namespace Dune +-{ +- +- namespace Python +- { +- +- namespace detail +- { +- +- template< class T > +- inline static constexpr T sum () noexcept +- { +- return static_cast< T >( 0 ); +- } +- +- template< class T > +- inline static constexpr T sum ( T a ) noexcept +- { +- return a; +- } +- +- template< class T, class... U > +- inline static constexpr T sum ( T a, T b, U... c ) noexcept +- { +- return sum( a+b, c... ); +- } +- +- +- template< class T, class Enable = void > +- struct DimRange; +- +- template< class T > +- struct DimRange< T, std::enable_if_t< std::is_arithmetic< T >::value > > +- : public std::integral_constant< std::size_t, 1 > +- {}; +- +- template< class... T > +- struct DimRange< std::tuple< T... >, void > +- : public std::integral_constant< std::size_t, sum< std::size_t >( DimRange< T >::value... ) > +- {}; +- +- template< class K, int n > +- struct DimRange< FieldVector< K, n >, void > +- : public std::integral_constant< std::size_t, n > +- {}; +- +- template< class K, int m, int n > +- struct DimRange< FieldMatrix< K, m, n >, void > +- : public std::integral_constant< std::size_t, m*n > +- {}; +- +-#if HAVE_DUNE_TYPETREE +- template< class T > +- struct DimRange< T, std::enable_if_t< std::is_same< typename T::NodeTag, Dune::TypeTree::CompositeNodeTag >::value > > +- : public DimRange< typename T::ChildTypes > +- {}; +- +- template< class T > +- struct DimRange< T, std::enable_if_t< std::is_same< typename T::NodeTag, Dune::TypeTree::PowerNodeTag >::value > > +- : public std::integral_constant< std::size_t, sum< int >( T::CHILDREN * DimRange< typename T::ChildType >::value ) > +- {}; +-#endif // #if HAVE_DUNE_TYPETREE +- +- template< class T > +- struct DimRange< T, std::enable_if_t< std::is_class< typename T::FiniteElement >::value > > +- : public DimRange< std::decay_t< decltype( std::declval< typename T::FiniteElement >().localBasis() ) > > +- {}; +- +- template< class T > +- struct DimRange< T, std::enable_if_t< std::is_same< std::size_t, decltype( static_cast< std::size_t >( T::Traits::dimRange ) ) >::value > > +- : public std::integral_constant< std::size_t, static_cast< std::size_t >( T::Traits::dimRange ) > +- {}; +- +- } // namespace detail +- +- +- +- // DimRange +- // -------- +- +- template< class T > +- using DimRange = detail::DimRange< T >; +- +- } // namespace Python +- +-} // namespace Dune +- +-#endif // #ifndef DUNE_PYTHON_COMMON_DIMRANGE_HH +diff --git a/dune/python/common/dynmatrix.hh b/dune/python/common/dynmatrix.hh +deleted file mode 100644 +index 0bc7e7769..000000000 +--- a/dune/python/common/dynmatrix.hh ++++ /dev/null +@@ -1,75 +0,0 @@ +-// -*- tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- +-// vi: set et ts=4 sw=2 sts=2: +- +-#ifndef DUNE_PYTHON_COMMON_DYNMATRIX_HH +-#define DUNE_PYTHON_COMMON_DYNMATRIX_HH +- +-#include +-#include +-#include +- +-#include +- +-#include +-#include +-#include +-#include +- +-namespace Dune +-{ +- +- namespace Python +- { +- +- template< class K > +- static void registerDynamicMatrix ( pybind11::handle scope ) +- { +- typedef Dune::DynamicMatrix< K > DM; +- +- auto cls = insertClass< DM >( scope, "DynamicMatrix", +- GenerateTypeName("Dune::DynamicMatrix",MetaType()), +- IncludeFiles{"dune/common/dynmatrix.hh"} ).first; +- +- cls.def( pybind11::init( [] () { return new DM(); } ) ); +- +- cls.def( pybind11::init( [] ( pybind11::list rows ) { +- std::size_t numRows = rows.size(); +- std::size_t numCols = (numRows > 0 ? rows[ 0 ].cast< pybind11::list >().size() : 0); +- +- DM *self = new DM( numRows, numCols, K( 0 ) ); +- for( std::size_t i = 0; i < numRows; ++i ) +- { +- pybind11::list row = rows[ i ].cast< pybind11::list >(); +- std::size_t numCol = row.size(); +- assert(numCols >= numCol); // dense matrix constructed with list having entries of different length +- for( std::size_t j = 0; j < numCol; ++j ) +- (*self)[ i ][ j ] = row[ j ].template cast< K >(); +- } +- return self; +- } ) ); +- +- cls.def("__repr__", +- [] (const DM& m) { +- std::string repr = "Dune::DynamicMatrix:\n("; +- +- for(unsigned int r = 0; r < m.rows(); r++) +- { +- repr += "("; +- for (unsigned int c = 0; c < m.cols(); c++) +- repr += (c > 0 ? ", " : "") + std::to_string(m[r][c]); +- repr += std::string(")") + (r < m.rows() - 1 ? "\n" : ""); +- } +- +- repr += ")"; +- +- return repr; +- }); +- +- registerDenseMatrix(cls); +- } +- +- } // namespace Python +- +-} // namespace Dune +- +-#endif // #ifndef DUNE_PYTHON_COMMON_DYNMATRIX_HH +diff --git a/dune/python/common/dynvector.hh b/dune/python/common/dynvector.hh +deleted file mode 100644 +index 2bd837be2..000000000 +--- a/dune/python/common/dynvector.hh ++++ /dev/null +@@ -1,64 +0,0 @@ +-// -*- tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- +-// vi: set et ts=4 sw=2 sts=2: +- +-#ifndef DUNE_PYTHON_COMMON_DYNVECTOR_HH +-#define DUNE_PYTHON_COMMON_DYNVECTOR_HH +- +-#include +-#include +-#include +- +-#include +- +-#include +-#include +-#include +-#include +- +-namespace Dune +-{ +- +- namespace Python +- { +- +- template< class K > +- void registerDynamicVector ( pybind11::handle scope ) +- { +- using pybind11::operator""_a; +- +- typedef Dune::DynamicVector< K > DV; +- +- auto cls = insertClass< DV >( scope, "DynamicVector", +- GenerateTypeName("Dune::DynamicVector",MetaType()), +- IncludeFiles{"dune/common/dynvector.hh"} ).first; +- +- cls.def( pybind11::init( [] () { return new DV(); } ) ); +- +- cls.def( pybind11::init( [] ( pybind11::list x ) { +- std::size_t size = x.size(); +- DV *self = new DV( size, K( 0 ) ); +- for( std::size_t i = 0; i < size; ++i ) +- (*self)[ i ] = x[ i ].template cast< K >(); +- return self; +- } ), "x"_a ); +- +- cls.def("__repr__", +- [] (const DV &v) { +- std::string repr = "Dune::DynamicVector: ("; +- +- for (std::size_t i = 0; i < v.size(); ++i) +- repr += (i > 0 ? ", " : "") + std::to_string(v[i]); +- +- repr += ")"; +- +- return repr; +- }); +- +- registerDenseVector(cls); +- } +- +- } // namespace Python +- +-} // namespace Dune +- +-#endif // #ifndef DUNE_PYTHON_COMMON_DYNVECTOR_HH +diff --git a/dune/python/common/fmatrix.hh b/dune/python/common/fmatrix.hh +deleted file mode 100644 +index c42e9fdfe..000000000 +--- a/dune/python/common/fmatrix.hh ++++ /dev/null +@@ -1,106 +0,0 @@ +-#ifndef DUNE_PYTHON_COMMON_FMATRIX_HH +-#define DUNE_PYTHON_COMMON_FMATRIX_HH +- +-#include +- +-#include +-#include +-#include +-#include +- +-#include +- +-#include +-#include +-#include +-#include +-#include +-#include +- +-namespace Dune +-{ +- +- namespace Python +- { +- +- // registerFieldMatrix +- // ------------------- +- +- template< class K, int m, int n, class ...options > +- void registerFieldMatrix ( pybind11::handle scope, pybind11::class_, options...> cls ) +- { +- typedef Dune::FieldMatrix< K, m, n > FM; +- using pybind11::operator""_a; +- +- if( (m == 1) && (n == 1) ) +- { +- cls.def( pybind11::init( [] ( int a ) { return new FM( K( a ) ); } ) ); +- cls.def( pybind11::init( [] ( K a ) { return new FM( a ); } ) ); +- cls.def( "__float__", [] ( const FM &self ) { return self[ 0 ][ 0 ]; } ); +- pybind11::implicitly_convertible< int, FM >(); +- pybind11::implicitly_convertible< K, FM >(); +- } +- +- cls.def( pybind11::init( [] () { return new FM( K( 0 ) ); } ) ); +- +- cls.def( pybind11::init( [] ( pybind11::list rows ) { +- FM *self = new FM( K( 0 ) ); +- +- const std::size_t numRows = std::min( static_cast< std::size_t >( m ), rows.size() ); +- for( std::size_t i = 0; i < numRows; ++i ) +- (*self)[ i ] = pybind11::cast< Dune::FieldVector< K, n > >( rows[ i ] ); +- return self; +- } ) ); +- +- pybind11::implicitly_convertible< pybind11::list, FM >(); +- +- cls.def( "__str__", [] ( const FM &self ) { +- std::string s = "("; +- for( int i = 0; i < m; ++i ) +- { +- s += (i > 0 ? "\n(" : "("); +- for( int j = 0; j < n; ++j ) +- s += (j > 0 ? ", " : "") + std::to_string( self[ i ][ j ] ); +- s += std::string( ") "); +- } +- return s += ")"; +- }); +- cls.def( "__repr__", [] ( const FM &self ) { +- return "Dune::FieldMatrix<"+to_string(m)+","+to_string(n)+">(...)"; +- } ); +- +- cls.def_buffer( [] ( FM &self ) -> pybind11::buffer_info { +- return pybind11::buffer_info( +- &self[ 0 ][ 0 ], /* Pointer to buffer */ +- sizeof( K ), /* Size of one scalar */ +- pybind11::format_descriptor< K >::value, /* Python struct-style format descriptor */ +- 2, /* Number of dimensions */ +- { m, n }, /* Buffer dimensions */ +- /* Strides (in bytes) for each index */ +- { +- static_cast< std::size_t >( reinterpret_cast< char * >( &self[ 1 ][ 0 ] ) - reinterpret_cast< char * >( &self[ 0 ][ 0 ] ) ), +- static_cast< std::size_t >( reinterpret_cast< char * >( &self[ 0 ][ 1 ] ) - reinterpret_cast< char * >( &self[ 0 ][ 0 ] ) ) +- } +- ); +- } ); +- +- registerDenseMatrix< FM >( cls ); +- } +- +- template< class K, int m, int n > +- inline static void registerFieldMatrix ( pybind11::handle scope ) +- { +- typedef Dune::FieldMatrix< K, m, n > FM; +- +- auto entry = insertClass( scope, "FieldMatrix_"+std::to_string(m)+"_"+std::to_string(n), pybind11::buffer_protocol(), +- GenerateTypeName("Dune::FieldMatrix",Dune::MetaType(),m,n), IncludeFiles{"dune/common/fmatrix.hh"} +- ); +- if (!entry.second) +- return; +- registerFieldMatrix( scope, entry.first ); +- } +- } // namespace Python +- +-} // namespace Dune +- +-#endif // #ifndef DUNE_PYTHON_COMMON_FMATRIX_HH +diff --git a/dune/python/common/fvecmatregistry.hh b/dune/python/common/fvecmatregistry.hh +deleted file mode 100644 +index c5d60570a..000000000 +--- a/dune/python/common/fvecmatregistry.hh ++++ /dev/null +@@ -1,36 +0,0 @@ +-#ifndef DUNE_PYTHON_COMMON_FVECMATREG_HH +-#define DUNE_PYTHON_COMMON_FVECMATREG_HH +- +-#include +-#include +-#include +-namespace Dune +-{ +- namespace Python +- { +- template +- struct registerFieldVecMat; +- +- template +- struct registerFieldVecMat> +- { +- static void apply() +- { +- pybind11::module scope = pybind11::module::import("dune.common"); +- registerFieldVector(scope); +- } +- }; +- template< class K, int row, int col > +- struct registerFieldVecMat> +- { +- static void apply() +- { +- pybind11::module scope = pybind11::module::import("dune.common"); +- registerFieldMatrix(scope); +- registerFieldVector(scope); +- registerFieldVector(scope); +- } +- }; +- } +-} +-#endif // DUNE_PYTHON_COMMON_FVECMATREG_HH +diff --git a/dune/python/common/fvector.hh b/dune/python/common/fvector.hh +deleted file mode 100644 +index 737ad2ee2..000000000 +--- a/dune/python/common/fvector.hh ++++ /dev/null +@@ -1,156 +0,0 @@ +-// -*- tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- +-// vi: set et ts=4 sw=2 sts=2: +-#ifndef DUNE_PYTHON_COMMON_FVECTOR_HH +-#define DUNE_PYTHON_COMMON_FVECTOR_HH +- +-#include +- +-#include +-#include +-#include +-#include +-#include +- +-#include +- +-#include +-#include +-#include +-#include +-#include +- +-namespace Dune +-{ +- +- namespace Python +- { +- +- // to_string +- // --------- +- +- template< class K, int size > +- inline static std::string to_string ( const FieldVector< K, size > &x ) +- { +- return "(" + join( ", ", [] ( auto &&x ) { return to_string( x ); }, x.begin(), x.end() ) + ")"; +- } +- +- +- +- // registerFieldVector +- // ------------------- +- template< class K, int size, class ...options > +- void registerFieldVector ( pybind11::handle scope, pybind11::class_, options...> cls ) +- { +- using pybind11::operator""_a; +- +- typedef Dune::FieldVector FV; +- cls.def( pybind11::init( [] () { return new FV(); } ) ); +- +- if( size == 1 ) +- { +- cls.def( pybind11::init( [] ( int a ) { return new FV( K( a ) ); } ) ); +- cls.def( pybind11::init( [] ( K a ) { return new FV( a ); } ) ); +- cls.def( "__float__", [] ( const FV &self ) { return self[ 0 ]; } ); +- pybind11::implicitly_convertible< int, FV >(); +- pybind11::implicitly_convertible< K, FV >(); +- } +- +- cls.def( pybind11::init( [] ( pybind11::buffer x ) { +- pybind11::buffer_info info = x.request(); +- if( info.format != pybind11::format_descriptor< K >::format() ) +- throw pybind11::value_error( "Incompatible buffer format." ); +- if( info.ndim != 1 ) +- throw pybind11::value_error( "Only one-dimensional buffers can be converted into FieldVector." ); +- const ssize_t stride = info.strides[ 0 ] / sizeof( K ); +- const ssize_t sz = std::min( static_cast< ssize_t >( size ), info.shape[ 0 ] ); +- +- FV *self = new FV( K( 0 ) ); +- for( ssize_t i = 0; i < sz; ++i ) +- (*self)[ i ] = static_cast< K * >( info.ptr )[ i*stride ]; +- return self; +- } ), "x"_a ); +- +- cls.def( pybind11::init( [] ( pybind11::tuple x ) { +- FV *self = new FV( K( 0 ) ); +- const std::size_t sz = std::min( static_cast< std::size_t >( size ), x.size() ); +- // should this fail in case the sizes do not match? +- for( std::size_t i = 0; i < sz; ++i ) +- (*self)[ i ] = x[ i ].template cast< K >(); +- return self; +- } ), "x"_a ); +- +- cls.def( pybind11::init( [] ( pybind11::list x ) { +- FV *self = new FV( K( 0 ) ); +- const std::size_t sz = std::min( static_cast< std::size_t >( size ), x.size() ); +- // should this fail in case the sizes do not match? +- for( std::size_t i = 0; i < sz; ++i ) +- (*self)[ i ] = x[ i ].template cast< K >(); +- return self; +- } ), "x"_a ); +- +- cls.def( pybind11::init( [] ( pybind11::args args ) { +- FV *self = new FV( K( 0 ) ); +- const std::size_t sz = std::min( static_cast< std::size_t >( size ), args.size() ); +- // should this fail in case the sizes do not match? +- for( std::size_t i = 0; i < sz; ++i ) +- (*self)[ i ] = args[ i ].template cast< K >(); +- return self; +- } ) ); +- +- pybind11::implicitly_convertible< pybind11::args, FV >(); +- pybind11::implicitly_convertible< pybind11::buffer, FV >(); +- +- cls.def("copy", [](FV& , pybind11::args l) { +- FV v(K(0)); +- const std::size_t sz = std::min(v.size(), l.size()); +- // should this fail in case the sizes do not match? +- for (std::size_t i = 0; i < sz; ++i) +- v[i] = l[i].template cast(); +- return v; +- }); +- +- cls.def( "__str__", [] ( const FV &self ) { return to_string( self ); } ); +- cls.def( "__repr__", [] ( const FV &self ) { +- return "Dune::FieldVector<"+to_string(size)+">"+to_string(self); +- } ); +- +- cls.def_buffer( [] ( FV &self ) -> pybind11::buffer_info { +- return pybind11::buffer_info( +- &self[ 0 ], /* Pointer to buffer */ +- sizeof( K ), /* Size of one scalar */ +- pybind11::format_descriptor< K >::format(), /* Python struct-style format descriptor */ +- 1, /* Number of dimensions */ +- { size }, /* Buffer dimensions */ +- /* Strides (in bytes) for each index */ +- { +- static_cast< std::size_t >( reinterpret_cast< char * >( &self[ 1 ] ) - reinterpret_cast< char * >( &self[ 0 ] ) ) } ); +- } +- ); +- +- registerDenseVector< FV >( cls ); +- } +- +- template< class K, int size > +- void registerFieldVector ( pybind11::handle scope, std::integral_constant< int, size > = {} ) +- { +- typedef Dune::FieldVector FV; +- +- auto entry = insertClass(scope, "FieldVector_"+std::to_string(size), pybind11::buffer_protocol(), +- GenerateTypeName("Dune::FieldVector",MetaType(),size),IncludeFiles{"dune/common/fvector.hh"} +- ); +- if (!entry.second) +- return; +- registerFieldVector(scope, entry.first); +- } +- +- template +- void registerFieldVector(pybind11::handle scope, std::integer_sequence) +- { +- std::ignore = std::make_tuple((registerFieldVector(scope, std::integral_constant()), size)...); +- } +- +- } // namespace Python +- +-} // namespace Dune +- +-#endif // #ifndef DUNE_PYTHON_COMMON_FVECTOR_HH +diff --git a/dune/python/common/getdimension.hh b/dune/python/common/getdimension.hh +deleted file mode 100644 +index 766e2bd57..000000000 +--- a/dune/python/common/getdimension.hh ++++ /dev/null +@@ -1,22 +0,0 @@ +-#ifndef DUNE_PYTHON_COMMON_GETDIMENSION_HH +-#define DUNE_PYTHON_COMMON_GETDIMENSION_HH +- +-#include +- +-#include +-#include +- +-template< class T, class=void > +-struct GetDimension; +- +-template< class T > +-struct GetDimension< T, std::enable_if_t::value>> +- : public std::integral_constant< int, 1 > {}; +-template< class FT, int dim > +-struct GetDimension> +- : public std::integral_constant< int, dim > {}; +-template< class FT, int dimr, int dimc > +-struct GetDimension> +- : public std::integral_constant< int, dimr*dimc > {}; +- +-#endif // DUNE_PYTHON_COMMON_GETDIMENSION_HH +diff --git a/dune/python/common/logger.hh b/dune/python/common/logger.hh +deleted file mode 100644 +index c3e5b4926..000000000 +--- a/dune/python/common/logger.hh ++++ /dev/null +@@ -1,95 +0,0 @@ +-#ifndef DUNE_PYTHON_COMMON_LOGGER_HH +-#define DUNE_PYTHON_COMMON_LOGGER_HH +- +-#include +-#include +- +-#include +- +-#include +- +-namespace Dune +-{ +- +- namespace Python +- { +- +- // Logger +- // ------ +- +- struct DUNE_PRIVATE Logger +- { +- enum class Level : int +- { +- critical = 50, +- error = 40, +- warning = 30, +- info = 20, +- debug = 10, +- notSet = 0 +- }; +- +- explicit Logger ( const std::string &name ) +- : logging_( pybind11::module::import( "logging" ) ), +- logger_( logging_.attr( "getLogger" )( name ) ) +- {} +- +- template< class... Args > +- void critical ( const std::string &msg, Args &&... args ) const +- { +- log( Level::critical, msg, std::forward< Args >( args )... ); +- } +- +- template< class... Args > +- void error ( const std::string &msg, Args &&... args ) const +- { +- log( Level::error, msg, std::forward< Args >( args )... ); +- } +- +- template< class... Args > +- void warning ( const std::string &msg, Args &&... args ) const +- { +- log( Level::warning, msg, std::forward< Args >( args )... ); +- } +- +- template< class... Args > +- void info ( const std::string &msg, Args &&... args ) const +- { +- log( Level::info, msg, std::forward< Args >( args )... ); +- } +- +- template< class... Args > +- void debug ( const std::string &msg, Args &&... args ) const +- { +- log( Level::debug, msg, std::forward< Args >( args )... ); +- } +- +- template< class... Args > +- void log ( int level, const std::string &msg, Args &&... args ) const +- { +- pybind11::object pyLevel = pybind11::int_( level ); +- logger_.attr( "log" )( pyLevel, msg, *pybind11::make_tuple( std::forward< Args >( args )... ) ); +- } +- +- template< class... Args > +- void log ( Level level, const std::string &msg, Args &&... args ) const +- { +- log( static_cast< int >( level ), msg, std::forward< Args >( args )... ); +- } +- +- void setLevel ( int level ) { logger_.attr( "setLevel" )( level ); } +- +- bool isEnabledFor ( int level ) { return pybind11::cast< bool >( logger_.attr( "isEnabledFor" )( level ) ); } +- +- int getEffectiveLevel () { return pybind11::cast< int >( logger_.attr( "getEffectiveLevel" )() ); } +- +- private: +- pybind11::module logging_; +- pybind11::object logger_; +- }; +- +- } // namespace Python +- +-} // namespace Dune +- +-#endif // #ifndef DUNE_PYTHON_COMMON_LOGGER_HH +diff --git a/dune/python/common/mpihelper.hh b/dune/python/common/mpihelper.hh +deleted file mode 100644 +index 6184edb74..000000000 +--- a/dune/python/common/mpihelper.hh ++++ /dev/null +@@ -1,55 +0,0 @@ +-// -*- tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- +-// vi: set et ts=4 sw=2 sts=2: +-#ifndef DUNE_PYTHON_COMMON_MPIHELPER_HH +-#define DUNE_PYTHON_COMMON_MPIHELPER_HH +- +-#include +- +-#include +-#include +- +-#include +-#include +- +-namespace Dune +-{ +- +- namespace Python +- { +- +- // registerCollectiveCommunication +- // ------------------------------- +- +- template< class Comm, class... objects > +- inline static void registerCollectiveCommunication ( pybind11::class_< Comm, objects... > cls ) +- { +- using pybind11::operator""_a; +- +- cls.def_property_readonly( "rank", &Comm::rank ); +- cls.def_property_readonly( "size", &Comm::size ); +- +- cls.def( "barrier", &Comm::barrier ); +- +- cls.def( "min", [] ( const Comm &self, double x ) { return self.min( x ); }, "x"_a ); +- cls.def( "max", [] ( const Comm &self, double x ) { return self.max( x ); }, "x"_a ); +- cls.def( "sum", [] ( const Comm &self, double x ) { return self.sum( x ); }, "x"_a ); +- } +- +- inline static void registerCollectiveCommunication ( pybind11::handle scope ) +- { +- typedef Dune::CollectiveCommunication< Dune::MPIHelper::MPICommunicator > Comm; +- +- auto typeName = GenerateTypeName( "Dune::CollectiveCommunication", "Dune::MPIHelper::MPICommunicator" ); +- auto includes = IncludeFiles{ "dune/common/parallel/collectivecommunication.hh", "dune/common/parallel/mpihelper.hh" }; +- auto clsComm = insertClass< Comm >( scope, "CollectiveCommunication", typeName, includes ); +- if( clsComm.second ) +- registerCollectiveCommunication( clsComm.first ); +- +- scope.attr( "comm" ) = pybind11::cast( Dune::MPIHelper::getCollectiveCommunication() ); +- } +- +- } // namespace Python +- +-} // namespace Dune +- +-#endif // #ifndef DUNE_PYTHON_COMMON_MPIHELPER_HH +diff --git a/dune/python/common/numpycommdatahandle.hh b/dune/python/common/numpycommdatahandle.hh +deleted file mode 100644 +index 89de9daf0..000000000 +--- a/dune/python/common/numpycommdatahandle.hh ++++ /dev/null +@@ -1,8 +0,0 @@ +-#if HAVE_DUNE_GRID +- +-#ifndef DUNE_PYTHON_UTILITY_VECTORCOMMDATAHANDLE_HH +-#warning "Deprecated header, #include instead!" +-#include +-#endif // #ifndef DUNE_PYTHON_UTILITY_VECTORCOMMDATAHANDLE_HH +- +-#endif // #if HAVE_DUNE_GRID +diff --git a/dune/python/common/numpyvector.hh b/dune/python/common/numpyvector.hh +deleted file mode 100644 +index 6c36e5ece..000000000 +--- a/dune/python/common/numpyvector.hh ++++ /dev/null +@@ -1,145 +0,0 @@ +-#ifndef DUNE_PYTHON_COMMON_NUMPYVECTOR_HH +-#define DUNE_PYTHON_COMMON_NUMPYVECTOR_HH +- +-#include +-#include +- +-#include +-#include +-#include +- +-namespace Dune +-{ +- +- namespace Python +- { +- +- // Internal Forward Declarations +- // ----------------------------- +- +- template< class T > +- class NumPyVector; +- +- } // namespace Python +- +- +- +- // DenseMatVecTraits for NumPyVector +- // --------------------------------- +- +- template< class T > +- struct DenseMatVecTraits< Python::NumPyVector< T > > +- { +- typedef Python::NumPyVector< T > derived_type; +- typedef pybind11::array_t< T > container_type; +- typedef T value_type; +- typedef std::size_t size_type; +- }; +- +- +- +- // FieldTraits for NumPyVector +- // --------------------------- +- +- template< class T > +- struct FieldTraits< Python::NumPyVector< T > > +- { +- typedef typename FieldTraits< T >::field_type field_type; +- typedef typename FieldTraits< T >::real_type real_type; +- }; +- +- +- namespace Python +- { +- +- template< class T > +- class NumPyVector +- : public DenseVector< NumPyVector< T > > +- { +- typedef NumPyVector< T > This; +- typedef DenseVector< NumPyVector< T > > Base; +- +- public: +- typedef typename Base::size_type size_type; +- typedef typename Base::value_type value_type; +- +- explicit NumPyVector ( size_type size ) +- : array_( pybind11::buffer_info( nullptr, sizeof( T ), +- pybind11::format_descriptor< T >::value, 1, { size }, { sizeof( T ) } ) +- ), +- size_(size) +- {} +- +- NumPyVector ( pybind11::buffer buf ) +- : array_( buf ), +- size_( 0 ) +- { +- pybind11::buffer_info info = buf.request(); +- if (info.ndim != 1) +- DUNE_THROW( InvalidStateException, "NumPyVector can only be created from one-dimensional array" ); +- size_ = info.shape[0]; +- } +- +- NumPyVector ( const This &other ) = delete; +- NumPyVector ( This &&other ) = delete; +- +- ~NumPyVector() {} +- +- This &operator= ( const This &other ) = delete; +- This &operator= ( This &&other ) = delete; +- +- operator pybind11::array_t< T > () const { return array_; } +- +- const value_type &operator[] ( size_type index ) const +- { +- return data()[ index ]; +- } +- value_type &operator[] ( size_type index ) +- { +- return data()[ index ]; +- } +- value_type &vec_access ( size_type index ) +- { +- return data()[ index ]; +- } +- const value_type &vec_access ( size_type index ) const +- { +- return data()[ index ]; +- } +- +- inline const value_type *data () const +- { +- return static_cast< const value_type * >( const_cast&>(array_).request(false).ptr ); +- } +- inline value_type *data () +- { +- return static_cast< value_type * >( array_.request(true).ptr ); +- } +- pybind11::array_t< T > &coefficients() +- { +- return array_; +- } +- pybind11::array_t< T > &coefficients() const +- { +- return array_; +- } +- +- size_type size () const +- { +- return size_; +- } +- size_type vec_size () const +- { +- return size_; +- } +- +- private: +- pybind11::array_t< T > array_; +- size_type size_; +- }; +- +- } // namespace Python +- +-} // namespace Dune +- +-#endif // #ifndef DUNE_PYTHON_COMMON_NUMPYVECTOR_HH +diff --git a/dune/python/common/pythonvector.hh b/dune/python/common/pythonvector.hh +deleted file mode 100644 +index ddd3b2dc7..000000000 +--- a/dune/python/common/pythonvector.hh ++++ /dev/null +@@ -1,103 +0,0 @@ +-#ifndef DUNE_PYTHON_COMMON_PYTHONVECTOR_HH +-#define DUNE_PYTHON_COMMON_PYTHONVECTOR_HH +- +-#include +- +-#include +- +-#include +- +-namespace Dune +-{ +- +- namespace Python +- { +- +- // Internal Forward Declarations +- // ----------------------------- +- +- template< class K > +- class PythonVector; +- +- } // namespace Python +- +- +- +- // DenseMatVecTraits for PythonVector +- // ---------------------------------- +- +- template< class K > +- struct DenseMatVecTraits< Python::PythonVector< K > > +- { +- typedef Python::PythonVector< K > derived_type; +- typedef K value_type; +- typedef std::size_t size_type; +- }; +- +- +- +- // FieldTraits for PythonVector +- // ---------------------------- +- +- template< class K > +- struct FieldTraits< Python::PythonVector< K > > +- { +- typedef typename FieldTraits< K >::field_type field_type; +- typedef typename FieldTraits< K >::real_type real_type; +- }; +- +- +- +- namespace Python +- { +- +- template< class K > +- class PythonVector +- : public Dune::DenseVector< PythonVector< K > > +- { +- typedef PythonVector< K > This; +- typedef Dune::DenseVector< PythonVector< K > > Base; +- +- public: +- typedef typename Base::size_type size_type; +- typedef typename Base::field_type field_type; +- +- explicit PythonVector ( pybind11::buffer buffer ) +- : buffer_( buffer ), info_( buffer_.request() ) +- { +- if( info_.format != pybind11::format_descriptor< field_type >::format() ) +- throw std::runtime_error( "Incompatible buffer format." ); +- if( info_.ndim != 1 ) +- throw std::runtime_error( "PythonVector can only be instantiated from one-dimensional buffers." ); +- stride_ = info_.strides[ 0 ] / sizeof( field_type ); +- } +- +- PythonVector ( const This & ) = delete; +- PythonVector ( This && ) = default; +- +- This &operator= ( const This & ) = delete; +- This &operator= ( This && ) = default; +- +- const field_type &operator[] ( size_type i ) const +- { +- return static_cast< const field_type * >( info_.ptr )[ i*stride_ ]; +- } +- +- field_type &operator[] ( size_type i ) +- { +- return static_cast< field_type * >( info_.ptr )[ i*stride_ ]; +- } +- +- size_type size () const { return info_.shape[ 0 ]; } +- +- private: +- pybind11::buffer buffer_; +- pybind11::buffer_info info_; +- size_type stride_; +- }; +- +- } // namespace Python +- +-} // namespace Dune +- +-#endif // #ifndef DUNE_PYTHON_COMMON_PYTHONVECTOR_HH +diff --git a/dune/python/common/string.hh b/dune/python/common/string.hh +deleted file mode 100644 +index 3852a3970..000000000 +--- a/dune/python/common/string.hh ++++ /dev/null +@@ -1,44 +0,0 @@ +-#ifndef DUNE_PYTHON_COMMON_STRING_HH +-#define DUNE_PYTHON_COMMON_STRING_HH +- +-#include +-#include +- +-namespace Dune +-{ +- +- namespace Python +- { +- +- using std::to_string; +- +- +- +- // join +- // ---- +- +- template< class Formatter, class Iterator > +- inline static auto join ( const std::string &delimiter, Formatter &&formatter, Iterator begin, Iterator end ) +- -> std::enable_if_t< std::is_same< std::decay_t< decltype( formatter( *begin ) ) >, std::string >::value, std::string > +- { +- std::string s; +- if( begin != end ) +- { +- for( s = formatter( *begin++ ); begin != end; s += formatter( *begin++ ) ) +- s += delimiter; +- } +- return s; +- } +- +- template< class Iterator > +- inline static auto join ( const std::string &delimiter, Iterator begin, Iterator end ) +- -> std::enable_if_t< std::is_same< std::decay_t< decltype( *begin ) >, std::string >::value, std::string > +- { +- return join( delimiter, [] ( decltype( *begin ) s ) -> decltype( *begin ) { return s; }, begin, end ); +- } +- +- } // namespace Python +- +-} // namespace Dune +- +-#endif // #ifndef DUNE_PYTHON_COMMON_STRING_HH +diff --git a/dune/python/common/typeregistry.hh b/dune/python/common/typeregistry.hh +deleted file mode 100644 +index 28c2affa7..000000000 +--- a/dune/python/common/typeregistry.hh ++++ /dev/null +@@ -1,462 +0,0 @@ +-#ifndef DUNE_PYTHON_COMMON_TYPEREGISTRY_HH +-#define DUNE_PYTHON_COMMON_TYPEREGISTRY_HH +- +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +- +-#include +-#include +- +-#include +-#include +- +-namespace Dune +-{ +- +- namespace Python +- { +- +- namespace detail +- { +- +- struct DUNE_PRIVATE Entry +- { +- std::string name; +- std::string pyName; +- std::vector< std::string > includes; +- pybind11::object object; +- }; +- +- +- // using an unordered_map directly for the type registry leads to a compilation +- // error in the cast used in the typeRegistry function: +- // assertion failed: Unable to cast type to reference: value is local to type caster +- struct DUNE_PRIVATE TypeRegistry : public std::unordered_map< std::type_index, Entry > +- {}; +- +- +- inline static TypeRegistry &typeRegistry () +- { +- // BUG: Capturing the pybind11::object in a static variable leads to a +- // memory fault in Python 3.6 upon module unloading. +- // As a simple fix, we reobtain the reference each time the type +- // registry is requested. +-#if 0 +- static pybind11::object instance; +- if( !instance ) +- instance = pybind11::module::import( "dune.typeregistry" ).attr( "typeRegistry" ); +- return pybind11::cast< TypeRegistry & >( instance ); +-#endif +- return pybind11::cast< TypeRegistry & >( pybind11::module::import( "dune.typeregistry" ).attr( "typeRegistry" ) ); +- } +- +- +- template< class T > +- inline static auto findInTypeRegistry () +- { +- auto pos = typeRegistry().find( typeid(T) ); +- return std::make_pair( pos, pos == typeRegistry().end() ); +- } +- +- +- template< class T > +- inline static auto insertIntoTypeRegistry ( +- const std::string &name, +- const std::string &pyName, +- std::vector< std::string > includes ) +- { +- auto ret = typeRegistry().emplace( typeid(T), Entry() ); +- if( ret.second ) +- { +- Entry &entry = ret.first->second; +- entry.name = name; +- entry.pyName = pyName; +- entry.includes = std::move( includes ); +- } +- return ret; +- } +- +- +- +- // TypeRegistryTag +- // --------------- +- +- struct TypeRegistryTag {}; +- +- +- +- // GenerateTypeName +- // ---------------- +- +- struct GenerateTypeName +- : public TypeRegistryTag +- { +- template +- GenerateTypeName(const std::string &main, Templ... templ) +- : main_(main) +- { +- templates(templ...); +- } +- template +- GenerateTypeName(const std::string &outer, const std::string &main, Templ... templ) +- : main_(outer+"::"+main) +- { +- templates(templ...); +- } +- template +- GenerateTypeName(pybind11::handle &outer, const std::string &main, Templ... templ) +- { +- main_ = getTypeName(outer) + "::" + main; +- includes_.push_back(getIncludes(outer)); +- std::sort( includes_.begin(), includes_.end() ); +- includes_.erase( std::unique( includes_.begin(), includes_.end() ), includes_.end() ); +- templates(templ...); +- } +- template +- GenerateTypeName(Dune::MetaType, const std::string &main, Templ... templ) +- { +- const auto& outerEntry = findInTypeRegistry(); +- if (outerEntry.second) +- throw std::invalid_argument( (std::string("couldn't find outer class ") + +- typeid(Outer).name() + " in type registry").c_str() ); +- main_ = outerEntry.first->second.name + "::" + main; +- includes_.push_back(outerEntry.first->second.includes); +- std::sort( includes_.begin(), includes_.end() ); +- includes_.erase( std::unique( includes_.begin(), includes_.end() ), includes_.end() ); +- templates(templ...); +- } +- GenerateTypeName(const std::string &main, pybind11::args args) +- : main_(main) +- { +- const std::size_t sz = args.size(); +- for( std::size_t i = 0; i < sz; ++i ) +- { +- templates_.insert( templates_.end(), getTypeName( (pybind11::handle)(args[i]) ) ); +- includes_.insert( includes_.end(), getIncludes( (pybind11::handle)(args[i]) ) ); +- std::sort( includes_.begin(), includes_.end() ); +- includes_.erase( std::unique( includes_.begin(), includes_.end() ), includes_.end() ); +- } +- } +- +- std::string name () const +- { +- std::string fullName = main_; +- if( !templates_.empty() ) +- { +- const char *delim = "< "; +- for( const auto &t : templates_ ) +- { +- fullName += delim + t; +- delim = ", "; +- } +- fullName += " >"; +- } +- return fullName; +- } +- std::vector includes() const +- { +- std::vector ret; +- for (const auto &i : includes_) +- ret.insert( ret.end(), i.begin(), i.end() ); +- return ret; +- } +- +- private: +- template +- void templates(Args... args) +- { +- templates_.insert(templates_.end(), { getTypeName( std::forward< Args >( args ) )... } ); +- includes_.insert( includes_.end(), { getIncludes( std::forward( args ) )... } ); +- std::sort( includes_.begin(), includes_.end() ); +- includes_.erase( std::unique( includes_.begin(), includes_.end() ), includes_.end() ); +- } +- template +- std::string getTypeName(const pybind11::class_ &obj) +- { +- return getTypeName(static_cast(obj)); +- } +- std::string getTypeName(const pybind11::object &obj) +- { +- return getTypeName(static_cast(obj)); +- } +- std::string getTypeName(const pybind11::handle &obj) +- { +- try +- { +- return obj.attr( "_typeName" ).cast(); +- } +- catch(const pybind11::error_already_set& ) +- { +- return pybind11::str(obj); +- } +- } +- static std::string getTypeName ( const GenerateTypeName &name ) { return name.name(); } +- std::string getTypeName ( const std::string &name ) { return name; } +- std::string getTypeName ( const char *name ) { return name; } +- template +- std::string getTypeName ( const Dune::MetaType & ) +- { +- auto entry = detail::findInTypeRegistry(); +- if (entry.second) +- throw std::invalid_argument( (std::string("couldn't find requested type ") + +- typeid(T).name() + " in type registry").c_str() ); +- return entry.first->second.name; +- } +- template +- std::string getTypeName ( const T& t ) { return std::to_string(t); } +- +- static std::vector getIncludes(pybind11::handle obj) +- { +- try +- { +- return obj.attr( "_includes" ).cast>(); +- } +- catch(const pybind11::error_already_set& ) +- { +- return {}; +- } +- } +- static std::vector< std::string > getIncludes ( const GenerateTypeName &name ) { return name.includes(); } +- template +- const std::vector &getIncludes ( const Dune::MetaType & ) +- { +- auto entry = detail::findInTypeRegistry(); +- if (entry.second) +- throw std::invalid_argument( (std::string("couldn't find requested type ") + +- typeid(T).name() + " in type registry").c_str() ); +- return entry.first->second.includes; +- } +- template +- std::vector getIncludes ( const T& ) { return {}; } +- +- std::string main_; +- std::vector templates_; +- std::vector> includes_; +- }; +- +- +- +- // IncludeFiles +- // ------------ +- +- struct IncludeFiles +- : public std::vector< std::string >, +- TypeRegistryTag +- { +- template +- IncludeFiles(Args... args) +- : std::vector({args...}) {} +- }; +- +- +- template< class DuneType > +- inline static auto _addToTypeRegistry ( std::string pyName, const GenerateTypeName &typeName, const std::vector< std::string > &inc = {} ) +- { +- std::vector< std::string > includes = typeName.includes(); +- includes.insert( includes.end(), inc.begin(), inc.end() ); +- auto entry = detail::insertIntoTypeRegistry< DuneType >( typeName.name(), std::move( pyName ), includes ); +- if( !entry.second ) +- throw std::invalid_argument( std::string( "adding a class (" ) + typeid( DuneType ).name() + ") twice to the type registry" ); +- return entry; +- } +- +- +- template > +- struct filter : O {}; +- template +- struct filter, std::index_sequence<0, Js...>, +- std::index_sequence> +- : filter, std::index_sequence, +- std::index_sequence> {}; +- template +- struct filter, std::index_sequence<1, Js...>, +- std::index_sequence> +- : filter, std::index_sequence, +- std::index_sequence> {}; +- +- template< template< class T> class F, class... Args > +- using Filter = filter< std::index_sequence_for< Args... >, std::index_sequence< F< Args >{}... > >; +- +- template< class DuneType > +- inline static auto +- _addToTypeRegistry( const std::string &pyName, const IncludeFiles &inc, const GenerateTypeName &typeName ) +- { +- return _addToTypeRegistry(std::move(pyName),typeName,inc); +- } +- +- template< class DuneType, class... Args, std::size_t... Is > +- inline static auto +- _addToTypeRegistry_filter_impl( const std::string &pyName, std::tuple< Args... > &&tuple, std::index_sequence< Is... > ) +- { +- return _addToTypeRegistry(std::move(pyName),std::get(std::move(tuple))...); +- } +- +- template< class DuneType, class... options, class... Args > +- inline static auto +- generateClass ( pybind11::handle scope, const char *name, Args... args ) +- { +- return pybind11::class_(scope,name,args...); +- } +- +- template< class DuneType, class... options, class... Args, std::size_t... Is > +- inline static auto +- generateClass_filter_impl ( pybind11::handle scope, const char *name, std::tuple&& tuple, std::index_sequence< Is... > ) +- { +- return generateClass(scope,name,std::get(std::move(tuple))...); +- } +- +- template +- struct negation : std::integral_constant { }; +- template +- using baseTag = std::is_base_of; +- template +- using notBaseTag = negation>; +- +- } // namespace detail +- +- /** \brief Generate class name as string given the base part plus a list of the +- * template arguments. +- * +- * This class is used to generate a string storing the full C++ class +- * name, i.e., 'Foo' given the string 'Foo' and the two types 'A' +- * and 'B'. The template arguments can be given as +- * - string, bool, or int (anything that works with std::to_string +- * basically, so even double...) +- * - Dune::MetaType, in which case the type T must be available in +- * the type registry +- * - pybind::object, in which case the attribute _typeName muse be +- * availablea +- * . +- * +- * In the last two cases the include files stored in the type registry +- * for this type or attached to the object via the '_includes' +- * attribute are collected. +- * +- * The main constructor is +- * template +- * GenerateTypeName(const std::string &main, Templ... templ) +- * +- * Further constructors are available to handle cases like +- * Bar::Foo +- * The outer type can again be either given as a string, a +- * Dune::MetaType, or a pybind11::object. +- * +- * At the moment constructs like Bar::Traits::Foo or Bar::Foo are +- * not possible except in the case where the outer type (e.g. +- * Bar::Traits) can be passed in as a string. +- * +- */ +- using GenerateTypeName = detail::GenerateTypeName; +- +- /** \brief A class used in the free standing method insertClass to tag +- * the list of include files in the argument list +- */ +- using IncludeFiles = detail::IncludeFiles; +- +- using detail::findInTypeRegistry; +- +- /** \brief add a type to the type registry without it being exported to python +- */ +- template +- inline static void addToTypeRegistry ( const GenerateTypeName &typeName, +- const std::vector< std::string > &inc = {} +- ) +- { +- std::vector includes = typeName.includes(); +- includes.insert(includes.end(), inc.begin(), inc.end()); +- detail::insertIntoTypeRegistry(typeName.name(),"",includes); +- } +- +- +- /** Function used to generate a new pybind11::class_ object and to add +- * an entry to the type registry. +- * +- * If 'DuneType' passed in as first argument will be exported to Python +- * by adding it to the given scope. If the type has already been insert +- * using this method the correct pybind11::class_ object is added to +- * the scope and returned. +- * +- * Usage: +- * \code +- * auto entry = insertClass,py11_toption1,py11_toption2>(scope, "Foo", +- * py11_option1(), py11_option2(), +- * GenerateTypeName( "Foo", Dune::MetaType() ), +- * IncludeFiles{ "file1.hh", "file2.hh" } ); +- * if (entry.second) +- * registerFoo(entry.first); +- * return entry.first); +- * \endcode +- * +- * \tparam Type the type of the dune class to export +- * \tparam options variadic template arguments passed on to * pybind11::class_ +- * \param scope the scope into which to export the python class +- * \param pyName the name to use for the python export +- * \param args variadic argument passed on to the constructor of +- * pybind11::class_ with the exception of an argument +- * the type 'GenerateTypeName' and 'IncludeFiles' +- * \return +- * \code +- * make_pair(pybind11::class_("pyName",args...), isNew); +- * \endcode +- * The first argument is the pybind11::class_ +- * object (either newly created or extracted from the type +- * registry) The second argument is false if the type was +- * already registered and otherwise it is true. +- */ +- template< class Type, class... options, class... Args > +- inline static std::pair< pybind11::class_< Type, options... >, bool > +- insertClass ( pybind11::handle scope, std::string pyName, Args... args ) +- { +- auto entry = detail::findInTypeRegistry(); +- if( !entry.second ) +- { +- if( scope ) +- scope.attr( pyName.c_str() ) = entry.first->second.object; +- return std::make_pair( static_cast< pybind11::class_< Type, options... > >( entry.first->second.object ), false ); +- } +- else +- { +- auto entry = detail::_addToTypeRegistry_filter_impl< Type >( std::move( pyName ), std::forward_as_tuple( std::forward< Args >( args )... ), detail::Filter< detail::baseTag, std::decay_t< Args >... >{} ); +- auto cls = detail::generateClass_filter_impl< Type, options...>( scope, entry.first->second.pyName.c_str(), std::forward_as_tuple( std::forward< Args >( args )... ), detail::Filter< detail::notBaseTag, std::decay_t< Args >... >{} ); +- entry.first->second.object = cls; +- +- cls.def_property_readonly_static( "_typeName", [ entry ] ( pybind11::object ) { return entry.first->second.name; } ); +- cls.def_property_readonly_static( "_includes", [ entry ] ( pybind11::object ) { return entry.first->second.includes; } ); +- +- return std::make_pair( cls, true ); +- } +- } +- +- +- // registerTypeRegistry +- // -------------------- +- +- inline static void registerTypeRegistry ( pybind11::module scope ) +- { +- using pybind11::operator""_a; +- +- pybind11::class_< detail::TypeRegistry > cls( scope, "TypeRegistry" ); +- +- scope.attr( "typeRegistry" ) = pybind11::cast( std::make_unique< detail::TypeRegistry >() ); +- +- scope.def( "generateTypeName", []( std::string className, pybind11::args targs ) { +- GenerateTypeName gtn( className, targs ); +- return std::make_pair( gtn.name(), gtn.includes() ); +- }, "className"_a ); +- } +- +- } // namespace Python +- +-} // namespace Dune +- +-#endif // #ifndef DUNE_PYTHON_COMMON_TYPEREGISTRY_HH +diff --git a/dune/python/common/vector.hh b/dune/python/common/vector.hh +deleted file mode 100644 +index ed58d7c43..000000000 +--- a/dune/python/common/vector.hh ++++ /dev/null +@@ -1,290 +0,0 @@ +-#ifndef DUNE_PYTHON_COMMON_TYPE_TRAITS_HH +-#define DUNE_PYTHON_COMMON_TYPE_TRAITS_HH +- +-#include +-#include +- +-#include +-#include +-#include +-#include +- +-#include +-#include +- +-namespace Dune +-{ +- +- // External Forward Declarations +- // ----------------------------- +- +- template< class V > +- class DenseVector; +- +- template< class K, int n > +- class FieldVector; +- +- template< class K, int m, int n > +- class FieldMatrix; +- +- namespace Imp +- { +- +- template< class B, class A > +- class block_vector_unmanaged; +- +- template< class B, class A > +- class compressed_block_vector_unmanaged; +- +- } // namespace Imp +- +- +- +- namespace Python +- { +- +- // IsDenseVector +- // ------------- +- +- template< class T, class = void > +- struct IsDenseVector +- : public std::false_type +- {}; +- +- template< class T > +- struct IsDenseVector< T, std::enable_if_t< std::is_base_of< Dune::DenseVector< T >, T >::value > > +- : public std::true_type +- {}; +- +- +- +- // IsBlockVector +- // ------------- +- +- template< class T, class = void > +- struct IsBlockVector +- : public std::false_type +- {}; +- +- template< class T > +- struct IsBlockVector< T, std::enable_if_t< std::is_base_of< Imp::block_vector_unmanaged< typename T::block_type, typename T::allocator_type >, T >::value > > +- : public std::true_type +- {}; +- +- template< class T > +- struct IsBlockVector< T, std::enable_if_t< std::is_base_of< Imp::compressed_block_vector_unmanaged< typename T::block_type, typename T::allocator_type >, T >::value > > +- : public std::true_type +- {}; +- +- +- +- // IsOneTensor +- // ----------- +- +- template< class T, class = void > +- struct IsOneTensor +- : public std::false_type +- {}; +- +- template< class T > +- struct IsOneTensor< T, std::enable_if_t< IsDenseVector< T >::value > > +- : public std::true_type +- {}; +- +- template< class T > +- struct IsOneTensor< T, std::enable_if_t< IsBlockVector< T >::value && IsOneTensor< typename T::block_type >::value > > +- : public std::true_type +- {}; +- +- +- +- namespace detail +- { +- +- // registerOneTensorInterface +- // -------------------------- +- +- template< class T, class... options > +- inline static auto registerOneTensorInterface ( pybind11::class_< T, options... > cls, PriorityTag< 1 > ) +- -> std::enable_if_t< IsOneTensor< T >::value > +- { +- cls.def( "__mul__", [] ( const T &self, const T &other ) { return self * other; } ); +- cls.def( "__rmul__", [] ( const T &self, const T &other ) { return self * other; } ); +- +- cls.def_property_readonly( "one_norm", [] ( const T &self ) { return self.one_norm(); } ); +- cls.def_property_readonly( "one_norm_real", [] ( const T &self ) { return self.one_norm_real(); } ); +- cls.def_property_readonly( "two_norm", [] ( const T &self ) { return self.two_norm(); } ); +- cls.def_property_readonly( "two_norm2", [] ( const T &self ) { return self.two_norm2(); } ); +- cls.def_property_readonly( "infinity_norm", [] ( const T &self ) { return self.infinity_norm(); } ); +- cls.def_property_readonly( "infinity_norm_real", [] ( const T &self ) { return self.infinity_norm_real(); } ); +- } +- +- template< class T, class... options > +- inline static void registerOneTensorInterface ( pybind11::class_< T, options... > cls, PriorityTag< 0 > ) +- {} +- +- template< class T, class... options > +- inline static void registerOneTensorInterface ( pybind11::class_< T, options... > cls ) +- { +- registerOneTensorInterface( cls, PriorityTag< 42 >() ); +- } +- +- } // namespace detail +- +- +- +- // FixedTensorTraits +- // ----------------- +- +- template< class T, class = void > +- struct FixedTensorTraits; +- +- template< class T > +- struct FixedTensorTraits< T, std::enable_if_t< IsNumber< T >::value > > +- { +- static constexpr std::array< ssize_t, 0 > shape () noexcept { return {{}}; } +- }; +- +- template< class K, int n > +- struct FixedTensorTraits< FieldVector< K, n >, void > +- { +- static constexpr std::array< ssize_t, 1 > shape () noexcept { return {{ n }}; } +- }; +- +- template< class K, int m, int n > +- struct FixedTensorTraits< FieldMatrix< K, m, n >, void > +- { +- static constexpr std::array< ssize_t, 2 > shape () noexcept { return {{ m, n }}; } +- }; +- +- +- +- // extendArray +- // ----------- +- +- template< std::size_t... i, class T, class... X > +- inline static constexpr auto extendArray ( std::index_sequence< i... >, const std::array< T, sizeof...( i ) > &array, X &&... x ) +- -> std::enable_if_t< std::conjunction< std::is_convertible< X, T >... >::value, std::array< T, sizeof...( i )+sizeof...( X ) > > +- { +- return {{ array[ i ]..., std::forward< X >( x )... }}; +- } +- +- template< class T, std::size_t n, class... X > +- inline static constexpr std::array< T, n+sizeof...( X ) > extendArray ( const std::array< T, n > &array, X &&... x ) +- { +- return extendArray( std::make_index_sequence< n >(), array, std::forward< X >( x )... ); +- } +- +- +- +- // getFixedTensor +- // -------------- +- +- template< std::size_t... k, class X, class Y, std::size_t n, class... I > +- inline static auto getFixedTensor ( std::index_sequence< k... >, X &x, const Y &y, std::array< ssize_t, n > j, I... i ) +- -> std::enable_if_t< (sizeof...( k ) == n) > +- { +- x = y( j[ k ]..., i... ); +- } +- +- template< std::size_t... k, class X, class Y, std::size_t n, class... I > +- inline static auto getFixedTensor ( std::index_sequence< k... >, X &x, const Y &y, std::array< ssize_t, n > j, I... i ) +- -> std::enable_if_t< (sizeof...( k ) < n) > +- { +- ssize_t &it = j[ sizeof...( k ) ]; +- ssize_t end = it; +- for( it = 0; it < end; ++it ) +- getFixedTensor( std::index_sequence< k..., sizeof...( k ) >(), x[ it ], y, j, i... ); +- } +- +- template< class X, class Y, class... I > +- inline static auto getFixedTensor ( X &x, const Y &y, I... i ) +- { +- getFixedTensor( std::index_sequence<>(), x, y, FixedTensorTraits< X >::shape(), i... ); +- } +- +- +- +- // setFixedTensor +- // -------------- +- +- template< std::size_t... k, class X, class Y, std::size_t n, class... I > +- inline static auto setFixedTensor ( std::index_sequence< k... >, const X &x, Y &y, std::array< ssize_t, n > j, I... i ) +- -> std::enable_if_t< (sizeof...( k ) == n) > +- { +- y( j[ k ]..., i... ) = x; +- } +- +- template< std::size_t... k, class X, class Y, std::size_t n, class... I > +- inline static auto setFixedTensor ( std::index_sequence< k... >, const X &x, Y &y, std::array< ssize_t, n > j, I... i ) +- -> std::enable_if_t< (sizeof...( k ) < n) > +- { +- ssize_t &it = j[ sizeof...( k ) ]; +- ssize_t end = it; +- for( it = 0; it < end; ++it ) +- setFixedTensor( std::index_sequence< k..., sizeof...( k ) >(), x[ it ], y, j, i... ); +- } +- +- template< class X, class Y, class... I > +- inline static auto setFixedTensor ( const X &x, Y &y, I... i ) +- { +- setFixedTensor( std::index_sequence<>(), x, y, FixedTensorTraits< X >::shape(), i... ); +- } +- +- +- +- // vectorize +- // --------- +- +- template< class F, class Y, class X > +- inline static pybind11::object vectorize ( F &&f, Y (*)( X ), pybind11::array_t< typename FieldTraits< std::decay_t< X > >::field_type > xArray ) +- { +- const auto xShape = FixedTensorTraits< std::decay_t< X > >::shape(); +- +- auto x = xArray.unchecked(); +- if( (std::size_t)x.ndim() < xShape.size() ) +- throw pybind11::value_error( "Tensor has too few dimensions" ); +- +- for( auto i : range( xShape.size() ) ) +- { +- if( x.shape( i ) != xShape[ i ] ) +- throw pybind11::value_error( "Tensor has wrong shape" ); +- } +- +- std::decay_t< X > xi; +- if( (xShape.size() > 0) && (x.ndim() == xShape.size()) ) +- { +- getFixedTensor( xi, x ); +- return pybind11::cast( f( xi ) ); +- } +- else if( x.ndim() == xShape.size() + 1 ) +- { +- const ssize_t size = x.shape( xShape.size() ); +- const auto yShape = extendArray( FixedTensorTraits< std::decay_t< Y > >::shape(), size ); +- +- pybind11::array_t< typename FieldTraits< std::decay_t< Y > >::field_type > yArray( yShape ); +- auto y = yArray.template mutable_unchecked< yShape.size() >(); +- +- for( auto i : range( size ) ) +- { +- getFixedTensor( xi, x, i ); +- setFixedTensor( f( xi ), y, i ); +- } +- return std::move(yArray); +- } +- else +- throw pybind11::value_error( "Tensor has too many dimensions" ); +- } +- +- template< class F, class X > +- inline static auto vectorize ( F &&f, pybind11::array_t< X > xArray ) +- -> decltype( vectorize( std::forward< F >( f ), static_cast< pybind11::detail::function_signature_t< F > * >( nullptr ), std::move( xArray ) ) ) +- { +- return vectorize( std::forward< F >( f ), static_cast< pybind11::detail::function_signature_t< F > * >( nullptr ), std::move( xArray ) ); +- } +- +- } // namespace Python +- +-} // namespace Dune +- +-#endif // #ifndef DUNE_PYTHON_COMMON_TYPE_TRAITS_HH +diff --git a/dune/python/pybind11/CMakeLists.txt b/dune/python/pybind11/CMakeLists.txt +deleted file mode 100644 +index c42b2a21a..000000000 +--- a/dune/python/pybind11/CMakeLists.txt ++++ /dev/null +@@ -1,25 +0,0 @@ +-add_subdirectory(detail) +- +-SET(HEADERS +- attr.h +- buffer_info.h +- cast.h +- chrono.h +- common.h +- complex.h +- eigen.h +- embed.h +- eval.h +- extensions.h +- functional.h +- iostream.h +- numpy.h +- operators.h +- options.h +- pybind11.h +- pytypes.h +- stl_bind.h +- stl.h +-) +- +-install(FILES ${HEADERS} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dune/python/pybind11) +diff --git a/dune/python/pybind11/LICENSE b/dune/python/pybind11/LICENSE +deleted file mode 100644 +index 6f15578cc..000000000 +--- a/dune/python/pybind11/LICENSE ++++ /dev/null +@@ -1,29 +0,0 @@ +-Copyright (c) 2016 Wenzel Jakob , All rights reserved. +- +-Redistribution and use in source and binary forms, with or without +-modification, are permitted provided that the following conditions are met: +- +-1. Redistributions of source code must retain the above copyright notice, this +- list of conditions and the following disclaimer. +- +-2. Redistributions in binary form must reproduce the above copyright notice, +- this list of conditions and the following disclaimer in the documentation +- and/or other materials provided with the distribution. +- +-3. Neither the name of the copyright holder nor the names of its contributors +- may be used to endorse or promote products derived from this software +- without specific prior written permission. +- +-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +- +-Please also refer to the file CONTRIBUTING.md, which clarifies licensing of +-external contributions to this project including patches, pull requests, etc. +diff --git a/dune/python/pybind11/_version.py b/dune/python/pybind11/_version.py +deleted file mode 100644 +index d18535cd7..000000000 +--- a/dune/python/pybind11/_version.py ++++ /dev/null +@@ -1,12 +0,0 @@ +-# -*- coding: utf-8 -*- +- +- +-def _to_int(s): +- try: +- return int(s) +- except ValueError: +- return s +- +- +-__version__ = "2.6.1" +-version_info = tuple(_to_int(s) for s in __version__.split(".")) +diff --git a/dune/python/pybind11/attr.h b/dune/python/pybind11/attr.h +deleted file mode 100644 +index 0c4167092..000000000 +--- a/dune/python/pybind11/attr.h ++++ /dev/null +@@ -1,551 +0,0 @@ +-/* +- pybind11/attr.h: Infrastructure for processing custom +- type and function attributes +- +- Copyright (c) 2016 Wenzel Jakob +- +- All rights reserved. Use of this source code is governed by a +- BSD-style license that can be found in the LICENSE file. +-*/ +- +-#pragma once +- +-#include "cast.h" +- +-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE) +- +-/// \addtogroup annotations +-/// @{ +- +-/// Annotation for methods +-struct is_method { handle class_; is_method(const handle &c) : class_(c) { } }; +- +-/// Annotation for operators +-struct is_operator { }; +- +-/// Annotation for classes that cannot be subclassed +-struct is_final { }; +- +-/// Annotation for parent scope +-struct scope { handle value; scope(const handle &s) : value(s) { } }; +- +-/// Annotation for documentation +-struct doc { const char *value; doc(const char *value) : value(value) { } }; +- +-/// Annotation for function names +-struct name { const char *value; name(const char *value) : value(value) { } }; +- +-/// Annotation indicating that a function is an overload associated with a given "sibling" +-struct sibling { handle value; sibling(const handle &value) : value(value.ptr()) { } }; +- +-/// Annotation indicating that a class derives from another given type +-template struct base { +- +- PYBIND11_DEPRECATED("base() was deprecated in favor of specifying 'T' as a template argument to class_") +- base() { } // NOLINT(modernize-use-equals-default): breaks MSVC 2015 when adding an attribute +-}; +- +-/// Keep patient alive while nurse lives +-template struct keep_alive { }; +- +-/// Annotation indicating that a class is involved in a multiple inheritance relationship +-struct multiple_inheritance { }; +- +-/// Annotation which enables dynamic attributes, i.e. adds `__dict__` to a class +-struct dynamic_attr { }; +- +-/// Annotation which enables the buffer protocol for a type +-struct buffer_protocol { }; +- +-/// Annotation which requests that a special metaclass is created for a type +-struct metaclass { +- handle value; +- +- PYBIND11_DEPRECATED("py::metaclass() is no longer required. It's turned on by default now.") +- metaclass() { } // NOLINT(modernize-use-equals-default): breaks MSVC 2015 when adding an attribute +- +- /// Override pybind11's default metaclass +- explicit metaclass(handle value) : value(value) { } +-}; +- +-/// Annotation that marks a class as local to the module: +-struct module_local { const bool value; constexpr module_local(bool v = true) : value(v) { } }; +- +-/// Annotation to mark enums as an arithmetic type +-struct arithmetic { }; +- +-/// Mark a function for addition at the beginning of the existing overload chain instead of the end +-struct prepend { }; +- +-/** \rst +- A call policy which places one or more guard variables (``Ts...``) around the function call. +- +- For example, this definition: +- +- .. code-block:: cpp +- +- m.def("foo", foo, py::call_guard()); +- +- is equivalent to the following pseudocode: +- +- .. code-block:: cpp +- +- m.def("foo", [](args...) { +- T scope_guard; +- return foo(args...); // forwarded arguments +- }); +- \endrst */ +-template struct call_guard; +- +-template <> struct call_guard<> { using type = detail::void_type; }; +- +-template +-struct call_guard { +- static_assert(std::is_default_constructible::value, +- "The guard type must be default constructible"); +- +- using type = T; +-}; +- +-template +-struct call_guard { +- struct type { +- T guard{}; // Compose multiple guard types with left-to-right default-constructor order +- typename call_guard::type next{}; +- }; +-}; +- +-/// @} annotations +- +-PYBIND11_NAMESPACE_BEGIN(detail) +-/* Forward declarations */ +-enum op_id : int; +-enum op_type : int; +-struct undefined_t; +-template struct op_; +-inline void keep_alive_impl(size_t Nurse, size_t Patient, function_call &call, handle ret); +- +-/// Internal data structure which holds metadata about a keyword argument +-struct argument_record { +- const char *name; ///< Argument name +- const char *descr; ///< Human-readable version of the argument value +- handle value; ///< Associated Python object +- bool convert : 1; ///< True if the argument is allowed to convert when loading +- bool none : 1; ///< True if None is allowed when loading +- +- argument_record(const char *name, const char *descr, handle value, bool convert, bool none) +- : name(name), descr(descr), value(value), convert(convert), none(none) { } +-}; +- +-/// Internal data structure which holds metadata about a bound function (signature, overloads, etc.) +-struct function_record { +- function_record() +- : is_constructor(false), is_new_style_constructor(false), is_stateless(false), +- is_operator(false), is_method(false), has_args(false), +- has_kwargs(false), has_kw_only_args(false), prepend(false) { } +- +- /// Function name +- char *name = nullptr; /* why no C++ strings? They generate heavier code.. */ +- +- // User-specified documentation string +- char *doc = nullptr; +- +- /// Human-readable version of the function signature +- char *signature = nullptr; +- +- /// List of registered keyword arguments +- std::vector args; +- +- /// Pointer to lambda function which converts arguments and performs the actual call +- handle (*impl) (function_call &) = nullptr; +- +- /// Storage for the wrapped function pointer and captured data, if any +- void *data[3] = { }; +- +- /// Pointer to custom destructor for 'data' (if needed) +- void (*free_data) (function_record *ptr) = nullptr; +- +- /// Return value policy associated with this function +- return_value_policy policy = return_value_policy::automatic; +- +- /// True if name == '__init__' +- bool is_constructor : 1; +- +- /// True if this is a new-style `__init__` defined in `detail/init.h` +- bool is_new_style_constructor : 1; +- +- /// True if this is a stateless function pointer +- bool is_stateless : 1; +- +- /// True if this is an operator (__add__), etc. +- bool is_operator : 1; +- +- /// True if this is a method +- bool is_method : 1; +- +- /// True if the function has a '*args' argument +- bool has_args : 1; +- +- /// True if the function has a '**kwargs' argument +- bool has_kwargs : 1; +- +- /// True once a 'py::kw_only' is encountered (any following args are keyword-only) +- bool has_kw_only_args : 1; +- +- /// True if this function is to be inserted at the beginning of the overload resolution chain +- bool prepend : 1; +- +- /// Number of arguments (including py::args and/or py::kwargs, if present) +- std::uint16_t nargs; +- +- /// Number of trailing arguments (counted in `nargs`) that are keyword-only +- std::uint16_t nargs_kw_only = 0; +- +- /// Number of leading arguments (counted in `nargs`) that are positional-only +- std::uint16_t nargs_pos_only = 0; +- +- /// Python method object +- PyMethodDef *def = nullptr; +- +- /// Python handle to the parent scope (a class or a module) +- handle scope; +- +- /// Python handle to the sibling function representing an overload chain +- handle sibling; +- +- /// Pointer to next overload +- function_record *next = nullptr; +-}; +- +-/// Special data structure which (temporarily) holds metadata about a bound class +-struct type_record { +- PYBIND11_NOINLINE type_record() +- : multiple_inheritance(false), dynamic_attr(false), buffer_protocol(false), +- default_holder(true), module_local(false), is_final(false) { } +- +- /// Handle to the parent scope +- handle scope; +- +- /// Name of the class +- const char *name = nullptr; +- +- // Pointer to RTTI type_info data structure +- const std::type_info *type = nullptr; +- +- /// How large is the underlying C++ type? +- size_t type_size = 0; +- +- /// What is the alignment of the underlying C++ type? +- size_t type_align = 0; +- +- /// How large is the type's holder? +- size_t holder_size = 0; +- +- /// The global operator new can be overridden with a class-specific variant +- void *(*operator_new)(size_t) = nullptr; +- +- /// Function pointer to class_<..>::init_instance +- void (*init_instance)(instance *, const void *) = nullptr; +- +- /// Function pointer to class_<..>::dealloc +- void (*dealloc)(detail::value_and_holder &) = nullptr; +- +- /// List of base classes of the newly created type +- list bases; +- +- /// Optional docstring +- const char *doc = nullptr; +- +- /// Custom metaclass (optional) +- handle metaclass; +- +- /// Multiple inheritance marker +- bool multiple_inheritance : 1; +- +- /// Does the class manage a __dict__? +- bool dynamic_attr : 1; +- +- /// Does the class implement the buffer protocol? +- bool buffer_protocol : 1; +- +- /// Is the default (unique_ptr) holder type used? +- bool default_holder : 1; +- +- /// Is the class definition local to the module shared object? +- bool module_local : 1; +- +- /// Is the class inheritable from python classes? +- bool is_final : 1; +- +- PYBIND11_NOINLINE void add_base(const std::type_info &base, void *(*caster)(void *)) { +- auto base_info = detail::get_type_info(base, false); +- if (!base_info) { +- std::string tname(base.name()); +- detail::clean_type_id(tname); +- pybind11_fail("generic_type: type \"" + std::string(name) + +- "\" referenced unknown base type \"" + tname + "\""); +- } +- +- if (default_holder != base_info->default_holder) { +- std::string tname(base.name()); +- detail::clean_type_id(tname); +- pybind11_fail("generic_type: type \"" + std::string(name) + "\" " + +- (default_holder ? "does not have" : "has") + +- " a non-default holder type while its base \"" + tname + "\" " + +- (base_info->default_holder ? "does not" : "does")); +- } +- +- bases.append((PyObject *) base_info->type); +- +- if (base_info->type->tp_dictoffset != 0) +- dynamic_attr = true; +- +- if (caster) +- base_info->implicit_casts.emplace_back(type, caster); +- } +-}; +- +-inline function_call::function_call(const function_record &f, handle p) : +- func(f), parent(p) { +- args.reserve(f.nargs); +- args_convert.reserve(f.nargs); +-} +- +-/// Tag for a new-style `__init__` defined in `detail/init.h` +-struct is_new_style_constructor { }; +- +-/** +- * Partial template specializations to process custom attributes provided to +- * cpp_function_ and class_. These are either used to initialize the respective +- * fields in the type_record and function_record data structures or executed at +- * runtime to deal with custom call policies (e.g. keep_alive). +- */ +-template struct process_attribute; +- +-template struct process_attribute_default { +- /// Default implementation: do nothing +- static void init(const T &, function_record *) { } +- static void init(const T &, type_record *) { } +- static void precall(function_call &) { } +- static void postcall(function_call &, handle) { } +-}; +- +-/// Process an attribute specifying the function's name +-template <> struct process_attribute : process_attribute_default { +- static void init(const name &n, function_record *r) { r->name = const_cast(n.value); } +-}; +- +-/// Process an attribute specifying the function's docstring +-template <> struct process_attribute : process_attribute_default { +- static void init(const doc &n, function_record *r) { r->doc = const_cast(n.value); } +-}; +- +-/// Process an attribute specifying the function's docstring (provided as a C-style string) +-template <> struct process_attribute : process_attribute_default { +- static void init(const char *d, function_record *r) { r->doc = const_cast(d); } +- static void init(const char *d, type_record *r) { r->doc = const_cast(d); } +-}; +-template <> struct process_attribute : process_attribute { }; +- +-/// Process an attribute indicating the function's return value policy +-template <> struct process_attribute : process_attribute_default { +- static void init(const return_value_policy &p, function_record *r) { r->policy = p; } +-}; +- +-/// Process an attribute which indicates that this is an overloaded function associated with a given sibling +-template <> struct process_attribute : process_attribute_default { +- static void init(const sibling &s, function_record *r) { r->sibling = s.value; } +-}; +- +-/// Process an attribute which indicates that this function is a method +-template <> struct process_attribute : process_attribute_default { +- static void init(const is_method &s, function_record *r) { r->is_method = true; r->scope = s.class_; } +-}; +- +-/// Process an attribute which indicates the parent scope of a method +-template <> struct process_attribute : process_attribute_default { +- static void init(const scope &s, function_record *r) { r->scope = s.value; } +-}; +- +-/// Process an attribute which indicates that this function is an operator +-template <> struct process_attribute : process_attribute_default { +- static void init(const is_operator &, function_record *r) { r->is_operator = true; } +-}; +- +-template <> struct process_attribute : process_attribute_default { +- static void init(const is_new_style_constructor &, function_record *r) { r->is_new_style_constructor = true; } +-}; +- +-inline void process_kw_only_arg(const arg &a, function_record *r) { +- if (!a.name || strlen(a.name) == 0) +- pybind11_fail("arg(): cannot specify an unnamed argument after an kw_only() annotation"); +- ++r->nargs_kw_only; +-} +- +-/// Process a keyword argument attribute (*without* a default value) +-template <> struct process_attribute : process_attribute_default { +- static void init(const arg &a, function_record *r) { +- if (r->is_method && r->args.empty()) +- r->args.emplace_back("self", nullptr, handle(), true /*convert*/, false /*none not allowed*/); +- r->args.emplace_back(a.name, nullptr, handle(), !a.flag_noconvert, a.flag_none); +- +- if (r->has_kw_only_args) process_kw_only_arg(a, r); +- } +-}; +- +-/// Process a keyword argument attribute (*with* a default value) +-template <> struct process_attribute : process_attribute_default { +- static void init(const arg_v &a, function_record *r) { +- if (r->is_method && r->args.empty()) +- r->args.emplace_back("self", nullptr /*descr*/, handle() /*parent*/, true /*convert*/, false /*none not allowed*/); +- +- if (!a.value) { +-#if !defined(NDEBUG) +- std::string descr("'"); +- if (a.name) descr += std::string(a.name) + ": "; +- descr += a.type + "'"; +- if (r->is_method) { +- if (r->name) +- descr += " in method '" + (std::string) str(r->scope) + "." + (std::string) r->name + "'"; +- else +- descr += " in method of '" + (std::string) str(r->scope) + "'"; +- } else if (r->name) { +- descr += " in function '" + (std::string) r->name + "'"; +- } +- pybind11_fail("arg(): could not convert default argument " +- + descr + " into a Python object (type not registered yet?)"); +-#else +- pybind11_fail("arg(): could not convert default argument " +- "into a Python object (type not registered yet?). " +- "Compile in debug mode for more information."); +-#endif +- } +- r->args.emplace_back(a.name, a.descr, a.value.inc_ref(), !a.flag_noconvert, a.flag_none); +- +- if (r->has_kw_only_args) process_kw_only_arg(a, r); +- } +-}; +- +-/// Process a keyword-only-arguments-follow pseudo argument +-template <> struct process_attribute : process_attribute_default { +- static void init(const kw_only &, function_record *r) { +- r->has_kw_only_args = true; +- } +-}; +- +-/// Process a positional-only-argument maker +-template <> struct process_attribute : process_attribute_default { +- static void init(const pos_only &, function_record *r) { +- r->nargs_pos_only = static_cast(r->args.size()); +- } +-}; +- +-/// Process a parent class attribute. Single inheritance only (class_ itself already guarantees that) +-template +-struct process_attribute::value>> : process_attribute_default { +- static void init(const handle &h, type_record *r) { r->bases.append(h); } +-}; +- +-/// Process a parent class attribute (deprecated, does not support multiple inheritance) +-template +-struct process_attribute> : process_attribute_default> { +- static void init(const base &, type_record *r) { r->add_base(typeid(T), nullptr); } +-}; +- +-/// Process a multiple inheritance attribute +-template <> +-struct process_attribute : process_attribute_default { +- static void init(const multiple_inheritance &, type_record *r) { r->multiple_inheritance = true; } +-}; +- +-template <> +-struct process_attribute : process_attribute_default { +- static void init(const dynamic_attr &, type_record *r) { r->dynamic_attr = true; } +-}; +- +-template <> +-struct process_attribute : process_attribute_default { +- static void init(const is_final &, type_record *r) { r->is_final = true; } +-}; +- +-template <> +-struct process_attribute : process_attribute_default { +- static void init(const buffer_protocol &, type_record *r) { r->buffer_protocol = true; } +-}; +- +-template <> +-struct process_attribute : process_attribute_default { +- static void init(const metaclass &m, type_record *r) { r->metaclass = m.value; } +-}; +- +-template <> +-struct process_attribute : process_attribute_default { +- static void init(const module_local &l, type_record *r) { r->module_local = l.value; } +-}; +- +-/// Process a 'prepend' attribute, putting this at the beginning of the overload chain +-template <> +-struct process_attribute : process_attribute_default { +- static void init(const prepend &, function_record *r) { r->prepend = true; } +-}; +- +-/// Process an 'arithmetic' attribute for enums (does nothing here) +-template <> +-struct process_attribute : process_attribute_default {}; +- +-template +-struct process_attribute> : process_attribute_default> { }; +- +-/** +- * Process a keep_alive call policy -- invokes keep_alive_impl during the +- * pre-call handler if both Nurse, Patient != 0 and use the post-call handler +- * otherwise +- */ +-template struct process_attribute> : public process_attribute_default> { +- template = 0> +- static void precall(function_call &call) { keep_alive_impl(Nurse, Patient, call, handle()); } +- template = 0> +- static void postcall(function_call &, handle) { } +- template = 0> +- static void precall(function_call &) { } +- template = 0> +- static void postcall(function_call &call, handle ret) { keep_alive_impl(Nurse, Patient, call, ret); } +-}; +- +-/// Recursively iterate over variadic template arguments +-template struct process_attributes { +- static void init(const Args&... args, function_record *r) { +- int unused[] = { 0, (process_attribute::type>::init(args, r), 0) ... }; +- ignore_unused(unused); +- } +- static void init(const Args&... args, type_record *r) { +- int unused[] = { 0, (process_attribute::type>::init(args, r), 0) ... }; +- ignore_unused(unused); +- } +- static void precall(function_call &call) { +- int unused[] = { 0, (process_attribute::type>::precall(call), 0) ... }; +- ignore_unused(unused); +- } +- static void postcall(function_call &call, handle fn_ret) { +- int unused[] = { 0, (process_attribute::type>::postcall(call, fn_ret), 0) ... }; +- ignore_unused(unused); +- } +-}; +- +-template +-using is_call_guard = is_instantiation; +- +-/// Extract the ``type`` from the first `call_guard` in `Extras...` (or `void_type` if none found) +-template +-using extract_guard_t = typename exactly_one_t, Extra...>::type; +- +-/// Check the number of named arguments at compile time +-template ::value...), +- size_t self = constexpr_sum(std::is_same::value...)> +-constexpr bool expected_num_args(size_t nargs, bool has_args, bool has_kwargs) { +- return named == 0 || (self + named + has_args + has_kwargs) == nargs; +-} +- +-PYBIND11_NAMESPACE_END(detail) +-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE) +diff --git a/dune/python/pybind11/buffer_info.h b/dune/python/pybind11/buffer_info.h +deleted file mode 100644 +index d803004a1..000000000 +--- a/dune/python/pybind11/buffer_info.h ++++ /dev/null +@@ -1,146 +0,0 @@ +-/* +- pybind11/buffer_info.h: Python buffer object interface +- +- Copyright (c) 2016 Wenzel Jakob +- +- All rights reserved. Use of this source code is governed by a +- BSD-style license that can be found in the LICENSE file. +-*/ +- +-#pragma once +- +-#include "detail/common.h" +- +-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE) +- +-PYBIND11_NAMESPACE_BEGIN(detail) +- +-// Default, C-style strides +-inline std::vector c_strides(const std::vector &shape, ssize_t itemsize) { +- auto ndim = shape.size(); +- std::vector strides(ndim, itemsize); +- if (ndim > 0) +- for (size_t i = ndim - 1; i > 0; --i) +- strides[i - 1] = strides[i] * shape[i]; +- return strides; +-} +- +-// F-style strides; default when constructing an array_t with `ExtraFlags & f_style` +-inline std::vector f_strides(const std::vector &shape, ssize_t itemsize) { +- auto ndim = shape.size(); +- std::vector strides(ndim, itemsize); +- for (size_t i = 1; i < ndim; ++i) +- strides[i] = strides[i - 1] * shape[i - 1]; +- return strides; +-} +- +-PYBIND11_NAMESPACE_END(detail) +- +-/// Information record describing a Python buffer object +-struct buffer_info { +- void *ptr = nullptr; // Pointer to the underlying storage +- ssize_t itemsize = 0; // Size of individual items in bytes +- ssize_t size = 0; // Total number of entries +- std::string format; // For homogeneous buffers, this should be set to format_descriptor::format() +- ssize_t ndim = 0; // Number of dimensions +- std::vector shape; // Shape of the tensor (1 entry per dimension) +- std::vector strides; // Number of bytes between adjacent entries (for each per dimension) +- bool readonly = false; // flag to indicate if the underlying storage may be written to +- +- buffer_info() = default; +- +- buffer_info(void *ptr, ssize_t itemsize, const std::string &format, ssize_t ndim, +- detail::any_container shape_in, detail::any_container strides_in, bool readonly=false) +- : ptr(ptr), itemsize(itemsize), size(1), format(format), ndim(ndim), +- shape(std::move(shape_in)), strides(std::move(strides_in)), readonly(readonly) { +- if (ndim != (ssize_t) shape.size() || ndim != (ssize_t) strides.size()) +- pybind11_fail("buffer_info: ndim doesn't match shape and/or strides length"); +- for (size_t i = 0; i < (size_t) ndim; ++i) +- size *= shape[i]; +- } +- +- template +- buffer_info(T *ptr, detail::any_container shape_in, detail::any_container strides_in, bool readonly=false) +- : buffer_info(private_ctr_tag(), ptr, sizeof(T), format_descriptor::format(), static_cast(shape_in->size()), std::move(shape_in), std::move(strides_in), readonly) { } +- +- buffer_info(void *ptr, ssize_t itemsize, const std::string &format, ssize_t size, bool readonly=false) +- : buffer_info(ptr, itemsize, format, 1, {size}, {itemsize}, readonly) { } +- +- template +- buffer_info(T *ptr, ssize_t size, bool readonly=false) +- : buffer_info(ptr, sizeof(T), format_descriptor::format(), size, readonly) { } +- +- template +- buffer_info(const T *ptr, ssize_t size, bool readonly=true) +- : buffer_info(const_cast(ptr), sizeof(T), format_descriptor::format(), size, readonly) { } +- +- explicit buffer_info(Py_buffer *view, bool ownview = true) +- : buffer_info(view->buf, view->itemsize, view->format, view->ndim, +- {view->shape, view->shape + view->ndim}, +- /* Though buffer::request() requests PyBUF_STRIDES, ctypes objects +- * ignore this flag and return a view with NULL strides. +- * When strides are NULL, build them manually. */ +- view->strides +- ? std::vector(view->strides, view->strides + view->ndim) +- : detail::c_strides({view->shape, view->shape + view->ndim}, view->itemsize), +- view->readonly) { +- this->m_view = view; +- this->ownview = ownview; +- } +- +- buffer_info(const buffer_info &) = delete; +- buffer_info& operator=(const buffer_info &) = delete; +- +- buffer_info(buffer_info &&other) { +- (*this) = std::move(other); +- } +- +- buffer_info& operator=(buffer_info &&rhs) { +- ptr = rhs.ptr; +- itemsize = rhs.itemsize; +- size = rhs.size; +- format = std::move(rhs.format); +- ndim = rhs.ndim; +- shape = std::move(rhs.shape); +- strides = std::move(rhs.strides); +- std::swap(m_view, rhs.m_view); +- std::swap(ownview, rhs.ownview); +- readonly = rhs.readonly; +- return *this; +- } +- +- ~buffer_info() { +- if (m_view && ownview) { PyBuffer_Release(m_view); delete m_view; } +- } +- +- Py_buffer *view() const { return m_view; } +- Py_buffer *&view() { return m_view; } +-private: +- struct private_ctr_tag { }; +- +- buffer_info(private_ctr_tag, void *ptr, ssize_t itemsize, const std::string &format, ssize_t ndim, +- detail::any_container &&shape_in, detail::any_container &&strides_in, bool readonly) +- : buffer_info(ptr, itemsize, format, ndim, std::move(shape_in), std::move(strides_in), readonly) { } +- +- Py_buffer *m_view = nullptr; +- bool ownview = false; +-}; +- +-PYBIND11_NAMESPACE_BEGIN(detail) +- +-template struct compare_buffer_info { +- static bool compare(const buffer_info& b) { +- return b.format == format_descriptor::format() && b.itemsize == (ssize_t) sizeof(T); +- } +-}; +- +-template struct compare_buffer_info::value>> { +- static bool compare(const buffer_info& b) { +- return (size_t) b.itemsize == sizeof(T) && (b.format == format_descriptor::value || +- ((sizeof(T) == sizeof(long)) && b.format == (std::is_unsigned::value ? "L" : "l")) || +- ((sizeof(T) == sizeof(size_t)) && b.format == (std::is_unsigned::value ? "N" : "n"))); +- } +-}; +- +-PYBIND11_NAMESPACE_END(detail) +-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE) +diff --git a/dune/python/pybind11/cast.h b/dune/python/pybind11/cast.h +deleted file mode 100644 +index 11c61a441..000000000 +--- a/dune/python/pybind11/cast.h ++++ /dev/null +@@ -1,2219 +0,0 @@ +-/* +- pybind11/cast.h: Partial template specializations to cast between +- C++ and Python types +- +- Copyright (c) 2016 Wenzel Jakob +- +- All rights reserved. Use of this source code is governed by a +- BSD-style license that can be found in the LICENSE file. +-*/ +- +-#pragma once +- +-#include "pytypes.h" +-#include "detail/typeid.h" +-#include "detail/descr.h" +-#include "detail/internals.h" +-#include +-#include +-#include +-#include +- +-#if defined(PYBIND11_CPP17) +-# if defined(__has_include) +-# if __has_include() +-# define PYBIND11_HAS_STRING_VIEW +-# endif +-# elif defined(_MSC_VER) +-# define PYBIND11_HAS_STRING_VIEW +-# endif +-#endif +-#ifdef PYBIND11_HAS_STRING_VIEW +-#include +-#endif +- +-#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L +-# define PYBIND11_HAS_U8STRING +-#endif +- +-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE) +-PYBIND11_NAMESPACE_BEGIN(detail) +- +-/// A life support system for temporary objects created by `type_caster::load()`. +-/// Adding a patient will keep it alive up until the enclosing function returns. +-class loader_life_support { +-public: +- /// A new patient frame is created when a function is entered +- loader_life_support() { +- get_internals().loader_patient_stack.push_back(nullptr); +- } +- +- /// ... and destroyed after it returns +- ~loader_life_support() { +- auto &stack = get_internals().loader_patient_stack; +- if (stack.empty()) +- pybind11_fail("loader_life_support: internal error"); +- +- auto ptr = stack.back(); +- stack.pop_back(); +- Py_CLEAR(ptr); +- +- // A heuristic to reduce the stack's capacity (e.g. after long recursive calls) +- if (stack.capacity() > 16 && !stack.empty() && stack.capacity() / stack.size() > 2) +- stack.shrink_to_fit(); +- } +- +- /// This can only be used inside a pybind11-bound function, either by `argument_loader` +- /// at argument preparation time or by `py::cast()` at execution time. +- PYBIND11_NOINLINE static void add_patient(handle h) { +- auto &stack = get_internals().loader_patient_stack; +- if (stack.empty()) +- throw cast_error("When called outside a bound function, py::cast() cannot " +- "do Python -> C++ conversions which require the creation " +- "of temporary values"); +- +- auto &list_ptr = stack.back(); +- if (list_ptr == nullptr) { +- list_ptr = PyList_New(1); +- if (!list_ptr) +- pybind11_fail("loader_life_support: error allocating list"); +- PyList_SET_ITEM(list_ptr, 0, h.inc_ref().ptr()); +- } else { +- auto result = PyList_Append(list_ptr, h.ptr()); +- if (result == -1) +- pybind11_fail("loader_life_support: error adding patient"); +- } +- } +-}; +- +-// Gets the cache entry for the given type, creating it if necessary. The return value is the pair +-// returned by emplace, i.e. an iterator for the entry and a bool set to `true` if the entry was +-// just created. +-inline std::pair all_type_info_get_cache(PyTypeObject *type); +- +-// Populates a just-created cache entry. +-PYBIND11_NOINLINE inline void all_type_info_populate(PyTypeObject *t, std::vector &bases) { +- std::vector check; +- for (handle parent : reinterpret_borrow(t->tp_bases)) +- check.push_back((PyTypeObject *) parent.ptr()); +- +- auto const &type_dict = get_internals().registered_types_py; +- for (size_t i = 0; i < check.size(); i++) { +- auto type = check[i]; +- // Ignore Python2 old-style class super type: +- if (!PyType_Check((PyObject *) type)) continue; +- +- // Check `type` in the current set of registered python types: +- auto it = type_dict.find(type); +- if (it != type_dict.end()) { +- // We found a cache entry for it, so it's either pybind-registered or has pre-computed +- // pybind bases, but we have to make sure we haven't already seen the type(s) before: we +- // want to follow Python/virtual C++ rules that there should only be one instance of a +- // common base. +- for (auto *tinfo : it->second) { +- // NB: Could use a second set here, rather than doing a linear search, but since +- // having a large number of immediate pybind11-registered types seems fairly +- // unlikely, that probably isn't worthwhile. +- bool found = false; +- for (auto *known : bases) { +- if (known == tinfo) { found = true; break; } +- } +- if (!found) bases.push_back(tinfo); +- } +- } +- else if (type->tp_bases) { +- // It's some python type, so keep follow its bases classes to look for one or more +- // registered types +- if (i + 1 == check.size()) { +- // When we're at the end, we can pop off the current element to avoid growing +- // `check` when adding just one base (which is typical--i.e. when there is no +- // multiple inheritance) +- check.pop_back(); +- i--; +- } +- for (handle parent : reinterpret_borrow(type->tp_bases)) +- check.push_back((PyTypeObject *) parent.ptr()); +- } +- } +-} +- +-/** +- * Extracts vector of type_info pointers of pybind-registered roots of the given Python type. Will +- * be just 1 pybind type for the Python type of a pybind-registered class, or for any Python-side +- * derived class that uses single inheritance. Will contain as many types as required for a Python +- * class that uses multiple inheritance to inherit (directly or indirectly) from multiple +- * pybind-registered classes. Will be empty if neither the type nor any base classes are +- * pybind-registered. +- * +- * The value is cached for the lifetime of the Python type. +- */ +-inline const std::vector &all_type_info(PyTypeObject *type) { +- auto ins = all_type_info_get_cache(type); +- if (ins.second) +- // New cache entry: populate it +- all_type_info_populate(type, ins.first->second); +- +- return ins.first->second; +-} +- +-/** +- * Gets a single pybind11 type info for a python type. Returns nullptr if neither the type nor any +- * ancestors are pybind11-registered. Throws an exception if there are multiple bases--use +- * `all_type_info` instead if you want to support multiple bases. +- */ +-PYBIND11_NOINLINE inline detail::type_info* get_type_info(PyTypeObject *type) { +- auto &bases = all_type_info(type); +- if (bases.empty()) +- return nullptr; +- if (bases.size() > 1) +- pybind11_fail("pybind11::detail::get_type_info: type has multiple pybind11-registered bases"); +- return bases.front(); +-} +- +-inline detail::type_info *get_local_type_info(const std::type_index &tp) { +- auto &locals = registered_local_types_cpp(); +- auto it = locals.find(tp); +- if (it != locals.end()) +- return it->second; +- return nullptr; +-} +- +-inline detail::type_info *get_global_type_info(const std::type_index &tp) { +- auto &types = get_internals().registered_types_cpp; +- auto it = types.find(tp); +- if (it != types.end()) +- return it->second; +- return nullptr; +-} +- +-/// Return the type info for a given C++ type; on lookup failure can either throw or return nullptr. +-PYBIND11_NOINLINE inline detail::type_info *get_type_info(const std::type_index &tp, +- bool throw_if_missing = false) { +- if (auto ltype = get_local_type_info(tp)) +- return ltype; +- if (auto gtype = get_global_type_info(tp)) +- return gtype; +- +- if (throw_if_missing) { +- std::string tname = tp.name(); +- detail::clean_type_id(tname); +- pybind11_fail("pybind11::detail::get_type_info: unable to find type info for \"" + tname + "\""); +- } +- return nullptr; +-} +- +-PYBIND11_NOINLINE inline handle get_type_handle(const std::type_info &tp, bool throw_if_missing) { +- detail::type_info *type_info = get_type_info(tp, throw_if_missing); +- return handle(type_info ? ((PyObject *) type_info->type) : nullptr); +-} +- +-struct value_and_holder { +- instance *inst = nullptr; +- size_t index = 0u; +- const detail::type_info *type = nullptr; +- void **vh = nullptr; +- +- // Main constructor for a found value/holder: +- value_and_holder(instance *i, const detail::type_info *type, size_t vpos, size_t index) : +- inst{i}, index{index}, type{type}, +- vh{inst->simple_layout ? inst->simple_value_holder : &inst->nonsimple.values_and_holders[vpos]} +- {} +- +- // Default constructor (used to signal a value-and-holder not found by get_value_and_holder()) +- value_and_holder() = default; +- +- // Used for past-the-end iterator +- value_and_holder(size_t index) : index{index} {} +- +- template V *&value_ptr() const { +- return reinterpret_cast(vh[0]); +- } +- // True if this `value_and_holder` has a non-null value pointer +- explicit operator bool() const { return value_ptr(); } +- +- template H &holder() const { +- return reinterpret_cast(vh[1]); +- } +- bool holder_constructed() const { +- return inst->simple_layout +- ? inst->simple_holder_constructed +- : inst->nonsimple.status[index] & instance::status_holder_constructed; +- } +- void set_holder_constructed(bool v = true) { +- if (inst->simple_layout) +- inst->simple_holder_constructed = v; +- else if (v) +- inst->nonsimple.status[index] |= instance::status_holder_constructed; +- else +- inst->nonsimple.status[index] &= (uint8_t) ~instance::status_holder_constructed; +- } +- bool instance_registered() const { +- return inst->simple_layout +- ? inst->simple_instance_registered +- : inst->nonsimple.status[index] & instance::status_instance_registered; +- } +- void set_instance_registered(bool v = true) { +- if (inst->simple_layout) +- inst->simple_instance_registered = v; +- else if (v) +- inst->nonsimple.status[index] |= instance::status_instance_registered; +- else +- inst->nonsimple.status[index] &= (uint8_t) ~instance::status_instance_registered; +- } +-}; +- +-// Container for accessing and iterating over an instance's values/holders +-struct values_and_holders { +-private: +- instance *inst; +- using type_vec = std::vector; +- const type_vec &tinfo; +- +-public: +- values_and_holders(instance *inst) : inst{inst}, tinfo(all_type_info(Py_TYPE(inst))) {} +- +- struct iterator { +- private: +- instance *inst = nullptr; +- const type_vec *types = nullptr; +- value_and_holder curr; +- friend struct values_and_holders; +- iterator(instance *inst, const type_vec *tinfo) +- : inst{inst}, types{tinfo}, +- curr(inst /* instance */, +- types->empty() ? nullptr : (*types)[0] /* type info */, +- 0, /* vpos: (non-simple types only): the first vptr comes first */ +- 0 /* index */) +- {} +- // Past-the-end iterator: +- iterator(size_t end) : curr(end) {} +- public: +- bool operator==(const iterator &other) const { return curr.index == other.curr.index; } +- bool operator!=(const iterator &other) const { return curr.index != other.curr.index; } +- iterator &operator++() { +- if (!inst->simple_layout) +- curr.vh += 1 + (*types)[curr.index]->holder_size_in_ptrs; +- ++curr.index; +- curr.type = curr.index < types->size() ? (*types)[curr.index] : nullptr; +- return *this; +- } +- value_and_holder &operator*() { return curr; } +- value_and_holder *operator->() { return &curr; } +- }; +- +- iterator begin() { return iterator(inst, &tinfo); } +- iterator end() { return iterator(tinfo.size()); } +- +- iterator find(const type_info *find_type) { +- auto it = begin(), endit = end(); +- while (it != endit && it->type != find_type) ++it; +- return it; +- } +- +- size_t size() { return tinfo.size(); } +-}; +- +-/** +- * Extracts C++ value and holder pointer references from an instance (which may contain multiple +- * values/holders for python-side multiple inheritance) that match the given type. Throws an error +- * if the given type (or ValueType, if omitted) is not a pybind11 base of the given instance. If +- * `find_type` is omitted (or explicitly specified as nullptr) the first value/holder are returned, +- * regardless of type (and the resulting .type will be nullptr). +- * +- * The returned object should be short-lived: in particular, it must not outlive the called-upon +- * instance. +- */ +-PYBIND11_NOINLINE inline value_and_holder instance::get_value_and_holder(const type_info *find_type /*= nullptr default in common.h*/, bool throw_if_missing /*= true in common.h*/) { +- // Optimize common case: +- if (!find_type || Py_TYPE(this) == find_type->type) +- return value_and_holder(this, find_type, 0, 0); +- +- detail::values_and_holders vhs(this); +- auto it = vhs.find(find_type); +- if (it != vhs.end()) +- return *it; +- +- if (!throw_if_missing) +- return value_and_holder(); +- +-#if defined(NDEBUG) +- pybind11_fail("pybind11::detail::instance::get_value_and_holder: " +- "type is not a pybind11 base of the given instance " +- "(compile in debug mode for type details)"); +-#else +- pybind11_fail("pybind11::detail::instance::get_value_and_holder: `" + +- get_fully_qualified_tp_name(find_type->type) + "' is not a pybind11 base of the given `" + +- get_fully_qualified_tp_name(Py_TYPE(this)) + "' instance"); +-#endif +-} +- +-PYBIND11_NOINLINE inline void instance::allocate_layout() { +- auto &tinfo = all_type_info(Py_TYPE(this)); +- +- const size_t n_types = tinfo.size(); +- +- if (n_types == 0) +- pybind11_fail("instance allocation failed: new instance has no pybind11-registered base types"); +- +- simple_layout = +- n_types == 1 && tinfo.front()->holder_size_in_ptrs <= instance_simple_holder_in_ptrs(); +- +- // Simple path: no python-side multiple inheritance, and a small-enough holder +- if (simple_layout) { +- simple_value_holder[0] = nullptr; +- simple_holder_constructed = false; +- simple_instance_registered = false; +- } +- else { // multiple base types or a too-large holder +- // Allocate space to hold: [v1*][h1][v2*][h2]...[bb...] where [vN*] is a value pointer, +- // [hN] is the (uninitialized) holder instance for value N, and [bb...] is a set of bool +- // values that tracks whether each associated holder has been initialized. Each [block] is +- // padded, if necessary, to an integer multiple of sizeof(void *). +- size_t space = 0; +- for (auto t : tinfo) { +- space += 1; // value pointer +- space += t->holder_size_in_ptrs; // holder instance +- } +- size_t flags_at = space; +- space += size_in_ptrs(n_types); // status bytes (holder_constructed and instance_registered) +- +- // Allocate space for flags, values, and holders, and initialize it to 0 (flags and values, +- // in particular, need to be 0). Use Python's memory allocation functions: in Python 3.6 +- // they default to using pymalloc, which is designed to be efficient for small allocations +- // like the one we're doing here; in earlier versions (and for larger allocations) they are +- // just wrappers around malloc. +-#if PY_VERSION_HEX >= 0x03050000 +- nonsimple.values_and_holders = (void **) PyMem_Calloc(space, sizeof(void *)); +- if (!nonsimple.values_and_holders) throw std::bad_alloc(); +-#else +- nonsimple.values_and_holders = (void **) PyMem_New(void *, space); +- if (!nonsimple.values_and_holders) throw std::bad_alloc(); +- std::memset(nonsimple.values_and_holders, 0, space * sizeof(void *)); +-#endif +- nonsimple.status = reinterpret_cast(&nonsimple.values_and_holders[flags_at]); +- } +- owned = true; +-} +- +-PYBIND11_NOINLINE inline void instance::deallocate_layout() { +- if (!simple_layout) +- PyMem_Free(nonsimple.values_and_holders); +-} +- +-PYBIND11_NOINLINE inline bool isinstance_generic(handle obj, const std::type_info &tp) { +- handle type = detail::get_type_handle(tp, false); +- if (!type) +- return false; +- return isinstance(obj, type); +-} +- +-PYBIND11_NOINLINE inline std::string error_string() { +- if (!PyErr_Occurred()) { +- PyErr_SetString(PyExc_RuntimeError, "Unknown internal error occurred"); +- return "Unknown internal error occurred"; +- } +- +- error_scope scope; // Preserve error state +- +- std::string errorString; +- if (scope.type) { +- errorString += handle(scope.type).attr("__name__").cast(); +- errorString += ": "; +- } +- if (scope.value) +- errorString += (std::string) str(scope.value); +- +- PyErr_NormalizeException(&scope.type, &scope.value, &scope.trace); +- +-#if PY_MAJOR_VERSION >= 3 +- if (scope.trace != nullptr) +- PyException_SetTraceback(scope.value, scope.trace); +-#endif +- +-#if !defined(PYPY_VERSION) +- if (scope.trace) { +- auto *trace = (PyTracebackObject *) scope.trace; +- +- /* Get the deepest trace possible */ +- while (trace->tb_next) +- trace = trace->tb_next; +- +- PyFrameObject *frame = trace->tb_frame; +- errorString += "\n\nAt:\n"; +- while (frame) { +- int lineno = PyFrame_GetLineNumber(frame); +- errorString += +- " " + handle(frame->f_code->co_filename).cast() + +- "(" + std::to_string(lineno) + "): " + +- handle(frame->f_code->co_name).cast() + "\n"; +- frame = frame->f_back; +- } +- } +-#endif +- +- return errorString; +-} +- +-PYBIND11_NOINLINE inline handle get_object_handle(const void *ptr, const detail::type_info *type ) { +- auto &instances = get_internals().registered_instances; +- auto range = instances.equal_range(ptr); +- for (auto it = range.first; it != range.second; ++it) { +- for (const auto &vh : values_and_holders(it->second)) { +- if (vh.type == type) +- return handle((PyObject *) it->second); +- } +- } +- return handle(); +-} +- +-inline PyThreadState *get_thread_state_unchecked() { +-#if defined(PYPY_VERSION) +- return PyThreadState_GET(); +-#elif PY_VERSION_HEX < 0x03000000 +- return _PyThreadState_Current; +-#elif PY_VERSION_HEX < 0x03050000 +- return (PyThreadState*) _Py_atomic_load_relaxed(&_PyThreadState_Current); +-#elif PY_VERSION_HEX < 0x03050200 +- return (PyThreadState*) _PyThreadState_Current.value; +-#else +- return _PyThreadState_UncheckedGet(); +-#endif +-} +- +-// Forward declarations +-inline void keep_alive_impl(handle nurse, handle patient); +-inline PyObject *make_new_instance(PyTypeObject *type); +- +-class type_caster_generic { +-public: +- PYBIND11_NOINLINE type_caster_generic(const std::type_info &type_info) +- : typeinfo(get_type_info(type_info)), cpptype(&type_info) { } +- +- type_caster_generic(const type_info *typeinfo) +- : typeinfo(typeinfo), cpptype(typeinfo ? typeinfo->cpptype : nullptr) { } +- +- bool load(handle src, bool convert) { +- return load_impl(src, convert); +- } +- +- PYBIND11_NOINLINE static handle cast(const void *_src, return_value_policy policy, handle parent, +- const detail::type_info *tinfo, +- void *(*copy_constructor)(const void *), +- void *(*move_constructor)(const void *), +- const void *existing_holder = nullptr) { +- if (!tinfo) // no type info: error will be set already +- return handle(); +- +- void *src = const_cast(_src); +- if (src == nullptr) +- return none().release(); +- +- auto it_instances = get_internals().registered_instances.equal_range(src); +- for (auto it_i = it_instances.first; it_i != it_instances.second; ++it_i) { +- for (auto instance_type : detail::all_type_info(Py_TYPE(it_i->second))) { +- if (instance_type && same_type(*instance_type->cpptype, *tinfo->cpptype)) +- return handle((PyObject *) it_i->second).inc_ref(); +- } +- } +- +- auto inst = reinterpret_steal(make_new_instance(tinfo->type)); +- auto wrapper = reinterpret_cast(inst.ptr()); +- wrapper->owned = false; +- void *&valueptr = values_and_holders(wrapper).begin()->value_ptr(); +- +- switch (policy) { +- case return_value_policy::automatic: +- case return_value_policy::take_ownership: +- valueptr = src; +- wrapper->owned = true; +- break; +- +- case return_value_policy::automatic_reference: +- case return_value_policy::reference: +- valueptr = src; +- wrapper->owned = false; +- break; +- +- case return_value_policy::copy: +- if (copy_constructor) +- valueptr = copy_constructor(src); +- else { +-#if defined(NDEBUG) +- throw cast_error("return_value_policy = copy, but type is " +- "non-copyable! (compile in debug mode for details)"); +-#else +- std::string type_name(tinfo->cpptype->name()); +- detail::clean_type_id(type_name); +- throw cast_error("return_value_policy = copy, but type " + +- type_name + " is non-copyable!"); +-#endif +- } +- wrapper->owned = true; +- break; +- +- case return_value_policy::move: +- if (move_constructor) +- valueptr = move_constructor(src); +- else if (copy_constructor) +- valueptr = copy_constructor(src); +- else { +-#if defined(NDEBUG) +- throw cast_error("return_value_policy = move, but type is neither " +- "movable nor copyable! " +- "(compile in debug mode for details)"); +-#else +- std::string type_name(tinfo->cpptype->name()); +- detail::clean_type_id(type_name); +- throw cast_error("return_value_policy = move, but type " + +- type_name + " is neither movable nor copyable!"); +-#endif +- } +- wrapper->owned = true; +- break; +- +- case return_value_policy::reference_internal: +- valueptr = src; +- wrapper->owned = false; +- keep_alive_impl(inst, parent); +- break; +- +- default: +- throw cast_error("unhandled return_value_policy: should not happen!"); +- } +- +- tinfo->init_instance(wrapper, existing_holder); +- +- return inst.release(); +- } +- +- // Base methods for generic caster; there are overridden in copyable_holder_caster +- void load_value(value_and_holder &&v_h) { +- auto *&vptr = v_h.value_ptr(); +- // Lazy allocation for unallocated values: +- if (vptr == nullptr) { +- auto *type = v_h.type ? v_h.type : typeinfo; +- if (type->operator_new) { +- vptr = type->operator_new(type->type_size); +- } else { +- #if defined(__cpp_aligned_new) && (!defined(_MSC_VER) || _MSC_VER >= 1912) +- if (type->type_align > __STDCPP_DEFAULT_NEW_ALIGNMENT__) +- vptr = ::operator new(type->type_size, +- std::align_val_t(type->type_align)); +- else +- #endif +- vptr = ::operator new(type->type_size); +- } +- } +- value = vptr; +- } +- bool try_implicit_casts(handle src, bool convert) { +- for (auto &cast : typeinfo->implicit_casts) { +- type_caster_generic sub_caster(*cast.first); +- if (sub_caster.load(src, convert)) { +- value = cast.second(sub_caster.value); +- return true; +- } +- } +- return false; +- } +- bool try_direct_conversions(handle src) { +- for (auto &converter : *typeinfo->direct_conversions) { +- if (converter(src.ptr(), value)) +- return true; +- } +- return false; +- } +- void check_holder_compat() {} +- +- PYBIND11_NOINLINE static void *local_load(PyObject *src, const type_info *ti) { +- auto caster = type_caster_generic(ti); +- if (caster.load(src, false)) +- return caster.value; +- return nullptr; +- } +- +- /// Try to load with foreign typeinfo, if available. Used when there is no +- /// native typeinfo, or when the native one wasn't able to produce a value. +- PYBIND11_NOINLINE bool try_load_foreign_module_local(handle src) { +- constexpr auto *local_key = PYBIND11_MODULE_LOCAL_ID; +- const auto pytype = type::handle_of(src); +- if (!hasattr(pytype, local_key)) +- return false; +- +- type_info *foreign_typeinfo = reinterpret_borrow(getattr(pytype, local_key)); +- // Only consider this foreign loader if actually foreign and is a loader of the correct cpp type +- if (foreign_typeinfo->module_local_load == &local_load +- || (cpptype && !same_type(*cpptype, *foreign_typeinfo->cpptype))) +- return false; +- +- if (auto result = foreign_typeinfo->module_local_load(src.ptr(), foreign_typeinfo)) { +- value = result; +- return true; +- } +- return false; +- } +- +- // Implementation of `load`; this takes the type of `this` so that it can dispatch the relevant +- // bits of code between here and copyable_holder_caster where the two classes need different +- // logic (without having to resort to virtual inheritance). +- template +- PYBIND11_NOINLINE bool load_impl(handle src, bool convert) { +- if (!src) return false; +- if (!typeinfo) return try_load_foreign_module_local(src); +- if (src.is_none()) { +- // Defer accepting None to other overloads (if we aren't in convert mode): +- if (!convert) return false; +- value = nullptr; +- return true; +- } +- +- auto &this_ = static_cast(*this); +- this_.check_holder_compat(); +- +- PyTypeObject *srctype = Py_TYPE(src.ptr()); +- +- // Case 1: If src is an exact type match for the target type then we can reinterpret_cast +- // the instance's value pointer to the target type: +- if (srctype == typeinfo->type) { +- this_.load_value(reinterpret_cast(src.ptr())->get_value_and_holder()); +- return true; +- } +- // Case 2: We have a derived class +- else if (PyType_IsSubtype(srctype, typeinfo->type)) { +- auto &bases = all_type_info(srctype); +- bool no_cpp_mi = typeinfo->simple_type; +- +- // Case 2a: the python type is a Python-inherited derived class that inherits from just +- // one simple (no MI) pybind11 class, or is an exact match, so the C++ instance is of +- // the right type and we can use reinterpret_cast. +- // (This is essentially the same as case 2b, but because not using multiple inheritance +- // is extremely common, we handle it specially to avoid the loop iterator and type +- // pointer lookup overhead) +- if (bases.size() == 1 && (no_cpp_mi || bases.front()->type == typeinfo->type)) { +- this_.load_value(reinterpret_cast(src.ptr())->get_value_and_holder()); +- return true; +- } +- // Case 2b: the python type inherits from multiple C++ bases. Check the bases to see if +- // we can find an exact match (or, for a simple C++ type, an inherited match); if so, we +- // can safely reinterpret_cast to the relevant pointer. +- else if (bases.size() > 1) { +- for (auto base : bases) { +- if (no_cpp_mi ? PyType_IsSubtype(base->type, typeinfo->type) : base->type == typeinfo->type) { +- this_.load_value(reinterpret_cast(src.ptr())->get_value_and_holder(base)); +- return true; +- } +- } +- } +- +- // Case 2c: C++ multiple inheritance is involved and we couldn't find an exact type match +- // in the registered bases, above, so try implicit casting (needed for proper C++ casting +- // when MI is involved). +- if (this_.try_implicit_casts(src, convert)) +- return true; +- } +- +- // Perform an implicit conversion +- if (convert) { +- for (auto &converter : typeinfo->implicit_conversions) { +- auto temp = reinterpret_steal(converter(src.ptr(), typeinfo->type)); +- if (load_impl(temp, false)) { +- loader_life_support::add_patient(temp); +- return true; +- } +- } +- if (this_.try_direct_conversions(src)) +- return true; +- } +- +- // Failed to match local typeinfo. Try again with global. +- if (typeinfo->module_local) { +- if (auto gtype = get_global_type_info(*typeinfo->cpptype)) { +- typeinfo = gtype; +- return load(src, false); +- } +- } +- +- // Global typeinfo has precedence over foreign module_local +- return try_load_foreign_module_local(src); +- } +- +- +- // Called to do type lookup and wrap the pointer and type in a pair when a dynamic_cast +- // isn't needed or can't be used. If the type is unknown, sets the error and returns a pair +- // with .second = nullptr. (p.first = nullptr is not an error: it becomes None). +- PYBIND11_NOINLINE static std::pair src_and_type( +- const void *src, const std::type_info &cast_type, const std::type_info *rtti_type = nullptr) { +- if (auto *tpi = get_type_info(cast_type)) +- return {src, const_cast(tpi)}; +- +- // Not found, set error: +- std::string tname = rtti_type ? rtti_type->name() : cast_type.name(); +- detail::clean_type_id(tname); +- std::string msg = "Unregistered type : " + tname; +- PyErr_SetString(PyExc_TypeError, msg.c_str()); +- return {nullptr, nullptr}; +- } +- +- const type_info *typeinfo = nullptr; +- const std::type_info *cpptype = nullptr; +- void *value = nullptr; +-}; +- +-/** +- * Determine suitable casting operator for pointer-or-lvalue-casting type casters. The type caster +- * needs to provide `operator T*()` and `operator T&()` operators. +- * +- * If the type supports moving the value away via an `operator T&&() &&` method, it should use +- * `movable_cast_op_type` instead. +- */ +-template +-using cast_op_type = +- conditional_t>::value, +- typename std::add_pointer>::type, +- typename std::add_lvalue_reference>::type>; +- +-/** +- * Determine suitable casting operator for a type caster with a movable value. Such a type caster +- * needs to provide `operator T*()`, `operator T&()`, and `operator T&&() &&`. The latter will be +- * called in appropriate contexts where the value can be moved rather than copied. +- * +- * These operator are automatically provided when using the PYBIND11_TYPE_CASTER macro. +- */ +-template +-using movable_cast_op_type = +- conditional_t::type>::value, +- typename std::add_pointer>::type, +- conditional_t::value, +- typename std::add_rvalue_reference>::type, +- typename std::add_lvalue_reference>::type>>; +- +-// std::is_copy_constructible isn't quite enough: it lets std::vector (and similar) through when +-// T is non-copyable, but code containing such a copy constructor fails to actually compile. +-template struct is_copy_constructible : std::is_copy_constructible {}; +- +-// Specialization for types that appear to be copy constructible but also look like stl containers +-// (we specifically check for: has `value_type` and `reference` with `reference = value_type&`): if +-// so, copy constructability depends on whether the value_type is copy constructible. +-template struct is_copy_constructible, +- std::is_same, +- // Avoid infinite recursion +- negation> +- >::value>> : is_copy_constructible {}; +- +-// Likewise for std::pair +-// (after C++17 it is mandatory that the copy constructor not exist when the two types aren't themselves +-// copy constructible, but this can not be relied upon when T1 or T2 are themselves containers). +-template struct is_copy_constructible> +- : all_of, is_copy_constructible> {}; +- +-// The same problems arise with std::is_copy_assignable, so we use the same workaround. +-template struct is_copy_assignable : std::is_copy_assignable {}; +-template struct is_copy_assignable, +- std::is_same +- >::value>> : is_copy_assignable {}; +-template struct is_copy_assignable> +- : all_of, is_copy_assignable> {}; +- +-PYBIND11_NAMESPACE_END(detail) +- +-// polymorphic_type_hook::get(src, tinfo) determines whether the object pointed +-// to by `src` actually is an instance of some class derived from `itype`. +-// If so, it sets `tinfo` to point to the std::type_info representing that derived +-// type, and returns a pointer to the start of the most-derived object of that type +-// (in which `src` is a subobject; this will be the same address as `src` in most +-// single inheritance cases). If not, or if `src` is nullptr, it simply returns `src` +-// and leaves `tinfo` at its default value of nullptr. +-// +-// The default polymorphic_type_hook just returns src. A specialization for polymorphic +-// types determines the runtime type of the passed object and adjusts the this-pointer +-// appropriately via dynamic_cast. This is what enables a C++ Animal* to appear +-// to Python as a Dog (if Dog inherits from Animal, Animal is polymorphic, Dog is +-// registered with pybind11, and this Animal is in fact a Dog). +-// +-// You may specialize polymorphic_type_hook yourself for types that want to appear +-// polymorphic to Python but do not use C++ RTTI. (This is a not uncommon pattern +-// in performance-sensitive applications, used most notably in LLVM.) +-// +-// polymorphic_type_hook_base allows users to specialize polymorphic_type_hook with +-// std::enable_if. User provided specializations will always have higher priority than +-// the default implementation and specialization provided in polymorphic_type_hook_base. +-template +-struct polymorphic_type_hook_base +-{ +- static const void *get(const itype *src, const std::type_info*&) { return src; } +-}; +-template +-struct polymorphic_type_hook_base::value>> +-{ +- static const void *get(const itype *src, const std::type_info*& type) { +- type = src ? &typeid(*src) : nullptr; +- return dynamic_cast(src); +- } +-}; +-template +-struct polymorphic_type_hook : public polymorphic_type_hook_base {}; +- +-PYBIND11_NAMESPACE_BEGIN(detail) +- +-/// Generic type caster for objects stored on the heap +-template class type_caster_base : public type_caster_generic { +- using itype = intrinsic_t; +- +-public: +- static constexpr auto name = _(); +- +- type_caster_base() : type_caster_base(typeid(type)) { } +- explicit type_caster_base(const std::type_info &info) : type_caster_generic(info) { } +- +- static handle cast(const itype &src, return_value_policy policy, handle parent) { +- if (policy == return_value_policy::automatic || policy == return_value_policy::automatic_reference) +- policy = return_value_policy::copy; +- return cast(&src, policy, parent); +- } +- +- static handle cast(itype &&src, return_value_policy, handle parent) { +- return cast(&src, return_value_policy::move, parent); +- } +- +- // Returns a (pointer, type_info) pair taking care of necessary type lookup for a +- // polymorphic type (using RTTI by default, but can be overridden by specializing +- // polymorphic_type_hook). If the instance isn't derived, returns the base version. +- static std::pair src_and_type(const itype *src) { +- auto &cast_type = typeid(itype); +- const std::type_info *instance_type = nullptr; +- const void *vsrc = polymorphic_type_hook::get(src, instance_type); +- if (instance_type && !same_type(cast_type, *instance_type)) { +- // This is a base pointer to a derived type. If the derived type is registered +- // with pybind11, we want to make the full derived object available. +- // In the typical case where itype is polymorphic, we get the correct +- // derived pointer (which may be != base pointer) by a dynamic_cast to +- // most derived type. If itype is not polymorphic, we won't get here +- // except via a user-provided specialization of polymorphic_type_hook, +- // and the user has promised that no this-pointer adjustment is +- // required in that case, so it's OK to use static_cast. +- if (const auto *tpi = get_type_info(*instance_type)) +- return {vsrc, tpi}; +- } +- // Otherwise we have either a nullptr, an `itype` pointer, or an unknown derived pointer, so +- // don't do a cast +- return type_caster_generic::src_and_type(src, cast_type, instance_type); +- } +- +- static handle cast(const itype *src, return_value_policy policy, handle parent) { +- auto st = src_and_type(src); +- return type_caster_generic::cast( +- st.first, policy, parent, st.second, +- make_copy_constructor(src), make_move_constructor(src)); +- } +- +- static handle cast_holder(const itype *src, const void *holder) { +- auto st = src_and_type(src); +- return type_caster_generic::cast( +- st.first, return_value_policy::take_ownership, {}, st.second, +- nullptr, nullptr, holder); +- } +- +- template using cast_op_type = detail::cast_op_type; +- +- operator itype*() { return (type *) value; } +- operator itype&() { if (!value) throw reference_cast_error(); return *((itype *) value); } +- +-protected: +- using Constructor = void *(*)(const void *); +- +- /* Only enabled when the types are {copy,move}-constructible *and* when the type +- does not have a private operator new implementation. */ +- template ::value>> +- static auto make_copy_constructor(const T *x) -> decltype(new T(*x), Constructor{}) { +- return [](const void *arg) -> void * { +- return new T(*reinterpret_cast(arg)); +- }; +- } +- +- template ::value>> +- static auto make_move_constructor(const T *x) -> decltype(new T(std::move(*const_cast(x))), Constructor{}) { +- return [](const void *arg) -> void * { +- return new T(std::move(*const_cast(reinterpret_cast(arg)))); +- }; +- } +- +- static Constructor make_copy_constructor(...) { return nullptr; } +- static Constructor make_move_constructor(...) { return nullptr; } +-}; +- +-template class type_caster : public type_caster_base { }; +-template using make_caster = type_caster>; +- +-// Shortcut for calling a caster's `cast_op_type` cast operator for casting a type_caster to a T +-template typename make_caster::template cast_op_type cast_op(make_caster &caster) { +- return caster.operator typename make_caster::template cast_op_type(); +-} +-template typename make_caster::template cast_op_type::type> +-cast_op(make_caster &&caster) { +- return std::move(caster).operator +- typename make_caster::template cast_op_type::type>(); +-} +- +-template class type_caster> { +-private: +- using caster_t = make_caster; +- caster_t subcaster; +- using subcaster_cast_op_type = typename caster_t::template cast_op_type; +- static_assert(std::is_same::type &, subcaster_cast_op_type>::value, +- "std::reference_wrapper caster requires T to have a caster with an `T &` operator"); +-public: +- bool load(handle src, bool convert) { return subcaster.load(src, convert); } +- static constexpr auto name = caster_t::name; +- static handle cast(const std::reference_wrapper &src, return_value_policy policy, handle parent) { +- // It is definitely wrong to take ownership of this pointer, so mask that rvp +- if (policy == return_value_policy::take_ownership || policy == return_value_policy::automatic) +- policy = return_value_policy::automatic_reference; +- return caster_t::cast(&src.get(), policy, parent); +- } +- template using cast_op_type = std::reference_wrapper; +- operator std::reference_wrapper() { return subcaster.operator subcaster_cast_op_type&(); } +-}; +- +-#define PYBIND11_TYPE_CASTER(type, py_name) \ +- protected: \ +- type value; \ +- public: \ +- static constexpr auto name = py_name; \ +- template >::value, int> = 0> \ +- static handle cast(T_ *src, return_value_policy policy, handle parent) { \ +- if (!src) return none().release(); \ +- if (policy == return_value_policy::take_ownership) { \ +- auto h = cast(std::move(*src), policy, parent); delete src; return h; \ +- } else { \ +- return cast(*src, policy, parent); \ +- } \ +- } \ +- operator type*() { return &value; } \ +- operator type&() { return value; } \ +- operator type&&() && { return std::move(value); } \ +- template using cast_op_type = pybind11::detail::movable_cast_op_type +- +- +-template using is_std_char_type = any_of< +- std::is_same, /* std::string */ +-#if defined(PYBIND11_HAS_U8STRING) +- std::is_same, /* std::u8string */ +-#endif +- std::is_same, /* std::u16string */ +- std::is_same, /* std::u32string */ +- std::is_same /* std::wstring */ +->; +- +- +-template +-struct type_caster::value && !is_std_char_type::value>> { +- using _py_type_0 = conditional_t; +- using _py_type_1 = conditional_t::value, _py_type_0, typename std::make_unsigned<_py_type_0>::type>; +- using py_type = conditional_t::value, double, _py_type_1>; +-public: +- +- bool load(handle src, bool convert) { +- py_type py_value; +- +- if (!src) +- return false; +- +- if (std::is_floating_point::value) { +- if (convert || PyFloat_Check(src.ptr())) +- py_value = (py_type) PyFloat_AsDouble(src.ptr()); +- else +- return false; +- } else if (PyFloat_Check(src.ptr())) { +- return false; +- } else if (std::is_unsigned::value) { +- py_value = as_unsigned(src.ptr()); +- } else { // signed integer: +- py_value = sizeof(T) <= sizeof(long) +- ? (py_type) PyLong_AsLong(src.ptr()) +- : (py_type) PYBIND11_LONG_AS_LONGLONG(src.ptr()); +- } +- +- // Python API reported an error +- bool py_err = py_value == (py_type) -1 && PyErr_Occurred(); +- +- // Check to see if the conversion is valid (integers should match exactly) +- // Signed/unsigned checks happen elsewhere +- if (py_err || (std::is_integral::value && sizeof(py_type) != sizeof(T) && py_value != (py_type) (T) py_value)) { +- bool type_error = py_err && PyErr_ExceptionMatches( +-#if PY_VERSION_HEX < 0x03000000 && !defined(PYPY_VERSION) +- PyExc_SystemError +-#else +- PyExc_TypeError +-#endif +- ); +- PyErr_Clear(); +- if (type_error && convert && PyNumber_Check(src.ptr())) { +- auto tmp = reinterpret_steal(std::is_floating_point::value +- ? PyNumber_Float(src.ptr()) +- : PyNumber_Long(src.ptr())); +- PyErr_Clear(); +- return load(tmp, false); +- } +- return false; +- } +- +- value = (T) py_value; +- return true; +- } +- +- template +- static typename std::enable_if::value, handle>::type +- cast(U src, return_value_policy /* policy */, handle /* parent */) { +- return PyFloat_FromDouble((double) src); +- } +- +- template +- static typename std::enable_if::value && std::is_signed::value && (sizeof(U) <= sizeof(long)), handle>::type +- cast(U src, return_value_policy /* policy */, handle /* parent */) { +- return PYBIND11_LONG_FROM_SIGNED((long) src); +- } +- +- template +- static typename std::enable_if::value && std::is_unsigned::value && (sizeof(U) <= sizeof(unsigned long)), handle>::type +- cast(U src, return_value_policy /* policy */, handle /* parent */) { +- return PYBIND11_LONG_FROM_UNSIGNED((unsigned long) src); +- } +- +- template +- static typename std::enable_if::value && std::is_signed::value && (sizeof(U) > sizeof(long)), handle>::type +- cast(U src, return_value_policy /* policy */, handle /* parent */) { +- return PyLong_FromLongLong((long long) src); +- } +- +- template +- static typename std::enable_if::value && std::is_unsigned::value && (sizeof(U) > sizeof(unsigned long)), handle>::type +- cast(U src, return_value_policy /* policy */, handle /* parent */) { +- return PyLong_FromUnsignedLongLong((unsigned long long) src); +- } +- +- PYBIND11_TYPE_CASTER(T, _::value>("int", "float")); +-}; +- +-template struct void_caster { +-public: +- bool load(handle src, bool) { +- if (src && src.is_none()) +- return true; +- return false; +- } +- static handle cast(T, return_value_policy /* policy */, handle /* parent */) { +- return none().inc_ref(); +- } +- PYBIND11_TYPE_CASTER(T, _("None")); +-}; +- +-template <> class type_caster : public void_caster {}; +- +-template <> class type_caster : public type_caster { +-public: +- using type_caster::cast; +- +- bool load(handle h, bool) { +- if (!h) { +- return false; +- } else if (h.is_none()) { +- value = nullptr; +- return true; +- } +- +- /* Check if this is a capsule */ +- if (isinstance(h)) { +- value = reinterpret_borrow(h); +- return true; +- } +- +- /* Check if this is a C++ type */ +- auto &bases = all_type_info((PyTypeObject *) type::handle_of(h).ptr()); +- if (bases.size() == 1) { // Only allowing loading from a single-value type +- value = values_and_holders(reinterpret_cast(h.ptr())).begin()->value_ptr(); +- return true; +- } +- +- /* Fail */ +- return false; +- } +- +- static handle cast(const void *ptr, return_value_policy /* policy */, handle /* parent */) { +- if (ptr) +- return capsule(ptr).release(); +- else +- return none().inc_ref(); +- } +- +- template using cast_op_type = void*&; +- operator void *&() { return value; } +- static constexpr auto name = _("capsule"); +-private: +- void *value = nullptr; +-}; +- +-template <> class type_caster : public void_caster { }; +- +-template <> class type_caster { +-public: +- bool load(handle src, bool convert) { +- if (!src) return false; +- else if (src.ptr() == Py_True) { value = true; return true; } +- else if (src.ptr() == Py_False) { value = false; return true; } +- else if (convert || !strcmp("numpy.bool_", Py_TYPE(src.ptr())->tp_name)) { +- // (allow non-implicit conversion for numpy booleans) +- +- Py_ssize_t res = -1; +- if (src.is_none()) { +- res = 0; // None is implicitly converted to False +- } +- #if defined(PYPY_VERSION) +- // On PyPy, check that "__bool__" (or "__nonzero__" on Python 2.7) attr exists +- else if (hasattr(src, PYBIND11_BOOL_ATTR)) { +- res = PyObject_IsTrue(src.ptr()); +- } +- #else +- // Alternate approach for CPython: this does the same as the above, but optimized +- // using the CPython API so as to avoid an unneeded attribute lookup. +- else if (auto tp_as_number = src.ptr()->ob_type->tp_as_number) { +- if (PYBIND11_NB_BOOL(tp_as_number)) { +- res = (*PYBIND11_NB_BOOL(tp_as_number))(src.ptr()); +- } +- } +- #endif +- if (res == 0 || res == 1) { +- value = (bool) res; +- return true; +- } else { +- PyErr_Clear(); +- } +- } +- return false; +- } +- static handle cast(bool src, return_value_policy /* policy */, handle /* parent */) { +- return handle(src ? Py_True : Py_False).inc_ref(); +- } +- PYBIND11_TYPE_CASTER(bool, _("bool")); +-}; +- +-// Helper class for UTF-{8,16,32} C++ stl strings: +-template struct string_caster { +- using CharT = typename StringType::value_type; +- +- // Simplify life by being able to assume standard char sizes (the standard only guarantees +- // minimums, but Python requires exact sizes) +- static_assert(!std::is_same::value || sizeof(CharT) == 1, "Unsupported char size != 1"); +-#if defined(PYBIND11_HAS_U8STRING) +- static_assert(!std::is_same::value || sizeof(CharT) == 1, "Unsupported char8_t size != 1"); +-#endif +- static_assert(!std::is_same::value || sizeof(CharT) == 2, "Unsupported char16_t size != 2"); +- static_assert(!std::is_same::value || sizeof(CharT) == 4, "Unsupported char32_t size != 4"); +- // wchar_t can be either 16 bits (Windows) or 32 (everywhere else) +- static_assert(!std::is_same::value || sizeof(CharT) == 2 || sizeof(CharT) == 4, +- "Unsupported wchar_t size != 2/4"); +- static constexpr size_t UTF_N = 8 * sizeof(CharT); +- +- bool load(handle src, bool) { +-#if PY_MAJOR_VERSION < 3 +- object temp; +-#endif +- handle load_src = src; +- if (!src) { +- return false; +- } else if (!PyUnicode_Check(load_src.ptr())) { +-#if PY_MAJOR_VERSION >= 3 +- return load_bytes(load_src); +-#else +- if (std::is_same::value) { +- return load_bytes(load_src); +- } +- +- // The below is a guaranteed failure in Python 3 when PyUnicode_Check returns false +- if (!PYBIND11_BYTES_CHECK(load_src.ptr())) +- return false; +- +- temp = reinterpret_steal(PyUnicode_FromObject(load_src.ptr())); +- if (!temp) { PyErr_Clear(); return false; } +- load_src = temp; +-#endif +- } +- +- auto utfNbytes = reinterpret_steal(PyUnicode_AsEncodedString( +- load_src.ptr(), UTF_N == 8 ? "utf-8" : UTF_N == 16 ? "utf-16" : "utf-32", nullptr)); +- if (!utfNbytes) { PyErr_Clear(); return false; } +- +- const auto *buffer = reinterpret_cast(PYBIND11_BYTES_AS_STRING(utfNbytes.ptr())); +- size_t length = (size_t) PYBIND11_BYTES_SIZE(utfNbytes.ptr()) / sizeof(CharT); +- if (UTF_N > 8) { buffer++; length--; } // Skip BOM for UTF-16/32 +- value = StringType(buffer, length); +- +- // If we're loading a string_view we need to keep the encoded Python object alive: +- if (IsView) +- loader_life_support::add_patient(utfNbytes); +- +- return true; +- } +- +- static handle cast(const StringType &src, return_value_policy /* policy */, handle /* parent */) { +- const char *buffer = reinterpret_cast(src.data()); +- auto nbytes = ssize_t(src.size() * sizeof(CharT)); +- handle s = decode_utfN(buffer, nbytes); +- if (!s) throw error_already_set(); +- return s; +- } +- +- PYBIND11_TYPE_CASTER(StringType, _(PYBIND11_STRING_NAME)); +- +-private: +- static handle decode_utfN(const char *buffer, ssize_t nbytes) { +-#if !defined(PYPY_VERSION) +- return +- UTF_N == 8 ? PyUnicode_DecodeUTF8(buffer, nbytes, nullptr) : +- UTF_N == 16 ? PyUnicode_DecodeUTF16(buffer, nbytes, nullptr, nullptr) : +- PyUnicode_DecodeUTF32(buffer, nbytes, nullptr, nullptr); +-#else +- // PyPy segfaults when on PyUnicode_DecodeUTF16 (and possibly on PyUnicode_DecodeUTF32 as well), +- // so bypass the whole thing by just passing the encoding as a string value, which works properly: +- return PyUnicode_Decode(buffer, nbytes, UTF_N == 8 ? "utf-8" : UTF_N == 16 ? "utf-16" : "utf-32", nullptr); +-#endif +- } +- +- // When loading into a std::string or char*, accept a bytes object as-is (i.e. +- // without any encoding/decoding attempt). For other C++ char sizes this is a no-op. +- // which supports loading a unicode from a str, doesn't take this path. +- template +- bool load_bytes(enable_if_t::value, handle> src) { +- if (PYBIND11_BYTES_CHECK(src.ptr())) { +- // We were passed a Python 3 raw bytes; accept it into a std::string or char* +- // without any encoding attempt. +- const char *bytes = PYBIND11_BYTES_AS_STRING(src.ptr()); +- if (bytes) { +- value = StringType(bytes, (size_t) PYBIND11_BYTES_SIZE(src.ptr())); +- return true; +- } +- } +- +- return false; +- } +- +- template +- bool load_bytes(enable_if_t::value, handle>) { return false; } +-}; +- +-template +-struct type_caster, enable_if_t::value>> +- : string_caster> {}; +- +-#ifdef PYBIND11_HAS_STRING_VIEW +-template +-struct type_caster, enable_if_t::value>> +- : string_caster, true> {}; +-#endif +- +-// Type caster for C-style strings. We basically use a std::string type caster, but also add the +-// ability to use None as a nullptr char* (which the string caster doesn't allow). +-template struct type_caster::value>> { +- using StringType = std::basic_string; +- using StringCaster = type_caster; +- StringCaster str_caster; +- bool none = false; +- CharT one_char = 0; +-public: +- bool load(handle src, bool convert) { +- if (!src) return false; +- if (src.is_none()) { +- // Defer accepting None to other overloads (if we aren't in convert mode): +- if (!convert) return false; +- none = true; +- return true; +- } +- return str_caster.load(src, convert); +- } +- +- static handle cast(const CharT *src, return_value_policy policy, handle parent) { +- if (src == nullptr) return pybind11::none().inc_ref(); +- return StringCaster::cast(StringType(src), policy, parent); +- } +- +- static handle cast(CharT src, return_value_policy policy, handle parent) { +- if (std::is_same::value) { +- handle s = PyUnicode_DecodeLatin1((const char *) &src, 1, nullptr); +- if (!s) throw error_already_set(); +- return s; +- } +- return StringCaster::cast(StringType(1, src), policy, parent); +- } +- +- operator CharT*() { return none ? nullptr : const_cast(static_cast(str_caster).c_str()); } +- operator CharT&() { +- if (none) +- throw value_error("Cannot convert None to a character"); +- +- auto &value = static_cast(str_caster); +- size_t str_len = value.size(); +- if (str_len == 0) +- throw value_error("Cannot convert empty string to a character"); +- +- // If we're in UTF-8 mode, we have two possible failures: one for a unicode character that +- // is too high, and one for multiple unicode characters (caught later), so we need to figure +- // out how long the first encoded character is in bytes to distinguish between these two +- // errors. We also allow want to allow unicode characters U+0080 through U+00FF, as those +- // can fit into a single char value. +- if (StringCaster::UTF_N == 8 && str_len > 1 && str_len <= 4) { +- auto v0 = static_cast(value[0]); +- size_t char0_bytes = !(v0 & 0x80) ? 1 : // low bits only: 0-127 +- (v0 & 0xE0) == 0xC0 ? 2 : // 0b110xxxxx - start of 2-byte sequence +- (v0 & 0xF0) == 0xE0 ? 3 : // 0b1110xxxx - start of 3-byte sequence +- 4; // 0b11110xxx - start of 4-byte sequence +- +- if (char0_bytes == str_len) { +- // If we have a 128-255 value, we can decode it into a single char: +- if (char0_bytes == 2 && (v0 & 0xFC) == 0xC0) { // 0x110000xx 0x10xxxxxx +- one_char = static_cast(((v0 & 3) << 6) + (static_cast(value[1]) & 0x3F)); +- return one_char; +- } +- // Otherwise we have a single character, but it's > U+00FF +- throw value_error("Character code point not in range(0x100)"); +- } +- } +- +- // UTF-16 is much easier: we can only have a surrogate pair for values above U+FFFF, thus a +- // surrogate pair with total length 2 instantly indicates a range error (but not a "your +- // string was too long" error). +- else if (StringCaster::UTF_N == 16 && str_len == 2) { +- one_char = static_cast(value[0]); +- if (one_char >= 0xD800 && one_char < 0xE000) +- throw value_error("Character code point not in range(0x10000)"); +- } +- +- if (str_len != 1) +- throw value_error("Expected a character, but multi-character string found"); +- +- one_char = value[0]; +- return one_char; +- } +- +- static constexpr auto name = _(PYBIND11_STRING_NAME); +- template using cast_op_type = pybind11::detail::cast_op_type<_T>; +-}; +- +-// Base implementation for std::tuple and std::pair +-template class Tuple, typename... Ts> class tuple_caster { +- using type = Tuple; +- static constexpr auto size = sizeof...(Ts); +- using indices = make_index_sequence; +-public: +- +- bool load(handle src, bool convert) { +- if (!isinstance(src)) +- return false; +- const auto seq = reinterpret_borrow(src); +- if (seq.size() != size) +- return false; +- return load_impl(seq, convert, indices{}); +- } +- +- template +- static handle cast(T &&src, return_value_policy policy, handle parent) { +- return cast_impl(std::forward(src), policy, parent, indices{}); +- } +- +- // copied from the PYBIND11_TYPE_CASTER macro +- template +- static handle cast(T *src, return_value_policy policy, handle parent) { +- if (!src) return none().release(); +- if (policy == return_value_policy::take_ownership) { +- auto h = cast(std::move(*src), policy, parent); delete src; return h; +- } else { +- return cast(*src, policy, parent); +- } +- } +- +- static constexpr auto name = _("Tuple[") + concat(make_caster::name...) + _("]"); +- +- template using cast_op_type = type; +- +- operator type() & { return implicit_cast(indices{}); } +- operator type() && { return std::move(*this).implicit_cast(indices{}); } +- +-protected: +- template +- type implicit_cast(index_sequence) & { return type(cast_op(std::get(subcasters))...); } +- template +- type implicit_cast(index_sequence) && { return type(cast_op(std::move(std::get(subcasters)))...); } +- +- static constexpr bool load_impl(const sequence &, bool, index_sequence<>) { return true; } +- +- template +- bool load_impl(const sequence &seq, bool convert, index_sequence) { +-#ifdef __cpp_fold_expressions +- if ((... || !std::get(subcasters).load(seq[Is], convert))) +- return false; +-#else +- for (bool r : {std::get(subcasters).load(seq[Is], convert)...}) +- if (!r) +- return false; +-#endif +- return true; +- } +- +- /* Implementation: Convert a C++ tuple into a Python tuple */ +- template +- static handle cast_impl(T &&src, return_value_policy policy, handle parent, index_sequence) { +- std::array entries{{ +- reinterpret_steal(make_caster::cast(std::get(std::forward(src)), policy, parent))... +- }}; +- for (const auto &entry: entries) +- if (!entry) +- return handle(); +- tuple result(size); +- int counter = 0; +- for (auto & entry: entries) +- PyTuple_SET_ITEM(result.ptr(), counter++, entry.release().ptr()); +- return result.release(); +- } +- +- Tuple...> subcasters; +-}; +- +-template class type_caster> +- : public tuple_caster {}; +- +-template class type_caster> +- : public tuple_caster {}; +- +-/// Helper class which abstracts away certain actions. Users can provide specializations for +-/// custom holders, but it's only necessary if the type has a non-standard interface. +-template +-struct holder_helper { +- static auto get(const T &p) -> decltype(p.get()) { return p.get(); } +-}; +- +-/// Type caster for holder types like std::shared_ptr, etc. +-template +-struct copyable_holder_caster : public type_caster_base { +-public: +- using base = type_caster_base; +- static_assert(std::is_base_of>::value, +- "Holder classes are only supported for custom types"); +- using base::base; +- using base::cast; +- using base::typeinfo; +- using base::value; +- +- bool load(handle src, bool convert) { +- return base::template load_impl>(src, convert); +- } +- +- explicit operator type*() { return this->value; } +- // static_cast works around compiler error with MSVC 17 and CUDA 10.2 +- // see issue #2180 +- explicit operator type&() { return *(static_cast(this->value)); } +- explicit operator holder_type*() { return std::addressof(holder); } +- explicit operator holder_type&() { return holder; } +- +- static handle cast(const holder_type &src, return_value_policy, handle) { +- const auto *ptr = holder_helper::get(src); +- return type_caster_base::cast_holder(ptr, &src); +- } +- +-protected: +- friend class type_caster_generic; +- void check_holder_compat() { +- if (typeinfo->default_holder) +- throw cast_error("Unable to load a custom holder type from a default-holder instance"); +- } +- +- bool load_value(value_and_holder &&v_h) { +- if (v_h.holder_constructed()) { +- value = v_h.value_ptr(); +- holder = v_h.template holder(); +- return true; +- } else { +- throw cast_error("Unable to cast from non-held to held instance (T& to Holder) " +-#if defined(NDEBUG) +- "(compile in debug mode for type information)"); +-#else +- "of type '" + type_id() + "''"); +-#endif +- } +- } +- +- template ::value, int> = 0> +- bool try_implicit_casts(handle, bool) { return false; } +- +- template ::value, int> = 0> +- bool try_implicit_casts(handle src, bool convert) { +- for (auto &cast : typeinfo->implicit_casts) { +- copyable_holder_caster sub_caster(*cast.first); +- if (sub_caster.load(src, convert)) { +- value = cast.second(sub_caster.value); +- holder = holder_type(sub_caster.holder, (type *) value); +- return true; +- } +- } +- return false; +- } +- +- static bool try_direct_conversions(handle) { return false; } +- +- +- holder_type holder; +-}; +- +-/// Specialize for the common std::shared_ptr, so users don't need to +-template +-class type_caster> : public copyable_holder_caster> { }; +- +-template +-struct move_only_holder_caster { +- static_assert(std::is_base_of, type_caster>::value, +- "Holder classes are only supported for custom types"); +- +- static handle cast(holder_type &&src, return_value_policy, handle) { +- auto *ptr = holder_helper::get(src); +- return type_caster_base::cast_holder(ptr, std::addressof(src)); +- } +- static constexpr auto name = type_caster_base::name; +-}; +- +-template +-class type_caster> +- : public move_only_holder_caster> { }; +- +-template +-using type_caster_holder = conditional_t::value, +- copyable_holder_caster, +- move_only_holder_caster>; +- +-template struct always_construct_holder { static constexpr bool value = Value; }; +- +-/// Create a specialization for custom holder types (silently ignores std::shared_ptr) +-#define PYBIND11_DECLARE_HOLDER_TYPE(type, holder_type, ...) \ +- namespace pybind11 { namespace detail { \ +- template \ +- struct always_construct_holder : always_construct_holder { }; \ +- template \ +- class type_caster::value>> \ +- : public type_caster_holder { }; \ +- }} +- +-// PYBIND11_DECLARE_HOLDER_TYPE holder types: +-template struct is_holder_type : +- std::is_base_of, detail::type_caster> {}; +-// Specialization for always-supported unique_ptr holders: +-template struct is_holder_type> : +- std::true_type {}; +- +-template struct handle_type_name { static constexpr auto name = _(); }; +-template <> struct handle_type_name { static constexpr auto name = _(PYBIND11_BYTES_NAME); }; +-template <> struct handle_type_name { static constexpr auto name = _("int"); }; +-template <> struct handle_type_name { static constexpr auto name = _("Iterable"); }; +-template <> struct handle_type_name { static constexpr auto name = _("Iterator"); }; +-template <> struct handle_type_name { static constexpr auto name = _("None"); }; +-template <> struct handle_type_name { static constexpr auto name = _("*args"); }; +-template <> struct handle_type_name { static constexpr auto name = _("**kwargs"); }; +- +-template +-struct pyobject_caster { +- template ::value, int> = 0> +- bool load(handle src, bool /* convert */) { value = src; return static_cast(value); } +- +- template ::value, int> = 0> +- bool load(handle src, bool /* convert */) { +- if (!isinstance(src)) +- return false; +- value = reinterpret_borrow(src); +- return true; +- } +- +- static handle cast(const handle &src, return_value_policy /* policy */, handle /* parent */) { +- return src.inc_ref(); +- } +- PYBIND11_TYPE_CASTER(type, handle_type_name::name); +-}; +- +-template +-class type_caster::value>> : public pyobject_caster { }; +- +-// Our conditions for enabling moving are quite restrictive: +-// At compile time: +-// - T needs to be a non-const, non-pointer, non-reference type +-// - type_caster::operator T&() must exist +-// - the type must be move constructible (obviously) +-// At run-time: +-// - if the type is non-copy-constructible, the object must be the sole owner of the type (i.e. it +-// must have ref_count() == 1)h +-// If any of the above are not satisfied, we fall back to copying. +-template using move_is_plain_type = satisfies_none_of; +-template struct move_always : std::false_type {}; +-template struct move_always, +- negation>, +- std::is_move_constructible, +- std::is_same>().operator T&()), T&> +->::value>> : std::true_type {}; +-template struct move_if_unreferenced : std::false_type {}; +-template struct move_if_unreferenced, +- negation>, +- std::is_move_constructible, +- std::is_same>().operator T&()), T&> +->::value>> : std::true_type {}; +-template using move_never = none_of, move_if_unreferenced>; +- +-// Detect whether returning a `type` from a cast on type's type_caster is going to result in a +-// reference or pointer to a local variable of the type_caster. Basically, only +-// non-reference/pointer `type`s and reference/pointers from a type_caster_generic are safe; +-// everything else returns a reference/pointer to a local variable. +-template using cast_is_temporary_value_reference = bool_constant< +- (std::is_reference::value || std::is_pointer::value) && +- !std::is_base_of>::value && +- !std::is_same, void>::value +->; +- +-// When a value returned from a C++ function is being cast back to Python, we almost always want to +-// force `policy = move`, regardless of the return value policy the function/method was declared +-// with. +-template struct return_value_policy_override { +- static return_value_policy policy(return_value_policy p) { return p; } +-}; +- +-template struct return_value_policy_override>::value, void>> { +- static return_value_policy policy(return_value_policy p) { +- return !std::is_lvalue_reference::value && +- !std::is_pointer::value +- ? return_value_policy::move : p; +- } +-}; +- +-// Basic python -> C++ casting; throws if casting fails +-template type_caster &load_type(type_caster &conv, const handle &handle) { +- if (!conv.load(handle, true)) { +-#if defined(NDEBUG) +- throw cast_error("Unable to cast Python instance to C++ type (compile in debug mode for details)"); +-#else +- throw cast_error("Unable to cast Python instance of type " + +- (std::string) str(type::handle_of(handle)) + " to C++ type '" + type_id() + "'"); +-#endif +- } +- return conv; +-} +-// Wrapper around the above that also constructs and returns a type_caster +-template make_caster load_type(const handle &handle) { +- make_caster conv; +- load_type(conv, handle); +- return conv; +-} +- +-PYBIND11_NAMESPACE_END(detail) +- +-// pytype -> C++ type +-template ::value, int> = 0> +-T cast(const handle &handle) { +- using namespace detail; +- static_assert(!cast_is_temporary_value_reference::value, +- "Unable to cast type to reference: value is local to type caster"); +- return cast_op(load_type(handle)); +-} +- +-// pytype -> pytype (calls converting constructor) +-template ::value, int> = 0> +-T cast(const handle &handle) { return T(reinterpret_borrow(handle)); } +- +-// C++ type -> py::object +-template ::value, int> = 0> +-object cast(T &&value, return_value_policy policy = return_value_policy::automatic_reference, +- handle parent = handle()) { +- using no_ref_T = typename std::remove_reference::type; +- if (policy == return_value_policy::automatic) +- policy = std::is_pointer::value ? return_value_policy::take_ownership : +- std::is_lvalue_reference::value ? return_value_policy::copy : return_value_policy::move; +- else if (policy == return_value_policy::automatic_reference) +- policy = std::is_pointer::value ? return_value_policy::reference : +- std::is_lvalue_reference::value ? return_value_policy::copy : return_value_policy::move; +- return reinterpret_steal(detail::make_caster::cast(std::forward(value), policy, parent)); +-} +- +-template T handle::cast() const { return pybind11::cast(*this); } +-template <> inline void handle::cast() const { return; } +- +-template +-detail::enable_if_t::value, T> move(object &&obj) { +- if (obj.ref_count() > 1) +-#if defined(NDEBUG) +- throw cast_error("Unable to cast Python instance to C++ rvalue: instance has multiple references" +- " (compile in debug mode for details)"); +-#else +- throw cast_error("Unable to move from Python " + (std::string) str(type::handle_of(obj)) + +- " instance to C++ " + type_id() + " instance: instance has multiple references"); +-#endif +- +- // Move into a temporary and return that, because the reference may be a local value of `conv` +- T ret = std::move(detail::load_type(obj).operator T&()); +- return ret; +-} +- +-// Calling cast() on an rvalue calls pybind11::cast with the object rvalue, which does: +-// - If we have to move (because T has no copy constructor), do it. This will fail if the moved +-// object has multiple references, but trying to copy will fail to compile. +-// - If both movable and copyable, check ref count: if 1, move; otherwise copy +-// - Otherwise (not movable), copy. +-template detail::enable_if_t::value, T> cast(object &&object) { +- return move(std::move(object)); +-} +-template detail::enable_if_t::value, T> cast(object &&object) { +- if (object.ref_count() > 1) +- return cast(object); +- else +- return move(std::move(object)); +-} +-template detail::enable_if_t::value, T> cast(object &&object) { +- return cast(object); +-} +- +-template T object::cast() const & { return pybind11::cast(*this); } +-template T object::cast() && { return pybind11::cast(std::move(*this)); } +-template <> inline void object::cast() const & { return; } +-template <> inline void object::cast() && { return; } +- +-PYBIND11_NAMESPACE_BEGIN(detail) +- +-// Declared in pytypes.h: +-template ::value, int>> +-object object_or_cast(T &&o) { return pybind11::cast(std::forward(o)); } +- +-struct override_unused {}; // Placeholder type for the unneeded (and dead code) static variable in the PYBIND11_OVERRIDE_OVERRIDE macro +-template using override_caster_t = conditional_t< +- cast_is_temporary_value_reference::value, make_caster, override_unused>; +- +-// Trampoline use: for reference/pointer types to value-converted values, we do a value cast, then +-// store the result in the given variable. For other types, this is a no-op. +-template enable_if_t::value, T> cast_ref(object &&o, make_caster &caster) { +- return cast_op(load_type(caster, o)); +-} +-template enable_if_t::value, T> cast_ref(object &&, override_unused &) { +- pybind11_fail("Internal error: cast_ref fallback invoked"); } +- +-// Trampoline use: Having a pybind11::cast with an invalid reference type is going to static_assert, even +-// though if it's in dead code, so we provide a "trampoline" to pybind11::cast that only does anything in +-// cases where pybind11::cast is valid. +-template enable_if_t::value, T> cast_safe(object &&o) { +- return pybind11::cast(std::move(o)); } +-template enable_if_t::value, T> cast_safe(object &&) { +- pybind11_fail("Internal error: cast_safe fallback invoked"); } +-template <> inline void cast_safe(object &&) {} +- +-PYBIND11_NAMESPACE_END(detail) +- +-template +-tuple make_tuple() { return tuple(0); } +- +-template tuple make_tuple(Args&&... args_) { +- constexpr size_t size = sizeof...(Args); +- std::array args { +- { reinterpret_steal(detail::make_caster::cast( +- std::forward(args_), policy, nullptr))... } +- }; +- for (size_t i = 0; i < args.size(); i++) { +- if (!args[i]) { +-#if defined(NDEBUG) +- throw cast_error("make_tuple(): unable to convert arguments to Python object (compile in debug mode for details)"); +-#else +- std::array argtypes { {type_id()...} }; +- throw cast_error("make_tuple(): unable to convert argument of type '" + +- argtypes[i] + "' to Python object"); +-#endif +- } +- } +- tuple result(size); +- int counter = 0; +- for (auto &arg_value : args) +- PyTuple_SET_ITEM(result.ptr(), counter++, arg_value.release().ptr()); +- return result; +-} +- +-/// \ingroup annotations +-/// Annotation for arguments +-struct arg { +- /// Constructs an argument with the name of the argument; if null or omitted, this is a positional argument. +- constexpr explicit arg(const char *name = nullptr) : name(name), flag_noconvert(false), flag_none(true) { } +- /// Assign a value to this argument +- template arg_v operator=(T &&value) const; +- /// Indicate that the type should not be converted in the type caster +- arg &noconvert(bool flag = true) { flag_noconvert = flag; return *this; } +- /// Indicates that the argument should/shouldn't allow None (e.g. for nullable pointer args) +- arg &none(bool flag = true) { flag_none = flag; return *this; } +- +- const char *name; ///< If non-null, this is a named kwargs argument +- bool flag_noconvert : 1; ///< If set, do not allow conversion (requires a supporting type caster!) +- bool flag_none : 1; ///< If set (the default), allow None to be passed to this argument +-}; +- +-/// \ingroup annotations +-/// Annotation for arguments with values +-struct arg_v : arg { +-private: +- template +- arg_v(arg &&base, T &&x, const char *descr = nullptr) +- : arg(base), +- value(reinterpret_steal( +- detail::make_caster::cast(x, return_value_policy::automatic, {}) +- )), +- descr(descr) +-#if !defined(NDEBUG) +- , type(type_id()) +-#endif +- { } +- +-public: +- /// Direct construction with name, default, and description +- template +- arg_v(const char *name, T &&x, const char *descr = nullptr) +- : arg_v(arg(name), std::forward(x), descr) { } +- +- /// Called internally when invoking `py::arg("a") = value` +- template +- arg_v(const arg &base, T &&x, const char *descr = nullptr) +- : arg_v(arg(base), std::forward(x), descr) { } +- +- /// Same as `arg::noconvert()`, but returns *this as arg_v&, not arg& +- arg_v &noconvert(bool flag = true) { arg::noconvert(flag); return *this; } +- +- /// Same as `arg::nonone()`, but returns *this as arg_v&, not arg& +- arg_v &none(bool flag = true) { arg::none(flag); return *this; } +- +- /// The default value +- object value; +- /// The (optional) description of the default value +- const char *descr; +-#if !defined(NDEBUG) +- /// The C++ type name of the default value (only available when compiled in debug mode) +- std::string type; +-#endif +-}; +- +-/// \ingroup annotations +-/// Annotation indicating that all following arguments are keyword-only; the is the equivalent of an +-/// unnamed '*' argument (in Python 3) +-struct kw_only {}; +- +-/// \ingroup annotations +-/// Annotation indicating that all previous arguments are positional-only; the is the equivalent of an +-/// unnamed '/' argument (in Python 3.8) +-struct pos_only {}; +- +-template +-arg_v arg::operator=(T &&value) const { return {std::move(*this), std::forward(value)}; } +- +-/// Alias for backward compatibility -- to be removed in version 2.0 +-template using arg_t = arg_v; +- +-inline namespace literals { +-/** \rst +- String literal version of `arg` +- \endrst */ +-constexpr arg operator"" _a(const char *name, size_t) { return arg(name); } +-} // namespace literals +- +-PYBIND11_NAMESPACE_BEGIN(detail) +- +-// forward declaration (definition in attr.h) +-struct function_record; +- +-/// Internal data associated with a single function call +-struct function_call { +- function_call(const function_record &f, handle p); // Implementation in attr.h +- +- /// The function data: +- const function_record &func; +- +- /// Arguments passed to the function: +- std::vector args; +- +- /// The `convert` value the arguments should be loaded with +- std::vector args_convert; +- +- /// Extra references for the optional `py::args` and/or `py::kwargs` arguments (which, if +- /// present, are also in `args` but without a reference). +- object args_ref, kwargs_ref; +- +- /// The parent, if any +- handle parent; +- +- /// If this is a call to an initializer, this argument contains `self` +- handle init_self; +-}; +- +- +-/// Helper class which loads arguments for C++ functions called from Python +-template +-class argument_loader { +- using indices = make_index_sequence; +- +- template using argument_is_args = std::is_same, args>; +- template using argument_is_kwargs = std::is_same, kwargs>; +- // Get args/kwargs argument positions relative to the end of the argument list: +- static constexpr auto args_pos = constexpr_first() - (int) sizeof...(Args), +- kwargs_pos = constexpr_first() - (int) sizeof...(Args); +- +- static constexpr bool args_kwargs_are_last = kwargs_pos >= - 1 && args_pos >= kwargs_pos - 1; +- +- static_assert(args_kwargs_are_last, "py::args/py::kwargs are only permitted as the last argument(s) of a function"); +- +-public: +- static constexpr bool has_kwargs = kwargs_pos < 0; +- static constexpr bool has_args = args_pos < 0; +- +- static constexpr auto arg_names = concat(type_descr(make_caster::name)...); +- +- bool load_args(function_call &call) { +- return load_impl_sequence(call, indices{}); +- } +- +- template +- enable_if_t::value, Return> call(Func &&f) && { +- return std::move(*this).template call_impl(std::forward(f), indices{}, Guard{}); +- } +- +- template +- enable_if_t::value, void_type> call(Func &&f) && { +- std::move(*this).template call_impl(std::forward(f), indices{}, Guard{}); +- return void_type(); +- } +- +-private: +- +- static bool load_impl_sequence(function_call &, index_sequence<>) { return true; } +- +- template +- bool load_impl_sequence(function_call &call, index_sequence) { +-#ifdef __cpp_fold_expressions +- if ((... || !std::get(argcasters).load(call.args[Is], call.args_convert[Is]))) +- return false; +-#else +- for (bool r : {std::get(argcasters).load(call.args[Is], call.args_convert[Is])...}) +- if (!r) +- return false; +-#endif +- return true; +- } +- +- template +- Return call_impl(Func &&f, index_sequence, Guard &&) && { +- return std::forward(f)(cast_op(std::move(std::get(argcasters)))...); +- } +- +- std::tuple...> argcasters; +-}; +- +-/// Helper class which collects only positional arguments for a Python function call. +-/// A fancier version below can collect any argument, but this one is optimal for simple calls. +-template +-class simple_collector { +-public: +- template +- explicit simple_collector(Ts &&...values) +- : m_args(pybind11::make_tuple(std::forward(values)...)) { } +- +- const tuple &args() const & { return m_args; } +- dict kwargs() const { return {}; } +- +- tuple args() && { return std::move(m_args); } +- +- /// Call a Python function and pass the collected arguments +- object call(PyObject *ptr) const { +- PyObject *result = PyObject_CallObject(ptr, m_args.ptr()); +- if (!result) +- throw error_already_set(); +- return reinterpret_steal(result); +- } +- +-private: +- tuple m_args; +-}; +- +-/// Helper class which collects positional, keyword, * and ** arguments for a Python function call +-template +-class unpacking_collector { +-public: +- template +- explicit unpacking_collector(Ts &&...values) { +- // Tuples aren't (easily) resizable so a list is needed for collection, +- // but the actual function call strictly requires a tuple. +- auto args_list = list(); +- int _[] = { 0, (process(args_list, std::forward(values)), 0)... }; +- ignore_unused(_); +- +- m_args = std::move(args_list); +- } +- +- const tuple &args() const & { return m_args; } +- const dict &kwargs() const & { return m_kwargs; } +- +- tuple args() && { return std::move(m_args); } +- dict kwargs() && { return std::move(m_kwargs); } +- +- /// Call a Python function and pass the collected arguments +- object call(PyObject *ptr) const { +- PyObject *result = PyObject_Call(ptr, m_args.ptr(), m_kwargs.ptr()); +- if (!result) +- throw error_already_set(); +- return reinterpret_steal(result); +- } +- +-private: +- template +- void process(list &args_list, T &&x) { +- auto o = reinterpret_steal(detail::make_caster::cast(std::forward(x), policy, {})); +- if (!o) { +-#if defined(NDEBUG) +- argument_cast_error(); +-#else +- argument_cast_error(std::to_string(args_list.size()), type_id()); +-#endif +- } +- args_list.append(o); +- } +- +- void process(list &args_list, detail::args_proxy ap) { +- for (auto a : ap) +- args_list.append(a); +- } +- +- void process(list &/*args_list*/, arg_v a) { +- if (!a.name) +-#if defined(NDEBUG) +- nameless_argument_error(); +-#else +- nameless_argument_error(a.type); +-#endif +- +- if (m_kwargs.contains(a.name)) { +-#if defined(NDEBUG) +- multiple_values_error(); +-#else +- multiple_values_error(a.name); +-#endif +- } +- if (!a.value) { +-#if defined(NDEBUG) +- argument_cast_error(); +-#else +- argument_cast_error(a.name, a.type); +-#endif +- } +- m_kwargs[a.name] = a.value; +- } +- +- void process(list &/*args_list*/, detail::kwargs_proxy kp) { +- if (!kp) +- return; +- for (auto k : reinterpret_borrow(kp)) { +- if (m_kwargs.contains(k.first)) { +-#if defined(NDEBUG) +- multiple_values_error(); +-#else +- multiple_values_error(str(k.first)); +-#endif +- } +- m_kwargs[k.first] = k.second; +- } +- } +- +- [[noreturn]] static void nameless_argument_error() { +- throw type_error("Got kwargs without a name; only named arguments " +- "may be passed via py::arg() to a python function call. " +- "(compile in debug mode for details)"); +- } +- [[noreturn]] static void nameless_argument_error(std::string type) { +- throw type_error("Got kwargs without a name of type '" + type + "'; only named " +- "arguments may be passed via py::arg() to a python function call. "); +- } +- [[noreturn]] static void multiple_values_error() { +- throw type_error("Got multiple values for keyword argument " +- "(compile in debug mode for details)"); +- } +- +- [[noreturn]] static void multiple_values_error(std::string name) { +- throw type_error("Got multiple values for keyword argument '" + name + "'"); +- } +- +- [[noreturn]] static void argument_cast_error() { +- throw cast_error("Unable to convert call argument to Python object " +- "(compile in debug mode for details)"); +- } +- +- [[noreturn]] static void argument_cast_error(std::string name, std::string type) { +- throw cast_error("Unable to convert call argument '" + name +- + "' of type '" + type + "' to Python object"); +- } +- +-private: +- tuple m_args; +- dict m_kwargs; +-}; +- +-/// Collect only positional arguments for a Python function call +-template ...>::value>> +-simple_collector collect_arguments(Args &&...args) { +- return simple_collector(std::forward(args)...); +-} +- +-/// Collect all arguments, including keywords and unpacking (only instantiated when needed) +-template ...>::value>> +-unpacking_collector collect_arguments(Args &&...args) { +- // Following argument order rules for generalized unpacking according to PEP 448 +- static_assert( +- constexpr_last() < constexpr_first() +- && constexpr_last() < constexpr_first(), +- "Invalid function call: positional args must precede keywords and ** unpacking; " +- "* unpacking must precede ** unpacking" +- ); +- return unpacking_collector(std::forward(args)...); +-} +- +-template +-template +-object object_api::operator()(Args &&...args) const { +- return detail::collect_arguments(std::forward(args)...).call(derived().ptr()); +-} +- +-template +-template +-object object_api::call(Args &&...args) const { +- return operator()(std::forward(args)...); +-} +- +-PYBIND11_NAMESPACE_END(detail) +- +- +-template +-handle type::handle_of() { +- static_assert( +- std::is_base_of>::value, +- "py::type::of only supports the case where T is a registered C++ types." +- ); +- +- return detail::get_type_handle(typeid(T), true); +-} +- +- +-#define PYBIND11_MAKE_OPAQUE(...) \ +- namespace pybind11 { namespace detail { \ +- template<> class type_caster<__VA_ARGS__> : public type_caster_base<__VA_ARGS__> { }; \ +- }} +- +-/// Lets you pass a type containing a `,` through a macro parameter without needing a separate +-/// typedef, e.g.: `PYBIND11_OVERRIDE(PYBIND11_TYPE(ReturnType), PYBIND11_TYPE(Parent), f, arg)` +-#define PYBIND11_TYPE(...) __VA_ARGS__ +- +-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE) +diff --git a/dune/python/pybind11/chrono.h b/dune/python/pybind11/chrono.h +deleted file mode 100644 +index c3681102d..000000000 +--- a/dune/python/pybind11/chrono.h ++++ /dev/null +@@ -1,191 +0,0 @@ +-/* +- pybind11/chrono.h: Transparent conversion between std::chrono and python's datetime +- +- Copyright (c) 2016 Trent Houliston and +- Wenzel Jakob +- +- All rights reserved. Use of this source code is governed by a +- BSD-style license that can be found in the LICENSE file. +-*/ +- +-#pragma once +- +-#include "pybind11.h" +-#include +-#include +-#include +-#include +- +-// Backport the PyDateTime_DELTA functions from Python3.3 if required +-#ifndef PyDateTime_DELTA_GET_DAYS +-#define PyDateTime_DELTA_GET_DAYS(o) (((PyDateTime_Delta*)o)->days) +-#endif +-#ifndef PyDateTime_DELTA_GET_SECONDS +-#define PyDateTime_DELTA_GET_SECONDS(o) (((PyDateTime_Delta*)o)->seconds) +-#endif +-#ifndef PyDateTime_DELTA_GET_MICROSECONDS +-#define PyDateTime_DELTA_GET_MICROSECONDS(o) (((PyDateTime_Delta*)o)->microseconds) +-#endif +- +-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE) +-PYBIND11_NAMESPACE_BEGIN(detail) +- +-template class duration_caster { +-public: +- using rep = typename type::rep; +- using period = typename type::period; +- +- using days = std::chrono::duration>; +- +- bool load(handle src, bool) { +- using namespace std::chrono; +- +- // Lazy initialise the PyDateTime import +- if (!PyDateTimeAPI) { PyDateTime_IMPORT; } +- +- if (!src) return false; +- // If invoked with datetime.delta object +- if (PyDelta_Check(src.ptr())) { +- value = type(duration_cast>( +- days(PyDateTime_DELTA_GET_DAYS(src.ptr())) +- + seconds(PyDateTime_DELTA_GET_SECONDS(src.ptr())) +- + microseconds(PyDateTime_DELTA_GET_MICROSECONDS(src.ptr())))); +- return true; +- } +- // If invoked with a float we assume it is seconds and convert +- else if (PyFloat_Check(src.ptr())) { +- value = type(duration_cast>(duration(PyFloat_AsDouble(src.ptr())))); +- return true; +- } +- else return false; +- } +- +- // If this is a duration just return it back +- static const std::chrono::duration& get_duration(const std::chrono::duration &src) { +- return src; +- } +- +- // If this is a time_point get the time_since_epoch +- template static std::chrono::duration get_duration(const std::chrono::time_point> &src) { +- return src.time_since_epoch(); +- } +- +- static handle cast(const type &src, return_value_policy /* policy */, handle /* parent */) { +- using namespace std::chrono; +- +- // Use overloaded function to get our duration from our source +- // Works out if it is a duration or time_point and get the duration +- auto d = get_duration(src); +- +- // Lazy initialise the PyDateTime import +- if (!PyDateTimeAPI) { PyDateTime_IMPORT; } +- +- // Declare these special duration types so the conversions happen with the correct primitive types (int) +- using dd_t = duration>; +- using ss_t = duration>; +- using us_t = duration; +- +- auto dd = duration_cast(d); +- auto subd = d - dd; +- auto ss = duration_cast(subd); +- auto us = duration_cast(subd - ss); +- return PyDelta_FromDSU(dd.count(), ss.count(), us.count()); +- } +- +- PYBIND11_TYPE_CASTER(type, _("datetime.timedelta")); +-}; +- +-// This is for casting times on the system clock into datetime.datetime instances +-template class type_caster> { +-public: +- using type = std::chrono::time_point; +- bool load(handle src, bool) { +- using namespace std::chrono; +- +- // Lazy initialise the PyDateTime import +- if (!PyDateTimeAPI) { PyDateTime_IMPORT; } +- +- if (!src) return false; +- +- std::tm cal; +- microseconds msecs; +- +- if (PyDateTime_Check(src.ptr())) { +- cal.tm_sec = PyDateTime_DATE_GET_SECOND(src.ptr()); +- cal.tm_min = PyDateTime_DATE_GET_MINUTE(src.ptr()); +- cal.tm_hour = PyDateTime_DATE_GET_HOUR(src.ptr()); +- cal.tm_mday = PyDateTime_GET_DAY(src.ptr()); +- cal.tm_mon = PyDateTime_GET_MONTH(src.ptr()) - 1; +- cal.tm_year = PyDateTime_GET_YEAR(src.ptr()) - 1900; +- cal.tm_isdst = -1; +- msecs = microseconds(PyDateTime_DATE_GET_MICROSECOND(src.ptr())); +- } else if (PyDate_Check(src.ptr())) { +- cal.tm_sec = 0; +- cal.tm_min = 0; +- cal.tm_hour = 0; +- cal.tm_mday = PyDateTime_GET_DAY(src.ptr()); +- cal.tm_mon = PyDateTime_GET_MONTH(src.ptr()) - 1; +- cal.tm_year = PyDateTime_GET_YEAR(src.ptr()) - 1900; +- cal.tm_isdst = -1; +- msecs = microseconds(0); +- } else if (PyTime_Check(src.ptr())) { +- cal.tm_sec = PyDateTime_TIME_GET_SECOND(src.ptr()); +- cal.tm_min = PyDateTime_TIME_GET_MINUTE(src.ptr()); +- cal.tm_hour = PyDateTime_TIME_GET_HOUR(src.ptr()); +- cal.tm_mday = 1; // This date (day, month, year) = (1, 0, 70) +- cal.tm_mon = 0; // represents 1-Jan-1970, which is the first +- cal.tm_year = 70; // earliest available date for Python's datetime +- cal.tm_isdst = -1; +- msecs = microseconds(PyDateTime_TIME_GET_MICROSECOND(src.ptr())); +- } +- else return false; +- +- value = time_point_cast(system_clock::from_time_t(std::mktime(&cal)) + msecs); +- return true; +- } +- +- static handle cast(const std::chrono::time_point &src, return_value_policy /* policy */, handle /* parent */) { +- using namespace std::chrono; +- +- // Lazy initialise the PyDateTime import +- if (!PyDateTimeAPI) { PyDateTime_IMPORT; } +- +- // Get out microseconds, and make sure they are positive, to avoid bug in eastern hemisphere time zones +- // (cfr. https://github.com/pybind/pybind11/issues/2417) +- using us_t = duration; +- auto us = duration_cast(src.time_since_epoch() % seconds(1)); +- if (us.count() < 0) +- us += seconds(1); +- +- // Subtract microseconds BEFORE `system_clock::to_time_t`, because: +- // > If std::time_t has lower precision, it is implementation-defined whether the value is rounded or truncated. +- // (https://en.cppreference.com/w/cpp/chrono/system_clock/to_time_t) +- std::time_t tt = system_clock::to_time_t(time_point_cast(src - us)); +- // this function uses static memory so it's best to copy it out asap just in case +- // otherwise other code that is using localtime may break this (not just python code) +- std::tm localtime = *std::localtime(&tt); +- +- return PyDateTime_FromDateAndTime(localtime.tm_year + 1900, +- localtime.tm_mon + 1, +- localtime.tm_mday, +- localtime.tm_hour, +- localtime.tm_min, +- localtime.tm_sec, +- us.count()); +- } +- PYBIND11_TYPE_CASTER(type, _("datetime.datetime")); +-}; +- +-// Other clocks that are not the system clock are not measured as datetime.datetime objects +-// since they are not measured on calendar time. So instead we just make them timedeltas +-// Or if they have passed us a time as a float we convert that +-template class type_caster> +-: public duration_caster> { +-}; +- +-template class type_caster> +-: public duration_caster> { +-}; +- +-PYBIND11_NAMESPACE_END(detail) +-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE) +diff --git a/dune/python/pybind11/common.h b/dune/python/pybind11/common.h +deleted file mode 100644 +index 6c8a4f1e8..000000000 +--- a/dune/python/pybind11/common.h ++++ /dev/null +@@ -1,2 +0,0 @@ +-#include "detail/common.h" +-#warning "Including 'common.h' is deprecated. It will be removed in v3.0. Use 'pybind11.h'." +diff --git a/dune/python/pybind11/complex.h b/dune/python/pybind11/complex.h +deleted file mode 100644 +index f8327eb37..000000000 +--- a/dune/python/pybind11/complex.h ++++ /dev/null +@@ -1,65 +0,0 @@ +-/* +- pybind11/complex.h: Complex number support +- +- Copyright (c) 2016 Wenzel Jakob +- +- All rights reserved. Use of this source code is governed by a +- BSD-style license that can be found in the LICENSE file. +-*/ +- +-#pragma once +- +-#include "pybind11.h" +-#include +- +-/// glibc defines I as a macro which breaks things, e.g., boost template names +-#ifdef I +-# undef I +-#endif +- +-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE) +- +-template struct format_descriptor, detail::enable_if_t::value>> { +- static constexpr const char c = format_descriptor::c; +- static constexpr const char value[3] = { 'Z', c, '\0' }; +- static std::string format() { return std::string(value); } +-}; +- +-#ifndef PYBIND11_CPP17 +- +-template constexpr const char format_descriptor< +- std::complex, detail::enable_if_t::value>>::value[3]; +- +-#endif +- +-PYBIND11_NAMESPACE_BEGIN(detail) +- +-template struct is_fmt_numeric, detail::enable_if_t::value>> { +- static constexpr bool value = true; +- static constexpr int index = is_fmt_numeric::index + 3; +-}; +- +-template class type_caster> { +-public: +- bool load(handle src, bool convert) { +- if (!src) +- return false; +- if (!convert && !PyComplex_Check(src.ptr())) +- return false; +- Py_complex result = PyComplex_AsCComplex(src.ptr()); +- if (result.real == -1.0 && PyErr_Occurred()) { +- PyErr_Clear(); +- return false; +- } +- value = std::complex((T) result.real, (T) result.imag); +- return true; +- } +- +- static handle cast(const std::complex &src, return_value_policy /* policy */, handle /* parent */) { +- return PyComplex_FromDoubles((double) src.real(), (double) src.imag()); +- } +- +- PYBIND11_TYPE_CASTER(std::complex, _("complex")); +-}; +-PYBIND11_NAMESPACE_END(detail) +-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE) +diff --git a/dune/python/pybind11/detail/CMakeLists.txt b/dune/python/pybind11/detail/CMakeLists.txt +deleted file mode 100644 +index eb1359f76..000000000 +--- a/dune/python/pybind11/detail/CMakeLists.txt ++++ /dev/null +@@ -1,10 +0,0 @@ +-SET(HEADERS +- class.h +- common.h +- descr.h +- init.h +- internals.h +- typeid.h +-) +- +-install(FILES ${HEADERS} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dune/python/pybind11/detail) +diff --git a/dune/python/pybind11/detail/class.h b/dune/python/pybind11/detail/class.h +deleted file mode 100644 +index 65dad5a57..000000000 +--- a/dune/python/pybind11/detail/class.h ++++ /dev/null +@@ -1,710 +0,0 @@ +-/* +- pybind11/detail/class.h: Python C API implementation details for py::class_ +- +- Copyright (c) 2017 Wenzel Jakob +- +- All rights reserved. Use of this source code is governed by a +- BSD-style license that can be found in the LICENSE file. +-*/ +- +-#pragma once +- +-#include "../attr.h" +-#include "../options.h" +- +-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE) +-PYBIND11_NAMESPACE_BEGIN(detail) +- +-#if PY_VERSION_HEX >= 0x03030000 && !defined(PYPY_VERSION) +-# define PYBIND11_BUILTIN_QUALNAME +-# define PYBIND11_SET_OLDPY_QUALNAME(obj, nameobj) +-#else +-// In pre-3.3 Python, we still set __qualname__ so that we can produce reliable function type +-// signatures; in 3.3+ this macro expands to nothing: +-# define PYBIND11_SET_OLDPY_QUALNAME(obj, nameobj) setattr((PyObject *) obj, "__qualname__", nameobj) +-#endif +- +-inline std::string get_fully_qualified_tp_name(PyTypeObject *type) { +-#if !defined(PYPY_VERSION) +- return type->tp_name; +-#else +- auto module_name = handle((PyObject *) type).attr("__module__").cast(); +- if (module_name == PYBIND11_BUILTINS_MODULE) +- return type->tp_name; +- else +- return std::move(module_name) + "." + type->tp_name; +-#endif +-} +- +-inline PyTypeObject *type_incref(PyTypeObject *type) { +- Py_INCREF(type); +- return type; +-} +- +-#if !defined(PYPY_VERSION) +- +-/// `pybind11_static_property.__get__()`: Always pass the class instead of the instance. +-extern "C" inline PyObject *pybind11_static_get(PyObject *self, PyObject * /*ob*/, PyObject *cls) { +- return PyProperty_Type.tp_descr_get(self, cls, cls); +-} +- +-/// `pybind11_static_property.__set__()`: Just like the above `__get__()`. +-extern "C" inline int pybind11_static_set(PyObject *self, PyObject *obj, PyObject *value) { +- PyObject *cls = PyType_Check(obj) ? obj : (PyObject *) Py_TYPE(obj); +- return PyProperty_Type.tp_descr_set(self, cls, value); +-} +- +-/** A `static_property` is the same as a `property` but the `__get__()` and `__set__()` +- methods are modified to always use the object type instead of a concrete instance. +- Return value: New reference. */ +-inline PyTypeObject *make_static_property_type() { +- constexpr auto *name = "pybind11_static_property"; +- auto name_obj = reinterpret_steal(PYBIND11_FROM_STRING(name)); +- +- /* Danger zone: from now (and until PyType_Ready), make sure to +- issue no Python C API calls which could potentially invoke the +- garbage collector (the GC will call type_traverse(), which will in +- turn find the newly constructed type in an invalid state) */ +- auto heap_type = (PyHeapTypeObject *) PyType_Type.tp_alloc(&PyType_Type, 0); +- if (!heap_type) +- pybind11_fail("make_static_property_type(): error allocating type!"); +- +- heap_type->ht_name = name_obj.inc_ref().ptr(); +-#ifdef PYBIND11_BUILTIN_QUALNAME +- heap_type->ht_qualname = name_obj.inc_ref().ptr(); +-#endif +- +- auto type = &heap_type->ht_type; +- type->tp_name = name; +- type->tp_base = type_incref(&PyProperty_Type); +- type->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HEAPTYPE; +- type->tp_descr_get = pybind11_static_get; +- type->tp_descr_set = pybind11_static_set; +- +- if (PyType_Ready(type) < 0) +- pybind11_fail("make_static_property_type(): failure in PyType_Ready()!"); +- +- setattr((PyObject *) type, "__module__", str("pybind11_builtins")); +- PYBIND11_SET_OLDPY_QUALNAME(type, name_obj); +- +- return type; +-} +- +-#else // PYPY +- +-/** PyPy has some issues with the above C API, so we evaluate Python code instead. +- This function will only be called once so performance isn't really a concern. +- Return value: New reference. */ +-inline PyTypeObject *make_static_property_type() { +- auto d = dict(); +- PyObject *result = PyRun_String(R"(\ +- class pybind11_static_property(property): +- def __get__(self, obj, cls): +- return property.__get__(self, cls, cls) +- +- def __set__(self, obj, value): +- cls = obj if isinstance(obj, type) else type(obj) +- property.__set__(self, cls, value) +- )", Py_file_input, d.ptr(), d.ptr() +- ); +- if (result == nullptr) +- throw error_already_set(); +- Py_DECREF(result); +- return (PyTypeObject *) d["pybind11_static_property"].cast().release().ptr(); +-} +- +-#endif // PYPY +- +-/** Types with static properties need to handle `Type.static_prop = x` in a specific way. +- By default, Python replaces the `static_property` itself, but for wrapped C++ types +- we need to call `static_property.__set__()` in order to propagate the new value to +- the underlying C++ data structure. */ +-extern "C" inline int pybind11_meta_setattro(PyObject* obj, PyObject* name, PyObject* value) { +- // Use `_PyType_Lookup()` instead of `PyObject_GetAttr()` in order to get the raw +- // descriptor (`property`) instead of calling `tp_descr_get` (`property.__get__()`). +- PyObject *descr = _PyType_Lookup((PyTypeObject *) obj, name); +- +- // The following assignment combinations are possible: +- // 1. `Type.static_prop = value` --> descr_set: `Type.static_prop.__set__(value)` +- // 2. `Type.static_prop = other_static_prop` --> setattro: replace existing `static_prop` +- // 3. `Type.regular_attribute = value` --> setattro: regular attribute assignment +- const auto static_prop = (PyObject *) get_internals().static_property_type; +- const auto call_descr_set = descr && value && PyObject_IsInstance(descr, static_prop) +- && !PyObject_IsInstance(value, static_prop); +- if (call_descr_set) { +- // Call `static_property.__set__()` instead of replacing the `static_property`. +-#if !defined(PYPY_VERSION) +- return Py_TYPE(descr)->tp_descr_set(descr, obj, value); +-#else +- if (PyObject *result = PyObject_CallMethod(descr, "__set__", "OO", obj, value)) { +- Py_DECREF(result); +- return 0; +- } else { +- return -1; +- } +-#endif +- } else { +- // Replace existing attribute. +- return PyType_Type.tp_setattro(obj, name, value); +- } +-} +- +-#if PY_MAJOR_VERSION >= 3 +-/** +- * Python 3's PyInstanceMethod_Type hides itself via its tp_descr_get, which prevents aliasing +- * methods via cls.attr("m2") = cls.attr("m1"): instead the tp_descr_get returns a plain function, +- * when called on a class, or a PyMethod, when called on an instance. Override that behaviour here +- * to do a special case bypass for PyInstanceMethod_Types. +- */ +-extern "C" inline PyObject *pybind11_meta_getattro(PyObject *obj, PyObject *name) { +- PyObject *descr = _PyType_Lookup((PyTypeObject *) obj, name); +- if (descr && PyInstanceMethod_Check(descr)) { +- Py_INCREF(descr); +- return descr; +- } +- else { +- return PyType_Type.tp_getattro(obj, name); +- } +-} +-#endif +- +-/// metaclass `__call__` function that is used to create all pybind11 objects. +-extern "C" inline PyObject *pybind11_meta_call(PyObject *type, PyObject *args, PyObject *kwargs) { +- +- // use the default metaclass call to create/initialize the object +- PyObject *self = PyType_Type.tp_call(type, args, kwargs); +- if (self == nullptr) { +- return nullptr; +- } +- +- // This must be a pybind11 instance +- auto instance = reinterpret_cast(self); +- +- // Ensure that the base __init__ function(s) were called +- for (const auto &vh : values_and_holders(instance)) { +- if (!vh.holder_constructed()) { +- PyErr_Format(PyExc_TypeError, "%.200s.__init__() must be called when overriding __init__", +- get_fully_qualified_tp_name(vh.type->type).c_str()); +- Py_DECREF(self); +- return nullptr; +- } +- } +- +- return self; +-} +- +-/// Cleanup the type-info for a pybind11-registered type. +-extern "C" inline void pybind11_meta_dealloc(PyObject *obj) { +- auto *type = (PyTypeObject *) obj; +- auto &internals = get_internals(); +- +- // A pybind11-registered type will: +- // 1) be found in internals.registered_types_py +- // 2) have exactly one associated `detail::type_info` +- auto found_type = internals.registered_types_py.find(type); +- if (found_type != internals.registered_types_py.end() && +- found_type->second.size() == 1 && +- found_type->second[0]->type == type) { +- +- auto *tinfo = found_type->second[0]; +- auto tindex = std::type_index(*tinfo->cpptype); +- internals.direct_conversions.erase(tindex); +- +- if (tinfo->module_local) +- registered_local_types_cpp().erase(tindex); +- else +- internals.registered_types_cpp.erase(tindex); +- internals.registered_types_py.erase(tinfo->type); +- +- // Actually just `std::erase_if`, but that's only available in C++20 +- auto &cache = internals.inactive_override_cache; +- for (auto it = cache.begin(), last = cache.end(); it != last; ) { +- if (it->first == (PyObject *) tinfo->type) +- it = cache.erase(it); +- else +- ++it; +- } +- +- delete tinfo; +- } +- +- PyType_Type.tp_dealloc(obj); +-} +- +-/** This metaclass is assigned by default to all pybind11 types and is required in order +- for static properties to function correctly. Users may override this using `py::metaclass`. +- Return value: New reference. */ +-inline PyTypeObject* make_default_metaclass() { +- constexpr auto *name = "pybind11_type"; +- auto name_obj = reinterpret_steal(PYBIND11_FROM_STRING(name)); +- +- /* Danger zone: from now (and until PyType_Ready), make sure to +- issue no Python C API calls which could potentially invoke the +- garbage collector (the GC will call type_traverse(), which will in +- turn find the newly constructed type in an invalid state) */ +- auto heap_type = (PyHeapTypeObject *) PyType_Type.tp_alloc(&PyType_Type, 0); +- if (!heap_type) +- pybind11_fail("make_default_metaclass(): error allocating metaclass!"); +- +- heap_type->ht_name = name_obj.inc_ref().ptr(); +-#ifdef PYBIND11_BUILTIN_QUALNAME +- heap_type->ht_qualname = name_obj.inc_ref().ptr(); +-#endif +- +- auto type = &heap_type->ht_type; +- type->tp_name = name; +- type->tp_base = type_incref(&PyType_Type); +- type->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HEAPTYPE; +- +- type->tp_call = pybind11_meta_call; +- +- type->tp_setattro = pybind11_meta_setattro; +-#if PY_MAJOR_VERSION >= 3 +- type->tp_getattro = pybind11_meta_getattro; +-#endif +- +- type->tp_dealloc = pybind11_meta_dealloc; +- +- if (PyType_Ready(type) < 0) +- pybind11_fail("make_default_metaclass(): failure in PyType_Ready()!"); +- +- setattr((PyObject *) type, "__module__", str("pybind11_builtins")); +- PYBIND11_SET_OLDPY_QUALNAME(type, name_obj); +- +- return type; +-} +- +-/// For multiple inheritance types we need to recursively register/deregister base pointers for any +-/// base classes with pointers that are difference from the instance value pointer so that we can +-/// correctly recognize an offset base class pointer. This calls a function with any offset base ptrs. +-inline void traverse_offset_bases(void *valueptr, const detail::type_info *tinfo, instance *self, +- bool (*f)(void * /*parentptr*/, instance * /*self*/)) { +- for (handle h : reinterpret_borrow(tinfo->type->tp_bases)) { +- if (auto parent_tinfo = get_type_info((PyTypeObject *) h.ptr())) { +- for (auto &c : parent_tinfo->implicit_casts) { +- if (c.first == tinfo->cpptype) { +- auto *parentptr = c.second(valueptr); +- if (parentptr != valueptr) +- f(parentptr, self); +- traverse_offset_bases(parentptr, parent_tinfo, self, f); +- break; +- } +- } +- } +- } +-} +- +-inline bool register_instance_impl(void *ptr, instance *self) { +- get_internals().registered_instances.emplace(ptr, self); +- return true; // unused, but gives the same signature as the deregister func +-} +-inline bool deregister_instance_impl(void *ptr, instance *self) { +- auto ®istered_instances = get_internals().registered_instances; +- auto range = registered_instances.equal_range(ptr); +- for (auto it = range.first; it != range.second; ++it) { +- if (self == it->second) { +- registered_instances.erase(it); +- return true; +- } +- } +- return false; +-} +- +-inline void register_instance(instance *self, void *valptr, const type_info *tinfo) { +- register_instance_impl(valptr, self); +- if (!tinfo->simple_ancestors) +- traverse_offset_bases(valptr, tinfo, self, register_instance_impl); +-} +- +-inline bool deregister_instance(instance *self, void *valptr, const type_info *tinfo) { +- bool ret = deregister_instance_impl(valptr, self); +- if (!tinfo->simple_ancestors) +- traverse_offset_bases(valptr, tinfo, self, deregister_instance_impl); +- return ret; +-} +- +-/// Instance creation function for all pybind11 types. It allocates the internal instance layout for +-/// holding C++ objects and holders. Allocation is done lazily (the first time the instance is cast +-/// to a reference or pointer), and initialization is done by an `__init__` function. +-inline PyObject *make_new_instance(PyTypeObject *type) { +-#if defined(PYPY_VERSION) +- // PyPy gets tp_basicsize wrong (issue 2482) under multiple inheritance when the first inherited +- // object is a a plain Python type (i.e. not derived from an extension type). Fix it. +- ssize_t instance_size = static_cast(sizeof(instance)); +- if (type->tp_basicsize < instance_size) { +- type->tp_basicsize = instance_size; +- } +-#endif +- PyObject *self = type->tp_alloc(type, 0); +- auto inst = reinterpret_cast(self); +- // Allocate the value/holder internals: +- inst->allocate_layout(); +- +- inst->owned = true; +- +- return self; +-} +- +-/// Instance creation function for all pybind11 types. It only allocates space for the +-/// C++ object, but doesn't call the constructor -- an `__init__` function must do that. +-extern "C" inline PyObject *pybind11_object_new(PyTypeObject *type, PyObject *, PyObject *) { +- return make_new_instance(type); +-} +- +-/// An `__init__` function constructs the C++ object. Users should provide at least one +-/// of these using `py::init` or directly with `.def(__init__, ...)`. Otherwise, the +-/// following default function will be used which simply throws an exception. +-extern "C" inline int pybind11_object_init(PyObject *self, PyObject *, PyObject *) { +- PyTypeObject *type = Py_TYPE(self); +- std::string msg = get_fully_qualified_tp_name(type) + ": No constructor defined!"; +- PyErr_SetString(PyExc_TypeError, msg.c_str()); +- return -1; +-} +- +-inline void add_patient(PyObject *nurse, PyObject *patient) { +- auto &internals = get_internals(); +- auto instance = reinterpret_cast(nurse); +- instance->has_patients = true; +- Py_INCREF(patient); +- internals.patients[nurse].push_back(patient); +-} +- +-inline void clear_patients(PyObject *self) { +- auto instance = reinterpret_cast(self); +- auto &internals = get_internals(); +- auto pos = internals.patients.find(self); +- assert(pos != internals.patients.end()); +- // Clearing the patients can cause more Python code to run, which +- // can invalidate the iterator. Extract the vector of patients +- // from the unordered_map first. +- auto patients = std::move(pos->second); +- internals.patients.erase(pos); +- instance->has_patients = false; +- for (PyObject *&patient : patients) +- Py_CLEAR(patient); +-} +- +-/// Clears all internal data from the instance and removes it from registered instances in +-/// preparation for deallocation. +-inline void clear_instance(PyObject *self) { +- auto instance = reinterpret_cast(self); +- +- // Deallocate any values/holders, if present: +- for (auto &v_h : values_and_holders(instance)) { +- if (v_h) { +- +- // We have to deregister before we call dealloc because, for virtual MI types, we still +- // need to be able to get the parent pointers. +- if (v_h.instance_registered() && !deregister_instance(instance, v_h.value_ptr(), v_h.type)) +- pybind11_fail("pybind11_object_dealloc(): Tried to deallocate unregistered instance!"); +- +- if (instance->owned || v_h.holder_constructed()) +- v_h.type->dealloc(v_h); +- } +- } +- // Deallocate the value/holder layout internals: +- instance->deallocate_layout(); +- +- if (instance->weakrefs) +- PyObject_ClearWeakRefs(self); +- +- PyObject **dict_ptr = _PyObject_GetDictPtr(self); +- if (dict_ptr) +- Py_CLEAR(*dict_ptr); +- +- if (instance->has_patients) +- clear_patients(self); +-} +- +-/// Instance destructor function for all pybind11 types. It calls `type_info.dealloc` +-/// to destroy the C++ object itself, while the rest is Python bookkeeping. +-extern "C" inline void pybind11_object_dealloc(PyObject *self) { +- clear_instance(self); +- +- auto type = Py_TYPE(self); +- type->tp_free(self); +- +-#if PY_VERSION_HEX < 0x03080000 +- // `type->tp_dealloc != pybind11_object_dealloc` means that we're being called +- // as part of a derived type's dealloc, in which case we're not allowed to decref +- // the type here. For cross-module compatibility, we shouldn't compare directly +- // with `pybind11_object_dealloc`, but with the common one stashed in internals. +- auto pybind11_object_type = (PyTypeObject *) get_internals().instance_base; +- if (type->tp_dealloc == pybind11_object_type->tp_dealloc) +- Py_DECREF(type); +-#else +- // This was not needed before Python 3.8 (Python issue 35810) +- // https://github.com/pybind/pybind11/issues/1946 +- Py_DECREF(type); +-#endif +-} +- +-/** Create the type which can be used as a common base for all classes. This is +- needed in order to satisfy Python's requirements for multiple inheritance. +- Return value: New reference. */ +-inline PyObject *make_object_base_type(PyTypeObject *metaclass) { +- constexpr auto *name = "pybind11_object"; +- auto name_obj = reinterpret_steal(PYBIND11_FROM_STRING(name)); +- +- /* Danger zone: from now (and until PyType_Ready), make sure to +- issue no Python C API calls which could potentially invoke the +- garbage collector (the GC will call type_traverse(), which will in +- turn find the newly constructed type in an invalid state) */ +- auto heap_type = (PyHeapTypeObject *) metaclass->tp_alloc(metaclass, 0); +- if (!heap_type) +- pybind11_fail("make_object_base_type(): error allocating type!"); +- +- heap_type->ht_name = name_obj.inc_ref().ptr(); +-#ifdef PYBIND11_BUILTIN_QUALNAME +- heap_type->ht_qualname = name_obj.inc_ref().ptr(); +-#endif +- +- auto type = &heap_type->ht_type; +- type->tp_name = name; +- type->tp_base = type_incref(&PyBaseObject_Type); +- type->tp_basicsize = static_cast(sizeof(instance)); +- type->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HEAPTYPE; +- +- type->tp_new = pybind11_object_new; +- type->tp_init = pybind11_object_init; +- type->tp_dealloc = pybind11_object_dealloc; +- +- /* Support weak references (needed for the keep_alive feature) */ +- type->tp_weaklistoffset = offsetof(instance, weakrefs); +- +- if (PyType_Ready(type) < 0) +- pybind11_fail("PyType_Ready failed in make_object_base_type():" + error_string()); +- +- setattr((PyObject *) type, "__module__", str("pybind11_builtins")); +- PYBIND11_SET_OLDPY_QUALNAME(type, name_obj); +- +- assert(!PyType_HasFeature(type, Py_TPFLAGS_HAVE_GC)); +- return (PyObject *) heap_type; +-} +- +-/// dynamic_attr: Support for `d = instance.__dict__`. +-extern "C" inline PyObject *pybind11_get_dict(PyObject *self, void *) { +- PyObject *&dict = *_PyObject_GetDictPtr(self); +- if (!dict) +- dict = PyDict_New(); +- Py_XINCREF(dict); +- return dict; +-} +- +-/// dynamic_attr: Support for `instance.__dict__ = dict()`. +-extern "C" inline int pybind11_set_dict(PyObject *self, PyObject *new_dict, void *) { +- if (!PyDict_Check(new_dict)) { +- PyErr_Format(PyExc_TypeError, "__dict__ must be set to a dictionary, not a '%.200s'", +- get_fully_qualified_tp_name(Py_TYPE(new_dict)).c_str()); +- return -1; +- } +- PyObject *&dict = *_PyObject_GetDictPtr(self); +- Py_INCREF(new_dict); +- Py_CLEAR(dict); +- dict = new_dict; +- return 0; +-} +- +-/// dynamic_attr: Allow the garbage collector to traverse the internal instance `__dict__`. +-extern "C" inline int pybind11_traverse(PyObject *self, visitproc visit, void *arg) { +- PyObject *&dict = *_PyObject_GetDictPtr(self); +- Py_VISIT(dict); +- return 0; +-} +- +-/// dynamic_attr: Allow the GC to clear the dictionary. +-extern "C" inline int pybind11_clear(PyObject *self) { +- PyObject *&dict = *_PyObject_GetDictPtr(self); +- Py_CLEAR(dict); +- return 0; +-} +- +-/// Give instances of this type a `__dict__` and opt into garbage collection. +-inline void enable_dynamic_attributes(PyHeapTypeObject *heap_type) { +- auto type = &heap_type->ht_type; +- type->tp_flags |= Py_TPFLAGS_HAVE_GC; +- type->tp_dictoffset = type->tp_basicsize; // place dict at the end +- type->tp_basicsize += (ssize_t)sizeof(PyObject *); // and allocate enough space for it +- type->tp_traverse = pybind11_traverse; +- type->tp_clear = pybind11_clear; +- +- static PyGetSetDef getset[] = { +- {const_cast("__dict__"), pybind11_get_dict, pybind11_set_dict, nullptr, nullptr}, +- {nullptr, nullptr, nullptr, nullptr, nullptr} +- }; +- type->tp_getset = getset; +-} +- +-/// buffer_protocol: Fill in the view as specified by flags. +-extern "C" inline int pybind11_getbuffer(PyObject *obj, Py_buffer *view, int flags) { +- // Look for a `get_buffer` implementation in this type's info or any bases (following MRO). +- type_info *tinfo = nullptr; +- for (auto type : reinterpret_borrow(Py_TYPE(obj)->tp_mro)) { +- tinfo = get_type_info((PyTypeObject *) type.ptr()); +- if (tinfo && tinfo->get_buffer) +- break; +- } +- if (view == nullptr || !tinfo || !tinfo->get_buffer) { +- if (view) +- view->obj = nullptr; +- PyErr_SetString(PyExc_BufferError, "pybind11_getbuffer(): Internal error"); +- return -1; +- } +- std::memset(view, 0, sizeof(Py_buffer)); +- buffer_info *info = tinfo->get_buffer(obj, tinfo->get_buffer_data); +- view->obj = obj; +- view->ndim = 1; +- view->internal = info; +- view->buf = info->ptr; +- view->itemsize = info->itemsize; +- view->len = view->itemsize; +- for (auto s : info->shape) +- view->len *= s; +- view->readonly = info->readonly; +- if ((flags & PyBUF_WRITABLE) == PyBUF_WRITABLE && info->readonly) { +- if (view) +- view->obj = nullptr; +- PyErr_SetString(PyExc_BufferError, "Writable buffer requested for readonly storage"); +- return -1; +- } +- if ((flags & PyBUF_FORMAT) == PyBUF_FORMAT) +- view->format = const_cast(info->format.c_str()); +- if ((flags & PyBUF_STRIDES) == PyBUF_STRIDES) { +- view->ndim = (int) info->ndim; +- view->strides = &info->strides[0]; +- view->shape = &info->shape[0]; +- } +- Py_INCREF(view->obj); +- return 0; +-} +- +-/// buffer_protocol: Release the resources of the buffer. +-extern "C" inline void pybind11_releasebuffer(PyObject *, Py_buffer *view) { +- delete (buffer_info *) view->internal; +-} +- +-/// Give this type a buffer interface. +-inline void enable_buffer_protocol(PyHeapTypeObject *heap_type) { +- heap_type->ht_type.tp_as_buffer = &heap_type->as_buffer; +-#if PY_MAJOR_VERSION < 3 +- heap_type->ht_type.tp_flags |= Py_TPFLAGS_HAVE_NEWBUFFER; +-#endif +- +- heap_type->as_buffer.bf_getbuffer = pybind11_getbuffer; +- heap_type->as_buffer.bf_releasebuffer = pybind11_releasebuffer; +-} +- +-/** Create a brand new Python type according to the `type_record` specification. +- Return value: New reference. */ +-inline PyObject* make_new_python_type(const type_record &rec) { +- auto name = reinterpret_steal(PYBIND11_FROM_STRING(rec.name)); +- +- auto qualname = name; +- if (rec.scope && !PyModule_Check(rec.scope.ptr()) && hasattr(rec.scope, "__qualname__")) { +-#if PY_MAJOR_VERSION >= 3 +- qualname = reinterpret_steal( +- PyUnicode_FromFormat("%U.%U", rec.scope.attr("__qualname__").ptr(), name.ptr())); +-#else +- qualname = str(rec.scope.attr("__qualname__").cast() + "." + rec.name); +-#endif +- } +- +- object module_; +- if (rec.scope) { +- if (hasattr(rec.scope, "__module__")) +- module_ = rec.scope.attr("__module__"); +- else if (hasattr(rec.scope, "__name__")) +- module_ = rec.scope.attr("__name__"); +- } +- +- auto full_name = c_str( +-#if !defined(PYPY_VERSION) +- module_ ? str(module_).cast() + "." + rec.name : +-#endif +- rec.name); +- +- char *tp_doc = nullptr; +- if (rec.doc && options::show_user_defined_docstrings()) { +- /* Allocate memory for docstring (using PyObject_MALLOC, since +- Python will free this later on) */ +- size_t size = strlen(rec.doc) + 1; +- tp_doc = (char *) PyObject_MALLOC(size); +- memcpy((void *) tp_doc, rec.doc, size); +- } +- +- auto &internals = get_internals(); +- auto bases = tuple(rec.bases); +- auto base = (bases.empty()) ? internals.instance_base +- : bases[0].ptr(); +- +- /* Danger zone: from now (and until PyType_Ready), make sure to +- issue no Python C API calls which could potentially invoke the +- garbage collector (the GC will call type_traverse(), which will in +- turn find the newly constructed type in an invalid state) */ +- auto metaclass = rec.metaclass.ptr() ? (PyTypeObject *) rec.metaclass.ptr() +- : internals.default_metaclass; +- +- auto heap_type = (PyHeapTypeObject *) metaclass->tp_alloc(metaclass, 0); +- if (!heap_type) +- pybind11_fail(std::string(rec.name) + ": Unable to create type object!"); +- +- heap_type->ht_name = name.release().ptr(); +-#ifdef PYBIND11_BUILTIN_QUALNAME +- heap_type->ht_qualname = qualname.inc_ref().ptr(); +-#endif +- +- auto type = &heap_type->ht_type; +- type->tp_name = full_name; +- type->tp_doc = tp_doc; +- type->tp_base = type_incref((PyTypeObject *)base); +- type->tp_basicsize = static_cast(sizeof(instance)); +- if (!bases.empty()) +- type->tp_bases = bases.release().ptr(); +- +- /* Don't inherit base __init__ */ +- type->tp_init = pybind11_object_init; +- +- /* Supported protocols */ +- type->tp_as_number = &heap_type->as_number; +- type->tp_as_sequence = &heap_type->as_sequence; +- type->tp_as_mapping = &heap_type->as_mapping; +-#if PY_VERSION_HEX >= 0x03050000 +- type->tp_as_async = &heap_type->as_async; +-#endif +- +- /* Flags */ +- type->tp_flags |= Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HEAPTYPE; +-#if PY_MAJOR_VERSION < 3 +- type->tp_flags |= Py_TPFLAGS_CHECKTYPES; +-#endif +- if (!rec.is_final) +- type->tp_flags |= Py_TPFLAGS_BASETYPE; +- +- if (rec.dynamic_attr) +- enable_dynamic_attributes(heap_type); +- +- if (rec.buffer_protocol) +- enable_buffer_protocol(heap_type); +- +- if (PyType_Ready(type) < 0) +- pybind11_fail(std::string(rec.name) + ": PyType_Ready failed (" + error_string() + ")!"); +- +- assert(rec.dynamic_attr ? PyType_HasFeature(type, Py_TPFLAGS_HAVE_GC) +- : !PyType_HasFeature(type, Py_TPFLAGS_HAVE_GC)); +- +- /* Register type with the parent scope */ +- if (rec.scope) +- setattr(rec.scope, rec.name, (PyObject *) type); +- else +- Py_INCREF(type); // Keep it alive forever (reference leak) +- +- if (module_) // Needed by pydoc +- setattr((PyObject *) type, "__module__", module_); +- +- PYBIND11_SET_OLDPY_QUALNAME(type, qualname); +- +- return (PyObject *) type; +-} +- +-PYBIND11_NAMESPACE_END(detail) +-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE) +diff --git a/dune/python/pybind11/detail/common.h b/dune/python/pybind11/detail/common.h +deleted file mode 100644 +index 751141a92..000000000 +--- a/dune/python/pybind11/detail/common.h ++++ /dev/null +@@ -1,853 +0,0 @@ +-/* +- pybind11/detail/common.h -- Basic macros +- +- Copyright (c) 2016 Wenzel Jakob +- +- All rights reserved. Use of this source code is governed by a +- BSD-style license that can be found in the LICENSE file. +-*/ +- +-#pragma once +- +-#define PYBIND11_VERSION_MAJOR 2 +-#define PYBIND11_VERSION_MINOR 6 +-#define PYBIND11_VERSION_PATCH 1 +- +-#define PYBIND11_NAMESPACE_BEGIN(name) namespace name { +-#define PYBIND11_NAMESPACE_END(name) } +- +-// Robust support for some features and loading modules compiled against different pybind versions +-// requires forcing hidden visibility on pybind code, so we enforce this by setting the attribute on +-// the main `pybind11` namespace. +-#if !defined(PYBIND11_NAMESPACE) +-# ifdef __GNUG__ +-# define PYBIND11_NAMESPACE pybind11 __attribute__((visibility("hidden"))) +-# else +-# define PYBIND11_NAMESPACE pybind11 +-# endif +-#endif +- +-#if !(defined(_MSC_VER) && __cplusplus == 199711L) && !defined(__INTEL_COMPILER) +-# if __cplusplus >= 201402L +-# define PYBIND11_CPP14 +-# if __cplusplus >= 201703L +-# define PYBIND11_CPP17 +-# endif +-# endif +-#elif defined(_MSC_VER) && __cplusplus == 199711L +-// MSVC sets _MSVC_LANG rather than __cplusplus (supposedly until the standard is fully implemented) +-// Unless you use the /Zc:__cplusplus flag on Visual Studio 2017 15.7 Preview 3 or newer +-# if _MSVC_LANG >= 201402L +-# define PYBIND11_CPP14 +-# if _MSVC_LANG > 201402L && _MSC_VER >= 1910 +-# define PYBIND11_CPP17 +-# endif +-# endif +-#endif +- +-// Compiler version assertions +-#if defined(__INTEL_COMPILER) +-# if __INTEL_COMPILER < 1800 +-# error pybind11 requires Intel C++ compiler v18 or newer +-# endif +-#elif defined(__clang__) && !defined(__apple_build_version__) +-# if __clang_major__ < 3 || (__clang_major__ == 3 && __clang_minor__ < 3) +-# error pybind11 requires clang 3.3 or newer +-# endif +-#elif defined(__clang__) +-// Apple changes clang version macros to its Xcode version; the first Xcode release based on +-// (upstream) clang 3.3 was Xcode 5: +-# if __clang_major__ < 5 +-# error pybind11 requires Xcode/clang 5.0 or newer +-# endif +-#elif defined(__GNUG__) +-# if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 8) +-# error pybind11 requires gcc 4.8 or newer +-# endif +-#elif defined(_MSC_VER) +-// Pybind hits various compiler bugs in 2015u2 and earlier, and also makes use of some stl features +-// (e.g. std::negation) added in 2015u3: +-# if _MSC_FULL_VER < 190024210 +-# error pybind11 requires MSVC 2015 update 3 or newer +-# endif +-#endif +- +-#if !defined(PYBIND11_EXPORT) +-# if defined(WIN32) || defined(_WIN32) +-# define PYBIND11_EXPORT __declspec(dllexport) +-# else +-# define PYBIND11_EXPORT __attribute__ ((visibility("default"))) +-# endif +-#endif +- +-#if defined(_MSC_VER) +-# define PYBIND11_NOINLINE __declspec(noinline) +-#else +-# define PYBIND11_NOINLINE __attribute__ ((noinline)) +-#endif +- +-#if defined(PYBIND11_CPP14) +-# define PYBIND11_DEPRECATED(reason) [[deprecated(reason)]] +-#else +-# define PYBIND11_DEPRECATED(reason) __attribute__((deprecated(reason))) +-#endif +- +-#if defined(PYBIND11_CPP17) +-# define PYBIND11_MAYBE_UNUSED [[maybe_unused]] +-#elif defined(_MSC_VER) && !defined(__clang__) +-# define PYBIND11_MAYBE_UNUSED +-#else +-# define PYBIND11_MAYBE_UNUSED __attribute__ ((__unused__)) +-#endif +- +-/* Don't let Python.h #define (v)snprintf as macro because they are implemented +- properly in Visual Studio since 2015. */ +-#if defined(_MSC_VER) && _MSC_VER >= 1900 +-# define HAVE_SNPRINTF 1 +-#endif +- +-/// Include Python header, disable linking to pythonX_d.lib on Windows in debug mode +-#if defined(_MSC_VER) +-# if (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION < 4) +-# define HAVE_ROUND 1 +-# endif +-# pragma warning(push) +-# pragma warning(disable: 4510 4610 4512 4005) +-# if defined(_DEBUG) && !defined(Py_DEBUG) +-# define PYBIND11_DEBUG_MARKER +-# undef _DEBUG +-# endif +-#endif +- +-#include +-#include +-#include +- +-/* Python #defines overrides on all sorts of core functions, which +- tends to weak havok in C++ codebases that expect these to work +- like regular functions (potentially with several overloads) */ +-#if defined(isalnum) +-# undef isalnum +-# undef isalpha +-# undef islower +-# undef isspace +-# undef isupper +-# undef tolower +-# undef toupper +-#endif +- +-#if defined(copysign) +-# undef copysign +-#endif +- +-#if defined(_MSC_VER) +-# if defined(PYBIND11_DEBUG_MARKER) +-# define _DEBUG +-# undef PYBIND11_DEBUG_MARKER +-# endif +-# pragma warning(pop) +-#endif +- +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +- +-#if PY_MAJOR_VERSION >= 3 /// Compatibility macros for various Python versions +-#define PYBIND11_INSTANCE_METHOD_NEW(ptr, class_) PyInstanceMethod_New(ptr) +-#define PYBIND11_INSTANCE_METHOD_CHECK PyInstanceMethod_Check +-#define PYBIND11_INSTANCE_METHOD_GET_FUNCTION PyInstanceMethod_GET_FUNCTION +-#define PYBIND11_BYTES_CHECK PyBytes_Check +-#define PYBIND11_BYTES_FROM_STRING PyBytes_FromString +-#define PYBIND11_BYTES_FROM_STRING_AND_SIZE PyBytes_FromStringAndSize +-#define PYBIND11_BYTES_AS_STRING_AND_SIZE PyBytes_AsStringAndSize +-#define PYBIND11_BYTES_AS_STRING PyBytes_AsString +-#define PYBIND11_BYTES_SIZE PyBytes_Size +-#define PYBIND11_LONG_CHECK(o) PyLong_Check(o) +-#define PYBIND11_LONG_AS_LONGLONG(o) PyLong_AsLongLong(o) +-#define PYBIND11_LONG_FROM_SIGNED(o) PyLong_FromSsize_t((ssize_t) o) +-#define PYBIND11_LONG_FROM_UNSIGNED(o) PyLong_FromSize_t((size_t) o) +-#define PYBIND11_BYTES_NAME "bytes" +-#define PYBIND11_STRING_NAME "str" +-#define PYBIND11_SLICE_OBJECT PyObject +-#define PYBIND11_FROM_STRING PyUnicode_FromString +-#define PYBIND11_STR_TYPE ::pybind11::str +-#define PYBIND11_BOOL_ATTR "__bool__" +-#define PYBIND11_NB_BOOL(ptr) ((ptr)->nb_bool) +-#define PYBIND11_BUILTINS_MODULE "builtins" +-// Providing a separate declaration to make Clang's -Wmissing-prototypes happy. +-// See comment for PYBIND11_MODULE below for why this is marked "maybe unused". +-#define PYBIND11_PLUGIN_IMPL(name) \ +- extern "C" PYBIND11_MAYBE_UNUSED PYBIND11_EXPORT PyObject *PyInit_##name(); \ +- extern "C" PYBIND11_EXPORT PyObject *PyInit_##name() +- +-#else +-#define PYBIND11_INSTANCE_METHOD_NEW(ptr, class_) PyMethod_New(ptr, nullptr, class_) +-#define PYBIND11_INSTANCE_METHOD_CHECK PyMethod_Check +-#define PYBIND11_INSTANCE_METHOD_GET_FUNCTION PyMethod_GET_FUNCTION +-#define PYBIND11_BYTES_CHECK PyString_Check +-#define PYBIND11_BYTES_FROM_STRING PyString_FromString +-#define PYBIND11_BYTES_FROM_STRING_AND_SIZE PyString_FromStringAndSize +-#define PYBIND11_BYTES_AS_STRING_AND_SIZE PyString_AsStringAndSize +-#define PYBIND11_BYTES_AS_STRING PyString_AsString +-#define PYBIND11_BYTES_SIZE PyString_Size +-#define PYBIND11_LONG_CHECK(o) (PyInt_Check(o) || PyLong_Check(o)) +-#define PYBIND11_LONG_AS_LONGLONG(o) (PyInt_Check(o) ? (long long) PyLong_AsLong(o) : PyLong_AsLongLong(o)) +-#define PYBIND11_LONG_FROM_SIGNED(o) PyInt_FromSsize_t((ssize_t) o) // Returns long if needed. +-#define PYBIND11_LONG_FROM_UNSIGNED(o) PyInt_FromSize_t((size_t) o) // Returns long if needed. +-#define PYBIND11_BYTES_NAME "str" +-#define PYBIND11_STRING_NAME "unicode" +-#define PYBIND11_SLICE_OBJECT PySliceObject +-#define PYBIND11_FROM_STRING PyString_FromString +-#define PYBIND11_STR_TYPE ::pybind11::bytes +-#define PYBIND11_BOOL_ATTR "__nonzero__" +-#define PYBIND11_NB_BOOL(ptr) ((ptr)->nb_nonzero) +-#define PYBIND11_BUILTINS_MODULE "__builtin__" +-// Providing a separate PyInit decl to make Clang's -Wmissing-prototypes happy. +-// See comment for PYBIND11_MODULE below for why this is marked "maybe unused". +-#define PYBIND11_PLUGIN_IMPL(name) \ +- static PyObject *pybind11_init_wrapper(); \ +- extern "C" PYBIND11_MAYBE_UNUSED PYBIND11_EXPORT void init##name(); \ +- extern "C" PYBIND11_EXPORT void init##name() { \ +- (void)pybind11_init_wrapper(); \ +- } \ +- PyObject *pybind11_init_wrapper() +-#endif +- +-#if PY_VERSION_HEX >= 0x03050000 && PY_VERSION_HEX < 0x03050200 +-extern "C" { +- struct _Py_atomic_address { void *value; }; +- PyAPI_DATA(_Py_atomic_address) _PyThreadState_Current; +-} +-#endif +- +-#define PYBIND11_TRY_NEXT_OVERLOAD ((PyObject *) 1) // special failure return code +-#define PYBIND11_STRINGIFY(x) #x +-#define PYBIND11_TOSTRING(x) PYBIND11_STRINGIFY(x) +-#define PYBIND11_CONCAT(first, second) first##second +-#define PYBIND11_ENSURE_INTERNALS_READY \ +- pybind11::detail::get_internals(); +- +-#define PYBIND11_CHECK_PYTHON_VERSION \ +- { \ +- const char *compiled_ver = PYBIND11_TOSTRING(PY_MAJOR_VERSION) \ +- "." PYBIND11_TOSTRING(PY_MINOR_VERSION); \ +- const char *runtime_ver = Py_GetVersion(); \ +- size_t len = std::strlen(compiled_ver); \ +- if (std::strncmp(runtime_ver, compiled_ver, len) != 0 \ +- || (runtime_ver[len] >= '0' && runtime_ver[len] <= '9')) { \ +- PyErr_Format(PyExc_ImportError, \ +- "Python version mismatch: module was compiled for Python %s, " \ +- "but the interpreter version is incompatible: %s.", \ +- compiled_ver, runtime_ver); \ +- return nullptr; \ +- } \ +- } +- +-#define PYBIND11_CATCH_INIT_EXCEPTIONS \ +- catch (pybind11::error_already_set &e) { \ +- PyErr_SetString(PyExc_ImportError, e.what()); \ +- return nullptr; \ +- } catch (const std::exception &e) { \ +- PyErr_SetString(PyExc_ImportError, e.what()); \ +- return nullptr; \ +- } \ +- +-/** \rst +- ***Deprecated in favor of PYBIND11_MODULE*** +- +- This macro creates the entry point that will be invoked when the Python interpreter +- imports a plugin library. Please create a `module_` in the function body and return +- the pointer to its underlying Python object at the end. +- +- .. code-block:: cpp +- +- PYBIND11_PLUGIN(example) { +- pybind11::module_ m("example", "pybind11 example plugin"); +- /// Set up bindings here +- return m.ptr(); +- } +-\endrst */ +-#define PYBIND11_PLUGIN(name) \ +- PYBIND11_DEPRECATED("PYBIND11_PLUGIN is deprecated, use PYBIND11_MODULE") \ +- static PyObject *pybind11_init(); \ +- PYBIND11_PLUGIN_IMPL(name) { \ +- PYBIND11_CHECK_PYTHON_VERSION \ +- PYBIND11_ENSURE_INTERNALS_READY \ +- try { \ +- return pybind11_init(); \ +- } PYBIND11_CATCH_INIT_EXCEPTIONS \ +- } \ +- PyObject *pybind11_init() +- +-/** \rst +- This macro creates the entry point that will be invoked when the Python interpreter +- imports an extension module. The module name is given as the fist argument and it +- should not be in quotes. The second macro argument defines a variable of type +- `py::module_` which can be used to initialize the module. +- +- The entry point is marked as "maybe unused" to aid dead-code detection analysis: +- since the entry point is typically only looked up at runtime and not referenced +- during translation, it would otherwise appear as unused ("dead") code. +- +- .. code-block:: cpp +- +- PYBIND11_MODULE(example, m) { +- m.doc() = "pybind11 example module"; +- +- // Add bindings here +- m.def("foo", []() { +- return "Hello, World!"; +- }); +- } +-\endrst */ +-#define PYBIND11_MODULE(name, variable) \ +- static ::pybind11::module_::module_def \ +- PYBIND11_CONCAT(pybind11_module_def_, name) PYBIND11_MAYBE_UNUSED; \ +- PYBIND11_MAYBE_UNUSED \ +- static void PYBIND11_CONCAT(pybind11_init_, name)(::pybind11::module_ &); \ +- PYBIND11_PLUGIN_IMPL(name) { \ +- PYBIND11_CHECK_PYTHON_VERSION \ +- PYBIND11_ENSURE_INTERNALS_READY \ +- auto m = ::pybind11::module_::create_extension_module( \ +- PYBIND11_TOSTRING(name), nullptr, \ +- &PYBIND11_CONCAT(pybind11_module_def_, name)); \ +- try { \ +- PYBIND11_CONCAT(pybind11_init_, name)(m); \ +- return m.ptr(); \ +- } PYBIND11_CATCH_INIT_EXCEPTIONS \ +- } \ +- void PYBIND11_CONCAT(pybind11_init_, name)(::pybind11::module_ &variable) +- +- +-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE) +- +-using ssize_t = Py_ssize_t; +-using size_t = std::size_t; +- +-/// Approach used to cast a previously unknown C++ instance into a Python object +-enum class return_value_policy : uint8_t { +- /** This is the default return value policy, which falls back to the policy +- return_value_policy::take_ownership when the return value is a pointer. +- Otherwise, it uses return_value::move or return_value::copy for rvalue +- and lvalue references, respectively. See below for a description of what +- all of these different policies do. */ +- automatic = 0, +- +- /** As above, but use policy return_value_policy::reference when the return +- value is a pointer. This is the default conversion policy for function +- arguments when calling Python functions manually from C++ code (i.e. via +- handle::operator()). You probably won't need to use this. */ +- automatic_reference, +- +- /** Reference an existing object (i.e. do not create a new copy) and take +- ownership. Python will call the destructor and delete operator when the +- object’s reference count reaches zero. Undefined behavior ensues when +- the C++ side does the same.. */ +- take_ownership, +- +- /** Create a new copy of the returned object, which will be owned by +- Python. This policy is comparably safe because the lifetimes of the two +- instances are decoupled. */ +- copy, +- +- /** Use std::move to move the return value contents into a new instance +- that will be owned by Python. This policy is comparably safe because the +- lifetimes of the two instances (move source and destination) are +- decoupled. */ +- move, +- +- /** Reference an existing object, but do not take ownership. The C++ side +- is responsible for managing the object’s lifetime and deallocating it +- when it is no longer used. Warning: undefined behavior will ensue when +- the C++ side deletes an object that is still referenced and used by +- Python. */ +- reference, +- +- /** This policy only applies to methods and properties. It references the +- object without taking ownership similar to the above +- return_value_policy::reference policy. In contrast to that policy, the +- function or property’s implicit this argument (called the parent) is +- considered to be the the owner of the return value (the child). +- pybind11 then couples the lifetime of the parent to the child via a +- reference relationship that ensures that the parent cannot be garbage +- collected while Python is still using the child. More advanced +- variations of this scheme are also possible using combinations of +- return_value_policy::reference and the keep_alive call policy */ +- reference_internal +-}; +- +-PYBIND11_NAMESPACE_BEGIN(detail) +- +-inline static constexpr int log2(size_t n, int k = 0) { return (n <= 1) ? k : log2(n >> 1, k + 1); } +- +-// Returns the size as a multiple of sizeof(void *), rounded up. +-inline static constexpr size_t size_in_ptrs(size_t s) { return 1 + ((s - 1) >> log2(sizeof(void *))); } +- +-/** +- * The space to allocate for simple layout instance holders (see below) in multiple of the size of +- * a pointer (e.g. 2 means 16 bytes on 64-bit architectures). The default is the minimum required +- * to holder either a std::unique_ptr or std::shared_ptr (which is almost always +- * sizeof(std::shared_ptr)). +- */ +-constexpr size_t instance_simple_holder_in_ptrs() { +- static_assert(sizeof(std::shared_ptr) >= sizeof(std::unique_ptr), +- "pybind assumes std::shared_ptrs are at least as big as std::unique_ptrs"); +- return size_in_ptrs(sizeof(std::shared_ptr)); +-} +- +-// Forward declarations +-struct type_info; +-struct value_and_holder; +- +-struct nonsimple_values_and_holders { +- void **values_and_holders; +- uint8_t *status; +-}; +- +-/// The 'instance' type which needs to be standard layout (need to be able to use 'offsetof') +-struct instance { +- PyObject_HEAD +- /// Storage for pointers and holder; see simple_layout, below, for a description +- union { +- void *simple_value_holder[1 + instance_simple_holder_in_ptrs()]; +- nonsimple_values_and_holders nonsimple; +- }; +- /// Weak references +- PyObject *weakrefs; +- /// If true, the pointer is owned which means we're free to manage it with a holder. +- bool owned : 1; +- /** +- * An instance has two possible value/holder layouts. +- * +- * Simple layout (when this flag is true), means the `simple_value_holder` is set with a pointer +- * and the holder object governing that pointer, i.e. [val1*][holder]. This layout is applied +- * whenever there is no python-side multiple inheritance of bound C++ types *and* the type's +- * holder will fit in the default space (which is large enough to hold either a std::unique_ptr +- * or std::shared_ptr). +- * +- * Non-simple layout applies when using custom holders that require more space than `shared_ptr` +- * (which is typically the size of two pointers), or when multiple inheritance is used on the +- * python side. Non-simple layout allocates the required amount of memory to have multiple +- * bound C++ classes as parents. Under this layout, `nonsimple.values_and_holders` is set to a +- * pointer to allocated space of the required space to hold a sequence of value pointers and +- * holders followed `status`, a set of bit flags (1 byte each), i.e. +- * [val1*][holder1][val2*][holder2]...[bb...] where each [block] is rounded up to a multiple of +- * `sizeof(void *)`. `nonsimple.status` is, for convenience, a pointer to the +- * beginning of the [bb...] block (but not independently allocated). +- * +- * Status bits indicate whether the associated holder is constructed (& +- * status_holder_constructed) and whether the value pointer is registered (& +- * status_instance_registered) in `registered_instances`. +- */ +- bool simple_layout : 1; +- /// For simple layout, tracks whether the holder has been constructed +- bool simple_holder_constructed : 1; +- /// For simple layout, tracks whether the instance is registered in `registered_instances` +- bool simple_instance_registered : 1; +- /// If true, get_internals().patients has an entry for this object +- bool has_patients : 1; +- +- /// Initializes all of the above type/values/holders data (but not the instance values themselves) +- void allocate_layout(); +- +- /// Destroys/deallocates all of the above +- void deallocate_layout(); +- +- /// Returns the value_and_holder wrapper for the given type (or the first, if `find_type` +- /// omitted). Returns a default-constructed (with `.inst = nullptr`) object on failure if +- /// `throw_if_missing` is false. +- value_and_holder get_value_and_holder(const type_info *find_type = nullptr, bool throw_if_missing = true); +- +- /// Bit values for the non-simple status flags +- static constexpr uint8_t status_holder_constructed = 1; +- static constexpr uint8_t status_instance_registered = 2; +-}; +- +-static_assert(std::is_standard_layout::value, "Internal error: `pybind11::detail::instance` is not standard layout!"); +- +-/// from __cpp_future__ import (convenient aliases from C++14/17) +-#if defined(PYBIND11_CPP14) && (!defined(_MSC_VER) || _MSC_VER >= 1910) +-using std::enable_if_t; +-using std::conditional_t; +-using std::remove_cv_t; +-using std::remove_reference_t; +-#else +-template using enable_if_t = typename std::enable_if::type; +-template using conditional_t = typename std::conditional::type; +-template using remove_cv_t = typename std::remove_cv::type; +-template using remove_reference_t = typename std::remove_reference::type; +-#endif +- +-/// Index sequences +-#if defined(PYBIND11_CPP14) +-using std::index_sequence; +-using std::make_index_sequence; +-#else +-template struct index_sequence { }; +-template struct make_index_sequence_impl : make_index_sequence_impl { }; +-template struct make_index_sequence_impl <0, S...> { using type = index_sequence; }; +-template using make_index_sequence = typename make_index_sequence_impl::type; +-#endif +- +-/// Make an index sequence of the indices of true arguments +-template struct select_indices_impl { using type = ISeq; }; +-template struct select_indices_impl, I, B, Bs...> +- : select_indices_impl, index_sequence>, I + 1, Bs...> {}; +-template using select_indices = typename select_indices_impl, 0, Bs...>::type; +- +-/// Backports of std::bool_constant and std::negation to accommodate older compilers +-template using bool_constant = std::integral_constant; +-template struct negation : bool_constant { }; +- +-// PGI/Intel cannot detect operator delete with the "compatible" void_t impl, so +-// using the new one (C++14 defect, so generally works on newer compilers, even +-// if not in C++17 mode) +-#if defined(__PGIC__) || defined(__INTEL_COMPILER) +-template using void_t = void; +-#else +-template struct void_t_impl { using type = void; }; +-template using void_t = typename void_t_impl::type; +-#endif +- +- +-/// Compile-time all/any/none of that check the boolean value of all template types +-#if defined(__cpp_fold_expressions) && !(defined(_MSC_VER) && (_MSC_VER < 1916)) +-template using all_of = bool_constant<(Ts::value && ...)>; +-template using any_of = bool_constant<(Ts::value || ...)>; +-#elif !defined(_MSC_VER) +-template struct bools {}; +-template using all_of = std::is_same< +- bools, +- bools>; +-template using any_of = negation...>>; +-#else +-// MSVC has trouble with the above, but supports std::conjunction, which we can use instead (albeit +-// at a slight loss of compilation efficiency). +-template using all_of = std::conjunction; +-template using any_of = std::disjunction; +-#endif +-template using none_of = negation>; +- +-template class... Predicates> using satisfies_all_of = all_of...>; +-template class... Predicates> using satisfies_any_of = any_of...>; +-template class... Predicates> using satisfies_none_of = none_of...>; +- +-/// Strip the class from a method type +-template struct remove_class { }; +-template struct remove_class { using type = R (A...); }; +-template struct remove_class { using type = R (A...); }; +- +-/// Helper template to strip away type modifiers +-template struct intrinsic_type { using type = T; }; +-template struct intrinsic_type { using type = typename intrinsic_type::type; }; +-template struct intrinsic_type { using type = typename intrinsic_type::type; }; +-template struct intrinsic_type { using type = typename intrinsic_type::type; }; +-template struct intrinsic_type { using type = typename intrinsic_type::type; }; +-template struct intrinsic_type { using type = typename intrinsic_type::type; }; +-template struct intrinsic_type { using type = typename intrinsic_type::type; }; +-template using intrinsic_t = typename intrinsic_type::type; +- +-/// Helper type to replace 'void' in some expressions +-struct void_type { }; +- +-/// Helper template which holds a list of types +-template struct type_list { }; +- +-/// Compile-time integer sum +-#ifdef __cpp_fold_expressions +-template constexpr size_t constexpr_sum(Ts... ns) { return (0 + ... + size_t{ns}); } +-#else +-constexpr size_t constexpr_sum() { return 0; } +-template +-constexpr size_t constexpr_sum(T n, Ts... ns) { return size_t{n} + constexpr_sum(ns...); } +-#endif +- +-PYBIND11_NAMESPACE_BEGIN(constexpr_impl) +-/// Implementation details for constexpr functions +-constexpr int first(int i) { return i; } +-template +-constexpr int first(int i, T v, Ts... vs) { return v ? i : first(i + 1, vs...); } +- +-constexpr int last(int /*i*/, int result) { return result; } +-template +-constexpr int last(int i, int result, T v, Ts... vs) { return last(i + 1, v ? i : result, vs...); } +-PYBIND11_NAMESPACE_END(constexpr_impl) +- +-/// Return the index of the first type in Ts which satisfies Predicate. Returns sizeof...(Ts) if +-/// none match. +-template class Predicate, typename... Ts> +-constexpr int constexpr_first() { return constexpr_impl::first(0, Predicate::value...); } +- +-/// Return the index of the last type in Ts which satisfies Predicate, or -1 if none match. +-template class Predicate, typename... Ts> +-constexpr int constexpr_last() { return constexpr_impl::last(0, -1, Predicate::value...); } +- +-/// Return the Nth element from the parameter pack +-template +-struct pack_element { using type = typename pack_element::type; }; +-template +-struct pack_element<0, T, Ts...> { using type = T; }; +- +-/// Return the one and only type which matches the predicate, or Default if none match. +-/// If more than one type matches the predicate, fail at compile-time. +-template class Predicate, typename Default, typename... Ts> +-struct exactly_one { +- static constexpr auto found = constexpr_sum(Predicate::value...); +- static_assert(found <= 1, "Found more than one type matching the predicate"); +- +- static constexpr auto index = found ? constexpr_first() : 0; +- using type = conditional_t::type, Default>; +-}; +-template class P, typename Default> +-struct exactly_one { using type = Default; }; +- +-template class Predicate, typename Default, typename... Ts> +-using exactly_one_t = typename exactly_one::type; +- +-/// Defer the evaluation of type T until types Us are instantiated +-template struct deferred_type { using type = T; }; +-template using deferred_t = typename deferred_type::type; +- +-/// Like is_base_of, but requires a strict base (i.e. `is_strict_base_of::value == false`, +-/// unlike `std::is_base_of`) +-template using is_strict_base_of = bool_constant< +- std::is_base_of::value && !std::is_same::value>; +- +-/// Like is_base_of, but also requires that the base type is accessible (i.e. that a Derived pointer +-/// can be converted to a Base pointer) +-/// For unions, `is_base_of::value` is False, so we need to check `is_same` as well. +-template using is_accessible_base_of = bool_constant< +- (std::is_same::value || std::is_base_of::value) && std::is_convertible::value>; +- +-template class Base> +-struct is_template_base_of_impl { +- template static std::true_type check(Base *); +- static std::false_type check(...); +-}; +- +-/// Check if a template is the base of a type. For example: +-/// `is_template_base_of` is true if `struct T : Base {}` where U can be anything +-template class Base, typename T> +-#if !defined(_MSC_VER) +-using is_template_base_of = decltype(is_template_base_of_impl::check((intrinsic_t*)nullptr)); +-#else // MSVC2015 has trouble with decltype in template aliases +-struct is_template_base_of : decltype(is_template_base_of_impl::check((intrinsic_t*)nullptr)) { }; +-#endif +- +-/// Check if T is an instantiation of the template `Class`. For example: +-/// `is_instantiation` is true if `T == shared_ptr` where U can be anything. +-template class Class, typename T> +-struct is_instantiation : std::false_type { }; +-template class Class, typename... Us> +-struct is_instantiation> : std::true_type { }; +- +-/// Check if T is std::shared_ptr where U can be anything +-template using is_shared_ptr = is_instantiation; +- +-/// Check if T looks like an input iterator +-template struct is_input_iterator : std::false_type {}; +-template +-struct is_input_iterator()), decltype(++std::declval())>> +- : std::true_type {}; +- +-template using is_function_pointer = bool_constant< +- std::is_pointer::value && std::is_function::type>::value>; +- +-template struct strip_function_object { +- using type = typename remove_class::type; +-}; +- +-// Extracts the function signature from a function, function pointer or lambda. +-template > +-using function_signature_t = conditional_t< +- std::is_function::value, +- F, +- typename conditional_t< +- std::is_pointer::value || std::is_member_pointer::value, +- std::remove_pointer, +- strip_function_object +- >::type +->; +- +-/// Returns true if the type looks like a lambda: that is, isn't a function, pointer or member +-/// pointer. Note that this can catch all sorts of other things, too; this is intended to be used +-/// in a place where passing a lambda makes sense. +-template using is_lambda = satisfies_none_of, +- std::is_function, std::is_pointer, std::is_member_pointer>; +- +-/// Ignore that a variable is unused in compiler warnings +-inline void ignore_unused(const int *) { } +- +-/// Apply a function over each element of a parameter pack +-#ifdef __cpp_fold_expressions +-#define PYBIND11_EXPAND_SIDE_EFFECTS(PATTERN) (((PATTERN), void()), ...) +-#else +-using expand_side_effects = bool[]; +-#define PYBIND11_EXPAND_SIDE_EFFECTS(PATTERN) (void)pybind11::detail::expand_side_effects{ ((PATTERN), void(), false)..., false } +-#endif +- +-PYBIND11_NAMESPACE_END(detail) +- +-/// C++ bindings of builtin Python exceptions +-class builtin_exception : public std::runtime_error { +-public: +- using std::runtime_error::runtime_error; +- /// Set the error using the Python C API +- virtual void set_error() const = 0; +-}; +- +-#define PYBIND11_RUNTIME_EXCEPTION(name, type) \ +- class name : public builtin_exception { public: \ +- using builtin_exception::builtin_exception; \ +- name() : name("") { } \ +- void set_error() const override { PyErr_SetString(type, what()); } \ +- }; +- +-PYBIND11_RUNTIME_EXCEPTION(stop_iteration, PyExc_StopIteration) +-PYBIND11_RUNTIME_EXCEPTION(index_error, PyExc_IndexError) +-PYBIND11_RUNTIME_EXCEPTION(key_error, PyExc_KeyError) +-PYBIND11_RUNTIME_EXCEPTION(value_error, PyExc_ValueError) +-PYBIND11_RUNTIME_EXCEPTION(type_error, PyExc_TypeError) +-PYBIND11_RUNTIME_EXCEPTION(buffer_error, PyExc_BufferError) +-PYBIND11_RUNTIME_EXCEPTION(import_error, PyExc_ImportError) +-PYBIND11_RUNTIME_EXCEPTION(cast_error, PyExc_RuntimeError) /// Thrown when pybind11::cast or handle::call fail due to a type casting error +-PYBIND11_RUNTIME_EXCEPTION(reference_cast_error, PyExc_RuntimeError) /// Used internally +- +-[[noreturn]] PYBIND11_NOINLINE inline void pybind11_fail(const char *reason) { throw std::runtime_error(reason); } +-[[noreturn]] PYBIND11_NOINLINE inline void pybind11_fail(const std::string &reason) { throw std::runtime_error(reason); } +- +-template struct format_descriptor { }; +- +-PYBIND11_NAMESPACE_BEGIN(detail) +-// Returns the index of the given type in the type char array below, and in the list in numpy.h +-// The order here is: bool; 8 ints ((signed,unsigned)x(8,16,32,64)bits); float,double,long double; +-// complex float,double,long double. Note that the long double types only participate when long +-// double is actually longer than double (it isn't under MSVC). +-// NB: not only the string below but also complex.h and numpy.h rely on this order. +-template struct is_fmt_numeric { static constexpr bool value = false; }; +-template struct is_fmt_numeric::value>> { +- static constexpr bool value = true; +- static constexpr int index = std::is_same::value ? 0 : 1 + ( +- std::is_integral::value ? detail::log2(sizeof(T))*2 + std::is_unsigned::value : 8 + ( +- std::is_same::value ? 1 : std::is_same::value ? 2 : 0)); +-}; +-PYBIND11_NAMESPACE_END(detail) +- +-template struct format_descriptor::value>> { +- static constexpr const char c = "?bBhHiIqQfdg"[detail::is_fmt_numeric::index]; +- static constexpr const char value[2] = { c, '\0' }; +- static std::string format() { return std::string(1, c); } +-}; +- +-#if !defined(PYBIND11_CPP17) +- +-template constexpr const char format_descriptor< +- T, detail::enable_if_t::value>>::value[2]; +- +-#endif +- +-/// RAII wrapper that temporarily clears any Python error state +-struct error_scope { +- PyObject *type, *value, *trace; +- error_scope() { PyErr_Fetch(&type, &value, &trace); } +- ~error_scope() { PyErr_Restore(type, value, trace); } +-}; +- +-/// Dummy destructor wrapper that can be used to expose classes with a private destructor +-struct nodelete { template void operator()(T*) { } }; +- +-PYBIND11_NAMESPACE_BEGIN(detail) +-template +-struct overload_cast_impl { +- constexpr overload_cast_impl() {}; // NOLINT(modernize-use-equals-default): MSVC 2015 needs this +- +- template +- constexpr auto operator()(Return (*pf)(Args...)) const noexcept +- -> decltype(pf) { return pf; } +- +- template +- constexpr auto operator()(Return (Class::*pmf)(Args...), std::false_type = {}) const noexcept +- -> decltype(pmf) { return pmf; } +- +- template +- constexpr auto operator()(Return (Class::*pmf)(Args...) const, std::true_type) const noexcept +- -> decltype(pmf) { return pmf; } +-}; +-PYBIND11_NAMESPACE_END(detail) +- +-// overload_cast requires variable templates: C++14 +-#if defined(PYBIND11_CPP14) +-#define PYBIND11_OVERLOAD_CAST 1 +-/// Syntax sugar for resolving overloaded function pointers: +-/// - regular: static_cast(&Class::func) +-/// - sweet: overload_cast(&Class::func) +-template +-static constexpr detail::overload_cast_impl overload_cast = {}; +-// MSVC 2015 only accepts this particular initialization syntax for this variable template. +-#endif +- +-/// Const member function selector for overload_cast +-/// - regular: static_cast(&Class::func) +-/// - sweet: overload_cast(&Class::func, const_) +-static constexpr auto const_ = std::true_type{}; +- +-#if !defined(PYBIND11_CPP14) // no overload_cast: providing something that static_assert-fails: +-template struct overload_cast { +- static_assert(detail::deferred_t::value, +- "pybind11::overload_cast<...> requires compiling in C++14 mode"); +-}; +-#endif // overload_cast +- +-PYBIND11_NAMESPACE_BEGIN(detail) +- +-// Adaptor for converting arbitrary container arguments into a vector; implicitly convertible from +-// any standard container (or C-style array) supporting std::begin/std::end, any singleton +-// arithmetic type (if T is arithmetic), or explicitly constructible from an iterator pair. +-template +-class any_container { +- std::vector v; +-public: +- any_container() = default; +- +- // Can construct from a pair of iterators +- template ::value>> +- any_container(It first, It last) : v(first, last) { } +- +- // Implicit conversion constructor from any arbitrary container type with values convertible to T +- template ())), T>::value>> +- any_container(const Container &c) : any_container(std::begin(c), std::end(c)) { } +- +- // initializer_list's aren't deducible, so don't get matched by the above template; we need this +- // to explicitly allow implicit conversion from one: +- template ::value>> +- any_container(const std::initializer_list &c) : any_container(c.begin(), c.end()) { } +- +- // Avoid copying if given an rvalue vector of the correct type. +- any_container(std::vector &&v) : v(std::move(v)) { } +- +- // Moves the vector out of an rvalue any_container +- operator std::vector &&() && { return std::move(v); } +- +- // Dereferencing obtains a reference to the underlying vector +- std::vector &operator*() { return v; } +- const std::vector &operator*() const { return v; } +- +- // -> lets you call methods on the underlying vector +- std::vector *operator->() { return &v; } +- const std::vector *operator->() const { return &v; } +-}; +- +-// Forward-declaration; see detail/class.h +-std::string get_fully_qualified_tp_name(PyTypeObject*); +- +-PYBIND11_NAMESPACE_END(detail) +-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE) +diff --git a/dune/python/pybind11/detail/descr.h b/dune/python/pybind11/detail/descr.h +deleted file mode 100644 +index 92720cd56..000000000 +--- a/dune/python/pybind11/detail/descr.h ++++ /dev/null +@@ -1,100 +0,0 @@ +-/* +- pybind11/detail/descr.h: Helper type for concatenating type signatures at compile time +- +- Copyright (c) 2016 Wenzel Jakob +- +- All rights reserved. Use of this source code is governed by a +- BSD-style license that can be found in the LICENSE file. +-*/ +- +-#pragma once +- +-#include "common.h" +- +-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE) +-PYBIND11_NAMESPACE_BEGIN(detail) +- +-#if !defined(_MSC_VER) +-# define PYBIND11_DESCR_CONSTEXPR static constexpr +-#else +-# define PYBIND11_DESCR_CONSTEXPR const +-#endif +- +-/* Concatenate type signatures at compile time */ +-template +-struct descr { +- char text[N + 1]; +- +- constexpr descr() : text{'\0'} { } +- constexpr descr(char const (&s)[N+1]) : descr(s, make_index_sequence()) { } +- +- template +- constexpr descr(char const (&s)[N+1], index_sequence) : text{s[Is]..., '\0'} { } +- +- template +- constexpr descr(char c, Chars... cs) : text{c, static_cast(cs)..., '\0'} { } +- +- static constexpr std::array types() { +- return {{&typeid(Ts)..., nullptr}}; +- } +-}; +- +-template +-constexpr descr plus_impl(const descr &a, const descr &b, +- index_sequence, index_sequence) { +- return {a.text[Is1]..., b.text[Is2]...}; +-} +- +-template +-constexpr descr operator+(const descr &a, const descr &b) { +- return plus_impl(a, b, make_index_sequence(), make_index_sequence()); +-} +- +-template +-constexpr descr _(char const(&text)[N]) { return descr(text); } +-constexpr descr<0> _(char const(&)[1]) { return {}; } +- +-template struct int_to_str : int_to_str { }; +-template struct int_to_str<0, Digits...> { +- static constexpr auto digits = descr(('0' + Digits)...); +-}; +- +-// Ternary description (like std::conditional) +-template +-constexpr enable_if_t> _(char const(&text1)[N1], char const(&)[N2]) { +- return _(text1); +-} +-template +-constexpr enable_if_t> _(char const(&)[N1], char const(&text2)[N2]) { +- return _(text2); +-} +- +-template +-constexpr enable_if_t _(const T1 &d, const T2 &) { return d; } +-template +-constexpr enable_if_t _(const T1 &, const T2 &d) { return d; } +- +-template auto constexpr _() -> decltype(int_to_str::digits) { +- return int_to_str::digits; +-} +- +-template constexpr descr<1, Type> _() { return {'%'}; } +- +-constexpr descr<0> concat() { return {}; } +- +-template +-constexpr descr concat(const descr &descr) { return descr; } +- +-template +-constexpr auto concat(const descr &d, const Args &...args) +- -> decltype(std::declval>() + concat(args...)) { +- return d + _(", ") + concat(args...); +-} +- +-template +-constexpr descr type_descr(const descr &descr) { +- return _("{") + descr + _("}"); +-} +- +-PYBIND11_NAMESPACE_END(detail) +-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE) +diff --git a/dune/python/pybind11/detail/init.h b/dune/python/pybind11/detail/init.h +deleted file mode 100644 +index 3ef78c117..000000000 +--- a/dune/python/pybind11/detail/init.h ++++ /dev/null +@@ -1,336 +0,0 @@ +-/* +- pybind11/detail/init.h: init factory function implementation and support code. +- +- Copyright (c) 2017 Jason Rhinelander +- +- All rights reserved. Use of this source code is governed by a +- BSD-style license that can be found in the LICENSE file. +-*/ +- +-#pragma once +- +-#include "class.h" +- +-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE) +-PYBIND11_NAMESPACE_BEGIN(detail) +- +-template <> +-class type_caster { +-public: +- bool load(handle h, bool) { +- value = reinterpret_cast(h.ptr()); +- return true; +- } +- +- template using cast_op_type = value_and_holder &; +- operator value_and_holder &() { return *value; } +- static constexpr auto name = _(); +- +-private: +- value_and_holder *value = nullptr; +-}; +- +-PYBIND11_NAMESPACE_BEGIN(initimpl) +- +-inline void no_nullptr(void *ptr) { +- if (!ptr) throw type_error("pybind11::init(): factory function returned nullptr"); +-} +- +-// Implementing functions for all forms of py::init<...> and py::init(...) +-template using Cpp = typename Class::type; +-template using Alias = typename Class::type_alias; +-template using Holder = typename Class::holder_type; +- +-template using is_alias_constructible = std::is_constructible, Cpp &&>; +- +-// Takes a Cpp pointer and returns true if it actually is a polymorphic Alias instance. +-template = 0> +-bool is_alias(Cpp *ptr) { +- return dynamic_cast *>(ptr) != nullptr; +-} +-// Failing fallback version of the above for a no-alias class (always returns false) +-template +-constexpr bool is_alias(void *) { return false; } +- +-// Constructs and returns a new object; if the given arguments don't map to a constructor, we fall +-// back to brace aggregate initiailization so that for aggregate initialization can be used with +-// py::init, e.g. `py::init` to initialize a `struct T { int a; int b; }`. For +-// non-aggregate types, we need to use an ordinary T(...) constructor (invoking as `T{...}` usually +-// works, but will not do the expected thing when `T` has an `initializer_list` constructor). +-template ::value, int> = 0> +-inline Class *construct_or_initialize(Args &&...args) { return new Class(std::forward(args)...); } +-template ::value, int> = 0> +-inline Class *construct_or_initialize(Args &&...args) { return new Class{std::forward(args)...}; } +- +-// Attempts to constructs an alias using a `Alias(Cpp &&)` constructor. This allows types with +-// an alias to provide only a single Cpp factory function as long as the Alias can be +-// constructed from an rvalue reference of the base Cpp type. This means that Alias classes +-// can, when appropriate, simply define a `Alias(Cpp &&)` constructor rather than needing to +-// inherit all the base class constructors. +-template +-void construct_alias_from_cpp(std::true_type /*is_alias_constructible*/, +- value_and_holder &v_h, Cpp &&base) { +- v_h.value_ptr() = new Alias(std::move(base)); +-} +-template +-[[noreturn]] void construct_alias_from_cpp(std::false_type /*!is_alias_constructible*/, +- value_and_holder &, Cpp &&) { +- throw type_error("pybind11::init(): unable to convert returned instance to required " +- "alias class: no `Alias(Class &&)` constructor available"); +-} +- +-// Error-generating fallback for factories that don't match one of the below construction +-// mechanisms. +-template +-void construct(...) { +- static_assert(!std::is_same::value /* always false */, +- "pybind11::init(): init function must return a compatible pointer, " +- "holder, or value"); +-} +- +-// Pointer return v1: the factory function returns a class pointer for a registered class. +-// If we don't need an alias (because this class doesn't have one, or because the final type is +-// inherited on the Python side) we can simply take over ownership. Otherwise we need to try to +-// construct an Alias from the returned base instance. +-template +-void construct(value_and_holder &v_h, Cpp *ptr, bool need_alias) { +- no_nullptr(ptr); +- if (Class::has_alias && need_alias && !is_alias(ptr)) { +- // We're going to try to construct an alias by moving the cpp type. Whether or not +- // that succeeds, we still need to destroy the original cpp pointer (either the +- // moved away leftover, if the alias construction works, or the value itself if we +- // throw an error), but we can't just call `delete ptr`: it might have a special +- // deleter, or might be shared_from_this. So we construct a holder around it as if +- // it was a normal instance, then steal the holder away into a local variable; thus +- // the holder and destruction happens when we leave the C++ scope, and the holder +- // class gets to handle the destruction however it likes. +- v_h.value_ptr() = ptr; +- v_h.set_instance_registered(true); // To prevent init_instance from registering it +- v_h.type->init_instance(v_h.inst, nullptr); // Set up the holder +- Holder temp_holder(std::move(v_h.holder>())); // Steal the holder +- v_h.type->dealloc(v_h); // Destroys the moved-out holder remains, resets value ptr to null +- v_h.set_instance_registered(false); +- +- construct_alias_from_cpp(is_alias_constructible{}, v_h, std::move(*ptr)); +- } else { +- // Otherwise the type isn't inherited, so we don't need an Alias +- v_h.value_ptr() = ptr; +- } +-} +- +-// Pointer return v2: a factory that always returns an alias instance ptr. We simply take over +-// ownership of the pointer. +-template = 0> +-void construct(value_and_holder &v_h, Alias *alias_ptr, bool) { +- no_nullptr(alias_ptr); +- v_h.value_ptr() = static_cast *>(alias_ptr); +-} +- +-// Holder return: copy its pointer, and move or copy the returned holder into the new instance's +-// holder. This also handles types like std::shared_ptr and std::unique_ptr where T is a +-// derived type (through those holder's implicit conversion from derived class holder constructors). +-template +-void construct(value_and_holder &v_h, Holder holder, bool need_alias) { +- auto *ptr = holder_helper>::get(holder); +- no_nullptr(ptr); +- // If we need an alias, check that the held pointer is actually an alias instance +- if (Class::has_alias && need_alias && !is_alias(ptr)) +- throw type_error("pybind11::init(): construction failed: returned holder-wrapped instance " +- "is not an alias instance"); +- +- v_h.value_ptr() = ptr; +- v_h.type->init_instance(v_h.inst, &holder); +-} +- +-// return-by-value version 1: returning a cpp class by value. If the class has an alias and an +-// alias is required the alias must have an `Alias(Cpp &&)` constructor so that we can construct +-// the alias from the base when needed (i.e. because of Python-side inheritance). When we don't +-// need it, we simply move-construct the cpp value into a new instance. +-template +-void construct(value_and_holder &v_h, Cpp &&result, bool need_alias) { +- static_assert(std::is_move_constructible>::value, +- "pybind11::init() return-by-value factory function requires a movable class"); +- if (Class::has_alias && need_alias) +- construct_alias_from_cpp(is_alias_constructible{}, v_h, std::move(result)); +- else +- v_h.value_ptr() = new Cpp(std::move(result)); +-} +- +-// return-by-value version 2: returning a value of the alias type itself. We move-construct an +-// Alias instance (even if no the python-side inheritance is involved). The is intended for +-// cases where Alias initialization is always desired. +-template +-void construct(value_and_holder &v_h, Alias &&result, bool) { +- static_assert(std::is_move_constructible>::value, +- "pybind11::init() return-by-alias-value factory function requires a movable alias class"); +- v_h.value_ptr() = new Alias(std::move(result)); +-} +- +-// Implementing class for py::init<...>() +-template +-struct constructor { +- template = 0> +- static void execute(Class &cl, const Extra&... extra) { +- cl.def("__init__", [](value_and_holder &v_h, Args... args) { +- v_h.value_ptr() = construct_or_initialize>(std::forward(args)...); +- }, is_new_style_constructor(), extra...); +- } +- +- template , Args...>::value, int> = 0> +- static void execute(Class &cl, const Extra&... extra) { +- cl.def("__init__", [](value_and_holder &v_h, Args... args) { +- if (Py_TYPE(v_h.inst) == v_h.type->type) +- v_h.value_ptr() = construct_or_initialize>(std::forward(args)...); +- else +- v_h.value_ptr() = construct_or_initialize>(std::forward(args)...); +- }, is_new_style_constructor(), extra...); +- } +- +- template , Args...>::value, int> = 0> +- static void execute(Class &cl, const Extra&... extra) { +- cl.def("__init__", [](value_and_holder &v_h, Args... args) { +- v_h.value_ptr() = construct_or_initialize>(std::forward(args)...); +- }, is_new_style_constructor(), extra...); +- } +-}; +- +-// Implementing class for py::init_alias<...>() +-template struct alias_constructor { +- template , Args...>::value, int> = 0> +- static void execute(Class &cl, const Extra&... extra) { +- cl.def("__init__", [](value_and_holder &v_h, Args... args) { +- v_h.value_ptr() = construct_or_initialize>(std::forward(args)...); +- }, is_new_style_constructor(), extra...); +- } +-}; +- +-// Implementation class for py::init(Func) and py::init(Func, AliasFunc) +-template , typename = function_signature_t> +-struct factory; +- +-// Specialization for py::init(Func) +-template +-struct factory { +- remove_reference_t class_factory; +- +- factory(Func &&f) : class_factory(std::forward(f)) { } +- +- // The given class either has no alias or has no separate alias factory; +- // this always constructs the class itself. If the class is registered with an alias +- // type and an alias instance is needed (i.e. because the final type is a Python class +- // inheriting from the C++ type) the returned value needs to either already be an alias +- // instance, or the alias needs to be constructible from a `Class &&` argument. +- template +- void execute(Class &cl, const Extra &...extra) && { +- #if defined(PYBIND11_CPP14) +- cl.def("__init__", [func = std::move(class_factory)] +- #else +- auto &func = class_factory; +- cl.def("__init__", [func] +- #endif +- (value_and_holder &v_h, Args... args) { +- construct(v_h, func(std::forward(args)...), +- Py_TYPE(v_h.inst) != v_h.type->type); +- }, is_new_style_constructor(), extra...); +- } +-}; +- +-// Specialization for py::init(Func, AliasFunc) +-template +-struct factory { +- static_assert(sizeof...(CArgs) == sizeof...(AArgs), +- "pybind11::init(class_factory, alias_factory): class and alias factories " +- "must have identical argument signatures"); +- static_assert(all_of...>::value, +- "pybind11::init(class_factory, alias_factory): class and alias factories " +- "must have identical argument signatures"); +- +- remove_reference_t class_factory; +- remove_reference_t alias_factory; +- +- factory(CFunc &&c, AFunc &&a) +- : class_factory(std::forward(c)), alias_factory(std::forward(a)) { } +- +- // The class factory is called when the `self` type passed to `__init__` is the direct +- // class (i.e. not inherited), the alias factory when `self` is a Python-side subtype. +- template +- void execute(Class &cl, const Extra&... extra) && { +- static_assert(Class::has_alias, "The two-argument version of `py::init()` can " +- "only be used if the class has an alias"); +- #if defined(PYBIND11_CPP14) +- cl.def("__init__", [class_func = std::move(class_factory), alias_func = std::move(alias_factory)] +- #else +- auto &class_func = class_factory; +- auto &alias_func = alias_factory; +- cl.def("__init__", [class_func, alias_func] +- #endif +- (value_and_holder &v_h, CArgs... args) { +- if (Py_TYPE(v_h.inst) == v_h.type->type) +- // If the instance type equals the registered type we don't have inheritance, so +- // don't need the alias and can construct using the class function: +- construct(v_h, class_func(std::forward(args)...), false); +- else +- construct(v_h, alias_func(std::forward(args)...), true); +- }, is_new_style_constructor(), extra...); +- } +-}; +- +-/// Set just the C++ state. Same as `__init__`. +-template +-void setstate(value_and_holder &v_h, T &&result, bool need_alias) { +- construct(v_h, std::forward(result), need_alias); +-} +- +-/// Set both the C++ and Python states +-template ::value, int> = 0> +-void setstate(value_and_holder &v_h, std::pair &&result, bool need_alias) { +- construct(v_h, std::move(result.first), need_alias); +- setattr((PyObject *) v_h.inst, "__dict__", result.second); +-} +- +-/// Implementation for py::pickle(GetState, SetState) +-template , typename = function_signature_t> +-struct pickle_factory; +- +-template +-struct pickle_factory { +- static_assert(std::is_same, intrinsic_t>::value, +- "The type returned by `__getstate__` must be the same " +- "as the argument accepted by `__setstate__`"); +- +- remove_reference_t get; +- remove_reference_t set; +- +- pickle_factory(Get get, Set set) +- : get(std::forward(get)), set(std::forward(set)) { } +- +- template +- void execute(Class &cl, const Extra &...extra) && { +- cl.def("__getstate__", std::move(get)); +- +-#if defined(PYBIND11_CPP14) +- cl.def("__setstate__", [func = std::move(set)] +-#else +- auto &func = set; +- cl.def("__setstate__", [func] +-#endif +- (value_and_holder &v_h, ArgState state) { +- setstate(v_h, func(std::forward(state)), +- Py_TYPE(v_h.inst) != v_h.type->type); +- }, is_new_style_constructor(), extra...); +- } +-}; +- +-PYBIND11_NAMESPACE_END(initimpl) +-PYBIND11_NAMESPACE_END(detail) +-PYBIND11_NAMESPACE_END(pybind11) +diff --git a/dune/python/pybind11/detail/internals.h b/dune/python/pybind11/detail/internals.h +deleted file mode 100644 +index a455715bf..000000000 +--- a/dune/python/pybind11/detail/internals.h ++++ /dev/null +@@ -1,363 +0,0 @@ +-/* +- pybind11/detail/internals.h: Internal data structure and related functions +- +- Copyright (c) 2017 Wenzel Jakob +- +- All rights reserved. Use of this source code is governed by a +- BSD-style license that can be found in the LICENSE file. +-*/ +- +-#pragma once +- +-#include "../pytypes.h" +- +-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE) +-PYBIND11_NAMESPACE_BEGIN(detail) +-// Forward declarations +-inline PyTypeObject *make_static_property_type(); +-inline PyTypeObject *make_default_metaclass(); +-inline PyObject *make_object_base_type(PyTypeObject *metaclass); +- +-// The old Python Thread Local Storage (TLS) API is deprecated in Python 3.7 in favor of the new +-// Thread Specific Storage (TSS) API. +-#if PY_VERSION_HEX >= 0x03070000 +-# define PYBIND11_TLS_KEY_INIT(var) Py_tss_t *var = nullptr +-# define PYBIND11_TLS_GET_VALUE(key) PyThread_tss_get((key)) +-# define PYBIND11_TLS_REPLACE_VALUE(key, value) PyThread_tss_set((key), (value)) +-# define PYBIND11_TLS_DELETE_VALUE(key) PyThread_tss_set((key), nullptr) +-# define PYBIND11_TLS_FREE(key) PyThread_tss_free(key) +-#else +- // Usually an int but a long on Cygwin64 with Python 3.x +-# define PYBIND11_TLS_KEY_INIT(var) decltype(PyThread_create_key()) var = 0 +-# define PYBIND11_TLS_GET_VALUE(key) PyThread_get_key_value((key)) +-# if PY_MAJOR_VERSION < 3 +-# define PYBIND11_TLS_DELETE_VALUE(key) \ +- PyThread_delete_key_value(key) +-# define PYBIND11_TLS_REPLACE_VALUE(key, value) \ +- do { \ +- PyThread_delete_key_value((key)); \ +- PyThread_set_key_value((key), (value)); \ +- } while (false) +-# else +-# define PYBIND11_TLS_DELETE_VALUE(key) \ +- PyThread_set_key_value((key), nullptr) +-# define PYBIND11_TLS_REPLACE_VALUE(key, value) \ +- PyThread_set_key_value((key), (value)) +-# endif +-# define PYBIND11_TLS_FREE(key) (void)key +-#endif +- +-// Python loads modules by default with dlopen with the RTLD_LOCAL flag; under libc++ and possibly +-// other STLs, this means `typeid(A)` from one module won't equal `typeid(A)` from another module +-// even when `A` is the same, non-hidden-visibility type (e.g. from a common include). Under +-// libstdc++, this doesn't happen: equality and the type_index hash are based on the type name, +-// which works. If not under a known-good stl, provide our own name-based hash and equality +-// functions that use the type name. +-#if defined(__GLIBCXX__) +-inline bool same_type(const std::type_info &lhs, const std::type_info &rhs) { return lhs == rhs; } +-using type_hash = std::hash; +-using type_equal_to = std::equal_to; +-#else +-inline bool same_type(const std::type_info &lhs, const std::type_info &rhs) { +- return lhs.name() == rhs.name() || std::strcmp(lhs.name(), rhs.name()) == 0; +-} +- +-struct type_hash { +- size_t operator()(const std::type_index &t) const { +- size_t hash = 5381; +- const char *ptr = t.name(); +- while (auto c = static_cast(*ptr++)) +- hash = (hash * 33) ^ c; +- return hash; +- } +-}; +- +-struct type_equal_to { +- bool operator()(const std::type_index &lhs, const std::type_index &rhs) const { +- return lhs.name() == rhs.name() || std::strcmp(lhs.name(), rhs.name()) == 0; +- } +-}; +-#endif +- +-template +-using type_map = std::unordered_map; +- +-struct override_hash { +- inline size_t operator()(const std::pair& v) const { +- size_t value = std::hash()(v.first); +- value ^= std::hash()(v.second) + 0x9e3779b9 + (value<<6) + (value>>2); +- return value; +- } +-}; +- +-/// Internal data structure used to track registered instances and types. +-/// Whenever binary incompatible changes are made to this structure, +-/// `PYBIND11_INTERNALS_VERSION` must be incremented. +-struct internals { +- type_map registered_types_cpp; // std::type_index -> pybind11's type information +- std::unordered_map> registered_types_py; // PyTypeObject* -> base type_info(s) +- std::unordered_multimap registered_instances; // void * -> instance* +- std::unordered_set, override_hash> inactive_override_cache; +- type_map> direct_conversions; +- std::unordered_map> patients; +- std::forward_list registered_exception_translators; +- std::unordered_map shared_data; // Custom data to be shared across extensions +- std::vector loader_patient_stack; // Used by `loader_life_support` +- std::forward_list static_strings; // Stores the std::strings backing detail::c_str() +- PyTypeObject *static_property_type; +- PyTypeObject *default_metaclass; +- PyObject *instance_base; +-#if defined(WITH_THREAD) +- PYBIND11_TLS_KEY_INIT(tstate); +- PyInterpreterState *istate = nullptr; +- ~internals() { +- // This destructor is called *after* Py_Finalize() in finalize_interpreter(). +- // That *SHOULD BE* fine. The following details what happens whe PyThread_tss_free is called. +- // PYBIND11_TLS_FREE is PyThread_tss_free on python 3.7+. On older python, it does nothing. +- // PyThread_tss_free calls PyThread_tss_delete and PyMem_RawFree. +- // PyThread_tss_delete just calls TlsFree (on Windows) or pthread_key_delete (on *NIX). Neither +- // of those have anything to do with CPython internals. +- // PyMem_RawFree *requires* that the `tstate` be allocated with the CPython allocator. +- PYBIND11_TLS_FREE(tstate); +- } +-#endif +-}; +- +-/// Additional type information which does not fit into the PyTypeObject. +-/// Changes to this struct also require bumping `PYBIND11_INTERNALS_VERSION`. +-struct type_info { +- PyTypeObject *type; +- const std::type_info *cpptype; +- size_t type_size, type_align, holder_size_in_ptrs; +- void *(*operator_new)(size_t); +- void (*init_instance)(instance *, const void *); +- void (*dealloc)(value_and_holder &v_h); +- std::vector implicit_conversions; +- std::vector> implicit_casts; +- std::vector *direct_conversions; +- buffer_info *(*get_buffer)(PyObject *, void *) = nullptr; +- void *get_buffer_data = nullptr; +- void *(*module_local_load)(PyObject *, const type_info *) = nullptr; +- /* A simple type never occurs as a (direct or indirect) parent +- * of a class that makes use of multiple inheritance */ +- bool simple_type : 1; +- /* True if there is no multiple inheritance in this type's inheritance tree */ +- bool simple_ancestors : 1; +- /* for base vs derived holder_type checks */ +- bool default_holder : 1; +- /* true if this is a type registered with py::module_local */ +- bool module_local : 1; +-}; +- +-/// Tracks the `internals` and `type_info` ABI version independent of the main library version +-#define PYBIND11_INTERNALS_VERSION 4 +- +-/// On MSVC, debug and release builds are not ABI-compatible! +-#if defined(_MSC_VER) && defined(_DEBUG) +-# define PYBIND11_BUILD_TYPE "_debug" +-#else +-# define PYBIND11_BUILD_TYPE "" +-#endif +- +-/// Let's assume that different compilers are ABI-incompatible. +-/// A user can manually set this string if they know their +-/// compiler is compatible. +-#ifndef PYBIND11_COMPILER_TYPE +-# if defined(_MSC_VER) +-# define PYBIND11_COMPILER_TYPE "_msvc" +-# elif defined(__INTEL_COMPILER) +-# define PYBIND11_COMPILER_TYPE "_icc" +-# elif defined(__clang__) +-# define PYBIND11_COMPILER_TYPE "_clang" +-# elif defined(__PGI) +-# define PYBIND11_COMPILER_TYPE "_pgi" +-# elif defined(__MINGW32__) +-# define PYBIND11_COMPILER_TYPE "_mingw" +-# elif defined(__CYGWIN__) +-# define PYBIND11_COMPILER_TYPE "_gcc_cygwin" +-# elif defined(__GNUC__) +-# define PYBIND11_COMPILER_TYPE "_gcc" +-# else +-# define PYBIND11_COMPILER_TYPE "_unknown" +-# endif +-#endif +- +-/// Also standard libs +-#ifndef PYBIND11_STDLIB +-# if defined(_LIBCPP_VERSION) +-# define PYBIND11_STDLIB "_libcpp" +-# elif defined(__GLIBCXX__) || defined(__GLIBCPP__) +-# define PYBIND11_STDLIB "_libstdcpp" +-# else +-# define PYBIND11_STDLIB "" +-# endif +-#endif +- +-/// On Linux/OSX, changes in __GXX_ABI_VERSION__ indicate ABI incompatibility. +-#ifndef PYBIND11_BUILD_ABI +-# if defined(__GXX_ABI_VERSION) +-# define PYBIND11_BUILD_ABI "_cxxabi" PYBIND11_TOSTRING(__GXX_ABI_VERSION) +-# else +-# define PYBIND11_BUILD_ABI "" +-# endif +-#endif +- +-#ifndef PYBIND11_INTERNALS_KIND +-# if defined(WITH_THREAD) +-# define PYBIND11_INTERNALS_KIND "" +-# else +-# define PYBIND11_INTERNALS_KIND "_without_thread" +-# endif +-#endif +- +-#define PYBIND11_INTERNALS_ID "__pybind11_internals_v" \ +- PYBIND11_TOSTRING(PYBIND11_INTERNALS_VERSION) PYBIND11_INTERNALS_KIND PYBIND11_COMPILER_TYPE PYBIND11_STDLIB PYBIND11_BUILD_ABI PYBIND11_BUILD_TYPE "__" +- +-#define PYBIND11_MODULE_LOCAL_ID "__pybind11_module_local_v" \ +- PYBIND11_TOSTRING(PYBIND11_INTERNALS_VERSION) PYBIND11_INTERNALS_KIND PYBIND11_COMPILER_TYPE PYBIND11_STDLIB PYBIND11_BUILD_ABI PYBIND11_BUILD_TYPE "__" +- +-/// Each module locally stores a pointer to the `internals` data. The data +-/// itself is shared among modules with the same `PYBIND11_INTERNALS_ID`. +-inline internals **&get_internals_pp() { +- static internals **internals_pp = nullptr; +- return internals_pp; +-} +- +-inline void translate_exception(std::exception_ptr p) { +- try { +- if (p) std::rethrow_exception(p); +- } catch (error_already_set &e) { e.restore(); return; +- } catch (const builtin_exception &e) { e.set_error(); return; +- } catch (const std::bad_alloc &e) { PyErr_SetString(PyExc_MemoryError, e.what()); return; +- } catch (const std::domain_error &e) { PyErr_SetString(PyExc_ValueError, e.what()); return; +- } catch (const std::invalid_argument &e) { PyErr_SetString(PyExc_ValueError, e.what()); return; +- } catch (const std::length_error &e) { PyErr_SetString(PyExc_ValueError, e.what()); return; +- } catch (const std::out_of_range &e) { PyErr_SetString(PyExc_IndexError, e.what()); return; +- } catch (const std::range_error &e) { PyErr_SetString(PyExc_ValueError, e.what()); return; +- } catch (const std::overflow_error &e) { PyErr_SetString(PyExc_OverflowError, e.what()); return; +- } catch (const std::exception &e) { PyErr_SetString(PyExc_RuntimeError, e.what()); return; +- } catch (...) { +- PyErr_SetString(PyExc_RuntimeError, "Caught an unknown exception!"); +- return; +- } +-} +- +-#if !defined(__GLIBCXX__) +-inline void translate_local_exception(std::exception_ptr p) { +- try { +- if (p) std::rethrow_exception(p); +- } catch (error_already_set &e) { e.restore(); return; +- } catch (const builtin_exception &e) { e.set_error(); return; +- } +-} +-#endif +- +-/// Return a reference to the current `internals` data +-PYBIND11_NOINLINE inline internals &get_internals() { +- auto **&internals_pp = get_internals_pp(); +- if (internals_pp && *internals_pp) +- return **internals_pp; +- +- // Ensure that the GIL is held since we will need to make Python calls. +- // Cannot use py::gil_scoped_acquire here since that constructor calls get_internals. +- struct gil_scoped_acquire_local { +- gil_scoped_acquire_local() : state (PyGILState_Ensure()) {} +- ~gil_scoped_acquire_local() { PyGILState_Release(state); } +- const PyGILState_STATE state; +- } gil; +- +- constexpr auto *id = PYBIND11_INTERNALS_ID; +- auto builtins = handle(PyEval_GetBuiltins()); +- if (builtins.contains(id) && isinstance(builtins[id])) { +- internals_pp = static_cast(capsule(builtins[id])); +- +- // We loaded builtins through python's builtins, which means that our `error_already_set` +- // and `builtin_exception` may be different local classes than the ones set up in the +- // initial exception translator, below, so add another for our local exception classes. +- // +- // libstdc++ doesn't require this (types there are identified only by name) +-#if !defined(__GLIBCXX__) +- (*internals_pp)->registered_exception_translators.push_front(&translate_local_exception); +-#endif +- } else { +- if (!internals_pp) internals_pp = new internals*(); +- auto *&internals_ptr = *internals_pp; +- internals_ptr = new internals(); +-#if defined(WITH_THREAD) +- +- #if PY_VERSION_HEX < 0x03090000 +- PyEval_InitThreads(); +- #endif +- PyThreadState *tstate = PyThreadState_Get(); +- #if PY_VERSION_HEX >= 0x03070000 +- internals_ptr->tstate = PyThread_tss_alloc(); +- if (!internals_ptr->tstate || PyThread_tss_create(internals_ptr->tstate)) +- pybind11_fail("get_internals: could not successfully initialize the TSS key!"); +- PyThread_tss_set(internals_ptr->tstate, tstate); +- #else +- internals_ptr->tstate = PyThread_create_key(); +- if (internals_ptr->tstate == -1) +- pybind11_fail("get_internals: could not successfully initialize the TLS key!"); +- PyThread_set_key_value(internals_ptr->tstate, tstate); +- #endif +- internals_ptr->istate = tstate->interp; +-#endif +- builtins[id] = capsule(internals_pp); +- internals_ptr->registered_exception_translators.push_front(&translate_exception); +- internals_ptr->static_property_type = make_static_property_type(); +- internals_ptr->default_metaclass = make_default_metaclass(); +- internals_ptr->instance_base = make_object_base_type(internals_ptr->default_metaclass); +- } +- return **internals_pp; +-} +- +-/// Works like `internals.registered_types_cpp`, but for module-local registered types: +-inline type_map ®istered_local_types_cpp() { +- static type_map locals{}; +- return locals; +-} +- +-/// Constructs a std::string with the given arguments, stores it in `internals`, and returns its +-/// `c_str()`. Such strings objects have a long storage duration -- the internal strings are only +-/// cleared when the program exits or after interpreter shutdown (when embedding), and so are +-/// suitable for c-style strings needed by Python internals (such as PyTypeObject's tp_name). +-template +-const char *c_str(Args &&...args) { +- auto &strings = get_internals().static_strings; +- strings.emplace_front(std::forward(args)...); +- return strings.front().c_str(); +-} +- +-PYBIND11_NAMESPACE_END(detail) +- +-/// Returns a named pointer that is shared among all extension modules (using the same +-/// pybind11 version) running in the current interpreter. Names starting with underscores +-/// are reserved for internal usage. Returns `nullptr` if no matching entry was found. +-inline PYBIND11_NOINLINE void *get_shared_data(const std::string &name) { +- auto &internals = detail::get_internals(); +- auto it = internals.shared_data.find(name); +- return it != internals.shared_data.end() ? it->second : nullptr; +-} +- +-/// Set the shared data that can be later recovered by `get_shared_data()`. +-inline PYBIND11_NOINLINE void *set_shared_data(const std::string &name, void *data) { +- detail::get_internals().shared_data[name] = data; +- return data; +-} +- +-/// Returns a typed reference to a shared data entry (by using `get_shared_data()`) if +-/// such entry exists. Otherwise, a new object of default-constructible type `T` is +-/// added to the shared data under the given name and a reference to it is returned. +-template +-T &get_or_create_shared_data(const std::string &name) { +- auto &internals = detail::get_internals(); +- auto it = internals.shared_data.find(name); +- T *ptr = (T *) (it != internals.shared_data.end() ? it->second : nullptr); +- if (!ptr) { +- ptr = new T(); +- internals.shared_data[name] = ptr; +- } +- return *ptr; +-} +- +-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE) +diff --git a/dune/python/pybind11/detail/typeid.h b/dune/python/pybind11/detail/typeid.h +deleted file mode 100644 +index 148889ffe..000000000 +--- a/dune/python/pybind11/detail/typeid.h ++++ /dev/null +@@ -1,55 +0,0 @@ +-/* +- pybind11/detail/typeid.h: Compiler-independent access to type identifiers +- +- Copyright (c) 2016 Wenzel Jakob +- +- All rights reserved. Use of this source code is governed by a +- BSD-style license that can be found in the LICENSE file. +-*/ +- +-#pragma once +- +-#include +-#include +- +-#if defined(__GNUG__) +-#include +-#endif +- +-#include "common.h" +- +-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE) +-PYBIND11_NAMESPACE_BEGIN(detail) +-/// Erase all occurrences of a substring +-inline void erase_all(std::string &string, const std::string &search) { +- for (size_t pos = 0;;) { +- pos = string.find(search, pos); +- if (pos == std::string::npos) break; +- string.erase(pos, search.length()); +- } +-} +- +-PYBIND11_NOINLINE inline void clean_type_id(std::string &name) { +-#if defined(__GNUG__) +- int status = 0; +- std::unique_ptr res { +- abi::__cxa_demangle(name.c_str(), nullptr, nullptr, &status), std::free }; +- if (status == 0) +- name = res.get(); +-#else +- detail::erase_all(name, "class "); +- detail::erase_all(name, "struct "); +- detail::erase_all(name, "enum "); +-#endif +- detail::erase_all(name, "pybind11::"); +-} +-PYBIND11_NAMESPACE_END(detail) +- +-/// Return a string representation of a C++ type +-template static std::string type_id() { +- std::string name(typeid(T).name()); +- detail::clean_type_id(name); +- return name; +-} +- +-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE) +diff --git a/dune/python/pybind11/eigen.h b/dune/python/pybind11/eigen.h +deleted file mode 100644 +index e8c6f6339..000000000 +--- a/dune/python/pybind11/eigen.h ++++ /dev/null +@@ -1,607 +0,0 @@ +-/* +- pybind11/eigen.h: Transparent conversion for dense and sparse Eigen matrices +- +- Copyright (c) 2016 Wenzel Jakob +- +- All rights reserved. Use of this source code is governed by a +- BSD-style license that can be found in the LICENSE file. +-*/ +- +-#pragma once +- +-#include "numpy.h" +- +-#if defined(__INTEL_COMPILER) +-# pragma warning(disable: 1682) // implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem) +-#elif defined(__GNUG__) || defined(__clang__) +-# pragma GCC diagnostic push +-# pragma GCC diagnostic ignored "-Wconversion" +-# pragma GCC diagnostic ignored "-Wdeprecated-declarations" +-# ifdef __clang__ +-// Eigen generates a bunch of implicit-copy-constructor-is-deprecated warnings with -Wdeprecated +-// under Clang, so disable that warning here: +-# pragma GCC diagnostic ignored "-Wdeprecated" +-# endif +-# if __GNUC__ >= 7 +-# pragma GCC diagnostic ignored "-Wint-in-bool-context" +-# endif +-#endif +- +-#if defined(_MSC_VER) +-# pragma warning(push) +-# pragma warning(disable: 4127) // warning C4127: Conditional expression is constant +-# pragma warning(disable: 4996) // warning C4996: std::unary_negate is deprecated in C++17 +-#endif +- +-#include +-#include +- +-// Eigen prior to 3.2.7 doesn't have proper move constructors--but worse, some classes get implicit +-// move constructors that break things. We could detect this an explicitly copy, but an extra copy +-// of matrices seems highly undesirable. +-static_assert(EIGEN_VERSION_AT_LEAST(3,2,7), "Eigen support in pybind11 requires Eigen >= 3.2.7"); +- +-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE) +- +-// Provide a convenience alias for easier pass-by-ref usage with fully dynamic strides: +-using EigenDStride = Eigen::Stride; +-template using EigenDRef = Eigen::Ref; +-template using EigenDMap = Eigen::Map; +- +-PYBIND11_NAMESPACE_BEGIN(detail) +- +-#if EIGEN_VERSION_AT_LEAST(3,3,0) +-using EigenIndex = Eigen::Index; +-#else +-using EigenIndex = EIGEN_DEFAULT_DENSE_INDEX_TYPE; +-#endif +- +-// Matches Eigen::Map, Eigen::Ref, blocks, etc: +-template using is_eigen_dense_map = all_of, std::is_base_of, T>>; +-template using is_eigen_mutable_map = std::is_base_of, T>; +-template using is_eigen_dense_plain = all_of>, is_template_base_of>; +-template using is_eigen_sparse = is_template_base_of; +-// Test for objects inheriting from EigenBase that aren't captured by the above. This +-// basically covers anything that can be assigned to a dense matrix but that don't have a typical +-// matrix data layout that can be copied from their .data(). For example, DiagonalMatrix and +-// SelfAdjointView fall into this category. +-template using is_eigen_other = all_of< +- is_template_base_of, +- negation, is_eigen_dense_plain, is_eigen_sparse>> +->; +- +-// Captures numpy/eigen conformability status (returned by EigenProps::conformable()): +-template struct EigenConformable { +- bool conformable = false; +- EigenIndex rows = 0, cols = 0; +- EigenDStride stride{0, 0}; // Only valid if negativestrides is false! +- bool negativestrides = false; // If true, do not use stride! +- +- EigenConformable(bool fits = false) : conformable{fits} {} +- // Matrix type: +- EigenConformable(EigenIndex r, EigenIndex c, +- EigenIndex rstride, EigenIndex cstride) : +- conformable{true}, rows{r}, cols{c} { +- // TODO: when Eigen bug #747 is fixed, remove the tests for non-negativity. http://eigen.tuxfamily.org/bz/show_bug.cgi?id=747 +- if (rstride < 0 || cstride < 0) { +- negativestrides = true; +- } else { +- stride = {EigenRowMajor ? rstride : cstride /* outer stride */, +- EigenRowMajor ? cstride : rstride /* inner stride */ }; +- } +- } +- // Vector type: +- EigenConformable(EigenIndex r, EigenIndex c, EigenIndex stride) +- : EigenConformable(r, c, r == 1 ? c*stride : stride, c == 1 ? r : r*stride) {} +- +- template bool stride_compatible() const { +- // To have compatible strides, we need (on both dimensions) one of fully dynamic strides, +- // matching strides, or a dimension size of 1 (in which case the stride value is irrelevant) +- return +- !negativestrides && +- (props::inner_stride == Eigen::Dynamic || props::inner_stride == stride.inner() || +- (EigenRowMajor ? cols : rows) == 1) && +- (props::outer_stride == Eigen::Dynamic || props::outer_stride == stride.outer() || +- (EigenRowMajor ? rows : cols) == 1); +- } +- operator bool() const { return conformable; } +-}; +- +-template struct eigen_extract_stride { using type = Type; }; +-template +-struct eigen_extract_stride> { using type = StrideType; }; +-template +-struct eigen_extract_stride> { using type = StrideType; }; +- +-// Helper struct for extracting information from an Eigen type +-template struct EigenProps { +- using Type = Type_; +- using Scalar = typename Type::Scalar; +- using StrideType = typename eigen_extract_stride::type; +- static constexpr EigenIndex +- rows = Type::RowsAtCompileTime, +- cols = Type::ColsAtCompileTime, +- size = Type::SizeAtCompileTime; +- static constexpr bool +- row_major = Type::IsRowMajor, +- vector = Type::IsVectorAtCompileTime, // At least one dimension has fixed size 1 +- fixed_rows = rows != Eigen::Dynamic, +- fixed_cols = cols != Eigen::Dynamic, +- fixed = size != Eigen::Dynamic, // Fully-fixed size +- dynamic = !fixed_rows && !fixed_cols; // Fully-dynamic size +- +- template using if_zero = std::integral_constant; +- static constexpr EigenIndex inner_stride = if_zero::value, +- outer_stride = if_zero::value; +- static constexpr bool dynamic_stride = inner_stride == Eigen::Dynamic && outer_stride == Eigen::Dynamic; +- static constexpr bool requires_row_major = !dynamic_stride && !vector && (row_major ? inner_stride : outer_stride) == 1; +- static constexpr bool requires_col_major = !dynamic_stride && !vector && (row_major ? outer_stride : inner_stride) == 1; +- +- // Takes an input array and determines whether we can make it fit into the Eigen type. If +- // the array is a vector, we attempt to fit it into either an Eigen 1xN or Nx1 vector +- // (preferring the latter if it will fit in either, i.e. for a fully dynamic matrix type). +- static EigenConformable conformable(const array &a) { +- const auto dims = a.ndim(); +- if (dims < 1 || dims > 2) +- return false; +- +- if (dims == 2) { // Matrix type: require exact match (or dynamic) +- +- EigenIndex +- np_rows = a.shape(0), +- np_cols = a.shape(1), +- np_rstride = a.strides(0) / static_cast(sizeof(Scalar)), +- np_cstride = a.strides(1) / static_cast(sizeof(Scalar)); +- if ((fixed_rows && np_rows != rows) || (fixed_cols && np_cols != cols)) +- return false; +- +- return {np_rows, np_cols, np_rstride, np_cstride}; +- } +- +- // Otherwise we're storing an n-vector. Only one of the strides will be used, but whichever +- // is used, we want the (single) numpy stride value. +- const EigenIndex n = a.shape(0), +- stride = a.strides(0) / static_cast(sizeof(Scalar)); +- +- if (vector) { // Eigen type is a compile-time vector +- if (fixed && size != n) +- return false; // Vector size mismatch +- return {rows == 1 ? 1 : n, cols == 1 ? 1 : n, stride}; +- } +- else if (fixed) { +- // The type has a fixed size, but is not a vector: abort +- return false; +- } +- else if (fixed_cols) { +- // Since this isn't a vector, cols must be != 1. We allow this only if it exactly +- // equals the number of elements (rows is Dynamic, and so 1 row is allowed). +- if (cols != n) return false; +- return {1, n, stride}; +- } +- else { +- // Otherwise it's either fully dynamic, or column dynamic; both become a column vector +- if (fixed_rows && rows != n) return false; +- return {n, 1, stride}; +- } +- } +- +- static constexpr bool show_writeable = is_eigen_dense_map::value && is_eigen_mutable_map::value; +- static constexpr bool show_order = is_eigen_dense_map::value; +- static constexpr bool show_c_contiguous = show_order && requires_row_major; +- static constexpr bool show_f_contiguous = !show_c_contiguous && show_order && requires_col_major; +- +- static constexpr auto descriptor = +- _("numpy.ndarray[") + npy_format_descriptor::name + +- _("[") + _(_<(size_t) rows>(), _("m")) + +- _(", ") + _(_<(size_t) cols>(), _("n")) + +- _("]") + +- // For a reference type (e.g. Ref) we have other constraints that might need to be +- // satisfied: writeable=True (for a mutable reference), and, depending on the map's stride +- // options, possibly f_contiguous or c_contiguous. We include them in the descriptor output +- // to provide some hint as to why a TypeError is occurring (otherwise it can be confusing to +- // see that a function accepts a 'numpy.ndarray[float64[3,2]]' and an error message that you +- // *gave* a numpy.ndarray of the right type and dimensions. +- _(", flags.writeable", "") + +- _(", flags.c_contiguous", "") + +- _(", flags.f_contiguous", "") + +- _("]"); +-}; +- +-// Casts an Eigen type to numpy array. If given a base, the numpy array references the src data, +-// otherwise it'll make a copy. writeable lets you turn off the writeable flag for the array. +-template handle eigen_array_cast(typename props::Type const &src, handle base = handle(), bool writeable = true) { +- constexpr ssize_t elem_size = sizeof(typename props::Scalar); +- array a; +- if (props::vector) +- a = array({ src.size() }, { elem_size * src.innerStride() }, src.data(), base); +- else +- a = array({ src.rows(), src.cols() }, { elem_size * src.rowStride(), elem_size * src.colStride() }, +- src.data(), base); +- +- if (!writeable) +- array_proxy(a.ptr())->flags &= ~detail::npy_api::NPY_ARRAY_WRITEABLE_; +- +- return a.release(); +-} +- +-// Takes an lvalue ref to some Eigen type and a (python) base object, creating a numpy array that +-// reference the Eigen object's data with `base` as the python-registered base class (if omitted, +-// the base will be set to None, and lifetime management is up to the caller). The numpy array is +-// non-writeable if the given type is const. +-template +-handle eigen_ref_array(Type &src, handle parent = none()) { +- // none here is to get past array's should-we-copy detection, which currently always +- // copies when there is no base. Setting the base to None should be harmless. +- return eigen_array_cast(src, parent, !std::is_const::value); +-} +- +-// Takes a pointer to some dense, plain Eigen type, builds a capsule around it, then returns a numpy +-// array that references the encapsulated data with a python-side reference to the capsule to tie +-// its destruction to that of any dependent python objects. Const-ness is determined by whether or +-// not the Type of the pointer given is const. +-template ::value>> +-handle eigen_encapsulate(Type *src) { +- capsule base(src, [](void *o) { delete static_cast(o); }); +- return eigen_ref_array(*src, base); +-} +- +-// Type caster for regular, dense matrix types (e.g. MatrixXd), but not maps/refs/etc. of dense +-// types. +-template +-struct type_caster::value>> { +- using Scalar = typename Type::Scalar; +- using props = EigenProps; +- +- bool load(handle src, bool convert) { +- // If we're in no-convert mode, only load if given an array of the correct type +- if (!convert && !isinstance>(src)) +- return false; +- +- // Coerce into an array, but don't do type conversion yet; the copy below handles it. +- auto buf = array::ensure(src); +- +- if (!buf) +- return false; +- +- auto dims = buf.ndim(); +- if (dims < 1 || dims > 2) +- return false; +- +- auto fits = props::conformable(buf); +- if (!fits) +- return false; +- +- // Allocate the new type, then build a numpy reference into it +- value = Type(fits.rows, fits.cols); +- auto ref = reinterpret_steal(eigen_ref_array(value)); +- if (dims == 1) ref = ref.squeeze(); +- else if (ref.ndim() == 1) buf = buf.squeeze(); +- +- int result = detail::npy_api::get().PyArray_CopyInto_(ref.ptr(), buf.ptr()); +- +- if (result < 0) { // Copy failed! +- PyErr_Clear(); +- return false; +- } +- +- return true; +- } +- +-private: +- +- // Cast implementation +- template +- static handle cast_impl(CType *src, return_value_policy policy, handle parent) { +- switch (policy) { +- case return_value_policy::take_ownership: +- case return_value_policy::automatic: +- return eigen_encapsulate(src); +- case return_value_policy::move: +- return eigen_encapsulate(new CType(std::move(*src))); +- case return_value_policy::copy: +- return eigen_array_cast(*src); +- case return_value_policy::reference: +- case return_value_policy::automatic_reference: +- return eigen_ref_array(*src); +- case return_value_policy::reference_internal: +- return eigen_ref_array(*src, parent); +- default: +- throw cast_error("unhandled return_value_policy: should not happen!"); +- }; +- } +- +-public: +- +- // Normal returned non-reference, non-const value: +- static handle cast(Type &&src, return_value_policy /* policy */, handle parent) { +- return cast_impl(&src, return_value_policy::move, parent); +- } +- // If you return a non-reference const, we mark the numpy array readonly: +- static handle cast(const Type &&src, return_value_policy /* policy */, handle parent) { +- return cast_impl(&src, return_value_policy::move, parent); +- } +- // lvalue reference return; default (automatic) becomes copy +- static handle cast(Type &src, return_value_policy policy, handle parent) { +- if (policy == return_value_policy::automatic || policy == return_value_policy::automatic_reference) +- policy = return_value_policy::copy; +- return cast_impl(&src, policy, parent); +- } +- // const lvalue reference return; default (automatic) becomes copy +- static handle cast(const Type &src, return_value_policy policy, handle parent) { +- if (policy == return_value_policy::automatic || policy == return_value_policy::automatic_reference) +- policy = return_value_policy::copy; +- return cast(&src, policy, parent); +- } +- // non-const pointer return +- static handle cast(Type *src, return_value_policy policy, handle parent) { +- return cast_impl(src, policy, parent); +- } +- // const pointer return +- static handle cast(const Type *src, return_value_policy policy, handle parent) { +- return cast_impl(src, policy, parent); +- } +- +- static constexpr auto name = props::descriptor; +- +- operator Type*() { return &value; } +- operator Type&() { return value; } +- operator Type&&() && { return std::move(value); } +- template using cast_op_type = movable_cast_op_type; +- +-private: +- Type value; +-}; +- +-// Base class for casting reference/map/block/etc. objects back to python. +-template struct eigen_map_caster { +-private: +- using props = EigenProps; +- +-public: +- +- // Directly referencing a ref/map's data is a bit dangerous (whatever the map/ref points to has +- // to stay around), but we'll allow it under the assumption that you know what you're doing (and +- // have an appropriate keep_alive in place). We return a numpy array pointing directly at the +- // ref's data (The numpy array ends up read-only if the ref was to a const matrix type.) Note +- // that this means you need to ensure you don't destroy the object in some other way (e.g. with +- // an appropriate keep_alive, or with a reference to a statically allocated matrix). +- static handle cast(const MapType &src, return_value_policy policy, handle parent) { +- switch (policy) { +- case return_value_policy::copy: +- return eigen_array_cast(src); +- case return_value_policy::reference_internal: +- return eigen_array_cast(src, parent, is_eigen_mutable_map::value); +- case return_value_policy::reference: +- case return_value_policy::automatic: +- case return_value_policy::automatic_reference: +- return eigen_array_cast(src, none(), is_eigen_mutable_map::value); +- default: +- // move, take_ownership don't make any sense for a ref/map: +- pybind11_fail("Invalid return_value_policy for Eigen Map/Ref/Block type"); +- } +- } +- +- static constexpr auto name = props::descriptor; +- +- // Explicitly delete these: support python -> C++ conversion on these (i.e. these can be return +- // types but not bound arguments). We still provide them (with an explicitly delete) so that +- // you end up here if you try anyway. +- bool load(handle, bool) = delete; +- operator MapType() = delete; +- template using cast_op_type = MapType; +-}; +- +-// We can return any map-like object (but can only load Refs, specialized next): +-template struct type_caster::value>> +- : eigen_map_caster {}; +- +-// Loader for Ref<...> arguments. See the documentation for info on how to make this work without +-// copying (it requires some extra effort in many cases). +-template +-struct type_caster< +- Eigen::Ref, +- enable_if_t>::value> +-> : public eigen_map_caster> { +-private: +- using Type = Eigen::Ref; +- using props = EigenProps; +- using Scalar = typename props::Scalar; +- using MapType = Eigen::Map; +- using Array = array_t; +- static constexpr bool need_writeable = is_eigen_mutable_map::value; +- // Delay construction (these have no default constructor) +- std::unique_ptr map; +- std::unique_ptr ref; +- // Our array. When possible, this is just a numpy array pointing to the source data, but +- // sometimes we can't avoid copying (e.g. input is not a numpy array at all, has an incompatible +- // layout, or is an array of a type that needs to be converted). Using a numpy temporary +- // (rather than an Eigen temporary) saves an extra copy when we need both type conversion and +- // storage order conversion. (Note that we refuse to use this temporary copy when loading an +- // argument for a Ref with M non-const, i.e. a read-write reference). +- Array copy_or_ref; +-public: +- bool load(handle src, bool convert) { +- // First check whether what we have is already an array of the right type. If not, we can't +- // avoid a copy (because the copy is also going to do type conversion). +- bool need_copy = !isinstance(src); +- +- EigenConformable fits; +- if (!need_copy) { +- // We don't need a converting copy, but we also need to check whether the strides are +- // compatible with the Ref's stride requirements +- auto aref = reinterpret_borrow(src); +- +- if (aref && (!need_writeable || aref.writeable())) { +- fits = props::conformable(aref); +- if (!fits) return false; // Incompatible dimensions +- if (!fits.template stride_compatible()) +- need_copy = true; +- else +- copy_or_ref = std::move(aref); +- } +- else { +- need_copy = true; +- } +- } +- +- if (need_copy) { +- // We need to copy: If we need a mutable reference, or we're not supposed to convert +- // (either because we're in the no-convert overload pass, or because we're explicitly +- // instructed not to copy (via `py::arg().noconvert()`) we have to fail loading. +- if (!convert || need_writeable) return false; +- +- Array copy = Array::ensure(src); +- if (!copy) return false; +- fits = props::conformable(copy); +- if (!fits || !fits.template stride_compatible()) +- return false; +- copy_or_ref = std::move(copy); +- loader_life_support::add_patient(copy_or_ref); +- } +- +- ref.reset(); +- map.reset(new MapType(data(copy_or_ref), fits.rows, fits.cols, make_stride(fits.stride.outer(), fits.stride.inner()))); +- ref.reset(new Type(*map)); +- +- return true; +- } +- +- operator Type*() { return ref.get(); } +- operator Type&() { return *ref; } +- template using cast_op_type = pybind11::detail::cast_op_type<_T>; +- +-private: +- template ::value, int> = 0> +- Scalar *data(Array &a) { return a.mutable_data(); } +- +- template ::value, int> = 0> +- const Scalar *data(Array &a) { return a.data(); } +- +- // Attempt to figure out a constructor of `Stride` that will work. +- // If both strides are fixed, use a default constructor: +- template using stride_ctor_default = bool_constant< +- S::InnerStrideAtCompileTime != Eigen::Dynamic && S::OuterStrideAtCompileTime != Eigen::Dynamic && +- std::is_default_constructible::value>; +- // Otherwise, if there is a two-index constructor, assume it is (outer,inner) like +- // Eigen::Stride, and use it: +- template using stride_ctor_dual = bool_constant< +- !stride_ctor_default::value && std::is_constructible::value>; +- // Otherwise, if there is a one-index constructor, and just one of the strides is dynamic, use +- // it (passing whichever stride is dynamic). +- template using stride_ctor_outer = bool_constant< +- !any_of, stride_ctor_dual>::value && +- S::OuterStrideAtCompileTime == Eigen::Dynamic && S::InnerStrideAtCompileTime != Eigen::Dynamic && +- std::is_constructible::value>; +- template using stride_ctor_inner = bool_constant< +- !any_of, stride_ctor_dual>::value && +- S::InnerStrideAtCompileTime == Eigen::Dynamic && S::OuterStrideAtCompileTime != Eigen::Dynamic && +- std::is_constructible::value>; +- +- template ::value, int> = 0> +- static S make_stride(EigenIndex, EigenIndex) { return S(); } +- template ::value, int> = 0> +- static S make_stride(EigenIndex outer, EigenIndex inner) { return S(outer, inner); } +- template ::value, int> = 0> +- static S make_stride(EigenIndex outer, EigenIndex) { return S(outer); } +- template ::value, int> = 0> +- static S make_stride(EigenIndex, EigenIndex inner) { return S(inner); } +- +-}; +- +-// type_caster for special matrix types (e.g. DiagonalMatrix), which are EigenBase, but not +-// EigenDense (i.e. they don't have a data(), at least not with the usual matrix layout). +-// load() is not supported, but we can cast them into the python domain by first copying to a +-// regular Eigen::Matrix, then casting that. +-template +-struct type_caster::value>> { +-protected: +- using Matrix = Eigen::Matrix; +- using props = EigenProps; +-public: +- static handle cast(const Type &src, return_value_policy /* policy */, handle /* parent */) { +- handle h = eigen_encapsulate(new Matrix(src)); +- return h; +- } +- static handle cast(const Type *src, return_value_policy policy, handle parent) { return cast(*src, policy, parent); } +- +- static constexpr auto name = props::descriptor; +- +- // Explicitly delete these: support python -> C++ conversion on these (i.e. these can be return +- // types but not bound arguments). We still provide them (with an explicitly delete) so that +- // you end up here if you try anyway. +- bool load(handle, bool) = delete; +- operator Type() = delete; +- template using cast_op_type = Type; +-}; +- +-template +-struct type_caster::value>> { +- using Scalar = typename Type::Scalar; +- using StorageIndex = remove_reference_t().outerIndexPtr())>; +- using Index = typename Type::Index; +- static constexpr bool rowMajor = Type::IsRowMajor; +- +- bool load(handle src, bool) { +- if (!src) +- return false; +- +- auto obj = reinterpret_borrow(src); +- object sparse_module = module_::import("scipy.sparse"); +- object matrix_type = sparse_module.attr( +- rowMajor ? "csr_matrix" : "csc_matrix"); +- +- if (!type::handle_of(obj).is(matrix_type)) { +- try { +- obj = matrix_type(obj); +- } catch (const error_already_set &) { +- return false; +- } +- } +- +- auto values = array_t((object) obj.attr("data")); +- auto innerIndices = array_t((object) obj.attr("indices")); +- auto outerIndices = array_t((object) obj.attr("indptr")); +- auto shape = pybind11::tuple((pybind11::object) obj.attr("shape")); +- auto nnz = obj.attr("nnz").cast(); +- +- if (!values || !innerIndices || !outerIndices) +- return false; +- +- value = Eigen::MappedSparseMatrix( +- shape[0].cast(), shape[1].cast(), nnz, +- outerIndices.mutable_data(), innerIndices.mutable_data(), values.mutable_data()); +- +- return true; +- } +- +- static handle cast(const Type &src, return_value_policy /* policy */, handle /* parent */) { +- const_cast(src).makeCompressed(); +- +- object matrix_type = module_::import("scipy.sparse").attr( +- rowMajor ? "csr_matrix" : "csc_matrix"); +- +- array data(src.nonZeros(), src.valuePtr()); +- array outerIndices((rowMajor ? src.rows() : src.cols()) + 1, src.outerIndexPtr()); +- array innerIndices(src.nonZeros(), src.innerIndexPtr()); +- +- return matrix_type( +- std::make_tuple(data, innerIndices, outerIndices), +- std::make_pair(src.rows(), src.cols()) +- ).release(); +- } +- +- PYBIND11_TYPE_CASTER(Type, _<(Type::IsRowMajor) != 0>("scipy.sparse.csr_matrix[", "scipy.sparse.csc_matrix[") +- + npy_format_descriptor::name + _("]")); +-}; +- +-PYBIND11_NAMESPACE_END(detail) +-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE) +- +-#if defined(__GNUG__) || defined(__clang__) +-# pragma GCC diagnostic pop +-#elif defined(_MSC_VER) +-# pragma warning(pop) +-#endif +diff --git a/dune/python/pybind11/embed.h b/dune/python/pybind11/embed.h +deleted file mode 100644 +index 204aaf989..000000000 +--- a/dune/python/pybind11/embed.h ++++ /dev/null +@@ -1,201 +0,0 @@ +-/* +- pybind11/embed.h: Support for embedding the interpreter +- +- Copyright (c) 2017 Wenzel Jakob +- +- All rights reserved. Use of this source code is governed by a +- BSD-style license that can be found in the LICENSE file. +-*/ +- +-#pragma once +- +-#include "pybind11.h" +-#include "eval.h" +- +-#if defined(PYPY_VERSION) +-# error Embedding the interpreter is not supported with PyPy +-#endif +- +-#if PY_MAJOR_VERSION >= 3 +-# define PYBIND11_EMBEDDED_MODULE_IMPL(name) \ +- extern "C" PyObject *pybind11_init_impl_##name(); \ +- extern "C" PyObject *pybind11_init_impl_##name() { \ +- return pybind11_init_wrapper_##name(); \ +- } +-#else +-# define PYBIND11_EMBEDDED_MODULE_IMPL(name) \ +- extern "C" void pybind11_init_impl_##name(); \ +- extern "C" void pybind11_init_impl_##name() { \ +- pybind11_init_wrapper_##name(); \ +- } +-#endif +- +-/** \rst +- Add a new module to the table of builtins for the interpreter. Must be +- defined in global scope. The first macro parameter is the name of the +- module (without quotes). The second parameter is the variable which will +- be used as the interface to add functions and classes to the module. +- +- .. code-block:: cpp +- +- PYBIND11_EMBEDDED_MODULE(example, m) { +- // ... initialize functions and classes here +- m.def("foo", []() { +- return "Hello, World!"; +- }); +- } +- \endrst */ +-#define PYBIND11_EMBEDDED_MODULE(name, variable) \ +- static ::pybind11::module_::module_def \ +- PYBIND11_CONCAT(pybind11_module_def_, name); \ +- static void PYBIND11_CONCAT(pybind11_init_, name)(::pybind11::module_ &); \ +- static PyObject PYBIND11_CONCAT(*pybind11_init_wrapper_, name)() { \ +- auto m = ::pybind11::module_::create_extension_module( \ +- PYBIND11_TOSTRING(name), nullptr, \ +- &PYBIND11_CONCAT(pybind11_module_def_, name)); \ +- try { \ +- PYBIND11_CONCAT(pybind11_init_, name)(m); \ +- return m.ptr(); \ +- } PYBIND11_CATCH_INIT_EXCEPTIONS \ +- } \ +- PYBIND11_EMBEDDED_MODULE_IMPL(name) \ +- ::pybind11::detail::embedded_module PYBIND11_CONCAT(pybind11_module_, name) \ +- (PYBIND11_TOSTRING(name), \ +- PYBIND11_CONCAT(pybind11_init_impl_, name)); \ +- void PYBIND11_CONCAT(pybind11_init_, name)(::pybind11::module_ &variable) +- +- +-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE) +-PYBIND11_NAMESPACE_BEGIN(detail) +- +-/// Python 2.7/3.x compatible version of `PyImport_AppendInittab` and error checks. +-struct embedded_module { +-#if PY_MAJOR_VERSION >= 3 +- using init_t = PyObject *(*)(); +-#else +- using init_t = void (*)(); +-#endif +- embedded_module(const char *name, init_t init) { +- if (Py_IsInitialized()) +- pybind11_fail("Can't add new modules after the interpreter has been initialized"); +- +- auto result = PyImport_AppendInittab(name, init); +- if (result == -1) +- pybind11_fail("Insufficient memory to add a new module"); +- } +-}; +- +-PYBIND11_NAMESPACE_END(detail) +- +-/** \rst +- Initialize the Python interpreter. No other pybind11 or CPython API functions can be +- called before this is done; with the exception of `PYBIND11_EMBEDDED_MODULE`. The +- optional parameter can be used to skip the registration of signal handlers (see the +- `Python documentation`_ for details). Calling this function again after the interpreter +- has already been initialized is a fatal error. +- +- If initializing the Python interpreter fails, then the program is terminated. (This +- is controlled by the CPython runtime and is an exception to pybind11's normal behavior +- of throwing exceptions on errors.) +- +- .. _Python documentation: https://docs.python.org/3/c-api/init.html#c.Py_InitializeEx +- \endrst */ +-inline void initialize_interpreter(bool init_signal_handlers = true) { +- if (Py_IsInitialized()) +- pybind11_fail("The interpreter is already running"); +- +- Py_InitializeEx(init_signal_handlers ? 1 : 0); +- +- // Make .py files in the working directory available by default +- module_::import("sys").attr("path").cast().append("."); +-} +- +-/** \rst +- Shut down the Python interpreter. No pybind11 or CPython API functions can be called +- after this. In addition, pybind11 objects must not outlive the interpreter: +- +- .. code-block:: cpp +- +- { // BAD +- py::initialize_interpreter(); +- auto hello = py::str("Hello, World!"); +- py::finalize_interpreter(); +- } // <-- BOOM, hello's destructor is called after interpreter shutdown +- +- { // GOOD +- py::initialize_interpreter(); +- { // scoped +- auto hello = py::str("Hello, World!"); +- } // <-- OK, hello is cleaned up properly +- py::finalize_interpreter(); +- } +- +- { // BETTER +- py::scoped_interpreter guard{}; +- auto hello = py::str("Hello, World!"); +- } +- +- .. warning:: +- +- The interpreter can be restarted by calling `initialize_interpreter` again. +- Modules created using pybind11 can be safely re-initialized. However, Python +- itself cannot completely unload binary extension modules and there are several +- caveats with regard to interpreter restarting. All the details can be found +- in the CPython documentation. In short, not all interpreter memory may be +- freed, either due to reference cycles or user-created global data. +- +- \endrst */ +-inline void finalize_interpreter() { +- handle builtins(PyEval_GetBuiltins()); +- const char *id = PYBIND11_INTERNALS_ID; +- +- // Get the internals pointer (without creating it if it doesn't exist). It's possible for the +- // internals to be created during Py_Finalize() (e.g. if a py::capsule calls `get_internals()` +- // during destruction), so we get the pointer-pointer here and check it after Py_Finalize(). +- detail::internals **internals_ptr_ptr = detail::get_internals_pp(); +- // It could also be stashed in builtins, so look there too: +- if (builtins.contains(id) && isinstance(builtins[id])) +- internals_ptr_ptr = capsule(builtins[id]); +- +- Py_Finalize(); +- +- if (internals_ptr_ptr) { +- delete *internals_ptr_ptr; +- *internals_ptr_ptr = nullptr; +- } +-} +- +-/** \rst +- Scope guard version of `initialize_interpreter` and `finalize_interpreter`. +- This a move-only guard and only a single instance can exist. +- +- .. code-block:: cpp +- +- #include +- +- int main() { +- py::scoped_interpreter guard{}; +- py::print(Hello, World!); +- } // <-- interpreter shutdown +- \endrst */ +-class scoped_interpreter { +-public: +- scoped_interpreter(bool init_signal_handlers = true) { +- initialize_interpreter(init_signal_handlers); +- } +- +- scoped_interpreter(const scoped_interpreter &) = delete; +- scoped_interpreter(scoped_interpreter &&other) noexcept { other.is_valid = false; } +- scoped_interpreter &operator=(const scoped_interpreter &) = delete; +- scoped_interpreter &operator=(scoped_interpreter &&) = delete; +- +- ~scoped_interpreter() { +- if (is_valid) +- finalize_interpreter(); +- } +- +-private: +- bool is_valid = true; +-}; +- +-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE) +diff --git a/dune/python/pybind11/eval.h b/dune/python/pybind11/eval.h +deleted file mode 100644 +index fa6b8af47..000000000 +--- a/dune/python/pybind11/eval.h ++++ /dev/null +@@ -1,152 +0,0 @@ +-/* +- pybind11/exec.h: Support for evaluating Python expressions and statements +- from strings and files +- +- Copyright (c) 2016 Klemens Morgenstern and +- Wenzel Jakob +- +- All rights reserved. Use of this source code is governed by a +- BSD-style license that can be found in the LICENSE file. +-*/ +- +-#pragma once +- +-#include "pybind11.h" +- +-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE) +-PYBIND11_NAMESPACE_BEGIN(detail) +- +-inline void ensure_builtins_in_globals(object &global) { +- #if PY_VERSION_HEX < 0x03080000 +- // Running exec and eval on Python 2 and 3 adds `builtins` module under +- // `__builtins__` key to globals if not yet present. +- // Python 3.8 made PyRun_String behave similarly. Let's also do that for +- // older versions, for consistency. +- if (!global.contains("__builtins__")) +- global["__builtins__"] = module_::import(PYBIND11_BUILTINS_MODULE); +- #else +- (void) global; +- #endif +-} +- +-PYBIND11_NAMESPACE_END(detail) +- +-enum eval_mode { +- /// Evaluate a string containing an isolated expression +- eval_expr, +- +- /// Evaluate a string containing a single statement. Returns \c none +- eval_single_statement, +- +- /// Evaluate a string containing a sequence of statement. Returns \c none +- eval_statements +-}; +- +-template +-object eval(str expr, object global = globals(), object local = object()) { +- if (!local) +- local = global; +- +- detail::ensure_builtins_in_globals(global); +- +- /* PyRun_String does not accept a PyObject / encoding specifier, +- this seems to be the only alternative */ +- std::string buffer = "# -*- coding: utf-8 -*-\n" + (std::string) expr; +- +- int start; +- switch (mode) { +- case eval_expr: start = Py_eval_input; break; +- case eval_single_statement: start = Py_single_input; break; +- case eval_statements: start = Py_file_input; break; +- default: pybind11_fail("invalid evaluation mode"); +- } +- +- PyObject *result = PyRun_String(buffer.c_str(), start, global.ptr(), local.ptr()); +- if (!result) +- throw error_already_set(); +- return reinterpret_steal(result); +-} +- +-template +-object eval(const char (&s)[N], object global = globals(), object local = object()) { +- /* Support raw string literals by removing common leading whitespace */ +- auto expr = (s[0] == '\n') ? str(module_::import("textwrap").attr("dedent")(s)) +- : str(s); +- return eval(expr, global, local); +-} +- +-inline void exec(str expr, object global = globals(), object local = object()) { +- eval(expr, global, local); +-} +- +-template +-void exec(const char (&s)[N], object global = globals(), object local = object()) { +- eval(s, global, local); +-} +- +-#if defined(PYPY_VERSION) && PY_VERSION_HEX >= 0x03000000 +-template +-object eval_file(str, object, object) { +- pybind11_fail("eval_file not supported in PyPy3. Use eval"); +-} +-template +-object eval_file(str, object) { +- pybind11_fail("eval_file not supported in PyPy3. Use eval"); +-} +-template +-object eval_file(str) { +- pybind11_fail("eval_file not supported in PyPy3. Use eval"); +-} +-#else +-template +-object eval_file(str fname, object global = globals(), object local = object()) { +- if (!local) +- local = global; +- +- detail::ensure_builtins_in_globals(global); +- +- int start; +- switch (mode) { +- case eval_expr: start = Py_eval_input; break; +- case eval_single_statement: start = Py_single_input; break; +- case eval_statements: start = Py_file_input; break; +- default: pybind11_fail("invalid evaluation mode"); +- } +- +- int closeFile = 1; +- std::string fname_str = (std::string) fname; +-#if PY_VERSION_HEX >= 0x03040000 +- FILE *f = _Py_fopen_obj(fname.ptr(), "r"); +-#elif PY_VERSION_HEX >= 0x03000000 +- FILE *f = _Py_fopen(fname.ptr(), "r"); +-#else +- /* No unicode support in open() :( */ +- auto fobj = reinterpret_steal(PyFile_FromString( +- const_cast(fname_str.c_str()), +- const_cast("r"))); +- FILE *f = nullptr; +- if (fobj) +- f = PyFile_AsFile(fobj.ptr()); +- closeFile = 0; +-#endif +- if (!f) { +- PyErr_Clear(); +- pybind11_fail("File \"" + fname_str + "\" could not be opened!"); +- } +- +-#if PY_VERSION_HEX < 0x03000000 && defined(PYPY_VERSION) +- PyObject *result = PyRun_File(f, fname_str.c_str(), start, global.ptr(), +- local.ptr()); +- (void) closeFile; +-#else +- PyObject *result = PyRun_FileEx(f, fname_str.c_str(), start, global.ptr(), +- local.ptr(), closeFile); +-#endif +- +- if (!result) +- throw error_already_set(); +- return reinterpret_steal(result); +-} +-#endif +- +-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE) +diff --git a/dune/python/pybind11/extensions.h b/dune/python/pybind11/extensions.h +deleted file mode 100644 +index 72c08c49f..000000000 +--- a/dune/python/pybind11/extensions.h ++++ /dev/null +@@ -1,72 +0,0 @@ +-/* +- pybind11/extensions.h: Extensions to the C++11 python binding +- generator library for dune-fempy +- +- Copyright (c) 2016 Andreas Dedner +- Copyright (c) 2016 Martin Nolte +- +- All rights reserved. Use of this source code is governed by a +- BSD-style license that can be found in the LICENSE file. +-*/ +- +-#pragma once +- +-#include +-#include +-#include +- +-#include "pybind11.h" +-#include "numpy.h" +- +-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE) +- +-template +-inline bool already_registered() { +- return static_cast(detail::get_type_info(typeid(T))); +-} +- +- +-template +-inline void handle_buffer_format(const pybind11::buffer_info &info, F &&f) { +- if(info.format.size() != 1) +- throw std::runtime_error("Buffer format '" + info.format + "' not supported."); +- switch(info.format[0]) { +- case 'h': +- return f(format_descriptor()); +- case 'H': +- return f(format_descriptor()); +- case 'i': +- return f(format_descriptor()); +- case 'I': +- return f(format_descriptor()); +- case 'l': +- return f(format_descriptor()); +- case 'L': +- return f(format_descriptor()); +- case 'q': +- return f(format_descriptor()); +- case 'Q': +- return f(format_descriptor()); +- case 'f': +- return f(format_descriptor()); +- case 'd': +- return f(format_descriptor()); +- default: +- throw std::runtime_error("Buffer format '" + info.format + "' not supported."); +- } +-} +- +-template +-inline void implicitly_convert_facades() { +- auto implicit_caster = [](PyObject *obj, PyTypeObject *type) -> PyObject * { +- return getattr(obj, "__impl__", nullptr).release().ptr(); +- }; +- +- if(auto tinfo = detail::get_type_info(typeid(T))) +- tinfo->implicit_conversions.push_back(implicit_caster); +- else +- pybind11_fail("impplicitly_convert_facades: Unable to find type " + type_id()); +-} +- +- +-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE) +diff --git a/dune/python/pybind11/functional.h b/dune/python/pybind11/functional.h +deleted file mode 100644 +index 92c17dc22..000000000 +--- a/dune/python/pybind11/functional.h ++++ /dev/null +@@ -1,104 +0,0 @@ +-/* +- pybind11/functional.h: std::function<> support +- +- Copyright (c) 2016 Wenzel Jakob +- +- All rights reserved. Use of this source code is governed by a +- BSD-style license that can be found in the LICENSE file. +-*/ +- +-#pragma once +- +-#include "pybind11.h" +-#include +- +-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE) +-PYBIND11_NAMESPACE_BEGIN(detail) +- +-template +-struct type_caster> { +- using type = std::function; +- using retval_type = conditional_t::value, void_type, Return>; +- using function_type = Return (*) (Args...); +- +-public: +- bool load(handle src, bool convert) { +- if (src.is_none()) { +- // Defer accepting None to other overloads (if we aren't in convert mode): +- if (!convert) return false; +- return true; +- } +- +- if (!isinstance(src)) +- return false; +- +- auto func = reinterpret_borrow(src); +- +- /* +- When passing a C++ function as an argument to another C++ +- function via Python, every function call would normally involve +- a full C++ -> Python -> C++ roundtrip, which can be prohibitive. +- Here, we try to at least detect the case where the function is +- stateless (i.e. function pointer or lambda function without +- captured variables), in which case the roundtrip can be avoided. +- */ +- if (auto cfunc = func.cpp_function()) { +- auto c = reinterpret_borrow(PyCFunction_GET_SELF(cfunc.ptr())); +- auto rec = (function_record *) c; +- +- if (rec && rec->is_stateless && +- same_type(typeid(function_type), *reinterpret_cast(rec->data[1]))) { +- struct capture { function_type f; }; +- value = ((capture *) &rec->data)->f; +- return true; +- } +- } +- +- // ensure GIL is held during functor destruction +- struct func_handle { +- function f; +- func_handle(function&& f_) : f(std::move(f_)) {} +- func_handle(const func_handle& f_) { +- gil_scoped_acquire acq; +- f = f_.f; +- } +- ~func_handle() { +- gil_scoped_acquire acq; +- function kill_f(std::move(f)); +- } +- }; +- +- // to emulate 'move initialization capture' in C++11 +- struct func_wrapper { +- func_handle hfunc; +- func_wrapper(func_handle&& hf): hfunc(std::move(hf)) {} +- Return operator()(Args... args) const { +- gil_scoped_acquire acq; +- object retval(hfunc.f(std::forward(args)...)); +- /* Visual studio 2015 parser issue: need parentheses around this expression */ +- return (retval.template cast()); +- } +- }; +- +- value = func_wrapper(func_handle(std::move(func))); +- return true; +- } +- +- template +- static handle cast(Func &&f_, return_value_policy policy, handle /* parent */) { +- if (!f_) +- return none().inc_ref(); +- +- auto result = f_.template target(); +- if (result) +- return cpp_function(*result, policy).release(); +- else +- return cpp_function(std::forward(f_), policy).release(); +- } +- +- PYBIND11_TYPE_CASTER(type, _("Callable[[") + concat(make_caster::name...) + _("], ") +- + make_caster::name + _("]")); +-}; +- +-PYBIND11_NAMESPACE_END(detail) +-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE) +diff --git a/dune/python/pybind11/iostream.h b/dune/python/pybind11/iostream.h +deleted file mode 100644 +index 5e9a8143d..000000000 +--- a/dune/python/pybind11/iostream.h ++++ /dev/null +@@ -1,216 +0,0 @@ +-/* +- pybind11/iostream.h -- Tools to assist with redirecting cout and cerr to Python +- +- Copyright (c) 2017 Henry F. Schreiner +- +- All rights reserved. Use of this source code is governed by a +- BSD-style license that can be found in the LICENSE file. +-*/ +- +-#pragma once +- +-#include "pybind11.h" +- +-#include +-#include +-#include +-#include +-#include +- +-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE) +-PYBIND11_NAMESPACE_BEGIN(detail) +- +-// Buffer that writes to Python instead of C++ +-class pythonbuf : public std::streambuf { +-private: +- using traits_type = std::streambuf::traits_type; +- +- const size_t buf_size; +- std::unique_ptr d_buffer; +- object pywrite; +- object pyflush; +- +- int overflow(int c) override { +- if (!traits_type::eq_int_type(c, traits_type::eof())) { +- *pptr() = traits_type::to_char_type(c); +- pbump(1); +- } +- return sync() == 0 ? traits_type::not_eof(c) : traits_type::eof(); +- } +- +- // This function must be non-virtual to be called in a destructor. If the +- // rare MSVC test failure shows up with this version, then this should be +- // simplified to a fully qualified call. +- int _sync() { +- if (pbase() != pptr()) { +- // This subtraction cannot be negative, so dropping the sign +- str line(pbase(), static_cast(pptr() - pbase())); +- +- { +- gil_scoped_acquire tmp; +- pywrite(line); +- pyflush(); +- } +- +- setp(pbase(), epptr()); +- } +- return 0; +- } +- +- int sync() override { +- return _sync(); +- } +- +-public: +- +- pythonbuf(object pyostream, size_t buffer_size = 1024) +- : buf_size(buffer_size), +- d_buffer(new char[buf_size]), +- pywrite(pyostream.attr("write")), +- pyflush(pyostream.attr("flush")) { +- setp(d_buffer.get(), d_buffer.get() + buf_size - 1); +- } +- +- pythonbuf(pythonbuf&&) = default; +- +- /// Sync before destroy +- ~pythonbuf() override { +- _sync(); +- } +-}; +- +-PYBIND11_NAMESPACE_END(detail) +- +- +-/** \rst +- This a move-only guard that redirects output. +- +- .. code-block:: cpp +- +- #include +- +- ... +- +- { +- py::scoped_ostream_redirect output; +- std::cout << "Hello, World!"; // Python stdout +- } // <-- return std::cout to normal +- +- You can explicitly pass the c++ stream and the python object, +- for example to guard stderr instead. +- +- .. code-block:: cpp +- +- { +- py::scoped_ostream_redirect output{std::cerr, py::module_::import("sys").attr("stderr")}; +- std::cerr << "Hello, World!"; +- } +- \endrst */ +-class scoped_ostream_redirect { +-protected: +- std::streambuf *old; +- std::ostream &costream; +- detail::pythonbuf buffer; +- +-public: +- scoped_ostream_redirect( +- std::ostream &costream = std::cout, +- object pyostream = module_::import("sys").attr("stdout")) +- : costream(costream), buffer(pyostream) { +- old = costream.rdbuf(&buffer); +- } +- +- ~scoped_ostream_redirect() { +- costream.rdbuf(old); +- } +- +- scoped_ostream_redirect(const scoped_ostream_redirect &) = delete; +- scoped_ostream_redirect(scoped_ostream_redirect &&other) = default; +- scoped_ostream_redirect &operator=(const scoped_ostream_redirect &) = delete; +- scoped_ostream_redirect &operator=(scoped_ostream_redirect &&) = delete; +-}; +- +- +-/** \rst +- Like `scoped_ostream_redirect`, but redirects cerr by default. This class +- is provided primary to make ``py::call_guard`` easier to make. +- +- .. code-block:: cpp +- +- m.def("noisy_func", &noisy_func, +- py::call_guard()); +- +-\endrst */ +-class scoped_estream_redirect : public scoped_ostream_redirect { +-public: +- scoped_estream_redirect( +- std::ostream &costream = std::cerr, +- object pyostream = module_::import("sys").attr("stderr")) +- : scoped_ostream_redirect(costream,pyostream) {} +-}; +- +- +-PYBIND11_NAMESPACE_BEGIN(detail) +- +-// Class to redirect output as a context manager. C++ backend. +-class OstreamRedirect { +- bool do_stdout_; +- bool do_stderr_; +- std::unique_ptr redirect_stdout; +- std::unique_ptr redirect_stderr; +- +-public: +- OstreamRedirect(bool do_stdout = true, bool do_stderr = true) +- : do_stdout_(do_stdout), do_stderr_(do_stderr) {} +- +- void enter() { +- if (do_stdout_) +- redirect_stdout.reset(new scoped_ostream_redirect()); +- if (do_stderr_) +- redirect_stderr.reset(new scoped_estream_redirect()); +- } +- +- void exit() { +- redirect_stdout.reset(); +- redirect_stderr.reset(); +- } +-}; +- +-PYBIND11_NAMESPACE_END(detail) +- +-/** \rst +- This is a helper function to add a C++ redirect context manager to Python +- instead of using a C++ guard. To use it, add the following to your binding code: +- +- .. code-block:: cpp +- +- #include +- +- ... +- +- py::add_ostream_redirect(m, "ostream_redirect"); +- +- You now have a Python context manager that redirects your output: +- +- .. code-block:: python +- +- with m.ostream_redirect(): +- m.print_to_cout_function() +- +- This manager can optionally be told which streams to operate on: +- +- .. code-block:: python +- +- with m.ostream_redirect(stdout=true, stderr=true): +- m.noisy_function_with_error_printing() +- +- \endrst */ +-inline class_ add_ostream_redirect(module_ m, std::string name = "ostream_redirect") { +- return class_(m, name.c_str(), module_local()) +- .def(init(), arg("stdout")=true, arg("stderr")=true) +- .def("__enter__", &detail::OstreamRedirect::enter) +- .def("__exit__", [](detail::OstreamRedirect &self_, args) { self_.exit(); }); +-} +- +-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE) +diff --git a/dune/python/pybind11/numpy.h b/dune/python/pybind11/numpy.h +deleted file mode 100644 +index 019f5688e..000000000 +--- a/dune/python/pybind11/numpy.h ++++ /dev/null +@@ -1,1693 +0,0 @@ +-/* +- pybind11/numpy.h: Basic NumPy support, vectorize() wrapper +- +- Copyright (c) 2016 Wenzel Jakob +- +- All rights reserved. Use of this source code is governed by a +- BSD-style license that can be found in the LICENSE file. +-*/ +- +-#pragma once +- +-#include "pybind11.h" +-#include "complex.h" +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +- +-#if defined(_MSC_VER) +-# pragma warning(push) +-# pragma warning(disable: 4127) // warning C4127: Conditional expression is constant +-#endif +- +-/* This will be true on all flat address space platforms and allows us to reduce the +- whole npy_intp / ssize_t / Py_intptr_t business down to just ssize_t for all size +- and dimension types (e.g. shape, strides, indexing), instead of inflicting this +- upon the library user. */ +-static_assert(sizeof(::pybind11::ssize_t) == sizeof(Py_intptr_t), "ssize_t != Py_intptr_t"); +-static_assert(std::is_signed::value, "Py_intptr_t must be signed"); +-// We now can reinterpret_cast between py::ssize_t and Py_intptr_t (MSVC + PyPy cares) +- +-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE) +- +-class array; // Forward declaration +- +-PYBIND11_NAMESPACE_BEGIN(detail) +- +-template <> struct handle_type_name { static constexpr auto name = _("numpy.ndarray"); }; +- +-template struct npy_format_descriptor; +- +-struct PyArrayDescr_Proxy { +- PyObject_HEAD +- PyObject *typeobj; +- char kind; +- char type; +- char byteorder; +- char flags; +- int type_num; +- int elsize; +- int alignment; +- char *subarray; +- PyObject *fields; +- PyObject *names; +-}; +- +-struct PyArray_Proxy { +- PyObject_HEAD +- char *data; +- int nd; +- ssize_t *dimensions; +- ssize_t *strides; +- PyObject *base; +- PyObject *descr; +- int flags; +-}; +- +-struct PyVoidScalarObject_Proxy { +- PyObject_VAR_HEAD +- char *obval; +- PyArrayDescr_Proxy *descr; +- int flags; +- PyObject *base; +-}; +- +-struct numpy_type_info { +- PyObject* dtype_ptr; +- std::string format_str; +-}; +- +-struct numpy_internals { +- std::unordered_map registered_dtypes; +- +- numpy_type_info *get_type_info(const std::type_info& tinfo, bool throw_if_missing = true) { +- auto it = registered_dtypes.find(std::type_index(tinfo)); +- if (it != registered_dtypes.end()) +- return &(it->second); +- if (throw_if_missing) +- pybind11_fail(std::string("NumPy type info missing for ") + tinfo.name()); +- return nullptr; +- } +- +- template numpy_type_info *get_type_info(bool throw_if_missing = true) { +- return get_type_info(typeid(typename std::remove_cv::type), throw_if_missing); +- } +-}; +- +-inline PYBIND11_NOINLINE void load_numpy_internals(numpy_internals* &ptr) { +- ptr = &get_or_create_shared_data("_numpy_internals"); +-} +- +-inline numpy_internals& get_numpy_internals() { +- static numpy_internals* ptr = nullptr; +- if (!ptr) +- load_numpy_internals(ptr); +- return *ptr; +-} +- +-template struct same_size { +- template using as = bool_constant; +-}; +- +-template constexpr int platform_lookup() { return -1; } +- +-// Lookup a type according to its size, and return a value corresponding to the NumPy typenum. +-template +-constexpr int platform_lookup(int I, Ints... Is) { +- return sizeof(Concrete) == sizeof(T) ? I : platform_lookup(Is...); +-} +- +-struct npy_api { +- enum constants { +- NPY_ARRAY_C_CONTIGUOUS_ = 0x0001, +- NPY_ARRAY_F_CONTIGUOUS_ = 0x0002, +- NPY_ARRAY_OWNDATA_ = 0x0004, +- NPY_ARRAY_FORCECAST_ = 0x0010, +- NPY_ARRAY_ENSUREARRAY_ = 0x0040, +- NPY_ARRAY_ALIGNED_ = 0x0100, +- NPY_ARRAY_WRITEABLE_ = 0x0400, +- NPY_BOOL_ = 0, +- NPY_BYTE_, NPY_UBYTE_, +- NPY_SHORT_, NPY_USHORT_, +- NPY_INT_, NPY_UINT_, +- NPY_LONG_, NPY_ULONG_, +- NPY_LONGLONG_, NPY_ULONGLONG_, +- NPY_FLOAT_, NPY_DOUBLE_, NPY_LONGDOUBLE_, +- NPY_CFLOAT_, NPY_CDOUBLE_, NPY_CLONGDOUBLE_, +- NPY_OBJECT_ = 17, +- NPY_STRING_, NPY_UNICODE_, NPY_VOID_, +- // Platform-dependent normalization +- NPY_INT8_ = NPY_BYTE_, +- NPY_UINT8_ = NPY_UBYTE_, +- NPY_INT16_ = NPY_SHORT_, +- NPY_UINT16_ = NPY_USHORT_, +- // `npy_common.h` defines the integer aliases. In order, it checks: +- // NPY_BITSOF_LONG, NPY_BITSOF_LONGLONG, NPY_BITSOF_INT, NPY_BITSOF_SHORT, NPY_BITSOF_CHAR +- // and assigns the alias to the first matching size, so we should check in this order. +- NPY_INT32_ = platform_lookup( +- NPY_LONG_, NPY_INT_, NPY_SHORT_), +- NPY_UINT32_ = platform_lookup( +- NPY_ULONG_, NPY_UINT_, NPY_USHORT_), +- NPY_INT64_ = platform_lookup( +- NPY_LONG_, NPY_LONGLONG_, NPY_INT_), +- NPY_UINT64_ = platform_lookup( +- NPY_ULONG_, NPY_ULONGLONG_, NPY_UINT_), +- }; +- +- typedef struct { +- Py_intptr_t *ptr; +- int len; +- } PyArray_Dims; +- +- static npy_api& get() { +- static npy_api api = lookup(); +- return api; +- } +- +- bool PyArray_Check_(PyObject *obj) const { +- return (bool) PyObject_TypeCheck(obj, PyArray_Type_); +- } +- bool PyArrayDescr_Check_(PyObject *obj) const { +- return (bool) PyObject_TypeCheck(obj, PyArrayDescr_Type_); +- } +- +- unsigned int (*PyArray_GetNDArrayCFeatureVersion_)(); +- PyObject *(*PyArray_DescrFromType_)(int); +- PyObject *(*PyArray_NewFromDescr_) +- (PyTypeObject *, PyObject *, int, Py_intptr_t const *, +- Py_intptr_t const *, void *, int, PyObject *); +- // Unused. Not removed because that affects ABI of the class. +- PyObject *(*PyArray_DescrNewFromType_)(int); +- int (*PyArray_CopyInto_)(PyObject *, PyObject *); +- PyObject *(*PyArray_NewCopy_)(PyObject *, int); +- PyTypeObject *PyArray_Type_; +- PyTypeObject *PyVoidArrType_Type_; +- PyTypeObject *PyArrayDescr_Type_; +- PyObject *(*PyArray_DescrFromScalar_)(PyObject *); +- PyObject *(*PyArray_FromAny_) (PyObject *, PyObject *, int, int, int, PyObject *); +- int (*PyArray_DescrConverter_) (PyObject *, PyObject **); +- bool (*PyArray_EquivTypes_) (PyObject *, PyObject *); +- int (*PyArray_GetArrayParamsFromObject_)(PyObject *, PyObject *, unsigned char, PyObject **, int *, +- Py_intptr_t *, PyObject **, PyObject *); +- PyObject *(*PyArray_Squeeze_)(PyObject *); +- // Unused. Not removed because that affects ABI of the class. +- int (*PyArray_SetBaseObject_)(PyObject *, PyObject *); +- PyObject* (*PyArray_Resize_)(PyObject*, PyArray_Dims*, int, int); +-private: +- enum functions { +- API_PyArray_GetNDArrayCFeatureVersion = 211, +- API_PyArray_Type = 2, +- API_PyArrayDescr_Type = 3, +- API_PyVoidArrType_Type = 39, +- API_PyArray_DescrFromType = 45, +- API_PyArray_DescrFromScalar = 57, +- API_PyArray_FromAny = 69, +- API_PyArray_Resize = 80, +- API_PyArray_CopyInto = 82, +- API_PyArray_NewCopy = 85, +- API_PyArray_NewFromDescr = 94, +- API_PyArray_DescrNewFromType = 96, +- API_PyArray_DescrConverter = 174, +- API_PyArray_EquivTypes = 182, +- API_PyArray_GetArrayParamsFromObject = 278, +- API_PyArray_Squeeze = 136, +- API_PyArray_SetBaseObject = 282 +- }; +- +- static npy_api lookup() { +- module_ m = module_::import("numpy.core.multiarray"); +- auto c = m.attr("_ARRAY_API"); +-#if PY_MAJOR_VERSION >= 3 +- void **api_ptr = (void **) PyCapsule_GetPointer(c.ptr(), NULL); +-#else +- void **api_ptr = (void **) PyCObject_AsVoidPtr(c.ptr()); +-#endif +- npy_api api; +-#define DECL_NPY_API(Func) api.Func##_ = (decltype(api.Func##_)) api_ptr[API_##Func]; +- DECL_NPY_API(PyArray_GetNDArrayCFeatureVersion); +- if (api.PyArray_GetNDArrayCFeatureVersion_() < 0x7) +- pybind11_fail("pybind11 numpy support requires numpy >= 1.7.0"); +- DECL_NPY_API(PyArray_Type); +- DECL_NPY_API(PyVoidArrType_Type); +- DECL_NPY_API(PyArrayDescr_Type); +- DECL_NPY_API(PyArray_DescrFromType); +- DECL_NPY_API(PyArray_DescrFromScalar); +- DECL_NPY_API(PyArray_FromAny); +- DECL_NPY_API(PyArray_Resize); +- DECL_NPY_API(PyArray_CopyInto); +- DECL_NPY_API(PyArray_NewCopy); +- DECL_NPY_API(PyArray_NewFromDescr); +- DECL_NPY_API(PyArray_DescrNewFromType); +- DECL_NPY_API(PyArray_DescrConverter); +- DECL_NPY_API(PyArray_EquivTypes); +- DECL_NPY_API(PyArray_GetArrayParamsFromObject); +- DECL_NPY_API(PyArray_Squeeze); +- DECL_NPY_API(PyArray_SetBaseObject); +-#undef DECL_NPY_API +- return api; +- } +-}; +- +-inline PyArray_Proxy* array_proxy(void* ptr) { +- return reinterpret_cast(ptr); +-} +- +-inline const PyArray_Proxy* array_proxy(const void* ptr) { +- return reinterpret_cast(ptr); +-} +- +-inline PyArrayDescr_Proxy* array_descriptor_proxy(PyObject* ptr) { +- return reinterpret_cast(ptr); +-} +- +-inline const PyArrayDescr_Proxy* array_descriptor_proxy(const PyObject* ptr) { +- return reinterpret_cast(ptr); +-} +- +-inline bool check_flags(const void* ptr, int flag) { +- return (flag == (array_proxy(ptr)->flags & flag)); +-} +- +-template struct is_std_array : std::false_type { }; +-template struct is_std_array> : std::true_type { }; +-template struct is_complex : std::false_type { }; +-template struct is_complex> : std::true_type { }; +- +-template struct array_info_scalar { +- using type = T; +- static constexpr bool is_array = false; +- static constexpr bool is_empty = false; +- static constexpr auto extents = _(""); +- static void append_extents(list& /* shape */) { } +-}; +-// Computes underlying type and a comma-separated list of extents for array +-// types (any mix of std::array and built-in arrays). An array of char is +-// treated as scalar because it gets special handling. +-template struct array_info : array_info_scalar { }; +-template struct array_info> { +- using type = typename array_info::type; +- static constexpr bool is_array = true; +- static constexpr bool is_empty = (N == 0) || array_info::is_empty; +- static constexpr size_t extent = N; +- +- // appends the extents to shape +- static void append_extents(list& shape) { +- shape.append(N); +- array_info::append_extents(shape); +- } +- +- static constexpr auto extents = _::is_array>( +- concat(_(), array_info::extents), _() +- ); +-}; +-// For numpy we have special handling for arrays of characters, so we don't include +-// the size in the array extents. +-template struct array_info : array_info_scalar { }; +-template struct array_info> : array_info_scalar> { }; +-template struct array_info : array_info> { }; +-template using remove_all_extents_t = typename array_info::type; +- +-template using is_pod_struct = all_of< +- std::is_standard_layout, // since we're accessing directly in memory we need a standard layout type +-#if !defined(__GNUG__) || defined(_LIBCPP_VERSION) || defined(_GLIBCXX_USE_CXX11_ABI) +- // _GLIBCXX_USE_CXX11_ABI indicates that we're using libstdc++ from GCC 5 or newer, independent +- // of the actual compiler (Clang can also use libstdc++, but it always defines __GNUC__ == 4). +- std::is_trivially_copyable, +-#else +- // GCC 4 doesn't implement is_trivially_copyable, so approximate it +- std::is_trivially_destructible, +- satisfies_any_of, +-#endif +- satisfies_none_of +->; +- +-// Replacement for std::is_pod (deprecated in C++20) +-template using is_pod = all_of< +- std::is_standard_layout, +- std::is_trivial +->; +- +-template ssize_t byte_offset_unsafe(const Strides &) { return 0; } +-template +-ssize_t byte_offset_unsafe(const Strides &strides, ssize_t i, Ix... index) { +- return i * strides[Dim] + byte_offset_unsafe(strides, index...); +-} +- +-/** +- * Proxy class providing unsafe, unchecked const access to array data. This is constructed through +- * the `unchecked()` method of `array` or the `unchecked()` method of `array_t`. `Dims` +- * will be -1 for dimensions determined at runtime. +- */ +-template +-class unchecked_reference { +-protected: +- static constexpr bool Dynamic = Dims < 0; +- const unsigned char *data_; +- // Storing the shape & strides in local variables (i.e. these arrays) allows the compiler to +- // make large performance gains on big, nested loops, but requires compile-time dimensions +- conditional_t> +- shape_, strides_; +- const ssize_t dims_; +- +- friend class pybind11::array; +- // Constructor for compile-time dimensions: +- template +- unchecked_reference(const void *data, const ssize_t *shape, const ssize_t *strides, enable_if_t) +- : data_{reinterpret_cast(data)}, dims_{Dims} { +- for (size_t i = 0; i < (size_t) dims_; i++) { +- shape_[i] = shape[i]; +- strides_[i] = strides[i]; +- } +- } +- // Constructor for runtime dimensions: +- template +- unchecked_reference(const void *data, const ssize_t *shape, const ssize_t *strides, enable_if_t dims) +- : data_{reinterpret_cast(data)}, shape_{shape}, strides_{strides}, dims_{dims} {} +- +-public: +- /** +- * Unchecked const reference access to data at the given indices. For a compile-time known +- * number of dimensions, this requires the correct number of arguments; for run-time +- * dimensionality, this is not checked (and so is up to the caller to use safely). +- */ +- template const T &operator()(Ix... index) const { +- static_assert(ssize_t{sizeof...(Ix)} == Dims || Dynamic, +- "Invalid number of indices for unchecked array reference"); +- return *reinterpret_cast(data_ + byte_offset_unsafe(strides_, ssize_t(index)...)); +- } +- /** +- * Unchecked const reference access to data; this operator only participates if the reference +- * is to a 1-dimensional array. When present, this is exactly equivalent to `obj(index)`. +- */ +- template > +- const T &operator[](ssize_t index) const { return operator()(index); } +- +- /// Pointer access to the data at the given indices. +- template const T *data(Ix... ix) const { return &operator()(ssize_t(ix)...); } +- +- /// Returns the item size, i.e. sizeof(T) +- constexpr static ssize_t itemsize() { return sizeof(T); } +- +- /// Returns the shape (i.e. size) of dimension `dim` +- ssize_t shape(ssize_t dim) const { return shape_[(size_t) dim]; } +- +- /// Returns the number of dimensions of the array +- ssize_t ndim() const { return dims_; } +- +- /// Returns the total number of elements in the referenced array, i.e. the product of the shapes +- template +- enable_if_t size() const { +- return std::accumulate(shape_.begin(), shape_.end(), (ssize_t) 1, std::multiplies()); +- } +- template +- enable_if_t size() const { +- return std::accumulate(shape_, shape_ + ndim(), (ssize_t) 1, std::multiplies()); +- } +- +- /// Returns the total number of bytes used by the referenced data. Note that the actual span in +- /// memory may be larger if the referenced array has non-contiguous strides (e.g. for a slice). +- ssize_t nbytes() const { +- return size() * itemsize(); +- } +-}; +- +-template +-class unchecked_mutable_reference : public unchecked_reference { +- friend class pybind11::array; +- using ConstBase = unchecked_reference; +- using ConstBase::ConstBase; +- using ConstBase::Dynamic; +-public: +- // Bring in const-qualified versions from base class +- using ConstBase::operator(); +- using ConstBase::operator[]; +- +- /// Mutable, unchecked access to data at the given indices. +- template T& operator()(Ix... index) { +- static_assert(ssize_t{sizeof...(Ix)} == Dims || Dynamic, +- "Invalid number of indices for unchecked array reference"); +- return const_cast(ConstBase::operator()(index...)); +- } +- /** +- * Mutable, unchecked access data at the given index; this operator only participates if the +- * reference is to a 1-dimensional array (or has runtime dimensions). When present, this is +- * exactly equivalent to `obj(index)`. +- */ +- template > +- T &operator[](ssize_t index) { return operator()(index); } +- +- /// Mutable pointer access to the data at the given indices. +- template T *mutable_data(Ix... ix) { return &operator()(ssize_t(ix)...); } +-}; +- +-template +-struct type_caster> { +- static_assert(Dim == 0 && Dim > 0 /* always fail */, "unchecked array proxy object is not castable"); +-}; +-template +-struct type_caster> : type_caster> {}; +- +-PYBIND11_NAMESPACE_END(detail) +- +-class dtype : public object { +-public: +- PYBIND11_OBJECT_DEFAULT(dtype, object, detail::npy_api::get().PyArrayDescr_Check_); +- +- explicit dtype(const buffer_info &info) { +- dtype descr(_dtype_from_pep3118()(PYBIND11_STR_TYPE(info.format))); +- // If info.itemsize == 0, use the value calculated from the format string +- m_ptr = descr.strip_padding(info.itemsize ? info.itemsize : descr.itemsize()).release().ptr(); +- } +- +- explicit dtype(const std::string &format) { +- m_ptr = from_args(pybind11::str(format)).release().ptr(); +- } +- +- dtype(const char *format) : dtype(std::string(format)) { } +- +- dtype(list names, list formats, list offsets, ssize_t itemsize) { +- dict args; +- args["names"] = names; +- args["formats"] = formats; +- args["offsets"] = offsets; +- args["itemsize"] = pybind11::int_(itemsize); +- m_ptr = from_args(args).release().ptr(); +- } +- +- /// This is essentially the same as calling numpy.dtype(args) in Python. +- static dtype from_args(object args) { +- PyObject *ptr = nullptr; +- if (!detail::npy_api::get().PyArray_DescrConverter_(args.ptr(), &ptr) || !ptr) +- throw error_already_set(); +- return reinterpret_steal(ptr); +- } +- +- /// Return dtype associated with a C++ type. +- template static dtype of() { +- return detail::npy_format_descriptor::type>::dtype(); +- } +- +- /// Size of the data type in bytes. +- ssize_t itemsize() const { +- return detail::array_descriptor_proxy(m_ptr)->elsize; +- } +- +- /// Returns true for structured data types. +- bool has_fields() const { +- return detail::array_descriptor_proxy(m_ptr)->names != nullptr; +- } +- +- /// Single-character type code. +- char kind() const { +- return detail::array_descriptor_proxy(m_ptr)->kind; +- } +- +-private: +- static object _dtype_from_pep3118() { +- static PyObject *obj = module_::import("numpy.core._internal") +- .attr("_dtype_from_pep3118").cast().release().ptr(); +- return reinterpret_borrow(obj); +- } +- +- dtype strip_padding(ssize_t itemsize) { +- // Recursively strip all void fields with empty names that are generated for +- // padding fields (as of NumPy v1.11). +- if (!has_fields()) +- return *this; +- +- struct field_descr { PYBIND11_STR_TYPE name; object format; pybind11::int_ offset; }; +- std::vector field_descriptors; +- +- for (auto field : attr("fields").attr("items")()) { +- auto spec = field.cast(); +- auto name = spec[0].cast(); +- auto format = spec[1].cast()[0].cast(); +- auto offset = spec[1].cast()[1].cast(); +- if (!len(name) && format.kind() == 'V') +- continue; +- field_descriptors.push_back({(PYBIND11_STR_TYPE) name, format.strip_padding(format.itemsize()), offset}); +- } +- +- std::sort(field_descriptors.begin(), field_descriptors.end(), +- [](const field_descr& a, const field_descr& b) { +- return a.offset.cast() < b.offset.cast(); +- }); +- +- list names, formats, offsets; +- for (auto& descr : field_descriptors) { +- names.append(descr.name); +- formats.append(descr.format); +- offsets.append(descr.offset); +- } +- return dtype(names, formats, offsets, itemsize); +- } +-}; +- +-class array : public buffer { +-public: +- PYBIND11_OBJECT_CVT(array, buffer, detail::npy_api::get().PyArray_Check_, raw_array) +- +- enum { +- c_style = detail::npy_api::NPY_ARRAY_C_CONTIGUOUS_, +- f_style = detail::npy_api::NPY_ARRAY_F_CONTIGUOUS_, +- forcecast = detail::npy_api::NPY_ARRAY_FORCECAST_ +- }; +- +- array() : array(0, static_cast(nullptr)) {} +- +- using ShapeContainer = detail::any_container; +- using StridesContainer = detail::any_container; +- +- // Constructs an array taking shape/strides from arbitrary container types +- array(const pybind11::dtype &dt, ShapeContainer shape, StridesContainer strides, +- const void *ptr = nullptr, handle base = handle()) { +- +- if (strides->empty()) +- *strides = detail::c_strides(*shape, dt.itemsize()); +- +- auto ndim = shape->size(); +- if (ndim != strides->size()) +- pybind11_fail("NumPy: shape ndim doesn't match strides ndim"); +- auto descr = dt; +- +- int flags = 0; +- if (base && ptr) { +- if (isinstance(base)) +- /* Copy flags from base (except ownership bit) */ +- flags = reinterpret_borrow(base).flags() & ~detail::npy_api::NPY_ARRAY_OWNDATA_; +- else +- /* Writable by default, easy to downgrade later on if needed */ +- flags = detail::npy_api::NPY_ARRAY_WRITEABLE_; +- } +- +- auto &api = detail::npy_api::get(); +- auto tmp = reinterpret_steal(api.PyArray_NewFromDescr_( +- api.PyArray_Type_, descr.release().ptr(), (int) ndim, +- // Use reinterpret_cast for PyPy on Windows (remove if fixed, checked on 7.3.1) +- reinterpret_cast(shape->data()), +- reinterpret_cast(strides->data()), +- const_cast(ptr), flags, nullptr)); +- if (!tmp) +- throw error_already_set(); +- if (ptr) { +- if (base) { +- api.PyArray_SetBaseObject_(tmp.ptr(), base.inc_ref().ptr()); +- } else { +- tmp = reinterpret_steal(api.PyArray_NewCopy_(tmp.ptr(), -1 /* any order */)); +- } +- } +- m_ptr = tmp.release().ptr(); +- } +- +- array(const pybind11::dtype &dt, ShapeContainer shape, const void *ptr = nullptr, handle base = handle()) +- : array(dt, std::move(shape), {}, ptr, base) { } +- +- template ::value && !std::is_same::value>> +- array(const pybind11::dtype &dt, T count, const void *ptr = nullptr, handle base = handle()) +- : array(dt, {{count}}, ptr, base) { } +- +- template +- array(ShapeContainer shape, StridesContainer strides, const T *ptr, handle base = handle()) +- : array(pybind11::dtype::of(), std::move(shape), std::move(strides), ptr, base) { } +- +- template +- array(ShapeContainer shape, const T *ptr, handle base = handle()) +- : array(std::move(shape), {}, ptr, base) { } +- +- template +- explicit array(ssize_t count, const T *ptr, handle base = handle()) : array({count}, {}, ptr, base) { } +- +- explicit array(const buffer_info &info, handle base = handle()) +- : array(pybind11::dtype(info), info.shape, info.strides, info.ptr, base) { } +- +- /// Array descriptor (dtype) +- pybind11::dtype dtype() const { +- return reinterpret_borrow(detail::array_proxy(m_ptr)->descr); +- } +- +- /// Total number of elements +- ssize_t size() const { +- return std::accumulate(shape(), shape() + ndim(), (ssize_t) 1, std::multiplies()); +- } +- +- /// Byte size of a single element +- ssize_t itemsize() const { +- return detail::array_descriptor_proxy(detail::array_proxy(m_ptr)->descr)->elsize; +- } +- +- /// Total number of bytes +- ssize_t nbytes() const { +- return size() * itemsize(); +- } +- +- /// Number of dimensions +- ssize_t ndim() const { +- return detail::array_proxy(m_ptr)->nd; +- } +- +- /// Base object +- object base() const { +- return reinterpret_borrow(detail::array_proxy(m_ptr)->base); +- } +- +- /// Dimensions of the array +- const ssize_t* shape() const { +- return detail::array_proxy(m_ptr)->dimensions; +- } +- +- /// Dimension along a given axis +- ssize_t shape(ssize_t dim) const { +- if (dim >= ndim()) +- fail_dim_check(dim, "invalid axis"); +- return shape()[dim]; +- } +- +- /// Strides of the array +- const ssize_t* strides() const { +- return detail::array_proxy(m_ptr)->strides; +- } +- +- /// Stride along a given axis +- ssize_t strides(ssize_t dim) const { +- if (dim >= ndim()) +- fail_dim_check(dim, "invalid axis"); +- return strides()[dim]; +- } +- +- /// Return the NumPy array flags +- int flags() const { +- return detail::array_proxy(m_ptr)->flags; +- } +- +- /// If set, the array is writeable (otherwise the buffer is read-only) +- bool writeable() const { +- return detail::check_flags(m_ptr, detail::npy_api::NPY_ARRAY_WRITEABLE_); +- } +- +- /// If set, the array owns the data (will be freed when the array is deleted) +- bool owndata() const { +- return detail::check_flags(m_ptr, detail::npy_api::NPY_ARRAY_OWNDATA_); +- } +- +- /// Pointer to the contained data. If index is not provided, points to the +- /// beginning of the buffer. May throw if the index would lead to out of bounds access. +- template const void* data(Ix... index) const { +- return static_cast(detail::array_proxy(m_ptr)->data + offset_at(index...)); +- } +- +- /// Mutable pointer to the contained data. If index is not provided, points to the +- /// beginning of the buffer. May throw if the index would lead to out of bounds access. +- /// May throw if the array is not writeable. +- template void* mutable_data(Ix... index) { +- check_writeable(); +- return static_cast(detail::array_proxy(m_ptr)->data + offset_at(index...)); +- } +- +- /// Byte offset from beginning of the array to a given index (full or partial). +- /// May throw if the index would lead to out of bounds access. +- template ssize_t offset_at(Ix... index) const { +- if ((ssize_t) sizeof...(index) > ndim()) +- fail_dim_check(sizeof...(index), "too many indices for an array"); +- return byte_offset(ssize_t(index)...); +- } +- +- ssize_t offset_at() const { return 0; } +- +- /// Item count from beginning of the array to a given index (full or partial). +- /// May throw if the index would lead to out of bounds access. +- template ssize_t index_at(Ix... index) const { +- return offset_at(index...) / itemsize(); +- } +- +- /** +- * Returns a proxy object that provides access to the array's data without bounds or +- * dimensionality checking. Will throw if the array is missing the `writeable` flag. Use with +- * care: the array must not be destroyed or reshaped for the duration of the returned object, +- * and the caller must take care not to access invalid dimensions or dimension indices. +- */ +- template detail::unchecked_mutable_reference mutable_unchecked() & { +- if (Dims >= 0 && ndim() != Dims) +- throw std::domain_error("array has incorrect number of dimensions: " + std::to_string(ndim()) + +- "; expected " + std::to_string(Dims)); +- return detail::unchecked_mutable_reference(mutable_data(), shape(), strides(), ndim()); +- } +- +- /** +- * Returns a proxy object that provides const access to the array's data without bounds or +- * dimensionality checking. Unlike `mutable_unchecked()`, this does not require that the +- * underlying array have the `writable` flag. Use with care: the array must not be destroyed or +- * reshaped for the duration of the returned object, and the caller must take care not to access +- * invalid dimensions or dimension indices. +- */ +- template detail::unchecked_reference unchecked() const & { +- if (Dims >= 0 && ndim() != Dims) +- throw std::domain_error("array has incorrect number of dimensions: " + std::to_string(ndim()) + +- "; expected " + std::to_string(Dims)); +- return detail::unchecked_reference(data(), shape(), strides(), ndim()); +- } +- +- /// Return a new view with all of the dimensions of length 1 removed +- array squeeze() { +- auto& api = detail::npy_api::get(); +- return reinterpret_steal(api.PyArray_Squeeze_(m_ptr)); +- } +- +- /// Resize array to given shape +- /// If refcheck is true and more that one reference exist to this array +- /// then resize will succeed only if it makes a reshape, i.e. original size doesn't change +- void resize(ShapeContainer new_shape, bool refcheck = true) { +- detail::npy_api::PyArray_Dims d = { +- // Use reinterpret_cast for PyPy on Windows (remove if fixed, checked on 7.3.1) +- reinterpret_cast(new_shape->data()), +- int(new_shape->size()) +- }; +- // try to resize, set ordering param to -1 cause it's not used anyway +- auto new_array = reinterpret_steal( +- detail::npy_api::get().PyArray_Resize_(m_ptr, &d, int(refcheck), -1) +- ); +- if (!new_array) throw error_already_set(); +- if (isinstance(new_array)) { *this = std::move(new_array); } +- } +- +- /// Ensure that the argument is a NumPy array +- /// In case of an error, nullptr is returned and the Python error is cleared. +- static array ensure(handle h, int ExtraFlags = 0) { +- auto result = reinterpret_steal(raw_array(h.ptr(), ExtraFlags)); +- if (!result) +- PyErr_Clear(); +- return result; +- } +- +-protected: +- template friend struct detail::npy_format_descriptor; +- +- void fail_dim_check(ssize_t dim, const std::string& msg) const { +- throw index_error(msg + ": " + std::to_string(dim) + +- " (ndim = " + std::to_string(ndim()) + ")"); +- } +- +- template ssize_t byte_offset(Ix... index) const { +- check_dimensions(index...); +- return detail::byte_offset_unsafe(strides(), ssize_t(index)...); +- } +- +- void check_writeable() const { +- if (!writeable()) +- throw std::domain_error("array is not writeable"); +- } +- +- template void check_dimensions(Ix... index) const { +- check_dimensions_impl(ssize_t(0), shape(), ssize_t(index)...); +- } +- +- void check_dimensions_impl(ssize_t, const ssize_t*) const { } +- +- template void check_dimensions_impl(ssize_t axis, const ssize_t* shape, ssize_t i, Ix... index) const { +- if (i >= *shape) { +- throw index_error(std::string("index ") + std::to_string(i) + +- " is out of bounds for axis " + std::to_string(axis) + +- " with size " + std::to_string(*shape)); +- } +- check_dimensions_impl(axis + 1, shape + 1, index...); +- } +- +- /// Create array from any object -- always returns a new reference +- static PyObject *raw_array(PyObject *ptr, int ExtraFlags = 0) { +- if (ptr == nullptr) { +- PyErr_SetString(PyExc_ValueError, "cannot create a pybind11::array from a nullptr"); +- return nullptr; +- } +- return detail::npy_api::get().PyArray_FromAny_( +- ptr, nullptr, 0, 0, detail::npy_api::NPY_ARRAY_ENSUREARRAY_ | ExtraFlags, nullptr); +- } +-}; +- +-template class array_t : public array { +-private: +- struct private_ctor {}; +- // Delegating constructor needed when both moving and accessing in the same constructor +- array_t(private_ctor, ShapeContainer &&shape, StridesContainer &&strides, const T *ptr, handle base) +- : array(std::move(shape), std::move(strides), ptr, base) {} +-public: +- static_assert(!detail::array_info::is_array, "Array types cannot be used with array_t"); +- +- using value_type = T; +- +- array_t() : array(0, static_cast(nullptr)) {} +- array_t(handle h, borrowed_t) : array(h, borrowed_t{}) { } +- array_t(handle h, stolen_t) : array(h, stolen_t{}) { } +- +- PYBIND11_DEPRECATED("Use array_t::ensure() instead") +- array_t(handle h, bool is_borrowed) : array(raw_array_t(h.ptr()), stolen_t{}) { +- if (!m_ptr) PyErr_Clear(); +- if (!is_borrowed) Py_XDECREF(h.ptr()); +- } +- +- array_t(const object &o) : array(raw_array_t(o.ptr()), stolen_t{}) { +- if (!m_ptr) throw error_already_set(); +- } +- +- explicit array_t(const buffer_info& info, handle base = handle()) : array(info, base) { } +- +- array_t(ShapeContainer shape, StridesContainer strides, const T *ptr = nullptr, handle base = handle()) +- : array(std::move(shape), std::move(strides), ptr, base) { } +- +- explicit array_t(ShapeContainer shape, const T *ptr = nullptr, handle base = handle()) +- : array_t(private_ctor{}, std::move(shape), +- ExtraFlags & f_style +- ? detail::f_strides(*shape, itemsize()) +- : detail::c_strides(*shape, itemsize()), +- ptr, base) { } +- +- explicit array_t(ssize_t count, const T *ptr = nullptr, handle base = handle()) +- : array({count}, {}, ptr, base) { } +- +- constexpr ssize_t itemsize() const { +- return sizeof(T); +- } +- +- template ssize_t index_at(Ix... index) const { +- return offset_at(index...) / itemsize(); +- } +- +- template const T* data(Ix... index) const { +- return static_cast(array::data(index...)); +- } +- +- template T* mutable_data(Ix... index) { +- return static_cast(array::mutable_data(index...)); +- } +- +- // Reference to element at a given index +- template const T& at(Ix... index) const { +- if ((ssize_t) sizeof...(index) != ndim()) +- fail_dim_check(sizeof...(index), "index dimension mismatch"); +- return *(static_cast(array::data()) + byte_offset(ssize_t(index)...) / itemsize()); +- } +- +- // Mutable reference to element at a given index +- template T& mutable_at(Ix... index) { +- if ((ssize_t) sizeof...(index) != ndim()) +- fail_dim_check(sizeof...(index), "index dimension mismatch"); +- return *(static_cast(array::mutable_data()) + byte_offset(ssize_t(index)...) / itemsize()); +- } +- +- /** +- * Returns a proxy object that provides access to the array's data without bounds or +- * dimensionality checking. Will throw if the array is missing the `writeable` flag. Use with +- * care: the array must not be destroyed or reshaped for the duration of the returned object, +- * and the caller must take care not to access invalid dimensions or dimension indices. +- */ +- template detail::unchecked_mutable_reference mutable_unchecked() & { +- return array::mutable_unchecked(); +- } +- +- /** +- * Returns a proxy object that provides const access to the array's data without bounds or +- * dimensionality checking. Unlike `unchecked()`, this does not require that the underlying +- * array have the `writable` flag. Use with care: the array must not be destroyed or reshaped +- * for the duration of the returned object, and the caller must take care not to access invalid +- * dimensions or dimension indices. +- */ +- template detail::unchecked_reference unchecked() const & { +- return array::unchecked(); +- } +- +- /// Ensure that the argument is a NumPy array of the correct dtype (and if not, try to convert +- /// it). In case of an error, nullptr is returned and the Python error is cleared. +- static array_t ensure(handle h) { +- auto result = reinterpret_steal(raw_array_t(h.ptr())); +- if (!result) +- PyErr_Clear(); +- return result; +- } +- +- static bool check_(handle h) { +- const auto &api = detail::npy_api::get(); +- return api.PyArray_Check_(h.ptr()) +- && api.PyArray_EquivTypes_(detail::array_proxy(h.ptr())->descr, dtype::of().ptr()) +- && detail::check_flags(h.ptr(), ExtraFlags & (array::c_style | array::f_style)); +- } +- +-protected: +- /// Create array from any object -- always returns a new reference +- static PyObject *raw_array_t(PyObject *ptr) { +- if (ptr == nullptr) { +- PyErr_SetString(PyExc_ValueError, "cannot create a pybind11::array_t from a nullptr"); +- return nullptr; +- } +- return detail::npy_api::get().PyArray_FromAny_( +- ptr, dtype::of().release().ptr(), 0, 0, +- detail::npy_api::NPY_ARRAY_ENSUREARRAY_ | ExtraFlags, nullptr); +- } +-}; +- +-template +-struct format_descriptor::value>> { +- static std::string format() { +- return detail::npy_format_descriptor::type>::format(); +- } +-}; +- +-template struct format_descriptor { +- static std::string format() { return std::to_string(N) + "s"; } +-}; +-template struct format_descriptor> { +- static std::string format() { return std::to_string(N) + "s"; } +-}; +- +-template +-struct format_descriptor::value>> { +- static std::string format() { +- return format_descriptor< +- typename std::remove_cv::type>::type>::format(); +- } +-}; +- +-template +-struct format_descriptor::is_array>> { +- static std::string format() { +- using namespace detail; +- static constexpr auto extents = _("(") + array_info::extents + _(")"); +- return extents.text + format_descriptor>::format(); +- } +-}; +- +-PYBIND11_NAMESPACE_BEGIN(detail) +-template +-struct pyobject_caster> { +- using type = array_t; +- +- bool load(handle src, bool convert) { +- if (!convert && !type::check_(src)) +- return false; +- value = type::ensure(src); +- return static_cast(value); +- } +- +- static handle cast(const handle &src, return_value_policy /* policy */, handle /* parent */) { +- return src.inc_ref(); +- } +- PYBIND11_TYPE_CASTER(type, handle_type_name::name); +-}; +- +-template +-struct compare_buffer_info::value>> { +- static bool compare(const buffer_info& b) { +- return npy_api::get().PyArray_EquivTypes_(dtype::of().ptr(), dtype(b).ptr()); +- } +-}; +- +-template +-struct npy_format_descriptor_name; +- +-template +-struct npy_format_descriptor_name::value>> { +- static constexpr auto name = _::value>( +- _("bool"), _::value>("numpy.int", "numpy.uint") + _() +- ); +-}; +- +-template +-struct npy_format_descriptor_name::value>> { +- static constexpr auto name = _::value || std::is_same::value>( +- _("numpy.float") + _(), _("numpy.longdouble") +- ); +-}; +- +-template +-struct npy_format_descriptor_name::value>> { +- static constexpr auto name = _::value +- || std::is_same::value>( +- _("numpy.complex") + _(), _("numpy.longcomplex") +- ); +-}; +- +-template +-struct npy_format_descriptor::value>> +- : npy_format_descriptor_name { +-private: +- // NB: the order here must match the one in common.h +- constexpr static const int values[15] = { +- npy_api::NPY_BOOL_, +- npy_api::NPY_BYTE_, npy_api::NPY_UBYTE_, npy_api::NPY_INT16_, npy_api::NPY_UINT16_, +- npy_api::NPY_INT32_, npy_api::NPY_UINT32_, npy_api::NPY_INT64_, npy_api::NPY_UINT64_, +- npy_api::NPY_FLOAT_, npy_api::NPY_DOUBLE_, npy_api::NPY_LONGDOUBLE_, +- npy_api::NPY_CFLOAT_, npy_api::NPY_CDOUBLE_, npy_api::NPY_CLONGDOUBLE_ +- }; +- +-public: +- static constexpr int value = values[detail::is_fmt_numeric::index]; +- +- static pybind11::dtype dtype() { +- if (auto ptr = npy_api::get().PyArray_DescrFromType_(value)) +- return reinterpret_steal(ptr); +- pybind11_fail("Unsupported buffer format!"); +- } +-}; +- +-#define PYBIND11_DECL_CHAR_FMT \ +- static constexpr auto name = _("S") + _(); \ +- static pybind11::dtype dtype() { return pybind11::dtype(std::string("S") + std::to_string(N)); } +-template struct npy_format_descriptor { PYBIND11_DECL_CHAR_FMT }; +-template struct npy_format_descriptor> { PYBIND11_DECL_CHAR_FMT }; +-#undef PYBIND11_DECL_CHAR_FMT +- +-template struct npy_format_descriptor::is_array>> { +-private: +- using base_descr = npy_format_descriptor::type>; +-public: +- static_assert(!array_info::is_empty, "Zero-sized arrays are not supported"); +- +- static constexpr auto name = _("(") + array_info::extents + _(")") + base_descr::name; +- static pybind11::dtype dtype() { +- list shape; +- array_info::append_extents(shape); +- return pybind11::dtype::from_args(pybind11::make_tuple(base_descr::dtype(), shape)); +- } +-}; +- +-template struct npy_format_descriptor::value>> { +-private: +- using base_descr = npy_format_descriptor::type>; +-public: +- static constexpr auto name = base_descr::name; +- static pybind11::dtype dtype() { return base_descr::dtype(); } +-}; +- +-struct field_descriptor { +- const char *name; +- ssize_t offset; +- ssize_t size; +- std::string format; +- dtype descr; +-}; +- +-inline PYBIND11_NOINLINE void register_structured_dtype( +- any_container fields, +- const std::type_info& tinfo, ssize_t itemsize, +- bool (*direct_converter)(PyObject *, void *&)) { +- +- auto& numpy_internals = get_numpy_internals(); +- if (numpy_internals.get_type_info(tinfo, false)) +- pybind11_fail("NumPy: dtype is already registered"); +- +- // Use ordered fields because order matters as of NumPy 1.14: +- // https://docs.scipy.org/doc/numpy/release.html#multiple-field-indexing-assignment-of-structured-arrays +- std::vector ordered_fields(std::move(fields)); +- std::sort(ordered_fields.begin(), ordered_fields.end(), +- [](const field_descriptor &a, const field_descriptor &b) { return a.offset < b.offset; }); +- +- list names, formats, offsets; +- for (auto& field : ordered_fields) { +- if (!field.descr) +- pybind11_fail(std::string("NumPy: unsupported field dtype: `") + +- field.name + "` @ " + tinfo.name()); +- names.append(PYBIND11_STR_TYPE(field.name)); +- formats.append(field.descr); +- offsets.append(pybind11::int_(field.offset)); +- } +- auto dtype_ptr = pybind11::dtype(names, formats, offsets, itemsize).release().ptr(); +- +- // There is an existing bug in NumPy (as of v1.11): trailing bytes are +- // not encoded explicitly into the format string. This will supposedly +- // get fixed in v1.12; for further details, see these: +- // - https://github.com/numpy/numpy/issues/7797 +- // - https://github.com/numpy/numpy/pull/7798 +- // Because of this, we won't use numpy's logic to generate buffer format +- // strings and will just do it ourselves. +- ssize_t offset = 0; +- std::ostringstream oss; +- // mark the structure as unaligned with '^', because numpy and C++ don't +- // always agree about alignment (particularly for complex), and we're +- // explicitly listing all our padding. This depends on none of the fields +- // overriding the endianness. Putting the ^ in front of individual fields +- // isn't guaranteed to work due to https://github.com/numpy/numpy/issues/9049 +- oss << "^T{"; +- for (auto& field : ordered_fields) { +- if (field.offset > offset) +- oss << (field.offset - offset) << 'x'; +- oss << field.format << ':' << field.name << ':'; +- offset = field.offset + field.size; +- } +- if (itemsize > offset) +- oss << (itemsize - offset) << 'x'; +- oss << '}'; +- auto format_str = oss.str(); +- +- // Sanity check: verify that NumPy properly parses our buffer format string +- auto& api = npy_api::get(); +- auto arr = array(buffer_info(nullptr, itemsize, format_str, 1)); +- if (!api.PyArray_EquivTypes_(dtype_ptr, arr.dtype().ptr())) +- pybind11_fail("NumPy: invalid buffer descriptor!"); +- +- auto tindex = std::type_index(tinfo); +- numpy_internals.registered_dtypes[tindex] = { dtype_ptr, format_str }; +- get_internals().direct_conversions[tindex].push_back(direct_converter); +-} +- +-template struct npy_format_descriptor { +- static_assert(is_pod_struct::value, "Attempt to use a non-POD or unimplemented POD type as a numpy dtype"); +- +- static constexpr auto name = make_caster::name; +- +- static pybind11::dtype dtype() { +- return reinterpret_borrow(dtype_ptr()); +- } +- +- static std::string format() { +- static auto format_str = get_numpy_internals().get_type_info(true)->format_str; +- return format_str; +- } +- +- static void register_dtype(any_container fields) { +- register_structured_dtype(std::move(fields), typeid(typename std::remove_cv::type), +- sizeof(T), &direct_converter); +- } +- +-private: +- static PyObject* dtype_ptr() { +- static PyObject* ptr = get_numpy_internals().get_type_info(true)->dtype_ptr; +- return ptr; +- } +- +- static bool direct_converter(PyObject *obj, void*& value) { +- auto& api = npy_api::get(); +- if (!PyObject_TypeCheck(obj, api.PyVoidArrType_Type_)) +- return false; +- if (auto descr = reinterpret_steal(api.PyArray_DescrFromScalar_(obj))) { +- if (api.PyArray_EquivTypes_(dtype_ptr(), descr.ptr())) { +- value = ((PyVoidScalarObject_Proxy *) obj)->obval; +- return true; +- } +- } +- return false; +- } +-}; +- +-#ifdef __CLION_IDE__ // replace heavy macro with dummy code for the IDE (doesn't affect code) +-# define PYBIND11_NUMPY_DTYPE(Type, ...) ((void)0) +-# define PYBIND11_NUMPY_DTYPE_EX(Type, ...) ((void)0) +-#else +- +-#define PYBIND11_FIELD_DESCRIPTOR_EX(T, Field, Name) \ +- ::pybind11::detail::field_descriptor { \ +- Name, offsetof(T, Field), sizeof(decltype(std::declval().Field)), \ +- ::pybind11::format_descriptor().Field)>::format(), \ +- ::pybind11::detail::npy_format_descriptor().Field)>::dtype() \ +- } +- +-// Extract name, offset and format descriptor for a struct field +-#define PYBIND11_FIELD_DESCRIPTOR(T, Field) PYBIND11_FIELD_DESCRIPTOR_EX(T, Field, #Field) +- +-// The main idea of this macro is borrowed from https://github.com/swansontec/map-macro +-// (C) William Swanson, Paul Fultz +-#define PYBIND11_EVAL0(...) __VA_ARGS__ +-#define PYBIND11_EVAL1(...) PYBIND11_EVAL0 (PYBIND11_EVAL0 (PYBIND11_EVAL0 (__VA_ARGS__))) +-#define PYBIND11_EVAL2(...) PYBIND11_EVAL1 (PYBIND11_EVAL1 (PYBIND11_EVAL1 (__VA_ARGS__))) +-#define PYBIND11_EVAL3(...) PYBIND11_EVAL2 (PYBIND11_EVAL2 (PYBIND11_EVAL2 (__VA_ARGS__))) +-#define PYBIND11_EVAL4(...) PYBIND11_EVAL3 (PYBIND11_EVAL3 (PYBIND11_EVAL3 (__VA_ARGS__))) +-#define PYBIND11_EVAL(...) PYBIND11_EVAL4 (PYBIND11_EVAL4 (PYBIND11_EVAL4 (__VA_ARGS__))) +-#define PYBIND11_MAP_END(...) +-#define PYBIND11_MAP_OUT +-#define PYBIND11_MAP_COMMA , +-#define PYBIND11_MAP_GET_END() 0, PYBIND11_MAP_END +-#define PYBIND11_MAP_NEXT0(test, next, ...) next PYBIND11_MAP_OUT +-#define PYBIND11_MAP_NEXT1(test, next) PYBIND11_MAP_NEXT0 (test, next, 0) +-#define PYBIND11_MAP_NEXT(test, next) PYBIND11_MAP_NEXT1 (PYBIND11_MAP_GET_END test, next) +-#if defined(_MSC_VER) && !defined(__clang__) // MSVC is not as eager to expand macros, hence this workaround +-#define PYBIND11_MAP_LIST_NEXT1(test, next) \ +- PYBIND11_EVAL0 (PYBIND11_MAP_NEXT0 (test, PYBIND11_MAP_COMMA next, 0)) +-#else +-#define PYBIND11_MAP_LIST_NEXT1(test, next) \ +- PYBIND11_MAP_NEXT0 (test, PYBIND11_MAP_COMMA next, 0) +-#endif +-#define PYBIND11_MAP_LIST_NEXT(test, next) \ +- PYBIND11_MAP_LIST_NEXT1 (PYBIND11_MAP_GET_END test, next) +-#define PYBIND11_MAP_LIST0(f, t, x, peek, ...) \ +- f(t, x) PYBIND11_MAP_LIST_NEXT (peek, PYBIND11_MAP_LIST1) (f, t, peek, __VA_ARGS__) +-#define PYBIND11_MAP_LIST1(f, t, x, peek, ...) \ +- f(t, x) PYBIND11_MAP_LIST_NEXT (peek, PYBIND11_MAP_LIST0) (f, t, peek, __VA_ARGS__) +-// PYBIND11_MAP_LIST(f, t, a1, a2, ...) expands to f(t, a1), f(t, a2), ... +-#define PYBIND11_MAP_LIST(f, t, ...) \ +- PYBIND11_EVAL (PYBIND11_MAP_LIST1 (f, t, __VA_ARGS__, (), 0)) +- +-#define PYBIND11_NUMPY_DTYPE(Type, ...) \ +- ::pybind11::detail::npy_format_descriptor::register_dtype \ +- (::std::vector<::pybind11::detail::field_descriptor> \ +- {PYBIND11_MAP_LIST (PYBIND11_FIELD_DESCRIPTOR, Type, __VA_ARGS__)}) +- +-#if defined(_MSC_VER) && !defined(__clang__) +-#define PYBIND11_MAP2_LIST_NEXT1(test, next) \ +- PYBIND11_EVAL0 (PYBIND11_MAP_NEXT0 (test, PYBIND11_MAP_COMMA next, 0)) +-#else +-#define PYBIND11_MAP2_LIST_NEXT1(test, next) \ +- PYBIND11_MAP_NEXT0 (test, PYBIND11_MAP_COMMA next, 0) +-#endif +-#define PYBIND11_MAP2_LIST_NEXT(test, next) \ +- PYBIND11_MAP2_LIST_NEXT1 (PYBIND11_MAP_GET_END test, next) +-#define PYBIND11_MAP2_LIST0(f, t, x1, x2, peek, ...) \ +- f(t, x1, x2) PYBIND11_MAP2_LIST_NEXT (peek, PYBIND11_MAP2_LIST1) (f, t, peek, __VA_ARGS__) +-#define PYBIND11_MAP2_LIST1(f, t, x1, x2, peek, ...) \ +- f(t, x1, x2) PYBIND11_MAP2_LIST_NEXT (peek, PYBIND11_MAP2_LIST0) (f, t, peek, __VA_ARGS__) +-// PYBIND11_MAP2_LIST(f, t, a1, a2, ...) expands to f(t, a1, a2), f(t, a3, a4), ... +-#define PYBIND11_MAP2_LIST(f, t, ...) \ +- PYBIND11_EVAL (PYBIND11_MAP2_LIST1 (f, t, __VA_ARGS__, (), 0)) +- +-#define PYBIND11_NUMPY_DTYPE_EX(Type, ...) \ +- ::pybind11::detail::npy_format_descriptor::register_dtype \ +- (::std::vector<::pybind11::detail::field_descriptor> \ +- {PYBIND11_MAP2_LIST (PYBIND11_FIELD_DESCRIPTOR_EX, Type, __VA_ARGS__)}) +- +-#endif // __CLION_IDE__ +- +-class common_iterator { +-public: +- using container_type = std::vector; +- using value_type = container_type::value_type; +- using size_type = container_type::size_type; +- +- common_iterator() : p_ptr(0), m_strides() {} +- +- common_iterator(void* ptr, const container_type& strides, const container_type& shape) +- : p_ptr(reinterpret_cast(ptr)), m_strides(strides.size()) { +- m_strides.back() = static_cast(strides.back()); +- for (size_type i = m_strides.size() - 1; i != 0; --i) { +- size_type j = i - 1; +- auto s = static_cast(shape[i]); +- m_strides[j] = strides[j] + m_strides[i] - strides[i] * s; +- } +- } +- +- void increment(size_type dim) { +- p_ptr += m_strides[dim]; +- } +- +- void* data() const { +- return p_ptr; +- } +- +-private: +- char* p_ptr; +- container_type m_strides; +-}; +- +-template class multi_array_iterator { +-public: +- using container_type = std::vector; +- +- multi_array_iterator(const std::array &buffers, +- const container_type &shape) +- : m_shape(shape.size()), m_index(shape.size(), 0), +- m_common_iterator() { +- +- // Manual copy to avoid conversion warning if using std::copy +- for (size_t i = 0; i < shape.size(); ++i) +- m_shape[i] = shape[i]; +- +- container_type strides(shape.size()); +- for (size_t i = 0; i < N; ++i) +- init_common_iterator(buffers[i], shape, m_common_iterator[i], strides); +- } +- +- multi_array_iterator& operator++() { +- for (size_t j = m_index.size(); j != 0; --j) { +- size_t i = j - 1; +- if (++m_index[i] != m_shape[i]) { +- increment_common_iterator(i); +- break; +- } else { +- m_index[i] = 0; +- } +- } +- return *this; +- } +- +- template T* data() const { +- return reinterpret_cast(m_common_iterator[K].data()); +- } +- +-private: +- +- using common_iter = common_iterator; +- +- void init_common_iterator(const buffer_info &buffer, +- const container_type &shape, +- common_iter &iterator, +- container_type &strides) { +- auto buffer_shape_iter = buffer.shape.rbegin(); +- auto buffer_strides_iter = buffer.strides.rbegin(); +- auto shape_iter = shape.rbegin(); +- auto strides_iter = strides.rbegin(); +- +- while (buffer_shape_iter != buffer.shape.rend()) { +- if (*shape_iter == *buffer_shape_iter) +- *strides_iter = *buffer_strides_iter; +- else +- *strides_iter = 0; +- +- ++buffer_shape_iter; +- ++buffer_strides_iter; +- ++shape_iter; +- ++strides_iter; +- } +- +- std::fill(strides_iter, strides.rend(), 0); +- iterator = common_iter(buffer.ptr, strides, shape); +- } +- +- void increment_common_iterator(size_t dim) { +- for (auto &iter : m_common_iterator) +- iter.increment(dim); +- } +- +- container_type m_shape; +- container_type m_index; +- std::array m_common_iterator; +-}; +- +-enum class broadcast_trivial { non_trivial, c_trivial, f_trivial }; +- +-// Populates the shape and number of dimensions for the set of buffers. Returns a broadcast_trivial +-// enum value indicating whether the broadcast is "trivial"--that is, has each buffer being either a +-// singleton or a full-size, C-contiguous (`c_trivial`) or Fortran-contiguous (`f_trivial`) storage +-// buffer; returns `non_trivial` otherwise. +-template +-broadcast_trivial broadcast(const std::array &buffers, ssize_t &ndim, std::vector &shape) { +- ndim = std::accumulate(buffers.begin(), buffers.end(), ssize_t(0), [](ssize_t res, const buffer_info &buf) { +- return std::max(res, buf.ndim); +- }); +- +- shape.clear(); +- shape.resize((size_t) ndim, 1); +- +- // Figure out the output size, and make sure all input arrays conform (i.e. are either size 1 or +- // the full size). +- for (size_t i = 0; i < N; ++i) { +- auto res_iter = shape.rbegin(); +- auto end = buffers[i].shape.rend(); +- for (auto shape_iter = buffers[i].shape.rbegin(); shape_iter != end; ++shape_iter, ++res_iter) { +- const auto &dim_size_in = *shape_iter; +- auto &dim_size_out = *res_iter; +- +- // Each input dimension can either be 1 or `n`, but `n` values must match across buffers +- if (dim_size_out == 1) +- dim_size_out = dim_size_in; +- else if (dim_size_in != 1 && dim_size_in != dim_size_out) +- pybind11_fail("pybind11::vectorize: incompatible size/dimension of inputs!"); +- } +- } +- +- bool trivial_broadcast_c = true; +- bool trivial_broadcast_f = true; +- for (size_t i = 0; i < N && (trivial_broadcast_c || trivial_broadcast_f); ++i) { +- if (buffers[i].size == 1) +- continue; +- +- // Require the same number of dimensions: +- if (buffers[i].ndim != ndim) +- return broadcast_trivial::non_trivial; +- +- // Require all dimensions be full-size: +- if (!std::equal(buffers[i].shape.cbegin(), buffers[i].shape.cend(), shape.cbegin())) +- return broadcast_trivial::non_trivial; +- +- // Check for C contiguity (but only if previous inputs were also C contiguous) +- if (trivial_broadcast_c) { +- ssize_t expect_stride = buffers[i].itemsize; +- auto end = buffers[i].shape.crend(); +- for (auto shape_iter = buffers[i].shape.crbegin(), stride_iter = buffers[i].strides.crbegin(); +- trivial_broadcast_c && shape_iter != end; ++shape_iter, ++stride_iter) { +- if (expect_stride == *stride_iter) +- expect_stride *= *shape_iter; +- else +- trivial_broadcast_c = false; +- } +- } +- +- // Check for Fortran contiguity (if previous inputs were also F contiguous) +- if (trivial_broadcast_f) { +- ssize_t expect_stride = buffers[i].itemsize; +- auto end = buffers[i].shape.cend(); +- for (auto shape_iter = buffers[i].shape.cbegin(), stride_iter = buffers[i].strides.cbegin(); +- trivial_broadcast_f && shape_iter != end; ++shape_iter, ++stride_iter) { +- if (expect_stride == *stride_iter) +- expect_stride *= *shape_iter; +- else +- trivial_broadcast_f = false; +- } +- } +- } +- +- return +- trivial_broadcast_c ? broadcast_trivial::c_trivial : +- trivial_broadcast_f ? broadcast_trivial::f_trivial : +- broadcast_trivial::non_trivial; +-} +- +-template +-struct vectorize_arg { +- static_assert(!std::is_rvalue_reference::value, "Functions with rvalue reference arguments cannot be vectorized"); +- // The wrapped function gets called with this type: +- using call_type = remove_reference_t; +- // Is this a vectorized argument? +- static constexpr bool vectorize = +- satisfies_any_of::value && +- satisfies_none_of::value && +- (!std::is_reference::value || +- (std::is_lvalue_reference::value && std::is_const::value)); +- // Accept this type: an array for vectorized types, otherwise the type as-is: +- using type = conditional_t, array::forcecast>, T>; +-}; +- +- +-// py::vectorize when a return type is present +-template +-struct vectorize_returned_array { +- using Type = array_t; +- +- static Type create(broadcast_trivial trivial, const std::vector &shape) { +- if (trivial == broadcast_trivial::f_trivial) +- return array_t(shape); +- else +- return array_t(shape); +- } +- +- static Return *mutable_data(Type &array) { +- return array.mutable_data(); +- } +- +- static Return call(Func &f, Args &... args) { +- return f(args...); +- } +- +- static void call(Return *out, size_t i, Func &f, Args &... args) { +- out[i] = f(args...); +- } +-}; +- +-// py::vectorize when a return type is not present +-template +-struct vectorize_returned_array { +- using Type = none; +- +- static Type create(broadcast_trivial, const std::vector &) { +- return none(); +- } +- +- static void *mutable_data(Type &) { +- return nullptr; +- } +- +- static detail::void_type call(Func &f, Args &... args) { +- f(args...); +- return {}; +- } +- +- static void call(void *, size_t, Func &f, Args &... args) { +- f(args...); +- } +-}; +- +- +-template +-struct vectorize_helper { +- +-// NVCC for some reason breaks if NVectorized is private +-#ifdef __CUDACC__ +-public: +-#else +-private: +-#endif +- +- static constexpr size_t N = sizeof...(Args); +- static constexpr size_t NVectorized = constexpr_sum(vectorize_arg::vectorize...); +- static_assert(NVectorized >= 1, +- "pybind11::vectorize(...) requires a function with at least one vectorizable argument"); +- +-public: +- template +- explicit vectorize_helper(T &&f) : f(std::forward(f)) { } +- +- object operator()(typename vectorize_arg::type... args) { +- return run(args..., +- make_index_sequence(), +- select_indices::vectorize...>(), +- make_index_sequence()); +- } +- +-private: +- remove_reference_t f; +- +- // Internal compiler error in MSVC 19.16.27025.1 (Visual Studio 2017 15.9.4), when compiling with "/permissive-" flag +- // when arg_call_types is manually inlined. +- using arg_call_types = std::tuple::call_type...>; +- template using param_n_t = typename std::tuple_element::type; +- +- using returned_array = vectorize_returned_array; +- +- // Runs a vectorized function given arguments tuple and three index sequences: +- // - Index is the full set of 0 ... (N-1) argument indices; +- // - VIndex is the subset of argument indices with vectorized parameters, letting us access +- // vectorized arguments (anything not in this sequence is passed through) +- // - BIndex is a incremental sequence (beginning at 0) of the same size as VIndex, so that +- // we can store vectorized buffer_infos in an array (argument VIndex has its buffer at +- // index BIndex in the array). +- template object run( +- typename vectorize_arg::type &...args, +- index_sequence i_seq, index_sequence vi_seq, index_sequence bi_seq) { +- +- // Pointers to values the function was called with; the vectorized ones set here will start +- // out as array_t pointers, but they will be changed them to T pointers before we make +- // call the wrapped function. Non-vectorized pointers are left as-is. +- std::array params{{ &args... }}; +- +- // The array of `buffer_info`s of vectorized arguments: +- std::array buffers{{ reinterpret_cast(params[VIndex])->request()... }}; +- +- /* Determine dimensions parameters of output array */ +- ssize_t nd = 0; +- std::vector shape(0); +- auto trivial = broadcast(buffers, nd, shape); +- auto ndim = (size_t) nd; +- +- size_t size = std::accumulate(shape.begin(), shape.end(), (size_t) 1, std::multiplies()); +- +- // If all arguments are 0-dimension arrays (i.e. single values) return a plain value (i.e. +- // not wrapped in an array). +- if (size == 1 && ndim == 0) { +- PYBIND11_EXPAND_SIDE_EFFECTS(params[VIndex] = buffers[BIndex].ptr); +- return cast(returned_array::call(f, *reinterpret_cast *>(params[Index])...)); +- } +- +- auto result = returned_array::create(trivial, shape); +- +- if (size == 0) return std::move(result); +- +- /* Call the function */ +- auto mutable_data = returned_array::mutable_data(result); +- if (trivial == broadcast_trivial::non_trivial) +- apply_broadcast(buffers, params, mutable_data, size, shape, i_seq, vi_seq, bi_seq); +- else +- apply_trivial(buffers, params, mutable_data, size, i_seq, vi_seq, bi_seq); +- +- return std::move(result); +- } +- +- template +- void apply_trivial(std::array &buffers, +- std::array ¶ms, +- Return *out, +- size_t size, +- index_sequence, index_sequence, index_sequence) { +- +- // Initialize an array of mutable byte references and sizes with references set to the +- // appropriate pointer in `params`; as we iterate, we'll increment each pointer by its size +- // (except for singletons, which get an increment of 0). +- std::array, NVectorized> vecparams{{ +- std::pair( +- reinterpret_cast(params[VIndex] = buffers[BIndex].ptr), +- buffers[BIndex].size == 1 ? 0 : sizeof(param_n_t) +- )... +- }}; +- +- for (size_t i = 0; i < size; ++i) { +- returned_array::call(out, i, f, *reinterpret_cast *>(params[Index])...); +- for (auto &x : vecparams) x.first += x.second; +- } +- } +- +- template +- void apply_broadcast(std::array &buffers, +- std::array ¶ms, +- Return *out, +- size_t size, +- const std::vector &output_shape, +- index_sequence, index_sequence, index_sequence) { +- +- multi_array_iterator input_iter(buffers, output_shape); +- +- for (size_t i = 0; i < size; ++i, ++input_iter) { +- PYBIND11_EXPAND_SIDE_EFFECTS(( +- params[VIndex] = input_iter.template data() +- )); +- returned_array::call(out, i, f, *reinterpret_cast *>(std::get(params))...); +- } +- } +-}; +- +-template +-vectorize_helper +-vectorize_extractor(const Func &f, Return (*) (Args ...)) { +- return detail::vectorize_helper(f); +-} +- +-template struct handle_type_name> { +- static constexpr auto name = _("numpy.ndarray[") + npy_format_descriptor::name + _("]"); +-}; +- +-PYBIND11_NAMESPACE_END(detail) +- +-// Vanilla pointer vectorizer: +-template +-detail::vectorize_helper +-vectorize(Return (*f) (Args ...)) { +- return detail::vectorize_helper(f); +-} +- +-// lambda vectorizer: +-template ::value, int> = 0> +-auto vectorize(Func &&f) -> decltype( +- detail::vectorize_extractor(std::forward(f), (detail::function_signature_t *) nullptr)) { +- return detail::vectorize_extractor(std::forward(f), (detail::function_signature_t *) nullptr); +-} +- +-// Vectorize a class method (non-const): +-template ())), Return, Class *, Args...>> +-Helper vectorize(Return (Class::*f)(Args...)) { +- return Helper(std::mem_fn(f)); +-} +- +-// Vectorize a class method (const): +-template ())), Return, const Class *, Args...>> +-Helper vectorize(Return (Class::*f)(Args...) const) { +- return Helper(std::mem_fn(f)); +-} +- +-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE) +- +-#if defined(_MSC_VER) +-#pragma warning(pop) +-#endif +diff --git a/dune/python/pybind11/operators.h b/dune/python/pybind11/operators.h +deleted file mode 100644 +index 086cb4cfd..000000000 +--- a/dune/python/pybind11/operators.h ++++ /dev/null +@@ -1,173 +0,0 @@ +-/* +- pybind11/operator.h: Metatemplates for operator overloading +- +- Copyright (c) 2016 Wenzel Jakob +- +- All rights reserved. Use of this source code is governed by a +- BSD-style license that can be found in the LICENSE file. +-*/ +- +-#pragma once +- +-#include "pybind11.h" +- +-#if defined(__clang__) && !defined(__INTEL_COMPILER) +-# pragma clang diagnostic ignored "-Wunsequenced" // multiple unsequenced modifications to 'self' (when using def(py::self OP Type())) +-#elif defined(_MSC_VER) +-# pragma warning(push) +-# pragma warning(disable: 4127) // warning C4127: Conditional expression is constant +-#endif +- +-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE) +-PYBIND11_NAMESPACE_BEGIN(detail) +- +-/// Enumeration with all supported operator types +-enum op_id : int { +- op_add, op_sub, op_mul, op_div, op_mod, op_divmod, op_pow, op_lshift, +- op_rshift, op_and, op_xor, op_or, op_neg, op_pos, op_abs, op_invert, +- op_int, op_long, op_float, op_str, op_cmp, op_gt, op_ge, op_lt, op_le, +- op_eq, op_ne, op_iadd, op_isub, op_imul, op_idiv, op_imod, op_ilshift, +- op_irshift, op_iand, op_ixor, op_ior, op_complex, op_bool, op_nonzero, +- op_repr, op_truediv, op_itruediv, op_hash +-}; +- +-enum op_type : int { +- op_l, /* base type on left */ +- op_r, /* base type on right */ +- op_u /* unary operator */ +-}; +- +-struct self_t { }; +-static const self_t self = self_t(); +- +-/// Type for an unused type slot +-struct undefined_t { }; +- +-/// Don't warn about an unused variable +-inline self_t __self() { return self; } +- +-/// base template of operator implementations +-template struct op_impl { }; +- +-/// Operator implementation generator +-template struct op_ { +- template void execute(Class &cl, const Extra&... extra) const { +- using Base = typename Class::type; +- using L_type = conditional_t::value, Base, L>; +- using R_type = conditional_t::value, Base, R>; +- using op = op_impl; +- cl.def(op::name(), &op::execute, is_operator(), extra...); +- #if PY_MAJOR_VERSION < 3 +- if (id == op_truediv || id == op_itruediv) +- cl.def(id == op_itruediv ? "__idiv__" : ot == op_l ? "__div__" : "__rdiv__", +- &op::execute, is_operator(), extra...); +- #endif +- } +- template void execute_cast(Class &cl, const Extra&... extra) const { +- using Base = typename Class::type; +- using L_type = conditional_t::value, Base, L>; +- using R_type = conditional_t::value, Base, R>; +- using op = op_impl; +- cl.def(op::name(), &op::execute_cast, is_operator(), extra...); +- #if PY_MAJOR_VERSION < 3 +- if (id == op_truediv || id == op_itruediv) +- cl.def(id == op_itruediv ? "__idiv__" : ot == op_l ? "__div__" : "__rdiv__", +- &op::execute, is_operator(), extra...); +- #endif +- } +-}; +- +-#define PYBIND11_BINARY_OPERATOR(id, rid, op, expr) \ +-template struct op_impl { \ +- static char const* name() { return "__" #id "__"; } \ +- static auto execute(const L &l, const R &r) -> decltype(expr) { return (expr); } \ +- static B execute_cast(const L &l, const R &r) { return B(expr); } \ +-}; \ +-template struct op_impl { \ +- static char const* name() { return "__" #rid "__"; } \ +- static auto execute(const R &r, const L &l) -> decltype(expr) { return (expr); } \ +- static B execute_cast(const R &r, const L &l) { return B(expr); } \ +-}; \ +-inline op_ op(const self_t &, const self_t &) { \ +- return op_(); \ +-} \ +-template op_ op(const self_t &, const T &) { \ +- return op_(); \ +-} \ +-template op_ op(const T &, const self_t &) { \ +- return op_(); \ +-} +- +-#define PYBIND11_INPLACE_OPERATOR(id, op, expr) \ +-template struct op_impl { \ +- static char const* name() { return "__" #id "__"; } \ +- static auto execute(L &l, const R &r) -> decltype(expr) { return expr; } \ +- static B execute_cast(L &l, const R &r) { return B(expr); } \ +-}; \ +-template op_ op(const self_t &, const T &) { \ +- return op_(); \ +-} +- +-#define PYBIND11_UNARY_OPERATOR(id, op, expr) \ +-template struct op_impl { \ +- static char const* name() { return "__" #id "__"; } \ +- static auto execute(const L &l) -> decltype(expr) { return expr; } \ +- static B execute_cast(const L &l) { return B(expr); } \ +-}; \ +-inline op_ op(const self_t &) { \ +- return op_(); \ +-} +- +-PYBIND11_BINARY_OPERATOR(sub, rsub, operator-, l - r) +-PYBIND11_BINARY_OPERATOR(add, radd, operator+, l + r) +-PYBIND11_BINARY_OPERATOR(mul, rmul, operator*, l * r) +-PYBIND11_BINARY_OPERATOR(truediv, rtruediv, operator/, l / r) +-PYBIND11_BINARY_OPERATOR(mod, rmod, operator%, l % r) +-PYBIND11_BINARY_OPERATOR(lshift, rlshift, operator<<, l << r) +-PYBIND11_BINARY_OPERATOR(rshift, rrshift, operator>>, l >> r) +-PYBIND11_BINARY_OPERATOR(and, rand, operator&, l & r) +-PYBIND11_BINARY_OPERATOR(xor, rxor, operator^, l ^ r) +-PYBIND11_BINARY_OPERATOR(eq, eq, operator==, l == r) +-PYBIND11_BINARY_OPERATOR(ne, ne, operator!=, l != r) +-PYBIND11_BINARY_OPERATOR(or, ror, operator|, l | r) +-PYBIND11_BINARY_OPERATOR(gt, lt, operator>, l > r) +-PYBIND11_BINARY_OPERATOR(ge, le, operator>=, l >= r) +-PYBIND11_BINARY_OPERATOR(lt, gt, operator<, l < r) +-PYBIND11_BINARY_OPERATOR(le, ge, operator<=, l <= r) +-//PYBIND11_BINARY_OPERATOR(pow, rpow, pow, std::pow(l, r)) +-PYBIND11_INPLACE_OPERATOR(iadd, operator+=, l += r) +-PYBIND11_INPLACE_OPERATOR(isub, operator-=, l -= r) +-PYBIND11_INPLACE_OPERATOR(imul, operator*=, l *= r) +-PYBIND11_INPLACE_OPERATOR(itruediv, operator/=, l /= r) +-PYBIND11_INPLACE_OPERATOR(imod, operator%=, l %= r) +-PYBIND11_INPLACE_OPERATOR(ilshift, operator<<=, l <<= r) +-PYBIND11_INPLACE_OPERATOR(irshift, operator>>=, l >>= r) +-PYBIND11_INPLACE_OPERATOR(iand, operator&=, l &= r) +-PYBIND11_INPLACE_OPERATOR(ixor, operator^=, l ^= r) +-PYBIND11_INPLACE_OPERATOR(ior, operator|=, l |= r) +-PYBIND11_UNARY_OPERATOR(neg, operator-, -l) +-PYBIND11_UNARY_OPERATOR(pos, operator+, +l) +-// WARNING: This usage of `abs` should only be done for existing STL overloads. +-// Adding overloads directly in to the `std::` namespace is advised against: +-// https://en.cppreference.com/w/cpp/language/extending_std +-PYBIND11_UNARY_OPERATOR(abs, abs, std::abs(l)) +-PYBIND11_UNARY_OPERATOR(hash, hash, std::hash()(l)) +-PYBIND11_UNARY_OPERATOR(invert, operator~, (~l)) +-PYBIND11_UNARY_OPERATOR(bool, operator!, !!l) +-PYBIND11_UNARY_OPERATOR(int, int_, (int) l) +-PYBIND11_UNARY_OPERATOR(float, float_, (double) l) +- +-#undef PYBIND11_BINARY_OPERATOR +-#undef PYBIND11_INPLACE_OPERATOR +-#undef PYBIND11_UNARY_OPERATOR +-PYBIND11_NAMESPACE_END(detail) +- +-using detail::self; +-// Add named operators so that they are accessible via `py::`. +-using detail::hash; +- +-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE) +- +-#if defined(_MSC_VER) +-# pragma warning(pop) +-#endif +diff --git a/dune/python/pybind11/options.h b/dune/python/pybind11/options.h +deleted file mode 100644 +index d74db1c68..000000000 +--- a/dune/python/pybind11/options.h ++++ /dev/null +@@ -1,65 +0,0 @@ +-/* +- pybind11/options.h: global settings that are configurable at runtime. +- +- Copyright (c) 2016 Wenzel Jakob +- +- All rights reserved. Use of this source code is governed by a +- BSD-style license that can be found in the LICENSE file. +-*/ +- +-#pragma once +- +-#include "detail/common.h" +- +-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE) +- +-class options { +-public: +- +- // Default RAII constructor, which leaves settings as they currently are. +- options() : previous_state(global_state()) {} +- +- // Class is non-copyable. +- options(const options&) = delete; +- options& operator=(const options&) = delete; +- +- // Destructor, which restores settings that were in effect before. +- ~options() { +- global_state() = previous_state; +- } +- +- // Setter methods (affect the global state): +- +- options& disable_user_defined_docstrings() & { global_state().show_user_defined_docstrings = false; return *this; } +- +- options& enable_user_defined_docstrings() & { global_state().show_user_defined_docstrings = true; return *this; } +- +- options& disable_function_signatures() & { global_state().show_function_signatures = false; return *this; } +- +- options& enable_function_signatures() & { global_state().show_function_signatures = true; return *this; } +- +- // Getter methods (return the global state): +- +- static bool show_user_defined_docstrings() { return global_state().show_user_defined_docstrings; } +- +- static bool show_function_signatures() { return global_state().show_function_signatures; } +- +- // This type is not meant to be allocated on the heap. +- void* operator new(size_t) = delete; +- +-private: +- +- struct state { +- bool show_user_defined_docstrings = true; //< Include user-supplied texts in docstrings. +- bool show_function_signatures = true; //< Include auto-generated function signatures in docstrings. +- }; +- +- static state &global_state() { +- static state instance; +- return instance; +- } +- +- state previous_state; +-}; +- +-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE) +diff --git a/dune/python/pybind11/pybind11.h b/dune/python/pybind11/pybind11.h +deleted file mode 100644 +index e2ddda020..000000000 +--- a/dune/python/pybind11/pybind11.h ++++ /dev/null +@@ -1,2378 +0,0 @@ +-/* +- pybind11/pybind11.h: Main header file of the C++11 python +- binding generator library +- +- Copyright (c) 2016 Wenzel Jakob +- +- All rights reserved. Use of this source code is governed by a +- BSD-style license that can be found in the LICENSE file. +-*/ +- +-#pragma once +- +-#if defined(__INTEL_COMPILER) +-# pragma warning push +-# pragma warning disable 68 // integer conversion resulted in a change of sign +-# pragma warning disable 186 // pointless comparison of unsigned integer with zero +-# pragma warning disable 878 // incompatible exception specifications +-# pragma warning disable 1334 // the "template" keyword used for syntactic disambiguation may only be used within a template +-# pragma warning disable 1682 // implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem) +-# pragma warning disable 1786 // function "strdup" was declared deprecated +-# pragma warning disable 1875 // offsetof applied to non-POD (Plain Old Data) types is nonstandard +-# pragma warning disable 2196 // warning #2196: routine is both "inline" and "noinline" +-#elif defined(_MSC_VER) +-# pragma warning(push) +-# pragma warning(disable: 4100) // warning C4100: Unreferenced formal parameter +-# pragma warning(disable: 4127) // warning C4127: Conditional expression is constant +-# pragma warning(disable: 4512) // warning C4512: Assignment operator was implicitly defined as deleted +-# pragma warning(disable: 4800) // warning C4800: 'int': forcing value to bool 'true' or 'false' (performance warning) +-# pragma warning(disable: 4996) // warning C4996: The POSIX name for this item is deprecated. Instead, use the ISO C and C++ conformant name +-# pragma warning(disable: 4702) // warning C4702: unreachable code +-# pragma warning(disable: 4522) // warning C4522: multiple assignment operators specified +-# pragma warning(disable: 4505) // warning C4505: 'PySlice_GetIndicesEx': unreferenced local function has been removed (PyPy only) +-#elif defined(__GNUG__) && !defined(__clang__) +-# pragma GCC diagnostic push +-# pragma GCC diagnostic ignored "-Wunused-but-set-parameter" +-# pragma GCC diagnostic ignored "-Wunused-but-set-variable" +-# pragma GCC diagnostic ignored "-Wmissing-field-initializers" +-# pragma GCC diagnostic ignored "-Wstrict-aliasing" +-# pragma GCC diagnostic ignored "-Wattributes" +-# if __GNUC__ >= 7 +-# pragma GCC diagnostic ignored "-Wnoexcept-type" +-# endif +-#endif +- +-#include "attr.h" +-#include "options.h" +-#include "detail/class.h" +-#include "detail/init.h" +- +-#include +-#include +-#include +-#include +- +-#if defined(__GNUG__) && !defined(__clang__) +-# include +-#endif +- +-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE) +- +-/// Wraps an arbitrary C++ function/method/lambda function/.. into a callable Python object +-class cpp_function : public function { +-public: +- cpp_function() = default; +- cpp_function(std::nullptr_t) { } +- +- /// Construct a cpp_function from a vanilla function pointer +- template +- cpp_function(Return (*f)(Args...), const Extra&... extra) { +- initialize(f, f, extra...); +- } +- +- /// Construct a cpp_function from a lambda function (possibly with internal state) +- template ::value>> +- cpp_function(Func &&f, const Extra&... extra) { +- initialize(std::forward(f), +- (detail::function_signature_t *) nullptr, extra...); +- } +- +- /// Construct a cpp_function from a class method (non-const, no ref-qualifier) +- template +- cpp_function(Return (Class::*f)(Arg...), const Extra&... extra) { +- initialize([f](Class *c, Arg... args) -> Return { return (c->*f)(std::forward(args)...); }, +- (Return (*) (Class *, Arg...)) nullptr, extra...); +- } +- +- /// Construct a cpp_function from a class method (non-const, lvalue ref-qualifier) +- /// A copy of the overload for non-const functions without explicit ref-qualifier +- /// but with an added `&`. +- template +- cpp_function(Return (Class::*f)(Arg...)&, const Extra&... extra) { +- initialize([f](Class *c, Arg... args) -> Return { return (c->*f)(args...); }, +- (Return (*) (Class *, Arg...)) nullptr, extra...); +- } +- +- /// Construct a cpp_function from a class method (const, no ref-qualifier) +- template +- cpp_function(Return (Class::*f)(Arg...) const, const Extra&... extra) { +- initialize([f](const Class *c, Arg... args) -> Return { return (c->*f)(std::forward(args)...); }, +- (Return (*)(const Class *, Arg ...)) nullptr, extra...); +- } +- +- /// Construct a cpp_function from a class method (const, lvalue ref-qualifier) +- /// A copy of the overload for const functions without explicit ref-qualifier +- /// but with an added `&`. +- template +- cpp_function(Return (Class::*f)(Arg...) const&, const Extra&... extra) { +- initialize([f](const Class *c, Arg... args) -> Return { return (c->*f)(args...); }, +- (Return (*)(const Class *, Arg ...)) nullptr, extra...); +- } +- +- /// Return the function name +- object name() const { return attr("__name__"); } +- +-protected: +- /// Space optimization: don't inline this frequently instantiated fragment +- PYBIND11_NOINLINE detail::function_record *make_function_record() { +- return new detail::function_record(); +- } +- +- /// Special internal constructor for functors, lambda functions, etc. +- template +- void initialize(Func &&f, Return (*)(Args...), const Extra&... extra) { +- using namespace detail; +- struct capture { remove_reference_t f; }; +- +- /* Store the function including any extra state it might have (e.g. a lambda capture object) */ +- auto rec = make_function_record(); +- +- /* Store the capture object directly in the function record if there is enough space */ +- if (sizeof(capture) <= sizeof(rec->data)) { +- /* Without these pragmas, GCC warns that there might not be +- enough space to use the placement new operator. However, the +- 'if' statement above ensures that this is the case. */ +-#if defined(__GNUG__) && !defined(__clang__) && __GNUC__ >= 6 +-# pragma GCC diagnostic push +-# pragma GCC diagnostic ignored "-Wplacement-new" +-#endif +- new ((capture *) &rec->data) capture { std::forward(f) }; +-#if defined(__GNUG__) && !defined(__clang__) && __GNUC__ >= 6 +-# pragma GCC diagnostic pop +-#endif +- if (!std::is_trivially_destructible::value) +- rec->free_data = [](function_record *r) { ((capture *) &r->data)->~capture(); }; +- } else { +- rec->data[0] = new capture { std::forward(f) }; +- rec->free_data = [](function_record *r) { delete ((capture *) r->data[0]); }; +- } +- +- /* Type casters for the function arguments and return value */ +- using cast_in = argument_loader; +- using cast_out = make_caster< +- conditional_t::value, void_type, Return> +- >; +- +- static_assert(expected_num_args(sizeof...(Args), cast_in::has_args, cast_in::has_kwargs), +- "The number of argument annotations does not match the number of function arguments"); +- +- /* Dispatch code which converts function arguments and performs the actual function call */ +- rec->impl = [](function_call &call) -> handle { +- cast_in args_converter; +- +- /* Try to cast the function arguments into the C++ domain */ +- if (!args_converter.load_args(call)) +- return PYBIND11_TRY_NEXT_OVERLOAD; +- +- /* Invoke call policy pre-call hook */ +- process_attributes::precall(call); +- +- /* Get a pointer to the capture object */ +- auto data = (sizeof(capture) <= sizeof(call.func.data) +- ? &call.func.data : call.func.data[0]); +- auto *cap = const_cast(reinterpret_cast(data)); +- +- /* Override policy for rvalues -- usually to enforce rvp::move on an rvalue */ +- return_value_policy policy = return_value_policy_override::policy(call.func.policy); +- +- /* Function scope guard -- defaults to the compile-to-nothing `void_type` */ +- using Guard = extract_guard_t; +- +- /* Perform the function call */ +- handle result = cast_out::cast( +- std::move(args_converter).template call(cap->f), policy, call.parent); +- +- /* Invoke call policy post-call hook */ +- process_attributes::postcall(call, result); +- +- return result; +- }; +- +- /* Process any user-provided function attributes */ +- process_attributes::init(extra..., rec); +- +- { +- constexpr bool has_kw_only_args = any_of...>::value, +- has_pos_only_args = any_of...>::value, +- has_args = any_of...>::value, +- has_arg_annotations = any_of...>::value; +- static_assert(has_arg_annotations || !has_kw_only_args, "py::kw_only requires the use of argument annotations"); +- static_assert(has_arg_annotations || !has_pos_only_args, "py::pos_only requires the use of argument annotations (for docstrings and aligning the annotations to the argument)"); +- static_assert(!(has_args && has_kw_only_args), "py::kw_only cannot be combined with a py::args argument"); +- } +- +- /* Generate a readable signature describing the function's arguments and return value types */ +- static constexpr auto signature = _("(") + cast_in::arg_names + _(") -> ") + cast_out::name; +- PYBIND11_DESCR_CONSTEXPR auto types = decltype(signature)::types(); +- +- /* Register the function with Python from generic (non-templated) code */ +- initialize_generic(rec, signature.text, types.data(), sizeof...(Args)); +- +- if (cast_in::has_args) rec->has_args = true; +- if (cast_in::has_kwargs) rec->has_kwargs = true; +- +- /* Stash some additional information used by an important optimization in 'functional.h' */ +- using FunctionType = Return (*)(Args...); +- constexpr bool is_function_ptr = +- std::is_convertible::value && +- sizeof(capture) == sizeof(void *); +- if (is_function_ptr) { +- rec->is_stateless = true; +- rec->data[1] = const_cast(reinterpret_cast(&typeid(FunctionType))); +- } +- } +- +- /// Register a function call with Python (generic non-templated code goes here) +- void initialize_generic(detail::function_record *rec, const char *text, +- const std::type_info *const *types, size_t args) { +- +- /* Create copies of all referenced C-style strings */ +- rec->name = strdup(rec->name ? rec->name : ""); +- if (rec->doc) rec->doc = strdup(rec->doc); +- for (auto &a: rec->args) { +- if (a.name) +- a.name = strdup(a.name); +- if (a.descr) +- a.descr = strdup(a.descr); +- else if (a.value) +- a.descr = strdup(repr(a.value).cast().c_str()); +- } +- +- rec->is_constructor = !strcmp(rec->name, "__init__") || !strcmp(rec->name, "__setstate__"); +- +-#if !defined(NDEBUG) && !defined(PYBIND11_DISABLE_NEW_STYLE_INIT_WARNING) +- if (rec->is_constructor && !rec->is_new_style_constructor) { +- const auto class_name = detail::get_fully_qualified_tp_name((PyTypeObject *) rec->scope.ptr()); +- const auto func_name = std::string(rec->name); +- PyErr_WarnEx( +- PyExc_FutureWarning, +- ("pybind11-bound class '" + class_name + "' is using an old-style " +- "placement-new '" + func_name + "' which has been deprecated. See " +- "the upgrade guide in pybind11's docs. This message is only visible " +- "when compiled in debug mode.").c_str(), 0 +- ); +- } +-#endif +- +- /* Generate a proper function signature */ +- std::string signature; +- size_t type_index = 0, arg_index = 0; +- for (auto *pc = text; *pc != '\0'; ++pc) { +- const auto c = *pc; +- +- if (c == '{') { +- // Write arg name for everything except *args and **kwargs. +- if (*(pc + 1) == '*') +- continue; +- // Separator for keyword-only arguments, placed before the kw +- // arguments start +- if (rec->nargs_kw_only > 0 && arg_index + rec->nargs_kw_only == args) +- signature += "*, "; +- if (arg_index < rec->args.size() && rec->args[arg_index].name) { +- signature += rec->args[arg_index].name; +- } else if (arg_index == 0 && rec->is_method) { +- signature += "self"; +- } else { +- signature += "arg" + std::to_string(arg_index - (rec->is_method ? 1 : 0)); +- } +- signature += ": "; +- } else if (c == '}') { +- // Write default value if available. +- if (arg_index < rec->args.size() && rec->args[arg_index].descr) { +- signature += " = "; +- signature += rec->args[arg_index].descr; +- } +- // Separator for positional-only arguments (placed after the +- // argument, rather than before like * +- if (rec->nargs_pos_only > 0 && (arg_index + 1) == rec->nargs_pos_only) +- signature += ", /"; +- arg_index++; +- } else if (c == '%') { +- const std::type_info *t = types[type_index++]; +- if (!t) +- pybind11_fail("Internal error while parsing type signature (1)"); +- if (auto tinfo = detail::get_type_info(*t)) { +- handle th((PyObject *) tinfo->type); +- signature += +- th.attr("__module__").cast() + "." + +- th.attr("__qualname__").cast(); // Python 3.3+, but we backport it to earlier versions +- } else if (rec->is_new_style_constructor && arg_index == 0) { +- // A new-style `__init__` takes `self` as `value_and_holder`. +- // Rewrite it to the proper class type. +- signature += +- rec->scope.attr("__module__").cast() + "." + +- rec->scope.attr("__qualname__").cast(); +- } else { +- std::string tname(t->name()); +- detail::clean_type_id(tname); +- signature += tname; +- } +- } else { +- signature += c; +- } +- } +- +- if (arg_index != args || types[type_index] != nullptr) +- pybind11_fail("Internal error while parsing type signature (2)"); +- +-#if PY_MAJOR_VERSION < 3 +- if (strcmp(rec->name, "__next__") == 0) { +- std::free(rec->name); +- rec->name = strdup("next"); +- } else if (strcmp(rec->name, "__bool__") == 0) { +- std::free(rec->name); +- rec->name = strdup("__nonzero__"); +- } +-#endif +- rec->signature = strdup(signature.c_str()); +- rec->args.shrink_to_fit(); +- rec->nargs = (std::uint16_t) args; +- +- if (rec->sibling && PYBIND11_INSTANCE_METHOD_CHECK(rec->sibling.ptr())) +- rec->sibling = PYBIND11_INSTANCE_METHOD_GET_FUNCTION(rec->sibling.ptr()); +- +- detail::function_record *chain = nullptr, *chain_start = rec; +- if (rec->sibling) { +- if (PyCFunction_Check(rec->sibling.ptr())) { +- auto rec_capsule = reinterpret_borrow(PyCFunction_GET_SELF(rec->sibling.ptr())); +- chain = (detail::function_record *) rec_capsule; +- /* Never append a method to an overload chain of a parent class; +- instead, hide the parent's overloads in this case */ +- if (!chain->scope.is(rec->scope)) +- chain = nullptr; +- } +- // Don't trigger for things like the default __init__, which are wrapper_descriptors that we are intentionally replacing +- else if (!rec->sibling.is_none() && rec->name[0] != '_') +- pybind11_fail("Cannot overload existing non-function object \"" + std::string(rec->name) + +- "\" with a function of the same name"); +- } +- +- if (!chain) { +- /* No existing overload was found, create a new function object */ +- rec->def = new PyMethodDef(); +- std::memset(rec->def, 0, sizeof(PyMethodDef)); +- rec->def->ml_name = rec->name; +- rec->def->ml_meth = reinterpret_cast(reinterpret_cast(*dispatcher)); +- rec->def->ml_flags = METH_VARARGS | METH_KEYWORDS; +- +- capsule rec_capsule(rec, [](void *ptr) { +- destruct((detail::function_record *) ptr); +- }); +- +- object scope_module; +- if (rec->scope) { +- if (hasattr(rec->scope, "__module__")) { +- scope_module = rec->scope.attr("__module__"); +- } else if (hasattr(rec->scope, "__name__")) { +- scope_module = rec->scope.attr("__name__"); +- } +- } +- +- m_ptr = PyCFunction_NewEx(rec->def, rec_capsule.ptr(), scope_module.ptr()); +- if (!m_ptr) +- pybind11_fail("cpp_function::cpp_function(): Could not allocate function object"); +- } else { +- /* Append at the beginning or end of the overload chain */ +- m_ptr = rec->sibling.ptr(); +- inc_ref(); +- if (chain->is_method != rec->is_method) +- pybind11_fail("overloading a method with both static and instance methods is not supported; " +- #if defined(NDEBUG) +- "compile in debug mode for more details" +- #else +- "error while attempting to bind " + std::string(rec->is_method ? "instance" : "static") + " method " + +- std::string(pybind11::str(rec->scope.attr("__name__"))) + "." + std::string(rec->name) + signature +- #endif +- ); +- +- if (rec->prepend) { +- // Beginning of chain; we need to replace the capsule's current head-of-the-chain +- // pointer with this one, then make this one point to the previous head of the +- // chain. +- chain_start = rec; +- rec->next = chain; +- auto rec_capsule = reinterpret_borrow(((PyCFunctionObject *) m_ptr)->m_self); +- rec_capsule.set_pointer(rec); +- } else { +- // Or end of chain (normal behavior) +- chain_start = chain; +- while (chain->next) +- chain = chain->next; +- chain->next = rec; +- } +- } +- +- std::string signatures; +- int index = 0; +- /* Create a nice pydoc rec including all signatures and +- docstrings of the functions in the overload chain */ +- if (chain && options::show_function_signatures()) { +- // First a generic signature +- signatures += rec->name; +- signatures += "(*args, **kwargs)\n"; +- signatures += "Overloaded function.\n\n"; +- } +- // Then specific overload signatures +- bool first_user_def = true; +- for (auto it = chain_start; it != nullptr; it = it->next) { +- if (options::show_function_signatures()) { +- if (index > 0) signatures += "\n"; +- if (chain) +- signatures += std::to_string(++index) + ". "; +- signatures += rec->name; +- signatures += it->signature; +- signatures += "\n"; +- } +- if (it->doc && strlen(it->doc) > 0 && options::show_user_defined_docstrings()) { +- // If we're appending another docstring, and aren't printing function signatures, we +- // need to append a newline first: +- if (!options::show_function_signatures()) { +- if (first_user_def) first_user_def = false; +- else signatures += "\n"; +- } +- if (options::show_function_signatures()) signatures += "\n"; +- signatures += it->doc; +- if (options::show_function_signatures()) signatures += "\n"; +- } +- } +- +- /* Install docstring */ +- auto *func = (PyCFunctionObject *) m_ptr; +- if (func->m_ml->ml_doc) +- std::free(const_cast(func->m_ml->ml_doc)); +- func->m_ml->ml_doc = strdup(signatures.c_str()); +- +- if (rec->is_method) { +- m_ptr = PYBIND11_INSTANCE_METHOD_NEW(m_ptr, rec->scope.ptr()); +- if (!m_ptr) +- pybind11_fail("cpp_function::cpp_function(): Could not allocate instance method object"); +- Py_DECREF(func); +- } +- } +- +- /// When a cpp_function is GCed, release any memory allocated by pybind11 +- static void destruct(detail::function_record *rec) { +- // If on Python 3.9, check the interpreter "MICRO" (patch) version. +- // If this is running on 3.9.0, we have to work around a bug. +- #if !defined(PYPY_VERSION) && PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION == 9 +- static bool is_zero = Py_GetVersion()[4] == '0'; +- #endif +- +- while (rec) { +- detail::function_record *next = rec->next; +- if (rec->free_data) +- rec->free_data(rec); +- std::free((char *) rec->name); +- std::free((char *) rec->doc); +- std::free((char *) rec->signature); +- for (auto &arg: rec->args) { +- std::free(const_cast(arg.name)); +- std::free(const_cast(arg.descr)); +- arg.value.dec_ref(); +- } +- if (rec->def) { +- std::free(const_cast(rec->def->ml_doc)); +- // Python 3.9.0 decref's these in the wrong order; rec->def +- // If loaded on 3.9.0, let these leak (use Python 3.9.1 at runtime to fix) +- // See https://github.com/python/cpython/pull/22670 +- #if !defined(PYPY_VERSION) && PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION == 9 +- if (!is_zero) +- delete rec->def; +- #else +- delete rec->def; +- #endif +- } +- delete rec; +- rec = next; +- } +- } +- +- /// Main dispatch logic for calls to functions bound using pybind11 +- static PyObject *dispatcher(PyObject *self, PyObject *args_in, PyObject *kwargs_in) { +- using namespace detail; +- +- /* Iterator over the list of potentially admissible overloads */ +- const function_record *overloads = (function_record *) PyCapsule_GetPointer(self, nullptr), +- *it = overloads; +- +- /* Need to know how many arguments + keyword arguments there are to pick the right overload */ +- const auto n_args_in = (size_t) PyTuple_GET_SIZE(args_in); +- +- handle parent = n_args_in > 0 ? PyTuple_GET_ITEM(args_in, 0) : nullptr, +- result = PYBIND11_TRY_NEXT_OVERLOAD; +- +- auto self_value_and_holder = value_and_holder(); +- if (overloads->is_constructor) { +- const auto tinfo = get_type_info((PyTypeObject *) overloads->scope.ptr()); +- const auto pi = reinterpret_cast(parent.ptr()); +- self_value_and_holder = pi->get_value_and_holder(tinfo, false); +- +- if (!self_value_and_holder.type || !self_value_and_holder.inst) { +- PyErr_SetString(PyExc_TypeError, "__init__(self, ...) called with invalid `self` argument"); +- return nullptr; +- } +- +- // If this value is already registered it must mean __init__ is invoked multiple times; +- // we really can't support that in C++, so just ignore the second __init__. +- if (self_value_and_holder.instance_registered()) +- return none().release().ptr(); +- } +- +- try { +- // We do this in two passes: in the first pass, we load arguments with `convert=false`; +- // in the second, we allow conversion (except for arguments with an explicit +- // py::arg().noconvert()). This lets us prefer calls without conversion, with +- // conversion as a fallback. +- std::vector second_pass; +- +- // However, if there are no overloads, we can just skip the no-convert pass entirely +- const bool overloaded = it != nullptr && it->next != nullptr; +- +- for (; it != nullptr; it = it->next) { +- +- /* For each overload: +- 1. Copy all positional arguments we were given, also checking to make sure that +- named positional arguments weren't *also* specified via kwarg. +- 2. If we weren't given enough, try to make up the omitted ones by checking +- whether they were provided by a kwarg matching the `py::arg("name")` name. If +- so, use it (and remove it from kwargs; if not, see if the function binding +- provided a default that we can use. +- 3. Ensure that either all keyword arguments were "consumed", or that the function +- takes a kwargs argument to accept unconsumed kwargs. +- 4. Any positional arguments still left get put into a tuple (for args), and any +- leftover kwargs get put into a dict. +- 5. Pack everything into a vector; if we have py::args or py::kwargs, they are an +- extra tuple or dict at the end of the positional arguments. +- 6. Call the function call dispatcher (function_record::impl) +- +- If one of these fail, move on to the next overload and keep trying until we get a +- result other than PYBIND11_TRY_NEXT_OVERLOAD. +- */ +- +- const function_record &func = *it; +- size_t num_args = func.nargs; // Number of positional arguments that we need +- if (func.has_args) --num_args; // (but don't count py::args +- if (func.has_kwargs) --num_args; // or py::kwargs) +- size_t pos_args = num_args - func.nargs_kw_only; +- +- if (!func.has_args && n_args_in > pos_args) +- continue; // Too many positional arguments for this overload +- +- if (n_args_in < pos_args && func.args.size() < pos_args) +- continue; // Not enough positional arguments given, and not enough defaults to fill in the blanks +- +- function_call call(func, parent); +- +- size_t args_to_copy = (std::min)(pos_args, n_args_in); // Protect std::min with parentheses +- size_t args_copied = 0; +- +- // 0. Inject new-style `self` argument +- if (func.is_new_style_constructor) { +- // The `value` may have been preallocated by an old-style `__init__` +- // if it was a preceding candidate for overload resolution. +- if (self_value_and_holder) +- self_value_and_holder.type->dealloc(self_value_and_holder); +- +- call.init_self = PyTuple_GET_ITEM(args_in, 0); +- call.args.emplace_back(reinterpret_cast(&self_value_and_holder)); +- call.args_convert.push_back(false); +- ++args_copied; +- } +- +- // 1. Copy any position arguments given. +- bool bad_arg = false; +- for (; args_copied < args_to_copy; ++args_copied) { +- const argument_record *arg_rec = args_copied < func.args.size() ? &func.args[args_copied] : nullptr; +- if (kwargs_in && arg_rec && arg_rec->name && PyDict_GetItemString(kwargs_in, arg_rec->name)) { +- bad_arg = true; +- break; +- } +- +- handle arg(PyTuple_GET_ITEM(args_in, args_copied)); +- if (arg_rec && !arg_rec->none && arg.is_none()) { +- bad_arg = true; +- break; +- } +- call.args.push_back(arg); +- call.args_convert.push_back(arg_rec ? arg_rec->convert : true); +- } +- if (bad_arg) +- continue; // Maybe it was meant for another overload (issue #688) +- +- // We'll need to copy this if we steal some kwargs for defaults +- dict kwargs = reinterpret_borrow(kwargs_in); +- +- // 1.5. Fill in any missing pos_only args from defaults if they exist +- if (args_copied < func.nargs_pos_only) { +- for (; args_copied < func.nargs_pos_only; ++args_copied) { +- const auto &arg_rec = func.args[args_copied]; +- handle value; +- +- if (arg_rec.value) { +- value = arg_rec.value; +- } +- if (value) { +- call.args.push_back(value); +- call.args_convert.push_back(arg_rec.convert); +- } else +- break; +- } +- +- if (args_copied < func.nargs_pos_only) +- continue; // Not enough defaults to fill the positional arguments +- } +- +- // 2. Check kwargs and, failing that, defaults that may help complete the list +- if (args_copied < num_args) { +- bool copied_kwargs = false; +- +- for (; args_copied < num_args; ++args_copied) { +- const auto &arg_rec = func.args[args_copied]; +- +- handle value; +- if (kwargs_in && arg_rec.name) +- value = PyDict_GetItemString(kwargs.ptr(), arg_rec.name); +- +- if (value) { +- // Consume a kwargs value +- if (!copied_kwargs) { +- kwargs = reinterpret_steal(PyDict_Copy(kwargs.ptr())); +- copied_kwargs = true; +- } +- PyDict_DelItemString(kwargs.ptr(), arg_rec.name); +- } else if (arg_rec.value) { +- value = arg_rec.value; +- } +- +- if (!arg_rec.none && value.is_none()) { +- break; +- } +- +- if (value) { +- call.args.push_back(value); +- call.args_convert.push_back(arg_rec.convert); +- } +- else +- break; +- } +- +- if (args_copied < num_args) +- continue; // Not enough arguments, defaults, or kwargs to fill the positional arguments +- } +- +- // 3. Check everything was consumed (unless we have a kwargs arg) +- if (kwargs && !kwargs.empty() && !func.has_kwargs) +- continue; // Unconsumed kwargs, but no py::kwargs argument to accept them +- +- // 4a. If we have a py::args argument, create a new tuple with leftovers +- if (func.has_args) { +- tuple extra_args; +- if (args_to_copy == 0) { +- // We didn't copy out any position arguments from the args_in tuple, so we +- // can reuse it directly without copying: +- extra_args = reinterpret_borrow(args_in); +- } else if (args_copied >= n_args_in) { +- extra_args = tuple(0); +- } else { +- size_t args_size = n_args_in - args_copied; +- extra_args = tuple(args_size); +- for (size_t i = 0; i < args_size; ++i) { +- extra_args[i] = PyTuple_GET_ITEM(args_in, args_copied + i); +- } +- } +- call.args.push_back(extra_args); +- call.args_convert.push_back(false); +- call.args_ref = std::move(extra_args); +- } +- +- // 4b. If we have a py::kwargs, pass on any remaining kwargs +- if (func.has_kwargs) { +- if (!kwargs.ptr()) +- kwargs = dict(); // If we didn't get one, send an empty one +- call.args.push_back(kwargs); +- call.args_convert.push_back(false); +- call.kwargs_ref = std::move(kwargs); +- } +- +- // 5. Put everything in a vector. Not technically step 5, we've been building it +- // in `call.args` all along. +- #if !defined(NDEBUG) +- if (call.args.size() != func.nargs || call.args_convert.size() != func.nargs) +- pybind11_fail("Internal error: function call dispatcher inserted wrong number of arguments!"); +- #endif +- +- std::vector second_pass_convert; +- if (overloaded) { +- // We're in the first no-convert pass, so swap out the conversion flags for a +- // set of all-false flags. If the call fails, we'll swap the flags back in for +- // the conversion-allowed call below. +- second_pass_convert.resize(func.nargs, false); +- call.args_convert.swap(second_pass_convert); +- } +- +- // 6. Call the function. +- try { +- loader_life_support guard{}; +- result = func.impl(call); +- } catch (reference_cast_error &) { +- result = PYBIND11_TRY_NEXT_OVERLOAD; +- } +- +- if (result.ptr() != PYBIND11_TRY_NEXT_OVERLOAD) +- break; +- +- if (overloaded) { +- // The (overloaded) call failed; if the call has at least one argument that +- // permits conversion (i.e. it hasn't been explicitly specified `.noconvert()`) +- // then add this call to the list of second pass overloads to try. +- for (size_t i = func.is_method ? 1 : 0; i < pos_args; i++) { +- if (second_pass_convert[i]) { +- // Found one: swap the converting flags back in and store the call for +- // the second pass. +- call.args_convert.swap(second_pass_convert); +- second_pass.push_back(std::move(call)); +- break; +- } +- } +- } +- } +- +- if (overloaded && !second_pass.empty() && result.ptr() == PYBIND11_TRY_NEXT_OVERLOAD) { +- // The no-conversion pass finished without success, try again with conversion allowed +- for (auto &call : second_pass) { +- try { +- loader_life_support guard{}; +- result = call.func.impl(call); +- } catch (reference_cast_error &) { +- result = PYBIND11_TRY_NEXT_OVERLOAD; +- } +- +- if (result.ptr() != PYBIND11_TRY_NEXT_OVERLOAD) { +- // The error reporting logic below expects 'it' to be valid, as it would be +- // if we'd encountered this failure in the first-pass loop. +- if (!result) +- it = &call.func; +- break; +- } +- } +- } +- } catch (error_already_set &e) { +- e.restore(); +- return nullptr; +-#ifdef __GLIBCXX__ +- } catch ( abi::__forced_unwind& ) { +- throw; +-#endif +- } catch (...) { +- /* When an exception is caught, give each registered exception +- translator a chance to translate it to a Python exception +- in reverse order of registration. +- +- A translator may choose to do one of the following: +- +- - catch the exception and call PyErr_SetString or PyErr_SetObject +- to set a standard (or custom) Python exception, or +- - do nothing and let the exception fall through to the next translator, or +- - delegate translation to the next translator by throwing a new type of exception. */ +- +- auto last_exception = std::current_exception(); +- auto ®istered_exception_translators = get_internals().registered_exception_translators; +- for (auto& translator : registered_exception_translators) { +- try { +- translator(last_exception); +- } catch (...) { +- last_exception = std::current_exception(); +- continue; +- } +- return nullptr; +- } +- PyErr_SetString(PyExc_SystemError, "Exception escaped from default exception translator!"); +- return nullptr; +- } +- +- auto append_note_if_missing_header_is_suspected = [](std::string &msg) { +- if (msg.find("std::") != std::string::npos) { +- msg += "\n\n" +- "Did you forget to `#include `? Or ,\n" +- ", , etc. Some automatic\n" +- "conversions are optional and require extra headers to be included\n" +- "when compiling your pybind11 module."; +- } +- }; +- +- if (result.ptr() == PYBIND11_TRY_NEXT_OVERLOAD) { +- if (overloads->is_operator) +- return handle(Py_NotImplemented).inc_ref().ptr(); +- +- std::string msg = std::string(overloads->name) + "(): incompatible " + +- std::string(overloads->is_constructor ? "constructor" : "function") + +- " arguments. The following argument types are supported:\n"; +- +- int ctr = 0; +- for (const function_record *it2 = overloads; it2 != nullptr; it2 = it2->next) { +- msg += " "+ std::to_string(++ctr) + ". "; +- +- bool wrote_sig = false; +- if (overloads->is_constructor) { +- // For a constructor, rewrite `(self: Object, arg0, ...) -> NoneType` as `Object(arg0, ...)` +- std::string sig = it2->signature; +- size_t start = sig.find('(') + 7; // skip "(self: " +- if (start < sig.size()) { +- // End at the , for the next argument +- size_t end = sig.find(", "), next = end + 2; +- size_t ret = sig.rfind(" -> "); +- // Or the ), if there is no comma: +- if (end >= sig.size()) next = end = sig.find(')'); +- if (start < end && next < sig.size()) { +- msg.append(sig, start, end - start); +- msg += '('; +- msg.append(sig, next, ret - next); +- wrote_sig = true; +- } +- } +- } +- if (!wrote_sig) msg += it2->signature; +- +- msg += "\n"; +- } +- msg += "\nInvoked with: "; +- auto args_ = reinterpret_borrow(args_in); +- bool some_args = false; +- for (size_t ti = overloads->is_constructor ? 1 : 0; ti < args_.size(); ++ti) { +- if (!some_args) some_args = true; +- else msg += ", "; +- try { +- msg += pybind11::repr(args_[ti]); +- } catch (const error_already_set&) { +- msg += ""; +- } +- } +- if (kwargs_in) { +- auto kwargs = reinterpret_borrow(kwargs_in); +- if (!kwargs.empty()) { +- if (some_args) msg += "; "; +- msg += "kwargs: "; +- bool first = true; +- for (auto kwarg : kwargs) { +- if (first) first = false; +- else msg += ", "; +- msg += pybind11::str("{}=").format(kwarg.first); +- try { +- msg += pybind11::repr(kwarg.second); +- } catch (const error_already_set&) { +- msg += ""; +- } +- } +- } +- } +- +- append_note_if_missing_header_is_suspected(msg); +- PyErr_SetString(PyExc_TypeError, msg.c_str()); +- return nullptr; +- } else if (!result) { +- std::string msg = "Unable to convert function return value to a " +- "Python type! The signature was\n\t"; +- msg += it->signature; +- append_note_if_missing_header_is_suspected(msg); +- PyErr_SetString(PyExc_TypeError, msg.c_str()); +- return nullptr; +- } else { +- if (overloads->is_constructor && !self_value_and_holder.holder_constructed()) { +- auto *pi = reinterpret_cast(parent.ptr()); +- self_value_and_holder.type->init_instance(pi, nullptr); +- } +- return result.ptr(); +- } +- } +-}; +- +-/// Wrapper for Python extension modules +-class module_ : public object { +-public: +- PYBIND11_OBJECT_DEFAULT(module_, object, PyModule_Check) +- +- /// Create a new top-level Python module with the given name and docstring +- PYBIND11_DEPRECATED("Use PYBIND11_MODULE or module_::create_extension_module instead") +- explicit module_(const char *name, const char *doc = nullptr) { +-#if PY_MAJOR_VERSION >= 3 +- *this = create_extension_module(name, doc, new PyModuleDef()); +-#else +- *this = create_extension_module(name, doc, nullptr); +-#endif +- } +- +- /** \rst +- Create Python binding for a new function within the module scope. ``Func`` +- can be a plain C++ function, a function pointer, or a lambda function. For +- details on the ``Extra&& ... extra`` argument, see section :ref:`extras`. +- \endrst */ +- template +- module_ &def(const char *name_, Func &&f, const Extra& ... extra) { +- cpp_function func(std::forward(f), name(name_), scope(*this), +- sibling(getattr(*this, name_, none())), extra...); +- // NB: allow overwriting here because cpp_function sets up a chain with the intention of +- // overwriting (and has already checked internally that it isn't overwriting non-functions). +- add_object(name_, func, true /* overwrite */); +- return *this; +- } +- +- /** \rst +- Create and return a new Python submodule with the given name and docstring. +- This also works recursively, i.e. +- +- .. code-block:: cpp +- +- py::module_ m("example", "pybind11 example plugin"); +- py::module_ m2 = m.def_submodule("sub", "A submodule of 'example'"); +- py::module_ m3 = m2.def_submodule("subsub", "A submodule of 'example.sub'"); +- \endrst */ +- module_ def_submodule(const char *name, const char *doc = nullptr) { +- std::string full_name = std::string(PyModule_GetName(m_ptr)) +- + std::string(".") + std::string(name); +- auto result = reinterpret_borrow(PyImport_AddModule(full_name.c_str())); +- if (doc && options::show_user_defined_docstrings()) +- result.attr("__doc__") = pybind11::str(doc); +- attr(name) = result; +- return result; +- } +- +- /// Import and return a module or throws `error_already_set`. +- static module_ import(const char *name) { +- PyObject *obj = PyImport_ImportModule(name); +- if (!obj) +- throw error_already_set(); +- return reinterpret_steal(obj); +- } +- +- /// Reload the module or throws `error_already_set`. +- void reload() { +- PyObject *obj = PyImport_ReloadModule(ptr()); +- if (!obj) +- throw error_already_set(); +- *this = reinterpret_steal(obj); +- } +- +- /** \rst +- Adds an object to the module using the given name. Throws if an object with the given name +- already exists. +- +- ``overwrite`` should almost always be false: attempting to overwrite objects that pybind11 has +- established will, in most cases, break things. +- \endrst */ +- PYBIND11_NOINLINE void add_object(const char *name, handle obj, bool overwrite = false) { +- if (!overwrite && hasattr(*this, name)) +- pybind11_fail("Error during initialization: multiple incompatible definitions with name \"" + +- std::string(name) + "\""); +- +- PyModule_AddObject(ptr(), name, obj.inc_ref().ptr() /* steals a reference */); +- } +- +-#if PY_MAJOR_VERSION >= 3 +- using module_def = PyModuleDef; +-#else +- struct module_def {}; +-#endif +- +- /** \rst +- Create a new top-level module that can be used as the main module of a C extension. +- +- For Python 3, ``def`` should point to a staticly allocated module_def. +- For Python 2, ``def`` can be a nullptr and is completely ignored. +- \endrst */ +- static module_ create_extension_module(const char *name, const char *doc, module_def *def) { +-#if PY_MAJOR_VERSION >= 3 +- // module_def is PyModuleDef +- def = new (def) PyModuleDef { // Placement new (not an allocation). +- /* m_base */ PyModuleDef_HEAD_INIT, +- /* m_name */ name, +- /* m_doc */ options::show_user_defined_docstrings() ? doc : nullptr, +- /* m_size */ -1, +- /* m_methods */ nullptr, +- /* m_slots */ nullptr, +- /* m_traverse */ nullptr, +- /* m_clear */ nullptr, +- /* m_free */ nullptr +- }; +- auto m = PyModule_Create(def); +-#else +- // Ignore module_def *def; only necessary for Python 3 +- (void) def; +- auto m = Py_InitModule3(name, nullptr, options::show_user_defined_docstrings() ? doc : nullptr); +-#endif +- if (m == nullptr) { +- if (PyErr_Occurred()) +- throw error_already_set(); +- pybind11_fail("Internal error in module_::create_extension_module()"); +- } +- // TODO: Sould be reinterpret_steal for Python 3, but Python also steals it again when returned from PyInit_... +- // For Python 2, reinterpret_borrow is correct. +- return reinterpret_borrow(m); +- } +-}; +- +-// When inside a namespace (or anywhere as long as it's not the first item on a line), +-// C++20 allows "module" to be used. This is provided for backward compatibility, and for +-// simplicity, if someone wants to use py::module for example, that is perfectly safe. +-using module = module_; +- +-/// \ingroup python_builtins +-/// Return a dictionary representing the global variables in the current execution frame, +-/// or ``__main__.__dict__`` if there is no frame (usually when the interpreter is embedded). +-inline dict globals() { +- PyObject *p = PyEval_GetGlobals(); +- return reinterpret_borrow(p ? p : module_::import("__main__").attr("__dict__").ptr()); +-} +- +-PYBIND11_NAMESPACE_BEGIN(detail) +-/// Generic support for creating new Python heap types +-class generic_type : public object { +-public: +- PYBIND11_OBJECT_DEFAULT(generic_type, object, PyType_Check) +-protected: +- void initialize(const type_record &rec) { +- if (rec.scope && hasattr(rec.scope, "__dict__") && rec.scope.attr("__dict__").contains(rec.name)) +- pybind11_fail("generic_type: cannot initialize type \"" + std::string(rec.name) + +- "\": an object with that name is already defined"); +- +- if (rec.module_local ? get_local_type_info(*rec.type) : get_global_type_info(*rec.type)) +- pybind11_fail("generic_type: type \"" + std::string(rec.name) + +- "\" is already registered!"); +- +- m_ptr = make_new_python_type(rec); +- +- /* Register supplemental type information in C++ dict */ +- auto *tinfo = new detail::type_info(); +- tinfo->type = (PyTypeObject *) m_ptr; +- tinfo->cpptype = rec.type; +- tinfo->type_size = rec.type_size; +- tinfo->type_align = rec.type_align; +- tinfo->operator_new = rec.operator_new; +- tinfo->holder_size_in_ptrs = size_in_ptrs(rec.holder_size); +- tinfo->init_instance = rec.init_instance; +- tinfo->dealloc = rec.dealloc; +- tinfo->simple_type = true; +- tinfo->simple_ancestors = true; +- tinfo->default_holder = rec.default_holder; +- tinfo->module_local = rec.module_local; +- +- auto &internals = get_internals(); +- auto tindex = std::type_index(*rec.type); +- tinfo->direct_conversions = &internals.direct_conversions[tindex]; +- if (rec.module_local) +- registered_local_types_cpp()[tindex] = tinfo; +- else +- internals.registered_types_cpp[tindex] = tinfo; +- internals.registered_types_py[(PyTypeObject *) m_ptr] = { tinfo }; +- +- if (rec.bases.size() > 1 || rec.multiple_inheritance) { +- mark_parents_nonsimple(tinfo->type); +- tinfo->simple_ancestors = false; +- } +- else if (rec.bases.size() == 1) { +- auto parent_tinfo = get_type_info((PyTypeObject *) rec.bases[0].ptr()); +- tinfo->simple_ancestors = parent_tinfo->simple_ancestors; +- } +- +- if (rec.module_local) { +- // Stash the local typeinfo and loader so that external modules can access it. +- tinfo->module_local_load = &type_caster_generic::local_load; +- setattr(m_ptr, PYBIND11_MODULE_LOCAL_ID, capsule(tinfo)); +- } +- } +- +- /// Helper function which tags all parents of a type using mult. inheritance +- void mark_parents_nonsimple(PyTypeObject *value) { +- auto t = reinterpret_borrow(value->tp_bases); +- for (handle h : t) { +- auto tinfo2 = get_type_info((PyTypeObject *) h.ptr()); +- if (tinfo2) +- tinfo2->simple_type = false; +- mark_parents_nonsimple((PyTypeObject *) h.ptr()); +- } +- } +- +- void install_buffer_funcs( +- buffer_info *(*get_buffer)(PyObject *, void *), +- void *get_buffer_data) { +- auto *type = (PyHeapTypeObject*) m_ptr; +- auto tinfo = detail::get_type_info(&type->ht_type); +- +- if (!type->ht_type.tp_as_buffer) +- pybind11_fail( +- "To be able to register buffer protocol support for the type '" + +- get_fully_qualified_tp_name(tinfo->type) + +- "' the associated class<>(..) invocation must " +- "include the pybind11::buffer_protocol() annotation!"); +- +- tinfo->get_buffer = get_buffer; +- tinfo->get_buffer_data = get_buffer_data; +- } +- +- // rec_func must be set for either fget or fset. +- void def_property_static_impl(const char *name, +- handle fget, handle fset, +- detail::function_record *rec_func) { +- const auto is_static = rec_func && !(rec_func->is_method && rec_func->scope); +- const auto has_doc = rec_func && rec_func->doc && pybind11::options::show_user_defined_docstrings(); +- auto property = handle((PyObject *) (is_static ? get_internals().static_property_type +- : &PyProperty_Type)); +- attr(name) = property(fget.ptr() ? fget : none(), +- fset.ptr() ? fset : none(), +- /*deleter*/none(), +- pybind11::str(has_doc ? rec_func->doc : "")); +- } +-}; +- +-/// Set the pointer to operator new if it exists. The cast is needed because it can be overloaded. +-template (T::operator new))>> +-void set_operator_new(type_record *r) { r->operator_new = &T::operator new; } +- +-template void set_operator_new(...) { } +- +-template struct has_operator_delete : std::false_type { }; +-template struct has_operator_delete(T::operator delete))>> +- : std::true_type { }; +-template struct has_operator_delete_size : std::false_type { }; +-template struct has_operator_delete_size(T::operator delete))>> +- : std::true_type { }; +-/// Call class-specific delete if it exists or global otherwise. Can also be an overload set. +-template ::value, int> = 0> +-void call_operator_delete(T *p, size_t, size_t) { T::operator delete(p); } +-template ::value && has_operator_delete_size::value, int> = 0> +-void call_operator_delete(T *p, size_t s, size_t) { T::operator delete(p, s); } +- +-inline void call_operator_delete(void *p, size_t s, size_t a) { +- (void)s; (void)a; +- #if defined(__cpp_aligned_new) && (!defined(_MSC_VER) || _MSC_VER >= 1912) +- if (a > __STDCPP_DEFAULT_NEW_ALIGNMENT__) { +- #ifdef __cpp_sized_deallocation +- ::operator delete(p, s, std::align_val_t(a)); +- #else +- ::operator delete(p, std::align_val_t(a)); +- #endif +- return; +- } +- #endif +- #ifdef __cpp_sized_deallocation +- ::operator delete(p, s); +- #else +- ::operator delete(p); +- #endif +-} +- +-inline void add_class_method(object& cls, const char *name_, const cpp_function &cf) { +- cls.attr(cf.name()) = cf; +- if (strcmp(name_, "__eq__") == 0 && !cls.attr("__dict__").contains("__hash__")) { +- cls.attr("__hash__") = none(); +- } +-} +- +-PYBIND11_NAMESPACE_END(detail) +- +-/// Given a pointer to a member function, cast it to its `Derived` version. +-/// Forward everything else unchanged. +-template +-auto method_adaptor(F &&f) -> decltype(std::forward(f)) { return std::forward(f); } +- +-template +-auto method_adaptor(Return (Class::*pmf)(Args...)) -> Return (Derived::*)(Args...) { +- static_assert(detail::is_accessible_base_of::value, +- "Cannot bind an inaccessible base class method; use a lambda definition instead"); +- return pmf; +-} +- +-template +-auto method_adaptor(Return (Class::*pmf)(Args...) const) -> Return (Derived::*)(Args...) const { +- static_assert(detail::is_accessible_base_of::value, +- "Cannot bind an inaccessible base class method; use a lambda definition instead"); +- return pmf; +-} +- +-template +-class class_ : public detail::generic_type { +- template using is_holder = detail::is_holder_type; +- template using is_subtype = detail::is_strict_base_of; +- template using is_base = detail::is_strict_base_of; +- // struct instead of using here to help MSVC: +- template struct is_valid_class_option : +- detail::any_of, is_subtype, is_base> {}; +- +-public: +- using type = type_; +- using type_alias = detail::exactly_one_t; +- constexpr static bool has_alias = !std::is_void::value; +- using holder_type = detail::exactly_one_t, options...>; +- +- static_assert(detail::all_of...>::value, +- "Unknown/invalid class_ template parameters provided"); +- +- static_assert(!has_alias || std::is_polymorphic::value, +- "Cannot use an alias class with a non-polymorphic type"); +- +- PYBIND11_OBJECT(class_, generic_type, PyType_Check) +- +- template +- class_(handle scope, const char *name, const Extra &... extra) { +- using namespace detail; +- +- // MI can only be specified via class_ template options, not constructor parameters +- static_assert( +- none_of...>::value || // no base class arguments, or: +- ( constexpr_sum(is_pyobject::value...) == 1 && // Exactly one base +- constexpr_sum(is_base::value...) == 0 && // no template option bases +- none_of...>::value), // no multiple_inheritance attr +- "Error: multiple inheritance bases must be specified via class_ template options"); +- +- type_record record; +- record.scope = scope; +- record.name = name; +- record.type = &typeid(type); +- record.type_size = sizeof(conditional_t); +- record.type_align = alignof(conditional_t&); +- record.holder_size = sizeof(holder_type); +- record.init_instance = init_instance; +- record.dealloc = dealloc; +- record.default_holder = detail::is_instantiation::value; +- +- set_operator_new(&record); +- +- /* Register base classes specified via template arguments to class_, if any */ +- PYBIND11_EXPAND_SIDE_EFFECTS(add_base(record)); +- +- /* Process optional arguments, if any */ +- process_attributes::init(extra..., &record); +- +- generic_type::initialize(record); +- +- if (has_alias) { +- auto &instances = record.module_local ? registered_local_types_cpp() : get_internals().registered_types_cpp; +- instances[std::type_index(typeid(type_alias))] = instances[std::type_index(typeid(type))]; +- } +- } +- +- template ::value, int> = 0> +- static void add_base(detail::type_record &rec) { +- rec.add_base(typeid(Base), [](void *src) -> void * { +- return static_cast(reinterpret_cast(src)); +- }); +- } +- +- template ::value, int> = 0> +- static void add_base(detail::type_record &) { } +- +- template +- class_ &def(const char *name_, Func&& f, const Extra&... extra) { +- cpp_function cf(method_adaptor(std::forward(f)), name(name_), is_method(*this), +- sibling(getattr(*this, name_, none())), extra...); +- add_class_method(*this, name_, cf); +- return *this; +- } +- +- template class_ & +- def_static(const char *name_, Func &&f, const Extra&... extra) { +- static_assert(!std::is_member_function_pointer::value, +- "def_static(...) called with a non-static member function pointer"); +- cpp_function cf(std::forward(f), name(name_), scope(*this), +- sibling(getattr(*this, name_, none())), extra...); +- attr(cf.name()) = staticmethod(cf); +- return *this; +- } +- +- template +- class_ &def(const detail::op_ &op, const Extra&... extra) { +- op.execute(*this, extra...); +- return *this; +- } +- +- template +- class_ & def_cast(const detail::op_ &op, const Extra&... extra) { +- op.execute_cast(*this, extra...); +- return *this; +- } +- +- template +- class_ &def(const detail::initimpl::constructor &init, const Extra&... extra) { +- init.execute(*this, extra...); +- return *this; +- } +- +- template +- class_ &def(const detail::initimpl::alias_constructor &init, const Extra&... extra) { +- init.execute(*this, extra...); +- return *this; +- } +- +- template +- class_ &def(detail::initimpl::factory &&init, const Extra&... extra) { +- std::move(init).execute(*this, extra...); +- return *this; +- } +- +- template +- class_ &def(detail::initimpl::pickle_factory &&pf, const Extra &...extra) { +- std::move(pf).execute(*this, extra...); +- return *this; +- } +- +- template +- class_& def_buffer(Func &&func) { +- struct capture { Func func; }; +- auto *ptr = new capture { std::forward(func) }; +- install_buffer_funcs([](PyObject *obj, void *ptr) -> buffer_info* { +- detail::make_caster caster; +- if (!caster.load(obj, false)) +- return nullptr; +- return new buffer_info(((capture *) ptr)->func(caster)); +- }, ptr); +- weakref(m_ptr, cpp_function([ptr](handle wr) { +- delete ptr; +- wr.dec_ref(); +- })).release(); +- return *this; +- } +- +- template +- class_ &def_buffer(Return (Class::*func)(Args...)) { +- return def_buffer([func] (type &obj) { return (obj.*func)(); }); +- } +- +- template +- class_ &def_buffer(Return (Class::*func)(Args...) const) { +- return def_buffer([func] (const type &obj) { return (obj.*func)(); }); +- } +- +- template +- class_ &def_readwrite(const char *name, D C::*pm, const Extra&... extra) { +- static_assert(std::is_same::value || std::is_base_of::value, "def_readwrite() requires a class member (or base class member)"); +- cpp_function fget([pm](const type &c) -> const D &{ return c.*pm; }, is_method(*this)), +- fset([pm](type &c, const D &value) { c.*pm = value; }, is_method(*this)); +- def_property(name, fget, fset, return_value_policy::reference_internal, extra...); +- return *this; +- } +- +- template +- class_ &def_readonly(const char *name, const D C::*pm, const Extra& ...extra) { +- static_assert(std::is_same::value || std::is_base_of::value, "def_readonly() requires a class member (or base class member)"); +- cpp_function fget([pm](const type &c) -> const D &{ return c.*pm; }, is_method(*this)); +- def_property_readonly(name, fget, return_value_policy::reference_internal, extra...); +- return *this; +- } +- +- template +- class_ &def_readwrite_static(const char *name, D *pm, const Extra& ...extra) { +- cpp_function fget([pm](object) -> const D &{ return *pm; }, scope(*this)), +- fset([pm](object, const D &value) { *pm = value; }, scope(*this)); +- def_property_static(name, fget, fset, return_value_policy::reference, extra...); +- return *this; +- } +- +- template +- class_ &def_readonly_static(const char *name, const D *pm, const Extra& ...extra) { +- cpp_function fget([pm](object) -> const D &{ return *pm; }, scope(*this)); +- def_property_readonly_static(name, fget, return_value_policy::reference, extra...); +- return *this; +- } +- +- /// Uses return_value_policy::reference_internal by default +- template +- class_ &def_property_readonly(const char *name, const Getter &fget, const Extra& ...extra) { +- return def_property_readonly(name, cpp_function(method_adaptor(fget)), +- return_value_policy::reference_internal, extra...); +- } +- +- /// Uses cpp_function's return_value_policy by default +- template +- class_ &def_property_readonly(const char *name, const cpp_function &fget, const Extra& ...extra) { +- return def_property(name, fget, nullptr, extra...); +- } +- +- /// Uses return_value_policy::reference by default +- template +- class_ &def_property_readonly_static(const char *name, const Getter &fget, const Extra& ...extra) { +- return def_property_readonly_static(name, cpp_function(fget), return_value_policy::reference, extra...); +- } +- +- /// Uses cpp_function's return_value_policy by default +- template +- class_ &def_property_readonly_static(const char *name, const cpp_function &fget, const Extra& ...extra) { +- return def_property_static(name, fget, nullptr, extra...); +- } +- +- /// Uses return_value_policy::reference_internal by default +- template +- class_ &def_property(const char *name, const Getter &fget, const Setter &fset, const Extra& ...extra) { +- return def_property(name, fget, cpp_function(method_adaptor(fset)), extra...); +- } +- template +- class_ &def_property(const char *name, const Getter &fget, const cpp_function &fset, const Extra& ...extra) { +- return def_property(name, cpp_function(method_adaptor(fget)), fset, +- return_value_policy::reference_internal, extra...); +- } +- +- /// Uses cpp_function's return_value_policy by default +- template +- class_ &def_property(const char *name, const cpp_function &fget, const cpp_function &fset, const Extra& ...extra) { +- return def_property_static(name, fget, fset, is_method(*this), extra...); +- } +- +- /// Uses return_value_policy::reference by default +- template +- class_ &def_property_static(const char *name, const Getter &fget, const cpp_function &fset, const Extra& ...extra) { +- return def_property_static(name, cpp_function(fget), fset, return_value_policy::reference, extra...); +- } +- +- /// Uses cpp_function's return_value_policy by default +- template +- class_ &def_property_static(const char *name, const cpp_function &fget, const cpp_function &fset, const Extra& ...extra) { +- static_assert( 0 == detail::constexpr_sum(std::is_base_of::value...), +- "Argument annotations are not allowed for properties"); +- auto rec_fget = get_function_record(fget), rec_fset = get_function_record(fset); +- auto *rec_active = rec_fget; +- if (rec_fget) { +- char *doc_prev = rec_fget->doc; /* 'extra' field may include a property-specific documentation string */ +- detail::process_attributes::init(extra..., rec_fget); +- if (rec_fget->doc && rec_fget->doc != doc_prev) { +- free(doc_prev); +- rec_fget->doc = strdup(rec_fget->doc); +- } +- } +- if (rec_fset) { +- char *doc_prev = rec_fset->doc; +- detail::process_attributes::init(extra..., rec_fset); +- if (rec_fset->doc && rec_fset->doc != doc_prev) { +- free(doc_prev); +- rec_fset->doc = strdup(rec_fset->doc); +- } +- if (! rec_active) rec_active = rec_fset; +- } +- def_property_static_impl(name, fget, fset, rec_active); +- return *this; +- } +- +-private: +- /// Initialize holder object, variant 1: object derives from enable_shared_from_this +- template +- static void init_holder(detail::instance *inst, detail::value_and_holder &v_h, +- const holder_type * /* unused */, const std::enable_shared_from_this * /* dummy */) { +- try { +- auto sh = std::dynamic_pointer_cast( +- v_h.value_ptr()->shared_from_this()); +- if (sh) { +- new (std::addressof(v_h.holder())) holder_type(std::move(sh)); +- v_h.set_holder_constructed(); +- } +- } catch (const std::bad_weak_ptr &) {} +- +- if (!v_h.holder_constructed() && inst->owned) { +- new (std::addressof(v_h.holder())) holder_type(v_h.value_ptr()); +- v_h.set_holder_constructed(); +- } +- } +- +- static void init_holder_from_existing(const detail::value_and_holder &v_h, +- const holder_type *holder_ptr, std::true_type /*is_copy_constructible*/) { +- new (std::addressof(v_h.holder())) holder_type(*reinterpret_cast(holder_ptr)); +- } +- +- static void init_holder_from_existing(const detail::value_and_holder &v_h, +- const holder_type *holder_ptr, std::false_type /*is_copy_constructible*/) { +- new (std::addressof(v_h.holder())) holder_type(std::move(*const_cast(holder_ptr))); +- } +- +- /// Initialize holder object, variant 2: try to construct from existing holder object, if possible +- static void init_holder(detail::instance *inst, detail::value_and_holder &v_h, +- const holder_type *holder_ptr, const void * /* dummy -- not enable_shared_from_this) */) { +- if (holder_ptr) { +- init_holder_from_existing(v_h, holder_ptr, std::is_copy_constructible()); +- v_h.set_holder_constructed(); +- } else if (inst->owned || detail::always_construct_holder::value) { +- new (std::addressof(v_h.holder())) holder_type(v_h.value_ptr()); +- v_h.set_holder_constructed(); +- } +- } +- +- /// Performs instance initialization including constructing a holder and registering the known +- /// instance. Should be called as soon as the `type` value_ptr is set for an instance. Takes an +- /// optional pointer to an existing holder to use; if not specified and the instance is +- /// `.owned`, a new holder will be constructed to manage the value pointer. +- static void init_instance(detail::instance *inst, const void *holder_ptr) { +- auto v_h = inst->get_value_and_holder(detail::get_type_info(typeid(type))); +- if (!v_h.instance_registered()) { +- register_instance(inst, v_h.value_ptr(), v_h.type); +- v_h.set_instance_registered(); +- } +- init_holder(inst, v_h, (const holder_type *) holder_ptr, v_h.value_ptr()); +- } +- +- /// Deallocates an instance; via holder, if constructed; otherwise via operator delete. +- static void dealloc(detail::value_and_holder &v_h) { +- // We could be deallocating because we are cleaning up after a Python exception. +- // If so, the Python error indicator will be set. We need to clear that before +- // running the destructor, in case the destructor code calls more Python. +- // If we don't, the Python API will exit with an exception, and pybind11 will +- // throw error_already_set from the C++ destructor which is forbidden and triggers +- // std::terminate(). +- error_scope scope; +- if (v_h.holder_constructed()) { +- v_h.holder().~holder_type(); +- v_h.set_holder_constructed(false); +- } +- else { +- detail::call_operator_delete(v_h.value_ptr(), +- v_h.type->type_size, +- v_h.type->type_align +- ); +- } +- v_h.value_ptr() = nullptr; +- } +- +- static detail::function_record *get_function_record(handle h) { +- h = detail::get_function(h); +- return h ? (detail::function_record *) reinterpret_borrow(PyCFunction_GET_SELF(h.ptr())) +- : nullptr; +- } +-}; +- +-/// Binds an existing constructor taking arguments Args... +-template detail::initimpl::constructor init() { return {}; } +-/// Like `init()`, but the instance is always constructed through the alias class (even +-/// when not inheriting on the Python side). +-template detail::initimpl::alias_constructor init_alias() { return {}; } +- +-/// Binds a factory function as a constructor +-template > +-Ret init(Func &&f) { return {std::forward(f)}; } +- +-/// Dual-argument factory function: the first function is called when no alias is needed, the second +-/// when an alias is needed (i.e. due to python-side inheritance). Arguments must be identical. +-template > +-Ret init(CFunc &&c, AFunc &&a) { +- return {std::forward(c), std::forward(a)}; +-} +- +-/// Binds pickling functions `__getstate__` and `__setstate__` and ensures that the type +-/// returned by `__getstate__` is the same as the argument accepted by `__setstate__`. +-template +-detail::initimpl::pickle_factory pickle(GetState &&g, SetState &&s) { +- return {std::forward(g), std::forward(s)}; +-} +- +-PYBIND11_NAMESPACE_BEGIN(detail) +- +-inline str enum_name(handle arg) { +- dict entries = arg.get_type().attr("__entries"); +- for (auto kv : entries) { +- if (handle(kv.second[int_(0)]).equal(arg)) +- return pybind11::str(kv.first); +- } +- return "???"; +-} +- +-struct enum_base { +- enum_base(handle base, handle parent) : m_base(base), m_parent(parent) { } +- +- PYBIND11_NOINLINE void init(bool is_arithmetic, bool is_convertible) { +- m_base.attr("__entries") = dict(); +- auto property = handle((PyObject *) &PyProperty_Type); +- auto static_property = handle((PyObject *) get_internals().static_property_type); +- +- m_base.attr("__repr__") = cpp_function( +- [](object arg) -> str { +- handle type = type::handle_of(arg); +- object type_name = type.attr("__name__"); +- return pybind11::str("<{}.{}: {}>").format(type_name, enum_name(arg), int_(arg)); +- }, name("__repr__"), is_method(m_base) +- ); +- +- m_base.attr("name") = property(cpp_function(&enum_name, name("name"), is_method(m_base))); +- +- m_base.attr("__str__") = cpp_function( +- [](handle arg) -> str { +- object type_name = type::handle_of(arg).attr("__name__"); +- return pybind11::str("{}.{}").format(type_name, enum_name(arg)); +- }, name("name"), is_method(m_base) +- ); +- +- m_base.attr("__doc__") = static_property(cpp_function( +- [](handle arg) -> std::string { +- std::string docstring; +- dict entries = arg.attr("__entries"); +- if (((PyTypeObject *) arg.ptr())->tp_doc) +- docstring += std::string(((PyTypeObject *) arg.ptr())->tp_doc) + "\n\n"; +- docstring += "Members:"; +- for (auto kv : entries) { +- auto key = std::string(pybind11::str(kv.first)); +- auto comment = kv.second[int_(1)]; +- docstring += "\n\n " + key; +- if (!comment.is_none()) +- docstring += " : " + (std::string) pybind11::str(comment); +- } +- return docstring; +- }, name("__doc__") +- ), none(), none(), ""); +- +- m_base.attr("__members__") = static_property(cpp_function( +- [](handle arg) -> dict { +- dict entries = arg.attr("__entries"), m; +- for (auto kv : entries) +- m[kv.first] = kv.second[int_(0)]; +- return m; +- }, name("__members__")), none(), none(), "" +- ); +- +- #define PYBIND11_ENUM_OP_STRICT(op, expr, strict_behavior) \ +- m_base.attr(op) = cpp_function( \ +- [](object a, object b) { \ +- if (!type::handle_of(a).is(type::handle_of(b))) \ +- strict_behavior; \ +- return expr; \ +- }, \ +- name(op), is_method(m_base), arg("other")) +- +- #define PYBIND11_ENUM_OP_CONV(op, expr) \ +- m_base.attr(op) = cpp_function( \ +- [](object a_, object b_) { \ +- int_ a(a_), b(b_); \ +- return expr; \ +- }, \ +- name(op), is_method(m_base), arg("other")) +- +- #define PYBIND11_ENUM_OP_CONV_LHS(op, expr) \ +- m_base.attr(op) = cpp_function( \ +- [](object a_, object b) { \ +- int_ a(a_); \ +- return expr; \ +- }, \ +- name(op), is_method(m_base), arg("other")) +- +- if (is_convertible) { +- PYBIND11_ENUM_OP_CONV_LHS("__eq__", !b.is_none() && a.equal(b)); +- PYBIND11_ENUM_OP_CONV_LHS("__ne__", b.is_none() || !a.equal(b)); +- +- if (is_arithmetic) { +- PYBIND11_ENUM_OP_CONV("__lt__", a < b); +- PYBIND11_ENUM_OP_CONV("__gt__", a > b); +- PYBIND11_ENUM_OP_CONV("__le__", a <= b); +- PYBIND11_ENUM_OP_CONV("__ge__", a >= b); +- PYBIND11_ENUM_OP_CONV("__and__", a & b); +- PYBIND11_ENUM_OP_CONV("__rand__", a & b); +- PYBIND11_ENUM_OP_CONV("__or__", a | b); +- PYBIND11_ENUM_OP_CONV("__ror__", a | b); +- PYBIND11_ENUM_OP_CONV("__xor__", a ^ b); +- PYBIND11_ENUM_OP_CONV("__rxor__", a ^ b); +- m_base.attr("__invert__") = cpp_function( +- [](object arg) { return ~(int_(arg)); }, name("__invert__"), is_method(m_base)); +- } +- } else { +- PYBIND11_ENUM_OP_STRICT("__eq__", int_(a).equal(int_(b)), return false); +- PYBIND11_ENUM_OP_STRICT("__ne__", !int_(a).equal(int_(b)), return true); +- +- if (is_arithmetic) { +- #define PYBIND11_THROW throw type_error("Expected an enumeration of matching type!"); +- PYBIND11_ENUM_OP_STRICT("__lt__", int_(a) < int_(b), PYBIND11_THROW); +- PYBIND11_ENUM_OP_STRICT("__gt__", int_(a) > int_(b), PYBIND11_THROW); +- PYBIND11_ENUM_OP_STRICT("__le__", int_(a) <= int_(b), PYBIND11_THROW); +- PYBIND11_ENUM_OP_STRICT("__ge__", int_(a) >= int_(b), PYBIND11_THROW); +- #undef PYBIND11_THROW +- } +- } +- +- #undef PYBIND11_ENUM_OP_CONV_LHS +- #undef PYBIND11_ENUM_OP_CONV +- #undef PYBIND11_ENUM_OP_STRICT +- +- m_base.attr("__getstate__") = cpp_function( +- [](object arg) { return int_(arg); }, name("__getstate__"), is_method(m_base)); +- +- m_base.attr("__hash__") = cpp_function( +- [](object arg) { return int_(arg); }, name("__hash__"), is_method(m_base)); +- } +- +- PYBIND11_NOINLINE void value(char const* name_, object value, const char *doc = nullptr) { +- dict entries = m_base.attr("__entries"); +- str name(name_); +- if (entries.contains(name)) { +- std::string type_name = (std::string) str(m_base.attr("__name__")); +- throw value_error(type_name + ": element \"" + std::string(name_) + "\" already exists!"); +- } +- +- entries[name] = std::make_pair(value, doc); +- m_base.attr(name) = value; +- } +- +- PYBIND11_NOINLINE void export_values() { +- dict entries = m_base.attr("__entries"); +- for (auto kv : entries) +- m_parent.attr(kv.first) = kv.second[int_(0)]; +- } +- +- handle m_base; +- handle m_parent; +-}; +- +-PYBIND11_NAMESPACE_END(detail) +- +-/// Binds C++ enumerations and enumeration classes to Python +-template class enum_ : public class_ { +-public: +- using Base = class_; +- using Base::def; +- using Base::attr; +- using Base::def_property_readonly; +- using Base::def_property_readonly_static; +- using Scalar = typename std::underlying_type::type; +- +- template +- enum_(const handle &scope, const char *name, const Extra&... extra) +- : class_(scope, name, extra...), m_base(*this, scope) { +- constexpr bool is_arithmetic = detail::any_of...>::value; +- constexpr bool is_convertible = std::is_convertible::value; +- m_base.init(is_arithmetic, is_convertible); +- +- def(init([](Scalar i) { return static_cast(i); }), arg("value")); +- def("__int__", [](Type value) { return (Scalar) value; }); +- #if PY_MAJOR_VERSION < 3 +- def("__long__", [](Type value) { return (Scalar) value; }); +- #endif +- #if PY_MAJOR_VERSION > 3 || (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION >= 8) +- def("__index__", [](Type value) { return (Scalar) value; }); +- #endif +- +- attr("__setstate__") = cpp_function( +- [](detail::value_and_holder &v_h, Scalar arg) { +- detail::initimpl::setstate(v_h, static_cast(arg), +- Py_TYPE(v_h.inst) != v_h.type->type); }, +- detail::is_new_style_constructor(), +- pybind11::name("__setstate__"), is_method(*this), arg("state")); +- } +- +- /// Export enumeration entries into the parent scope +- enum_& export_values() { +- m_base.export_values(); +- return *this; +- } +- +- /// Add an enumeration entry +- enum_& value(char const* name, Type value, const char *doc = nullptr) { +- m_base.value(name, pybind11::cast(value, return_value_policy::copy), doc); +- return *this; +- } +- +-private: +- detail::enum_base m_base; +-}; +- +-PYBIND11_NAMESPACE_BEGIN(detail) +- +- +-inline void keep_alive_impl(handle nurse, handle patient) { +- if (!nurse || !patient) +- pybind11_fail("Could not activate keep_alive!"); +- +- if (patient.is_none() || nurse.is_none()) +- return; /* Nothing to keep alive or nothing to be kept alive by */ +- +- auto tinfo = all_type_info(Py_TYPE(nurse.ptr())); +- if (!tinfo.empty()) { +- /* It's a pybind-registered type, so we can store the patient in the +- * internal list. */ +- add_patient(nurse.ptr(), patient.ptr()); +- } +- else { +- /* Fall back to clever approach based on weak references taken from +- * Boost.Python. This is not used for pybind-registered types because +- * the objects can be destroyed out-of-order in a GC pass. */ +- cpp_function disable_lifesupport( +- [patient](handle weakref) { patient.dec_ref(); weakref.dec_ref(); }); +- +- weakref wr(nurse, disable_lifesupport); +- +- patient.inc_ref(); /* reference patient and leak the weak reference */ +- (void) wr.release(); +- } +-} +- +-PYBIND11_NOINLINE inline void keep_alive_impl(size_t Nurse, size_t Patient, function_call &call, handle ret) { +- auto get_arg = [&](size_t n) { +- if (n == 0) +- return ret; +- else if (n == 1 && call.init_self) +- return call.init_self; +- else if (n <= call.args.size()) +- return call.args[n - 1]; +- return handle(); +- }; +- +- keep_alive_impl(get_arg(Nurse), get_arg(Patient)); +-} +- +-inline std::pair all_type_info_get_cache(PyTypeObject *type) { +- auto res = get_internals().registered_types_py +-#ifdef __cpp_lib_unordered_map_try_emplace +- .try_emplace(type); +-#else +- .emplace(type, std::vector()); +-#endif +- if (res.second) { +- // New cache entry created; set up a weak reference to automatically remove it if the type +- // gets destroyed: +- weakref((PyObject *) type, cpp_function([type](handle wr) { +- get_internals().registered_types_py.erase(type); +- wr.dec_ref(); +- })).release(); +- } +- +- return res; +-} +- +-template +-struct iterator_state { +- Iterator it; +- Sentinel end; +- bool first_or_done; +-}; +- +-PYBIND11_NAMESPACE_END(detail) +- +-/// Makes a python iterator from a first and past-the-end C++ InputIterator. +-template ()), +- typename... Extra> +-iterator make_iterator(Iterator first, Sentinel last, Extra &&... extra) { +- using state = detail::iterator_state; +- +- if (!detail::get_type_info(typeid(state), false)) { +- class_(handle(), "iterator", pybind11::module_local()) +- .def("__iter__", [](state &s) -> state& { return s; }) +- .def("__next__", [](state &s) -> ValueType { +- if (!s.first_or_done) +- ++s.it; +- else +- s.first_or_done = false; +- if (s.it == s.end) { +- s.first_or_done = true; +- throw stop_iteration(); +- } +- return *s.it; +- }, std::forward(extra)..., Policy); +- } +- +- return cast(state{first, last, true}); +-} +- +-/// Makes an python iterator over the keys (`.first`) of a iterator over pairs from a +-/// first and past-the-end InputIterator. +-template ()).first), +- typename... Extra> +-iterator make_key_iterator(Iterator first, Sentinel last, Extra &&... extra) { +- using state = detail::iterator_state; +- +- if (!detail::get_type_info(typeid(state), false)) { +- class_(handle(), "iterator", pybind11::module_local()) +- .def("__iter__", [](state &s) -> state& { return s; }) +- .def("__next__", [](state &s) -> KeyType { +- if (!s.first_or_done) +- ++s.it; +- else +- s.first_or_done = false; +- if (s.it == s.end) { +- s.first_or_done = true; +- throw stop_iteration(); +- } +- return (*s.it).first; +- }, std::forward(extra)..., Policy); +- } +- +- return cast(state{first, last, true}); +-} +- +-/// Makes an iterator over values of an stl container or other container supporting +-/// `std::begin()`/`std::end()` +-template iterator make_iterator(Type &value, Extra&&... extra) { +- return make_iterator(std::begin(value), std::end(value), extra...); +-} +- +-/// Makes an iterator over the keys (`.first`) of a stl map-like container supporting +-/// `std::begin()`/`std::end()` +-template iterator make_key_iterator(Type &value, Extra&&... extra) { +- return make_key_iterator(std::begin(value), std::end(value), extra...); +-} +- +-template void implicitly_convertible() { +- struct set_flag { +- bool &flag; +- set_flag(bool &flag) : flag(flag) { flag = true; } +- ~set_flag() { flag = false; } +- }; +- auto implicit_caster = [](PyObject *obj, PyTypeObject *type) -> PyObject * { +- static bool currently_used = false; +- if (currently_used) // implicit conversions are non-reentrant +- return nullptr; +- set_flag flag_helper(currently_used); +- if (!detail::make_caster().load(obj, false)) +- return nullptr; +- tuple args(1); +- args[0] = obj; +- PyObject *result = PyObject_Call((PyObject *) type, args.ptr(), nullptr); +- if (result == nullptr) +- PyErr_Clear(); +- return result; +- }; +- +- if (auto tinfo = detail::get_type_info(typeid(OutputType))) +- tinfo->implicit_conversions.push_back(implicit_caster); +- else +- pybind11_fail("implicitly_convertible: Unable to find type " + type_id()); +-} +- +-template +-void register_exception_translator(ExceptionTranslator&& translator) { +- detail::get_internals().registered_exception_translators.push_front( +- std::forward(translator)); +-} +- +-/** +- * Wrapper to generate a new Python exception type. +- * +- * This should only be used with PyErr_SetString for now. +- * It is not (yet) possible to use as a py::base. +- * Template type argument is reserved for future use. +- */ +-template +-class exception : public object { +-public: +- exception() = default; +- exception(handle scope, const char *name, handle base = PyExc_Exception) { +- std::string full_name = scope.attr("__name__").cast() + +- std::string(".") + name; +- m_ptr = PyErr_NewException(const_cast(full_name.c_str()), base.ptr(), NULL); +- if (hasattr(scope, "__dict__") && scope.attr("__dict__").contains(name)) +- pybind11_fail("Error during initialization: multiple incompatible " +- "definitions with name \"" + std::string(name) + "\""); +- scope.attr(name) = *this; +- } +- +- // Sets the current python exception to this exception object with the given message +- void operator()(const char *message) { +- PyErr_SetString(m_ptr, message); +- } +-}; +- +-PYBIND11_NAMESPACE_BEGIN(detail) +-// Returns a reference to a function-local static exception object used in the simple +-// register_exception approach below. (It would be simpler to have the static local variable +-// directly in register_exception, but that makes clang <3.5 segfault - issue #1349). +-template +-exception &get_exception_object() { static exception ex; return ex; } +-PYBIND11_NAMESPACE_END(detail) +- +-/** +- * Registers a Python exception in `m` of the given `name` and installs an exception translator to +- * translate the C++ exception to the created Python exception using the exceptions what() method. +- * This is intended for simple exception translations; for more complex translation, register the +- * exception object and translator directly. +- */ +-template +-exception ®ister_exception(handle scope, +- const char *name, +- handle base = PyExc_Exception) { +- auto &ex = detail::get_exception_object(); +- if (!ex) ex = exception(scope, name, base); +- +- register_exception_translator([](std::exception_ptr p) { +- if (!p) return; +- try { +- std::rethrow_exception(p); +- } catch (const CppException &e) { +- detail::get_exception_object()(e.what()); +- } +- }); +- return ex; +-} +- +-PYBIND11_NAMESPACE_BEGIN(detail) +-PYBIND11_NOINLINE inline void print(tuple args, dict kwargs) { +- auto strings = tuple(args.size()); +- for (size_t i = 0; i < args.size(); ++i) { +- strings[i] = str(args[i]); +- } +- auto sep = kwargs.contains("sep") ? kwargs["sep"] : cast(" "); +- auto line = sep.attr("join")(strings); +- +- object file; +- if (kwargs.contains("file")) { +- file = kwargs["file"].cast(); +- } else { +- try { +- file = module_::import("sys").attr("stdout"); +- } catch (const error_already_set &) { +- /* If print() is called from code that is executed as +- part of garbage collection during interpreter shutdown, +- importing 'sys' can fail. Give up rather than crashing the +- interpreter in this case. */ +- return; +- } +- } +- +- auto write = file.attr("write"); +- write(line); +- write(kwargs.contains("end") ? kwargs["end"] : cast("\n")); +- +- if (kwargs.contains("flush") && kwargs["flush"].cast()) +- file.attr("flush")(); +-} +-PYBIND11_NAMESPACE_END(detail) +- +-template +-void print(Args &&...args) { +- auto c = detail::collect_arguments(std::forward(args)...); +- detail::print(c.args(), c.kwargs()); +-} +- +-#if defined(WITH_THREAD) && !defined(PYPY_VERSION) +- +-/* The functions below essentially reproduce the PyGILState_* API using a RAII +- * pattern, but there are a few important differences: +- * +- * 1. When acquiring the GIL from an non-main thread during the finalization +- * phase, the GILState API blindly terminates the calling thread, which +- * is often not what is wanted. This API does not do this. +- * +- * 2. The gil_scoped_release function can optionally cut the relationship +- * of a PyThreadState and its associated thread, which allows moving it to +- * another thread (this is a fairly rare/advanced use case). +- * +- * 3. The reference count of an acquired thread state can be controlled. This +- * can be handy to prevent cases where callbacks issued from an external +- * thread would otherwise constantly construct and destroy thread state data +- * structures. +- * +- * See the Python bindings of NanoGUI (http://github.com/wjakob/nanogui) for an +- * example which uses features 2 and 3 to migrate the Python thread of +- * execution to another thread (to run the event loop on the original thread, +- * in this case). +- */ +- +-class gil_scoped_acquire { +-public: +- PYBIND11_NOINLINE gil_scoped_acquire() { +- auto const &internals = detail::get_internals(); +- tstate = (PyThreadState *) PYBIND11_TLS_GET_VALUE(internals.tstate); +- +- if (!tstate) { +- /* Check if the GIL was acquired using the PyGILState_* API instead (e.g. if +- calling from a Python thread). Since we use a different key, this ensures +- we don't create a new thread state and deadlock in PyEval_AcquireThread +- below. Note we don't save this state with internals.tstate, since we don't +- create it we would fail to clear it (its reference count should be > 0). */ +- tstate = PyGILState_GetThisThreadState(); +- } +- +- if (!tstate) { +- tstate = PyThreadState_New(internals.istate); +- #if !defined(NDEBUG) +- if (!tstate) +- pybind11_fail("scoped_acquire: could not create thread state!"); +- #endif +- tstate->gilstate_counter = 0; +- PYBIND11_TLS_REPLACE_VALUE(internals.tstate, tstate); +- } else { +- release = detail::get_thread_state_unchecked() != tstate; +- } +- +- if (release) { +- /* Work around an annoying assertion in PyThreadState_Swap */ +- #if defined(Py_DEBUG) +- PyInterpreterState *interp = tstate->interp; +- tstate->interp = nullptr; +- #endif +- PyEval_AcquireThread(tstate); +- #if defined(Py_DEBUG) +- tstate->interp = interp; +- #endif +- } +- +- inc_ref(); +- } +- +- void inc_ref() { +- ++tstate->gilstate_counter; +- } +- +- PYBIND11_NOINLINE void dec_ref() { +- --tstate->gilstate_counter; +- #if !defined(NDEBUG) +- if (detail::get_thread_state_unchecked() != tstate) +- pybind11_fail("scoped_acquire::dec_ref(): thread state must be current!"); +- if (tstate->gilstate_counter < 0) +- pybind11_fail("scoped_acquire::dec_ref(): reference count underflow!"); +- #endif +- if (tstate->gilstate_counter == 0) { +- #if !defined(NDEBUG) +- if (!release) +- pybind11_fail("scoped_acquire::dec_ref(): internal error!"); +- #endif +- PyThreadState_Clear(tstate); +- PyThreadState_DeleteCurrent(); +- PYBIND11_TLS_DELETE_VALUE(detail::get_internals().tstate); +- release = false; +- } +- } +- +- PYBIND11_NOINLINE ~gil_scoped_acquire() { +- dec_ref(); +- if (release) +- PyEval_SaveThread(); +- } +-private: +- PyThreadState *tstate = nullptr; +- bool release = true; +-}; +- +-class gil_scoped_release { +-public: +- explicit gil_scoped_release(bool disassoc = false) : disassoc(disassoc) { +- // `get_internals()` must be called here unconditionally in order to initialize +- // `internals.tstate` for subsequent `gil_scoped_acquire` calls. Otherwise, an +- // initialization race could occur as multiple threads try `gil_scoped_acquire`. +- const auto &internals = detail::get_internals(); +- tstate = PyEval_SaveThread(); +- if (disassoc) { +- auto key = internals.tstate; +- PYBIND11_TLS_DELETE_VALUE(key); +- } +- } +- ~gil_scoped_release() { +- if (!tstate) +- return; +- PyEval_RestoreThread(tstate); +- if (disassoc) { +- auto key = detail::get_internals().tstate; +- PYBIND11_TLS_REPLACE_VALUE(key, tstate); +- } +- } +-private: +- PyThreadState *tstate; +- bool disassoc; +-}; +-#elif defined(PYPY_VERSION) +-class gil_scoped_acquire { +- PyGILState_STATE state; +-public: +- gil_scoped_acquire() { state = PyGILState_Ensure(); } +- ~gil_scoped_acquire() { PyGILState_Release(state); } +-}; +- +-class gil_scoped_release { +- PyThreadState *state; +-public: +- gil_scoped_release() { state = PyEval_SaveThread(); } +- ~gil_scoped_release() { PyEval_RestoreThread(state); } +-}; +-#else +-class gil_scoped_acquire { }; +-class gil_scoped_release { }; +-#endif +- +-error_already_set::~error_already_set() { +- if (m_type) { +- gil_scoped_acquire gil; +- error_scope scope; +- m_type.release().dec_ref(); +- m_value.release().dec_ref(); +- m_trace.release().dec_ref(); +- } +-} +- +-PYBIND11_NAMESPACE_BEGIN(detail) +-inline function get_type_override(const void *this_ptr, const type_info *this_type, const char *name) { +- handle self = get_object_handle(this_ptr, this_type); +- if (!self) +- return function(); +- handle type = type::handle_of(self); +- auto key = std::make_pair(type.ptr(), name); +- +- /* Cache functions that aren't overridden in Python to avoid +- many costly Python dictionary lookups below */ +- auto &cache = get_internals().inactive_override_cache; +- if (cache.find(key) != cache.end()) +- return function(); +- +- function override = getattr(self, name, function()); +- if (override.is_cpp_function()) { +- cache.insert(key); +- return function(); +- } +- +- /* Don't call dispatch code if invoked from overridden function. +- Unfortunately this doesn't work on PyPy. */ +-#if !defined(PYPY_VERSION) +- PyFrameObject *frame = PyThreadState_Get()->frame; +- if (frame && (std::string) str(frame->f_code->co_name) == name && +- frame->f_code->co_argcount > 0) { +- PyFrame_FastToLocals(frame); +- PyObject *self_caller = PyDict_GetItem( +- frame->f_locals, PyTuple_GET_ITEM(frame->f_code->co_varnames, 0)); +- if (self_caller == self.ptr()) +- return function(); +- } +-#else +- /* PyPy currently doesn't provide a detailed cpyext emulation of +- frame objects, so we have to emulate this using Python. This +- is going to be slow..*/ +- dict d; d["self"] = self; d["name"] = pybind11::str(name); +- PyObject *result = PyRun_String( +- "import inspect\n" +- "frame = inspect.currentframe()\n" +- "if frame is not None:\n" +- " frame = frame.f_back\n" +- " if frame is not None and str(frame.f_code.co_name) == name and " +- "frame.f_code.co_argcount > 0:\n" +- " self_caller = frame.f_locals[frame.f_code.co_varnames[0]]\n" +- " if self_caller == self:\n" +- " self = None\n", +- Py_file_input, d.ptr(), d.ptr()); +- if (result == nullptr) +- throw error_already_set(); +- if (d["self"].is_none()) +- return function(); +- Py_DECREF(result); +-#endif +- +- return override; +-} +-PYBIND11_NAMESPACE_END(detail) +- +-/** \rst +- Try to retrieve a python method by the provided name from the instance pointed to by the this_ptr. +- +- :this_ptr: The pointer to the object the overriden method should be retrieved for. This should be +- the first non-trampoline class encountered in the inheritance chain. +- :name: The name of the overridden Python method to retrieve. +- :return: The Python method by this name from the object or an empty function wrapper. +- \endrst */ +-template function get_override(const T *this_ptr, const char *name) { +- auto tinfo = detail::get_type_info(typeid(T)); +- return tinfo ? detail::get_type_override(this_ptr, tinfo, name) : function(); +-} +- +-#define PYBIND11_OVERRIDE_IMPL(ret_type, cname, name, ...) \ +- do { \ +- pybind11::gil_scoped_acquire gil; \ +- pybind11::function override = pybind11::get_override(static_cast(this), name); \ +- if (override) { \ +- auto o = override(__VA_ARGS__); \ +- if (pybind11::detail::cast_is_temporary_value_reference::value) { \ +- static pybind11::detail::override_caster_t caster; \ +- return pybind11::detail::cast_ref(std::move(o), caster); \ +- } \ +- else return pybind11::detail::cast_safe(std::move(o)); \ +- } \ +- } while (false) +- +-/** \rst +- Macro to populate the virtual method in the trampoline class. This macro tries to look up a method named 'fn' +- from the Python side, deals with the :ref:`gil` and necessary argument conversions to call this method and return +- the appropriate type. See :ref:`overriding_virtuals` for more information. This macro should be used when the method +- name in C is not the same as the method name in Python. For example with `__str__`. +- +- .. code-block:: cpp +- +- std::string toString() override { +- PYBIND11_OVERRIDE_NAME( +- std::string, // Return type (ret_type) +- Animal, // Parent class (cname) +- "__str__", // Name of method in Python (name) +- toString, // Name of function in C++ (fn) +- ); +- } +-\endrst */ +-#define PYBIND11_OVERRIDE_NAME(ret_type, cname, name, fn, ...) \ +- do { \ +- PYBIND11_OVERRIDE_IMPL(PYBIND11_TYPE(ret_type), PYBIND11_TYPE(cname), name, __VA_ARGS__); \ +- return cname::fn(__VA_ARGS__); \ +- } while (false) +- +-/** \rst +- Macro for pure virtual functions, this function is identical to :c:macro:`PYBIND11_OVERRIDE_NAME`, except that it +- throws if no override can be found. +-\endrst */ +-#define PYBIND11_OVERRIDE_PURE_NAME(ret_type, cname, name, fn, ...) \ +- do { \ +- PYBIND11_OVERRIDE_IMPL(PYBIND11_TYPE(ret_type), PYBIND11_TYPE(cname), name, __VA_ARGS__); \ +- pybind11::pybind11_fail("Tried to call pure virtual function \"" PYBIND11_STRINGIFY(cname) "::" name "\""); \ +- } while (false) +- +-/** \rst +- Macro to populate the virtual method in the trampoline class. This macro tries to look up the method +- from the Python side, deals with the :ref:`gil` and necessary argument conversions to call this method and return +- the appropriate type. This macro should be used if the method name in C and in Python are identical. +- See :ref:`overriding_virtuals` for more information. +- +- .. code-block:: cpp +- +- class PyAnimal : public Animal { +- public: +- // Inherit the constructors +- using Animal::Animal; +- +- // Trampoline (need one for each virtual function) +- std::string go(int n_times) override { +- PYBIND11_OVERRIDE_PURE( +- std::string, // Return type (ret_type) +- Animal, // Parent class (cname) +- go, // Name of function in C++ (must match Python name) (fn) +- n_times // Argument(s) (...) +- ); +- } +- }; +-\endrst */ +-#define PYBIND11_OVERRIDE(ret_type, cname, fn, ...) \ +- PYBIND11_OVERRIDE_NAME(PYBIND11_TYPE(ret_type), PYBIND11_TYPE(cname), #fn, fn, __VA_ARGS__) +- +-/** \rst +- Macro for pure virtual functions, this function is identical to :c:macro:`PYBIND11_OVERRIDE`, except that it throws +- if no override can be found. +-\endrst */ +-#define PYBIND11_OVERRIDE_PURE(ret_type, cname, fn, ...) \ +- PYBIND11_OVERRIDE_PURE_NAME(PYBIND11_TYPE(ret_type), PYBIND11_TYPE(cname), #fn, fn, __VA_ARGS__) +- +- +-// Deprecated versions +- +-PYBIND11_DEPRECATED("get_type_overload has been deprecated") +-inline function get_type_overload(const void *this_ptr, const detail::type_info *this_type, const char *name) { +- return detail::get_type_override(this_ptr, this_type, name); +-} +- +-template +-inline function get_overload(const T *this_ptr, const char *name) { +- return get_override(this_ptr, name); +-} +- +-#define PYBIND11_OVERLOAD_INT(ret_type, cname, name, ...) \ +- PYBIND11_OVERRIDE_IMPL(PYBIND11_TYPE(ret_type), PYBIND11_TYPE(cname), name, __VA_ARGS__) +-#define PYBIND11_OVERLOAD_NAME(ret_type, cname, name, fn, ...) \ +- PYBIND11_OVERRIDE_NAME(PYBIND11_TYPE(ret_type), PYBIND11_TYPE(cname), name, fn, __VA_ARGS__) +-#define PYBIND11_OVERLOAD_PURE_NAME(ret_type, cname, name, fn, ...) \ +- PYBIND11_OVERRIDE_PURE_NAME(PYBIND11_TYPE(ret_type), PYBIND11_TYPE(cname), name, fn, __VA_ARGS__); +-#define PYBIND11_OVERLOAD(ret_type, cname, fn, ...) \ +- PYBIND11_OVERRIDE(PYBIND11_TYPE(ret_type), PYBIND11_TYPE(cname), fn, __VA_ARGS__) +-#define PYBIND11_OVERLOAD_PURE(ret_type, cname, fn, ...) \ +- PYBIND11_OVERRIDE_PURE(PYBIND11_TYPE(ret_type), PYBIND11_TYPE(cname), fn, __VA_ARGS__); +- +-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE) +- +-#if defined(_MSC_VER) && !defined(__INTEL_COMPILER) +-# pragma warning(pop) +-#elif defined(__GNUG__) && !defined(__clang__) +-# pragma GCC diagnostic pop +-#endif +diff --git a/dune/python/pybind11/pytypes.h b/dune/python/pybind11/pytypes.h +deleted file mode 100644 +index 1010ad713..000000000 +--- a/dune/python/pybind11/pytypes.h ++++ /dev/null +@@ -1,1659 +0,0 @@ +-/* +- pybind11/pytypes.h: Convenience wrapper classes for basic Python types +- +- Copyright (c) 2016 Wenzel Jakob +- +- All rights reserved. Use of this source code is governed by a +- BSD-style license that can be found in the LICENSE file. +-*/ +- +-#pragma once +- +-#include "detail/common.h" +-#include "buffer_info.h" +-#include +-#include +- +-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE) +- +-/* A few forward declarations */ +-class handle; class object; +-class str; class iterator; +-class type; +-struct arg; struct arg_v; +- +-PYBIND11_NAMESPACE_BEGIN(detail) +-class args_proxy; +-inline bool isinstance_generic(handle obj, const std::type_info &tp); +- +-// Accessor forward declarations +-template class accessor; +-namespace accessor_policies { +- struct obj_attr; +- struct str_attr; +- struct generic_item; +- struct sequence_item; +- struct list_item; +- struct tuple_item; +-} // namespace accessor_policies +-using obj_attr_accessor = accessor; +-using str_attr_accessor = accessor; +-using item_accessor = accessor; +-using sequence_accessor = accessor; +-using list_accessor = accessor; +-using tuple_accessor = accessor; +- +-/// Tag and check to identify a class which implements the Python object API +-class pyobject_tag { }; +-template using is_pyobject = std::is_base_of>; +- +-/** \rst +- A mixin class which adds common functions to `handle`, `object` and various accessors. +- The only requirement for `Derived` is to implement ``PyObject *Derived::ptr() const``. +-\endrst */ +-template +-class object_api : public pyobject_tag { +- const Derived &derived() const { return static_cast(*this); } +- +-public: +- /** \rst +- Return an iterator equivalent to calling ``iter()`` in Python. The object +- must be a collection which supports the iteration protocol. +- \endrst */ +- iterator begin() const; +- /// Return a sentinel which ends iteration. +- iterator end() const; +- +- /** \rst +- Return an internal functor to invoke the object's sequence protocol. Casting +- the returned ``detail::item_accessor`` instance to a `handle` or `object` +- subclass causes a corresponding call to ``__getitem__``. Assigning a `handle` +- or `object` subclass causes a call to ``__setitem__``. +- \endrst */ +- item_accessor operator[](handle key) const; +- /// See above (the only difference is that they key is provided as a string literal) +- item_accessor operator[](const char *key) const; +- +- /** \rst +- Return an internal functor to access the object's attributes. Casting the +- returned ``detail::obj_attr_accessor`` instance to a `handle` or `object` +- subclass causes a corresponding call to ``getattr``. Assigning a `handle` +- or `object` subclass causes a call to ``setattr``. +- \endrst */ +- obj_attr_accessor attr(handle key) const; +- /// See above (the only difference is that they key is provided as a string literal) +- str_attr_accessor attr(const char *key) const; +- +- /** \rst +- Matches * unpacking in Python, e.g. to unpack arguments out of a ``tuple`` +- or ``list`` for a function call. Applying another * to the result yields +- ** unpacking, e.g. to unpack a dict as function keyword arguments. +- See :ref:`calling_python_functions`. +- \endrst */ +- args_proxy operator*() const; +- +- /// Check if the given item is contained within this object, i.e. ``item in obj``. +- template bool contains(T &&item) const; +- +- /** \rst +- Assuming the Python object is a function or implements the ``__call__`` +- protocol, ``operator()`` invokes the underlying function, passing an +- arbitrary set of parameters. The result is returned as a `object` and +- may need to be converted back into a Python object using `handle::cast()`. +- +- When some of the arguments cannot be converted to Python objects, the +- function will throw a `cast_error` exception. When the Python function +- call fails, a `error_already_set` exception is thrown. +- \endrst */ +- template +- object operator()(Args &&...args) const; +- template +- PYBIND11_DEPRECATED("call(...) was deprecated in favor of operator()(...)") +- object call(Args&&... args) const; +- +- /// Equivalent to ``obj is other`` in Python. +- bool is(object_api const& other) const { return derived().ptr() == other.derived().ptr(); } +- /// Equivalent to ``obj is None`` in Python. +- bool is_none() const { return derived().ptr() == Py_None; } +- /// Equivalent to obj == other in Python +- bool equal(object_api const &other) const { return rich_compare(other, Py_EQ); } +- bool not_equal(object_api const &other) const { return rich_compare(other, Py_NE); } +- bool operator<(object_api const &other) const { return rich_compare(other, Py_LT); } +- bool operator<=(object_api const &other) const { return rich_compare(other, Py_LE); } +- bool operator>(object_api const &other) const { return rich_compare(other, Py_GT); } +- bool operator>=(object_api const &other) const { return rich_compare(other, Py_GE); } +- +- object operator-() const; +- object operator~() const; +- object operator+(object_api const &other) const; +- object operator+=(object_api const &other) const; +- object operator-(object_api const &other) const; +- object operator-=(object_api const &other) const; +- object operator*(object_api const &other) const; +- object operator*=(object_api const &other) const; +- object operator/(object_api const &other) const; +- object operator/=(object_api const &other) const; +- object operator|(object_api const &other) const; +- object operator|=(object_api const &other) const; +- object operator&(object_api const &other) const; +- object operator&=(object_api const &other) const; +- object operator^(object_api const &other) const; +- object operator^=(object_api const &other) const; +- object operator<<(object_api const &other) const; +- object operator<<=(object_api const &other) const; +- object operator>>(object_api const &other) const; +- object operator>>=(object_api const &other) const; +- +- PYBIND11_DEPRECATED("Use py::str(obj) instead") +- pybind11::str str() const; +- +- /// Get or set the object's docstring, i.e. ``obj.__doc__``. +- str_attr_accessor doc() const; +- +- /// Return the object's current reference count +- int ref_count() const { return static_cast(Py_REFCNT(derived().ptr())); } +- +- // TODO PYBIND11_DEPRECATED("Call py::type::handle_of(h) or py::type::of(h) instead of h.get_type()") +- handle get_type() const; +- +-private: +- bool rich_compare(object_api const &other, int value) const; +-}; +- +-PYBIND11_NAMESPACE_END(detail) +- +-/** \rst +- Holds a reference to a Python object (no reference counting) +- +- The `handle` class is a thin wrapper around an arbitrary Python object (i.e. a +- ``PyObject *`` in Python's C API). It does not perform any automatic reference +- counting and merely provides a basic C++ interface to various Python API functions. +- +- .. seealso:: +- The `object` class inherits from `handle` and adds automatic reference +- counting features. +-\endrst */ +-class handle : public detail::object_api { +-public: +- /// The default constructor creates a handle with a ``nullptr``-valued pointer +- handle() = default; +- /// Creates a ``handle`` from the given raw Python object pointer +- handle(PyObject *ptr) : m_ptr(ptr) { } // Allow implicit conversion from PyObject* +- +- /// Return the underlying ``PyObject *`` pointer +- PyObject *ptr() const { return m_ptr; } +- PyObject *&ptr() { return m_ptr; } +- +- /** \rst +- Manually increase the reference count of the Python object. Usually, it is +- preferable to use the `object` class which derives from `handle` and calls +- this function automatically. Returns a reference to itself. +- \endrst */ +- const handle& inc_ref() const & { Py_XINCREF(m_ptr); return *this; } +- +- /** \rst +- Manually decrease the reference count of the Python object. Usually, it is +- preferable to use the `object` class which derives from `handle` and calls +- this function automatically. Returns a reference to itself. +- \endrst */ +- const handle& dec_ref() const & { Py_XDECREF(m_ptr); return *this; } +- +- /** \rst +- Attempt to cast the Python object into the given C++ type. A `cast_error` +- will be throw upon failure. +- \endrst */ +- template T cast() const; +- /// Return ``true`` when the `handle` wraps a valid Python object +- explicit operator bool() const { return m_ptr != nullptr; } +- /** \rst +- Deprecated: Check that the underlying pointers are the same. +- Equivalent to ``obj1 is obj2`` in Python. +- \endrst */ +- PYBIND11_DEPRECATED("Use obj1.is(obj2) instead") +- bool operator==(const handle &h) const { return m_ptr == h.m_ptr; } +- PYBIND11_DEPRECATED("Use !obj1.is(obj2) instead") +- bool operator!=(const handle &h) const { return m_ptr != h.m_ptr; } +- PYBIND11_DEPRECATED("Use handle::operator bool() instead") +- bool check() const { return m_ptr != nullptr; } +-protected: +- PyObject *m_ptr = nullptr; +-}; +- +-/** \rst +- Holds a reference to a Python object (with reference counting) +- +- Like `handle`, the `object` class is a thin wrapper around an arbitrary Python +- object (i.e. a ``PyObject *`` in Python's C API). In contrast to `handle`, it +- optionally increases the object's reference count upon construction, and it +- *always* decreases the reference count when the `object` instance goes out of +- scope and is destructed. When using `object` instances consistently, it is much +- easier to get reference counting right at the first attempt. +-\endrst */ +-class object : public handle { +-public: +- object() = default; +- PYBIND11_DEPRECATED("Use reinterpret_borrow() or reinterpret_steal()") +- object(handle h, bool is_borrowed) : handle(h) { if (is_borrowed) inc_ref(); } +- /// Copy constructor; always increases the reference count +- object(const object &o) : handle(o) { inc_ref(); } +- /// Move constructor; steals the object from ``other`` and preserves its reference count +- object(object &&other) noexcept { m_ptr = other.m_ptr; other.m_ptr = nullptr; } +- /// Destructor; automatically calls `handle::dec_ref()` +- ~object() { dec_ref(); } +- +- /** \rst +- Resets the internal pointer to ``nullptr`` without decreasing the +- object's reference count. The function returns a raw handle to the original +- Python object. +- \endrst */ +- handle release() { +- PyObject *tmp = m_ptr; +- m_ptr = nullptr; +- return handle(tmp); +- } +- +- object& operator=(const object &other) { +- other.inc_ref(); +- dec_ref(); +- m_ptr = other.m_ptr; +- return *this; +- } +- +- object& operator=(object &&other) noexcept { +- if (this != &other) { +- handle temp(m_ptr); +- m_ptr = other.m_ptr; +- other.m_ptr = nullptr; +- temp.dec_ref(); +- } +- return *this; +- } +- +- // Calling cast() on an object lvalue just copies (via handle::cast) +- template T cast() const &; +- // Calling on an object rvalue does a move, if needed and/or possible +- template T cast() &&; +- +-protected: +- // Tags for choosing constructors from raw PyObject * +- struct borrowed_t { }; +- struct stolen_t { }; +- +- template friend T reinterpret_borrow(handle); +- template friend T reinterpret_steal(handle); +- +-public: +- // Only accessible from derived classes and the reinterpret_* functions +- object(handle h, borrowed_t) : handle(h) { inc_ref(); } +- object(handle h, stolen_t) : handle(h) { } +-}; +- +-/** \rst +- Declare that a `handle` or ``PyObject *`` is a certain type and borrow the reference. +- The target type ``T`` must be `object` or one of its derived classes. The function +- doesn't do any conversions or checks. It's up to the user to make sure that the +- target type is correct. +- +- .. code-block:: cpp +- +- PyObject *p = PyList_GetItem(obj, index); +- py::object o = reinterpret_borrow(p); +- // or +- py::tuple t = reinterpret_borrow(p); // <-- `p` must be already be a `tuple` +-\endrst */ +-template T reinterpret_borrow(handle h) { return {h, object::borrowed_t{}}; } +- +-/** \rst +- Like `reinterpret_borrow`, but steals the reference. +- +- .. code-block:: cpp +- +- PyObject *p = PyObject_Str(obj); +- py::str s = reinterpret_steal(p); // <-- `p` must be already be a `str` +-\endrst */ +-template T reinterpret_steal(handle h) { return {h, object::stolen_t{}}; } +- +-PYBIND11_NAMESPACE_BEGIN(detail) +-inline std::string error_string(); +-PYBIND11_NAMESPACE_END(detail) +- +-/// Fetch and hold an error which was already set in Python. An instance of this is typically +-/// thrown to propagate python-side errors back through C++ which can either be caught manually or +-/// else falls back to the function dispatcher (which then raises the captured error back to +-/// python). +-class error_already_set : public std::runtime_error { +-public: +- /// Constructs a new exception from the current Python error indicator, if any. The current +- /// Python error indicator will be cleared. +- error_already_set() : std::runtime_error(detail::error_string()) { +- PyErr_Fetch(&m_type.ptr(), &m_value.ptr(), &m_trace.ptr()); +- } +- +- error_already_set(const error_already_set &) = default; +- error_already_set(error_already_set &&) = default; +- +- inline ~error_already_set() override; +- +- /// Give the currently-held error back to Python, if any. If there is currently a Python error +- /// already set it is cleared first. After this call, the current object no longer stores the +- /// error variables (but the `.what()` string is still available). +- void restore() { PyErr_Restore(m_type.release().ptr(), m_value.release().ptr(), m_trace.release().ptr()); } +- +- /// If it is impossible to raise the currently-held error, such as in destructor, we can write +- /// it out using Python's unraisable hook (sys.unraisablehook). The error context should be +- /// some object whose repr() helps identify the location of the error. Python already knows the +- /// type and value of the error, so there is no need to repeat that. For example, __func__ could +- /// be helpful. After this call, the current object no longer stores the error variables, +- /// and neither does Python. +- void discard_as_unraisable(object err_context) { +- restore(); +- PyErr_WriteUnraisable(err_context.ptr()); +- } +- void discard_as_unraisable(const char *err_context) { +- discard_as_unraisable(reinterpret_steal(PYBIND11_FROM_STRING(err_context))); +- } +- +- // Does nothing; provided for backwards compatibility. +- PYBIND11_DEPRECATED("Use of error_already_set.clear() is deprecated") +- void clear() {} +- +- /// Check if the currently trapped error type matches the given Python exception class (or a +- /// subclass thereof). May also be passed a tuple to search for any exception class matches in +- /// the given tuple. +- bool matches(handle exc) const { return PyErr_GivenExceptionMatches(m_type.ptr(), exc.ptr()); } +- +- const object& type() const { return m_type; } +- const object& value() const { return m_value; } +- const object& trace() const { return m_trace; } +- +-private: +- object m_type, m_value, m_trace; +-}; +- +-/** \defgroup python_builtins _ +- Unless stated otherwise, the following C++ functions behave the same +- as their Python counterparts. +- */ +- +-/** \ingroup python_builtins +- \rst +- Return true if ``obj`` is an instance of ``T``. Type ``T`` must be a subclass of +- `object` or a class which was exposed to Python as ``py::class_``. +-\endrst */ +-template ::value, int> = 0> +-bool isinstance(handle obj) { return T::check_(obj); } +- +-template ::value, int> = 0> +-bool isinstance(handle obj) { return detail::isinstance_generic(obj, typeid(T)); } +- +-template <> inline bool isinstance(handle) = delete; +-template <> inline bool isinstance(handle obj) { return obj.ptr() != nullptr; } +- +-/// \ingroup python_builtins +-/// Return true if ``obj`` is an instance of the ``type``. +-inline bool isinstance(handle obj, handle type) { +- const auto result = PyObject_IsInstance(obj.ptr(), type.ptr()); +- if (result == -1) +- throw error_already_set(); +- return result != 0; +-} +- +-/// \addtogroup python_builtins +-/// @{ +-inline bool hasattr(handle obj, handle name) { +- return PyObject_HasAttr(obj.ptr(), name.ptr()) == 1; +-} +- +-inline bool hasattr(handle obj, const char *name) { +- return PyObject_HasAttrString(obj.ptr(), name) == 1; +-} +- +-inline void delattr(handle obj, handle name) { +- if (PyObject_DelAttr(obj.ptr(), name.ptr()) != 0) { throw error_already_set(); } +-} +- +-inline void delattr(handle obj, const char *name) { +- if (PyObject_DelAttrString(obj.ptr(), name) != 0) { throw error_already_set(); } +-} +- +-inline object getattr(handle obj, handle name) { +- PyObject *result = PyObject_GetAttr(obj.ptr(), name.ptr()); +- if (!result) { throw error_already_set(); } +- return reinterpret_steal(result); +-} +- +-inline object getattr(handle obj, const char *name) { +- PyObject *result = PyObject_GetAttrString(obj.ptr(), name); +- if (!result) { throw error_already_set(); } +- return reinterpret_steal(result); +-} +- +-inline object getattr(handle obj, handle name, handle default_) { +- if (PyObject *result = PyObject_GetAttr(obj.ptr(), name.ptr())) { +- return reinterpret_steal(result); +- } else { +- PyErr_Clear(); +- return reinterpret_borrow(default_); +- } +-} +- +-inline object getattr(handle obj, const char *name, handle default_) { +- if (PyObject *result = PyObject_GetAttrString(obj.ptr(), name)) { +- return reinterpret_steal(result); +- } else { +- PyErr_Clear(); +- return reinterpret_borrow(default_); +- } +-} +- +-inline void setattr(handle obj, handle name, handle value) { +- if (PyObject_SetAttr(obj.ptr(), name.ptr(), value.ptr()) != 0) { throw error_already_set(); } +-} +- +-inline void setattr(handle obj, const char *name, handle value) { +- if (PyObject_SetAttrString(obj.ptr(), name, value.ptr()) != 0) { throw error_already_set(); } +-} +- +-inline ssize_t hash(handle obj) { +- auto h = PyObject_Hash(obj.ptr()); +- if (h == -1) { throw error_already_set(); } +- return h; +-} +- +-/// @} python_builtins +- +-PYBIND11_NAMESPACE_BEGIN(detail) +-inline handle get_function(handle value) { +- if (value) { +-#if PY_MAJOR_VERSION >= 3 +- if (PyInstanceMethod_Check(value.ptr())) +- value = PyInstanceMethod_GET_FUNCTION(value.ptr()); +- else +-#endif +- if (PyMethod_Check(value.ptr())) +- value = PyMethod_GET_FUNCTION(value.ptr()); +- } +- return value; +-} +- +-// Helper aliases/functions to support implicit casting of values given to python accessors/methods. +-// When given a pyobject, this simply returns the pyobject as-is; for other C++ type, the value goes +-// through pybind11::cast(obj) to convert it to an `object`. +-template ::value, int> = 0> +-auto object_or_cast(T &&o) -> decltype(std::forward(o)) { return std::forward(o); } +-// The following casting version is implemented in cast.h: +-template ::value, int> = 0> +-object object_or_cast(T &&o); +-// Match a PyObject*, which we want to convert directly to handle via its converting constructor +-inline handle object_or_cast(PyObject *ptr) { return ptr; } +- +-template +-class accessor : public object_api> { +- using key_type = typename Policy::key_type; +- +-public: +- accessor(handle obj, key_type key) : obj(obj), key(std::move(key)) { } +- accessor(const accessor &) = default; +- accessor(accessor &&) = default; +- +- // accessor overload required to override default assignment operator (templates are not allowed +- // to replace default compiler-generated assignments). +- void operator=(const accessor &a) && { std::move(*this).operator=(handle(a)); } +- void operator=(const accessor &a) & { operator=(handle(a)); } +- +- template void operator=(T &&value) && { +- Policy::set(obj, key, object_or_cast(std::forward(value))); +- } +- template void operator=(T &&value) & { +- get_cache() = reinterpret_borrow(object_or_cast(std::forward(value))); +- } +- +- template +- PYBIND11_DEPRECATED("Use of obj.attr(...) as bool is deprecated in favor of pybind11::hasattr(obj, ...)") +- explicit operator enable_if_t::value || +- std::is_same::value, bool>() const { +- return hasattr(obj, key); +- } +- template +- PYBIND11_DEPRECATED("Use of obj[key] as bool is deprecated in favor of obj.contains(key)") +- explicit operator enable_if_t::value, bool>() const { +- return obj.contains(key); +- } +- +- operator object() const { return get_cache(); } +- PyObject *ptr() const { return get_cache().ptr(); } +- template T cast() const { return get_cache().template cast(); } +- +-private: +- object &get_cache() const { +- if (!cache) { cache = Policy::get(obj, key); } +- return cache; +- } +- +-private: +- handle obj; +- key_type key; +- mutable object cache; +-}; +- +-PYBIND11_NAMESPACE_BEGIN(accessor_policies) +-struct obj_attr { +- using key_type = object; +- static object get(handle obj, handle key) { return getattr(obj, key); } +- static void set(handle obj, handle key, handle val) { setattr(obj, key, val); } +-}; +- +-struct str_attr { +- using key_type = const char *; +- static object get(handle obj, const char *key) { return getattr(obj, key); } +- static void set(handle obj, const char *key, handle val) { setattr(obj, key, val); } +-}; +- +-struct generic_item { +- using key_type = object; +- +- static object get(handle obj, handle key) { +- PyObject *result = PyObject_GetItem(obj.ptr(), key.ptr()); +- if (!result) { throw error_already_set(); } +- return reinterpret_steal(result); +- } +- +- static void set(handle obj, handle key, handle val) { +- if (PyObject_SetItem(obj.ptr(), key.ptr(), val.ptr()) != 0) { throw error_already_set(); } +- } +-}; +- +-struct sequence_item { +- using key_type = size_t; +- +- static object get(handle obj, size_t index) { +- PyObject *result = PySequence_GetItem(obj.ptr(), static_cast(index)); +- if (!result) { throw error_already_set(); } +- return reinterpret_steal(result); +- } +- +- static void set(handle obj, size_t index, handle val) { +- // PySequence_SetItem does not steal a reference to 'val' +- if (PySequence_SetItem(obj.ptr(), static_cast(index), val.ptr()) != 0) { +- throw error_already_set(); +- } +- } +-}; +- +-struct list_item { +- using key_type = size_t; +- +- static object get(handle obj, size_t index) { +- PyObject *result = PyList_GetItem(obj.ptr(), static_cast(index)); +- if (!result) { throw error_already_set(); } +- return reinterpret_borrow(result); +- } +- +- static void set(handle obj, size_t index, handle val) { +- // PyList_SetItem steals a reference to 'val' +- if (PyList_SetItem(obj.ptr(), static_cast(index), val.inc_ref().ptr()) != 0) { +- throw error_already_set(); +- } +- } +-}; +- +-struct tuple_item { +- using key_type = size_t; +- +- static object get(handle obj, size_t index) { +- PyObject *result = PyTuple_GetItem(obj.ptr(), static_cast(index)); +- if (!result) { throw error_already_set(); } +- return reinterpret_borrow(result); +- } +- +- static void set(handle obj, size_t index, handle val) { +- // PyTuple_SetItem steals a reference to 'val' +- if (PyTuple_SetItem(obj.ptr(), static_cast(index), val.inc_ref().ptr()) != 0) { +- throw error_already_set(); +- } +- } +-}; +-PYBIND11_NAMESPACE_END(accessor_policies) +- +-/// STL iterator template used for tuple, list, sequence and dict +-template +-class generic_iterator : public Policy { +- using It = generic_iterator; +- +-public: +- using difference_type = ssize_t; +- using iterator_category = typename Policy::iterator_category; +- using value_type = typename Policy::value_type; +- using reference = typename Policy::reference; +- using pointer = typename Policy::pointer; +- +- generic_iterator() = default; +- generic_iterator(handle seq, ssize_t index) : Policy(seq, index) { } +- +- reference operator*() const { return Policy::dereference(); } +- reference operator[](difference_type n) const { return *(*this + n); } +- pointer operator->() const { return **this; } +- +- It &operator++() { Policy::increment(); return *this; } +- It operator++(int) { auto copy = *this; Policy::increment(); return copy; } +- It &operator--() { Policy::decrement(); return *this; } +- It operator--(int) { auto copy = *this; Policy::decrement(); return copy; } +- It &operator+=(difference_type n) { Policy::advance(n); return *this; } +- It &operator-=(difference_type n) { Policy::advance(-n); return *this; } +- +- friend It operator+(const It &a, difference_type n) { auto copy = a; return copy += n; } +- friend It operator+(difference_type n, const It &b) { return b + n; } +- friend It operator-(const It &a, difference_type n) { auto copy = a; return copy -= n; } +- friend difference_type operator-(const It &a, const It &b) { return a.distance_to(b); } +- +- friend bool operator==(const It &a, const It &b) { return a.equal(b); } +- friend bool operator!=(const It &a, const It &b) { return !(a == b); } +- friend bool operator< (const It &a, const It &b) { return b - a > 0; } +- friend bool operator> (const It &a, const It &b) { return b < a; } +- friend bool operator>=(const It &a, const It &b) { return !(a < b); } +- friend bool operator<=(const It &a, const It &b) { return !(a > b); } +-}; +- +-PYBIND11_NAMESPACE_BEGIN(iterator_policies) +-/// Quick proxy class needed to implement ``operator->`` for iterators which can't return pointers +-template +-struct arrow_proxy { +- T value; +- +- arrow_proxy(T &&value) : value(std::move(value)) { } +- T *operator->() const { return &value; } +-}; +- +-/// Lightweight iterator policy using just a simple pointer: see ``PySequence_Fast_ITEMS`` +-class sequence_fast_readonly { +-protected: +- using iterator_category = std::random_access_iterator_tag; +- using value_type = handle; +- using reference = const handle; +- using pointer = arrow_proxy; +- +- sequence_fast_readonly(handle obj, ssize_t n) : ptr(PySequence_Fast_ITEMS(obj.ptr()) + n) { } +- +- reference dereference() const { return *ptr; } +- void increment() { ++ptr; } +- void decrement() { --ptr; } +- void advance(ssize_t n) { ptr += n; } +- bool equal(const sequence_fast_readonly &b) const { return ptr == b.ptr; } +- ssize_t distance_to(const sequence_fast_readonly &b) const { return ptr - b.ptr; } +- +-private: +- PyObject **ptr; +-}; +- +-/// Full read and write access using the sequence protocol: see ``detail::sequence_accessor`` +-class sequence_slow_readwrite { +-protected: +- using iterator_category = std::random_access_iterator_tag; +- using value_type = object; +- using reference = sequence_accessor; +- using pointer = arrow_proxy; +- +- sequence_slow_readwrite(handle obj, ssize_t index) : obj(obj), index(index) { } +- +- reference dereference() const { return {obj, static_cast(index)}; } +- void increment() { ++index; } +- void decrement() { --index; } +- void advance(ssize_t n) { index += n; } +- bool equal(const sequence_slow_readwrite &b) const { return index == b.index; } +- ssize_t distance_to(const sequence_slow_readwrite &b) const { return index - b.index; } +- +-private: +- handle obj; +- ssize_t index; +-}; +- +-/// Python's dictionary protocol permits this to be a forward iterator +-class dict_readonly { +-protected: +- using iterator_category = std::forward_iterator_tag; +- using value_type = std::pair; +- using reference = const value_type; +- using pointer = arrow_proxy; +- +- dict_readonly() = default; +- dict_readonly(handle obj, ssize_t pos) : obj(obj), pos(pos) { increment(); } +- +- reference dereference() const { return {key, value}; } +- void increment() { if (!PyDict_Next(obj.ptr(), &pos, &key, &value)) { pos = -1; } } +- bool equal(const dict_readonly &b) const { return pos == b.pos; } +- +-private: +- handle obj; +- PyObject *key = nullptr, *value = nullptr; +- ssize_t pos = -1; +-}; +-PYBIND11_NAMESPACE_END(iterator_policies) +- +-#if !defined(PYPY_VERSION) +-using tuple_iterator = generic_iterator; +-using list_iterator = generic_iterator; +-#else +-using tuple_iterator = generic_iterator; +-using list_iterator = generic_iterator; +-#endif +- +-using sequence_iterator = generic_iterator; +-using dict_iterator = generic_iterator; +- +-inline bool PyIterable_Check(PyObject *obj) { +- PyObject *iter = PyObject_GetIter(obj); +- if (iter) { +- Py_DECREF(iter); +- return true; +- } else { +- PyErr_Clear(); +- return false; +- } +-} +- +-inline bool PyNone_Check(PyObject *o) { return o == Py_None; } +-inline bool PyEllipsis_Check(PyObject *o) { return o == Py_Ellipsis; } +- +-inline bool PyUnicode_Check_Permissive(PyObject *o) { return PyUnicode_Check(o) || PYBIND11_BYTES_CHECK(o); } +- +-inline bool PyStaticMethod_Check(PyObject *o) { return o->ob_type == &PyStaticMethod_Type; } +- +-class kwargs_proxy : public handle { +-public: +- explicit kwargs_proxy(handle h) : handle(h) { } +-}; +- +-class args_proxy : public handle { +-public: +- explicit args_proxy(handle h) : handle(h) { } +- kwargs_proxy operator*() const { return kwargs_proxy(*this); } +-}; +- +-/// Python argument categories (using PEP 448 terms) +-template using is_keyword = std::is_base_of; +-template using is_s_unpacking = std::is_same; // * unpacking +-template using is_ds_unpacking = std::is_same; // ** unpacking +-template using is_positional = satisfies_none_of; +-template using is_keyword_or_ds = satisfies_any_of; +- +-// Call argument collector forward declarations +-template +-class simple_collector; +-template +-class unpacking_collector; +- +-PYBIND11_NAMESPACE_END(detail) +- +-// TODO: After the deprecated constructors are removed, this macro can be simplified by +-// inheriting ctors: `using Parent::Parent`. It's not an option right now because +-// the `using` statement triggers the parent deprecation warning even if the ctor +-// isn't even used. +-#define PYBIND11_OBJECT_COMMON(Name, Parent, CheckFun) \ +- public: \ +- PYBIND11_DEPRECATED("Use reinterpret_borrow<"#Name">() or reinterpret_steal<"#Name">()") \ +- Name(handle h, bool is_borrowed) : Parent(is_borrowed ? Parent(h, borrowed_t{}) : Parent(h, stolen_t{})) { } \ +- Name(handle h, borrowed_t) : Parent(h, borrowed_t{}) { } \ +- Name(handle h, stolen_t) : Parent(h, stolen_t{}) { } \ +- PYBIND11_DEPRECATED("Use py::isinstance(obj) instead") \ +- bool check() const { return m_ptr != nullptr && (bool) CheckFun(m_ptr); } \ +- static bool check_(handle h) { return h.ptr() != nullptr && CheckFun(h.ptr()); } \ +- template \ +- Name(const ::pybind11::detail::accessor &a) : Name(object(a)) { } +- +-#define PYBIND11_OBJECT_CVT(Name, Parent, CheckFun, ConvertFun) \ +- PYBIND11_OBJECT_COMMON(Name, Parent, CheckFun) \ +- /* This is deliberately not 'explicit' to allow implicit conversion from object: */ \ +- Name(const object &o) \ +- : Parent(check_(o) ? o.inc_ref().ptr() : ConvertFun(o.ptr()), stolen_t{}) \ +- { if (!m_ptr) throw error_already_set(); } \ +- Name(object &&o) \ +- : Parent(check_(o) ? o.release().ptr() : ConvertFun(o.ptr()), stolen_t{}) \ +- { if (!m_ptr) throw error_already_set(); } +- +-#define PYBIND11_OBJECT_CHECK_FAILED(Name, o) \ +- ::pybind11::type_error("Object of type '" + \ +- ::pybind11::detail::get_fully_qualified_tp_name(Py_TYPE(o.ptr())) + \ +- "' is not an instance of '" #Name "'") +- +-#define PYBIND11_OBJECT(Name, Parent, CheckFun) \ +- PYBIND11_OBJECT_COMMON(Name, Parent, CheckFun) \ +- /* This is deliberately not 'explicit' to allow implicit conversion from object: */ \ +- Name(const object &o) : Parent(o) \ +- { if (o && !check_(o)) throw PYBIND11_OBJECT_CHECK_FAILED(Name, o); } \ +- Name(object &&o) : Parent(std::move(o)) \ +- { if (o && !check_(o)) throw PYBIND11_OBJECT_CHECK_FAILED(Name, o); } +- +-#define PYBIND11_OBJECT_DEFAULT(Name, Parent, CheckFun) \ +- PYBIND11_OBJECT(Name, Parent, CheckFun) \ +- Name() : Parent() { } +- +-/// \addtogroup pytypes +-/// @{ +- +-/** \rst +- Wraps a Python iterator so that it can also be used as a C++ input iterator +- +- Caveat: copying an iterator does not (and cannot) clone the internal +- state of the Python iterable. This also applies to the post-increment +- operator. This iterator should only be used to retrieve the current +- value using ``operator*()``. +-\endrst */ +-class iterator : public object { +-public: +- using iterator_category = std::input_iterator_tag; +- using difference_type = ssize_t; +- using value_type = handle; +- using reference = const handle; +- using pointer = const handle *; +- +- PYBIND11_OBJECT_DEFAULT(iterator, object, PyIter_Check) +- +- iterator& operator++() { +- advance(); +- return *this; +- } +- +- iterator operator++(int) { +- auto rv = *this; +- advance(); +- return rv; +- } +- +- reference operator*() const { +- if (m_ptr && !value.ptr()) { +- auto& self = const_cast(*this); +- self.advance(); +- } +- return value; +- } +- +- pointer operator->() const { operator*(); return &value; } +- +- /** \rst +- The value which marks the end of the iteration. ``it == iterator::sentinel()`` +- is equivalent to catching ``StopIteration`` in Python. +- +- .. code-block:: cpp +- +- void foo(py::iterator it) { +- while (it != py::iterator::sentinel()) { +- // use `*it` +- ++it; +- } +- } +- \endrst */ +- static iterator sentinel() { return {}; } +- +- friend bool operator==(const iterator &a, const iterator &b) { return a->ptr() == b->ptr(); } +- friend bool operator!=(const iterator &a, const iterator &b) { return a->ptr() != b->ptr(); } +- +-private: +- void advance() { +- value = reinterpret_steal(PyIter_Next(m_ptr)); +- if (PyErr_Occurred()) { throw error_already_set(); } +- } +- +-private: +- object value = {}; +-}; +- +- +- +-class type : public object { +-public: +- PYBIND11_OBJECT(type, object, PyType_Check) +- +- /// Return a type handle from a handle or an object +- static handle handle_of(handle h) { return handle((PyObject*) Py_TYPE(h.ptr())); } +- +- /// Return a type object from a handle or an object +- static type of(handle h) { return type(type::handle_of(h), borrowed_t{}); } +- +- // Defined in pybind11/cast.h +- /// Convert C++ type to handle if previously registered. Does not convert +- /// standard types, like int, float. etc. yet. +- /// See https://github.com/pybind/pybind11/issues/2486 +- template +- static handle handle_of(); +- +- /// Convert C++ type to type if previously registered. Does not convert +- /// standard types, like int, float. etc. yet. +- /// See https://github.com/pybind/pybind11/issues/2486 +- template +- static type of() {return type(type::handle_of(), borrowed_t{}); } +-}; +- +-class iterable : public object { +-public: +- PYBIND11_OBJECT_DEFAULT(iterable, object, detail::PyIterable_Check) +-}; +- +-class bytes; +- +-class str : public object { +-public: +- PYBIND11_OBJECT_CVT(str, object, detail::PyUnicode_Check_Permissive, raw_str) +- +- str(const char *c, size_t n) +- : object(PyUnicode_FromStringAndSize(c, (ssize_t) n), stolen_t{}) { +- if (!m_ptr) pybind11_fail("Could not allocate string object!"); +- } +- +- // 'explicit' is explicitly omitted from the following constructors to allow implicit conversion to py::str from C++ string-like objects +- str(const char *c = "") +- : object(PyUnicode_FromString(c), stolen_t{}) { +- if (!m_ptr) pybind11_fail("Could not allocate string object!"); +- } +- +- str(const std::string &s) : str(s.data(), s.size()) { } +- +- explicit str(const bytes &b); +- +- /** \rst +- Return a string representation of the object. This is analogous to +- the ``str()`` function in Python. +- \endrst */ +- explicit str(handle h) : object(raw_str(h.ptr()), stolen_t{}) { if (!m_ptr) throw error_already_set(); } +- +- operator std::string() const { +- object temp = *this; +- if (PyUnicode_Check(m_ptr)) { +- temp = reinterpret_steal(PyUnicode_AsUTF8String(m_ptr)); +- if (!temp) +- pybind11_fail("Unable to extract string contents! (encoding issue)"); +- } +- char *buffer; +- ssize_t length; +- if (PYBIND11_BYTES_AS_STRING_AND_SIZE(temp.ptr(), &buffer, &length)) +- pybind11_fail("Unable to extract string contents! (invalid type)"); +- return std::string(buffer, (size_t) length); +- } +- +- template +- str format(Args &&...args) const { +- return attr("format")(std::forward(args)...); +- } +- +-private: +- /// Return string representation -- always returns a new reference, even if already a str +- static PyObject *raw_str(PyObject *op) { +- PyObject *str_value = PyObject_Str(op); +-#if PY_MAJOR_VERSION < 3 +- if (!str_value) throw error_already_set(); +- PyObject *unicode = PyUnicode_FromEncodedObject(str_value, "utf-8", nullptr); +- Py_XDECREF(str_value); str_value = unicode; +-#endif +- return str_value; +- } +-}; +-/// @} pytypes +- +-inline namespace literals { +-/** \rst +- String literal version of `str` +- \endrst */ +-inline str operator"" _s(const char *s, size_t size) { return {s, size}; } +-} // namespace literals +- +-/// \addtogroup pytypes +-/// @{ +-class bytes : public object { +-public: +- PYBIND11_OBJECT(bytes, object, PYBIND11_BYTES_CHECK) +- +- // Allow implicit conversion: +- bytes(const char *c = "") +- : object(PYBIND11_BYTES_FROM_STRING(c), stolen_t{}) { +- if (!m_ptr) pybind11_fail("Could not allocate bytes object!"); +- } +- +- bytes(const char *c, size_t n) +- : object(PYBIND11_BYTES_FROM_STRING_AND_SIZE(c, (ssize_t) n), stolen_t{}) { +- if (!m_ptr) pybind11_fail("Could not allocate bytes object!"); +- } +- +- // Allow implicit conversion: +- bytes(const std::string &s) : bytes(s.data(), s.size()) { } +- +- explicit bytes(const pybind11::str &s); +- +- operator std::string() const { +- char *buffer; +- ssize_t length; +- if (PYBIND11_BYTES_AS_STRING_AND_SIZE(m_ptr, &buffer, &length)) +- pybind11_fail("Unable to extract bytes contents!"); +- return std::string(buffer, (size_t) length); +- } +-}; +-// Note: breathe >= 4.17.0 will fail to build docs if the below two constructors +-// are included in the doxygen group; close here and reopen after as a workaround +-/// @} pytypes +- +-inline bytes::bytes(const pybind11::str &s) { +- object temp = s; +- if (PyUnicode_Check(s.ptr())) { +- temp = reinterpret_steal(PyUnicode_AsUTF8String(s.ptr())); +- if (!temp) +- pybind11_fail("Unable to extract string contents! (encoding issue)"); +- } +- char *buffer; +- ssize_t length; +- if (PYBIND11_BYTES_AS_STRING_AND_SIZE(temp.ptr(), &buffer, &length)) +- pybind11_fail("Unable to extract string contents! (invalid type)"); +- auto obj = reinterpret_steal(PYBIND11_BYTES_FROM_STRING_AND_SIZE(buffer, length)); +- if (!obj) +- pybind11_fail("Could not allocate bytes object!"); +- m_ptr = obj.release().ptr(); +-} +- +-inline str::str(const bytes& b) { +- char *buffer; +- ssize_t length; +- if (PYBIND11_BYTES_AS_STRING_AND_SIZE(b.ptr(), &buffer, &length)) +- pybind11_fail("Unable to extract bytes contents!"); +- auto obj = reinterpret_steal(PyUnicode_FromStringAndSize(buffer, (ssize_t) length)); +- if (!obj) +- pybind11_fail("Could not allocate string object!"); +- m_ptr = obj.release().ptr(); +-} +- +-/// \addtogroup pytypes +-/// @{ +-class none : public object { +-public: +- PYBIND11_OBJECT(none, object, detail::PyNone_Check) +- none() : object(Py_None, borrowed_t{}) { } +-}; +- +-class ellipsis : public object { +-public: +- PYBIND11_OBJECT(ellipsis, object, detail::PyEllipsis_Check) +- ellipsis() : object(Py_Ellipsis, borrowed_t{}) { } +-}; +- +-class bool_ : public object { +-public: +- PYBIND11_OBJECT_CVT(bool_, object, PyBool_Check, raw_bool) +- bool_() : object(Py_False, borrowed_t{}) { } +- // Allow implicit conversion from and to `bool`: +- bool_(bool value) : object(value ? Py_True : Py_False, borrowed_t{}) { } +- operator bool() const { return m_ptr && PyLong_AsLong(m_ptr) != 0; } +- +-private: +- /// Return the truth value of an object -- always returns a new reference +- static PyObject *raw_bool(PyObject *op) { +- const auto value = PyObject_IsTrue(op); +- if (value == -1) return nullptr; +- return handle(value ? Py_True : Py_False).inc_ref().ptr(); +- } +-}; +- +-PYBIND11_NAMESPACE_BEGIN(detail) +-// Converts a value to the given unsigned type. If an error occurs, you get back (Unsigned) -1; +-// otherwise you get back the unsigned long or unsigned long long value cast to (Unsigned). +-// (The distinction is critically important when casting a returned -1 error value to some other +-// unsigned type: (A)-1 != (B)-1 when A and B are unsigned types of different sizes). +-template +-Unsigned as_unsigned(PyObject *o) { +- if (sizeof(Unsigned) <= sizeof(unsigned long) +-#if PY_VERSION_HEX < 0x03000000 +- || PyInt_Check(o) +-#endif +- ) { +- unsigned long v = PyLong_AsUnsignedLong(o); +- return v == (unsigned long) -1 && PyErr_Occurred() ? (Unsigned) -1 : (Unsigned) v; +- } +- else { +- unsigned long long v = PyLong_AsUnsignedLongLong(o); +- return v == (unsigned long long) -1 && PyErr_Occurred() ? (Unsigned) -1 : (Unsigned) v; +- } +-} +-PYBIND11_NAMESPACE_END(detail) +- +-class int_ : public object { +-public: +- PYBIND11_OBJECT_CVT(int_, object, PYBIND11_LONG_CHECK, PyNumber_Long) +- int_() : object(PyLong_FromLong(0), stolen_t{}) { } +- // Allow implicit conversion from C++ integral types: +- template ::value, int> = 0> +- int_(T value) { +- if (sizeof(T) <= sizeof(long)) { +- if (std::is_signed::value) +- m_ptr = PyLong_FromLong((long) value); +- else +- m_ptr = PyLong_FromUnsignedLong((unsigned long) value); +- } else { +- if (std::is_signed::value) +- m_ptr = PyLong_FromLongLong((long long) value); +- else +- m_ptr = PyLong_FromUnsignedLongLong((unsigned long long) value); +- } +- if (!m_ptr) pybind11_fail("Could not allocate int object!"); +- } +- +- template ::value, int> = 0> +- operator T() const { +- return std::is_unsigned::value +- ? detail::as_unsigned(m_ptr) +- : sizeof(T) <= sizeof(long) +- ? (T) PyLong_AsLong(m_ptr) +- : (T) PYBIND11_LONG_AS_LONGLONG(m_ptr); +- } +-}; +- +-class float_ : public object { +-public: +- PYBIND11_OBJECT_CVT(float_, object, PyFloat_Check, PyNumber_Float) +- // Allow implicit conversion from float/double: +- float_(float value) : object(PyFloat_FromDouble((double) value), stolen_t{}) { +- if (!m_ptr) pybind11_fail("Could not allocate float object!"); +- } +- float_(double value = .0) : object(PyFloat_FromDouble((double) value), stolen_t{}) { +- if (!m_ptr) pybind11_fail("Could not allocate float object!"); +- } +- operator float() const { return (float) PyFloat_AsDouble(m_ptr); } +- operator double() const { return (double) PyFloat_AsDouble(m_ptr); } +-}; +- +-class weakref : public object { +-public: +- PYBIND11_OBJECT_DEFAULT(weakref, object, PyWeakref_Check) +- explicit weakref(handle obj, handle callback = {}) +- : object(PyWeakref_NewRef(obj.ptr(), callback.ptr()), stolen_t{}) { +- if (!m_ptr) pybind11_fail("Could not allocate weak reference!"); +- } +-}; +- +-class slice : public object { +-public: +- PYBIND11_OBJECT_DEFAULT(slice, object, PySlice_Check) +- slice(ssize_t start_, ssize_t stop_, ssize_t step_) { +- int_ start(start_), stop(stop_), step(step_); +- m_ptr = PySlice_New(start.ptr(), stop.ptr(), step.ptr()); +- if (!m_ptr) pybind11_fail("Could not allocate slice object!"); +- } +- bool compute(size_t length, size_t *start, size_t *stop, size_t *step, +- size_t *slicelength) const { +- return PySlice_GetIndicesEx((PYBIND11_SLICE_OBJECT *) m_ptr, +- (ssize_t) length, (ssize_t *) start, +- (ssize_t *) stop, (ssize_t *) step, +- (ssize_t *) slicelength) == 0; +- } +- bool compute(ssize_t length, ssize_t *start, ssize_t *stop, ssize_t *step, +- ssize_t *slicelength) const { +- return PySlice_GetIndicesEx((PYBIND11_SLICE_OBJECT *) m_ptr, +- length, start, +- stop, step, +- slicelength) == 0; +- } +-}; +- +-class capsule : public object { +-public: +- PYBIND11_OBJECT_DEFAULT(capsule, object, PyCapsule_CheckExact) +- PYBIND11_DEPRECATED("Use reinterpret_borrow() or reinterpret_steal()") +- capsule(PyObject *ptr, bool is_borrowed) : object(is_borrowed ? object(ptr, borrowed_t{}) : object(ptr, stolen_t{})) { } +- +- explicit capsule(const void *value, const char *name = nullptr, void (*destructor)(PyObject *) = nullptr) +- : object(PyCapsule_New(const_cast(value), name, destructor), stolen_t{}) { +- if (!m_ptr) +- pybind11_fail("Could not allocate capsule object!"); +- } +- +- PYBIND11_DEPRECATED("Please pass a destructor that takes a void pointer as input") +- capsule(const void *value, void (*destruct)(PyObject *)) +- : object(PyCapsule_New(const_cast(value), nullptr, destruct), stolen_t{}) { +- if (!m_ptr) +- pybind11_fail("Could not allocate capsule object!"); +- } +- +- capsule(const void *value, void (*destructor)(void *)) { +- m_ptr = PyCapsule_New(const_cast(value), nullptr, [](PyObject *o) { +- auto destructor = reinterpret_cast(PyCapsule_GetContext(o)); +- void *ptr = PyCapsule_GetPointer(o, nullptr); +- destructor(ptr); +- }); +- +- if (!m_ptr) +- pybind11_fail("Could not allocate capsule object!"); +- +- if (PyCapsule_SetContext(m_ptr, (void *) destructor) != 0) +- pybind11_fail("Could not set capsule context!"); +- } +- +- capsule(void (*destructor)()) { +- m_ptr = PyCapsule_New(reinterpret_cast(destructor), nullptr, [](PyObject *o) { +- auto destructor = reinterpret_cast(PyCapsule_GetPointer(o, nullptr)); +- destructor(); +- }); +- +- if (!m_ptr) +- pybind11_fail("Could not allocate capsule object!"); +- } +- +- template operator T *() const { +- return get_pointer(); +- } +- +- /// Get the pointer the capsule holds. +- template +- T* get_pointer() const { +- auto name = this->name(); +- T *result = static_cast(PyCapsule_GetPointer(m_ptr, name)); +- if (!result) pybind11_fail("Unable to extract capsule contents!"); +- return result; +- } +- +- /// Replaces a capsule's pointer *without* calling the destructor on the existing one. +- void set_pointer(const void *value) { +- if (PyCapsule_SetPointer(m_ptr, const_cast(value)) != 0) +- pybind11_fail("Could not set capsule pointer"); +- } +- +- const char *name() const { return PyCapsule_GetName(m_ptr); } +-}; +- +-class tuple : public object { +-public: +- PYBIND11_OBJECT_CVT(tuple, object, PyTuple_Check, PySequence_Tuple) +- explicit tuple(size_t size = 0) : object(PyTuple_New((ssize_t) size), stolen_t{}) { +- if (!m_ptr) pybind11_fail("Could not allocate tuple object!"); +- } +- size_t size() const { return (size_t) PyTuple_Size(m_ptr); } +- bool empty() const { return size() == 0; } +- detail::tuple_accessor operator[](size_t index) const { return {*this, index}; } +- detail::item_accessor operator[](handle h) const { return object::operator[](h); } +- detail::tuple_iterator begin() const { return {*this, 0}; } +- detail::tuple_iterator end() const { return {*this, PyTuple_GET_SIZE(m_ptr)}; } +-}; +- +-class dict : public object { +-public: +- PYBIND11_OBJECT_CVT(dict, object, PyDict_Check, raw_dict) +- dict() : object(PyDict_New(), stolen_t{}) { +- if (!m_ptr) pybind11_fail("Could not allocate dict object!"); +- } +- template ...>::value>, +- // MSVC workaround: it can't compile an out-of-line definition, so defer the collector +- typename collector = detail::deferred_t, Args...>> +- explicit dict(Args &&...args) : dict(collector(std::forward(args)...).kwargs()) { } +- +- size_t size() const { return (size_t) PyDict_Size(m_ptr); } +- bool empty() const { return size() == 0; } +- detail::dict_iterator begin() const { return {*this, 0}; } +- detail::dict_iterator end() const { return {}; } +- void clear() const { PyDict_Clear(ptr()); } +- template bool contains(T &&key) const { +- return PyDict_Contains(m_ptr, detail::object_or_cast(std::forward(key)).ptr()) == 1; +- } +- +-private: +- /// Call the `dict` Python type -- always returns a new reference +- static PyObject *raw_dict(PyObject *op) { +- if (PyDict_Check(op)) +- return handle(op).inc_ref().ptr(); +- return PyObject_CallFunctionObjArgs((PyObject *) &PyDict_Type, op, nullptr); +- } +-}; +- +-class sequence : public object { +-public: +- PYBIND11_OBJECT_DEFAULT(sequence, object, PySequence_Check) +- size_t size() const { +- ssize_t result = PySequence_Size(m_ptr); +- if (result == -1) +- throw error_already_set(); +- return (size_t) result; +- } +- bool empty() const { return size() == 0; } +- detail::sequence_accessor operator[](size_t index) const { return {*this, index}; } +- detail::item_accessor operator[](handle h) const { return object::operator[](h); } +- detail::sequence_iterator begin() const { return {*this, 0}; } +- detail::sequence_iterator end() const { return {*this, PySequence_Size(m_ptr)}; } +-}; +- +-class list : public object { +-public: +- PYBIND11_OBJECT_CVT(list, object, PyList_Check, PySequence_List) +- explicit list(size_t size = 0) : object(PyList_New((ssize_t) size), stolen_t{}) { +- if (!m_ptr) pybind11_fail("Could not allocate list object!"); +- } +- size_t size() const { return (size_t) PyList_Size(m_ptr); } +- bool empty() const { return size() == 0; } +- detail::list_accessor operator[](size_t index) const { return {*this, index}; } +- detail::item_accessor operator[](handle h) const { return object::operator[](h); } +- detail::list_iterator begin() const { return {*this, 0}; } +- detail::list_iterator end() const { return {*this, PyList_GET_SIZE(m_ptr)}; } +- template void append(T &&val) const { +- PyList_Append(m_ptr, detail::object_or_cast(std::forward(val)).ptr()); +- } +- template void insert(size_t index, T &&val) const { +- PyList_Insert(m_ptr, static_cast(index), +- detail::object_or_cast(std::forward(val)).ptr()); +- } +-}; +- +-class args : public tuple { PYBIND11_OBJECT_DEFAULT(args, tuple, PyTuple_Check) }; +-class kwargs : public dict { PYBIND11_OBJECT_DEFAULT(kwargs, dict, PyDict_Check) }; +- +-class set : public object { +-public: +- PYBIND11_OBJECT_CVT(set, object, PySet_Check, PySet_New) +- set() : object(PySet_New(nullptr), stolen_t{}) { +- if (!m_ptr) pybind11_fail("Could not allocate set object!"); +- } +- size_t size() const { return (size_t) PySet_Size(m_ptr); } +- bool empty() const { return size() == 0; } +- template bool add(T &&val) const { +- return PySet_Add(m_ptr, detail::object_or_cast(std::forward(val)).ptr()) == 0; +- } +- void clear() const { PySet_Clear(m_ptr); } +- template bool contains(T &&val) const { +- return PySet_Contains(m_ptr, detail::object_or_cast(std::forward(val)).ptr()) == 1; +- } +-}; +- +-class function : public object { +-public: +- PYBIND11_OBJECT_DEFAULT(function, object, PyCallable_Check) +- handle cpp_function() const { +- handle fun = detail::get_function(m_ptr); +- if (fun && PyCFunction_Check(fun.ptr())) +- return fun; +- return handle(); +- } +- bool is_cpp_function() const { return (bool) cpp_function(); } +-}; +- +-class staticmethod : public object { +-public: +- PYBIND11_OBJECT_CVT(staticmethod, object, detail::PyStaticMethod_Check, PyStaticMethod_New) +-}; +- +-class buffer : public object { +-public: +- PYBIND11_OBJECT_DEFAULT(buffer, object, PyObject_CheckBuffer) +- +- buffer_info request(bool writable = false) const { +- int flags = PyBUF_STRIDES | PyBUF_FORMAT; +- if (writable) flags |= PyBUF_WRITABLE; +- auto *view = new Py_buffer(); +- if (PyObject_GetBuffer(m_ptr, view, flags) != 0) { +- delete view; +- throw error_already_set(); +- } +- return buffer_info(view); +- } +-}; +- +-class memoryview : public object { +-public: +- PYBIND11_OBJECT_CVT(memoryview, object, PyMemoryView_Check, PyMemoryView_FromObject) +- +- /** \rst +- Creates ``memoryview`` from ``buffer_info``. +- +- ``buffer_info`` must be created from ``buffer::request()``. Otherwise +- throws an exception. +- +- For creating a ``memoryview`` from objects that support buffer protocol, +- use ``memoryview(const object& obj)`` instead of this constructor. +- \endrst */ +- explicit memoryview(const buffer_info& info) { +- if (!info.view()) +- pybind11_fail("Prohibited to create memoryview without Py_buffer"); +- // Note: PyMemoryView_FromBuffer never increments obj reference. +- m_ptr = (info.view()->obj) ? +- PyMemoryView_FromObject(info.view()->obj) : +- PyMemoryView_FromBuffer(info.view()); +- if (!m_ptr) +- pybind11_fail("Unable to create memoryview from buffer descriptor"); +- } +- +- /** \rst +- Creates ``memoryview`` from static buffer. +- +- This method is meant for providing a ``memoryview`` for C/C++ buffer not +- managed by Python. The caller is responsible for managing the lifetime +- of ``ptr`` and ``format``, which MUST outlive the memoryview constructed +- here. +- +- See also: Python C API documentation for `PyMemoryView_FromBuffer`_. +- +- .. _PyMemoryView_FromBuffer: https://docs.python.org/c-api/memoryview.html#c.PyMemoryView_FromBuffer +- +- :param ptr: Pointer to the buffer. +- :param itemsize: Byte size of an element. +- :param format: Pointer to the null-terminated format string. For +- homogeneous Buffers, this should be set to +- ``format_descriptor::value``. +- :param shape: Shape of the tensor (1 entry per dimension). +- :param strides: Number of bytes between adjacent entries (for each +- per dimension). +- :param readonly: Flag to indicate if the underlying storage may be +- written to. +- \endrst */ +- static memoryview from_buffer( +- void *ptr, ssize_t itemsize, const char *format, +- detail::any_container shape, +- detail::any_container strides, bool readonly = false); +- +- static memoryview from_buffer( +- const void *ptr, ssize_t itemsize, const char *format, +- detail::any_container shape, +- detail::any_container strides) { +- return memoryview::from_buffer( +- const_cast(ptr), itemsize, format, shape, strides, true); +- } +- +- template +- static memoryview from_buffer( +- T *ptr, detail::any_container shape, +- detail::any_container strides, bool readonly = false) { +- return memoryview::from_buffer( +- reinterpret_cast(ptr), sizeof(T), +- format_descriptor::value, shape, strides, readonly); +- } +- +- template +- static memoryview from_buffer( +- const T *ptr, detail::any_container shape, +- detail::any_container strides) { +- return memoryview::from_buffer( +- const_cast(ptr), shape, strides, true); +- } +- +-#if PY_MAJOR_VERSION >= 3 +- /** \rst +- Creates ``memoryview`` from static memory. +- +- This method is meant for providing a ``memoryview`` for C/C++ buffer not +- managed by Python. The caller is responsible for managing the lifetime +- of ``mem``, which MUST outlive the memoryview constructed here. +- +- This method is not available in Python 2. +- +- See also: Python C API documentation for `PyMemoryView_FromBuffer`_. +- +- .. _PyMemoryView_FromMemory: https://docs.python.org/c-api/memoryview.html#c.PyMemoryView_FromMemory +- \endrst */ +- static memoryview from_memory(void *mem, ssize_t size, bool readonly = false) { +- PyObject* ptr = PyMemoryView_FromMemory( +- reinterpret_cast(mem), size, +- (readonly) ? PyBUF_READ : PyBUF_WRITE); +- if (!ptr) +- pybind11_fail("Could not allocate memoryview object!"); +- return memoryview(object(ptr, stolen_t{})); +- } +- +- static memoryview from_memory(const void *mem, ssize_t size) { +- return memoryview::from_memory(const_cast(mem), size, true); +- } +-#endif +-}; +- +-#ifndef DOXYGEN_SHOULD_SKIP_THIS +-inline memoryview memoryview::from_buffer( +- void *ptr, ssize_t itemsize, const char* format, +- detail::any_container shape, +- detail::any_container strides, bool readonly) { +- size_t ndim = shape->size(); +- if (ndim != strides->size()) +- pybind11_fail("memoryview: shape length doesn't match strides length"); +- ssize_t size = ndim ? 1 : 0; +- for (size_t i = 0; i < ndim; ++i) +- size *= (*shape)[i]; +- Py_buffer view; +- view.buf = ptr; +- view.obj = nullptr; +- view.len = size * itemsize; +- view.readonly = static_cast(readonly); +- view.itemsize = itemsize; +- view.format = const_cast(format); +- view.ndim = static_cast(ndim); +- view.shape = shape->data(); +- view.strides = strides->data(); +- view.suboffsets = nullptr; +- view.internal = nullptr; +- PyObject* obj = PyMemoryView_FromBuffer(&view); +- if (!obj) +- throw error_already_set(); +- return memoryview(object(obj, stolen_t{})); +-} +-#endif // DOXYGEN_SHOULD_SKIP_THIS +-/// @} pytypes +- +-/// \addtogroup python_builtins +-/// @{ +- +-/// Get the length of a Python object. +-inline size_t len(handle h) { +- ssize_t result = PyObject_Length(h.ptr()); +- if (result < 0) +- throw error_already_set(); +- return (size_t) result; +-} +- +-/// Get the length hint of a Python object. +-/// Returns 0 when this cannot be determined. +-inline size_t len_hint(handle h) { +-#if PY_VERSION_HEX >= 0x03040000 +- ssize_t result = PyObject_LengthHint(h.ptr(), 0); +-#else +- ssize_t result = PyObject_Length(h.ptr()); +-#endif +- if (result < 0) { +- // Sometimes a length can't be determined at all (eg generators) +- // In which case simply return 0 +- PyErr_Clear(); +- return 0; +- } +- return (size_t) result; +-} +- +-inline str repr(handle h) { +- PyObject *str_value = PyObject_Repr(h.ptr()); +- if (!str_value) throw error_already_set(); +-#if PY_MAJOR_VERSION < 3 +- PyObject *unicode = PyUnicode_FromEncodedObject(str_value, "utf-8", nullptr); +- Py_XDECREF(str_value); str_value = unicode; +- if (!str_value) throw error_already_set(); +-#endif +- return reinterpret_steal(str_value); +-} +- +-inline iterator iter(handle obj) { +- PyObject *result = PyObject_GetIter(obj.ptr()); +- if (!result) { throw error_already_set(); } +- return reinterpret_steal(result); +-} +-/// @} python_builtins +- +-PYBIND11_NAMESPACE_BEGIN(detail) +-template iterator object_api::begin() const { return iter(derived()); } +-template iterator object_api::end() const { return iterator::sentinel(); } +-template item_accessor object_api::operator[](handle key) const { +- return {derived(), reinterpret_borrow(key)}; +-} +-template item_accessor object_api::operator[](const char *key) const { +- return {derived(), pybind11::str(key)}; +-} +-template obj_attr_accessor object_api::attr(handle key) const { +- return {derived(), reinterpret_borrow(key)}; +-} +-template str_attr_accessor object_api::attr(const char *key) const { +- return {derived(), key}; +-} +-template args_proxy object_api::operator*() const { +- return args_proxy(derived().ptr()); +-} +-template template bool object_api::contains(T &&item) const { +- return attr("__contains__")(std::forward(item)).template cast(); +-} +- +-template +-pybind11::str object_api::str() const { return pybind11::str(derived()); } +- +-template +-str_attr_accessor object_api::doc() const { return attr("__doc__"); } +- +-template +-handle object_api::get_type() const { return type::handle_of(derived()); } +- +-template +-bool object_api::rich_compare(object_api const &other, int value) const { +- int rv = PyObject_RichCompareBool(derived().ptr(), other.derived().ptr(), value); +- if (rv == -1) +- throw error_already_set(); +- return rv == 1; +-} +- +-#define PYBIND11_MATH_OPERATOR_UNARY(op, fn) \ +- template object object_api::op() const { \ +- object result = reinterpret_steal(fn(derived().ptr())); \ +- if (!result.ptr()) \ +- throw error_already_set(); \ +- return result; \ +- } +- +-#define PYBIND11_MATH_OPERATOR_BINARY(op, fn) \ +- template \ +- object object_api::op(object_api const &other) const { \ +- object result = reinterpret_steal( \ +- fn(derived().ptr(), other.derived().ptr())); \ +- if (!result.ptr()) \ +- throw error_already_set(); \ +- return result; \ +- } +- +-PYBIND11_MATH_OPERATOR_UNARY (operator~, PyNumber_Invert) +-PYBIND11_MATH_OPERATOR_UNARY (operator-, PyNumber_Negative) +-PYBIND11_MATH_OPERATOR_BINARY(operator+, PyNumber_Add) +-PYBIND11_MATH_OPERATOR_BINARY(operator+=, PyNumber_InPlaceAdd) +-PYBIND11_MATH_OPERATOR_BINARY(operator-, PyNumber_Subtract) +-PYBIND11_MATH_OPERATOR_BINARY(operator-=, PyNumber_InPlaceSubtract) +-PYBIND11_MATH_OPERATOR_BINARY(operator*, PyNumber_Multiply) +-PYBIND11_MATH_OPERATOR_BINARY(operator*=, PyNumber_InPlaceMultiply) +-PYBIND11_MATH_OPERATOR_BINARY(operator/, PyNumber_TrueDivide) +-PYBIND11_MATH_OPERATOR_BINARY(operator/=, PyNumber_InPlaceTrueDivide) +-PYBIND11_MATH_OPERATOR_BINARY(operator|, PyNumber_Or) +-PYBIND11_MATH_OPERATOR_BINARY(operator|=, PyNumber_InPlaceOr) +-PYBIND11_MATH_OPERATOR_BINARY(operator&, PyNumber_And) +-PYBIND11_MATH_OPERATOR_BINARY(operator&=, PyNumber_InPlaceAnd) +-PYBIND11_MATH_OPERATOR_BINARY(operator^, PyNumber_Xor) +-PYBIND11_MATH_OPERATOR_BINARY(operator^=, PyNumber_InPlaceXor) +-PYBIND11_MATH_OPERATOR_BINARY(operator<<, PyNumber_Lshift) +-PYBIND11_MATH_OPERATOR_BINARY(operator<<=, PyNumber_InPlaceLshift) +-PYBIND11_MATH_OPERATOR_BINARY(operator>>, PyNumber_Rshift) +-PYBIND11_MATH_OPERATOR_BINARY(operator>>=, PyNumber_InPlaceRshift) +- +-#undef PYBIND11_MATH_OPERATOR_UNARY +-#undef PYBIND11_MATH_OPERATOR_BINARY +- +-PYBIND11_NAMESPACE_END(detail) +-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE) +diff --git a/dune/python/pybind11/stl.h b/dune/python/pybind11/stl.h +deleted file mode 100644 +index 721bb669f..000000000 +--- a/dune/python/pybind11/stl.h ++++ /dev/null +@@ -1,388 +0,0 @@ +-/* +- pybind11/stl.h: Transparent conversion for STL data types +- +- Copyright (c) 2016 Wenzel Jakob +- +- All rights reserved. Use of this source code is governed by a +- BSD-style license that can be found in the LICENSE file. +-*/ +- +-#pragma once +- +-#include "pybind11.h" +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +- +-#if defined(_MSC_VER) +-#pragma warning(push) +-#pragma warning(disable: 4127) // warning C4127: Conditional expression is constant +-#endif +- +-#ifdef __has_include +-// std::optional (but including it in c++14 mode isn't allowed) +-# if defined(PYBIND11_CPP17) && __has_include() +-# include +-# define PYBIND11_HAS_OPTIONAL 1 +-# endif +-// std::experimental::optional (but not allowed in c++11 mode) +-# if defined(PYBIND11_CPP14) && (__has_include() && \ +- !__has_include()) +-# include +-# define PYBIND11_HAS_EXP_OPTIONAL 1 +-# endif +-// std::variant +-# if defined(PYBIND11_CPP17) && __has_include() +-# include +-# define PYBIND11_HAS_VARIANT 1 +-# endif +-#elif defined(_MSC_VER) && defined(PYBIND11_CPP17) +-# include +-# include +-# define PYBIND11_HAS_OPTIONAL 1 +-# define PYBIND11_HAS_VARIANT 1 +-#endif +- +-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE) +-PYBIND11_NAMESPACE_BEGIN(detail) +- +-/// Extracts an const lvalue reference or rvalue reference for U based on the type of T (e.g. for +-/// forwarding a container element). Typically used indirect via forwarded_type(), below. +-template +-using forwarded_type = conditional_t< +- std::is_lvalue_reference::value, remove_reference_t &, remove_reference_t &&>; +- +-/// Forwards a value U as rvalue or lvalue according to whether T is rvalue or lvalue; typically +-/// used for forwarding a container's elements. +-template +-forwarded_type forward_like(U &&u) { +- return std::forward>(std::forward(u)); +-} +- +-template struct set_caster { +- using type = Type; +- using key_conv = make_caster; +- +- bool load(handle src, bool convert) { +- if (!isinstance(src)) +- return false; +- auto s = reinterpret_borrow(src); +- value.clear(); +- for (auto entry : s) { +- key_conv conv; +- if (!conv.load(entry, convert)) +- return false; +- value.insert(cast_op(std::move(conv))); +- } +- return true; +- } +- +- template +- static handle cast(T &&src, return_value_policy policy, handle parent) { +- if (!std::is_lvalue_reference::value) +- policy = return_value_policy_override::policy(policy); +- pybind11::set s; +- for (auto &&value : src) { +- auto value_ = reinterpret_steal(key_conv::cast(forward_like(value), policy, parent)); +- if (!value_ || !s.add(value_)) +- return handle(); +- } +- return s.release(); +- } +- +- PYBIND11_TYPE_CASTER(type, _("Set[") + key_conv::name + _("]")); +-}; +- +-template struct map_caster { +- using key_conv = make_caster; +- using value_conv = make_caster; +- +- bool load(handle src, bool convert) { +- if (!isinstance(src)) +- return false; +- auto d = reinterpret_borrow(src); +- value.clear(); +- for (auto it : d) { +- key_conv kconv; +- value_conv vconv; +- if (!kconv.load(it.first.ptr(), convert) || +- !vconv.load(it.second.ptr(), convert)) +- return false; +- value.emplace(cast_op(std::move(kconv)), cast_op(std::move(vconv))); +- } +- return true; +- } +- +- template +- static handle cast(T &&src, return_value_policy policy, handle parent) { +- dict d; +- return_value_policy policy_key = policy; +- return_value_policy policy_value = policy; +- if (!std::is_lvalue_reference::value) { +- policy_key = return_value_policy_override::policy(policy_key); +- policy_value = return_value_policy_override::policy(policy_value); +- } +- for (auto &&kv : src) { +- auto key = reinterpret_steal(key_conv::cast(forward_like(kv.first), policy_key, parent)); +- auto value = reinterpret_steal(value_conv::cast(forward_like(kv.second), policy_value, parent)); +- if (!key || !value) +- return handle(); +- d[key] = value; +- } +- return d.release(); +- } +- +- PYBIND11_TYPE_CASTER(Type, _("Dict[") + key_conv::name + _(", ") + value_conv::name + _("]")); +-}; +- +-template struct list_caster { +- using value_conv = make_caster; +- +- bool load(handle src, bool convert) { +- if (!isinstance(src) || isinstance(src)) +- return false; +- auto s = reinterpret_borrow(src); +- value.clear(); +- reserve_maybe(s, &value); +- for (auto it : s) { +- value_conv conv; +- if (!conv.load(it, convert)) +- return false; +- value.push_back(cast_op(std::move(conv))); +- } +- return true; +- } +- +-private: +- template ().reserve(0)), void>::value, int> = 0> +- void reserve_maybe(sequence s, Type *) { value.reserve(s.size()); } +- void reserve_maybe(sequence, void *) { } +- +-public: +- template +- static handle cast(T &&src, return_value_policy policy, handle parent) { +- if (!std::is_lvalue_reference::value) +- policy = return_value_policy_override::policy(policy); +- list l(src.size()); +- size_t index = 0; +- for (auto &&value : src) { +- auto value_ = reinterpret_steal(value_conv::cast(forward_like(value), policy, parent)); +- if (!value_) +- return handle(); +- PyList_SET_ITEM(l.ptr(), (ssize_t) index++, value_.release().ptr()); // steals a reference +- } +- return l.release(); +- } +- +- PYBIND11_TYPE_CASTER(Type, _("List[") + value_conv::name + _("]")); +-}; +- +-template struct type_caster> +- : list_caster, Type> { }; +- +-template struct type_caster> +- : list_caster, Type> { }; +- +-template struct type_caster> +- : list_caster, Type> { }; +- +-template struct array_caster { +- using value_conv = make_caster; +- +-private: +- template +- bool require_size(enable_if_t size) { +- if (value.size() != size) +- value.resize(size); +- return true; +- } +- template +- bool require_size(enable_if_t size) { +- return size == Size; +- } +- +-public: +- bool load(handle src, bool convert) { +- if (!isinstance(src)) +- return false; +- auto l = reinterpret_borrow(src); +- if (!require_size(l.size())) +- return false; +- size_t ctr = 0; +- for (auto it : l) { +- value_conv conv; +- if (!conv.load(it, convert)) +- return false; +- value[ctr++] = cast_op(std::move(conv)); +- } +- return true; +- } +- +- template +- static handle cast(T &&src, return_value_policy policy, handle parent) { +- list l(src.size()); +- size_t index = 0; +- for (auto &&value : src) { +- auto value_ = reinterpret_steal(value_conv::cast(forward_like(value), policy, parent)); +- if (!value_) +- return handle(); +- PyList_SET_ITEM(l.ptr(), (ssize_t) index++, value_.release().ptr()); // steals a reference +- } +- return l.release(); +- } +- +- PYBIND11_TYPE_CASTER(ArrayType, _("List[") + value_conv::name + _(_(""), _("[") + _() + _("]")) + _("]")); +-}; +- +-template struct type_caster> +- : array_caster, Type, false, Size> { }; +- +-template struct type_caster> +- : array_caster, Type, true> { }; +- +-template struct type_caster> +- : set_caster, Key> { }; +- +-template struct type_caster> +- : set_caster, Key> { }; +- +-template struct type_caster> +- : map_caster, Key, Value> { }; +- +-template struct type_caster> +- : map_caster, Key, Value> { }; +- +-// This type caster is intended to be used for std::optional and std::experimental::optional +-template struct optional_caster { +- using value_conv = make_caster; +- +- template +- static handle cast(T_ &&src, return_value_policy policy, handle parent) { +- if (!src) +- return none().inc_ref(); +- if (!std::is_lvalue_reference::value) { +- policy = return_value_policy_override::policy(policy); +- } +- return value_conv::cast(*std::forward(src), policy, parent); +- } +- +- bool load(handle src, bool convert) { +- if (!src) { +- return false; +- } else if (src.is_none()) { +- return true; // default-constructed value is already empty +- } +- value_conv inner_caster; +- if (!inner_caster.load(src, convert)) +- return false; +- +- value.emplace(cast_op(std::move(inner_caster))); +- return true; +- } +- +- PYBIND11_TYPE_CASTER(T, _("Optional[") + value_conv::name + _("]")); +-}; +- +-#if defined(PYBIND11_HAS_OPTIONAL) +-template struct type_caster> +- : public optional_caster> {}; +- +-template<> struct type_caster +- : public void_caster {}; +-#endif +- +-#if defined(PYBIND11_HAS_EXP_OPTIONAL) +-template struct type_caster> +- : public optional_caster> {}; +- +-template<> struct type_caster +- : public void_caster {}; +-#endif +- +-/// Visit a variant and cast any found type to Python +-struct variant_caster_visitor { +- return_value_policy policy; +- handle parent; +- +- using result_type = handle; // required by boost::variant in C++11 +- +- template +- result_type operator()(T &&src) const { +- return make_caster::cast(std::forward(src), policy, parent); +- } +-}; +- +-/// Helper class which abstracts away variant's `visit` function. `std::variant` and similar +-/// `namespace::variant` types which provide a `namespace::visit()` function are handled here +-/// automatically using argument-dependent lookup. Users can provide specializations for other +-/// variant-like classes, e.g. `boost::variant` and `boost::apply_visitor`. +-template class Variant> +-struct visit_helper { +- template +- static auto call(Args &&...args) -> decltype(visit(std::forward(args)...)) { +- return visit(std::forward(args)...); +- } +-}; +- +-/// Generic variant caster +-template struct variant_caster; +- +-template class V, typename... Ts> +-struct variant_caster> { +- static_assert(sizeof...(Ts) > 0, "Variant must consist of at least one alternative."); +- +- template +- bool load_alternative(handle src, bool convert, type_list) { +- auto caster = make_caster(); +- if (caster.load(src, convert)) { +- value = cast_op(caster); +- return true; +- } +- return load_alternative(src, convert, type_list{}); +- } +- +- bool load_alternative(handle, bool, type_list<>) { return false; } +- +- bool load(handle src, bool convert) { +- // Do a first pass without conversions to improve constructor resolution. +- // E.g. `py::int_(1).cast>()` needs to fill the `int` +- // slot of the variant. Without two-pass loading `double` would be filled +- // because it appears first and a conversion is possible. +- if (convert && load_alternative(src, false, type_list{})) +- return true; +- return load_alternative(src, convert, type_list{}); +- } +- +- template +- static handle cast(Variant &&src, return_value_policy policy, handle parent) { +- return visit_helper::call(variant_caster_visitor{policy, parent}, +- std::forward(src)); +- } +- +- using Type = V; +- PYBIND11_TYPE_CASTER(Type, _("Union[") + detail::concat(make_caster::name...) + _("]")); +-}; +- +-#if defined(PYBIND11_HAS_VARIANT) +-template +-struct type_caster> : variant_caster> { }; +-#endif +- +-PYBIND11_NAMESPACE_END(detail) +- +-inline std::ostream &operator<<(std::ostream &os, const handle &obj) { +- os << (std::string) str(obj); +- return os; +-} +- +-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE) +- +-#if defined(_MSC_VER) +-#pragma warning(pop) +-#endif +diff --git a/dune/python/pybind11/stl_bind.h b/dune/python/pybind11/stl_bind.h +deleted file mode 100644 +index 9d8ed0c82..000000000 +--- a/dune/python/pybind11/stl_bind.h ++++ /dev/null +@@ -1,661 +0,0 @@ +-/* +- pybind11/std_bind.h: Binding generators for STL data types +- +- Copyright (c) 2016 Sergey Lyskov and Wenzel Jakob +- +- All rights reserved. Use of this source code is governed by a +- BSD-style license that can be found in the LICENSE file. +-*/ +- +-#pragma once +- +-#include "detail/common.h" +-#include "operators.h" +- +-#include +-#include +- +-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE) +-PYBIND11_NAMESPACE_BEGIN(detail) +- +-/* SFINAE helper class used by 'is_comparable */ +-template struct container_traits { +- template static std::true_type test_comparable(decltype(std::declval() == std::declval())*); +- template static std::false_type test_comparable(...); +- template static std::true_type test_value(typename T2::value_type *); +- template static std::false_type test_value(...); +- template static std::true_type test_pair(typename T2::first_type *, typename T2::second_type *); +- template static std::false_type test_pair(...); +- +- static constexpr const bool is_comparable = std::is_same(nullptr))>::value; +- static constexpr const bool is_pair = std::is_same(nullptr, nullptr))>::value; +- static constexpr const bool is_vector = std::is_same(nullptr))>::value; +- static constexpr const bool is_element = !is_pair && !is_vector; +-}; +- +-/* Default: is_comparable -> std::false_type */ +-template +-struct is_comparable : std::false_type { }; +- +-/* For non-map data structures, check whether operator== can be instantiated */ +-template +-struct is_comparable< +- T, enable_if_t::is_element && +- container_traits::is_comparable>> +- : std::true_type { }; +- +-/* For a vector/map data structure, recursively check the value type (which is std::pair for maps) */ +-template +-struct is_comparable::is_vector>> { +- static constexpr const bool value = +- is_comparable::value; +-}; +- +-/* For pairs, recursively check the two data types */ +-template +-struct is_comparable::is_pair>> { +- static constexpr const bool value = +- is_comparable::value && +- is_comparable::value; +-}; +- +-/* Fallback functions */ +-template void vector_if_copy_constructible(const Args &...) { } +-template void vector_if_equal_operator(const Args &...) { } +-template void vector_if_insertion_operator(const Args &...) { } +-template void vector_modifiers(const Args &...) { } +- +-template +-void vector_if_copy_constructible(enable_if_t::value, Class_> &cl) { +- cl.def(init(), "Copy constructor"); +-} +- +-template +-void vector_if_equal_operator(enable_if_t::value, Class_> &cl) { +- using T = typename Vector::value_type; +- +- cl.def(self == self); +- cl.def(self != self); +- +- cl.def("count", +- [](const Vector &v, const T &x) { +- return std::count(v.begin(), v.end(), x); +- }, +- arg("x"), +- "Return the number of times ``x`` appears in the list" +- ); +- +- cl.def("remove", [](Vector &v, const T &x) { +- auto p = std::find(v.begin(), v.end(), x); +- if (p != v.end()) +- v.erase(p); +- else +- throw value_error(); +- }, +- arg("x"), +- "Remove the first item from the list whose value is x. " +- "It is an error if there is no such item." +- ); +- +- cl.def("__contains__", +- [](const Vector &v, const T &x) { +- return std::find(v.begin(), v.end(), x) != v.end(); +- }, +- arg("x"), +- "Return true the container contains ``x``" +- ); +-} +- +-// Vector modifiers -- requires a copyable vector_type: +-// (Technically, some of these (pop and __delitem__) don't actually require copyability, but it seems +-// silly to allow deletion but not insertion, so include them here too.) +-template +-void vector_modifiers(enable_if_t::value, Class_> &cl) { +- using T = typename Vector::value_type; +- using SizeType = typename Vector::size_type; +- using DiffType = typename Vector::difference_type; +- +- auto wrap_i = [](DiffType i, SizeType n) { +- if (i < 0) +- i += n; +- if (i < 0 || (SizeType)i >= n) +- throw index_error(); +- return i; +- }; +- +- cl.def("append", +- [](Vector &v, const T &value) { v.push_back(value); }, +- arg("x"), +- "Add an item to the end of the list"); +- +- cl.def(init([](iterable it) { +- auto v = std::unique_ptr(new Vector()); +- v->reserve(len_hint(it)); +- for (handle h : it) +- v->push_back(h.cast()); +- return v.release(); +- })); +- +- cl.def("clear", +- [](Vector &v) { +- v.clear(); +- }, +- "Clear the contents" +- ); +- +- cl.def("extend", +- [](Vector &v, const Vector &src) { +- v.insert(v.end(), src.begin(), src.end()); +- }, +- arg("L"), +- "Extend the list by appending all the items in the given list" +- ); +- +- cl.def("extend", +- [](Vector &v, iterable it) { +- const size_t old_size = v.size(); +- v.reserve(old_size + len_hint(it)); +- try { +- for (handle h : it) { +- v.push_back(h.cast()); +- } +- } catch (const cast_error &) { +- v.erase(v.begin() + static_cast(old_size), v.end()); +- try { +- v.shrink_to_fit(); +- } catch (const std::exception &) { +- // Do nothing +- } +- throw; +- } +- }, +- arg("L"), +- "Extend the list by appending all the items in the given list" +- ); +- +- cl.def("insert", +- [](Vector &v, DiffType i, const T &x) { +- // Can't use wrap_i; i == v.size() is OK +- if (i < 0) +- i += v.size(); +- if (i < 0 || (SizeType)i > v.size()) +- throw index_error(); +- v.insert(v.begin() + i, x); +- }, +- arg("i") , arg("x"), +- "Insert an item at a given position." +- ); +- +- cl.def("pop", +- [](Vector &v) { +- if (v.empty()) +- throw index_error(); +- T t = v.back(); +- v.pop_back(); +- return t; +- }, +- "Remove and return the last item" +- ); +- +- cl.def("pop", +- [wrap_i](Vector &v, DiffType i) { +- i = wrap_i(i, v.size()); +- T t = v[(SizeType) i]; +- v.erase(v.begin() + i); +- return t; +- }, +- arg("i"), +- "Remove and return the item at index ``i``" +- ); +- +- cl.def("__setitem__", +- [wrap_i](Vector &v, DiffType i, const T &t) { +- i = wrap_i(i, v.size()); +- v[(SizeType)i] = t; +- } +- ); +- +- /// Slicing protocol +- cl.def("__getitem__", +- [](const Vector &v, slice slice) -> Vector * { +- size_t start, stop, step, slicelength; +- +- if (!slice.compute(v.size(), &start, &stop, &step, &slicelength)) +- throw error_already_set(); +- +- auto *seq = new Vector(); +- seq->reserve((size_t) slicelength); +- +- for (size_t i=0; ipush_back(v[start]); +- start += step; +- } +- return seq; +- }, +- arg("s"), +- "Retrieve list elements using a slice object" +- ); +- +- cl.def("__setitem__", +- [](Vector &v, slice slice, const Vector &value) { +- size_t start, stop, step, slicelength; +- if (!slice.compute(v.size(), &start, &stop, &step, &slicelength)) +- throw error_already_set(); +- +- if (slicelength != value.size()) +- throw std::runtime_error("Left and right hand size of slice assignment have different sizes!"); +- +- for (size_t i=0; i), +-// we have to access by copying; otherwise we return by reference. +-template using vector_needs_copy = negation< +- std::is_same()[typename Vector::size_type()]), typename Vector::value_type &>>; +- +-// The usual case: access and iterate by reference +-template +-void vector_accessor(enable_if_t::value, Class_> &cl) { +- using T = typename Vector::value_type; +- using SizeType = typename Vector::size_type; +- using DiffType = typename Vector::difference_type; +- using ItType = typename Vector::iterator; +- +- auto wrap_i = [](DiffType i, SizeType n) { +- if (i < 0) +- i += n; +- if (i < 0 || (SizeType)i >= n) +- throw index_error(); +- return i; +- }; +- +- cl.def("__getitem__", +- [wrap_i](Vector &v, DiffType i) -> T & { +- i = wrap_i(i, v.size()); +- return v[(SizeType)i]; +- }, +- return_value_policy::reference_internal // ref + keepalive +- ); +- +- cl.def("__iter__", +- [](Vector &v) { +- return make_iterator< +- return_value_policy::reference_internal, ItType, ItType, T&>( +- v.begin(), v.end()); +- }, +- keep_alive<0, 1>() /* Essential: keep list alive while iterator exists */ +- ); +-} +- +-// The case for special objects, like std::vector, that have to be returned-by-copy: +-template +-void vector_accessor(enable_if_t::value, Class_> &cl) { +- using T = typename Vector::value_type; +- using SizeType = typename Vector::size_type; +- using DiffType = typename Vector::difference_type; +- using ItType = typename Vector::iterator; +- cl.def("__getitem__", +- [](const Vector &v, DiffType i) -> T { +- if (i < 0 && (i += v.size()) < 0) +- throw index_error(); +- if ((SizeType)i >= v.size()) +- throw index_error(); +- return v[(SizeType)i]; +- } +- ); +- +- cl.def("__iter__", +- [](Vector &v) { +- return make_iterator< +- return_value_policy::copy, ItType, ItType, T>( +- v.begin(), v.end()); +- }, +- keep_alive<0, 1>() /* Essential: keep list alive while iterator exists */ +- ); +-} +- +-template auto vector_if_insertion_operator(Class_ &cl, std::string const &name) +- -> decltype(std::declval() << std::declval(), void()) { +- using size_type = typename Vector::size_type; +- +- cl.def("__repr__", +- [name](Vector &v) { +- std::ostringstream s; +- s << name << '['; +- for (size_type i=0; i < v.size(); ++i) { +- s << v[i]; +- if (i != v.size() - 1) +- s << ", "; +- } +- s << ']'; +- return s.str(); +- }, +- "Return the canonical string representation of this list." +- ); +-} +- +-// Provide the buffer interface for vectors if we have data() and we have a format for it +-// GCC seems to have "void std::vector::data()" - doing SFINAE on the existence of data() is insufficient, we need to check it returns an appropriate pointer +-template +-struct vector_has_data_and_format : std::false_type {}; +-template +-struct vector_has_data_and_format::format(), std::declval().data()), typename Vector::value_type*>::value>> : std::true_type {}; +- +-// Add the buffer interface to a vector +-template +-enable_if_t...>::value> +-vector_buffer(Class_& cl) { +- using T = typename Vector::value_type; +- +- static_assert(vector_has_data_and_format::value, "There is not an appropriate format descriptor for this vector"); +- +- // numpy.h declares this for arbitrary types, but it may raise an exception and crash hard at runtime if PYBIND11_NUMPY_DTYPE hasn't been called, so check here +- format_descriptor::format(); +- +- cl.def_buffer([](Vector& v) -> buffer_info { +- return buffer_info(v.data(), static_cast(sizeof(T)), format_descriptor::format(), 1, {v.size()}, {sizeof(T)}); +- }); +- +- cl.def(init([](buffer buf) { +- auto info = buf.request(); +- if (info.ndim != 1 || info.strides[0] % static_cast(sizeof(T))) +- throw type_error("Only valid 1D buffers can be copied to a vector"); +- if (!detail::compare_buffer_info::compare(info) || (ssize_t) sizeof(T) != info.itemsize) +- throw type_error("Format mismatch (Python: " + info.format + " C++: " + format_descriptor::format() + ")"); +- +- T *p = static_cast(info.ptr); +- ssize_t step = info.strides[0] / static_cast(sizeof(T)); +- T *end = p + info.shape[0] * step; +- if (step == 1) { +- return Vector(p, end); +- } +- else { +- Vector vec; +- vec.reserve((size_t) info.shape[0]); +- for (; p != end; p += step) +- vec.push_back(*p); +- return vec; +- } +- })); +- +- return; +-} +- +-template +-enable_if_t...>::value> vector_buffer(Class_&) {} +- +-PYBIND11_NAMESPACE_END(detail) +- +-// +-// std::vector +-// +-template , typename... Args> +-class_ bind_vector(handle scope, std::string const &name, Args&&... args) { +- using Class_ = class_; +- +- // If the value_type is unregistered (e.g. a converting type) or is itself registered +- // module-local then make the vector binding module-local as well: +- using vtype = typename Vector::value_type; +- auto vtype_info = detail::get_type_info(typeid(vtype)); +- bool local = !vtype_info || vtype_info->module_local; +- +- Class_ cl(scope, name.c_str(), pybind11::module_local(local), std::forward(args)...); +- +- // Declare the buffer interface if a buffer_protocol() is passed in +- detail::vector_buffer(cl); +- +- cl.def(init<>()); +- +- // Register copy constructor (if possible) +- detail::vector_if_copy_constructible(cl); +- +- // Register comparison-related operators and functions (if possible) +- detail::vector_if_equal_operator(cl); +- +- // Register stream insertion operator (if possible) +- detail::vector_if_insertion_operator(cl, name); +- +- // Modifiers require copyable vector value type +- detail::vector_modifiers(cl); +- +- // Accessor and iterator; return by value if copyable, otherwise we return by ref + keep-alive +- detail::vector_accessor(cl); +- +- cl.def("__bool__", +- [](const Vector &v) -> bool { +- return !v.empty(); +- }, +- "Check whether the list is nonempty" +- ); +- +- cl.def("__len__", &Vector::size); +- +- +- +- +-#if 0 +- // C++ style functions deprecated, leaving it here as an example +- cl.def(init()); +- +- cl.def("resize", +- (void (Vector::*) (size_type count)) & Vector::resize, +- "changes the number of elements stored"); +- +- cl.def("erase", +- [](Vector &v, SizeType i) { +- if (i >= v.size()) +- throw index_error(); +- v.erase(v.begin() + i); +- }, "erases element at index ``i``"); +- +- cl.def("empty", &Vector::empty, "checks whether the container is empty"); +- cl.def("size", &Vector::size, "returns the number of elements"); +- cl.def("push_back", (void (Vector::*)(const T&)) &Vector::push_back, "adds an element to the end"); +- cl.def("pop_back", &Vector::pop_back, "removes the last element"); +- +- cl.def("max_size", &Vector::max_size, "returns the maximum possible number of elements"); +- cl.def("reserve", &Vector::reserve, "reserves storage"); +- cl.def("capacity", &Vector::capacity, "returns the number of elements that can be held in currently allocated storage"); +- cl.def("shrink_to_fit", &Vector::shrink_to_fit, "reduces memory usage by freeing unused memory"); +- +- cl.def("clear", &Vector::clear, "clears the contents"); +- cl.def("swap", &Vector::swap, "swaps the contents"); +- +- cl.def("front", [](Vector &v) { +- if (v.size()) return v.front(); +- else throw index_error(); +- }, "access the first element"); +- +- cl.def("back", [](Vector &v) { +- if (v.size()) return v.back(); +- else throw index_error(); +- }, "access the last element "); +- +-#endif +- +- return cl; +-} +- +- +- +-// +-// std::map, std::unordered_map +-// +- +-PYBIND11_NAMESPACE_BEGIN(detail) +- +-/* Fallback functions */ +-template void map_if_insertion_operator(const Args &...) { } +-template void map_assignment(const Args &...) { } +- +-// Map assignment when copy-assignable: just copy the value +-template +-void map_assignment(enable_if_t::value, Class_> &cl) { +- using KeyType = typename Map::key_type; +- using MappedType = typename Map::mapped_type; +- +- cl.def("__setitem__", +- [](Map &m, const KeyType &k, const MappedType &v) { +- auto it = m.find(k); +- if (it != m.end()) it->second = v; +- else m.emplace(k, v); +- } +- ); +-} +- +-// Not copy-assignable, but still copy-constructible: we can update the value by erasing and reinserting +-template +-void map_assignment(enable_if_t< +- !is_copy_assignable::value && +- is_copy_constructible::value, +- Class_> &cl) { +- using KeyType = typename Map::key_type; +- using MappedType = typename Map::mapped_type; +- +- cl.def("__setitem__", +- [](Map &m, const KeyType &k, const MappedType &v) { +- // We can't use m[k] = v; because value type might not be default constructable +- auto r = m.emplace(k, v); +- if (!r.second) { +- // value type is not copy assignable so the only way to insert it is to erase it first... +- m.erase(r.first); +- m.emplace(k, v); +- } +- } +- ); +-} +- +- +-template auto map_if_insertion_operator(Class_ &cl, std::string const &name) +--> decltype(std::declval() << std::declval() << std::declval(), void()) { +- +- cl.def("__repr__", +- [name](Map &m) { +- std::ostringstream s; +- s << name << '{'; +- bool f = false; +- for (auto const &kv : m) { +- if (f) +- s << ", "; +- s << kv.first << ": " << kv.second; +- f = true; +- } +- s << '}'; +- return s.str(); +- }, +- "Return the canonical string representation of this map." +- ); +-} +- +- +-PYBIND11_NAMESPACE_END(detail) +- +-template , typename... Args> +-class_ bind_map(handle scope, const std::string &name, Args&&... args) { +- using KeyType = typename Map::key_type; +- using MappedType = typename Map::mapped_type; +- using Class_ = class_; +- +- // If either type is a non-module-local bound type then make the map binding non-local as well; +- // otherwise (e.g. both types are either module-local or converting) the map will be +- // module-local. +- auto tinfo = detail::get_type_info(typeid(MappedType)); +- bool local = !tinfo || tinfo->module_local; +- if (local) { +- tinfo = detail::get_type_info(typeid(KeyType)); +- local = !tinfo || tinfo->module_local; +- } +- +- Class_ cl(scope, name.c_str(), pybind11::module_local(local), std::forward(args)...); +- +- cl.def(init<>()); +- +- // Register stream insertion operator (if possible) +- detail::map_if_insertion_operator(cl, name); +- +- cl.def("__bool__", +- [](const Map &m) -> bool { return !m.empty(); }, +- "Check whether the map is nonempty" +- ); +- +- cl.def("__iter__", +- [](Map &m) { return make_key_iterator(m.begin(), m.end()); }, +- keep_alive<0, 1>() /* Essential: keep list alive while iterator exists */ +- ); +- +- cl.def("items", +- [](Map &m) { return make_iterator(m.begin(), m.end()); }, +- keep_alive<0, 1>() /* Essential: keep list alive while iterator exists */ +- ); +- +- cl.def("__getitem__", +- [](Map &m, const KeyType &k) -> MappedType & { +- auto it = m.find(k); +- if (it == m.end()) +- throw key_error(); +- return it->second; +- }, +- return_value_policy::reference_internal // ref + keepalive +- ); +- +- cl.def("__contains__", +- [](Map &m, const KeyType &k) -> bool { +- auto it = m.find(k); +- if (it == m.end()) +- return false; +- return true; +- } +- ); +- +- // Assignment provided only if the type is copyable +- detail::map_assignment(cl); +- +- cl.def("__delitem__", +- [](Map &m, const KeyType &k) { +- auto it = m.find(k); +- if (it == m.end()) +- throw key_error(); +- m.erase(it); +- } +- ); +- +- cl.def("__len__", &Map::size); +- +- return cl; +-} +- +-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE) +diff --git a/dune/python/test/CMakeLists.txt b/dune/python/test/CMakeLists.txt +deleted file mode 100644 +index 6ee34f903..000000000 +--- a/dune/python/test/CMakeLists.txt ++++ /dev/null +@@ -1,13 +0,0 @@ +-dune_python_add_test(NAME pythontests +- SCRIPT pythontests.py +- WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} +- LABELS quick) +- +-dune_add_test(SOURCES test_embed1.cc +- LINK_LIBRARIES ${DUNE_LIBS} ${Python3_LIBRARIES} +- LABELS quick +- ) +- +-add_executable(test_embed2 EXCLUDE_FROM_ALL test_embed2.cc) +-target_link_libraries(test_embed2 PUBLIC ${DUNE_LIBS} ${Python3_LIBRARIES}) +-# the following should apparently work but doesn't target_link_libraries(test_embed2 PRIVATE Python3::Python) +diff --git a/dune/python/test/pythontests.py b/dune/python/test/pythontests.py +deleted file mode 100644 +index a1a7cf287..000000000 +--- a/dune/python/test/pythontests.py ++++ /dev/null +@@ -1,37 +0,0 @@ +-from io import StringIO +-classACode=""" +-struct MyClassA { +- MyClassA(int a,int b) : a_(a), b_(b) {} +- int a_,b_; +-}; +-""" +-classBCode=""" +-#include +-template struct MyClassB { +- MyClassB(T &t, int p) : a_(std::pow(t.a_,p)), b_(std::pow(t.b_,p)) {} +- int a_,b_; +-}; +-""" +-runCode=""" +-template int run(T &t) { +- return t.a_ * t.b_; +-} +-""" +- +-def test_class_export(): +- from dune.generator.importclass import load +- from dune.generator.algorithm import run +- from dune.generator import path +- from dune.typeregistry import generateTypeName +- cls = load("MyClassA",StringIO(classACode),10,20) +- assert run("run",StringIO(runCode),cls) == 10*20 +- clsName,includes = generateTypeName("MyClassB",cls) +- cls = load(clsName,StringIO(classBCode),cls,2) +- assert run("run",StringIO(runCode),cls) == 10**2*20**2 +-if __name__ == "__main__": +- try: +- from dune.common.module import get_dune_py_dir +- _ = get_dune_py_dir() +- test_class_export() +- except ImportError: +- pass +diff --git a/dune/python/test/test_embed1.cc b/dune/python/test/test_embed1.cc +deleted file mode 100644 +index f94f8cd04..000000000 +--- a/dune/python/test/test_embed1.cc ++++ /dev/null +@@ -1,151 +0,0 @@ +-#include +- +-#include +-#include +-#include +- +-int main() +-{ +- /* +- remark: combine getting the guard and loading +- dune.common in a single 'initialization' function - +- the dune.common module can also be used to register additional +- types - although a 'dummy' scope can also be used, i.e., +- pybind11::handle scope; +- */ +- pybind11::scoped_interpreter guard{}; +- pybind11::module dcommon = pybind11::module::import("dune.common"); +- auto global = pybind11::dict(pybind11::module::import("__main__").attr("__dict__")); +- +- // using the C++ registry functions directly: +- Dune::Python::registerFieldVector ( dcommon ); +- /* +- // instead of importing dune.common one could use the dummy scope and +- // the first step is done in 'dune.common' (_common.cc) +- Dune::Python::addToTypeRegistry(Dune::Python::GenerateTypeName("double")); +- // now we want to pass a FV to Python so need to register that +- Dune::Python::registerFieldVector ( scope ); +- */ +- +- // first set of tests +- { +- // First example: +- // Call a C++ function that generats a FV, +- // call that in Python and compute squared 2-norm +- auto local = pybind11::dict(); +- local["call_test"] = pybind11::cpp_function([&]() -> auto +- { return Dune::FieldVector{4,2}; }); +- auto result = pybind11::eval( +- "print('Example 1');\n" +- "x = call_test();\n" +- "norm2_x = x.two_norm2;\n" +- "print('results',x);", +- global, local +- ); +- auto &x = local["x"].cast&>(); +- auto norm2_x = local["norm2_x"].cast(); +- if( !result.is( pybind11::none() ) +- || (x != Dune::FieldVector{4,2}) +- || (norm2_x != 20) ) +- std::cout << "Test 1 failed" << std::endl; +- +- // Second example: +- // Call a C++ function pssing in a FV reference and changing that +- // Note that the FV passed in is 'x&' generated in Example 2 +- local["call_testref"] = pybind11::cpp_function([&] +- (Dune::FieldVector& y) -> auto +- { y+=Dune::FieldVector{-4,-2}; }); +- auto resultref = pybind11::eval( +- "print('Example 2');\n" +- "call_testref(x);\n" +- "norm2_x = x.two_norm2;\n" +- "print('result',x);", +- global, local +- ); +- norm2_x = local["norm2_x"].cast(); +- if( !resultref.is( pybind11::none() ) +- || (x != Dune::FieldVector{0,0}) +- || (norm2_x != 0) ) +- std::cout << "Test 2 failed" << std::endl; +- +- // Third example: +- // Construct a FV on C++ side and use that on Python side +- // Note: local["z"]=z generates a copy so to retrieve the changed +- // FV one needs to copy again using z = local["z"].cast<...>(); +- Dune::FieldVector z{4,2}; +- local["call_testref2"] = pybind11::cpp_function([&] +- (Dune::FieldVector& y) -> auto +- { y+=z; }); +- local["z"] = z; +- auto resultref2 = pybind11::eval( +- "print('Example 3');\n" +- "import dune.common;\n" +- "zz=dune.common.FieldVector((2,4));\n" +- "call_testref2(zz);\n" +- "print('results',zz,'using',z);" +- "z *= 2\n" +- "print('changed z to',z);", +- global, local +- ); +- z = local["z"].cast>(); +- std::cout << "change of z on C++ side:" << z << std::endl; +- auto &zz = local["zz"].cast&>(); +- if( !resultref2.is( pybind11::none() ) +- || (zz != Dune::FieldVector{6,6}) ) +- std::cout << "Test 3 failed" << std::endl; +- +- // Example 4 +- // Can also use pointer to a FV in the `local` dict soo that +- // changes on the Python side are available on the C++ side without copy +- auto newLocal = pybind11::dict(); // test with a new local dict +- Dune::FieldVector fv2{4,2}; +- newLocal["fv2"] = pybind11::cast(&fv2); +- auto resultFVptr = pybind11::eval( +- "print('Example 4');\n" +- "print('changed fv from',fv2,end=' -> ')\n" +- "fv2 *= 2\n" +- "print(fv2);", +- global, newLocal +- ); +- std::cout << "C++ FV=" << fv2 << std::endl; +- if( !resultFVptr.is( pybind11::none() ) +- || (fv2 != Dune::FieldVector{8,4}) ) +- std::cout << "Test 4 failed" << std::endl; +- } +- +- // the final example uses the `FieldVector` function from the +- // dune.common module - this approach requires JIT in dune-py and +- // is turned off for the general embedding tests +- if (false) +- { +- // Example 5 +- // Similar to example 3 but without copying similar to Example 4 +- auto pyfv = dcommon.attr("FieldVector")(std::vector{4,2}); +- Dune::FieldVector& fv = pyfv.cast&>(); +- std::cout << "FV=" << pyfv << "==" << fv << std::endl; +- auto newLocal = pybind11::dict(); +- newLocal["fv"] = pyfv; +- auto resultFVa = pybind11::eval( +- "print('Example 5a');\n" +- "print('changed fv from',fv,end=' -> ')\n" +- "fv *= 2\n" +- "print(fv);", +- global, newLocal +- ); +- std::cout << "C++ FV=" << fv << std::endl; +- if( !resultFVa.is( pybind11::none() ) +- || (fv != Dune::FieldVector{8,4}) ) +- std::cout << "Test 5a failed" << std::endl; +- auto resultFVb = pybind11::eval( +- "print('Example 5b');\n" +- "print('changed fv from',fv,end=' -> ')\n" +- "fv *= 2\n" +- "print(fv);", +- global, newLocal +- ); +- std::cout << "C++ FV=" << fv << std::endl; +- if( !resultFVb.is( pybind11::none() ) +- || (fv != Dune::FieldVector{16,8}) ) +- std::cout << "Test 5b failed" << std::endl; +- } +-} +diff --git a/dune/python/test/test_embed2.cc b/dune/python/test/test_embed2.cc +deleted file mode 100644 +index 5f42b7543..000000000 +--- a/dune/python/test/test_embed2.cc ++++ /dev/null +@@ -1,38 +0,0 @@ +-#include +- +-#include +-#include +-#include +- +-int main() +-{ +- pybind11::scoped_interpreter guard{}; +- auto global = pybind11::dict(pybind11::module::import("__main__").attr("__dict__")); +- { +- pybind11::module dcommon = pybind11::module::import("dune.common"); +- // the following not only returns a fv but more importantly registers +- // the FV (but leads to JIT (the first time it's called) +- // in contrast to the approach in 'test_embed1.cc'). +- // Perhaps the use of 'std::vector' could be improved +- auto fv = dcommon.attr("FieldVector")(std::vector{4,2}); +- std::cout << "FV=" << fv << std::endl; +- +- // now execute Python code +- auto local = pybind11::dict(); +- local["call_test"] = pybind11::cpp_function([&]() -> auto +- { return Dune::FieldVector{4,2}; }); +- auto result = pybind11::eval( +- "print('Hello World!');\n" +- "x = call_test();\n" +- "norm2_x = x.two_norm2;\n" +- "print(x);", +- global, local +- ); +- auto x = local["x"].cast>(); +- if( !result.is( pybind11::none() ) || (x != Dune::FieldVector{4,2}) ) +- std::cout << "Test 1 failed" << std::endl; +- auto norm2_x = local["norm2_x"].cast(); +- if( !result.is( pybind11::none() ) || (norm2_x != 20) ) +- std::cout << "Test 1 failed" << std::endl; +- } +-} diff --git a/python/CMakeLists.txt b/python/CMakeLists.txt index 0c4ddccf90e05122277901c3cfbf4c9b2957cb68..cba93c3c8cc8f74c86c6edc4e885c17eb8ea0064 100644 --- a/python/CMakeLists.txt +++ b/python/CMakeLists.txt @@ -1,2 +1 @@ add_subdirectory(dumux) -configure_file(setup.py.in setup.py) diff --git a/python/dumux/CMakeLists.txt b/python/dumux/CMakeLists.txt index e11f39eed6571d247f90fbad0bc03b5324db7e29..4f95771a6614eff8b2224375adc22822a3c0c1ec 100644 --- a/python/dumux/CMakeLists.txt +++ b/python/dumux/CMakeLists.txt @@ -1,6 +1,2 @@ add_subdirectory(common) add_subdirectory(discretization) - -add_python_targets(dumux - __init__ -) diff --git a/python/dumux/common/CMakeLists.txt b/python/dumux/common/CMakeLists.txt index dc0edac4c667c3749dba21046d8675d5bead2b08..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644 --- a/python/dumux/common/CMakeLists.txt +++ b/python/dumux/common/CMakeLists.txt @@ -1,6 +0,0 @@ -add_python_targets(common - __init__ -) -dune_add_pybind11_module(NAME _common) -set_property(TARGET _common PROPERTY LINK_LIBRARIES dunecommon dunegrid APPEND) -install(TARGETS _common LIBRARY DESTINATION python/dumux/common) diff --git a/python/dumux/discretization/CMakeLists.txt b/python/dumux/discretization/CMakeLists.txt index 22b582c564c01350d456389cbab7543022d79cb3..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644 --- a/python/dumux/discretization/CMakeLists.txt +++ b/python/dumux/discretization/CMakeLists.txt @@ -1,3 +0,0 @@ -add_python_targets(discretization - __init__ -) diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 10f2e116f95d19981893b05b99ce3d314457aaac..22b9b8f7759dc6338f66d7827c3ed45583772d72 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -1,8 +1,9 @@ add_subdirectory(common) -add_subdirectory(geomechanics) -add_subdirectory(geometry) +add_subdirectory(discretization) add_subdirectory(flux) add_subdirectory(freeflow) +add_subdirectory(geomechanics) +add_subdirectory(geometry) add_subdirectory(io) add_subdirectory(linear) add_subdirectory(material) @@ -10,10 +11,6 @@ add_subdirectory(multidomain) add_subdirectory(nonlinear) add_subdirectory(porenetwork) add_subdirectory(porousmediumflow) -add_subdirectory(discretization) +add_subdirectory(python) +add_subdirectory(references) add_subdirectory(timestepping) - -# if Python bindings are enabled, include Python binding tests -if(DUNE_ENABLE_PYTHONBINDINGS) - add_subdirectory(python) -endif() diff --git a/test/common/CMakeLists.txt b/test/common/CMakeLists.txt index aa5c941f743298cb0299bde6c6a1817667a5402c..2dd942283dab405e29f6a2fa83b8a8ae7aff1f32 100644 --- a/test/common/CMakeLists.txt +++ b/test/common/CMakeLists.txt @@ -7,7 +7,3 @@ add_subdirectory(spline) add_subdirectory(stringutilities) add_subdirectory(timeloop) add_subdirectory(typetraits) - -dumux_add_test(SOURCES test_partial.cc LABELS unit) -dumux_add_test(SOURCES test_enumerate.cc LABELS unit) -dumux_add_test(SOURCES test_tag.cc LABELS unit) diff --git a/test/common/functions/CMakeLists.txt b/test/common/functions/CMakeLists.txt index 6903af93fd669c9e1253b221c2793d80a7572edc..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644 --- a/test/common/functions/CMakeLists.txt +++ b/test/common/functions/CMakeLists.txt @@ -1,3 +0,0 @@ -dumux_add_test(SOURCES test_function_l2norm.cc - CMAKE_GUARD dune-functions_FOUND - LABELS unit) diff --git a/test/common/integrate/CMakeLists.txt b/test/common/integrate/CMakeLists.txt index 54f255b05100a9714fe6b8ecd2fbbbb253feacaa..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644 --- a/test/common/integrate/CMakeLists.txt +++ b/test/common/integrate/CMakeLists.txt @@ -1 +0,0 @@ -dumux_add_test(SOURCES test_integratescalar.cc LABELS unit) diff --git a/test/common/math/CMakeLists.txt b/test/common/math/CMakeLists.txt index dca80ec4cb1ed681cb125e2c9a538e12376a0dbe..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644 --- a/test/common/math/CMakeLists.txt +++ b/test/common/math/CMakeLists.txt @@ -1,3 +0,0 @@ -# build the test for the math header -dumux_add_test(SOURCES test_math.cc - LABELS unit) diff --git a/test/common/parameters/CMakeLists.txt b/test/common/parameters/CMakeLists.txt index a69c776a6295109c8987bee8509cbd75edbf6b1b..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644 --- a/test/common/parameters/CMakeLists.txt +++ b/test/common/parameters/CMakeLists.txt @@ -1,3 +0,0 @@ -dumux_add_test(SOURCES test_loggingparametertree.cc - LABELS unit) -dune_symlink_to_source_files(FILES "params.input") diff --git a/test/common/propertysystem/CMakeLists.txt b/test/common/propertysystem/CMakeLists.txt index a023dbb47e4d078f4bc715e662f02089631795ab..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644 --- a/test/common/propertysystem/CMakeLists.txt +++ b/test/common/propertysystem/CMakeLists.txt @@ -1,3 +0,0 @@ -# build the test for the property system -dumux_add_test(SOURCES test_propertysystem.cc - LABELS unit) diff --git a/test/common/spline/CMakeLists.txt b/test/common/spline/CMakeLists.txt index 9e2cbccfe194c69d01f34a639b9c0c8e9f0b95a9..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644 --- a/test/common/spline/CMakeLists.txt +++ b/test/common/spline/CMakeLists.txt @@ -1,6 +0,0 @@ -dumux_add_test(SOURCES test_spline.cc - LABELS unit) -dumux_add_test(SOURCES test_cubicspline.cc - LABELS unit) -dumux_add_test(SOURCES test_monotonecubicspline.cc - LABELS unit) diff --git a/test/common/stringutilities/CMakeLists.txt b/test/common/stringutilities/CMakeLists.txt index 4d18231943f35558f4cdffa1cb16b20a9c8c0dab..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644 --- a/test/common/stringutilities/CMakeLists.txt +++ b/test/common/stringutilities/CMakeLists.txt @@ -1,2 +0,0 @@ -dumux_add_test(SOURCES test_stringutilities.cc - LABELS unit) diff --git a/test/common/timeloop/CMakeLists.txt b/test/common/timeloop/CMakeLists.txt index f7053d872f45229175cc9300ad1f4e1978123c6c..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644 --- a/test/common/timeloop/CMakeLists.txt +++ b/test/common/timeloop/CMakeLists.txt @@ -1,2 +0,0 @@ -dumux_add_test(SOURCES test_timeloop.cc - LABELS unit) diff --git a/test/common/typetraits/CMakeLists.txt b/test/common/typetraits/CMakeLists.txt index 550f1104573e9c5358614f95ba25672dcd14a549..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644 --- a/test/common/typetraits/CMakeLists.txt +++ b/test/common/typetraits/CMakeLists.txt @@ -1,2 +0,0 @@ -dumux_add_test(SOURCES test_isvalid.cc - LABELS unit) diff --git a/test/discretization/CMakeLists.txt b/test/discretization/CMakeLists.txt index 616b4ceee953dbf8f12b56d35407a2fb530488c7..71333063a30599fc5231d474775403b4bbc5cc13 100644 --- a/test/discretization/CMakeLists.txt +++ b/test/discretization/CMakeLists.txt @@ -1,11 +1,5 @@ -add_subdirectory(cellcentered) -add_subdirectory(staggered) add_subdirectory(box) +add_subdirectory(cellcentered) add_subdirectory(projection) add_subdirectory(rotationsymmetry) - -dumux_add_test(NAME test_disc_fvgridvariables - LABELS unit - SOURCES test_fvgridvariables.cc - COMMAND ./test_disc_fvgridvariables - CMD_ARGS -Problem.Name gridvarstest) +add_subdirectory(staggered) diff --git a/test/discretization/box/CMakeLists.txt b/test/discretization/box/CMakeLists.txt index f2ad7070ff4541773cbab499d225c86168da3cfe..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644 --- a/test/discretization/box/CMakeLists.txt +++ b/test/discretization/box/CMakeLists.txt @@ -1,9 +0,0 @@ -dumux_add_test(NAME test_boxfvgeometry - SOURCES test_boxfvgeometry.cc - COMPILE_DEFINITIONS ENABLE_CACHING=false - LABELS unit discretization) - -dumux_add_test(NAME test_boxfvgeometry_caching - SOURCES test_boxfvgeometry.cc - COMPILE_DEFINITIONS ENABLE_CACHING=true - LABELS unit discretization) diff --git a/test/discretization/cellcentered/CMakeLists.txt b/test/discretization/cellcentered/CMakeLists.txt index 5ac953e3e293c32368913d8e9cdcd511ad2c184d..2086b59aaf015f4186e6491a9b3991d060cacec6 100644 --- a/test/discretization/cellcentered/CMakeLists.txt +++ b/test/discretization/cellcentered/CMakeLists.txt @@ -1 +1 @@ -add_subdirectory("tpfa") +add_subdirectory(tpfa) diff --git a/test/discretization/cellcentered/tpfa/CMakeLists.txt b/test/discretization/cellcentered/tpfa/CMakeLists.txt index 8cfd8de84b8bacab972ab5a9f6bd6cd1da255905..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644 --- a/test/discretization/cellcentered/tpfa/CMakeLists.txt +++ b/test/discretization/cellcentered/tpfa/CMakeLists.txt @@ -1,21 +0,0 @@ -dumux_add_test(NAME test_tpfafvgeometry - SOURCES test_tpfafvgeometry.cc - COMPILE_DEFINITIONS ENABLE_CACHING=false - LABELS unit discretization) - -dumux_add_test(NAME test_tpfafvgeometry_caching - SOURCES test_tpfafvgeometry.cc - COMPILE_DEFINITIONS ENABLE_CACHING=true - LABELS unit discretization) - -dumux_add_test(NAME test_tpfafvgeometry_nonconforming - SOURCES test_tpfafvgeometry_nonconforming.cc - COMPILE_DEFINITIONS ENABLE_CACHING=false - CMAKE_GUARD dune-alugrid_FOUND - LABELS unit discretization) - -dumux_add_test(NAME test_cachedtpfafvgeometry_nonconforming - SOURCES test_tpfafvgeometry_nonconforming.cc - COMPILE_DEFINITIONS ENABLE_CACHING=true - CMAKE_GUARD dune-alugrid_FOUND - LABELS unit discretization) diff --git a/test/discretization/projection/CMakeLists.txt b/test/discretization/projection/CMakeLists.txt index 6a2c731827a1c449b9526d7d7736ab98df683332..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644 --- a/test/discretization/projection/CMakeLists.txt +++ b/test/discretization/projection/CMakeLists.txt @@ -1,6 +0,0 @@ -dune_symlink_to_source_files(FILES "params.input") - -dumux_add_test(NAME test_projection_2d1d - SOURCES test_projection_2d1d.cc - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-functions_FOUND )" - LABELS unit discretization) diff --git a/test/discretization/rotationsymmetry/CMakeLists.txt b/test/discretization/rotationsymmetry/CMakeLists.txt index f5d6c7dc71d25ba68f6101775c9f987a678d5330..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644 --- a/test/discretization/rotationsymmetry/CMakeLists.txt +++ b/test/discretization/rotationsymmetry/CMakeLists.txt @@ -1,2 +0,0 @@ -dumux_add_test(SOURCES test_rotationsymmetric_gridgeometry.cc - LABELS unit discretization) diff --git a/test/discretization/staggered/CMakeLists.txt b/test/discretization/staggered/CMakeLists.txt index 3a97bfbc52488439b360f3418478997503ff767d..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644 --- a/test/discretization/staggered/CMakeLists.txt +++ b/test/discretization/staggered/CMakeLists.txt @@ -1,9 +0,0 @@ -dune_symlink_to_source_files(FILES "params.input") - -dumux_add_test(NAME test_staggeredfvgeometry - SOURCES test_staggeredfvgeometry.cc - LABELS unit discretization) - -dumux_add_test(NAME test_staggered_free_flow_geometry - SOURCES test_staggered_free_flow_geometry.cc - LABELS unit discretization) diff --git a/test/flux/CMakeLists.txt b/test/flux/CMakeLists.txt index 0d26745087d0ea0223412d470141220580dc031d..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644 --- a/test/flux/CMakeLists.txt +++ b/test/flux/CMakeLists.txt @@ -1,2 +0,0 @@ -dumux_add_test(SOURCES test_diffusioncontainers.cc - LABELS unit flux) diff --git a/test/freeflow/navierstokes/CMakeLists.txt b/test/freeflow/navierstokes/CMakeLists.txt index ad8cb9cb700d8441d28a8658c532c590ad893440..632a667d5d1583e7f506a387d69a4b9402d2cabc 100644 --- a/test/freeflow/navierstokes/CMakeLists.txt +++ b/test/freeflow/navierstokes/CMakeLists.txt @@ -1,7 +1,9 @@ -add_subdirectory(donea) add_subdirectory(angeli) -add_subdirectory(kovasznay) add_subdirectory(channel) +add_subdirectory(donea) +add_subdirectory(kovasznay) add_subdirectory(sincos) -dune_symlink_to_source_files(FILES convergence.sh) +file(GLOB DUMUX_TEST_FREEFLOW_NAVIERSTOKES_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_FREEFLOW_NAVIERSTOKES_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/freeflow/navierstokes) diff --git a/test/freeflow/navierstokes/angeli/CMakeLists.txt b/test/freeflow/navierstokes/angeli/CMakeLists.txt index cb411f6e9a0d0f26db0f7422b50e5a280dddcba9..5e5292658d094b031338fca44a59800981c33d79 100644 --- a/test/freeflow/navierstokes/angeli/CMakeLists.txt +++ b/test/freeflow/navierstokes/angeli/CMakeLists.txt @@ -1,26 +1,3 @@ -dumux_add_test(NAME test_ff_navierstokes_angeli - LABELS freeflow navierstokes - SOURCES main.cc - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_navierstokes_angeli-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_navierstokes_angeli-00009.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_navierstokes_angeli params.input - -Problem.Name test_ff_navierstokes_angeli") - -dumux_add_test(NAME test_ff_navierstokes_angeli_averaged - LABELS freeflow navierstokes - TARGET test_ff_navierstokes_angeli - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_navierstokes_angeli_averaged-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_navierstokes_angeli_averaged-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_navierstokes_angeli params.input - -TimeLoop.TEnd 1e-6 -TimeLoop.DtInitial 1e-6 - -Problem.Name test_ff_navierstokes_angeli_averaged - -Problem.UseVelocityAveragingForInitial true - -Problem.UseVelocityAveragingForDirichlet true") - -dune_symlink_to_source_files(FILES "params.input") +file(GLOB DUMUX_TEST_FREEFLOW_NAVIERSTOKES_ANGELI_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_FREEFLOW_NAVIERSTOKES_ANGELI_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/freeflow/navierstokes/angeli) diff --git a/test/freeflow/navierstokes/channel/1d/CMakeLists.txt b/test/freeflow/navierstokes/channel/1d/CMakeLists.txt index 3a736323d12014cf5897ac633bebf310a1a29359..81d1dbc3e02f545b85e02d67d92a05bd31d3c104 100644 --- a/test/freeflow/navierstokes/channel/1d/CMakeLists.txt +++ b/test/freeflow/navierstokes/channel/1d/CMakeLists.txt @@ -1,11 +1,3 @@ -dumux_add_test(NAME test_ff_navierstokes_1d - LABELS freeflow navierstokes - SOURCES main.cc - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_navierstokes_1d-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_navierstokes_1d-00001.vtp - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_navierstokes_1d params.input - -Problem.Name test_ff_navierstokes_1d") -dune_symlink_to_source_files(FILES params.input) +file(GLOB DUMUX_TEST_FREEFLOW_NAVIERSTOKES_CHANNEL_1D_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_FREEFLOW_NAVIERSTOKES_CHANNEL_1D_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/freeflow/navierstokes/channel/1d) diff --git a/test/freeflow/navierstokes/channel/2d/CMakeLists.txt b/test/freeflow/navierstokes/channel/2d/CMakeLists.txt index 8729e2f1fc9d11d6f1276386f7464b4d93bde915..eeff587cadf52366f75cefb86e36dad37808ccb2 100644 --- a/test/freeflow/navierstokes/channel/2d/CMakeLists.txt +++ b/test/freeflow/navierstokes/channel/2d/CMakeLists.txt @@ -1,86 +1,3 @@ -add_input_file_links() - -add_executable(test_ff_channel EXCLUDE_FROM_ALL main.cc) - -dumux_add_test(NAME test_ff_stokes_channel_outflow - TARGET test_ff_channel - LABELS freeflow navierstokes - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_stokes_channel-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_stokes_channel_outflow-00002.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_channel params.input -Problem.OutletCondition Outflow - -Problem.Name test_ff_stokes_channel_outflow") - -dumux_add_test(NAME test_ff_stokes_channel_neumann_x_dirichlet_y - TARGET test_ff_channel - LABELS freeflow navierstokes - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_stokes_channel-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_stokes_channel_nxdy-00002.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_channel params.input -Problem.OutletCondition NeumannX_DirichletY - -Problem.Name test_ff_stokes_channel_nxdy") - -dumux_add_test(NAME test_ff_stokes_channel_neumann_x_neumann_y - TARGET test_ff_channel - LABELS freeflow navierstokes - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_stokes_channel_neumann-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_stokes_channel_nxny-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_channel params.input -Grid.UpperRight \"2 1\" -Grid.Cells \"50 25\" - -Problem.Name test_ff_stokes_channel_nxny -Problem.OutletCondition NeumannX_NeumannY - -Problem.UseVelocityProfile true -Problem.OutletPressure 0 -Problem.IsStationary 1") - -dumux_add_test(NAME test_ff_stokes_channel_do_nothing - TARGET test_ff_channel - LABELS freeflow navierstokes - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_stokes_channel_do_nothing-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_stokes_channel_do_nothing-00002.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_channel params.input -Problem.OutletCondition DoNothing -Grid.UpperRight \"2 1\" -Grid.Cells \"50 25\" - -Problem.Name test_ff_stokes_channel_do_nothing -Problem.OutletCondition DoNothing -Problem.UseVelocityProfile true -Problem.OutletPressure 0") - -dumux_add_test(NAME test_ff_navierstokes_channel - TARGET test_ff_channel - LABELS freeflow navierstokes - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_navierstokes_channel-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_navierstokes_channel-00002.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_channel params_navierstokes.input - -Vtk.WriteFaceData 1 - -Problem.Name test_ff_navierstokes_channel") - -add_executable(test_ff_stokesni_channel EXCLUDE_FROM_ALL main.cc) -target_compile_definitions(test_ff_stokesni_channel PUBLIC "NONISOTHERMAL=1") - -dumux_add_test(NAME test_ff_stokesni_channel_convection - TARGET test_ff_stokesni_channel - LABELS freeflow navierstokes - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_stokesni_channel_convection-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_stokesni_channel_convection-00005.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_stokesni_channel params_convection.input - -Problem.Name test_ff_stokesni_channel_convection") - -dumux_add_test(NAME test_ff_stokesni_channel_conduction - TARGET test_ff_stokesni_channel - LABELS freeflow navierstokes - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_stokesni_channel_conduction-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_stokesni_channel_conduction-00004.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_stokesni_channel params_conduction.input - -Problem.Name test_ff_stokesni_channel_conduction" - --zeroThreshold {"velocity_liq \(m/s\)":1e-20}) +file(GLOB DUMUX_TEST_FREEFLOW_NAVIERSTOKES_CHANNEL_2D_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_FREEFLOW_NAVIERSTOKES_CHANNEL_2D_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/freeflow/navierstokes/channel/2d) diff --git a/test/freeflow/navierstokes/channel/3d/CMakeLists.txt b/test/freeflow/navierstokes/channel/3d/CMakeLists.txt index 11356d3181361dc964ea2ff5cdb069fedf48ba23..85ea6421bd61b2e6ec22bb631a0e24e81c2737a9 100644 --- a/test/freeflow/navierstokes/channel/3d/CMakeLists.txt +++ b/test/freeflow/navierstokes/channel/3d/CMakeLists.txt @@ -1,42 +1,3 @@ -add_executable(test_ff_stokes_channel_3d EXCLUDE_FROM_ALL main.cc) -target_compile_definitions(test_ff_stokes_channel_3d PUBLIC "GRID_DIM=3") - -dumux_add_test(NAME test_ff_stokes_channel_3d_cuboid - TARGET test_ff_stokes_channel_3d - LABELS freeflow navierstokes - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_stokes_channel_3d_cuboid-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_stokes_channel_3d_cuboid-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_stokes_channel_3d params.input - -Problem.Name test_ff_stokes_channel_3d_cuboid" - --zeroThreshold {"velocity_liq \(m/s\)":1e-12}) - -dumux_add_test(NAME test_ff_stokes_channel_3d_staircase - TARGET test_ff_stokes_channel_3d - LABELS freeflow navierstokes - CMAKE_GUARD HAVE_UMFPACK dune-subgrid_FOUND - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_stokes_channel_3d_staircase-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_stokes_channel_3d_staircase-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_stokes_channel_3d params.input - -Problem.Name test_ff_stokes_channel_3d_staircase -Problem.IsStaircaseGeometry true" - --zeroThreshold {"velocity_liq \(m/s\)":1e-12}) - -dumux_add_test(NAME test_ff_stokes_channel_pseudo3d - LABELS freeflow navierstokes - SOURCES main.cc - COMPILE_DEFINITIONS GRID_DIM=2 - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_stokes_channel_pseudo3d-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_stokes_channel_pseudo3d-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_stokes_channel_pseudo3d params_pseudo.input - -Problem.Name test_ff_stokes_channel_pseudo3d" - --zeroThreshold {"velocity_liq \(m/s\)":1e-12}) - - -dune_symlink_to_source_files(FILES "params.input" "params_pseudo.input") +file(GLOB DUMUX_TEST_FREEFLOW_NAVIERSTOKES_CHANNEL_3D_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_FREEFLOW_NAVIERSTOKES_CHANNEL_3D_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/freeflow/navierstokes/channel/3d) diff --git a/test/freeflow/navierstokes/channel/pipe/CMakeLists.txt b/test/freeflow/navierstokes/channel/pipe/CMakeLists.txt index b6df8b18118d1bdf9576dd1115e04c437d933ed6..7e72c0b48317d764617bea41ecf3edb8a8a2de47 100644 --- a/test/freeflow/navierstokes/channel/pipe/CMakeLists.txt +++ b/test/freeflow/navierstokes/channel/pipe/CMakeLists.txt @@ -1,8 +1,3 @@ -dune_symlink_to_source_files(FILES params.input convergencetest.py) -dumux_add_test(NAME test_ff_stokes_channel_pipe - LABELS freeflow navierstokes - SOURCES main.cc - LABELS freeflow - CMAKE_GUARD HAVE_UMFPACK - COMMAND ./convergencetest.py - CMD_ARGS test_ff_stokes_channel_pipe) +file(GLOB DUMUX_TEST_FREEFLOW_NAVIERSTOKES_CHANNEL_PIPE_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_FREEFLOW_NAVIERSTOKES_CHANNEL_PIPE_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/freeflow/navierstokes/channel/pipe) diff --git a/test/freeflow/navierstokes/donea/CMakeLists.txt b/test/freeflow/navierstokes/donea/CMakeLists.txt index d61d235af3224a85aeb3dc01747aff4b07fdc539..1d05a357e7f946ff0083619d7a5172c95182df53 100644 --- a/test/freeflow/navierstokes/donea/CMakeLists.txt +++ b/test/freeflow/navierstokes/donea/CMakeLists.txt @@ -1,25 +1,3 @@ -dumux_add_test(NAME test_ff_stokes_donea_nocaching - LABELS freeflow navierstokes - SOURCES main.cc - CMAKE_GUARD HAVE_UMFPACK - COMPILE_DEFINITIONS ENABLECACHING=0 - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_stokes_donea-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_stokes_donea_nocaching-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_stokes_donea_nocaching params.input - -Problem.Name test_ff_stokes_donea_nocaching") - -dumux_add_test(NAME test_ff_stokes_donea - LABELS freeflow navierstokes - SOURCES main.cc - CMAKE_GUARD HAVE_UMFPACK - COMPILE_DEFINITIONS ENABLECACHING=1 - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_stokes_donea-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_stokes_donea-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_stokes_donea params.input - -Problem.Name test_ff_stokes_donea") - -dune_symlink_to_source_files(FILES "params.input") +file(GLOB DUMUX_TEST_FREEFLOW_NAVIERSTOKES_DONEA_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_FREEFLOW_NAVIERSTOKES_DONEA_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/freeflow/navierstokes/donea) diff --git a/test/freeflow/navierstokes/kovasznay/CMakeLists.txt b/test/freeflow/navierstokes/kovasznay/CMakeLists.txt index b23ba04847fdc2060cb927d920380e0a0adf6833..d50bbba957e82a07228a308cbec6b4edbb8f657f 100644 --- a/test/freeflow/navierstokes/kovasznay/CMakeLists.txt +++ b/test/freeflow/navierstokes/kovasznay/CMakeLists.txt @@ -1,46 +1,3 @@ -dumux_add_test(NAME test_ff_navierstokes_kovasznay - LABELS freeflow navierstokes - TIMEOUT 3600 - SOURCES main.cc - CMAKE_GUARD HAVE_UMFPACK - COMPILE_DEFINITIONS UPWINDSCHEMEORDER=1 - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_navierstokes_kovasznay-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_navierstokes_kovasznay-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_navierstokes_kovasznay params.input - -Problem.Name test_ff_navierstokes_kovasznay") - -add_executable(test_ff_navierstokes_kovasznay_higherorder EXCLUDE_FROM_ALL main.cc) -target_compile_definitions(test_ff_navierstokes_kovasznay_higherorder PUBLIC "UPWINDSCHEMEORDER=2") - -dumux_add_test(NAME test_ff_navierstokes_kovasznay_higherorder_cuboid - TARGET test_ff_navierstokes_kovasznay_higherorder - LABELS freeflow navierstokes - TIMEOUT 3600 - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_navierstokes_kovasznay_higherorder_cuboid-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_navierstokes_kovasznay_higherorder_cuboid-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_navierstokes_kovasznay_higherorder params.input - -Problem.Name test_ff_navierstokes_kovasznay_higherorder_cuboid - -Flux.TvdApproach Hou - -Flux.DifferencingScheme Vanleer") - -dumux_add_test(NAME test_ff_navierstokes_kovasznay_higherorder_staircase - TARGET test_ff_navierstokes_kovasznay_higherorder - LABELS freeflow navierstokes - TIMEOUT 3600 - CMAKE_GUARD HAVE_UMFPACK dune-subgrid_FOUND - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_navierstokes_kovasznay_higherorder_staircase-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_navierstokes_kovasznay_higherorder_staircase-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_navierstokes_kovasznay_higherorder params.input - -Problem.Name test_ff_navierstokes_kovasznay_higherorder_staircase - -Problem.IsStaircaseGeometry true - -Flux.TvdApproach Hou - -Flux.DifferencingScheme Vanleer") - -dune_symlink_to_source_files(FILES "params.input") +file(GLOB DUMUX_TEST_FREEFLOW_NAVIERSTOKES_KOVASZNAY_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_FREEFLOW_NAVIERSTOKES_KOVASZNAY_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/freeflow/navierstokes/kovasznay) diff --git a/test/freeflow/navierstokes/sincos/CMakeLists.txt b/test/freeflow/navierstokes/sincos/CMakeLists.txt index ebf2aae64e1483b832bdfeeedeeb411b5f1dbab3..eaa10e566bf6b091724a357dad3821a082ff4060 100644 --- a/test/freeflow/navierstokes/sincos/CMakeLists.txt +++ b/test/freeflow/navierstokes/sincos/CMakeLists.txt @@ -1,50 +1,3 @@ -dune_symlink_to_source_files(FILES "convergencetest.py") -dune_symlink_to_source_files(FILES "params.input") - -dumux_add_test(NAME test_ff_navierstokes_sincos - SOURCES main.cc - LABELS freeflow - TIMEOUT 3600 - CMAKE_GUARD HAVE_UMFPACK - COMPILE_DEFINITIONS LINEARSOLVER=UMFPackBackend - COMMAND ./convergencetest.py - CMD_ARGS test_ff_navierstokes_sincos params.input - -Grid.UpperRight "6.28 6.28" - -Grid.Cells "150 150" - -Problem.Name test_ff_navierstokes_sincos_stationary_convergence - -Problem.IsStationary true - -Component.LiquidKinematicViscosity 0.001) - -dumux_add_test(NAME test_ff_navierstokes_sincos_instationary - TARGET test_ff_navierstokes_sincos - LABELS freeflow - TIMEOUT 3600 - CMAKE_GUARD HAVE_UMFPACK - COMPILE_DEFINITIONS LINEARSOLVER=UMFPackBackend - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_navierstokes_sincos_instationary-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_navierstokes_sincos_instationary-00017.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_navierstokes_sincos params.input - -Grid.UpperRight '1 1' - -Grid.Cells '50 50' - -Problem.Name test_ff_navierstokes_sincos_instationary - -Problem.IsStationary false - -Component.LiquidKinematicViscosity 0.1") - -dumux_add_test(NAME test_ff_navierstokes_sincos_uzawapreconditioner_factory - SOURCES main.cc - LABELS freeflow - TIMEOUT 5000 - CMAKE_GUARD "( HAVE_UMFPACK AND ( ( DUNE_ISTL_VERSION VERSION_GREATER 2.7 ) OR ( DUNE_ISTL_VERSION VERSION_EQUAL 2.7 ) ) )" - COMPILE_DEFINITIONS LINEARSOLVER=IstlSolverFactoryBackend> - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_navierstokes_sincos_instationary-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_navierstokes_sincos_uzawapreconditioner-00017.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_navierstokes_sincos_uzawapreconditioner_factory params.input - -Grid.UpperRight '1 1' - -Grid.Cells '50 50' - -Problem.Name test_ff_navierstokes_sincos_uzawapreconditioner - -Problem.IsStationary false - -Component.LiquidKinematicViscosity 0.1") +file(GLOB DUMUX_TEST_FREEFLOW_NAVIERSTOKES_SINCOS_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_FREEFLOW_NAVIERSTOKES_SINCOS_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/freeflow/navierstokes/sincos) diff --git a/test/freeflow/navierstokesnc/CMakeLists.txt b/test/freeflow/navierstokesnc/CMakeLists.txt index b658ab60ea9765194c3e85f9da67e36bf3cf593d..509fcbd0e541a880487f9ae8927308ccf3e8b88c 100644 --- a/test/freeflow/navierstokesnc/CMakeLists.txt +++ b/test/freeflow/navierstokesnc/CMakeLists.txt @@ -1,3 +1,3 @@ -add_subdirectory(densitydrivenflow) add_subdirectory(channel) +add_subdirectory(densitydrivenflow) add_subdirectory(maxwellstefan) diff --git a/test/freeflow/navierstokesnc/channel/CMakeLists.txt b/test/freeflow/navierstokesnc/channel/CMakeLists.txt index a09eba5f0ecd48243b42674b4a338e09af9f0824..6b36cf47892c63c715a2f84bd6261fac2597f489 100644 --- a/test/freeflow/navierstokesnc/channel/CMakeLists.txt +++ b/test/freeflow/navierstokesnc/channel/CMakeLists.txt @@ -1,79 +1,3 @@ -dune_symlink_to_source_files(FILES "params_advection.input" "params_diffusion.input" "params_advectionni.input" "params_diffusionni.input") - -add_executable(test_ff_stokes2c_mass EXCLUDE_FROM_ALL main.cc) -target_compile_definitions(test_ff_stokes2c_mass PUBLIC "USE_MASS=1") - -dumux_add_test(NAME test_ff_stokes2c_diffusion_mass - TARGET test_ff_stokes2c_mass - LABELS freeflow navierstokes - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_stokes2c_diffusion-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_stokes2c_diffusion_mass-00015.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_stokes2c_mass params_diffusion.input - -Problem.Name test_ff_stokes2c_diffusion_mass" - --zeroThreshold {"velocity_liq \(m/s\)":1e-22}) - -add_executable(test_ff_stokes2c EXCLUDE_FROM_ALL main.cc) - -dumux_add_test(NAME test_ff_stokes2c_diffusion_mole - TARGET test_ff_stokes2c - LABELS freeflow navierstokes - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_stokes2c_diffusion-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_stokes2c_diffusion_mole-00015.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_stokes2c params_diffusion.input - -Problem.Name test_ff_stokes2c_diffusion_mole" - --zeroThreshold {"velocity_liq \(m/s\)":1e-22}) - -dumux_add_test(NAME test_ff_stokes2c_advection - TARGET test_ff_stokes2c - LABELS freeflow navierstokes - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_stokes2c_advection-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_stokes2c_advection-00009.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_stokes2c params_advection.input - -Problem.Name test_ff_stokes2c_advection") - -dumux_add_test(NAME test_ff_stokes2c_advection_nocaching - SOURCES main.cc - LABELS freeflow navierstokes - CMAKE_GUARD HAVE_UMFPACK - COMPILE_DEFINITIONS ENABLECACHING=0 - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_stokes2c_advection-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_stokes2c_advection_nocaching-00009.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_stokes2c_advection_nocaching params_advection.input - -Problem.Name test_ff_stokes2c_advection_nocaching") - -add_executable(test_ff_stokes2cni EXCLUDE_FROM_ALL main.cc) -target_compile_definitions(test_ff_stokes2cni PUBLIC "NONISOTHERMAL=1") - -dumux_add_test(NAME test_ff_stokes2cni_advection - TARGET test_ff_stokes2cni - LABELS freeflow navierstokes - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_stokes2cni_advection-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_stokes2cni_advection-00009.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_stokes2cni params_advectionni.input - -Problem.Name test_ff_stokes2cni_advection") - -dumux_add_test(NAME test_ff_stokes2cni_diffusion - TARGET test_ff_stokes2cni - LABELS freeflow navierstokes - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_stokes2cni_diffusion-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_stokes2cni_diffusion-00014.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_stokes2cni params_diffusionni.input - -Problem.Name test_ff_stokes2cni_diffusion" - --zeroThreshold {"velocity_liq \(m/s\)":1e-13}) +file(GLOB DUMUX_TEST_FREEFLOW_NAVIERSTOKESNC_CHANNEL_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_FREEFLOW_NAVIERSTOKESNC_CHANNEL_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/freeflow/navierstokesnc/channel) diff --git a/test/freeflow/navierstokesnc/densitydrivenflow/CMakeLists.txt b/test/freeflow/navierstokesnc/densitydrivenflow/CMakeLists.txt index d2c0a1af740de64d5d13abc345d4103f5513e86e..e985cb70ca9215f52171dd1d6c1ca7e0b73f601f 100644 --- a/test/freeflow/navierstokesnc/densitydrivenflow/CMakeLists.txt +++ b/test/freeflow/navierstokesnc/densitydrivenflow/CMakeLists.txt @@ -1,17 +1,3 @@ - -dumux_add_test(NAME test_ff_stokes2c_densitydrivenflow - LABELS freeflow navierstokes - SOURCES main.cc - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_stokes2c_densitydrivenflow-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_stokes2c_densitydrivenflow-00021.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_stokes2c_densitydrivenflow params.input - -Problem.Name test_ff_stokes2c_densitydrivenflow" - --zeroThreshold {"X^Air_liq":1e-12} - --zeroThreshold {"x^Air_liq":1e-12} - --zeroThreshold {"velocity_liq \(m/s\)":1e-10} - --zeroThreshold {"deltaRho":1e-7}) - -dune_symlink_to_source_files(FILES "params.input") +file(GLOB DUMUX_TEST_FREEFLOW_NAVIERSTOKESNC_DENSITYDRIVENFLOW_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_FREEFLOW_NAVIERSTOKESNC_DENSITYDRIVENFLOW_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/freeflow/navierstokesnc/densitydrivenflow) diff --git a/test/freeflow/navierstokesnc/maxwellstefan/CMakeLists.txt b/test/freeflow/navierstokesnc/maxwellstefan/CMakeLists.txt index 1fe76a15d7d57d868a9068d775bd8a2a12bc35ab..3063c26c07d0804aa95405a68d75cd15021bc69a 100644 --- a/test/freeflow/navierstokesnc/maxwellstefan/CMakeLists.txt +++ b/test/freeflow/navierstokesnc/maxwellstefan/CMakeLists.txt @@ -1,12 +1,3 @@ -dumux_add_test(NAME test_ff_stokes2c_maxwellstefan - LABELS freeflow navierstokes - SOURCES main.cc - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_stokes2c_maxwellstefan-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_stokes2c_maxwellstefan-00005.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_stokes2c_maxwellstefan params.input - -Problem.Name test_ff_stokes2c_maxwellstefan") - -dune_symlink_to_source_files(FILES "params.input") +file(GLOB DUMUX_TEST_FREEFLOW_NAVIERSTOKESNC_MAXWELLSTEFAN_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_FREEFLOW_NAVIERSTOKESNC_MAXWELLSTEFAN_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/freeflow/navierstokesnc/maxwellstefan) diff --git a/test/freeflow/rans/CMakeLists.txt b/test/freeflow/rans/CMakeLists.txt index 2b6e93fd99929f323061d0d2bb153cee2e4b3557..f8832795ac86b5399dcb701fc95bb2ea95b3bbf9 100644 --- a/test/freeflow/rans/CMakeLists.txt +++ b/test/freeflow/rans/CMakeLists.txt @@ -1,182 +1,6 @@ -add_input_file_links() -dune_symlink_to_source_files(FILES references scripts) +add_subdirectory(references) +add_subdirectory(scripts) -add_executable(test_ff_rans_lauferpipe_kepsilon EXCLUDE_FROM_ALL main.cc) -target_compile_definitions(test_ff_rans_lauferpipe_kepsilon PUBLIC "TYPETAG=PipeLauferKEpsilon") - -dumux_add_test(NAME test_ff_rans_lauferpipe_kepsilon_twolayers - TARGET test_ff_rans_lauferpipe_kepsilon - LABELS freeflow rans - CMAKE_GUARD HAVE_UMFPACK - TIMEOUT 1500 - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_rans_lauferpipe_kepsilon_twolayers-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_rans_lauferpipe_kepsilon_twolayers-00070.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_rans_lauferpipe_kepsilon params.input - -Problem.Name test_ff_rans_lauferpipe_kepsilon_twolayers - -RANS.IsFlatWallBounded True") - -dumux_add_test(NAME test_ff_rans_lauferpipe_kepsilon_wallfunction - TARGET test_ff_rans_lauferpipe_kepsilon - LABELS freeflow rans - CMAKE_GUARD HAVE_UMFPACK - TIMEOUT 1500 - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_rans_lauferpipe_kepsilon_wallfunction-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_rans_lauferpipe_kepsilon_wallfunction-00034.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_rans_lauferpipe_kepsilon params_wallfunction.input - -Problem.Name test_ff_rans_lauferpipe_kepsilon_wallfunction - -RANS.IsFlatWallBounded True") - -dumux_add_test(NAME test_ff_rans_lauferpipe_lowrekepsilon - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=PipeLauferLowReKEpsilon - LABELS freeflow rans - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_rans_lauferpipe_lowrekepsilon-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_rans_lauferpipe_lowrekepsilon-00053.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_rans_lauferpipe_lowrekepsilon params.input - -Problem.Name test_ff_rans_lauferpipe_lowrekepsilon - -RANS.IsFlatWallBounded True") - - -add_executable(test_ff_rans_lauferpipe_komega EXCLUDE_FROM_ALL main.cc) -target_compile_definitions(test_ff_rans_lauferpipe_komega PUBLIC "TYPETAG=PipeLauferKOmega") - -dumux_add_test(NAME test_ff_rans_lauferpipe_komega_channel - TARGET test_ff_rans_lauferpipe_komega - LABELS freeflow rans - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_rans_lauferpipe_komega-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_rans_lauferpipe_komega-00047.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_rans_lauferpipe_komega params.input - -Problem.Name test_ff_rans_lauferpipe_komega - -RANS.IsFlatWallBounded True") - -dumux_add_test(NAME test_ff_rans_lauferpipe_komega_nochannel - TARGET test_ff_rans_lauferpipe_komega - LABELS freeflow rans - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_rans_lauferpipe_komega_nochannel-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_rans_lauferpipe_komega_nochannel-00047.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_rans_lauferpipe_komega params.input - -Problem.Name test_ff_rans_lauferpipe_komega_nochannel - -RANS.IsFlatWallBounded False - -RANS.WriteFlatWallBoundedFields False") - -dumux_add_test(NAME test_ff_rans_lauferpipe_oneeq - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=PipeLauferOneEq - LABELS freeflow rans - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_rans_lauferpipe_oneeq-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_rans_lauferpipe_oneeq-00044.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_rans_lauferpipe_oneeq params.input - -Problem.Name test_ff_rans_lauferpipe_oneeq - -RANS.IsFlatWallBounded True") - -dumux_add_test(NAME test_ff_rans_lauferpipe_zeroeq - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=PipeLauferZeroEq - LABELS freeflow rans - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_rans_lauferpipe_zeroeq-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_rans_lauferpipe_zeroeq-00035.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_rans_lauferpipe_zeroeq params.input - -Problem.Name test_ff_rans_lauferpipe_zeroeq - -RANS.IsFlatWallBounded True") - -#/////////////////////////////// -#/// The nonisothermal tests /// -#/////////////////////////////// - -add_executable(test_ff_ransni_lauferpipe_kepsilon EXCLUDE_FROM_ALL main.cc) -target_compile_definitions(test_ff_ransni_lauferpipe_kepsilon PUBLIC "TYPETAG=PipeLauferNIKEpsilon" "NONISOTHERMAL=1") - -dumux_add_test(NAME test_ff_ransni_lauferpipe_kepsilon_twolayers - TARGET test_ff_ransni_lauferpipe_kepsilon - LABELS freeflow rans - CMAKE_GUARD HAVE_UMFPACK - TIMEOUT 1500 - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_ransni_lauferpipe_kepsilon_twolayers-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_ransni_lauferpipe_kepsilon_twolayers-00034.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_ransni_lauferpipe_kepsilon params_nonisothermal.input - -Problem.Name test_ff_ransni_lauferpipe_kepsilon_twolayers") - -dumux_add_test(NAME test_ff_ransni_lauferpipe_kepsilon_wallfunction - TARGET test_ff_ransni_lauferpipe_kepsilon - LABELS freeflow rans - TIMEOUT 1500 - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_ransni_lauferpipe_kepsilon_wallfunction-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_ransni_lauferpipe_kepsilon_wallfunction-00027.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_ransni_lauferpipe_kepsilon params_nonisothermal_wallfunction.input - -Problem.Name test_ff_ransni_lauferpipe_kepsilon_wallfunction") - -dumux_add_test(NAME test_ff_ransni_lauferpipe_lowrekepsilon - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=PipeLauferNILowReKEpsilon - LABELS freeflow rans - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/./test_ff_ransni_lauferpipe_lowrekepsilon-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/./test_ff_ransni_lauferpipe_lowrekepsilon-00034.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_ransni_lauferpipe_lowrekepsilon params_nonisothermal.input - -Problem.Name ./test_ff_ransni_lauferpipe_lowrekepsilon") -target_compile_definitions(test_ff_ransni_lauferpipe_lowrekepsilon PUBLIC "NONISOTHERMAL=1") - -dumux_add_test(NAME test_ff_ransni_lauferpipe_komega - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=PipeLauferNIKOmega - LABELS freeflow rans - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_ransni_lauferpipe_komega-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_ransni_lauferpipe_komega-00040.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_ransni_lauferpipe_komega params_nonisothermal.input - -Problem.Name test_ff_ransni_lauferpipe_komega") -target_compile_definitions(test_ff_ransni_lauferpipe_komega PUBLIC "NONISOTHERMAL=1") - -dumux_add_test(NAME test_ff_ransni_lauferpipe_oneeq - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=PipeLauferNIOneEq - LABELS freeflow rans - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_ransni_lauferpipe_oneeq-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_ransni_lauferpipe_oneeq-00037.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_ransni_lauferpipe_oneeq params_nonisothermal.input - -Problem.Name test_ff_ransni_lauferpipe_oneeq") -target_compile_definitions(test_ff_ransni_lauferpipe_oneeq PUBLIC "NONISOTHERMAL=1") - -dumux_add_test(NAME test_ff_ransni_lauferpipe_zeroeq - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=PipeLauferNIZeroEq - LABELS freeflow rans - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_ransni_lauferpipe_zeroeq-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_ransni_lauferpipe_zeroeq-00033.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_ransni_lauferpipe_zeroeq params_nonisothermal.input - -Problem.Name test_ff_ransni_lauferpipe_zeroeq") -target_compile_definitions(test_ff_ransni_lauferpipe_zeroeq PUBLIC "NONISOTHERMAL=1") +file(GLOB DUMUX_TEST_FREEFLOW_RANS_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_FREEFLOW_RANS_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/freeflow/rans) diff --git a/test/freeflow/rans/references/CMakeLists.txt b/test/freeflow/rans/references/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/test/freeflow/rans/scripts/CMakeLists.txt b/test/freeflow/rans/scripts/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/test/freeflow/ransnc/CMakeLists.txt b/test/freeflow/ransnc/CMakeLists.txt index 2f3ae507580be8848fcae485c99839a92552e85e..67457ab8e1b94e6a5e9b99f9f3f9e535c595aa7d 100644 --- a/test/freeflow/ransnc/CMakeLists.txt +++ b/test/freeflow/ransnc/CMakeLists.txt @@ -1,182 +1,5 @@ -add_input_file_links() -dune_symlink_to_source_files(FILES solutions) +add_subdirectory(solutions) -# isothermal tests -add_executable(test_ff_rans2c_kepsilon EXCLUDE_FROM_ALL main.cc) -target_compile_definitions(test_ff_rans2c_kepsilon PUBLIC "TYPETAG=FlatPlateNCKEpsilon") - -dumux_add_test(NAME test_ff_rans2c_kepsilon_twolayer - TARGET test_ff_rans2c_kepsilon - LABELS freeflow rans - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_rans2c_kepsilon_twolayer-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_rans2c_kepsilon_twolayer-00032.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_rans2c_kepsilon params.input - -Problem.Name test_ff_rans2c_kepsilon_twolayer") - -dumux_add_test(NAME test_ff_rans2c_kepsilon_wallfunctions - TARGET test_ff_rans2c_kepsilon - LABELS freeflow rans - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_rans2c_kepsilon_wallfunctions-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_rans2c_kepsilon_wallfunctions-00028.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_rans2c_kepsilon params_wallfunction.input - -Problem.Name test_ff_rans2c_kepsilon_wallfunctions") - -dumux_add_test(NAME test_ff_rans2c_komega - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=FlatPlateNCKOmega - LABELS freeflow rans - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_rans2c_komega-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_rans2c_komega-00036.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_rans2c_komega params.input - -Problem.Name test_ff_rans2c_komega") - -dumux_add_test(NAME test_ff_rans2c_lowrekepsilon - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=FlatPlateNCLowReKEpsilon - LABELS freeflow rans - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_rans2c_lowrekepsilon-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_rans2c_lowrekepsilon-00031.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_rans2c_lowrekepsilon params.input - -Problem.Name test_ff_rans2c_lowrekepsilon") - -dumux_add_test(NAME test_ff_rans2c_oneeq - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=FlatPlateNCOneEq - LABELS freeflow rans - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_rans2c_oneeq-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_rans2c_oneeq-00032.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_rans2c_oneeq params.input - -Problem.Name test_ff_rans2c_oneeq") - - -dumux_add_test(NAME test_ff_rans2c_zeroeq - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=FlatPlateNCZeroEq - LABELS freeflow rans - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_rans2c_zeroeq-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_rans2c_zeroeq-00030.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_rans2c_zeroeq params.input - -Problem.Name test_ff_rans2c_zeroeq") - -#/////////////////////////// -#/// Nonisothermal tests /// -#/////////////////////////// - -add_executable(test_ff_rans2cni_kepsilon EXCLUDE_FROM_ALL main.cc) -target_compile_definitions(test_ff_rans2cni_kepsilon PUBLIC "TYPETAG=FlatPlateNCNIKEpsilon" "NONISOTHERMAL") - -dumux_add_test(NAME test_ff_rans2cni_kepsilon_twolayer - TARGET test_ff_rans2cni_kepsilon - LABELS freeflow rans - TIMEOUT 3600 - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_rans2cni_kepsilon_twolayer-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_rans2cni_kepsilon_twolayer-00031.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_rans2cni_kepsilon params_nonisothermal.input - -Problem.Name test_ff_rans2cni_kepsilon_twolayer") - -dumux_add_test(NAME test_ff_rans2cni_kepsilon_wallfunction - TARGET test_ff_rans2cni_kepsilon - LABELS freeflow rans - TIMEOUT 3600 - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_rans2cni_kepsilon_wallfunction-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_rans2cni_kepsilon_wallfunction-00024.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_rans2cni_kepsilon params_nonisothermal_wallfunction.input - -Problem.Name test_ff_rans2cni_kepsilon_wallfunction") - -dumux_add_test(NAME test_ff_rans2cni_komega - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=FlatPlateNCNIKOmega - COMPILE_DEFINITIONS NONISOTHERMAL - LABELS freeflow rans - TIMEOUT 3600 - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_rans2cni_komega-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_rans2cni_komega-00031.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_rans2cni_komega params_nonisothermal.input - -Problem.Name test_ff_rans2cni_komega - -Newton.TargetSteps 12") - -dumux_add_test(NAME test_ff_rans2cni_komega_loadsolution - TARGET test_ff_rans2cni_komega - LABELS freeflow rans loadsolution - TIMEOUT 3600 - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_rans2cni_komega_loadsolution-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_rans2cni_komega_loadsolution-00008.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_rans2cni_komega params_nonisothermal.input - -LoadSolution.RansCCFile ./solutions/komeganc_ccsolution.vtu - -LoadSolution.RansFaceFile ./solutions/komeganc_facesolution.vtp - -Problem.Name test_ff_rans2cni_komega_loadsolution - -TimeLoop.DtInitial 5.0 - -TimeLoop.TEnd 200.0") - -dumux_add_test(NAME test_ff_rans2cni_lowrekepsilon - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=FlatPlateNCNILowReKEpsilon - LABELS freeflow rans - TIMEOUT 3600 - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_rans2cni_lowrekepsilon-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_rans2cni_lowrekepsilon-00030.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_rans2cni_lowrekepsilon params_nonisothermal.input - -Problem.Name test_ff_rans2cni_lowrekepsilon") -target_compile_definitions(test_ff_rans2cni_lowrekepsilon PUBLIC "NONISOTHERMAL") - -dumux_add_test(NAME test_ff_rans2cni_oneeq - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=FlatPlateNCNIOneEq - LABELS freeflow rans - TIMEOUT 3600 - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_rans2cni_oneeq-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_rans2cni_oneeq-00031.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_rans2cni_oneeq params_nonisothermal.input - -Problem.Name test_ff_rans2cni_oneeq") - -target_compile_definitions(test_ff_rans2cni_oneeq PUBLIC "NONISOTHERMAL") - -dumux_add_test(NAME test_ff_rans2cni_zeroeq - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=FlatPlateNCNIZeroEq - LABELS freeflow rans - TIMEOUT 3600 - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_rans2cni_zeroeq-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_ff_rans2cni_zeroeq-00030.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_ff_rans2cni_zeroeq params_nonisothermal.input - -Problem.Name test_ff_rans2cni_zeroeq") -target_compile_definitions(test_ff_rans2cni_zeroeq PUBLIC "NONISOTHERMAL") +file(GLOB DUMUX_TEST_FREEFLOW_RANSNC_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_FREEFLOW_RANSNC_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/freeflow/ransnc) diff --git a/test/freeflow/ransnc/solutions/CMakeLists.txt b/test/freeflow/ransnc/solutions/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/test/freeflow/shallowwater/CMakeLists.txt b/test/freeflow/shallowwater/CMakeLists.txt index 2f2fec8b7675709ea0dcec2a628829e39c12f97d..7afd2d607f933ce55c5dc6d12a5823d600f4780a 100644 --- a/test/freeflow/shallowwater/CMakeLists.txt +++ b/test/freeflow/shallowwater/CMakeLists.txt @@ -1,3 +1,4 @@ +add_subdirectory(Testing) add_subdirectory(bowl) add_subdirectory(dambreak) add_subdirectory(poiseuilleflow) diff --git a/test/freeflow/shallowwater/bowl/CMakeLists.txt b/test/freeflow/shallowwater/bowl/CMakeLists.txt index 3e91f2fe467a106cb4b9d0cdb622fc1194d57927..f9cb94a174af8dd70a319cb5c01db057d4bf99f2 100644 --- a/test/freeflow/shallowwater/bowl/CMakeLists.txt +++ b/test/freeflow/shallowwater/bowl/CMakeLists.txt @@ -1,24 +1,3 @@ -dune_symlink_to_source_files(FILES "params.input") - -dumux_add_test(NAME test_shallowwater_bowl - SOURCES main.cc - LABELS shallowwater - TIMEOUT 3600 - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_shallowwater_bowl-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/bowl-00013.vtu - --zeroThreshold {"velocityY":1e-14} - --command "${CMAKE_CURRENT_BINARY_DIR}/test_shallowwater_bowl") - -dumux_add_test(NAME test_shallowwater_bowl_parallel - TARGET test_shallowwater_bowl - LABELS shallowwater - TIMEOUT 3600 - CMAKE_GUARD MPI_FOUND - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_shallowwater_bowl-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/s0002-bowl-parallel-00013.pvtu - --zeroThreshold {"velocityY":1e-14,"process rank":100} - --command "${MPIEXEC} -np 2 ${CMAKE_CURRENT_BINARY_DIR}/test_shallowwater_bowl -Problem.Name bowl-parallel") +file(GLOB DUMUX_TEST_FREEFLOW_SHALLOWWATER_BOWL_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_FREEFLOW_SHALLOWWATER_BOWL_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/freeflow/shallowwater/bowl) diff --git a/test/freeflow/shallowwater/dambreak/CMakeLists.txt b/test/freeflow/shallowwater/dambreak/CMakeLists.txt index ee23f9b411a18dbe32a63ef70e4e5a2d0e49a6df..4cb81a3d8b6ceed733f361ae25c780c808e76360 100644 --- a/test/freeflow/shallowwater/dambreak/CMakeLists.txt +++ b/test/freeflow/shallowwater/dambreak/CMakeLists.txt @@ -1,28 +1,3 @@ -dune_symlink_to_source_files(FILES "params.input") - -add_executable(test_shallowwater_dambreak EXCLUDE_FROM_ALL main.cc) - -dumux_add_test(NAME test_shallowwater_dambreak_sequential - TARGET test_shallowwater_dambreak - LABELS shallowwater - TIMEOUT 1500 - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_shallowwater_dambreak-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/dambreak-00001.vtu - --zeroThreshold {"velocityY":1e-14} - --command "${CMAKE_CURRENT_BINARY_DIR}/test_shallowwater_dambreak params.input - -Problem.Name dambreak") - -dumux_add_test(NAME test_shallowwater_dambreak_parallel - TARGET test_shallowwater_dambreak - LABELS shallowwater parallel - TIMEOUT 1500 - CMAKE_GUARD MPI_FOUND - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_shallowwater_dambreak-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/s0002-dambreak_parallel-00001.pvtu - --zeroThreshold {"velocityY":1e-14,"process rank":100} - --command "${MPIEXEC} -np 2 ${CMAKE_CURRENT_BINARY_DIR}/test_shallowwater_dambreak params.input - -Problem.Name dambreak_parallel") +file(GLOB DUMUX_TEST_FREEFLOW_SHALLOWWATER_DAMBREAK_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_FREEFLOW_SHALLOWWATER_DAMBREAK_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/freeflow/shallowwater/dambreak) diff --git a/test/freeflow/shallowwater/poiseuilleflow/CMakeLists.txt b/test/freeflow/shallowwater/poiseuilleflow/CMakeLists.txt index c8ed563ddab4827c65ceffdaad0c424de17d8ff0..8fa4b6378337fa11f68f526f0e524810a8646e15 100644 --- a/test/freeflow/shallowwater/poiseuilleflow/CMakeLists.txt +++ b/test/freeflow/shallowwater/poiseuilleflow/CMakeLists.txt @@ -1,48 +1,5 @@ -dune_symlink_to_source_files(FILES "params.input") +add_subdirectory(grids) -dumux_add_test(NAME test_shallowwater_poiseuilleflow - SOURCES main.cc - LABELS shallowwater - COMPILE_DEFINITIONS GRIDTYPE=Dune::YaspGrid<2,Dune::EquidistantOffsetCoordinates> - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_shallowwater_poiseuilleflow-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/poiseuilleflow-00007.vtu - --zeroThreshold {"velocityY":1e-14} - --command "${CMAKE_CURRENT_BINARY_DIR}/test_shallowwater_poiseuilleflow params.input") - -dumux_add_test(NAME test_shallowwater_poiseuilleflow_parallel - TARGET test_shallowwater_poiseuilleflow - LABELS shallowwater - CMAKE_GUARD MPI_FOUND - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_shallowwater_poiseuilleflow-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/s0002-poiseuilleflow-parallel-00007.pvtu - --zeroThreshold {"velocityY":1e-14,"process rank":100} - --command "${MPIEXEC} -np 2 ${CMAKE_CURRENT_BINARY_DIR}/test_shallowwater_poiseuilleflow params.input -Problem.Name poiseuilleflow-parallel") - -dumux_add_test(NAME test_shallowwater_poiseuilleflow_unstructured - SOURCES main.cc - LABELS shallowwater - CMAKE_GUARD dune-uggrid_FOUND - COMPILE_DEFINITIONS GRIDTYPE=Dune::UGGrid<2> - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_shallowwater_poiseuilleflow_unstructured-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/poiseuilleflow-unstructured-00007.vtu - --zeroThreshold {"velocityY":1e-14} - --command "${CMAKE_CURRENT_BINARY_DIR}/test_shallowwater_poiseuilleflow_unstructured params.input -Problem.Name poiseuilleflow-unstructured -Grid.File grids/irregular_grid_10m.dgf") - -dumux_add_test(NAME test_shallowwater_poiseuilleflow_unstructured_parallel - TARGET test_shallowwater_poiseuilleflow_unstructured - LABELS shallowwater - CMAKE_GUARD "( MPI_FOUND AND dune-uggrid_FOUND )" - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_shallowwater_poiseuilleflow_unstructured-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/s0002-poiseuilleflow-unstructured-parallel-00007.pvtu - --zeroThreshold {"velocityY":1e-14,"process rank":100} - --command "${MPIEXEC} -np 2 ${CMAKE_CURRENT_BINARY_DIR}/test_shallowwater_poiseuilleflow_unstructured params.input -Problem.Name poiseuilleflow-unstructured-parallel -Grid.File grids/irregular_grid_10m.dgf") - -dune_symlink_to_source_files(FILES "grids") +file(GLOB DUMUX_TEST_FREEFLOW_SHALLOWWATER_POISEUILLEFLOW_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_FREEFLOW_SHALLOWWATER_POISEUILLEFLOW_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/freeflow/shallowwater/poiseuilleflow) diff --git a/test/freeflow/shallowwater/poiseuilleflow/grids/CMakeLists.txt b/test/freeflow/shallowwater/poiseuilleflow/grids/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/test/freeflow/shallowwater/roughchannel/CMakeLists.txt b/test/freeflow/shallowwater/roughchannel/CMakeLists.txt index b6d509befe6fa8f900c5d9cefd01f6bd44a47358..3789d46517d9143941060d3cf837bbe154a269e1 100644 --- a/test/freeflow/shallowwater/roughchannel/CMakeLists.txt +++ b/test/freeflow/shallowwater/roughchannel/CMakeLists.txt @@ -1,12 +1,3 @@ -dune_symlink_to_source_files(FILES "params.input") - -dumux_add_test(NAME test_shallowwater_roughchannel - SOURCES main.cc - LABELS shallowwater - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_ff_shallowwater_roughchannel-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/roughchannel-00001.vtu - --zeroThreshold {"velocityY":1e-14} - --command "${CMAKE_CURRENT_BINARY_DIR}/test_shallowwater_roughchannel params.input - -Problem.Name roughchannel") +file(GLOB DUMUX_TEST_FREEFLOW_SHALLOWWATER_ROUGHCHANNEL_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_FREEFLOW_SHALLOWWATER_ROUGHCHANNEL_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/freeflow/shallowwater/roughchannel) diff --git a/test/geomechanics/elastic/CMakeLists.txt b/test/geomechanics/elastic/CMakeLists.txt index 7c365740bf658817f756598f7840f926e42bce3f..dd9037f2d7d9c07bf1a8b350dd2e1f0090271b40 100644 --- a/test/geomechanics/elastic/CMakeLists.txt +++ b/test/geomechanics/elastic/CMakeLists.txt @@ -1,11 +1,3 @@ -dune_symlink_to_source_files(FILES "params.input") - -# using box -dumux_add_test(NAME test_elastic_box - LABELS geomechanics elastic - SOURCES main.cc - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_elastic_box-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_elastic_box-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_elastic_box params.input -Problem.Name test_elastic_box") +file(GLOB DUMUX_TEST_GEOMECHANICS_ELASTIC_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_GEOMECHANICS_ELASTIC_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/geomechanics/elastic) diff --git a/test/geomechanics/poroelastic/CMakeLists.txt b/test/geomechanics/poroelastic/CMakeLists.txt index d9d0a355442c15f39984de6f55ed4005f4888f1a..7b3b2e58629b74ac37914c5f16a8f102cf753740 100644 --- a/test/geomechanics/poroelastic/CMakeLists.txt +++ b/test/geomechanics/poroelastic/CMakeLists.txt @@ -1,11 +1,3 @@ -dune_symlink_to_source_files(FILES "params.input") - -# using box and numeric differentiation -dumux_add_test(NAME test_poroelastic_box - LABELS geomechanics poroelastic - SOURCES main.cc - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_poroelastic_box-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_poroelastic_box-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_poroelastic_box params.input -Problem.Name test_poroelastic_box") +file(GLOB DUMUX_TEST_GEOMECHANICS_POROELASTIC_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_GEOMECHANICS_POROELASTIC_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/geomechanics/poroelastic) diff --git a/test/geometry/CMakeLists.txt b/test/geometry/CMakeLists.txt index 5e5c273e27c52f628e79f3052dc7226dc1f5305e..5576a3025eb8e819fe6bedde7d3a77b024328f6b 100644 --- a/test/geometry/CMakeLists.txt +++ b/test/geometry/CMakeLists.txt @@ -1,22 +1,5 @@ add_subdirectory(boundingboxtree) -dumux_add_test(SOURCES test_0d1d_intersection.cc LABELS unit) -dumux_add_test(SOURCES test_0d2d_intersection.cc LABELS unit) -dumux_add_test(SOURCES test_0d3d_intersection.cc LABELS unit) -dumux_add_test(SOURCES test_1d1d_intersection.cc LABELS unit) -dumux_add_test(SOURCES test_1d3d_intersection.cc LABELS unit) -dumux_add_test(SOURCES test_1d2d_intersection.cc LABELS unit) -dumux_add_test(SOURCES test_2d2d_intersection.cc LABELS unit) -dumux_add_test(SOURCES test_2d3d_intersection.cc LABELS unit) -dumux_add_test(SOURCES test_distance.cc LABELS unit) -dumux_add_test(SOURCES test_normal.cc LABELS unit) -dumux_add_test(SOURCES test_graham_convex_hull.cc LABELS unit) -dumux_add_test(SOURCES test_intersectingentity_cartesiangrid.cc LABELS unit) -dumux_add_test(SOURCES test_circlepoints.cc LABELS unit) -dumux_add_test(SOURCES test_cylinderintegration.cc LABELS unit) -dumux_add_test(SOURCES test_makegeometry.cc LABELS unit) -dumux_add_test(SOURCES test_refinementquadraturerule.cc LABELS unit) -dune_symlink_to_source_files(FILES ball.msh) -dumux_add_test(SOURCES test_intersectionentityset.cc - CMAKE_GUARD dune-alugrid_FOUND - LABELS unit) +file(GLOB DUMUX_TEST_GEOMETRY_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_GEOMETRY_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/geometry) diff --git a/test/geometry/boundingboxtree/CMakeLists.txt b/test/geometry/boundingboxtree/CMakeLists.txt index 45660e2e21de6ff76356004255975d1aee264e66..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644 --- a/test/geometry/boundingboxtree/CMakeLists.txt +++ b/test/geometry/boundingboxtree/CMakeLists.txt @@ -1,23 +0,0 @@ -# build the tests for the bounding box tree -dumux_add_test(NAME test_bboxtree_dim1 - SOURCES test_bboxtree.cc - COMPILE_DEFINITIONS WORLD_DIMENSION=1 - LABELS unit) - -dumux_add_test(NAME test_bboxtree_dim2 - SOURCES test_bboxtree.cc - COMPILE_DEFINITIONS WORLD_DIMENSION=2 - LABELS unit) - -dumux_add_test(NAME test_bboxtree_dim3 - SOURCES test_bboxtree.cc - COMPILE_DEFINITIONS WORLD_DIMENSION=3 - LABELS unit) - -dumux_add_test(NAME test_geometry_fracture - SOURCES test_geometry_fracture.cc - CMAKE_GUARD dune-foamgrid_FOUND - LABELS unit) - -# symlink the input file in the build directory -dune_symlink_to_source_files(FILES "network1d.msh" "network2d.msh" "fracture.msh") diff --git a/test/io/container/CMakeLists.txt b/test/io/container/CMakeLists.txt index f79ecc28efd1544be71cb2f8770f337d4a103282..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644 --- a/test/io/container/CMakeLists.txt +++ b/test/io/container/CMakeLists.txt @@ -1,2 +0,0 @@ -dumux_add_test(SOURCES test_container_io.cc - LABELS unit io) diff --git a/test/io/format/CMakeLists.txt b/test/io/format/CMakeLists.txt index 5cf89a067d5b74a8a0a02ffa23ab1cfa2b10eb25..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644 --- a/test/io/format/CMakeLists.txt +++ b/test/io/format/CMakeLists.txt @@ -1,2 +0,0 @@ -dumux_add_test(SOURCES test_format.cc - LABELS io unit) diff --git a/test/io/gnuplotinterface/CMakeLists.txt b/test/io/gnuplotinterface/CMakeLists.txt index 09465e0bfc5dacb6ead89ff25b3fd95847f15880..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644 --- a/test/io/gnuplotinterface/CMakeLists.txt +++ b/test/io/gnuplotinterface/CMakeLists.txt @@ -1,3 +0,0 @@ -file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/output") -dumux_add_test(SOURCES test_gnuplotinterface.cc - LABELS unit io) diff --git a/test/io/gridmanager/CMakeLists.txt b/test/io/gridmanager/CMakeLists.txt index 7162339a6fd33e63c45529e0d5d07cc39a371dd7..14fc80a301fa5b32d39d94561b7eee7edcb3875b 100644 --- a/test/io/gridmanager/CMakeLists.txt +++ b/test/io/gridmanager/CMakeLists.txt @@ -1,389 +1,5 @@ -add_input_file_links() -dune_symlink_to_source_files(FILES grids) +add_subdirectory(grids) -add_executable(test_gridmanager_cake_ug EXCLUDE_FROM_ALL test_gridmanager_cake.cc) -target_compile_definitions(test_gridmanager_cake_ug PUBLIC "USEUG=1") - -add_executable(test_gridmanager_cake_alu EXCLUDE_FROM_ALL test_gridmanager_cake.cc) - -dumux_add_test(NAME test_gridmanager_cake_360_ug - TARGET test_gridmanager_cake_ug - LABELS unit io - CMAKE_GUARD dune-uggrid_FOUND - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --command "${CMAKE_CURRENT_BINARY_DIR}/test_gridmanager_cake_ug -Grid.Name ug-360" - --files ${CMAKE_SOURCE_DIR}/test/references/test_gridmanager_cake_3d_360-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/cake-3d-ug-360.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_gridmanager_cake_2d_360-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/cake-2d-ug-360.vtu - --relative 1e-6) - -dumux_add_test(NAME test_gridmanager_cake_360_alu - TARGET test_gridmanager_cake_alu - LABELS unit io - CMAKE_GUARD dune-alugrid_FOUND - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --command "${CMAKE_CURRENT_BINARY_DIR}/test_gridmanager_cake_alu -Grid.Name alu-360" - --files ${CMAKE_SOURCE_DIR}/test/references/test_gridmanager_cake_3d_360-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/cake-3d-alu-360.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_gridmanager_cake_2d_360-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/cake-2d-alu-360.vtu - --relative 1e-6) - -dumux_add_test(NAME test_gridmanager_cake_210_ug - TARGET test_gridmanager_cake_ug - LABELS unit io - CMAKE_GUARD dune-uggrid_FOUND - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --command "${CMAKE_CURRENT_BINARY_DIR}/test_gridmanager_cake_ug -Grid.Name ug-210 -Grid.Angular1 '0.0 210.0'" - --files ${CMAKE_SOURCE_DIR}/test/references/test_gridmanager_cake_3d_210-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/cake-3d-ug-210.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_gridmanager_cake_2d_210-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/cake-2d-ug-210.vtu - --relative 1e-6) - -dumux_add_test(NAME test_gridmanager_cake_210_alu - TARGET test_gridmanager_cake_alu - LABELS unit io - CMAKE_GUARD dune-alugrid_FOUND - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --command "${CMAKE_CURRENT_BINARY_DIR}/test_gridmanager_cake_alu -Grid.Name alu-210 -Grid.Angular1 '0.0 210.0'" - --files ${CMAKE_SOURCE_DIR}/test/references/test_gridmanager_cake_3d_210-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/cake-3d-alu-210.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_gridmanager_cake_2d_210-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/cake-2d-alu-210.vtu - --relative 1e-6) - -dumux_add_test(NAME test_gridmanager_cake_360_nowell - TARGET test_gridmanager_cake_ug - LABELS unit io - CMAKE_GUARD dune-uggrid_FOUND - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --command "${CMAKE_CURRENT_BINARY_DIR}/test_gridmanager_cake_ug -Grid.Name nowell-360 -Grid.Radial0 '0.0 0.3 1.0'" - --files ${CMAKE_SOURCE_DIR}/test/references/test_gridmanager_cake_3d_360_nowell-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/cake-3d-nowell-360.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_gridmanager_cake_2d_360_nowell-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/cake-2d-nowell-360.vtu - --relative 1e-6) - -dumux_add_test(NAME test_gridmanager_subgrid - SOURCES test_gridmanager_subgrid.cc - LABELS unit io - CMAKE_GUARD dune-subgrid_FOUND - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --command "${CMAKE_CURRENT_BINARY_DIR}/test_gridmanager_subgrid" - --files ${CMAKE_SOURCE_DIR}/test/references/subgrid-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/subgrid_circle_yasp.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_gridmanager_subgrid_binary_image.vtu - ${CMAKE_CURRENT_BINARY_DIR}/subgrid_binary_image.vtu) - -dune_symlink_to_source_files(FILES "test_gridmanager_gmsh_3d.input" - "test_gridmanager_gmsh_e_markers.input" - "test_gridmanager_dgf.input") - -add_executable(test_gridmanager_gmsh_3d_alu EXCLUDE_FROM_ALL test_gridmanager_gmsh_3d.cc) -target_compile_definitions(test_gridmanager_gmsh_3d_alu PUBLIC GRIDTYPE=Dune::ALUGrid<3,3,Dune::simplex,Dune::nonconforming>) - -dumux_add_test(NAME test_gridmanager_gmsh_3d_alu_sequential - TARGET test_gridmanager_gmsh_3d_alu - LABELS unit io - CMAKE_GUARD dune-alugrid_FOUND - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --command "${CMAKE_CURRENT_BINARY_DIR}/test_gridmanager_gmsh_3d_alu -Problem.Name bifurcation_alu -Grid.Refine false" - --files ${CMAKE_SOURCE_DIR}/test/references/gridmanager-bifurcation-3d-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/bifurcation_alu-00000.vtu) - -dumux_add_test(NAME test_gridmanager_gmsh_3d_alu_parallel - TARGET test_gridmanager_gmsh_3d_alu - LABELS unit io parallel - TIMEOUT 300 - CMAKE_GUARD dune-alugrid_FOUND - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy --zeroThreshold {"rank":100} - --command "${MPIEXEC} -np 2 ${CMAKE_CURRENT_BINARY_DIR}/test_gridmanager_gmsh_3d_alu -Problem.Name bifurcation_alu_parallel -Grid.Refine false" - --files ${CMAKE_SOURCE_DIR}/test/references/gridmanager-bifurcation-3d-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/s0002-bifurcation_alu_parallel-00000.pvtu) - -add_executable(test_gridmanager_gmsh_3d_ug EXCLUDE_FROM_ALL test_gridmanager_gmsh_3d.cc) -target_compile_definitions(test_gridmanager_gmsh_3d_ug PUBLIC GRIDTYPE=Dune::UGGrid<3>) - -dumux_add_test(NAME test_gridmanager_gmsh_3d_ug_sequential - TARGET test_gridmanager_gmsh_3d_ug - LABELS unit io - CMAKE_GUARD dune-uggrid_FOUND - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --command "${CMAKE_CURRENT_BINARY_DIR}/test_gridmanager_gmsh_3d_ug -Problem.Name bifurcation_ug" - --files ${CMAKE_SOURCE_DIR}/test/references/gridmanager-bifurcation-3d-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/bifurcation_ug-00000.vtu - ${CMAKE_SOURCE_DIR}/test/references/gridmanager-bifurcation-3d-reference-refined.vtu - ${CMAKE_CURRENT_BINARY_DIR}/bifurcation_ug-00001.vtu) - -dumux_add_test(NAME test_gridmanager_gmsh_3d_ug_parallel - TARGET test_gridmanager_gmsh_3d_ug - LABELS unit io parallel - TIMEOUT 300 - CMAKE_GUARD dune-uggrid_FOUND - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy --zeroThreshold {"rank":100} - --command "${MPIEXEC} -np 2 ${CMAKE_CURRENT_BINARY_DIR}/test_gridmanager_gmsh_3d_ug -Problem.Name bifurcation_ug_parallel -Grid.Refine false" - --files ${CMAKE_SOURCE_DIR}/test/references/gridmanager-bifurcation-3d-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/s0002-bifurcation_ug_parallel-00000.pvtu) - -add_executable(test_gridmanager_gmsh_e_markers_alu EXCLUDE_FROM_ALL test_gridmanager_gmsh_e_markers.cc) -target_compile_definitions(test_gridmanager_gmsh_e_markers_alu PUBLIC GRIDTYPE=Dune::ALUGrid<2,2,Dune::simplex,Dune::nonconforming>) - -dumux_add_test(NAME test_gridmanager_gmsh_e_markers_alu_sequential - TARGET test_gridmanager_gmsh_e_markers_alu - LABELS unit io - CMAKE_GUARD dune-alugrid_FOUND - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --command "${CMAKE_CURRENT_BINARY_DIR}/test_gridmanager_gmsh_e_markers_alu -Problem.Name fracture_alu" - --files ${CMAKE_SOURCE_DIR}/test/references/gridmanager-fracture-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/fracture_alu-00000.vtu - ${CMAKE_SOURCE_DIR}/test/references/gridmanager-fracture-reference-refined.vtu - ${CMAKE_CURRENT_BINARY_DIR}/fracture_alu-00001.vtu) - -dumux_add_test(NAME test_gridmanager_gmsh_e_markers_alu_parallel - TARGET test_gridmanager_gmsh_e_markers_alu - LABELS unit io parallel - TIMEOUT 300 - CMAKE_GUARD "( dune-alugrid_FOUND AND MPI_FOUND )" - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy --zeroThreshold {"rank":100} - --command "${MPIEXEC} -np 2 ${CMAKE_CURRENT_BINARY_DIR}/test_gridmanager_gmsh_e_markers_alu -Problem.Name fracture_alu_parallel" - --files ${CMAKE_SOURCE_DIR}/test/references/gridmanager-fracture-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/s0002-fracture_alu_parallel-00000.pvtu - ${CMAKE_SOURCE_DIR}/test/references/gridmanager-fracture-reference-refined.vtu - ${CMAKE_CURRENT_BINARY_DIR}/s0002-fracture_alu_parallel-00001.pvtu) - -add_executable(test_gridmanager_gmsh_e_markers_ug EXCLUDE_FROM_ALL test_gridmanager_gmsh_e_markers.cc) -target_compile_definitions(test_gridmanager_gmsh_e_markers_ug PUBLIC GRIDTYPE=Dune::UGGrid<2>) - -dumux_add_test(NAME test_gridmanager_gmsh_e_markers_ug_sequential - TARGET test_gridmanager_gmsh_e_markers_ug - LABELS unit io - CMAKE_GUARD dune-uggrid_FOUND - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --command "${CMAKE_CURRENT_BINARY_DIR}/test_gridmanager_gmsh_e_markers_ug -Problem.Name fracture_ug" - --files ${CMAKE_SOURCE_DIR}/test/references/gridmanager-fracture-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/fracture_ug-00000.vtu - ${CMAKE_SOURCE_DIR}/test/references/gridmanager-fracture-reference-refined.vtu - ${CMAKE_CURRENT_BINARY_DIR}/fracture_ug-00001.vtu) - -dumux_add_test(NAME test_gridmanager_gmsh_e_markers_ug_parallel - TARGET test_gridmanager_gmsh_e_markers_ug - LABELS unit io parallel - TIMEOUT 300 - CMAKE_GUARD "( dune-uggrid_FOUND AND MPI_FOUND )" - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy --zeroThreshold {"rank":100} - --command "${MPIEXEC} -np 2 ${CMAKE_CURRENT_BINARY_DIR}/test_gridmanager_gmsh_e_markers_ug -Problem.Name fracture_ug_parallel" - --files ${CMAKE_SOURCE_DIR}/test/references/gridmanager-fracture-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/s0002-fracture_ug_parallel-00000.pvtu - ${CMAKE_SOURCE_DIR}/test/references/gridmanager-fracture-reference-refined.vtu - ${CMAKE_CURRENT_BINARY_DIR}/s0002-fracture_ug_parallel-00001.pvtu) - -add_executable(test_gridmanager_dgf_alu EXCLUDE_FROM_ALL test_gridmanager_dgf.cc) -target_compile_definitions(test_gridmanager_dgf_alu PUBLIC GRIDTYPE=Dune::ALUGrid<2,2,Dune::simplex,Dune::conforming>) - -dumux_add_test(NAME test_gridmanager_dgf_alu_sequential - TARGET test_gridmanager_dgf_alu - LABELS unit io - CMAKE_GUARD dune-alugrid_FOUND - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --command "${CMAKE_CURRENT_BINARY_DIR}/test_gridmanager_dgf_alu -Problem.Name co2_alu" - --files ${CMAKE_SOURCE_DIR}/test/references/gridmanager-co2-simpl-element-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/co2_alu-element-00000.vtu - ${CMAKE_SOURCE_DIR}/test/references/gridmanager-co2-simpl-element-reference-refined.vtu - ${CMAKE_CURRENT_BINARY_DIR}/co2_alu-element-00001.vtu - ${CMAKE_SOURCE_DIR}/test/references/gridmanager-co2-simpl-vertex-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/co2_alu-vertex-00000.vtu) - -dumux_add_test(NAME test_gridmanager_dgf_alu_parallel - TARGET test_gridmanager_dgf_alu - LABELS unit io parallel - TIMEOUT 300 - CMAKE_GUARD "( dune-alugrid_FOUND AND MPI_FOUND )" - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy --zeroThreshold {"rank":100} - --command "${MPIEXEC} -np 2 ${CMAKE_CURRENT_BINARY_DIR}/test_gridmanager_dgf_alu -Problem.Name co2_alu_parallel" - --files ${CMAKE_SOURCE_DIR}/test/references/gridmanager-co2-simpl-element-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/s0002-co2_alu_parallel-element-00000.pvtu - ${CMAKE_SOURCE_DIR}/test/references/gridmanager-co2-simpl-element-reference-refined.vtu - ${CMAKE_CURRENT_BINARY_DIR}/s0002-co2_alu_parallel-element-00001.pvtu - ${CMAKE_SOURCE_DIR}/test/references/gridmanager-co2-simpl-vertex-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/s0002-co2_alu_parallel-vertex-00000.pvtu) - -add_executable(test_gridmanager_dgf_ug EXCLUDE_FROM_ALL test_gridmanager_dgf.cc) -target_compile_definitions(test_gridmanager_dgf_ug PUBLIC GRIDTYPE=Dune::UGGrid<2>) - -dumux_add_test(NAME test_gridmanager_dgf_ug_sequential - TARGET test_gridmanager_dgf_ug - LABELS unit io - CMAKE_GUARD dune-uggrid_FOUND - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --command "${CMAKE_CURRENT_BINARY_DIR}/test_gridmanager_dgf_ug -Problem.Name co2_ug" - --files ${CMAKE_SOURCE_DIR}/test/references/gridmanager-co2-quad-element-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/co2_ug-element-00000.vtu - ${CMAKE_SOURCE_DIR}/test/references/gridmanager-co2-quad-element-reference-refined.vtu - ${CMAKE_CURRENT_BINARY_DIR}/co2_ug-element-00001.vtu - ${CMAKE_SOURCE_DIR}/test/references/gridmanager-co2-quad-vertex-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/co2_ug-vertex-00000.vtu) - -dumux_add_test(NAME test_gridmanager_dgf_ug_parallel - TARGET test_gridmanager_dgf_ug - LABELS unit io parallel - TIMEOUT 300 - CMAKE_GUARD "( dune-uggrid_FOUND AND MPI_FOUND )" - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy --zeroThreshold {"rank":100} - --command "${MPIEXEC} -np 2 ${CMAKE_CURRENT_BINARY_DIR}/test_gridmanager_dgf_ug -Problem.Name co2_ug_parallel" - --files ${CMAKE_SOURCE_DIR}/test/references/gridmanager-co2-quad-element-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/s0002-co2_ug_parallel-element-00000.pvtu - ${CMAKE_SOURCE_DIR}/test/references/gridmanager-co2-quad-element-reference-refined.vtu - ${CMAKE_CURRENT_BINARY_DIR}/s0002-co2_ug_parallel-element-00001.pvtu - ${CMAKE_SOURCE_DIR}/test/references/gridmanager-co2-quad-vertex-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/s0002-co2_ug_parallel-vertex-00000.pvtu) - -dumux_add_test(NAME test_gridmanager_vtk_foam - SOURCES test_gridmanager_vtk.cc - LABELS unit io - COMPILE_DEFINITIONS FOAMGRID - CMAKE_GUARD dune-foamgrid_FOUND - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --command ${CMAKE_CURRENT_BINARY_DIR}/test_gridmanager_vtk_foam - --files ${CMAKE_CURRENT_BINARY_DIR}/grids/lupine.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test-gridmanager-vtk-foamgrid-0.vtp) - -dumux_add_test(NAME test_gridmanager_vtk_ug - SOURCES test_gridmanager_vtk.cc - LABELS unit io - COMPILE_DEFINITIONS UGGRID - CMAKE_GUARD dune-uggrid_FOUND - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --command ${CMAKE_CURRENT_BINARY_DIR}/test_gridmanager_vtk_ug - --files ${CMAKE_CURRENT_BINARY_DIR}/grids/lens.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test-gridmanager-vtk-uggrid-0.vtu) - - -dumux_add_test(NAME test_gmshboundaryflag - SOURCES test_gmshboundaryflag.cc - COMPILE_DEFINITIONS ENABLE_CACHING=false - LABELS unit io - CMAKE_GUARD "( dune-alugrid_FOUND )" - ) - -dumux_add_test(NAME test_gmshboundaryflag_caching - SOURCES test_gmshboundaryflag.cc - COMPILE_DEFINITIONS ENABLE_CACHING=true - LABELS unit io - CMAKE_GUARD "( dune-alugrid_FOUND )" - ) - -dumux_add_test(NAME test_gridmanager_mmesh - SOURCES test_gridmanager_mmesh.cc - LABELS unit io - CMAKE_GUARD "( dune-mmesh_FOUND )" - ) - -add_executable(test_pnm_gridmanager EXCLUDE_FROM_ALL test_pnm_gridmanager.cc) - -dumux_add_test(NAME test_pnm_gridmanager_constant_params - LABELS unit io porenetwork - TARGET test_pnm_gridmanager - CMAKE_GUARD dune-foamgrid_FOUND - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/pnm_gridmanager-3d-constant.vtp - ${CMAKE_CURRENT_BINARY_DIR}/generic-3dgrid-constant-params.vtp - ${CMAKE_SOURCE_DIR}/test/references/pnm_gridmanager-3d-constant.vtp - ${CMAKE_CURRENT_BINARY_DIR}/dgf-3dgrid-constant-params.vtp - ${CMAKE_SOURCE_DIR}/test/references/pnm_gridmanager-2d-constant.vtp - ${CMAKE_CURRENT_BINARY_DIR}/generic-2dgrid-constant-params.vtp - ${CMAKE_SOURCE_DIR}/test/references/pnm_gridmanager-2d-constant.vtp - ${CMAKE_CURRENT_BINARY_DIR}/dgf-2dgrid-constant-params.vtp - ${CMAKE_SOURCE_DIR}/test/references/pnm_gridmanager-1d-constant.vtp - ${CMAKE_CURRENT_BINARY_DIR}/generic-1dgrid-constant-params.vtp - ${CMAKE_SOURCE_DIR}/test/references/pnm_gridmanager-1d-constant.vtp - ${CMAKE_CURRENT_BINARY_DIR}/dgf-1dgrid-constant-params.vtp - --command "${CMAKE_CURRENT_BINARY_DIR}/test_pnm_gridmanager test_pnm_gridmanager-constant-params.input") - -dumux_add_test(NAME test_pnm_gridmanager_random_params - LABELS unit io porenetwork - TARGET test_pnm_gridmanager - CMAKE_GUARD dune-foamgrid_FOUND - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/pnm_gridmanager-3d-random.vtp - ${CMAKE_CURRENT_BINARY_DIR}/generic-3dgrid-random-params.vtp - ${CMAKE_SOURCE_DIR}/test/references/pnm_gridmanager-3d-random.vtp - ${CMAKE_CURRENT_BINARY_DIR}/dgf-3dgrid-random-params.vtp - ${CMAKE_SOURCE_DIR}/test/references/pnm_gridmanager-2d-random.vtp - ${CMAKE_CURRENT_BINARY_DIR}/generic-2dgrid-random-params.vtp - ${CMAKE_SOURCE_DIR}/test/references/pnm_gridmanager-2d-random.vtp - ${CMAKE_CURRENT_BINARY_DIR}/dgf-2dgrid-random-params.vtp - ${CMAKE_SOURCE_DIR}/test/references/pnm_gridmanager-1d-random.vtp - ${CMAKE_CURRENT_BINARY_DIR}/generic-1dgrid-random-params.vtp - ${CMAKE_SOURCE_DIR}/test/references/pnm_gridmanager-1d-random.vtp - ${CMAKE_CURRENT_BINARY_DIR}/dgf-1dgrid-random-params.vtp - --command "${CMAKE_CURRENT_BINARY_DIR}/test_pnm_gridmanager test_pnm_gridmanager-random-params.input") - -dumux_add_test(NAME test_pnm_gridmanager_remove_throats_on_boundary_none - LABELS unit io porenetwork - TARGET test_pnm_gridmanager - CMAKE_GUARD dune-foamgrid_FOUND - COMMAND ${CMAKE_CURRENT_BINARY_DIR}/test_pnm_gridmanager - CMD_ARGS test_remove-troats-on-boundary.input) - -dumux_add_test(NAME test_pnm_gridmanager_remove_throats_on_boundary_0 - LABELS unit io porenetwork - TARGET test_pnm_gridmanager - CMAKE_GUARD dune-foamgrid_FOUND - COMMAND ${CMAKE_CURRENT_BINARY_DIR}/test_pnm_gridmanager - CMD_ARGS test_remove-troats-on-boundary.input -Grid.RemoveThroatsOnBoundary 0) - -dumux_add_test(NAME test_pnm_gridmanager_remove_throats_on_boundary_1 - LABELS unit io porenetwork - TARGET test_pnm_gridmanager - CMAKE_GUARD dune-foamgrid_FOUND - COMMAND ${CMAKE_CURRENT_BINARY_DIR}/test_pnm_gridmanager - CMD_ARGS test_remove-troats-on-boundary.input -Grid.RemoveThroatsOnBoundary 1) - -dumux_add_test(NAME test_pnm_gridmanager_remove_throats_on_boundary_2 - LABELS unit io porenetwork - TARGET test_pnm_gridmanager - CMAKE_GUARD dune-foamgrid_FOUND - COMMAND ${CMAKE_CURRENT_BINARY_DIR}/test_pnm_gridmanager - CMD_ARGS test_remove-troats-on-boundary.input -Grid.RemoveThroatsOnBoundary 2) - -dumux_add_test(NAME test_pnm_gridmanager_remove_throats_on_boundary_3 - LABELS unit io porenetwork - TARGET test_pnm_gridmanager - CMAKE_GUARD dune-foamgrid_FOUND - COMMAND ${CMAKE_CURRENT_BINARY_DIR}/test_pnm_gridmanager - CMD_ARGS test_remove-troats-on-boundary.input -Grid.RemoveThroatsOnBoundary 3) - -dumux_add_test(NAME test_pnm_gridmanager_remove_throats_on_boundary_all - LABELS unit io porenetwork - TARGET test_pnm_gridmanager - CMAKE_GUARD dune-foamgrid_FOUND - COMMAND ${CMAKE_CURRENT_BINARY_DIR}/test_pnm_gridmanager - CMD_ARGS test_remove-troats-on-boundary.input -Grid.RemoveThroatsOnBoundary "0 1 2 3") - -dumux_add_test(SOURCES test_pnm_subgriddata.cc - LABELS unit io porenetwork - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-subgrid_FOUND )") +file(GLOB DUMUX_TEST_IO_GRIDMANAGER_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_IO_GRIDMANAGER_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/io/gridmanager) diff --git a/test/io/gridmanager/grids/CMakeLists.txt b/test/io/gridmanager/grids/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/test/io/inputdata/CMakeLists.txt b/test/io/inputdata/CMakeLists.txt index ecf567d10832f99a1ae87a8ce813cdb2f0c6d037..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644 --- a/test/io/inputdata/CMakeLists.txt +++ b/test/io/inputdata/CMakeLists.txt @@ -1,2 +0,0 @@ -dune_symlink_to_source_files(FILES config.ini coordinates.txt mydata.xml numbers.txt) -dumux_add_test(SOURCES test_io_data_input.cc LABELS unit io) diff --git a/test/io/rasterimagereader/CMakeLists.txt b/test/io/rasterimagereader/CMakeLists.txt index 3488e608f14d42942adc6dbc8921d052c344d68c..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644 --- a/test/io/rasterimagereader/CMakeLists.txt +++ b/test/io/rasterimagereader/CMakeLists.txt @@ -1,8 +0,0 @@ -dune_symlink_to_source_files(FILES blackwhite_j.pbm blackwhite_binary_j.pbm blackwhite_j.txt - grayscale_j.pgm grayscale_binary_j.pgm grayscale_j.txt - blackwhite_dim_firstline.pbm blackwhite_dim_firstline_binary.pbm - blackwhite_fail.pbm grayscale_fail_binary.pgm) - -dumux_add_test(NAME test_io_rasterimagereader - SOURCES test_rasterimagereader.cc - LABELS unit io) diff --git a/test/io/vtk/CMakeLists.txt b/test/io/vtk/CMakeLists.txt index 2977a9c75e3dcea835943a01da29c9fedd641cf3..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644 --- a/test/io/vtk/CMakeLists.txt +++ b/test/io/vtk/CMakeLists.txt @@ -1,101 +0,0 @@ -add_input_file_links() -dune_symlink_to_source_files(FILES polyline.vtp) - -dumux_add_test(NAME test_vtkreader_3d - SOURCES test_vtkreader.cc - LABELS unit io - CMAKE_GUARD dune-alugrid_FOUND - COMPILE_DEFINITIONS GRIDTYPE=Dune::ALUGrid<3,3,Dune::cube,Dune::nonconforming> - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --command "${CMAKE_CURRENT_BINARY_DIR}/test_vtkreader_3d - ${CMAKE_SOURCE_DIR}/test/references/test_md_embedded_1d3d_1p2c_richards2c_3d-reference.vtu test-3d" - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_embedded_1d3d_1p2c_richards2c_3d-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test-3d.vtu) - -# dumux_add_test(NAME test_vtkreader_3d_structured_notimplemented -# SOURCES test_vtkreader.cc -# COMPILE_DEFINITIONS GRIDTYPE=Dune::YaspGrid<3,Dune::EquidistantOffsetCoordinates> -# EXPECT_COMPILE_FAIL) - -dumux_add_test(NAME test_vtkreader_2d - SOURCES test_vtkreader.cc - LABELS unit io - CMAKE_GUARD dune-alugrid_FOUND - COMPILE_DEFINITIONS GRIDTYPE=Dune::ALUGrid<2,2,Dune::cube,Dune::nonconforming> - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --command "${CMAKE_CURRENT_BINARY_DIR}/test_vtkreader_2d - ${CMAKE_SOURCE_DIR}/test/references/test_1p_box-reference.vtu test-2d" - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p_box-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test-2d.vtu) - -dumux_add_test(NAME test_vtkreader_2d3d - SOURCES test_vtkreader.cc - LABELS unit io - CMAKE_GUARD dune-foamgrid_FOUND - COMPILE_DEFINITIONS GRIDTYPE=Dune::FoamGrid<2,3> - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --command "${CMAKE_CURRENT_BINARY_DIR}/test_vtkreader_2d3d - ${CMAKE_SOURCE_DIR}/test/references/test_md_embedded_2d3d_fracture1p_tpfa_2d-reference.vtu test-2d3d" - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_embedded_2d3d_fracture1p_tpfa_2d-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test-2d3d.vtu) - -dumux_add_test(NAME test_vtkreader_1d - SOURCES test_vtkreader.cc - LABELS unit io - CMAKE_GUARD dune-foamgrid_FOUND - COMPILE_DEFINITIONS GRIDTYPE=Dune::FoamGrid<1,3> - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --command "${CMAKE_CURRENT_BINARY_DIR}/test_vtkreader_1d - ${CMAKE_SOURCE_DIR}/test/references/test_md_embedded_1d3d_1p_richards_tpfatpfa_1d-reference.vtp test-1d" - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_embedded_1d3d_1p_richards_tpfatpfa_1d-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test-1d.vtp) - -dumux_add_test(NAME test_vtkreader_1d_polyline - TARGET test_vtkreader_1d - LABELS unit io - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --command "${CMAKE_CURRENT_BINARY_DIR}/test_vtkreader_1d polyline.vtp test_polyline" - --files ${CMAKE_SOURCE_DIR}/test/references/test_vtkreader_1d_polyline-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_polyline.vtp) - -dumux_add_test(NAME test_vtk_staggeredfreeflowpvnames - SOURCES test_vtk_staggeredfreeflowpvnames.cc - LABELS unit io) - -# VTKOutputModule precision tests (before dune 2.7 everything was Float32) -if(${DUNE_GRID_VERSION} VERSION_LESS 2.7) - dumux_add_test(NAME test_vtkoutputmodule - SOURCES test_vtkoutputmodule.cc - LABELS unit io - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --command "${CMAKE_CURRENT_BINARY_DIR}/test_vtkoutputmodule" - --files ${CMAKE_SOURCE_DIR}/test/references/test_vtkoutputmodule_allfloat-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_vtkoutputmodule_allfloat-00000.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_vtkoutputmodule_allfloat-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_vtkoutputmodule_float-00000.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_vtkoutputmodule_allfloat-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_vtkoutputmodule_double-00000.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_vtkoutputmodule_allfloat-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_vtkoutputmodule_doublecoord-00000.vtu) -else() - dumux_add_test(NAME test_vtkoutputmodule - SOURCES test_vtkoutputmodule.cc - LABELS unit io - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --command "${CMAKE_CURRENT_BINARY_DIR}/test_vtkoutputmodule" - --files ${CMAKE_SOURCE_DIR}/test/references/test_vtkoutputmodule_allfloat-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_vtkoutputmodule_allfloat-00000.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_vtkoutputmodule_float-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_vtkoutputmodule_float-00000.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_vtkoutputmodule_double-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_vtkoutputmodule_double-00000.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_vtkoutputmodule_doublecoord-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_vtkoutputmodule_doublecoord-00000.vtu) -endif() diff --git a/test/linear/CMakeLists.txt b/test/linear/CMakeLists.txt index e514752212af6b9f355d52c7a4ee049296d2dd61..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644 --- a/test/linear/CMakeLists.txt +++ b/test/linear/CMakeLists.txt @@ -1,4 +0,0 @@ -dune_symlink_to_source_files(FILES "params.input") -dumux_add_test(NAME test_linearsolver - SOURCES test_linearsolver.cc - LABELS linear unit) diff --git a/test/material/CMakeLists.txt b/test/material/CMakeLists.txt index ea48b8f61be3d0668d30c076f6e4eece844d30ae..89d3c58285620dccaf47dffd8a4e227b30dbdcb8 100644 --- a/test/material/CMakeLists.txt +++ b/test/material/CMakeLists.txt @@ -1,8 +1,8 @@ add_subdirectory(binarycoefficients) add_subdirectory(components) add_subdirectory(compositionalflash) -add_subdirectory(fluidsystems) add_subdirectory(fluidmatrixinteractions) +add_subdirectory(fluidsystems) add_subdirectory(immiscibleflash) add_subdirectory(ncpflash) add_subdirectory(pengrobinson) diff --git a/test/material/binarycoefficients/CMakeLists.txt b/test/material/binarycoefficients/CMakeLists.txt index eafd05b7d3711189e7f281cf266acf0d34e44680..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644 --- a/test/material/binarycoefficients/CMakeLists.txt +++ b/test/material/binarycoefficients/CMakeLists.txt @@ -1,2 +0,0 @@ -dumux_add_test(SOURCES test_binarycoefficients.cc - LABELS unit material) diff --git a/test/material/components/CMakeLists.txt b/test/material/components/CMakeLists.txt index a2fa8428da76f8ee4adaf4d7be60d00e2ac11580..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644 --- a/test/material/components/CMakeLists.txt +++ b/test/material/components/CMakeLists.txt @@ -1,161 +0,0 @@ -dumux_add_test(SOURCES test_componenttraits.cc - COMPILE_ONLY - LABELS unit material) - -add_executable(plot_component plotproperties.cc) - -dumux_add_test(NAME plot_air - TARGET plot_component - COMMAND ./plot_component - CMD_ARGS "Air" - LABELS unit material) - -dumux_add_test(NAME plot_ammonia - TARGET plot_component - COMMAND ./plot_component - CMD_ARGS "Ammonia" - LABELS unit material) - -dumux_add_test(NAME plot_benzene - TARGET plot_component - COMMAND ./plot_component - CMD_ARGS "Benzene" - LABELS unit material) - -dumux_add_test(NAME plot_brine - TARGET plot_component - COMMAND ./plot_component - CMD_ARGS "Brine" - LABELS unit material) - -dumux_add_test(NAME plot_calcite - TARGET plot_component - COMMAND ./plot_component - CMD_ARGS "Calcite" - LABELS unit material) - -dumux_add_test(NAME plot_calciumion - TARGET plot_component - COMMAND ./plot_component - CMD_ARGS "CalciumIon" - LABELS unit material) - -dumux_add_test(NAME plot_cao - TARGET plot_component - COMMAND ./plot_component - CMD_ARGS "CaO" - LABELS unit material) - -dumux_add_test(NAME plot_cao2h2 - TARGET plot_component - COMMAND ./plot_component - CMD_ARGS "CaO2H2" - LABELS unit material) - -dumux_add_test(NAME plot_carbonateion - TARGET plot_component - COMMAND ./plot_component - CMD_ARGS "CarbonateIon" - LABELS unit material) - -dumux_add_test(NAME plot_ch4 - TARGET plot_component - COMMAND ./plot_component - CMD_ARGS "CH4" - LABELS unit material) - -dumux_add_test(NAME plot_constantcomponent - TARGET plot_component - COMMAND ./plot_component - CMD_ARGS "Constant" - LABELS unit material) - -dumux_add_test(NAME plot_chlorideion - TARGET plot_component - COMMAND ./plot_component - CMD_ARGS "ChlorideIon" - LABELS unit material) - -dumux_add_test(NAME plot_glucose - TARGET plot_component - COMMAND ./plot_component - CMD_ARGS "Glucose" - LABELS unit material) - -dumux_add_test(NAME plot_granite - TARGET plot_component - COMMAND ./plot_component - CMD_ARGS "Granite" - LABELS unit material) - -dumux_add_test(NAME plot_h2 - TARGET plot_component - COMMAND ./plot_component - CMD_ARGS "H2" - LABELS unit material) - -dumux_add_test(NAME plot_h2o - TARGET plot_component - COMMAND ./plot_component - CMD_ARGS "H2O" - LABELS unit material) - -dumux_add_test(NAME plot_heavyoil - TARGET plot_component - COMMAND ./plot_component - CMD_ARGS "HeavyOil" - LABELS unit material) - -dumux_add_test(NAME plot_mesitylene - TARGET plot_component - COMMAND ./plot_component - CMD_ARGS "Mesitylene" - LABELS unit material) - -dumux_add_test(NAME plot_n2 - TARGET plot_component - COMMAND ./plot_component - CMD_ARGS "N2" - LABELS unit material) - -dumux_add_test(NAME plot_nacl - TARGET plot_component - COMMAND ./plot_component - CMD_ARGS "NaCl" - LABELS unit material) - -dumux_add_test(NAME plot_o2 - TARGET plot_component - COMMAND ./plot_component - CMD_ARGS "O2" - LABELS unit material) - -dumux_add_test(NAME plot_simpleh2o - TARGET plot_component - COMMAND ./plot_component - CMD_ARGS "SimpleH2O" - LABELS unit material) - -dumux_add_test(NAME plot_sodiumion - TARGET plot_component - COMMAND ./plot_component - CMD_ARGS "SodiumIon" - LABELS unit material) - -dumux_add_test(NAME plot_trichloroethene - TARGET plot_component - COMMAND ./plot_component - CMD_ARGS "Trichloroethene" - LABELS unit material) - -dumux_add_test(NAME plot_urea - TARGET plot_component - COMMAND ./plot_component - CMD_ARGS "Urea" - LABELS unit material) - -dumux_add_test(NAME plot_xylene - TARGET plot_component - COMMAND ./plot_component - CMD_ARGS "Xylene" - LABELS unit material) diff --git a/test/material/compositionalflash/CMakeLists.txt b/test/material/compositionalflash/CMakeLists.txt index f231a9dc811fe4c8dd58a3dd290c06dc4fd9320f..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644 --- a/test/material/compositionalflash/CMakeLists.txt +++ b/test/material/compositionalflash/CMakeLists.txt @@ -1,2 +0,0 @@ -dumux_add_test(SOURCES test_compositionalflash.cc - LABELS unit material) diff --git a/test/material/fluidmatrixinteractions/2p/CMakeLists.txt b/test/material/fluidmatrixinteractions/2p/CMakeLists.txt index caf48084318a594ccc009744018e146de69ebfcd..b2fb3ee9f545e476eb5e0899845c1fb84f8c6f5e 100644 --- a/test/material/fluidmatrixinteractions/2p/CMakeLists.txt +++ b/test/material/fluidmatrixinteractions/2p/CMakeLists.txt @@ -1,34 +1,3 @@ -dumux_add_test(SOURCES test_thermalconductivity.cc - LABELS unit material - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzyData --delimiter " " - --files ${CMAKE_SOURCE_DIR}/test/references/thermalconductivitysomerton-reference.dat - ${CMAKE_CURRENT_BINARY_DIR}/somerton_lambda_eff.dat - ${CMAKE_SOURCE_DIR}/test/references/thermalconductivityjohansen-reference.dat - ${CMAKE_CURRENT_BINARY_DIR}/johansen_lambda_eff.dat - --command "${CMAKE_CURRENT_BINARY_DIR}/test_thermalconductivity") - -dumux_add_test(SOURCES test_material_2p_vangenuchten.cc - LABELS unit material - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzyData --delimiter " " - --files ${CMAKE_SOURCE_DIR}/test/references/test_pcsw_vangenuchten.dat - ${CMAKE_CURRENT_BINARY_DIR}/test_pcsw_vangenuchten.dat - --command "${CMAKE_CURRENT_BINARY_DIR}/test_material_2p_vangenuchten") - -dumux_add_test(SOURCES test_material_2p_brookscorey.cc - LABELS unit material - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzyData --delimiter " " - --files ${CMAKE_SOURCE_DIR}/test/references/test_pcsw_brookscorey.dat - ${CMAKE_CURRENT_BINARY_DIR}/test_pcsw_brookscorey.dat - --command "${CMAKE_CURRENT_BINARY_DIR}/test_material_2p_brookscorey") - - -dumux_add_test(SOURCES test_material_2p_spline.cc - LABELS unit material) - -dumux_add_test(SOURCES test_material_2p_dataspline.cc - LABELS unit material) - -dune_symlink_to_source_files(FILES test_material_2p_spline.input test_material_2p_dataspline.input) +file(GLOB DUMUX_TEST_MATERIAL_FLUIDMATRIXINTERACTIONS_2P_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_MATERIAL_FLUIDMATRIXINTERACTIONS_2P_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/material/fluidmatrixinteractions/2p) diff --git a/test/material/fluidmatrixinteractions/CMakeLists.txt b/test/material/fluidmatrixinteractions/CMakeLists.txt index 983c069d6bb53f11507624fe7421a93f966c0b2a..51ee613e83e9e91f4c2e15f8c8b853c9a0a23843 100644 --- a/test/material/fluidmatrixinteractions/CMakeLists.txt +++ b/test/material/fluidmatrixinteractions/CMakeLists.txt @@ -1,12 +1,2 @@ add_subdirectory(2p) add_subdirectory(porenetwork) - -dumux_add_test(SOURCES test_effectivediffusivity.cc - LABELS unit material - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzyData --delimiter " " - --files ${CMAKE_SOURCE_DIR}/test/references/effectivediffusivityconstanttau-reference.dat - ${CMAKE_CURRENT_BINARY_DIR}/constant_d_eff.dat - ${CMAKE_SOURCE_DIR}/test/references/effectivediffusivitymillingtonquirk-reference.dat - ${CMAKE_CURRENT_BINARY_DIR}/millingtonquirk_d_eff.dat - --command "${CMAKE_CURRENT_BINARY_DIR}/test_effectivediffusivity -SpatialParams.Tortuosity 0.3") diff --git a/test/material/fluidmatrixinteractions/porenetwork/CMakeLists.txt b/test/material/fluidmatrixinteractions/porenetwork/CMakeLists.txt index 2715b8ec29e2745c5bfa5d9fe22893a807884520..0985c9d420295e364beb9df4712882b3b9e24615 100644 --- a/test/material/fluidmatrixinteractions/porenetwork/CMakeLists.txt +++ b/test/material/fluidmatrixinteractions/porenetwork/CMakeLists.txt @@ -1,27 +1,3 @@ -dumux_add_test(NAME test_throattransmissibility - LABELS unit material porenetwork - SOURCES test_throattransmissibility.cc - COMMAND ${CMAKE_CURRENT_BINARY_DIR}/test_throattransmissibility) - -dumux_add_test(NAME test_material_2p_porenetwork - SOURCES test_material_2p_porenetwork.cc - LABELS unit material porenetwork - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzyData --delimiter " " - --files ${CMAKE_SOURCE_DIR}/test/references/test_pnm_pcsw_cube.dat - ${CMAKE_CURRENT_BINARY_DIR}/test_pnm_pcsw_cube.dat - ${CMAKE_SOURCE_DIR}/test/references/test_pnm_pcsw_tetrahedron.dat - ${CMAKE_CURRENT_BINARY_DIR}/test_pnm_pcsw_tetrahedron.dat - ${CMAKE_SOURCE_DIR}/test/references/test_pnm_pcsw_octahedron.dat - ${CMAKE_CURRENT_BINARY_DIR}/test_pnm_pcsw_octahedron.dat - ${CMAKE_SOURCE_DIR}/test/references/test_pnm_pcsw_icosahedron.dat - ${CMAKE_CURRENT_BINARY_DIR}/test_pnm_pcsw_icosahedron.dat - ${CMAKE_SOURCE_DIR}/test/references/test_pnm_pcsw_dodecahedron.dat - ${CMAKE_CURRENT_BINARY_DIR}/test_pnm_pcsw_dodecahedron.dat - ${CMAKE_SOURCE_DIR}/test/references/test_pnm_pcsw_cube.dat - ${CMAKE_CURRENT_BINARY_DIR}/test_pnm_pcsw_cube_with_linear_regularization.dat - ${CMAKE_SOURCE_DIR}/test/references/test_pnm_pcsw_cube_with_powerlaw_regularization.dat - ${CMAKE_CURRENT_BINARY_DIR}/test_pnm_pcsw_cube_with_powerlaw_regularization.dat - ${CMAKE_SOURCE_DIR}/test/references/test_pnm_pcsw_cube_with_spline_regularization.dat - ${CMAKE_CURRENT_BINARY_DIR}/test_pnm_pcsw_cube_with_spline_regularization.dat - --command "${CMAKE_CURRENT_BINARY_DIR}/test_material_2p_porenetwork") +file(GLOB DUMUX_TEST_MATERIAL_FLUIDMATRIXINTERACTIONS_PORENETWORK_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_MATERIAL_FLUIDMATRIXINTERACTIONS_PORENETWORK_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/material/fluidmatrixinteractions/porenetwork) diff --git a/test/material/fluidsystems/CMakeLists.txt b/test/material/fluidsystems/CMakeLists.txt index 65866a537b5308e9db0330a02b039ca632fdcecc..72387e3bd94469167f0654fb140ccc557fa09c90 100644 --- a/test/material/fluidsystems/CMakeLists.txt +++ b/test/material/fluidsystems/CMakeLists.txt @@ -1,2 +1,3 @@ -dumux_add_test(SOURCES test_fluidsystems.cc - LABELS unit material) +file(GLOB DUMUX_TEST_MATERIAL_FLUIDSYSTEMS_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_MATERIAL_FLUIDSYSTEMS_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/material/fluidsystems) diff --git a/test/material/immiscibleflash/CMakeLists.txt b/test/material/immiscibleflash/CMakeLists.txt index f125eb1f30bbe438a1407530cd9b87a8871a08a2..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644 --- a/test/material/immiscibleflash/CMakeLists.txt +++ b/test/material/immiscibleflash/CMakeLists.txt @@ -1,2 +0,0 @@ -dumux_add_test(SOURCES test_immiscibleflash.cc - LABELS unit material) diff --git a/test/material/ncpflash/CMakeLists.txt b/test/material/ncpflash/CMakeLists.txt index 4ee916369cea4e65912190daeaf20e8cd5ac75e7..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644 --- a/test/material/ncpflash/CMakeLists.txt +++ b/test/material/ncpflash/CMakeLists.txt @@ -1,2 +0,0 @@ -dumux_add_test(SOURCES test_ncpflash.cc - LABELS unit material) diff --git a/test/material/pengrobinson/CMakeLists.txt b/test/material/pengrobinson/CMakeLists.txt index b8695061c382b7ce83054103fd99ec4361fd1434..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644 --- a/test/material/pengrobinson/CMakeLists.txt +++ b/test/material/pengrobinson/CMakeLists.txt @@ -1,2 +0,0 @@ -dumux_add_test(SOURCES test_pengrobinson.cc - LABELS unit material) diff --git a/test/material/solidsystems/CMakeLists.txt b/test/material/solidsystems/CMakeLists.txt index 7afc19da1c0438f964a33b77e56bbfaa4c3808b4..8144e8a1d0be914e8f5aebadf0d0b12da31a840c 100644 --- a/test/material/solidsystems/CMakeLists.txt +++ b/test/material/solidsystems/CMakeLists.txt @@ -1,2 +1,3 @@ -dumux_add_test(SOURCES test_solidsystems.cc - LABELS unit material) +file(GLOB DUMUX_TEST_MATERIAL_SOLIDSYSTEMS_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_MATERIAL_SOLIDSYSTEMS_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/material/solidsystems) diff --git a/test/material/tabulation/CMakeLists.txt b/test/material/tabulation/CMakeLists.txt index aba2c95926079a9ba05139bfb5e5a10d9f396bf8..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644 --- a/test/material/tabulation/CMakeLists.txt +++ b/test/material/tabulation/CMakeLists.txt @@ -1,3 +0,0 @@ -dumux_add_test(SOURCES test_tabulation.cc - TIMEOUT 3600 - LABELS unit material) diff --git a/test/multidomain/CMakeLists.txt b/test/multidomain/CMakeLists.txt index 51fcab95172ef6a6588818ad9baaee77c4ab7d67..b5c87e3d4b5144705a97ef0cc1c5a092f1f8598a 100644 --- a/test/multidomain/CMakeLists.txt +++ b/test/multidomain/CMakeLists.txt @@ -1,4 +1,4 @@ -add_subdirectory(embedded) -add_subdirectory(poromechanics) add_subdirectory(boundary) +add_subdirectory(embedded) add_subdirectory(facet) +add_subdirectory(poromechanics) diff --git a/test/multidomain/boundary/darcydarcy/1p_1p/CMakeLists.txt b/test/multidomain/boundary/darcydarcy/1p_1p/CMakeLists.txt index 3c29cf11f4c1c5e98fad2627cbfb560de2ec4de6..d32c5f5f01dae622dc207d96062dc3655d0f3b0b 100644 --- a/test/multidomain/boundary/darcydarcy/1p_1p/CMakeLists.txt +++ b/test/multidomain/boundary/darcydarcy/1p_1p/CMakeLists.txt @@ -1,24 +1,3 @@ -dumux_add_test(NAME test_md_boundary_darcy1p_darcy1p_half - LABELS multidomain multidomain_boundary darcydarcy 1p - SOURCES main.cc - COMPILE_DEFINITIONS DOMAINSPLIT=0 - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p_cc-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_boundary_darcy1p_darcy1p_half_combined.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_boundary_darcy1p_darcy1p_half params.input \ - -Vtk.OutputName test_md_boundary_darcy1p_darcy1p_half") - -dumux_add_test(NAME test_md_boundary_darcy1p_darcy1p_lens - LABELS multidomain multidomain_boundary darcydarcy 1p - SOURCES main.cc - COMPILE_DEFINITIONS DOMAINSPLIT=1 - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMAKE_GUARD dune-subgrid_FOUND - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p_cc-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_boundary_darcy1p_darcy1p_lens_combined.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_boundary_darcy1p_darcy1p_lens params.input \ - -Vtk.OutputName test_md_boundary_darcy1p_darcy1p_lens") - -dune_symlink_to_source_files(FILES "params.input") +file(GLOB DUMUX_TEST_MULTIDOMAIN_BOUNDARY_DARCYDARCY_1P_1P_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_MULTIDOMAIN_BOUNDARY_DARCYDARCY_1P_1P_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/multidomain/boundary/darcydarcy/1p_1p) diff --git a/test/multidomain/boundary/darcydarcy/1p_2p/CMakeLists.txt b/test/multidomain/boundary/darcydarcy/1p_2p/CMakeLists.txt index 1442041181bc5a1c4679ed517a3845510ae6f0ff..6b77073898cfeead4c1a84aad824ec8982e1c111 100644 --- a/test/multidomain/boundary/darcydarcy/1p_2p/CMakeLists.txt +++ b/test/multidomain/boundary/darcydarcy/1p_2p/CMakeLists.txt @@ -1,14 +1,3 @@ -dumux_add_test(NAME test_md_boundary_darcy1p_darcy2p - LABELS multidomain multidomain_boundary darcydarcy 1p 2p - SOURCES main.cc - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMAKE_GUARD dune-subgrid_FOUND - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_boundary_darcy1p_darcy2p_2p-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_boundary_darcy1p_darcy2p_2p-00017.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_boundary_darcy1p_darcy2p_1p-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_boundary_darcy1p_darcy2p_1p-00017.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_boundary_darcy1p_darcy2p params.input - -Vtk.OutputName test_md_boundary_darcy1p_darcy2p") - -dune_symlink_to_source_files(FILES "params.input") +file(GLOB DUMUX_TEST_MULTIDOMAIN_BOUNDARY_DARCYDARCY_1P_2P_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_MULTIDOMAIN_BOUNDARY_DARCYDARCY_1P_2P_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/multidomain/boundary/darcydarcy/1p_2p) diff --git a/test/multidomain/boundary/stokesdarcy/1p2c_1p2c/CMakeLists.txt b/test/multidomain/boundary/stokesdarcy/1p2c_1p2c/CMakeLists.txt index 25afa7e1d40691964f2c7e78a5a12c33532d3949..43d3e99f63f24208c381c2bdb7243adfb5fbded4 100644 --- a/test/multidomain/boundary/stokesdarcy/1p2c_1p2c/CMakeLists.txt +++ b/test/multidomain/boundary/stokesdarcy/1p2c_1p2c/CMakeLists.txt @@ -1,46 +1,5 @@ add_subdirectory(diffusionlawcomparison) -add_input_file_links() - -add_executable(test_md_boundary_darcy1p2c_stokes1p2c EXCLUDE_FROM_ALL main.cc) - -dumux_add_test(NAME test_md_boundary_darcy1p2c_stokes1p2c_horizontal - LABELS multidomain multidomain_boundary stokesdarcy 1pnc navierstokes - TARGET test_md_boundary_darcy1p2c_stokes1p2c - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_boundary_darcy1p2c_stokes1p2c_horizontal_stokes-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_boundary_darcy1p2c_stokes1p2c_horizontal_stokes-00020.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_boundary_darcy1p2c_stokes1p2c_horizontal_darcy-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_boundary_darcy1p2c_stokes1p2c_horizontal_darcy-00020.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_boundary_darcy1p2c_stokes1p2c params_horizontalflow.input - -Vtk.OutputName test_md_boundary_darcy1p2c_stokes1p2c_horizontal") - -dumux_add_test(NAME test_md_boundary_darcy1p2c_stokes1p2c_vertical_diffusion - LABELS multidomain multidomain_boundary stokesdarcy 1pnc navierstokes - TARGET test_md_boundary_darcy1p2c_stokes1p2c - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --zeroThreshold {"velocity_liq \(m/s\)":1e-20} - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_boundary_darcy1p2c_stokes1p2c_vertical_diffusion_stokes-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_boundary_darcy1p2c_stokes1p2c_vertical_diffusion_stokes-00003.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_boundary_darcy1p2c_stokes1p2c_vertical_diffusion_darcy-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_boundary_darcy1p2c_stokes1p2c_vertical_diffusion_darcy-00003.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_boundary_darcy1p2c_stokes1p2c params_verticalflow_diffusion.input - -Vtk.OutputName test_md_boundary_darcy1p2c_stokes1p2c_vertical_diffusion") - -dumux_add_test(NAME test_md_boundary_darcy1p2c_stokes1p2c_vertical_advection - LABELS multidomain multidomain_boundary stokesdarcy 1pnc navierstokes - TARGET test_md_boundary_darcy1p2c_stokes1p2c - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --zeroThreshold {"velocity_liq \(m/s\)":1e-15} - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_boundary_darcy1p2c_stokes1p2c_vertical_advection_stokes-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_boundary_darcy1p2c_stokes1p2c_vertical_stokes-00030.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_boundary_darcy1p2c_stokes1p2c_vertical_advection_darcy-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_boundary_darcy1p2c_stokes1p2c_vertical_darcy-00030.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_boundary_darcy1p2c_stokes1p2c params_verticalflow.input - -Vtk.OutputName test_md_boundary_darcy1p2c_stokes1p2c_vertical") +file(GLOB DUMUX_TEST_MULTIDOMAIN_BOUNDARY_STOKESDARCY_1P2C_1P2C_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_MULTIDOMAIN_BOUNDARY_STOKESDARCY_1P2C_1P2C_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/multidomain/boundary/stokesdarcy/1p2c_1p2c) diff --git a/test/multidomain/boundary/stokesdarcy/1p2c_1p2c/diffusionlawcomparison/CMakeLists.txt b/test/multidomain/boundary/stokesdarcy/1p2c_1p2c/diffusionlawcomparison/CMakeLists.txt index af24169339785b21dff968ee887879af3448d4cc..9333af54fcf363ee5de10dc85ac65ab72e488a50 100644 --- a/test/multidomain/boundary/stokesdarcy/1p2c_1p2c/diffusionlawcomparison/CMakeLists.txt +++ b/test/multidomain/boundary/stokesdarcy/1p2c_1p2c/diffusionlawcomparison/CMakeLists.txt @@ -1,31 +1,3 @@ -add_input_file_links() - -dumux_add_test(NAME test_md_boundary_darcy1p2c_stokes1p2c_maxwellstefan - LABELS multidomain multidomain_boundary freeflow 1pnc - SOURCES main.cc - CMAKE_GUARD HAVE_UMFPACK - COMPILE_DEFINITIONS DIFFUSIONTYPE=MaxwellStefansLaw - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_boundary_darcy1p2c_stokes1p2c_comparison_stokes-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_boundary_darcy1p2c_stokes1p2c_comparison_ms_stokes-00020.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_boundary_darcy1p2c_stokes1p2c_comparison_darcy-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_boundary_darcy1p2c_stokes1p2c_comparison_ms_darcy-00020.vtu - - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_boundary_darcy1p2c_stokes1p2c_maxwellstefan params.input - -Problem.Name test_md_boundary_darcy1p2c_stokes1p2c_comparison_ms") - -dumux_add_test(NAME test_md_boundary_darcy1p2c_stokes1p2c_fickslaw - LABELS multidomain multidomain_boundary freeflow 1pnc - SOURCES main.cc - CMAKE_GUARD HAVE_UMFPACK - COMPILE_DEFINITIONS DIFFUSIONTYPE=FicksLaw - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_boundary_darcy1p2c_stokes1p2c_comparison_stokes-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_boundary_darcy1p2c_stokes1p2c_comparison_f_stokes-00020.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_boundary_darcy1p2c_stokes1p2c_comparison_darcy-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_boundary_darcy1p2c_stokes1p2c_comparison_f_darcy-00020.vtu - - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_boundary_darcy1p2c_stokes1p2c_fickslaw params.input - -Problem.Name test_md_boundary_darcy1p2c_stokes1p2c_comparison_f") +file(GLOB DUMUX_TEST_MULTIDOMAIN_BOUNDARY_STOKESDARCY_1P2C_1P2C_DIFFUSIONLAWCOMPARISON_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_MULTIDOMAIN_BOUNDARY_STOKESDARCY_1P2C_1P2C_DIFFUSIONLAWCOMPARISON_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/multidomain/boundary/stokesdarcy/1p2c_1p2c/diffusionlawcomparison) diff --git a/test/multidomain/boundary/stokesdarcy/1p2c_2p2c/CMakeLists.txt b/test/multidomain/boundary/stokesdarcy/1p2c_2p2c/CMakeLists.txt index a85654510183498fc8dc84084a029265129485c1..1984081b441c9c1bac59241c908258ae83eef715 100644 --- a/test/multidomain/boundary/stokesdarcy/1p2c_2p2c/CMakeLists.txt +++ b/test/multidomain/boundary/stokesdarcy/1p2c_2p2c/CMakeLists.txt @@ -1,30 +1,3 @@ -add_input_file_links() - -dumux_add_test(NAME test_md_boundary_darcy2p2c_stokes1p2c_horizontal - LABELS multidomain multidomain_boundary stokesdarcy 2p2c navierstokes - SOURCES main.cc - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_boundary_darcy2p2c_stokes1p2c_horizontal_stokes-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_boundary_darcy2p2c_stokes1p2c_horizontal_stokes-00039.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_boundary_darcy2p2c_stokes1p2c_horizontal_darcy-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_boundary_darcy2p2c_stokes1p2c_horizontal_darcy-00039.vtu - - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_boundary_darcy2p2c_stokes1p2c_horizontal params.input - -Vtk.OutputName test_md_boundary_darcy2p2c_stokes1p2c_horizontal") - -dumux_add_test(NAME test_md_boundary_darcy2p2cni_stokes1p2cni_horizontal - LABELS multidomain multidomain_boundary stokesdarcy 2p2c navierstokes - SOURCES main.cc - COMPILE_DEFINITIONS NONISOTHERMAL=1 - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_boundary_darcy2p2cni_stokes1p2cni_horizontal_stokes-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_boundary_darcy2p2cni_stokes1p2cni_horizontal_stokes-00039.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_boundary_darcy2p2cni_stokes1p2cni_horizontal_darcy-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_boundary_darcy2p2cni_stokes1p2cni_horizontal_darcy-00039.vtu - - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_boundary_darcy2p2cni_stokes1p2cni_horizontal params_nonisothermal.input - -Vtk.OutputName test_md_boundary_darcy2p2cni_stokes1p2cni_horizontal") +file(GLOB DUMUX_TEST_MULTIDOMAIN_BOUNDARY_STOKESDARCY_1P2C_2P2C_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_MULTIDOMAIN_BOUNDARY_STOKESDARCY_1P2C_2P2C_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/multidomain/boundary/stokesdarcy/1p2c_2p2c) diff --git a/test/multidomain/boundary/stokesdarcy/1p3c_1p3c/CMakeLists.txt b/test/multidomain/boundary/stokesdarcy/1p3c_1p3c/CMakeLists.txt index b3fa296c1413f8bab2538ce780a97220ee7c7d0a..dccb16e27cec1fb2f2dc54769b8b77af0cc7a1c4 100644 --- a/test/multidomain/boundary/stokesdarcy/1p3c_1p3c/CMakeLists.txt +++ b/test/multidomain/boundary/stokesdarcy/1p3c_1p3c/CMakeLists.txt @@ -1,14 +1,3 @@ -add_input_file_links() - -dumux_add_test(NAME test_md_boundary_darcy1p3c_stokes1p3c_horizontal - LABELS multidomain multidomain_boundary stokesdarcy 1pnc navierstokes - SOURCES main.cc - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_boundary_darcy1p3c_stokes1p3c_horizontal_stokes-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_boundary_darcy1p3c_stokes1p3c_horizontal_stokes-00015.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_boundary_darcy1p3c_stokes1p3c_horizontal_darcy-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_boundary_darcy1p3c_stokes1p3c_horizontal_darcy-00015.vtu - - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_boundary_darcy1p3c_stokes1p3c_horizontal params.input") +file(GLOB DUMUX_TEST_MULTIDOMAIN_BOUNDARY_STOKESDARCY_1P3C_1P3C_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_MULTIDOMAIN_BOUNDARY_STOKESDARCY_1P3C_1P3C_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/multidomain/boundary/stokesdarcy/1p3c_1p3c) diff --git a/test/multidomain/boundary/stokesdarcy/1p_1p/CMakeLists.txt b/test/multidomain/boundary/stokesdarcy/1p_1p/CMakeLists.txt index 45acb89ecd3ed8e3f2b58c3260ba52309dd9ee7f..2e925d456b3cd4b90412dac710b22888cee98268 100644 --- a/test/multidomain/boundary/stokesdarcy/1p_1p/CMakeLists.txt +++ b/test/multidomain/boundary/stokesdarcy/1p_1p/CMakeLists.txt @@ -1,32 +1,5 @@ add_subdirectory(convergencetest) -add_input_file_links() - -add_executable(test_md_boundary_darcy1p_stokes1p EXCLUDE_FROM_ALL main.cc) - -dumux_add_test(NAME test_md_boundary_darcy1p_stokes1p_horizontal - LABELS multidomain multidomain_boundary stokesdarcy 1p navierstokes - TARGET test_md_boundary_darcy1p_stokes1p - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_boundary_darcy1p_stokes1p_horizontal_stokes-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_boundary_darcy1p_stokes1p_horizontal_stokes-00001.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_boundary_darcy1p_stokes1p_horizontal_darcy-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_boundary_darcy1p_stokes1p_horizontal_darcy-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_boundary_darcy1p_stokes1p params_horizontalflow.input - -Vtk.OutputName test_md_boundary_darcy1p_stokes1p_horizontal") - -dumux_add_test(NAME test_md_boundary_darcy1p_stokes1p_vertical - LABELS multidomain multidomain_boundary stokesdarcy 1p navierstokes - TARGET test_md_boundary_darcy1p_stokes1p - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_boundary_darcy1p_stokes1p_vertical_stokes-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_boundary_darcy1p_stokes1p_vertical_stokes-00001.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_boundary_darcy1p_stokes1p_vertical_darcy-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_boundary_darcy1p_stokes1p_vertical_darcy-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_boundary_darcy1p_stokes1p params_verticalflow.input - -Vtk.OutputName test_md_boundary_darcy1p_stokes1p_vertical" - --zeroThreshold {"velocity_liq \(m/s\)_0":6e-17}) +file(GLOB DUMUX_TEST_MULTIDOMAIN_BOUNDARY_STOKESDARCY_1P_1P_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_MULTIDOMAIN_BOUNDARY_STOKESDARCY_1P_1P_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/multidomain/boundary/stokesdarcy/1p_1p) diff --git a/test/multidomain/boundary/stokesdarcy/1p_1p/convergencetest/CMakeLists.txt b/test/multidomain/boundary/stokesdarcy/1p_1p/convergencetest/CMakeLists.txt index 998112d9a3274ae117d941b0dfc6b39d46b03c8f..bbbc4f4d46cabbd401ccfa46642cbbe492cd95cb 100644 --- a/test/multidomain/boundary/stokesdarcy/1p_1p/convergencetest/CMakeLists.txt +++ b/test/multidomain/boundary/stokesdarcy/1p_1p/convergencetest/CMakeLists.txt @@ -1,25 +1,3 @@ -add_input_file_links() -dune_symlink_to_source_files(FILES "convergencetest.py") - -add_executable(test_md_boundary_darcy1p_freeflow1p_convtest EXCLUDE_FROM_ALL main.cc) - -dumux_add_test(NAME test_md_boundary_darcy1p_stokes1p_convtest - TARGET test_md_boundary_darcy1p_freeflow1p_convtest - LABELS multidomain multidomain_boundary stokesdarcy - TIMEOUT 1000 - CMAKE_GUARD HAVE_UMFPACK - COMMAND ./convergencetest.py - CMD_ARGS test_md_boundary_darcy1p_freeflow1p_convtest params.input - -Problem.TestCase ShiueExampleTwo - -Darcy.SpatialParams.Permeability 1.0) - -dumux_add_test(NAME test_md_boundary_darcy1p_navierstokes1p_convtest - TARGET test_md_boundary_darcy1p_freeflow1p_convtest - LABELS multidomain multidomain_boundary stokesdarcy - TIMEOUT 1000 - CMAKE_GUARD HAVE_UMFPACK - COMMAND ./convergencetest.py - CMD_ARGS test_md_boundary_darcy1p_freeflow1p_convtest params.input - -Problem.TestCase Schneider - -FreeFlow.Problem.EnableInertiaTerms true - -FreeFlow.EnableUnsymmetrizedVelocityGradientForBeaversJoseph true) +file(GLOB DUMUX_TEST_MULTIDOMAIN_BOUNDARY_STOKESDARCY_1P_1P_CONVERGENCETEST_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_MULTIDOMAIN_BOUNDARY_STOKESDARCY_1P_1P_CONVERGENCETEST_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/multidomain/boundary/stokesdarcy/1p_1p/convergencetest) diff --git a/test/multidomain/boundary/stokesdarcy/1p_2p/CMakeLists.txt b/test/multidomain/boundary/stokesdarcy/1p_2p/CMakeLists.txt index 62e62885ff73a120a2e7faa4cca013a95ca427b6..df71b544ad3f1bca8caf0f57861006f74f969618 100644 --- a/test/multidomain/boundary/stokesdarcy/1p_2p/CMakeLists.txt +++ b/test/multidomain/boundary/stokesdarcy/1p_2p/CMakeLists.txt @@ -1,16 +1,3 @@ -add_input_file_links() - -dumux_add_test(NAME test_md_boundary_darcy2p_stokes1p_vertical - LABELS multidomain multidomain_boundary stokesdarcy 1p navierstokes - SOURCES main.cc - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_boundary_darcy2p_stokes1p_vertical_stokes-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_boundary_darcy2p_stokes1p_vertical_stokes-00024.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_boundary_darcy2p_stokes1p_vertical_darcy-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_boundary_darcy2p_stokes1p_vertical_darcy-00024.vtu - - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_boundary_darcy2p_stokes1p_vertical params.input - -Vtk.OutputName test_md_boundary_darcy2p_stokes1p_vertical" - --zeroThreshold {"velocity_liq \(m/s\)_0":1e-14,"velocity_gas \(m/s\)":1e-15}) +file(GLOB DUMUX_TEST_MULTIDOMAIN_BOUNDARY_STOKESDARCY_1P_2P_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_MULTIDOMAIN_BOUNDARY_STOKESDARCY_1P_2P_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/multidomain/boundary/stokesdarcy/1p_2p) diff --git a/test/multidomain/boundary/stokesdarcy/CMakeLists.txt b/test/multidomain/boundary/stokesdarcy/CMakeLists.txt index 95d1a09424acf6eeface02181a5ad7cfcc729f44..7e3050adff5ed220aa3e9e66e7c79c88cc192c2d 100644 --- a/test/multidomain/boundary/stokesdarcy/CMakeLists.txt +++ b/test/multidomain/boundary/stokesdarcy/CMakeLists.txt @@ -1,5 +1,5 @@ -add_subdirectory(1p_1p) -add_subdirectory(1p_2p) add_subdirectory(1p2c_1p2c) -add_subdirectory(1p3c_1p3c) add_subdirectory(1p2c_2p2c) +add_subdirectory(1p3c_1p3c) +add_subdirectory(1p_1p) +add_subdirectory(1p_2p) diff --git a/test/multidomain/embedded/1d3d/1p2c_richards2c/CMakeLists.txt b/test/multidomain/embedded/1d3d/1p2c_richards2c/CMakeLists.txt index 237ec5e83202c52976031b993139d3749ae10625..1a766b2ea0645c481c3533479c2e944ef3576368 100644 --- a/test/multidomain/embedded/1d3d/1p2c_richards2c/CMakeLists.txt +++ b/test/multidomain/embedded/1d3d/1p2c_richards2c/CMakeLists.txt @@ -1,14 +1,3 @@ -dumux_add_test(NAME test_md_embedded_1d3d_1p2c_richards2c - LABELS multidomain multidomain_embedded 1pnc richardsnc - SOURCES main.cc - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-uggrid_FOUND )" - TIMEOUT 1500 - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_embedded_1d3d_1p2c_richards2c_1d-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_md_embedded_1d3d_1p2c_richards2c_1d-00003.vtp - ${CMAKE_SOURCE_DIR}/test/references/test_md_embedded_1d3d_1p2c_richards2c_3d-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_embedded_1d3d_1p2c_richards2c_3d-00003.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_embedded_1d3d_1p2c_richards2c params.input - -Vtk.OutputName test_md_embedded_1d3d_1p2c_richards2c") -dune_symlink_to_source_files(FILES "params.input") +file(GLOB DUMUX_TEST_MULTIDOMAIN_EMBEDDED_1D3D_1P2C_RICHARDS2C_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_MULTIDOMAIN_EMBEDDED_1D3D_1P2C_RICHARDS2C_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/multidomain/embedded/1d3d/1p2c_richards2c) diff --git a/test/multidomain/embedded/1d3d/1p_1p/CMakeLists.txt b/test/multidomain/embedded/1d3d/1p_1p/CMakeLists.txt index 8b8e9f0709ae6f6e2586fb309dab8f927075bd2f..bc438d0a56ca5d2fb64abdaa92a7de9eb979676e 100644 --- a/test/multidomain/embedded/1d3d/1p_1p/CMakeLists.txt +++ b/test/multidomain/embedded/1d3d/1p_1p/CMakeLists.txt @@ -1,91 +1,3 @@ -dumux_add_test(NAME test_md_embedded_1d3d_1p1p_tpfatpfa_average - LABELS multidomain multidomain_embedded 1p - SOURCES main.cc - COMPILE_DEFINITIONS BULKTYPETAG=TissueCC LOWDIMTYPETAG=BloodFlowCC COUPLINGMODE=Embedded1d3dCouplingMode::Average - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMAKE_GUARD dune-foamgrid_FOUND - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_embedded_1d3d_1p1p_tpfatpfa_average_1d-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_md_embedded_1d3d_1p1p_tpfatpfa_average_1d-00001.vtp - ${CMAKE_SOURCE_DIR}/test/references/test_md_embedded_1d3d_1p1p_tpfatpfa_average_3d-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_embedded_1d3d_1p1p_tpfatpfa_average_3d-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_embedded_1d3d_1p1p_tpfatpfa_average params.input \ - -Vtk.OutputName test_md_embedded_1d3d_1p1p_tpfatpfa_average") - -dumux_add_test(NAME test_md_embedded_1d3d_1p1p_boxtpfa_average - LABELS multidomain multidomain_embedded 1p - SOURCES main.cc - COMPILE_DEFINITIONS BULKTYPETAG=TissueBox LOWDIMTYPETAG=BloodFlowCC COUPLINGMODE=Embedded1d3dCouplingMode::Average - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMAKE_GUARD dune-foamgrid_FOUND - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_embedded_1d3d_1p1p_tpfatpfa_average_1d-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_md_embedded_1d3d_1p1p_boxtpfa_average_1d-00001.vtp - ${CMAKE_SOURCE_DIR}/test/references/test_md_embedded_1d3d_1p1p_boxbox_average_3d-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_embedded_1d3d_1p1p_boxtpfa_average_3d-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_embedded_1d3d_1p1p_boxtpfa_average params.input \ - -Vtk.OutputName test_md_embedded_1d3d_1p1p_boxtpfa_average -Tissue.Grid.Cells \"19 19 19\"") - -dumux_add_test(NAME test_md_embedded_1d3d_1p1p_tpfabox_average - LABELS multidomain multidomain_embedded 1p - SOURCES main.cc - COMPILE_DEFINITIONS BULKTYPETAG=TissueCC LOWDIMTYPETAG=BloodFlowBox COUPLINGMODE=Embedded1d3dCouplingMode::Average - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMAKE_GUARD dune-foamgrid_FOUND - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_embedded_1d3d_1p1p_boxbox_average_1d-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_md_embedded_1d3d_1p1p_tpfabox_average_1d-00001.vtp - ${CMAKE_SOURCE_DIR}/test/references/test_md_embedded_1d3d_1p1p_tpfatpfa_average_3d-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_embedded_1d3d_1p1p_tpfabox_average_3d-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_embedded_1d3d_1p1p_tpfabox_average params.input \ - -Vtk.OutputName test_md_embedded_1d3d_1p1p_tpfabox_average") - -dumux_add_test(NAME test_md_embedded_1d3d_1p1p_boxbox_average - LABELS multidomain multidomain_embedded 1p - SOURCES main.cc - COMPILE_DEFINITIONS BULKTYPETAG=TissueBox LOWDIMTYPETAG=BloodFlowBox COUPLINGMODE=Embedded1d3dCouplingMode::Average - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMAKE_GUARD dune-foamgrid_FOUND - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_embedded_1d3d_1p1p_boxbox_average_1d-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_md_embedded_1d3d_1p1p_boxbox_average_1d-00001.vtp - ${CMAKE_SOURCE_DIR}/test/references/test_md_embedded_1d3d_1p1p_boxbox_average_3d-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_embedded_1d3d_1p1p_boxbox_average_3d-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_embedded_1d3d_1p1p_boxbox_average params.input \ - -Vtk.OutputName test_md_embedded_1d3d_1p1p_boxbox_average -Tissue.Grid.Cells \"19 19 19\"") - -# make sure these configurations compile and run too -dumux_add_test(NAME test_md_embedded_1d3d_1p1p_tpfatpfa_surface - LABELS multidomain multidomain_embedded 1p - SOURCES main.cc - COMPILE_DEFINITIONS BULKTYPETAG=TissueCC LOWDIMTYPETAG=BloodFlowCC COUPLINGMODE=Embedded1d3dCouplingMode::Surface - COMMAND ./test_md_embedded_1d3d_1p1p_tpfatpfa_surface - CMAKE_GUARD dune-foamgrid_FOUND - CMD_ARGS params.input -Vtk.OutputName test_md_embedded_1d3d_1p1p_tpfatpfa_surface) - -dumux_add_test(NAME test_md_embedded_1d3d_1p1p_tpfatpfa_line - LABELS multidomain multidomain_embedded 1p - SOURCES main.cc - COMPILE_DEFINITIONS BULKTYPETAG=TissueCC LOWDIMTYPETAG=BloodFlowCC COUPLINGMODE=Embedded1d3dCouplingMode::Line - COMMAND ./test_md_embedded_1d3d_1p1p_tpfatpfa_line - CMAKE_GUARD dune-foamgrid_FOUND - CMD_ARGS params.input -Vtk.OutputName test_md_embedded_1d3d_1p1p_tpfatpfa_line) - -dumux_add_test(NAME test_md_embedded_1d3d_1p1p_tpfatpfa_kernel - LABELS multidomain multidomain_embedded 1p - SOURCES main.cc - COMPILE_DEFINITIONS BULKTYPETAG=TissueCC LOWDIMTYPETAG=BloodFlowCC COUPLINGMODE=Embedded1d3dCouplingMode::Kernel - COMMAND ./test_md_embedded_1d3d_1p1p_tpfatpfa_kernel - CMAKE_GUARD dune-foamgrid_FOUND - CMD_ARGS params.input -Vtk.OutputName test_md_embedded_1d3d_1p1p_tpfatpfa_kernel) - -dumux_add_test(NAME test_md_embedded_1d3d_1p1p_tpfatpfa_convergence - LABELS multidomain multidomain_embedded 1p - TIMEOUT 3600 - TARGET test_md_embedded_1d3d_1p1p_tpfatpfa_kernel - COMMAND ./convergence.py - CMAKE_GUARD dune-foamgrid_FOUND) - -set_tests_properties(test_md_embedded_1d3d_1p1p_tpfatpfa_convergence PROPERTIES DEPENDS "test_md_embedded_1d3d_1p1p_tpfatpfa_surface;test_md_embedded_1d3d_1p1p_tpfatpfa_line") - -dune_symlink_to_source_files(FILES "params.input" "convergence.py") +file(GLOB DUMUX_TEST_MULTIDOMAIN_EMBEDDED_1D3D_1P_1P_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_MULTIDOMAIN_EMBEDDED_1D3D_1P_1P_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/multidomain/embedded/1d3d/1p_1p) diff --git a/test/multidomain/embedded/1d3d/1p_richards/CMakeLists.txt b/test/multidomain/embedded/1d3d/1p_richards/CMakeLists.txt index 690280bb6651b77c5047f8eac78781ad31bbda0a..eb64202ab8b39d4808b0835fa755c5db05b90819 100644 --- a/test/multidomain/embedded/1d3d/1p_richards/CMakeLists.txt +++ b/test/multidomain/embedded/1d3d/1p_richards/CMakeLists.txt @@ -1,30 +1,3 @@ -dumux_add_test(NAME test_md_embedded_1d3d_1p_richards_tpfatpfa - LABELS multidomain multidomain_embedded 1p richards - SOURCES main.cc - COMPILE_DEFINITIONS SOILTYPETAG=SoilCC - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMAKE_GUARD dune-foamgrid_FOUND - TIMEOUT 1500 - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_embedded_1d3d_1p_richards_tpfatpfa_1d-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_md_embedded_1d3d_1p_richards_tpfatpfa_1d-00004.vtp - ${CMAKE_SOURCE_DIR}/test/references/test_md_embedded_1d3d_1p_richards_tpfatpfa_3d-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_embedded_1d3d_1p_richards_tpfatpfa_3d-00004.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_embedded_1d3d_1p_richards_tpfatpfa params.input \ - -Vtk.OutputName test_md_embedded_1d3d_1p_richards_tpfatpfa") - -dumux_add_test(NAME test_md_embedded_1d3d_1p_richards_tpfabox - LABELS multidomain multidomain_embedded 1p richards - SOURCES main.cc - COMPILE_DEFINITIONS SOILTYPETAG=SoilBox - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMAKE_GUARD dune-foamgrid_FOUND - TIMEOUT 1500 - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_embedded_1d3d_1p_richards_tpfatpfa_1d-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_md_embedded_1d3d_1p_richards_tpfabox_1d-00004.vtp - ${CMAKE_SOURCE_DIR}/test/references/test_md_embedded_1d3d_1p_richards_tpfabox_3d-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_embedded_1d3d_1p_richards_tpfabox_3d-00004.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_embedded_1d3d_1p_richards_tpfabox params.input \ - -Vtk.OutputName test_md_embedded_1d3d_1p_richards_tpfabox") -dune_symlink_to_source_files(FILES "params.input") +file(GLOB DUMUX_TEST_MULTIDOMAIN_EMBEDDED_1D3D_1P_RICHARDS_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_MULTIDOMAIN_EMBEDDED_1D3D_1P_RICHARDS_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/multidomain/embedded/1d3d/1p_richards) diff --git a/test/multidomain/embedded/1d3d/CMakeLists.txt b/test/multidomain/embedded/1d3d/CMakeLists.txt index 5d6a78487b672b756951ab60dadd714fc1c1110c..3387c17c025819a1479d0aab56dbb50b2466b188 100644 --- a/test/multidomain/embedded/1d3d/CMakeLists.txt +++ b/test/multidomain/embedded/1d3d/CMakeLists.txt @@ -1,5 +1,4 @@ +add_subdirectory(1p2c_richards2c) add_subdirectory(1p_1p) add_subdirectory(1p_richards) -add_subdirectory(1p2c_richards2c) - -dune_symlink_to_source_files(FILES "grids") +add_subdirectory(grids) diff --git a/test/multidomain/embedded/1d3d/grids/CMakeLists.txt b/test/multidomain/embedded/1d3d/grids/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/test/multidomain/embedded/2d3d/1p_1p/CMakeLists.txt b/test/multidomain/embedded/2d3d/1p_1p/CMakeLists.txt index bfceae77fc4a47173d3c00349e664010cc8117be..11a1a65d2f407bdceec82f45e52d55e36621e7c9 100644 --- a/test/multidomain/embedded/2d3d/1p_1p/CMakeLists.txt +++ b/test/multidomain/embedded/2d3d/1p_1p/CMakeLists.txt @@ -1,28 +1,3 @@ -add_executable(test_md_embedded_2d3d_fracture1p_tpfa EXCLUDE_FROM_ALL main.cc) - -dumux_add_test(NAME test_md_embedded_2d3d_fracture1p_tpfa_linearsolver - LABELS multidomain multidomain_embedded 1p - TARGET test_md_embedded_2d3d_fracture1p_tpfa - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMAKE_GUARD dune-foamgrid_FOUND - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_embedded_2d3d_fracture1p_tpfa_2d-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_embedded_2d3d_fracture1p_tpfa_linearsolver_2d-00001.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_embedded_2d3d_fracture1p_tpfa_3d-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_embedded_2d3d_fracture1p_tpfa_linearsolver_3d-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_embedded_2d3d_fracture1p_tpfa params.input \ - -Vtk.OutputName test_md_embedded_2d3d_fracture1p_tpfa_linearsolver -Problem.SolverType linear") - -dumux_add_test(NAME test_md_embedded_2d3d_fracture1p_tpfa_nonlinearsolver - LABELS multidomain multidomain_embedded 1p - TARGET test_md_embedded_2d3d_fracture1p_tpfa - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMAKE_GUARD dune-foamgrid_FOUND - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_embedded_2d3d_fracture1p_tpfa_2d-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_embedded_2d3d_fracture1p_tpfa_nonlinearsolver_2d-00001.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_embedded_2d3d_fracture1p_tpfa_3d-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_embedded_2d3d_fracture1p_tpfa_nonlinearsolver_3d-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_embedded_2d3d_fracture1p_tpfa params.input \ - -Vtk.OutputName test_md_embedded_2d3d_fracture1p_tpfa_nonlinearsolver -Problem.SolverType nonlinear") -dune_symlink_to_source_files(FILES "fracture.msh" "params.input") +file(GLOB DUMUX_TEST_MULTIDOMAIN_EMBEDDED_2D3D_1P_1P_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_MULTIDOMAIN_EMBEDDED_2D3D_1P_1P_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/multidomain/embedded/2d3d/1p_1p) diff --git a/test/multidomain/facet/1p_1p/analytical/CMakeLists.txt b/test/multidomain/facet/1p_1p/analytical/CMakeLists.txt index ac35de8aa5f6d7123ddc29fdb4587235d676ef25..0b263b3789dac32438c3d14aabc3ecff25c2ce00 100644 --- a/test/multidomain/facet/1p_1p/analytical/CMakeLists.txt +++ b/test/multidomain/facet/1p_1p/analytical/CMakeLists.txt @@ -1,17 +1,5 @@ -dune_symlink_to_source_files(FILES "grids" "params.input" "convergencetest.py") +add_subdirectory(grids) -dumux_add_test(NAME test_md_facet_1p1p_tpfa_convergence - LABELS multidomain multidomain_facet 1p - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND AND gmsh_FOUND )" - SOURCES main.cc - COMPILE_DEFINITIONS BULKTYPETAG=OnePBulkTpfa LOWDIMTYPETAG=OnePLowDimTpfa - COMMAND ./convergencetest.py - CMD_ARGS test_md_facet_1p1p_tpfa_convergence 1e-4) - -dumux_add_test(NAME test_md_facet_1p1p_box_convergence - LABELS multidomain multidomain_facet 1p - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND AND gmsh_FOUND )" - SOURCES main.cc - COMPILE_DEFINITIONS BULKTYPETAG=OnePBulkBox LOWDIMTYPETAG=OnePLowDimBox - COMMAND ./convergencetest.py - CMD_ARGS test_md_facet_1p1p_box_convergence 1e-4 ) +file(GLOB DUMUX_TEST_MULTIDOMAIN_FACET_1P_1P_ANALYTICAL_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_MULTIDOMAIN_FACET_1P_1P_ANALYTICAL_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/multidomain/facet/1p_1p/analytical) diff --git a/test/multidomain/facet/1p_1p/analytical/grids/CMakeLists.txt b/test/multidomain/facet/1p_1p/analytical/grids/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/test/multidomain/facet/1p_1p/gravity/CMakeLists.txt b/test/multidomain/facet/1p_1p/gravity/CMakeLists.txt index 132aa481bd96b8a7a40a2ccb24250cfb328160b8..8230dcb9b452aa26f37c8a4d28e9df9d4875dd8a 100644 --- a/test/multidomain/facet/1p_1p/gravity/CMakeLists.txt +++ b/test/multidomain/facet/1p_1p/gravity/CMakeLists.txt @@ -1,108 +1,5 @@ -dune_symlink_to_source_files(FILES "grids" "params.input") +add_subdirectory(grids) -# test gravity using different values for xi -add_executable(test_md_facet_1p1p_gravity_tpfa EXCLUDE_FROM_ALL main.cc) -target_compile_definitions(test_md_facet_1p1p_gravity_tpfa - PUBLIC BULKTYPETAG=OnePBulkTpfa - LOWDIMTYPETAG=OnePLowDimTpfa - LOWDIMGRIDTYPE=Dune::FoamGrid<1,2> - BULKGRIDTYPE=Dune::ALUGrid<2,2,Dune::cube,Dune::nonconforming>) - -add_executable(test_md_facet_1p1p_gravity_mpfa EXCLUDE_FROM_ALL main.cc) -target_compile_definitions(test_md_facet_1p1p_gravity_mpfa - PUBLIC BULKTYPETAG=OnePBulkMpfa - LOWDIMTYPETAG=OnePLowDimMpfa - LOWDIMGRIDTYPE=Dune::FoamGrid<1,2> - BULKGRIDTYPE=Dune::ALUGrid<2,2,Dune::cube,Dune::nonconforming>) - -dumux_add_test(NAME test_md_facet_1p1p_gravity_xi1_tpfa - LABELS multidomain multidomain_facet 1p - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND )" - TARGET test_md_facet_1p1p_gravity_tpfa - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_gravity_xi1_tpfa_bulk-00000.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_gravity_xi1_tpfa_bulk-00001.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_gravity_xi1_tpfa_lowdim-00000.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_gravity_xi1_tpfa_lowdim-00001.vtp - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_gravity_tpfa params.input \ - -Vtk.OutputName test_md_facet_1p1p_gravity_xi1_tpfa") - - -dumux_add_test(NAME test_md_facet_1p1p_gravity_xi066_tpfa - LABELS multidomain multidomain_facet 1p - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND )" - TARGET test_md_facet_1p1p_gravity_tpfa - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_gravity_xi066_tpfa_bulk-00000.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_gravity_xi066_tpfa_bulk-00001.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_gravity_xi066_tpfa_lowdim-00000.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_gravity_xi066_tpfa_lowdim-00001.vtp - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_gravity_tpfa params.input \ - -FacetCoupling.Xi 0.66 -Vtk.OutputName test_md_facet_1p1p_gravity_xi066_tpfa") - - - -dumux_add_test(NAME test_md_facet_1p1p_gravity_xi1_mpfa - LABELS multidomain multidomain_facet 1p - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND )" - TARGET test_md_facet_1p1p_gravity_mpfa - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_gravity_xi1_mpfa_bulk-00000.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_gravity_xi1_mpfa_bulk-00001.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_gravity_xi1_mpfa_lowdim-00000.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_gravity_xi1_mpfa_lowdim-00001.vtp - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_gravity_mpfa params.input \ - -Vtk.OutputName test_md_facet_1p1p_gravity_xi1_mpfa") - -dumux_add_test(NAME test_md_facet_1p1p_gravity_xi066_mpfa - LABELS multidomain multidomain_facet 1p - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND )" - TARGET test_md_facet_1p1p_gravity_mpfa - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_gravity_xi066_mpfa_bulk-00000.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_gravity_xi066_mpfa_bulk-00001.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_gravity_xi066_mpfa_lowdim-00000.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_gravity_xi066_mpfa_lowdim-00001.vtp - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_gravity_mpfa params.input \ - -FacetCoupling.Xi 0.66 - -Vtk.OutputName test_md_facet_1p1p_gravity_xi066_mpfa") - -dumux_add_test(NAME test_md_facet_1p1p_gravity_surface_tpfa - LABELS multidomain multidomain_facet 1p - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND )" - SOURCES main.cc - COMPILE_DEFINITIONS BULKTYPETAG=OnePBulkTpfa - COMPILE_DEFINITIONS LOWDIMTYPETAG=OnePLowDimTpfa - COMPILE_DEFINITIONS BULKGRIDTYPE=Dune::ALUGrid<2,3,Dune::cube,Dune::nonconforming> - COMPILE_DEFINITIONS LOWDIMGRIDTYPE=Dune::FoamGrid<1,3> - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_gravity_surface_tpfa_bulk-00000.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_gravity_surface_tpfa_bulk-00001.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_gravity_surface_tpfa_lowdim-00000.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_gravity_surface_tpfa_lowdim-00001.vtp - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_gravity_surface_tpfa params.input \ - -Vtk.OutputName test_md_facet_1p1p_gravity_surface_tpfa \ - -Grid.File grids/gravity_surface.msh") - -dumux_add_test(NAME test_md_facet_1p1p_gravity_surface_mpfa - LABELS multidomain multidomain_facet 1p - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND )" - SOURCES main.cc - COMPILE_DEFINITIONS BULKTYPETAG=OnePBulkMpfa - COMPILE_DEFINITIONS LOWDIMTYPETAG=OnePLowDimMpfa - COMPILE_DEFINITIONS BULKGRIDTYPE=Dune::ALUGrid<2,3,Dune::cube,Dune::nonconforming> - COMPILE_DEFINITIONS LOWDIMGRIDTYPE=Dune::FoamGrid<1,3> - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_gravity_surface_mpfa_bulk-00000.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_gravity_surface_mpfa_bulk-00001.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_gravity_surface_mpfa_lowdim-00000.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_gravity_surface_mpfa_lowdim-00001.vtp - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_gravity_surface_mpfa params.input \ - -Vtk.OutputName test_md_facet_1p1p_gravity_surface_mpfa \ - -Grid.File grids/gravity_surface.msh") +file(GLOB DUMUX_TEST_MULTIDOMAIN_FACET_1P_1P_GRAVITY_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_MULTIDOMAIN_FACET_1P_1P_GRAVITY_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/multidomain/facet/1p_1p/gravity) diff --git a/test/multidomain/facet/1p_1p/gravity/grids/CMakeLists.txt b/test/multidomain/facet/1p_1p/gravity/grids/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/test/multidomain/facet/1p_1p/linearprofile/CMakeLists.txt b/test/multidomain/facet/1p_1p/linearprofile/CMakeLists.txt index 6a91b1ec9d9316869465d3ec7284a21fadba42fe..c7bf2f816ff3fe397965862841f96a6b9fbc5d62 100644 --- a/test/multidomain/facet/1p_1p/linearprofile/CMakeLists.txt +++ b/test/multidomain/facet/1p_1p/linearprofile/CMakeLists.txt @@ -1,110 +1,5 @@ -dune_symlink_to_source_files(FILES "grids" "params.input") +add_subdirectory(grids) -add_executable(test_md_facet_1p1p_linearprofile_tpfa EXCLUDE_FROM_ALL main.cc) -target_compile_definitions(test_md_facet_1p1p_linearprofile_tpfa - PUBLIC BULKTYPETAG=OnePBulkTpfa - LOWDIMTYPETAG=OnePLowDimTpfa - LOWDIMGRIDTYPE=Dune::FoamGrid<1,2> - BULKGRIDTYPE=Dune::ALUGrid<2,2,Dune::cube,Dune::nonconforming>) - -add_executable(test_md_facet_1p1p_linearprofile_surface_tpfa EXCLUDE_FROM_ALL main.cc) -target_compile_definitions(test_md_facet_1p1p_linearprofile_surface_tpfa - PUBLIC BULKTYPETAG=OnePBulkTpfa - LOWDIMTYPETAG=OnePLowDimTpfa - LOWDIMGRIDTYPE=Dune::FoamGrid<1,3> - BULKGRIDTYPE=Dune::ALUGrid<2,3,Dune::cube,Dune::nonconforming>) - -add_executable(test_md_facet_1p1p_linearprofile_mpfa EXCLUDE_FROM_ALL main.cc) -target_compile_definitions(test_md_facet_1p1p_linearprofile_mpfa - PUBLIC BULKTYPETAG=OnePBulkMpfa - LOWDIMTYPETAG=OnePLowDimMpfa - LOWDIMGRIDTYPE=Dune::FoamGrid<1,2> - BULKGRIDTYPE=Dune::ALUGrid<2,2,Dune::cube,Dune::nonconforming>) - -add_executable(test_md_facet_1p1p_linearprofile_surface_mpfa EXCLUDE_FROM_ALL main.cc) -target_compile_definitions(test_md_facet_1p1p_linearprofile_surface_mpfa - PUBLIC BULKTYPETAG=OnePBulkMpfa - LOWDIMTYPETAG=OnePLowDimMpfa - LOWDIMGRIDTYPE=Dune::FoamGrid<1,3> - BULKGRIDTYPE=Dune::ALUGrid<2,3,Dune::cube,Dune::nonconforming>) - -dumux_add_test(NAME test_md_facet_1p1p_linearprofile_xi1_tpfa - LABELS multidomain multidomain_facet 1p - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND )" - TARGET test_md_facet_1p1p_linearprofile_tpfa - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1p1p_linearprofile_tpfa_bulk-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_linearprofile_xi1_tpfa_bulk-00001.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1p1p_linearprofile_tpfa_lowdim-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_linearprofile_xi1_tpfa_lowdim-00001.vtp - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_linearprofile_tpfa params.input") - -dumux_add_test(NAME test_md_facet_1p1p_linearprofile_xi066_tpfa - LABELS multidomain multidomain_facet 1p - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND )" - TARGET test_md_facet_1p1p_linearprofile_tpfa - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1p1p_linearprofile_tpfa_bulk-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_linearprofile_xi066_tpfa_bulk-00001.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1p1p_linearprofile_tpfa_lowdim-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_linearprofile_xi066_tpfa_lowdim-00001.vtp - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_linearprofile_tpfa params.input \ - -FacetCoupling.Xi 0.66 \ - -Vtk.OutputName test_md_facet_1p1p_linearprofile_xi066_tpfa") - -dumux_add_test(NAME test_md_facet_1p1p_linearprofile_surface_xi1_tpfa - LABELS multidomain multidomain_facet 1p - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND )" - TARGET test_md_facet_1p1p_linearprofile_surface_tpfa - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1p1p_linearprofile_surface_tpfa_bulk-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_linearprofile_surface_xi1_tpfa_bulk-00001.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1p1p_linearprofile_surface_tpfa_lowdim-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_linearprofile_surface_xi1_tpfa_lowdim-00001.vtp - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_linearprofile_surface_tpfa params.input \ - -Grid.File grids/linear_surface.msh \ - -Vtk.OutputName test_md_facet_1p1p_linearprofile_surface_xi1_tpfa") - -dumux_add_test(NAME test_md_facet_1p1p_linearprofile_xi1_mpfa - LABELS multidomain multidomain_facet 1p - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND )" - TARGET test_md_facet_1p1p_linearprofile_mpfa - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1p1p_linearprofile_tpfa_bulk-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_linearprofile_xi1_mpfa_bulk-00001.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1p1p_linearprofile_tpfa_lowdim-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_linearprofile_xi1_mpfa_lowdim-00001.vtp - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_linearprofile_mpfa params.input \ - -Vtk.OutputName test_md_facet_1p1p_linearprofile_xi1_mpfa") - -dumux_add_test(NAME test_md_facet_1p1p_linearprofile_xi066_mpfa - LABELS multidomain multidomain_facet 1p - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND )" - TARGET test_md_facet_1p1p_linearprofile_mpfa - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1p1p_linearprofile_tpfa_bulk-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_linearprofile_xi066_mpfa_bulk-00001.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1p1p_linearprofile_tpfa_lowdim-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_linearprofile_xi066_mpfa_lowdim-00001.vtp - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_linearprofile_mpfa params.input \ - -FacetCoupling.Xi 0.66 \ - -Vtk.OutputName test_md_facet_1p1p_linearprofile_xi066_mpfa") - -dumux_add_test(NAME test_md_facet_1p1p_linearprofile_surface_xi1_mpfa - LABELS multidomain multidomain_facet 1p - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND )" - TARGET test_md_facet_1p1p_linearprofile_surface_mpfa - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1p1p_linearprofile_surface_tpfa_bulk-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_linearprofile_surface_xi1_mpfa_bulk-00001.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1p1p_linearprofile_surface_tpfa_lowdim-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_linearprofile_surface_xi1_mpfa_lowdim-00001.vtp - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_linearprofile_surface_mpfa params.input \ - -Grid.File grids/linear_surface.msh \ - -Vtk.OutputName test_md_facet_1p1p_linearprofile_surface_xi1_mpfa") +file(GLOB DUMUX_TEST_MULTIDOMAIN_FACET_1P_1P_LINEARPROFILE_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_MULTIDOMAIN_FACET_1P_1P_LINEARPROFILE_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/multidomain/facet/1p_1p/linearprofile) diff --git a/test/multidomain/facet/1p_1p/linearprofile/grids/CMakeLists.txt b/test/multidomain/facet/1p_1p/linearprofile/grids/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/test/multidomain/facet/1p_1p/threedomain/CMakeLists.txt b/test/multidomain/facet/1p_1p/threedomain/CMakeLists.txt index 09e533905b8020d755cb00074dec05ca3cb23c84..ead577eb0efc3be72420cad5ff971a9e956bd059 100644 --- a/test/multidomain/facet/1p_1p/threedomain/CMakeLists.txt +++ b/test/multidomain/facet/1p_1p/threedomain/CMakeLists.txt @@ -1,59 +1,5 @@ -dune_symlink_to_source_files(FILES "grids" "params.input") +add_subdirectory(grids) -dumux_add_test(NAME test_md_facet_1p1p_threedomain_tpfa - LABELS multidomain multidomain_facet 1p - COMPILE_DEFINITIONS BULKTYPETAG=Dumux::Properties::TTag::OnePBulkTpfa - COMPILE_DEFINITIONS FACETTYPETAG=Dumux::Properties::TTag::OnePFacetTpfa - COMPILE_DEFINITIONS EDGETYPETAG=Dumux::Properties::TTag::OnePEdgeTpfa - SOURCES main.cc - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND )" - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1p1p_threedomain_tpfa_bulk-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_threedomain_tpfa_bulk-00001.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1p1p_threedomain_tpfa_facet-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_threedomain_tpfa_facet-00001.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1p1p_threedomain_tpfa_edge-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_threedomain_tpfa_edge-00001.vtp - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_threedomain_tpfa params.input - -Vtk.OutputName test_md_facet_1p1p_threedomain_tpfa") - -# DO not test mpfa yet because it is too inefficient. -# As soon as grid-wide flux variables caching is supported in multidomain -# simulations we can probably include this test as it will speed it up significantly -# TODO create reference solutions -# dumux_add_test(NAME test_md_facet_1p1p_threedomain_mpfa -# LABELS multidomain multidomain_facet 1p -# COMPILE_DEFINITIONS BULKTYPETAG=Dumux::Properties::TTag::OnePBulkMpfa -# COMPILE_DEFINITIONS FACETTYPETAG=Dumux::Properties::TTag::OnePFacetMpfa -# COMPILE_DEFINITIONS EDGETYPETAG=Dumux::Properties::TTag::OnePEdgeMpfa -# SOURCES main.cc -# CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND )" -# COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py -# CMD_ARGS --script fuzzy -# --files ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1p1p_threedomain_mpfa_bulk-reference.vtu -# ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_threedomain_mpfa_bulk-00001.vtu -# ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1p1p_threedomain_tpfa_facet-reference.vtu -# ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_threedomain_mpfa_facet-00001.vtu -# ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1p1p_threedomain_mpfa_edge-reference.vtp -# ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_threedomain_mpfa_edge-00001.vtp -# --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_threedomain_mpfa params.input -# -Vtk.OutputName test_md_facet_1p1p_threedomain_mpfa") - -dumux_add_test(NAME test_md_facet_1p1p_threedomain_box - LABELS multidomain multidomain_facet 1p - COMPILE_DEFINITIONS BULKTYPETAG=Dumux::Properties::TTag::OnePBulkBox - COMPILE_DEFINITIONS FACETTYPETAG=Dumux::Properties::TTag::OnePFacetBox - COMPILE_DEFINITIONS EDGETYPETAG=Dumux::Properties::TTag::OnePEdgeBox - SOURCES main.cc - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND )" - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1p1p_threedomain_box_bulk-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_threedomain_box_bulk-00001.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1p1p_threedomain_box_facet-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_threedomain_box_facet-00001.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1p1p_threedomain_box_edge-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_threedomain_box_edge-00001.vtp - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1p1p_threedomain_box params.input - -Vtk.OutputName test_md_facet_1p1p_threedomain_box") +file(GLOB DUMUX_TEST_MULTIDOMAIN_FACET_1P_1P_THREEDOMAIN_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_MULTIDOMAIN_FACET_1P_1P_THREEDOMAIN_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/multidomain/facet/1p_1p/threedomain) diff --git a/test/multidomain/facet/1p_1p/threedomain/grids/CMakeLists.txt b/test/multidomain/facet/1p_1p/threedomain/grids/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/test/multidomain/facet/1pnc_1pnc/CMakeLists.txt b/test/multidomain/facet/1pnc_1pnc/CMakeLists.txt index b445871eeebd4d277fa59e2a9c807cafa645e451..a9b76a983a0c85ed100aabb7285e731ee022f5a4 100644 --- a/test/multidomain/facet/1pnc_1pnc/CMakeLists.txt +++ b/test/multidomain/facet/1pnc_1pnc/CMakeLists.txt @@ -1,218 +1,5 @@ -dune_symlink_to_source_files(FILES "grids" "params.input") +add_subdirectory(grids) -dumux_add_test(NAME test_md_facet_1pnc1pnc_tpfa - SOURCES main.cc - LABELS multidomain multidomain_facet 1pnc - COMPILE_DEFINITIONS BULKTYPETAG=OnePNCBulkTpfa - COMPILE_DEFINITIONS FACETTYPETAG=OnePNCFacetTpfa - COMPILE_DEFINITIONS DIMWORLD=2 - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND )" - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1pnc1pnc_tpfa_bulk-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1pnc1pnc_tpfa_bulk-00018.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1pnc1pnc_tpfa_facet-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1pnc1pnc_tpfa_facet-00018.vtp - --zeroThreshold {"delp":1e-3} - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1pnc1pnc_tpfa params.input -Vtk.OutputName test_md_facet_1pnc1pnc_tpfa") - -dumux_add_test(NAME test_md_facet_1pnc1pnc_mpfa - SOURCES main.cc - LABELS multidomain multidomain_facet 1pnc - COMPILE_DEFINITIONS BULKTYPETAG=OnePNCBulkMpfa - COMPILE_DEFINITIONS FACETTYPETAG=OnePNCFacetTpfa - COMPILE_DEFINITIONS DIMWORLD=2 - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND )" - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1pnc1pnc_tpfa_bulk-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1pnc1pnc_mpfa_bulk-00018.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1pnc1pnc_tpfa_facet-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1pnc1pnc_mpfa_facet-00018.vtp - --zeroThreshold {"delp":1e-3} - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1pnc1pnc_mpfa params.input -Vtk.OutputName test_md_facet_1pnc1pnc_mpfa") - -dumux_add_test(NAME test_md_facet_1pnc1pnc_box - SOURCES main.cc - LABELS multidomain multidomain_facet 1pnc - COMPILE_DEFINITIONS BULKTYPETAG=OnePNCBulkBox - COMPILE_DEFINITIONS FACETTYPETAG=OnePNCFacetBox - COMPILE_DEFINITIONS DIMWORLD=2 - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND )" - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1pnc1pnc_box_bulk-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1pnc1pnc_box_bulk-00018.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1pnc1pnc_box_facet-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1pnc1pnc_box_facet-00018.vtp - --zeroThreshold {"delp":1e-3} - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1pnc1pnc_box params.input -Vtk.OutputName test_md_facet_1pnc1pnc_box") - -dumux_add_test(NAME test_md_facet_1pnc1pnc_box_mixedbcs - SOURCES main.cc - LABELS multidomain multidomain_facet 1pnc - COMPILE_DEFINITIONS BULKTYPETAG=OnePNCBulkBox - COMPILE_DEFINITIONS FACETTYPETAG=OnePNCFacetBox - COMPILE_DEFINITIONS DIMWORLD=2 - COMPILE_DEFINITIONS USEMIXEDBCS=true - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND )" - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1pnc1pnc_box_mixedbcs_bulk-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1pnc1pnc_box_mixedbcs_bulk-00018.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1pnc1pnc_box_mixedbcs_facet-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1pnc1pnc_box_mixedbcs_facet-00018.vtp - --zeroThreshold {"delp":1e-3} - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1pnc1pnc_box_mixedbcs params.input -Vtk.OutputName test_md_facet_1pnc1pnc_box_mixedbcs") - -dumux_add_test(NAME test_md_facet_1pncni1pncni_tpfa - SOURCES main.cc - LABELS multidomain multidomain_facet 1pnc - COMPILE_DEFINITIONS BULKTYPETAG=OnePNCNIBulkTpfa - COMPILE_DEFINITIONS FACETTYPETAG=OnePNCNIFacetTpfa - COMPILE_DEFINITIONS DIMWORLD=2 - COMPILE_DEFINITIONS BULKGRID=Dune::ALUGrid<2,2,Dune::cube,Dune::nonconforming> - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND )" - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1pncni1pncni_tpfa_bulk-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1pncni1pncni_tpfa_bulk-00019.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1pncni1pncni_tpfa_facet-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1pncni1pncni_tpfa_facet-00019.vtp - --zeroThreshold {"delp":1e-3} - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1pncni1pncni_tpfa params.input -Vtk.OutputName test_md_facet_1pncni1pncni_tpfa") - -dumux_add_test(NAME test_md_facet_1pncni1pncni_mpfa - SOURCES main.cc - LABELS multidomain multidomain_facet 1pnc - TIMEOUT 3600 - COMPILE_DEFINITIONS BULKTYPETAG=OnePNCNIBulkMpfa - COMPILE_DEFINITIONS FACETTYPETAG=OnePNCNIFacetTpfa - COMPILE_DEFINITIONS DIMWORLD=2 - COMPILE_DEFINITIONS BULKGRID=Dune::ALUGrid<2,2,Dune::cube,Dune::nonconforming> - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND )" - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1pncni1pncni_tpfa_bulk-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1pncni1pncni_mpfa_bulk-00019.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1pncni1pncni_tpfa_facet-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1pncni1pncni_mpfa_facet-00019.vtp - --zeroThreshold {"delp":1e-3} - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1pncni1pncni_mpfa params.input -Vtk.OutputName test_md_facet_1pncni1pncni_mpfa") - -dumux_add_test(NAME test_md_facet_1pncni1pncni_box - SOURCES main.cc - LABELS multidomain multidomain_facet 1pnc - COMPILE_DEFINITIONS BULKTYPETAG=OnePNCNIBulkBox - COMPILE_DEFINITIONS FACETTYPETAG=OnePNCNIFacetBox - COMPILE_DEFINITIONS DIMWORLD=2 - COMPILE_DEFINITIONS BULKGRID=Dune::ALUGrid<2,2,Dune::cube,Dune::nonconforming> - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND )" - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1pncni1pncni_box_bulk-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1pncni1pncni_box_bulk-00019.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1pncni1pncni_box_facet-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1pncni1pncni_box_facet-00019.vtp - --zeroThreshold {"delp":1e-3} - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1pncni1pncni_box params.input -Vtk.OutputName test_md_facet_1pncni1pncni_box") - - -dumux_add_test(NAME test_md_facet_1pnc1pnc_surface_tpfa - SOURCES main.cc - LABELS multidomain multidomain_facet 1pnc - COMPILE_DEFINITIONS BULKTYPETAG=OnePNCBulkTpfa - COMPILE_DEFINITIONS FACETTYPETAG=OnePNCFacetTpfa - COMPILE_DEFINITIONS DIMWORLD=3 - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND )" - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1pnc1pnc_surface_tpfa_bulk-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1pnc1pnc_surface_tpfa_bulk-00018.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1pnc1pnc_surface_tpfa_facet-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1pnc1pnc_surface_tpfa_facet-00018.vtp - --zeroThreshold {"delp":1e-3} - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1pnc1pnc_surface_tpfa params.input -Vtk.OutputName test_md_facet_1pnc1pnc_surface_tpfa -Grid.File grids/square_surface.msh") - -dumux_add_test(NAME test_md_facet_1pnc1pnc_surface_mpfa - SOURCES main.cc - LABELS multidomain multidomain_facet 1pnc - COMPILE_DEFINITIONS BULKTYPETAG=OnePNCBulkMpfa - COMPILE_DEFINITIONS FACETTYPETAG=OnePNCFacetTpfa - COMPILE_DEFINITIONS DIMWORLD=3 - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND )" - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --zeroThreshold {"delp":1e-8} - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1pnc1pnc_surface_tpfa_bulk-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1pnc1pnc_surface_mpfa_bulk-00018.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1pnc1pnc_surface_tpfa_facet-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1pnc1pnc_surface_mpfa_facet-00018.vtp - --zeroThreshold {"delp":1e-3} - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1pnc1pnc_surface_mpfa params.input -Vtk.OutputName test_md_facet_1pnc1pnc_surface_mpfa -Grid.File grids/square_surface.msh") - -dumux_add_test(NAME test_md_facet_1pnc1pnc_surface_box - SOURCES main.cc - LABELS multidomain multidomain_facet 1pnc - COMPILE_DEFINITIONS BULKTYPETAG=OnePNCBulkBox - COMPILE_DEFINITIONS FACETTYPETAG=OnePNCFacetBox - COMPILE_DEFINITIONS DIMWORLD=3 - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND )" - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1pnc1pnc_surface_box_bulk-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1pnc1pnc_surface_box_bulk-00018.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1pnc1pnc_surface_box_facet-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1pnc1pnc_surface_box_facet-00018.vtp - --zeroThreshold {"delp":1e-3} - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1pnc1pnc_surface_box params.input -Vtk.OutputName test_md_facet_1pnc1pnc_surface_box -Grid.File grids/square_surface.msh") - -dumux_add_test(NAME test_md_facet_1pncni1pncni_surface_tpfa - SOURCES main.cc - LABELS multidomain multidomain_facet 1pnc - COMPILE_DEFINITIONS BULKTYPETAG=OnePNCNIBulkTpfa - COMPILE_DEFINITIONS FACETTYPETAG=OnePNCNIFacetTpfa - COMPILE_DEFINITIONS DIMWORLD=3 - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND )" - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1pncni1pncni_surface_tpfa_bulk-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1pncni1pncni_surface_tpfa_bulk-00019.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1pncni1pncni_surface_tpfa_facet-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1pncni1pncni_surface_tpfa_facet-00019.vtp - --zeroThreshold {"delp":1e-3} - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1pncni1pncni_surface_tpfa params.input -Vtk.OutputName test_md_facet_1pncni1pncni_surface_tpfa -Grid.File grids/square_surface.msh") - -dumux_add_test(NAME test_md_facet_1pncni1pncni_surface_mpfa - SOURCES main.cc - LABELS multidomain multidomain_facet 1pnc - TIMEOUT 3600 - COMPILE_DEFINITIONS BULKTYPETAG=OnePNCNIBulkMpfa - COMPILE_DEFINITIONS FACETTYPETAG=OnePNCNIFacetTpfa - COMPILE_DEFINITIONS DIMWORLD=3 - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND )" - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --zeroThreshold {"delp":1e-8} - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1pncni1pncni_surface_tpfa_bulk-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1pncni1pncni_surface_mpfa_bulk-00020.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1pncni1pncni_surface_tpfa_facet-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1pncni1pncni_surface_mpfa_facet-00020.vtp - --zeroThreshold {"delp":1e-3} - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1pncni1pncni_surface_mpfa params.input -Vtk.OutputName test_md_facet_1pncni1pncni_surface_mpfa -Grid.File grids/square_surface.msh") - -dumux_add_test(NAME test_md_facet_1pncni1pncni_surface_box - SOURCES main.cc - LABELS multidomain multidomain_facet 1pnc - COMPILE_DEFINITIONS BULKTYPETAG=OnePNCNIBulkBox - COMPILE_DEFINITIONS FACETTYPETAG=OnePNCNIFacetBox - COMPILE_DEFINITIONS DIMWORLD=3 - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND )" - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1pncni1pncni_surface_box_bulk-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1pncni1pncni_surface_box_bulk-00019.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_1pncni1pncni_surface_box_facet-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1pncni1pncni_surface_box_facet-00019.vtp - --zeroThreshold {"delp":1e-3} - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_1pncni1pncni_surface_box params.input -Vtk.OutputName test_md_facet_1pncni1pncni_surface_box -Grid.File grids/square_surface.msh") +file(GLOB DUMUX_TEST_MULTIDOMAIN_FACET_1PNC_1PNC_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_MULTIDOMAIN_FACET_1PNC_1PNC_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/multidomain/facet/1pnc_1pnc) diff --git a/test/multidomain/facet/1pnc_1pnc/grids/CMakeLists.txt b/test/multidomain/facet/1pnc_1pnc/grids/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/test/multidomain/facet/CMakeLists.txt b/test/multidomain/facet/CMakeLists.txt index 38038164b2bee5a5ba93d2111ac9c0040b593f2c..13ac090e6db5b4af2c1502d2b00ce51fd415be42 100644 --- a/test/multidomain/facet/CMakeLists.txt +++ b/test/multidomain/facet/CMakeLists.txt @@ -1,107 +1,3 @@ add_subdirectory(1p_1p) add_subdirectory(1pnc_1pnc) add_subdirectory(tracer_tracer) - -dune_symlink_to_source_files(FILES "grid.msh" "grid2.msh" "test_gridmanager.input" "test_vertexmapper.input" "test_couplingmapper_boundary.input" "2d_grid.msh" "3d_grid.msh") - -dumux_add_test(NAME test_facetgridmanager_alu - LABELS multidomain multidomain_facet - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND )" - COMPILE_DEFINITIONS BULKGRIDTYPE=Dune::ALUGrid<3,3,Dune::simplex,Dune::conforming> - SOURCES test_gridmanager.cc - COMMAND ./test_facetgridmanager_alu - CMD_ARGS test_gridmanager.input) - -dumux_add_test(NAME test_facetgridmanager_ug - LABELS multidomain multidomain_facet - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-uggrid_FOUND )" - COMPILE_DEFINITIONS BULKGRIDTYPE=Dune::UGGrid<3> - SOURCES test_gridmanager.cc - COMMAND ./test_facetgridmanager_ug - CMD_ARGS test_gridmanager.input) - -dumux_add_test(NAME test_facetcouplingmapper_tpfa_alu - LABELS multidomain multidomain_facet - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND )" - COMPILE_DEFINITIONS BULKGRIDTYPE=Dune::ALUGrid<3,3,Dune::simplex,Dune::conforming> - SOURCES test_facetcouplingmapper.cc - COMMAND ./test_facetcouplingmapper_tpfa_alu - CMD_ARGS test_gridmanager.input) - -dumux_add_test(NAME test_facetcouplingmapper_tpfa_ug - LABELS multidomain multidomain_facet - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-uggrid_FOUND )" - COMPILE_DEFINITIONS BULKGRIDTYPE=Dune::UGGrid<3> - SOURCES test_facetcouplingmapper.cc - COMMAND ./test_facetcouplingmapper_tpfa_ug - CMD_ARGS test_gridmanager.input) - -dumux_add_test(NAME test_facetcouplingmapper_mpfa_alu - LABELS multidomain multidomain_facet - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND )" - COMPILE_DEFINITIONS BULKGRIDTYPE=Dune::ALUGrid<3,3,Dune::simplex,Dune::conforming> - COMPILE_DEFINITIONS USEMPFAINBULK=true - SOURCES test_facetcouplingmapper.cc - COMMAND ./test_facetcouplingmapper_mpfa_alu - CMD_ARGS test_gridmanager.input) - -dumux_add_test(NAME test_facetcouplingmapper_mpfa_ug - LABELS multidomain multidomain_facet - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-uggrid_FOUND )" - COMPILE_DEFINITIONS BULKGRIDTYPE=Dune::UGGrid<3> - COMPILE_DEFINITIONS USEMPFAINBULK=true - SOURCES test_facetcouplingmapper.cc - COMMAND ./test_facetcouplingmapper_mpfa_ug - CMD_ARGS test_gridmanager.input) - -dumux_add_test(NAME test_facetcouplingmapper_box_alu - LABELS multidomain facet - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND )" - COMPILE_DEFINITIONS BULKGRIDTYPE=Dune::ALUGrid<3,3,Dune::simplex,Dune::conforming> - COMPILE_DEFINITIONS USEBOXINBULK=true - SOURCES test_facetcouplingmapper.cc - COMMAND ./test_facetcouplingmapper_box_alu - CMD_ARGS test_gridmanager.input) - -dumux_add_test(NAME test_facetcouplingmapper_box_ug - LABELS multidomain multidomain_facet - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-uggrid_FOUND )" - COMPILE_DEFINITIONS BULKGRIDTYPE=Dune::UGGrid<3> - COMPILE_DEFINITIONS USEBOXINBULK=true - SOURCES test_facetcouplingmapper.cc - COMMAND ./test_facetcouplingmapper_box_ug - CMD_ARGS test_gridmanager.input) - -dumux_add_test(NAME test_facetcouplingmapper_tpfa_boundary_alu - LABELS multidomain multidomain_facet - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND )" - COMPILE_DEFINITIONS BULKGRIDTYPE=Dune::ALUGrid<2,2,Dune::simplex,Dune::conforming> - SOURCES test_facetcouplingmapper_boundary.cc - COMMAND ./test_facetcouplingmapper_tpfa_boundary_alu - CMD_ARGS test_couplingmapper_boundary.input) - -dumux_add_test(NAME test_facetcouplingmapper_tpfa_boundary_ug - LABELS multidomain multidomain_facet - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-uggrid_FOUND )" - COMPILE_DEFINITIONS BULKGRIDTYPE=Dune::UGGrid<2> - SOURCES test_facetcouplingmapper_boundary.cc - COMMAND ./test_facetcouplingmapper_tpfa_boundary_ug - CMD_ARGS test_couplingmapper_boundary.input) - -dumux_add_test(NAME test_vertexmapper_alu_3d - LABELS multidomain multidomain_facet - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND )" - COMPILE_DEFINITIONS BULKGRIDTYPE=Dune::ALUGrid<3,3,Dune::simplex,Dune::conforming> - COMPILE_DEFINITIONS FACETGRIDTYPE=Dune::FoamGrid<2,3> - SOURCES test_vertexmapper.cc - COMMAND ./test_vertexmapper_alu_3d - CMD_ARGS test_vertexmapper.input -Grid.File 3d_grid.msh) - -dumux_add_test(NAME test_vertexmapper_alu_2d - LABELS multidomain multidomain_facet - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND )" - COMPILE_DEFINITIONS BULKGRIDTYPE=Dune::ALUGrid<2,2,Dune::simplex,Dune::conforming> - COMPILE_DEFINITIONS FACETGRIDTYPE=Dune::FoamGrid<1,2> - SOURCES test_vertexmapper.cc - COMMAND ./test_vertexmapper_alu_2d - CMD_ARGS test_vertexmapper.input) diff --git a/test/multidomain/facet/tracer_tracer/CMakeLists.txt b/test/multidomain/facet/tracer_tracer/CMakeLists.txt index f6407da2173c87961e8930a474ee541a03025556..8bdfb397fd85d8119ba485f5274a1794d5061559 100644 --- a/test/multidomain/facet/tracer_tracer/CMakeLists.txt +++ b/test/multidomain/facet/tracer_tracer/CMakeLists.txt @@ -1,68 +1,5 @@ -dune_symlink_to_source_files(FILES "grids" "params.input") +add_subdirectory(grids) -dumux_add_test(NAME test_md_facet_tracertracer_tpfa - LABELS multidomain multidomain_facet tracer - SOURCES main.cc - COMPILE_DEFINITIONS ONEPBULKTYPETAG=OnePBulkTpfa - COMPILE_DEFINITIONS ONEPLOWDIMTYPETAG=OnePLowDimTpfa - COMPILE_DEFINITIONS TRACERBULKTYPETAG=TracerBulkTpfa - COMPILE_DEFINITIONS TRACERLOWDIMTYPETAG=TracerLowDimTpfa - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND )" - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_tracertracer_tpfa_onep_bulk-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_tracertracer_tpfa_onep_bulk-00000.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_tracertracer_tpfa_onep_lowdim-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_tracertracer_tpfa_onep_lowdim-00000.vtp - ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_tracertracer_tpfa_tracer_bulk-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_tracertracer_tpfa_tracer_bulk-00010.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_tracertracer_tpfa_tracer_lowdim-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_tracertracer_tpfa_tracer_lowdim-00010.vtp - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_tracertracer_tpfa params.input \ - -Vtk.OutputName test_md_facet_tracertracer_tpfa \ - -TimeLoop.TEnd 5e4") - -dumux_add_test(NAME test_md_facet_tracertracer_mpfa - LABELS multidomain multidomain_facet tracer - SOURCES main.cc - COMPILE_DEFINITIONS ONEPBULKTYPETAG=OnePBulkMpfa - COMPILE_DEFINITIONS ONEPLOWDIMTYPETAG=OnePLowDimMpfa - COMPILE_DEFINITIONS TRACERBULKTYPETAG=TracerBulkMpfa - COMPILE_DEFINITIONS TRACERLOWDIMTYPETAG=TracerLowDimMpfa - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND )" - TIMEOUT 1500 - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_tracertracer_mpfa_onep_bulk-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_tracertracer_mpfa_onep_bulk-00000.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_tracertracer_mpfa_onep_lowdim-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_tracertracer_mpfa_onep_lowdim-00000.vtp - ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_tracertracer_mpfa_tracer_bulk-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_tracertracer_mpfa_tracer_bulk-00010.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_tracertracer_mpfa_tracer_lowdim-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_tracertracer_mpfa_tracer_lowdim-00010.vtp - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_tracertracer_mpfa params.input \ - -Vtk.OutputName test_md_facet_tracertracer_mpfa \ - -TimeLoop.TEnd 5e4") - -dumux_add_test(NAME test_md_facet_tracertracer_box - LABELS multidomain multidomain_facet tracer - SOURCES main.cc - COMPILE_DEFINITIONS ONEPBULKTYPETAG=OnePBulkBox - COMPILE_DEFINITIONS ONEPLOWDIMTYPETAG=OnePLowDimBox - COMPILE_DEFINITIONS TRACERBULKTYPETAG=TracerBulkBox - COMPILE_DEFINITIONS TRACERLOWDIMTYPETAG=TracerLowDimBox - CMAKE_GUARD "( dune-foamgrid_FOUND AND dune-alugrid_FOUND )" - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_tracertracer_box_onep_bulk-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_tracertracer_box_onep_bulk-00000.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_tracertracer_box_onep_lowdim-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_tracertracer_box_onep_lowdim-00000.vtp - ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_tracertracer_box_tracer_bulk-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_tracertracer_box_tracer_bulk-00010.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_facet_tracertracer_box_tracer_lowdim-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_tracertracer_box_tracer_lowdim-00010.vtp - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_facet_tracertracer_box params.input \ - -Vtk.OutputName test_md_facet_tracertracer_box \ - -TimeLoop.TEnd 5e4") +file(GLOB DUMUX_TEST_MULTIDOMAIN_FACET_TRACER_TRACER_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_MULTIDOMAIN_FACET_TRACER_TRACER_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/multidomain/facet/tracer_tracer) diff --git a/test/multidomain/facet/tracer_tracer/grids/CMakeLists.txt b/test/multidomain/facet/tracer_tracer/grids/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/test/multidomain/poromechanics/el1p/CMakeLists.txt b/test/multidomain/poromechanics/el1p/CMakeLists.txt index cc801060a83097a7dc42c6fbd18acef5e1014c6f..1c6ec02963fab76c2e1a63883f1743119fa78840 100644 --- a/test/multidomain/poromechanics/el1p/CMakeLists.txt +++ b/test/multidomain/poromechanics/el1p/CMakeLists.txt @@ -1,14 +1,3 @@ -dune_symlink_to_source_files(FILES "params.input") - -dumux_add_test(NAME test_md_poromechanics_el1p - LABELS multidomain poromechanics 1p poroelastic - SOURCES main.cc - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_poromechanics_el1p_1p-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_poromechanics_el1p_onep-00001.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_poromechanics_el1p_poroelastic-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_poromechanics_el1p_poroelastic-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_poromechanics_el1p params.input - -Vtk.OutputName test_md_poromechanics_el1p" - --zeroThreshold {"u":1e-14}) +file(GLOB DUMUX_TEST_MULTIDOMAIN_POROMECHANICS_EL1P_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_MULTIDOMAIN_POROMECHANICS_EL1P_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/multidomain/poromechanics/el1p) diff --git a/test/multidomain/poromechanics/el2p/CMakeLists.txt b/test/multidomain/poromechanics/el2p/CMakeLists.txt index f0e1e2f1e6c426164dddd473bd0294c62642a7ae..4f3c76bace362fc6b9af4780b1419eee7caddd54 100644 --- a/test/multidomain/poromechanics/el2p/CMakeLists.txt +++ b/test/multidomain/poromechanics/el2p/CMakeLists.txt @@ -1,16 +1,3 @@ -dune_symlink_to_source_files(FILES "params.input") - -dumux_add_test(NAME test_md_poromechanics_el2p - LABELS multidomain poromechanics 2p poroelastic - SOURCES main.cc - CMAKE_GUARD HAVE_UMFPACK - TIMEOUT 3600 - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_md_poromechanics_el2p_2p-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_poromechanics_el2p_twop-00010.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_md_poromechanics_el2p_poroelastic-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_md_poromechanics_el2p_poroelastic-00010.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_md_poromechanics_el2p params.input - -Vtk.OutputName test_md_poromechanics_el2p" - --zeroThreshold {"u":1e-14}) +file(GLOB DUMUX_TEST_MULTIDOMAIN_POROMECHANICS_EL2P_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_MULTIDOMAIN_POROMECHANICS_EL2P_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/multidomain/poromechanics/el2p) diff --git a/test/nonlinear/findscalarroot/CMakeLists.txt b/test/nonlinear/findscalarroot/CMakeLists.txt index 004545b738f41d14f80c12ced54202de6cafaf80..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644 --- a/test/nonlinear/findscalarroot/CMakeLists.txt +++ b/test/nonlinear/findscalarroot/CMakeLists.txt @@ -1,2 +0,0 @@ -dumux_add_test(SOURCES test_findscalarroot.cc - LABELS unit nonlinear) diff --git a/test/nonlinear/newton/CMakeLists.txt b/test/nonlinear/newton/CMakeLists.txt index 4187ae5cab66a15cfa3ad925070af87a60174f10..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644 --- a/test/nonlinear/newton/CMakeLists.txt +++ b/test/nonlinear/newton/CMakeLists.txt @@ -1,7 +0,0 @@ -dumux_add_test(SOURCES test_newton.cc - LABELS unit nonlinear) -dumux_add_test(NAME test_newton_linesearch - TARGET test_newton - COMMAND test_newton - CMD_ARGS "-Newton.UseLineSearch" "true" - LABELS unit nonlinear) diff --git a/test/porenetwork/1p/CMakeLists.txt b/test/porenetwork/1p/CMakeLists.txt index 5d5bb3df63a3e6908df287ed13e8f62d46655574..c3b64c029bdff0e1288e152e26badebf6ae72de4 100644 --- a/test/porenetwork/1p/CMakeLists.txt +++ b/test/porenetwork/1p/CMakeLists.txt @@ -1,27 +1,7 @@ -add_subdirectory(nonisothermal) +add_subdirectory(grids) add_subdirectory(noncreepingflow) +add_subdirectory(nonisothermal) -add_input_file_links() -dune_symlink_to_source_files(FILES grids) - -dumux_add_test(NAME test_pnm_1p - SOURCES main.cc - LABELS porenetwork - COMPILE_DEFINITIONS ISOTHERMAL=1 - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMAKE_GUARD "( dune-foamgrid_FOUND AND HAVE_UMFPACK )" - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_pnm_1p-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_pnm_1p-00000.vtp - --command "${CMAKE_CURRENT_BINARY_DIR}/test_pnm_1p") - -dumux_add_test(NAME test_pnm_1p_gravity - TARGET test_pnm_1p - LABELS porenetwork - COMPILE_DEFINITIONS ISOTHERMAL=1 - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMAKE_GUARD "( dune-foamgrid_FOUND AND HAVE_UMFPACK )" - CMD_ARGS --script fuzzy --zeroThreshold {"velocity_liq \(m/s\)":1e-15,"volumeFlux":1e-25} - --files ${CMAKE_SOURCE_DIR}/test/references/test_pnm_1p_gravity-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_pnm_1p_gravity-00000.vtp - --command "${CMAKE_CURRENT_BINARY_DIR}/test_pnm_1p params_hydrostatic_pressure.input") +file(GLOB DUMUX_TEST_PORENETWORK_1P_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_PORENETWORK_1P_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/porenetwork/1p) diff --git a/test/porenetwork/1p/grids/CMakeLists.txt b/test/porenetwork/1p/grids/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/test/porenetwork/1p/noncreepingflow/CMakeLists.txt b/test/porenetwork/1p/noncreepingflow/CMakeLists.txt index e1833eb83345d30d4ca92f531ba82a805332baa2..53376440728e0d10bfc71a116e72c1ec7da255cf 100644 --- a/test/porenetwork/1p/noncreepingflow/CMakeLists.txt +++ b/test/porenetwork/1p/noncreepingflow/CMakeLists.txt @@ -1,14 +1,5 @@ add_subdirectory(nonisothermal) -add_input_file_links() - -dumux_add_test(NAME test_pnm_1p_noncreeping_flow - SOURCES main.cc - LABELS porenetwork - COMPILE_DEFINITIONS ISOTHERMAL=1 - CMAKE_GUARD "( dune-foamgrid_FOUND AND HAVE_UMFPACK )" - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_pnm_1p_noncreepingflow-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_pnm_1p_noncreepingflow-00000.vtp - --command "${CMAKE_CURRENT_BINARY_DIR}/test_pnm_1p_noncreeping_flow") +file(GLOB DUMUX_TEST_PORENETWORK_1P_NONCREEPINGFLOW_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_PORENETWORK_1P_NONCREEPINGFLOW_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/porenetwork/1p/noncreepingflow) diff --git a/test/porenetwork/1p/noncreepingflow/nonisothermal/CMakeLists.txt b/test/porenetwork/1p/noncreepingflow/nonisothermal/CMakeLists.txt index 06673ad59546f3ec652312fa7492ee9e6b3baba1..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644 --- a/test/porenetwork/1p/noncreepingflow/nonisothermal/CMakeLists.txt +++ b/test/porenetwork/1p/noncreepingflow/nonisothermal/CMakeLists.txt @@ -1,12 +0,0 @@ -add_input_file_links() - -dumux_add_test(NAME test_pnm_1pni_noncreeping_flow - SOURCES main.cc - LABELS porenetwork - COMPILE_DEFINITIONS ISOTHERMAL=0 - CMAKE_GUARD "( dune-foamgrid_FOUND AND HAVE_UMFPACK )" - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_pnm_1pni_noncreepingflow-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_pnm_1pni_noncreepingflow-00014.vtp - --command "${CMAKE_CURRENT_BINARY_DIR}/test_pnm_1pni_noncreeping_flow") diff --git a/test/porenetwork/1p/nonisothermal/CMakeLists.txt b/test/porenetwork/1p/nonisothermal/CMakeLists.txt index 1335a122a8233d33b177d2e6e7a48facef49826a..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644 --- a/test/porenetwork/1p/nonisothermal/CMakeLists.txt +++ b/test/porenetwork/1p/nonisothermal/CMakeLists.txt @@ -1,12 +0,0 @@ -add_input_file_links() - -dumux_add_test(NAME test_pnm_1pni - SOURCES main.cc - LABELS porenetwork - COMPILE_DEFINITIONS ISOTHERMAL=0 - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMAKE_GUARD "( dune-foamgrid_FOUND AND HAVE_UMFPACK )" - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_pnm_1pni-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_pnm_1pni-00014.vtp - --command "${CMAKE_CURRENT_BINARY_DIR}/test_pnm_1pni") diff --git a/test/porenetwork/1pnc/CMakeLists.txt b/test/porenetwork/1pnc/CMakeLists.txt index 8674b7890d0baa6c1587f4b1f4f0ee7c45f99d7d..8097cd1799b05c37688a0c83d740fefe7406d438 100644 --- a/test/porenetwork/1pnc/CMakeLists.txt +++ b/test/porenetwork/1pnc/CMakeLists.txt @@ -1,35 +1,3 @@ -add_input_file_links() - -add_executable(test_pnm_1p2c EXCLUDE_FROM_ALL main.cc) -target_compile_definitions(test_pnm_1p2c PRIVATE ISOTHERMAL=1) - -dumux_add_test(NAME test_pnm_1p2c_advection - TARGET test_pnm_1p2c - LABELS porenetwork - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMAKE_GUARD "( dune-foamgrid_FOUND AND HAVE_UMFPACK )" - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_pnm_1p2c-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_pnm_1p2c-00055.vtp - --command "${CMAKE_CURRENT_BINARY_DIR}/test_pnm_1p2c") - -dumux_add_test(NAME test_pnm_1p2c_diffusion - TARGET test_pnm_1p2c - LABELS porenetwork - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMAKE_GUARD "( dune-foamgrid_FOUND AND HAVE_UMFPACK )" - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_pnm_1p2c_diffusion-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_pnm_1p2c_diffusion-00054.vtp - --command "${CMAKE_CURRENT_BINARY_DIR}/test_pnm_1p2c params_diffusion.input") - -dumux_add_test(NAME test_pnm_1p2cni - SOURCES main.cc - LABELS porenetwork - COMPILE_DEFINITIONS ISOTHERMAL=0 - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMAKE_GUARD "( dune-foamgrid_FOUND AND HAVE_UMFPACK )" - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_pnm_1p2cni-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_pnm_1p2cni-00056.vtp - --command "${CMAKE_CURRENT_BINARY_DIR}/test_pnm_1p2cni -Problem.Name test_pnm_1p2cni") +file(GLOB DUMUX_TEST_PORENETWORK_1PNC_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_PORENETWORK_1PNC_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/porenetwork/1pnc) diff --git a/test/porenetwork/2p/CMakeLists.txt b/test/porenetwork/2p/CMakeLists.txt index ad938d1a9b1877f734a8dac672bc71d35fa1fb33..9bebf917c47c6790029bb6e4642d260bd1ead366 100644 --- a/test/porenetwork/2p/CMakeLists.txt +++ b/test/porenetwork/2p/CMakeLists.txt @@ -1,25 +1,5 @@ add_subdirectory(static) -add_input_file_links() - -dumux_add_test(NAME test_pnm_2p - SOURCES main.cc - LABELS porenetwork - COMPILE_DEFINITIONS ISOTHERMAL=1 - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMAKE_GUARD "( dune-foamgrid_FOUND AND HAVE_UMFPACK )" - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_pnm_2p-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_pnm_2p-00107.vtp - --command "${CMAKE_CURRENT_BINARY_DIR}/test_pnm_2p") - -dumux_add_test(NAME test_pnm_2pni - SOURCES main.cc - LABELS porenetwork - COMPILE_DEFINITIONS ISOTHERMAL=0 - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMAKE_GUARD "( dune-foamgrid_FOUND AND HAVE_UMFPACK )" - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_pnm_2pni-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_pnm_2pni-00133.vtp - --command "${CMAKE_CURRENT_BINARY_DIR}/test_pnm_2pni params_ni.input -Problem.Name test_pnm_2pni") +file(GLOB DUMUX_TEST_PORENETWORK_2P_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_PORENETWORK_2P_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/porenetwork/2p) diff --git a/test/porenetwork/2p/static/CMakeLists.txt b/test/porenetwork/2p/static/CMakeLists.txt index b0602ff1ee1b101ea5a9d8f6ba490d275103ba87..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644 --- a/test/porenetwork/2p/static/CMakeLists.txt +++ b/test/porenetwork/2p/static/CMakeLists.txt @@ -1,11 +0,0 @@ -add_input_file_links() - -dumux_add_test(NAME test_pnm_2p_static - SOURCES main.cc - LABELS porenetwork - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMAKE_GUARD "( dune-foamgrid_FOUND AND HAVE_UMFPACK )" - CMD_ARGS --script fuzzyData - --files ${CMAKE_SOURCE_DIR}/test/references/test_pnm_2p_static-reference.txt - ${CMAKE_CURRENT_BINARY_DIR}/test_pnm_2p_static_pc-s-curve.txt - --command "${CMAKE_CURRENT_BINARY_DIR}/test_pnm_2p_static") diff --git a/test/porousmediumflow/1p/CMakeLists.txt b/test/porousmediumflow/1p/CMakeLists.txt index 4b66f73a77d21bb734e83b1dac4c71370215bb91..f90624b7c5f8810ae42cb16ccc6212183519062d 100644 --- a/test/porousmediumflow/1p/CMakeLists.txt +++ b/test/porousmediumflow/1p/CMakeLists.txt @@ -1,11 +1,11 @@ +add_subdirectory(compressible) add_subdirectory(convergence) -add_subdirectory(pointsources) +add_subdirectory(fracture2d3d) add_subdirectory(incompressible) add_subdirectory(internaldirichlet) -add_subdirectory(compressible) -add_subdirectory(periodicbc) -add_subdirectory(fracture2d3d) add_subdirectory(isothermal) -add_subdirectory(nonisothermal) add_subdirectory(network1d3d) +add_subdirectory(nonisothermal) +add_subdirectory(periodicbc) +add_subdirectory(pointsources) add_subdirectory(rootbenchmark) diff --git a/test/porousmediumflow/1p/compressible/CMakeLists.txt b/test/porousmediumflow/1p/compressible/CMakeLists.txt index 92d3e20bd18ec89eebac2455362209d26c82966a..950841312268433b7aa20f21cae037f7aa158c03 100644 --- a/test/porousmediumflow/1p/compressible/CMakeLists.txt +++ b/test/porousmediumflow/1p/compressible/CMakeLists.txt @@ -1,2 +1,2 @@ -add_subdirectory(stationary) add_subdirectory(instationary) +add_subdirectory(stationary) diff --git a/test/porousmediumflow/1p/compressible/instationary/CMakeLists.txt b/test/porousmediumflow/1p/compressible/instationary/CMakeLists.txt index f824ba4a8f4d20d4fc5007ec33d98aa55a3f53d5..dae3414987fed57f586ecf334df68536a7dad538 100644 --- a/test/porousmediumflow/1p/compressible/instationary/CMakeLists.txt +++ b/test/porousmediumflow/1p/compressible/instationary/CMakeLists.txt @@ -1,43 +1,3 @@ -dune_symlink_to_source_files(FILES "params.input") - -# compressible instationary -dumux_add_test(NAME test_1p_compressible_instationary_tpfa - LABELS porousmediumflow 1p - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=OnePCompressibleTpfa - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p_cc-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p_compressible_instationary_tpfa-00010.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p_compressible_instationary_tpfa params.input -Problem.Name test_1p_compressible_instationary_tpfa") - -dumux_add_test(NAME test_1p_compressible_instationary_mpfa - LABELS porousmediumflow 1p - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=OnePCompressibleMpfa - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p_cc-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p_compressible_instationary_mpfa-00010.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p_compressible_instationary_mpfa params.input -Problem.Name test_1p_compressible_instationary_mpfa") - -dumux_add_test(NAME test_1p_compressible_instationary_box - LABELS porousmediumflow 1p - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=OnePCompressibleBox - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p_box-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p_compressible_instationary_box-00010.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p_compressible_instationary_box params.input -Problem.Name test_1p_compressible_instationary_box") - -dumux_add_test(NAME test_1p_compressible_instationary_tpfa_experimental - LABELS porousmediumflow 1p experimental - SOURCES main_experimental.cc - COMPILE_DEFINITIONS TYPETAG=OnePCompressibleTpfa - COMPILE_DEFINITIONS EXPERIMENTAL=1 - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p_cc-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p_compressible_instationary_tpfa_experimental-00010.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p_compressible_instationary_tpfa_experimental params.input -Problem.Name test_1p_compressible_instationary_tpfa_experimental") +file(GLOB DUMUX_TEST_POROUSMEDIUMFLOW_1P_COMPRESSIBLE_INSTATIONARY_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_POROUSMEDIUMFLOW_1P_COMPRESSIBLE_INSTATIONARY_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/porousmediumflow/1p/compressible/instationary) diff --git a/test/porousmediumflow/1p/compressible/stationary/CMakeLists.txt b/test/porousmediumflow/1p/compressible/stationary/CMakeLists.txt index 916c5679b90cc4b7bc0648ee4e1244008e6155fd..fcf7fe62f387afe046bfbe53a671175c9e2be524 100644 --- a/test/porousmediumflow/1p/compressible/stationary/CMakeLists.txt +++ b/test/porousmediumflow/1p/compressible/stationary/CMakeLists.txt @@ -1,32 +1,3 @@ -dune_symlink_to_source_files(FILES "params.input") - -# compressible stationary -dumux_add_test(NAME test_1p_compressible_stationary_tpfa - LABELS porousmediumflow 1p - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=OnePCompressibleTpfa - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p_cc-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p_compressible_stationary_tpfa-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p_compressible_stationary_tpfa params.input -Problem.Name test_1p_compressible_stationary_tpfa") - -dumux_add_test(NAME test_1p_compressible_stationary_mpfa - LABELS porousmediumflow 1p - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=OnePCompressibleMpfa - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p_cc-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p_compressible_stationary_mpfa-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p_compressible_stationary_mpfa params.input -Problem.Name test_1p_compressible_stationary_mpfa") - -dumux_add_test(NAME test_1p_compressible_stationary_box - LABELS porousmediumflow 1p - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=OnePCompressibleBox - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p_box-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p_compressible_stationary_box-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p_compressible_stationary_box params.input -Problem.Name test_1p_compressible_stationary_box") +file(GLOB DUMUX_TEST_POROUSMEDIUMFLOW_1P_COMPRESSIBLE_STATIONARY_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_POROUSMEDIUMFLOW_1P_COMPRESSIBLE_STATIONARY_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/porousmediumflow/1p/compressible/stationary) diff --git a/test/porousmediumflow/1p/convergence/analyticsolution/CMakeLists.txt b/test/porousmediumflow/1p/convergence/analyticsolution/CMakeLists.txt index a50498793eb468554f9b708aa9af7dfb01baf218..ab8049db19a93fdd0bdecabc219c13892a87d356 100644 --- a/test/porousmediumflow/1p/convergence/analyticsolution/CMakeLists.txt +++ b/test/porousmediumflow/1p/convergence/analyticsolution/CMakeLists.txt @@ -1,72 +1,3 @@ -add_input_file_links() -dune_symlink_to_source_files(FILES "convergencetest.py") - -# if UG is found, we use UG for all tests. Otherwise, we use -# YaspGrid for the tests on unstructured grids and enforce -# the tests on unstructured grids to be skipped -add_executable(test_1p_convergence_analytic_tpfa EXCLUDE_FROM_ALL main.cc) -add_executable(test_1p_convergence_analytic_mpfa EXCLUDE_FROM_ALL main.cc) -add_executable(test_1p_convergence_analytic_box EXCLUDE_FROM_ALL main.cc) - -if (dune-uggrid_FOUND) - target_compile_definitions(test_1p_convergence_analytic_tpfa PUBLIC "TYPETAG=OnePConvergenceTpfa" PUBLIC "GRIDTYPE=Dune::UGGrid<2>") - target_compile_definitions(test_1p_convergence_analytic_mpfa PUBLIC "TYPETAG=OnePConvergenceMpfa" PUBLIC "GRIDTYPE=Dune::UGGrid<2>") - target_compile_definitions(test_1p_convergence_analytic_box PUBLIC "TYPETAG=OnePConvergenceBox" PUBLIC "GRIDTYPE=Dune::UGGrid<2>") -else() - target_compile_definitions(test_1p_convergence_analytic_tpfa PUBLIC "TYPETAG=OnePConvergenceTpfa" PUBLIC "GRIDTYPE=Dune::YaspGrid<2>") - target_compile_definitions(test_1p_convergence_analytic_mpfa PUBLIC "TYPETAG=OnePConvergenceMpfa" PUBLIC "GRIDTYPE=Dune::YaspGrid<2>") - target_compile_definitions(test_1p_convergence_analytic_box PUBLIC "TYPETAG=OnePConvergenceBox" PUBLIC "GRIDTYPE=Dune::YaspGrid<2>") -endif() - -# using tpfa and structured grid with zero off-diagonal permeability entries -dumux_add_test(NAME test_1p_convergence_analytic_tpfa_structured - TARGET test_1p_convergence_analytic_tpfa - LABELS porousmediumflow 1p - COMMAND ./convergencetest.py - CMD_ARGS test_1p_convergence_analytic_tpfa - tpfa_structured params.input -Problem.C 0.0) - -# using mpfa and structured grid -dumux_add_test(NAME test_1p_convergence_analytic_mpfa_structured - TARGET test_1p_convergence_analytic_mpfa - LABELS porousmediumflow 1p - COMMAND ./convergencetest.py - CMD_ARGS test_1p_convergence_analytic_mpfa mpfa_structured) - -# using box and structured grid -dumux_add_test(NAME test_1p_convergence_analytic_box_structured - TARGET test_1p_convergence_analytic_box - LABELS porousmediumflow 1p - COMMAND ./convergencetest.py - CMD_ARGS test_1p_convergence_analytic_box box_structured) - -# tests on ustructured grids in case UG is found -if (dune-uggrid_FOUND) - # using mpfa and unstructured grid - dumux_add_test(NAME test_1p_convergence_analytic_mpfa_unstructured - TARGET test_1p_convergence_analytic_mpfa - LABELS porousmediumflow 1p - COMMAND ./convergencetest.py - CMD_ARGS test_1p_convergence_analytic_mpfa mpfa_unstructured - params.input -Grid.File ../../incompressible/grids/randomlydistorted.dgf) - - # using box and unstructured grid - dumux_add_test(NAME test_1p_convergence_analytic_box_unstructured - TARGET test_1p_convergence_analytic_box - LABELS porousmediumflow 1p - COMMAND ./convergencetest.py - CMD_ARGS test_1p_convergence_analytic_box box_unstructured - params.input -Grid.File ../../incompressible/grids/randomlydistorted.dgf) - -# otherwise define test with the same name but enforce skip -else() - dumux_add_test(NAME test_1p_convergence_analytic_mpfa_unstructured - SOURCES main.cc - CMAKE_GUARD dune-uggrid_FOUND - LABELS porousmediumflow 1p) - - dumux_add_test(NAME test_1p_convergence_analytic_box_unstructured - SOURCES main.cc - CMAKE_GUARD dune-uggrid_FOUND - LABELS porousmediumflow 1p) -endif() +file(GLOB DUMUX_TEST_POROUSMEDIUMFLOW_1P_CONVERGENCE_ANALYTICSOLUTION_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_POROUSMEDIUMFLOW_1P_CONVERGENCE_ANALYTICSOLUTION_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/porousmediumflow/1p/convergence/analyticsolution) diff --git a/test/porousmediumflow/1p/convergence/discretesolution/CMakeLists.txt b/test/porousmediumflow/1p/convergence/discretesolution/CMakeLists.txt index 65422ee2f420158a8ff0398d4b674e90327c5478..7056e1dd9fb74a39e633868f69e60196808284e2 100644 --- a/test/porousmediumflow/1p/convergence/discretesolution/CMakeLists.txt +++ b/test/porousmediumflow/1p/convergence/discretesolution/CMakeLists.txt @@ -1,41 +1,3 @@ -dune_symlink_to_source_files(FILES "params.input") - -# executable for tpfa tests -add_executable(test_1p_convergence_tpfa EXCLUDE_FROM_ALL main.cc) -target_compile_definitions(test_1p_convergence_tpfa PUBLIC "TYPETAG=OnePIncompressibleTpfa") - -# executable for box tests -add_executable(test_1p_convergence_box EXCLUDE_FROM_ALL main.cc) -target_compile_definitions(test_1p_convergence_box PUBLIC "TYPETAG=OnePIncompressibleBox") - -# using tpfa and conforming refinement -dumux_add_test(NAME test_1p_convergence_tpfa_conforming - TARGET test_1p_convergence_tpfa - CMAKE_GUARD "( dune-functions_FOUND )" - LABELS porousmediumflow 1p - COMMAND ./test_1p_convergence_tpfa - CMD_ARGS params.input -Problem.Name test_1p_convergence_tpfa_conforming) - -# using tpfa and nonconforming refinement -dumux_add_test(NAME test_1p_convergence_tpfa_nonconforming - TARGET test_1p_convergence_tpfa - CMAKE_GUARD "( dune-functions_FOUND )" - LABELS porousmediumflow 1p - COMMAND ./test_1p_convergence_tpfa - CMD_ARGS params.input -Problem.Name test_1p_convergence_tpfa_conforming) - -# using box and conforming refinement -dumux_add_test(NAME test_1p_convergence_box_conforming - TARGET test_1p_convergence_box - CMAKE_GUARD "( dune-functions_FOUND )" - LABELS porousmediumflow 1p - COMMAND ./test_1p_convergence_box - CMD_ARGS params.input -Problem.Name test_1p_convergence_box_conforming) - -# using box and nonconforming refinement -dumux_add_test(NAME test_1p_convergence_box_nonconforming - TARGET test_1p_convergence_box - CMAKE_GUARD "( dune-functions_FOUND )" - LABELS porousmediumflow 1p - COMMAND ./test_1p_convergence_box - CMD_ARGS params.input -Problem.Name test_1p_convergence_box_conforming) +file(GLOB DUMUX_TEST_POROUSMEDIUMFLOW_1P_CONVERGENCE_DISCRETESOLUTION_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_POROUSMEDIUMFLOW_1P_CONVERGENCE_DISCRETESOLUTION_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/porousmediumflow/1p/convergence/discretesolution) diff --git a/test/porousmediumflow/1p/fracture2d3d/CMakeLists.txt b/test/porousmediumflow/1p/fracture2d3d/CMakeLists.txt index f4993b197fe79bf1592562831024a6a829e8f948..14c2150e785c7f528c495e8ce4334d7e600bb376 100644 --- a/test/porousmediumflow/1p/fracture2d3d/CMakeLists.txt +++ b/test/porousmediumflow/1p/fracture2d3d/CMakeLists.txt @@ -1,37 +1,5 @@ -add_input_file_links() +add_subdirectory(grids) -dune_symlink_to_source_files(FILES grids) - -# dim < dimWorld tests with Dune::Foamgrid<2,3> -dumux_add_test(NAME test_1p_fracture2d3d_box - LABELS porousmediumflow 1p - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=FractureBox - CMAKE_GUARD dune-foamgrid_FOUND - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p_fracture2d3d_box-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p_fracture2d3d_box-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p_fracture2d3d_box params.input -Problem.Name test_1p_fracture2d3d_box") - -dumux_add_test(NAME test_1p_fracture2d3d_tpfa - LABELS porousmediumflow 1p - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=FractureCCTpfa - CMAKE_GUARD dune-foamgrid_FOUND - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p_fracture2d3d_cc-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p_fracture2d3d_tpfa-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p_fracture2d3d_tpfa params.input -Problem.Name test_1p_fracture2d3d_tpfa") - -dumux_add_test(NAME test_1p_fracture2d3d_mpfa - LABELS porousmediumflow 1p - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=FractureCCMpfa - CMAKE_GUARD dune-foamgrid_FOUND - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p_fracture2d3d_cc-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p_fracture2d3d_mpfa-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p_fracture2d3d_mpfa params.input -Problem.Name test_1p_fracture2d3d_mpfa") +file(GLOB DUMUX_TEST_POROUSMEDIUMFLOW_1P_FRACTURE2D3D_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_POROUSMEDIUMFLOW_1P_FRACTURE2D3D_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/porousmediumflow/1p/fracture2d3d) diff --git a/test/porousmediumflow/1p/fracture2d3d/grids/CMakeLists.txt b/test/porousmediumflow/1p/fracture2d3d/grids/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/test/porousmediumflow/1p/incompressible/CMakeLists.txt b/test/porousmediumflow/1p/incompressible/CMakeLists.txt index 02adbcc24585db8f2d13c44769a9fdaea54a2f93..9880514c0730aaa8e7b5cd65cc3f7904be86e546 100644 --- a/test/porousmediumflow/1p/incompressible/CMakeLists.txt +++ b/test/porousmediumflow/1p/incompressible/CMakeLists.txt @@ -1,155 +1,5 @@ -dune_symlink_to_source_files(FILES "params.input") -dune_symlink_to_source_files(FILES grids) +add_subdirectory(grids) -# using tpfa and analytical Jacobian -add_executable(test_1p_incompressible_tpfa_anadiff EXCLUDE_FROM_ALL main.cc) -target_compile_definitions(test_1p_incompressible_tpfa_anadiff PUBLIC "TYPETAG=OnePIncompressibleTpfa" "NUMDIFFMETHOD=DiffMethod::analytic") - -# using mpfa and analytical Jacobian -add_executable(test_1p_incompressible_mpfa_anadiff EXCLUDE_FROM_ALL main.cc) -target_compile_definitions(test_1p_incompressible_mpfa_anadiff PUBLIC "TYPETAG=OnePIncompressibleMpfa" "NUMDIFFMETHOD=DiffMethod::analytic") - -# using box and analytical Jacobian -add_executable(test_1p_incompressible_box_anadiff EXCLUDE_FROM_ALL main.cc) -target_compile_definitions(test_1p_incompressible_box_anadiff PUBLIC "TYPETAG=OnePIncompressibleBox" "NUMDIFFMETHOD=DiffMethod::analytic") - -# using tpfa and analytical Jacobian -dumux_add_test(NAME test_1p_incompressible_tpfa - TARGET test_1p_incompressible_tpfa_anadiff - LABELS porousmediumflow 1p - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p_cc-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p_incompressible_tpfa-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p_incompressible_tpfa_anadiff params.input -Problem.Name test_1p_incompressible_tpfa") - -# using tpfa, analytical Jacobian and quad precision -dumux_add_test(NAME test_1p_incompressible_tpfa_quad - LABELS porousmediumflow 1p - SOURCES main.cc - CMAKE_GUARD HAVE_QUADMATH - COMPILE_DEFINITIONS TYPETAG=OnePIncompressibleTpfaQuad NUMDIFFMETHOD=DiffMethod::analytic - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p_cc-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p_incompressible_tpfa_quad-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p_incompressible_tpfa_quad params.input -Problem.Name test_1p_incompressible_tpfa_quad") - -# using mpfa and analytical Jacobian -dumux_add_test(NAME test_1p_incompressible_mpfa - TARGET test_1p_incompressible_mpfa_anadiff - LABELS porousmediumflow 1p - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p_cc-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p_incompressible_mpfa-00001.vtu - ${CMAKE_SOURCE_DIR}/test/references/test_1p_mpfa_scvvelocities-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/mpfa_scv_velocities.vtp - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p_incompressible_mpfa_anadiff params.input -Problem.Name test_1p_incompressible_mpfa -IO.WriteMpfaVelocities true") - -# using box and analytical Jacobian -dumux_add_test(NAME test_1p_incompressible_box - TARGET test_1p_incompressible_box_anadiff - LABELS porousmediumflow 1p - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p_box-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p_incompressible_box-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p_incompressible_box_anadiff params.input -Problem.Name test_1p_incompressible_box") - -# using tpfa and numeric differentiation -dumux_add_test(NAME test_1p_incompressible_tpfa_numdiff - LABELS porousmediumflow 1p - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=OnePIncompressibleTpfa NUMDIFFMETHOD=DiffMethod::numeric - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p_cc-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p_incompressible_tpfa_numdiff-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p_incompressible_tpfa_numdiff params.input - -Problem.Name test_1p_incompressible_tpfa_numdiff - -Assembly.NumericDifference.PriVarMagnitude 1e5") - -# using box and numeric differentiation -dumux_add_test(NAME test_1p_incompressible_box_numdiff - LABELS porousmediumflow 1p - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=OnePIncompressibleBox NUMDIFFMETHOD=DiffMethod::numeric - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p_box-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p_incompressible_box_numdiff-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p_incompressible_box_numdiff params.input - -Problem.Name test_1p_incompressible_box_numdiff - -Assembly.NumericDifference.PriVarMagnitude 1e5") - -# using tpfa and analytical Jacobian with extrusion factor -dumux_add_test(NAME test_1p_incompressible_tpfa_extrude - TARGET test_1p_incompressible_tpfa_anadiff - LABELS porousmediumflow 1p - COMMAND ./test_1p_incompressible_tpfa_anadiff - CMD_ARGS params.input -Problem.Name test_1p_incompressible_tpfa_extrude - -Problem.ExtrusionFactor 10 - -Vtk.AddVelocity 1 - -Problem.CheckIsConstantVelocity true - -Problem.EnableGravity false) - -# using mpfa and analytical Jacobian with extrusion factor -dumux_add_test(NAME test_1p_incompressible_mpfa_extrude - TARGET test_1p_incompressible_mpfa_anadiff - LABELS porousmediumflow 1p - COMMAND ./test_1p_incompressible_mpfa_anadiff - CMD_ARGS params.input -Problem.Name test_1p_incompressible_mpfa_extrude - -Problem.ExtrusionFactor 10 - -Vtk.AddVelocity 1 - -Problem.CheckIsConstantVelocity true - -Problem.EnableGravity false) - -# using box and analytical Jacobian with extrusion factor -dumux_add_test(NAME test_1p_incompressible_box_extrude - TARGET test_1p_incompressible_box_anadiff - LABELS porousmediumflow 1p - COMMAND ./test_1p_incompressible_box_anadiff - CMD_ARGS params.input -Problem.Name test_1p_incompressible_box_extrude - -Problem.ExtrusionFactor 10 - -Vtk.AddVelocity 1 - -Problem.CheckIsConstantVelocity true - -Problem.EnableGravity false) - -# using box and analytical Jacobian with extrusion factor on distorted grid -dumux_add_test(NAME test_1p_incompressible_box_extrude_distorted - LABELS porousmediumflow 1p - SOURCES main.cc - CMAKE_GUARD dune-uggrid_FOUND - COMPILE_DEFINITIONS GRIDTYPE=Dune::UGGrid<2> - COMPILE_DEFINITIONS TYPETAG=OnePIncompressibleBox NUMDIFFMETHOD=DiffMethod::analytic - COMMAND ./test_1p_incompressible_box_extrude_distorted - CMD_ARGS params.input -Problem.Name test_1p_incompressible_box_extrude_distorted - -Problem.ExtrusionFactor 10 - -Vtk.AddVelocity 1 - -Problem.CheckIsConstantVelocity true - -Problem.EnableGravity false - -Grid.File ./grids/randomlydistorted.dgf) - -# using mpfa and analytical Jacobian with extrusion factor on distorted grid -dumux_add_test(NAME test_1p_incompressible_mpfa_extrude_distorted - LABELS porousmediumflow 1p - SOURCES main.cc - CMAKE_GUARD dune-uggrid_FOUND - COMPILE_DEFINITIONS GRIDTYPE=Dune::UGGrid<2> - COMPILE_DEFINITIONS TYPETAG=OnePIncompressibleMpfa NUMDIFFMETHOD=DiffMethod::analytic - COMMAND ./test_1p_incompressible_mpfa_extrude_distorted - CMD_ARGS params.input -Problem.Name test_1p_incompressible_mpfa_extrude_distorted - -Problem.ExtrusionFactor 10 - -Vtk.AddVelocity 1 - -Problem.CheckIsConstantVelocity true - -Problem.EnableGravity false - -Grid.File ./grids/randomlydistorted.dgf) - -# check grids without communicate method (using box and numeric differentiation) -dumux_add_test(NAME test_1p_incompressible_box_numdiff_no_communicate - LABELS porousmediumflow 1p - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=OnePIncompressibleBox NUMDIFFMETHOD=DiffMethod::numeric GRIDTYPE=Dumux::NoCommunicateGrid<2> - COMMAND ./test_1p_incompressible_box_numdiff_no_communicate - CMD_ARGS -Grid.Overlap 0) +file(GLOB DUMUX_TEST_POROUSMEDIUMFLOW_1P_INCOMPRESSIBLE_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_POROUSMEDIUMFLOW_1P_INCOMPRESSIBLE_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/porousmediumflow/1p/incompressible) diff --git a/test/porousmediumflow/1p/incompressible/grids/CMakeLists.txt b/test/porousmediumflow/1p/incompressible/grids/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/test/porousmediumflow/1p/internaldirichlet/CMakeLists.txt b/test/porousmediumflow/1p/internaldirichlet/CMakeLists.txt index 18f73857cb34f7947c457599249e40af7e72a5c2..38af1ae4b627e68d63c33b959a4cf51e709f34a1 100644 --- a/test/porousmediumflow/1p/internaldirichlet/CMakeLists.txt +++ b/test/porousmediumflow/1p/internaldirichlet/CMakeLists.txt @@ -1,22 +1,3 @@ - -dumux_add_test(NAME test_1p_internaldirichlet_tpfa - SOURCES ${CMAKE_SOURCE_DIR}/test/porousmediumflow/1p/incompressible/main.cc - LABELS porousmediumflow 1p - COMPILE_DEFINITIONS TYPETAG=OnePInternalDirichletTpfa - COMPILE_DEFINITIONS NUMDIFFMETHOD=DiffMethod::analytic - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p_internaldirichlet_tpfa-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p_internaldirichlet_tpfa-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p_internaldirichlet_tpfa ${CMAKE_SOURCE_DIR}/test/porousmediumflow/1p/incompressible/params.input -Problem.Name test_1p_internaldirichlet_tpfa -Problem.EnableGravity false") - -dumux_add_test(NAME test_1p_internaldirichlet_box - SOURCES ${CMAKE_SOURCE_DIR}/test/porousmediumflow/1p/incompressible/main.cc - LABELS porousmediumflow 1p - COMPILE_DEFINITIONS TYPETAG=OnePInternalDirichletBox - COMPILE_DEFINITIONS NUMDIFFMETHOD=DiffMethod::analytic - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p_internaldirichlet_box-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p_internaldirichlet_box-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p_internaldirichlet_box ${CMAKE_SOURCE_DIR}/test/porousmediumflow/1p/incompressible/params.input -Problem.Name test_1p_internaldirichlet_box -Problem.EnableGravity false") +file(GLOB DUMUX_TEST_POROUSMEDIUMFLOW_1P_INTERNALDIRICHLET_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_POROUSMEDIUMFLOW_1P_INTERNALDIRICHLET_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/porousmediumflow/1p/internaldirichlet) diff --git a/test/porousmediumflow/1p/isothermal/CMakeLists.txt b/test/porousmediumflow/1p/isothermal/CMakeLists.txt index 090267217b9f332e8a57d8805c55efb39aa5ea71..c44b14bd4e113b6982ab7c88cff2eb9da00d1ee6 100644 --- a/test/porousmediumflow/1p/isothermal/CMakeLists.txt +++ b/test/porousmediumflow/1p/isothermal/CMakeLists.txt @@ -1,54 +1,3 @@ - -add_input_file_links() -add_gstat_file_links() - -# isothermal tests -dumux_add_test(NAME test_1p_tpfa - LABELS porousmediumflow 1p - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=OnePTestCCTpfa - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p_cc-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p_tpfa-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p_tpfa params.input -Problem.Name test_1p_tpfa") - -dumux_add_test(NAME test_1p_mpfa - LABELS porousmediumflow 1p - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=OnePTestCCMpfa - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p_cc-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p_mpfa-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p_mpfa params.input -Problem.Name test_1p_mpfa") - -dumux_add_test(NAME test_1p_box - LABELS porousmediumflow 1p - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=OnePTestBox - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p_box-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p_box-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p_box params.input -Problem.Name test_1p_box") - -dumux_add_test(NAME test_1p_forchheimer_tpfa - LABELS porousmediumflow 1p - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=OnePTestCCTpfa FORCHHEIMER=1 - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p_forchheimer_tpfa-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p_forchheimer_tpfa-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p_forchheimer_tpfa params_forchheimer.input -Problem.Name test_1p_forchheimer_tpfa" - --zeroThreshold {"velocity_liq \(m/s\)":1e-12}) - -# a gstat test (becaue it's a random permeability field we can't test against a reference solution) -dumux_add_test(NAME test_1p_gstat - LABELS porousmediumflow 1p - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=OnePTestCCTpfa - CMAKE_GUARD HAVE_GSTAT - COMMAND ./test_1p_gstat - CMD_ARGS params_gstat.input) +file(GLOB DUMUX_TEST_POROUSMEDIUMFLOW_1P_ISOTHERMAL_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_POROUSMEDIUMFLOW_1P_ISOTHERMAL_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/porousmediumflow/1p/isothermal) diff --git a/test/porousmediumflow/1p/network1d3d/CMakeLists.txt b/test/porousmediumflow/1p/network1d3d/CMakeLists.txt index 4b09d46afed756dc68f8d3e8ff6f8823f2125c30..eeaf2c16da134ff6d5f4eecfb509ee348dd2b76d 100644 --- a/test/porousmediumflow/1p/network1d3d/CMakeLists.txt +++ b/test/porousmediumflow/1p/network1d3d/CMakeLists.txt @@ -1,22 +1,5 @@ -add_input_file_links() -add_gstat_file_links() +add_subdirectory(grids) -dune_symlink_to_source_files(FILES grids) -dune_symlink_to_source_files(FILES "convergencetest.py") - -# dim < dimWorld tests with Dune::Foamgrid<1,3> -dumux_add_test(NAME test_1p_network1d3d_tpfa - LABELS porousmediumflow 1p - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=TubesTestCCTpfa - CMAKE_GUARD dune-foamgrid_FOUND - COMMAND ./convergencetest.py - CMD_ARGS test_1p_network1d3d_tpfa params.input -Problem.Name test_1p_network1d3d_tpfa) - -dumux_add_test(NAME test_1p_network1d3d_box - LABELS porousmediumflow 1p - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=TubesTestBox - CMAKE_GUARD dune-foamgrid_FOUND - COMMAND ./convergencetest.py - CMD_ARGS test_1p_network1d3d_box params.input -Problem.Name test_1p_network1d3d_box) +file(GLOB DUMUX_TEST_POROUSMEDIUMFLOW_1P_NETWORK1D3D_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_POROUSMEDIUMFLOW_1P_NETWORK1D3D_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/porousmediumflow/1p/network1d3d) diff --git a/test/porousmediumflow/1p/network1d3d/grids/CMakeLists.txt b/test/porousmediumflow/1p/network1d3d/grids/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/test/porousmediumflow/1p/nonisothermal/CMakeLists.txt b/test/porousmediumflow/1p/nonisothermal/CMakeLists.txt index 9b2594e883040fe3de10ff0f124eea04a6e8301c..e1966d2263694bfe75b06ef83b3a02c487544e3c 100644 --- a/test/porousmediumflow/1p/nonisothermal/CMakeLists.txt +++ b/test/porousmediumflow/1p/nonisothermal/CMakeLists.txt @@ -1,70 +1,3 @@ -add_input_file_links() - -# non-isothermal tests -dumux_add_test(NAME test_1pni_conduction_box - LABELS porousmediumflow 1p 1pni - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=OnePNIConductionBox - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1pni_conduction_box-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1pni_conduction_box-00005.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1pni_conduction_box params_conduction.input -Problem.Name test_1pni_conduction_box" - --zeroThreshold {"velocity_liq":1e-8}) - -add_executable(test_1pni_convection_box EXCLUDE_FROM_ALL main.cc) -target_compile_definitions(test_1pni_convection_box PUBLIC TYPETAG=OnePNIConvectionBox) - -dumux_add_test(NAME test_1pni_convection_box - TARGET test_1pni_convection_box - LABELS porousmediumflow 1p 1pni - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1pni_convection_box-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_1pni_convection_box-00009.vtp - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1pni_convection_box params_convection.input -Problem.Name test_1pni_convection_box" - --zeroThreshold {"velocity":1e-15}) - -dumux_add_test(NAME test_1pni_convection_box_restart - TARGET test_1pni_convection_box - LABELS porousmediumflow 1p 1pni - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1pni_convection_box-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_1pni_convection_box_restart-00004.vtp - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1pni_convection_box params_convection.input -Problem.Name test_1pni_convection_box_restart -TimeLoop.DtInitial 1000 -Restart.Time 16768 -Restart.File test_1pni_convection_box-00006.vtp" - --zeroThreshold {"velocity":1e-15}) - -# the restart test has to run after the test that produces the corresponding vtu file -set_tests_properties(test_1pni_convection_box_restart PROPERTIES DEPENDS test_1pni_convection_box) - -dumux_add_test(NAME test_1pni_conduction_tpfa - LABELS porousmediumflow 1p 1pni - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=OnePNIConductionCCTpfa - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1pni_conduction_cc-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1pni_conduction_tpfa-00005.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1pni_conduction_tpfa params_conduction.input -Problem.Name test_1pni_conduction_tpfa" - --zeroThreshold {"velocity":1e-8}) - -dumux_add_test(NAME test_1pni_convection_tpfa - LABELS porousmediumflow 1p 1pni - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=OnePNIConvectionCCTpfa - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1pni_convection_cc-reference.vtp - ${CMAKE_CURRENT_BINARY_DIR}/test_1pni_convection_tpfa-00009.vtp - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1pni_convection_tpfa params_convection.input -Problem.Name test_1pni_convection_tpfa") - -dumux_add_test(NAME test_1pni_conduction_mpfa - LABELS porousmediumflow 1p 1pni - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=OnePNIConductionCCMpfa - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1pni_conduction_mpfa-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1pni_conduction_mpfa-00005.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1pni_conduction_mpfa params_conduction.input -Problem.Name test_1pni_conduction_mpfa") +file(GLOB DUMUX_TEST_POROUSMEDIUMFLOW_1P_NONISOTHERMAL_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_POROUSMEDIUMFLOW_1P_NONISOTHERMAL_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/porousmediumflow/1p/nonisothermal) diff --git a/test/porousmediumflow/1p/periodicbc/CMakeLists.txt b/test/porousmediumflow/1p/periodicbc/CMakeLists.txt index 84fa804292a95c79cb12558654df8fdf838640e9..6ac30cda78be45487fde42d93e6570213344ddbb 100644 --- a/test/porousmediumflow/1p/periodicbc/CMakeLists.txt +++ b/test/porousmediumflow/1p/periodicbc/CMakeLists.txt @@ -1,46 +1,3 @@ -dune_symlink_to_source_files(FILES "params.input" "periodic.dgf") - -# test using periodic boundary conditions -dumux_add_test(NAME test_1p_periodic_tpfa - SOURCES main.cc - LABELS porousmediumflow 1p - COMPILE_DEFINITIONS TYPETAG=OnePIncompressibleTpfa FVGEOMCACHING=false - CMAKE_GUARD dune-spgrid_FOUND - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p_tpfa_periodic-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p_periodic_tpfa-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p_periodic_tpfa params.input -Problem.Name test_1p_periodic_tpfa") - -dumux_add_test(NAME test_1p_periodic_tpfa_parallel - TARGET test_1p_periodic_tpfa - LABELS porousmediumflow 1p parallel - CMAKE_GUARD dune-spgrid_FOUND - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --zeroThreshold {"process rank":100} - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p_tpfa_periodic-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/s0002-test_1p_periodic_tpfa_parallel-00001.pvtu - --command "${MPIEXEC} -np 2 ${CMAKE_CURRENT_BINARY_DIR}/test_1p_periodic_tpfa params.input -Problem.Name test_1p_periodic_tpfa_parallel") - -dumux_add_test(NAME test_1p_periodic_tpfa_caching - LABELS porousmediumflow 1p - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=OnePIncompressibleTpfa FVGEOMCACHING=true - CMAKE_GUARD dune-spgrid_FOUND - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p_tpfa_periodic-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p_periodic_tpfa_caching-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p_periodic_tpfa params.input -Problem.Name test_1p_periodic_tpfa_caching") - -dumux_add_test(NAME test_1p_periodic_box - LABELS porousmediumflow 1p - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=OnePIncompressibleBox - CMAKE_GUARD dune-spgrid_FOUND - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p_box_periodic-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p_periodic_box-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p_periodic_box params.input -Problem.Name test_1p_periodic_box") +file(GLOB DUMUX_TEST_POROUSMEDIUMFLOW_1P_PERIODICBC_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_POROUSMEDIUMFLOW_1P_PERIODICBC_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/porousmediumflow/1p/periodicbc) diff --git a/test/porousmediumflow/1p/pointsources/CMakeLists.txt b/test/porousmediumflow/1p/pointsources/CMakeLists.txt index ef57bf2c78d5a32d3e3b429144e5be6d69483018..15ba43f766446a7e42f8ea583cae3683ffb88300 100644 --- a/test/porousmediumflow/1p/pointsources/CMakeLists.txt +++ b/test/porousmediumflow/1p/pointsources/CMakeLists.txt @@ -1,2 +1,2 @@ -add_subdirectory(timeindependent) add_subdirectory(timedependent) +add_subdirectory(timeindependent) diff --git a/test/porousmediumflow/1p/pointsources/timedependent/CMakeLists.txt b/test/porousmediumflow/1p/pointsources/timedependent/CMakeLists.txt index 0b0410c5c9fbe71dc7b453e6ed63c508dbbdbfa3..ccd7a099d49372e20aaa9aa34986d76d28b055c8 100644 --- a/test/porousmediumflow/1p/pointsources/timedependent/CMakeLists.txt +++ b/test/porousmediumflow/1p/pointsources/timedependent/CMakeLists.txt @@ -1,12 +1,3 @@ -add_input_file_links("params.input") - -dumux_add_test(NAME test_1p_pointsources_timedependent_tpfa - LABELS porousmediumflow 1p - SOURCES main.cc - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - COMPILE_DEFINITIONS TYPETAG=OnePSingularityTimeDependentCCTpfa - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p_pointsources_timedependent_tpfa-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p_pointsources_timedependent_tpfa-00003.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p_pointsources_timedependent_tpfa params.input -TimeLoop.TEnd 4 - -Problem.Name test_1p_pointsources_timedependent_tpfa") +file(GLOB DUMUX_TEST_POROUSMEDIUMFLOW_1P_POINTSOURCES_TIMEDEPENDENT_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_POROUSMEDIUMFLOW_1P_POINTSOURCES_TIMEDEPENDENT_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/porousmediumflow/1p/pointsources/timedependent) diff --git a/test/porousmediumflow/1p/pointsources/timeindependent/CMakeLists.txt b/test/porousmediumflow/1p/pointsources/timeindependent/CMakeLists.txt index e278897aaf85ca159fe56203f89de04a3206b002..fd5c38179d54e5ee39e6802f0e9fd3e631f63c90 100644 --- a/test/porousmediumflow/1p/pointsources/timeindependent/CMakeLists.txt +++ b/test/porousmediumflow/1p/pointsources/timeindependent/CMakeLists.txt @@ -1,50 +1,5 @@ -add_input_file_links("params.input") -dune_symlink_to_source_files(FILES grids) +add_subdirectory(grids) -dumux_add_test(NAME test_1p_pointsources_timeindependent_tpfa - LABELS porousmediumflow 1p - SOURCES main.cc - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - COMPILE_DEFINITIONS TYPETAG=OnePSingularityCCTpfa - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p_pointsources_timeindependent_cc-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p_pointsources_timeindependent_tpfa-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p_pointsources_timeindependent_tpfa params.input -Problem.Name test_1p_pointsources_timeindependent_tpfa") - -dumux_add_test(NAME test_1p_pointsources_timeindependent_box - LABELS porousmediumflow 1p - SOURCES main.cc - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - COMPILE_DEFINITIONS TYPETAG=OnePSingularityBox - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p_pointsources_timeindependent_box-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p_pointsources_timeindependent_box-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p_pointsources_timeindependent_box params.input -Problem.Name test_1p_pointsources_timeindependent_box") - -dumux_add_test(NAME test_1p_pointsources_timeindependent_tpfa_prism - LABELS porousmediumflow 1p - SOURCES main.cc - CMAKE_GUARD dune-uggrid_FOUND - COMPILE_DEFINITIONS GRIDTYPE=Dune::UGGrid<3> - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - COMPILE_DEFINITIONS TYPETAG=OnePSingularityCCTpfa - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p_pointsources_timeindependent_tpfa_prism-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p_pointsources_timeindependent_tpfa_prism-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p_pointsources_timeindependent_tpfa_prism params.input - -Problem.Name test_1p_pointsources_timeindependent_tpfa_prism - -Grid.File ./grids/well_prism.msh") - -dumux_add_test(NAME test_1p_pointsources_timeindependent_box_prism - LABELS porousmediumflow 1p - SOURCES main.cc - CMAKE_GUARD dune-uggrid_FOUND - COMPILE_DEFINITIONS GRIDTYPE=Dune::UGGrid<3> - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - COMPILE_DEFINITIONS TYPETAG=OnePSingularityBox - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p_pointsources_timeindependent_box_prism-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p_pointsources_timeindependent_box_prism-00001.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p_pointsources_timeindependent_box_prism params.input - -Problem.Name test_1p_pointsources_timeindependent_box_prism - -Grid.File ./grids/well_prism.msh") +file(GLOB DUMUX_TEST_POROUSMEDIUMFLOW_1P_POINTSOURCES_TIMEINDEPENDENT_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_POROUSMEDIUMFLOW_1P_POINTSOURCES_TIMEINDEPENDENT_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/porousmediumflow/1p/pointsources/timeindependent) diff --git a/test/porousmediumflow/1p/pointsources/timeindependent/grids/CMakeLists.txt b/test/porousmediumflow/1p/pointsources/timeindependent/grids/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/test/porousmediumflow/1p/rootbenchmark/CMakeLists.txt b/test/porousmediumflow/1p/rootbenchmark/CMakeLists.txt index e37556813e76b233b7cec4d62d36101448cbf3e7..13a23a69877a2a65fdf4bfe22a998810b9485011 100644 --- a/test/porousmediumflow/1p/rootbenchmark/CMakeLists.txt +++ b/test/porousmediumflow/1p/rootbenchmark/CMakeLists.txt @@ -1,15 +1,3 @@ -dune_symlink_to_source_files(FILES params.input convergencetest.py) - -dumux_add_test(NAME test_1p_rootbenchmark_tpfa - LABELS porousmediumflow 1p - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=RootBenchmarkCCTpfa - COMMAND ./convergencetest.py - CMD_ARGS test_1p_rootbenchmark_tpfa -Problem.EnableGravity false) - -dumux_add_test(NAME test_1p_rootbenchmark_tpfa_gravity - TARGET test_1p_rootbenchmark_tpfa - LABELS porousmediumflow 1p - COMPILE_DEFINITIONS TYPETAG=RootBenchmarkCCTpfa - COMMAND ./convergencetest.py - CMD_ARGS test_1p_rootbenchmark_tpfa test_1p_rootbenchmark_tpfa_gravity.log) +file(GLOB DUMUX_TEST_POROUSMEDIUMFLOW_1P_ROOTBENCHMARK_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_POROUSMEDIUMFLOW_1P_ROOTBENCHMARK_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/porousmediumflow/1p/rootbenchmark) diff --git a/test/porousmediumflow/1pnc/1p2c/CMakeLists.txt b/test/porousmediumflow/1pnc/1p2c/CMakeLists.txt index bc7eb9a410f5506335f56ed64b442d7de9fb3b2f..10d07f713b9e95995327d6d0b079ecd7dcef3a42 100644 --- a/test/porousmediumflow/1pnc/1p2c/CMakeLists.txt +++ b/test/porousmediumflow/1pnc/1p2c/CMakeLists.txt @@ -1,2 +1,6 @@ add_subdirectory(isothermal) add_subdirectory(nonisothermal) + +file(GLOB DUMUX_TEST_POROUSMEDIUMFLOW_1PNC_1P2C_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_POROUSMEDIUMFLOW_1PNC_1P2C_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/porousmediumflow/1pnc/1p2c) diff --git a/test/porousmediumflow/1pnc/1p2c/isothermal/CMakeLists.txt b/test/porousmediumflow/1pnc/1p2c/isothermal/CMakeLists.txt index 7a06e249c991fc832b1898ca8462cd58fd9bbb6f..e5151aaab7c493da56503b53bac80acf22a162dd 100644 --- a/test/porousmediumflow/1pnc/1p2c/isothermal/CMakeLists.txt +++ b/test/porousmediumflow/1pnc/1p2c/isothermal/CMakeLists.txt @@ -1,36 +1,5 @@ add_subdirectory(saltwaterintrusion) -add_input_file_links() - -dumux_add_test(NAME test_1p2c_transport_box - LABELS porousmediumflow 1p2c 1pnc - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=OnePTwoCTestBox - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p2c_transport_box-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p2c_transport_box-00009.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p2c_transport_box params.input -Problem.Name test_1p2c_transport_box" - --zeroThreshold {"velocity_liq \(m/s\)_1":1e-15}) - -dumux_add_test(NAME test_1p2c_transport_tpfa - LABELS porousmediumflow 1p2c 1pnc - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=OnePTwoCTestCCTpfa - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p2c_transport_tpfa-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p2c_transport_tpfa-00009.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p2c_transport_tpfa params.input -Problem.Name test_1p2c_transport_tpfa" - --zeroThreshold {"velocity_liq \(m/s\)_1":1e-15}) - -dumux_add_test(NAME test_1p2c_transport_mpfa - LABELS porousmediumflow 1p2c 1pnc - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=OnePTwoCTestCCMpfa - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p2c_transport_tpfa-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p2c_transport_mpfa-00009.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p2c_transport_mpfa params.input -Problem.Name test_1p2c_transport_mpfa" - --zeroThreshold {"velocity_liq \(m/s\)_1":1e-13}) +file(GLOB DUMUX_TEST_POROUSMEDIUMFLOW_1PNC_1P2C_ISOTHERMAL_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_POROUSMEDIUMFLOW_1PNC_1P2C_ISOTHERMAL_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/porousmediumflow/1pnc/1p2c/isothermal) diff --git a/test/porousmediumflow/1pnc/1p2c/isothermal/saltwaterintrusion/CMakeLists.txt b/test/porousmediumflow/1pnc/1p2c/isothermal/saltwaterintrusion/CMakeLists.txt index db68cc4654e807a433298070442b7b682af2ffac..40dfb8c988619ca944bc43274a11fe7dd197e5e5 100644 --- a/test/porousmediumflow/1pnc/1p2c/isothermal/saltwaterintrusion/CMakeLists.txt +++ b/test/porousmediumflow/1pnc/1p2c/isothermal/saltwaterintrusion/CMakeLists.txt @@ -1,13 +1,3 @@ -dune_symlink_to_source_files(FILES params.input test_1p2c_saltwaterintrusion_box_dt-reference.dat) - -# salt-water intrusion test using the box model -dumux_add_test(NAME test_1p2c_saltwaterintrusion_box - LABELS porousmediumflow 1p2c - SOURCES main.cc - LABELS 1pnc - COMPILE_DEFINITIONS TYPETAG=SaltWaterIntrusionTest - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p2c_saltwaterintrusion_box-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p2c_saltwaterintrusion_box-00033.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p2c_saltwaterintrusion_box params.input -Problem.Name test_1p2c_saltwaterintrusion_box -TimeLoop.TimeStepSizeFile test_1p2c_saltwaterintrusion_box_dt-reference.dat") +file(GLOB DUMUX_TEST_POROUSMEDIUMFLOW_1PNC_1P2C_ISOTHERMAL_SALTWATERINTRUSION_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_POROUSMEDIUMFLOW_1PNC_1P2C_ISOTHERMAL_SALTWATERINTRUSION_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/porousmediumflow/1pnc/1p2c/isothermal/saltwaterintrusion) diff --git a/test/porousmediumflow/1pnc/1p2c/nonisothermal/conduction/CMakeLists.txt b/test/porousmediumflow/1pnc/1p2c/nonisothermal/conduction/CMakeLists.txt index 30fcb84cf47dcd3411f201a1005978abeaf0cd73..cf9d0af72f62c6583bf0730bac638ce172fbb7ac 100644 --- a/test/porousmediumflow/1pnc/1p2c/nonisothermal/conduction/CMakeLists.txt +++ b/test/porousmediumflow/1pnc/1p2c/nonisothermal/conduction/CMakeLists.txt @@ -1,39 +1,3 @@ -add_input_file_links() - -# non-isothermal tests -# conduction -dumux_add_test(NAME test_1p2cni_conduction_box - LABELS porousmediumflow 1p2c 1p2cni - SOURCES main.cc - LABELS 1pnc - COMPILE_DEFINITIONS TYPETAG=OnePTwoCNIConductionBox - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p2cni_conduction_box-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p2cni_conduction_box-00005.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p2cni_conduction_box params.input -Problem.Name test_1p2cni_conduction_box" - --zeroThreshold {"velocity_liq \(m/s\)":1e-9}) - -dumux_add_test(NAME test_1p2cni_conduction_tpfa - LABELS porousmediumflow 1p2c 1p2cni - SOURCES main.cc - LABELS 1pnc - COMPILE_DEFINITIONS TYPETAG=OnePTwoCNIConductionCCTpfa - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p2cni_conduction_tpfa-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p2cni_conduction_tpfa-00005.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p2cni_conduction_tpfa params.input -Problem.Name test_1p2cni_conduction_tpfa" - --zeroThreshold {"velocity_liq \(m/s\)_0":1e-9}) - -dumux_add_test(NAME test_1p2cni_conduction_mpfa - LABELS porousmediumflow 1p2c 1p2cni - SOURCES main.cc - LABELS 1pnc - COMPILE_DEFINITIONS TYPETAG=OnePTwoCNIConductionCCMpfa - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p2cni_conduction_tpfa-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p2cni_conduction_mpfa-00005.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p2cni_conduction_mpfa params.input -Problem.Name test_1p2cni_conduction_mpfa" - --zeroThreshold {"velocity_liq \(m/s\)_0":1e-9}) +file(GLOB DUMUX_TEST_POROUSMEDIUMFLOW_1PNC_1P2C_NONISOTHERMAL_CONDUCTION_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_POROUSMEDIUMFLOW_1PNC_1P2C_NONISOTHERMAL_CONDUCTION_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/porousmediumflow/1pnc/1p2c/nonisothermal/conduction) diff --git a/test/porousmediumflow/1pnc/1p2c/nonisothermal/convection/CMakeLists.txt b/test/porousmediumflow/1pnc/1p2c/nonisothermal/convection/CMakeLists.txt index d86012463a85e799e021a070c4ff11866f01a283..38288fbeaa7c6808692fff7376c53e7776e9e713 100644 --- a/test/porousmediumflow/1pnc/1p2c/nonisothermal/convection/CMakeLists.txt +++ b/test/porousmediumflow/1pnc/1p2c/nonisothermal/convection/CMakeLists.txt @@ -1,39 +1,3 @@ -add_input_file_links() - -# non-isothermal tests -# convection -dumux_add_test(NAME test_1p2cni_convection_box - LABELS porousmediumflow 1p2c 1p2cni - SOURCES main.cc - LABELS 1pnc - COMPILE_DEFINITIONS TYPETAG=OnePTwoCNIConvectionBox - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p2cni_convection_box-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p2cni_convection_box-00009.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p2cni_convection_box params.input -Problem.Name test_1p2cni_convection_box" - --zeroThreshold {"velocity_liq \(m/s\)":1e-9}) - -dumux_add_test(NAME test_1p2cni_convection_tpfa - LABELS porousmediumflow 1p2c 1p2cni - SOURCES main.cc - LABELS 1pnc - COMPILE_DEFINITIONS TYPETAG=OnePTwoCNIConvectionCCTpfa - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p2cni_convection_tpfa-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p2cni_convection_tpfa-00009.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p2cni_convection_tpfa params.input -Problem.Name test_1p2cni_convection_tpfa" - --zeroThreshold {"velocity_liq \(m/s\)_0":1e-9}) - -dumux_add_test(NAME test_1p2cni_convection_mpfa - LABELS porousmediumflow 1p2c 1p2cni - SOURCES main.cc - LABELS 1pnc - COMPILE_DEFINITIONS TYPETAG=OnePTwoCNIConvectionCCMpfa - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p2cni_convection_tpfa-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p2cni_convection_mpfa-00009.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1p2cni_convection_mpfa params.input -Problem.Name test_1p2cni_convection_mpfa" - --zeroThreshold {"velocity_liq \(m/s\)_0":1e-9}) +file(GLOB DUMUX_TEST_POROUSMEDIUMFLOW_1PNC_1P2C_NONISOTHERMAL_CONVECTION_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_POROUSMEDIUMFLOW_1PNC_1P2C_NONISOTHERMAL_CONVECTION_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/porousmediumflow/1pnc/1p2c/nonisothermal/convection) diff --git a/test/porousmediumflow/1pnc/1p2c/nonisothermal/transientbc/CMakeLists.txt b/test/porousmediumflow/1pnc/1p2c/nonisothermal/transientbc/CMakeLists.txt index 792fd3fffd001f99545d19d4eaf27c56b80f483e..38915608a0f72ff72353304595d3001b65fb7111 100644 --- a/test/porousmediumflow/1pnc/1p2c/nonisothermal/transientbc/CMakeLists.txt +++ b/test/porousmediumflow/1pnc/1p2c/nonisothermal/transientbc/CMakeLists.txt @@ -1,73 +1,3 @@ -add_input_file_links() - -dumux_add_test(NAME test_1pncni_transientbc_box_caching - LABELS porousmediumflow 1pnc 1pncni - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=OnePTwoCNITransientBCBox ENABLECACHING=1 - LABELS caching - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p2cni_transientbc_box-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p2cni_transientbc_box_caching-00009.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1pncni_transientbc_box_caching params.input -Problem.Name test_1p2cni_transientbc_box_caching") - -dumux_add_test(NAME test_1pncni_transientbc_box - LABELS porousmediumflow 1pnc 1pncni - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=OnePTwoCNITransientBCBox ENABLECACHING=0 - LABELS caching - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p2cni_transientbc_box-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p2cni_transientbc_box-00009.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1pncni_transientbc_box params.input -Problem.Name test_1p2cni_transientbc_box") - -dumux_add_test(NAME test_1pncni_transientbc_tpfa_caching - LABELS porousmediumflow 1pnc 1pncni - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=OnePTwoCNITransientBCCCTpfa ENABLECACHING=1 - LABELS caching - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p2cni_transientbc_tpfa-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p2cni_transientbc_tpfa_caching-00009.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1pncni_transientbc_tpfa_caching params.input -Problem.Name test_1p2cni_transientbc_tpfa_caching") - -dumux_add_test(NAME test_1pncni_transientbc_tpfa - LABELS porousmediumflow 1pnc 1pncni - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=OnePTwoCNITransientBCCCTpfa ENABLECACHING=0 - LABELS caching - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p2cni_transientbc_tpfa-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p2cni_transientbc_tpfa-00009.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1pncni_transientbc_tpfa params.input -Problem.Name test_1p2cni_transientbc_tpfa") - -dumux_add_test(NAME test_1pncni_transientbc_mpfa_caching - LABELS porousmediumflow 1pnc 1pncni - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=OnePTwoCNITransientBCCCMpfa ENABLECACHING=1 - LABELS caching - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p2cni_transientbc_mpfa-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p2cni_transientbc_mpfa_caching-00009.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1pncni_transientbc_mpfa_caching params.input -Problem.Name test_1p2cni_transientbc_mpfa_caching") - -dumux_add_test(NAME test_1pncni_transientbc_mpfa - LABELS porousmediumflow 1pnc 1pncni - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=OnePTwoCNITransientBCCCMpfa ENABLECACHING=0 - LABELS caching - CMAKE_GUARD HAVE_UMFPACK - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1p2cni_transientbc_mpfa-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1p2cni_transientbc_mpfa-00009.vtu - --command "${CMAKE_CURRENT_BINARY_DIR}/test_1pncni_transientbc_mpfa params.input -Problem.Name test_1p2cni_transientbc_mpfa") +file(GLOB DUMUX_TEST_POROUSMEDIUMFLOW_1PNC_1P2C_NONISOTHERMAL_TRANSIENTBC_HEADERS *.hh *.inc) +install(FILES ${DUMUX_TEST_POROUSMEDIUMFLOW_1PNC_1P2C_NONISOTHERMAL_TRANSIENTBC_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/test/porousmediumflow/1pnc/1p2c/nonisothermal/transientbc) diff --git a/test/porousmediumflow/1pnc/1p3c/CMakeLists.txt b/test/porousmediumflow/1pnc/1p3c/CMakeLists.txt index fad2b2b91f1241567203d9b7e901d5ac43045aa2..2fc8f98b0e69a171019c812bdeb0c00b40e7f6ee 100644 --- a/test/porousmediumflow/1pnc/1p3c/CMakeLists.txt +++ b/test/porousmediumflow/1pnc/1p3c/CMakeLists.txt @@ -1,23 +1,3 @@ -add_input_file_links() - -# 1pnc tests -dumux_add_test(NAME test_1pnc_maxwellstefan_tpfa - LABELS porousmediumflow 1pnc - SOURCES main.cc - COMPILE_DEFINITIONS TYPETAG=MaxwellStefanOnePThreeCTestCCTpfa - COMMAND ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py - CMD_ARGS --script fuzzy - --files ${CMAKE_SOURCE_DIR}/test/references/test_1pnc_maxwellstefan_tpfa-reference.vtu - ${CMAKE_CURRENT_BINARY_DIR}/test_1pnc_maxwellstefan_tpfa-00019.vtu - --command "${CMAKE_CURRENT_BINA