From b28efa7c0f529415bfacd98faac73f292426fbf5 Mon Sep 17 00:00:00 2001 From: Jean-Paul Pelteret Date: Fri, 22 Mar 2019 10:10:09 +0100 Subject: [PATCH] Add tests for AD framework: Sacado --- tests/sacado/ad_number_traits_02c.output.1 | 63 +++++++++++++++++ tests/sacado/ad_number_traits_02d.output.1 | 63 +++++++++++++++++ ...helper_scalar_coupled_2_components_01_1.cc | 47 +++++++++++++ ...er_scalar_coupled_2_components_01_1.output | 4 ++ ...helper_scalar_coupled_2_components_01_2.cc | 47 +++++++++++++ ...er_scalar_coupled_2_components_01_2.output | 4 ++ ...helper_scalar_coupled_2_components_01_3.cc | 47 +++++++++++++ ...er_scalar_coupled_2_components_01_3.output | 4 ++ ...helper_scalar_coupled_2_components_01_4.cc | 47 +++++++++++++ ...er_scalar_coupled_2_components_01_4.output | 4 ++ ...helper_scalar_coupled_2_components_02_1.cc | 47 +++++++++++++ ...er_scalar_coupled_2_components_02_1.output | 4 ++ ...helper_scalar_coupled_2_components_02_2.cc | 47 +++++++++++++ ...er_scalar_coupled_2_components_02_2.output | 4 ++ ...helper_scalar_coupled_2_components_02_3.cc | 47 +++++++++++++ ...er_scalar_coupled_2_components_02_3.output | 4 ++ ...helper_scalar_coupled_2_components_02_4.cc | 47 +++++++++++++ ...er_scalar_coupled_2_components_02_4.output | 4 ++ ...helper_scalar_coupled_2_components_03_1.cc | 47 +++++++++++++ ...er_scalar_coupled_2_components_03_1.output | 4 ++ ...helper_scalar_coupled_2_components_03_2.cc | 47 +++++++++++++ ...er_scalar_coupled_2_components_03_2.output | 4 ++ ...helper_scalar_coupled_2_components_03_3.cc | 47 +++++++++++++ ...er_scalar_coupled_2_components_03_3.output | 4 ++ ...helper_scalar_coupled_2_components_03_4.cc | 47 +++++++++++++ ...er_scalar_coupled_2_components_03_4.output | 4 ++ ...helper_scalar_coupled_2_components_04_1.cc | 47 +++++++++++++ ...er_scalar_coupled_2_components_04_1.output | 4 ++ ...helper_scalar_coupled_2_components_04_2.cc | 47 +++++++++++++ ...er_scalar_coupled_2_components_04_2.output | 4 ++ ...helper_scalar_coupled_2_components_04_3.cc | 47 +++++++++++++ ...er_scalar_coupled_2_components_04_3.output | 4 ++ ...helper_scalar_coupled_2_components_04_4.cc | 47 +++++++++++++ ...er_scalar_coupled_2_components_04_4.output | 4 ++ ...helper_scalar_coupled_2_components_05_1.cc | 47 +++++++++++++ ...er_scalar_coupled_2_components_05_1.output | 4 ++ ...helper_scalar_coupled_2_components_05_2.cc | 47 +++++++++++++ ...er_scalar_coupled_2_components_05_2.output | 4 ++ ...helper_scalar_coupled_2_components_05_3.cc | 47 +++++++++++++ ...er_scalar_coupled_2_components_05_3.output | 4 ++ ...helper_scalar_coupled_2_components_05_4.cc | 47 +++++++++++++ ...er_scalar_coupled_2_components_05_4.output | 4 ++ ...helper_scalar_coupled_2_components_06_1.cc | 55 +++++++++++++++ ...er_scalar_coupled_2_components_06_1.output | 4 ++ ...helper_scalar_coupled_2_components_06_2.cc | 55 +++++++++++++++ ...er_scalar_coupled_2_components_06_2.output | 4 ++ ...helper_scalar_coupled_2_components_06_3.cc | 55 +++++++++++++++ ...er_scalar_coupled_2_components_06_3.output | 4 ++ ...helper_scalar_coupled_2_components_06_4.cc | 55 +++++++++++++++ ...er_scalar_coupled_2_components_06_4.output | 4 ++ ...helper_scalar_coupled_2_components_07_1.cc | 55 +++++++++++++++ ...er_scalar_coupled_2_components_07_1.output | 4 ++ ...helper_scalar_coupled_2_components_07_2.cc | 55 +++++++++++++++ ...er_scalar_coupled_2_components_07_2.output | 4 ++ ...helper_scalar_coupled_2_components_07_3.cc | 55 +++++++++++++++ ...er_scalar_coupled_2_components_07_3.output | 4 ++ ...helper_scalar_coupled_2_components_07_4.cc | 55 +++++++++++++++ ...er_scalar_coupled_2_components_07_4.output | 4 ++ ...helper_scalar_coupled_2_components_08_1.cc | 59 ++++++++++++++++ ...er_scalar_coupled_2_components_08_1.output | 4 ++ ...helper_scalar_coupled_2_components_08_2.cc | 59 ++++++++++++++++ ...er_scalar_coupled_2_components_08_2.output | 4 ++ ...helper_scalar_coupled_2_components_08_3.cc | 59 ++++++++++++++++ ...er_scalar_coupled_2_components_08_3.output | 4 ++ ...helper_scalar_coupled_2_components_08_4.cc | 59 ++++++++++++++++ ...er_scalar_coupled_2_components_08_4.output | 4 ++ ...helper_scalar_coupled_3_components_01_1.cc | 52 ++++++++++++++ ...er_scalar_coupled_3_components_01_1.output | 4 ++ ...ponents_01_1.with_mpi=true.mpirun=2.output | 8 +++ ...helper_scalar_coupled_3_components_01_2.cc | 56 +++++++++++++++ ...er_scalar_coupled_3_components_01_2.output | 4 ++ ...ponents_01_2.with_mpi=true.mpirun=2.output | 8 +++ ...helper_scalar_coupled_3_components_01_3.cc | 48 +++++++++++++ ...er_scalar_coupled_3_components_01_3.output | 4 ++ ...ponents_01_3.with_mpi=true.mpirun=2.output | 8 +++ ...helper_scalar_coupled_3_components_01_4.cc | 56 +++++++++++++++ ...er_scalar_coupled_3_components_01_4.output | 4 ++ ...ponents_01_4.with_mpi=true.mpirun=2.output | 8 +++ ...coupled_3_components_01_tapeless_only_1.cc | 56 +++++++++++++++ ...led_3_components_01_tapeless_only_1.output | 4 ++ ...coupled_3_components_01_tapeless_only_2.cc | 60 ++++++++++++++++ ...led_3_components_01_tapeless_only_2.output | 4 ++ ...coupled_3_components_01_tapeless_only_3.cc | 52 ++++++++++++++ ...led_3_components_01_tapeless_only_3.output | 4 ++ ...coupled_3_components_01_tapeless_only_4.cc | 60 ++++++++++++++++ ...led_3_components_01_tapeless_only_4.output | 4 ++ .../helper_scalar_single_component_01_1.cc | 46 +++++++++++++ ...helper_scalar_single_component_01_1.output | 4 ++ .../helper_scalar_single_component_01_2.cc | 46 +++++++++++++ ...helper_scalar_single_component_01_2.output | 4 ++ .../helper_scalar_single_component_01_3.cc | 46 +++++++++++++ ...helper_scalar_single_component_01_3.output | 4 ++ .../helper_scalar_single_component_01_4.cc | 46 +++++++++++++ ...helper_scalar_single_component_01_4.output | 4 ++ .../helper_scalar_single_component_02_1.cc | 46 +++++++++++++ ...helper_scalar_single_component_02_1.output | 4 ++ .../helper_scalar_single_component_02_2.cc | 46 +++++++++++++ ...helper_scalar_single_component_02_2.output | 4 ++ .../helper_scalar_single_component_02_3.cc | 46 +++++++++++++ ...helper_scalar_single_component_02_3.output | 4 ++ .../helper_scalar_single_component_02_4.cc | 46 +++++++++++++ ...helper_scalar_single_component_02_4.output | 4 ++ .../helper_scalar_single_component_03_1.cc | 46 +++++++++++++ ...helper_scalar_single_component_03_1.output | 4 ++ .../helper_scalar_single_component_03_2.cc | 46 +++++++++++++ ...helper_scalar_single_component_03_2.output | 4 ++ .../helper_scalar_single_component_03_3.cc | 46 +++++++++++++ ...helper_scalar_single_component_03_3.output | 4 ++ .../helper_scalar_single_component_03_4.cc | 46 +++++++++++++ ...helper_scalar_single_component_03_4.output | 4 ++ .../helper_scalar_single_component_04_1.cc | 47 +++++++++++++ ...helper_scalar_single_component_04_1.output | 4 ++ .../helper_scalar_single_component_04_2.cc | 47 +++++++++++++ ...helper_scalar_single_component_04_2.output | 4 ++ .../helper_scalar_single_component_04_3.cc | 47 +++++++++++++ ...helper_scalar_single_component_04_3.output | 4 ++ .../helper_scalar_single_component_04_4.cc | 47 +++++++++++++ ...helper_scalar_single_component_04_4.output | 4 ++ .../helper_vector_1_indep_1_dep_vars_01_1.cc | 48 +++++++++++++ ...lper_vector_1_indep_1_dep_vars_01_1.output | 4 ++ .../helper_vector_1_indep_1_dep_vars_01_2.cc | 48 +++++++++++++ ...lper_vector_1_indep_1_dep_vars_01_2.output | 4 ++ .../helper_vector_1_indep_1_dep_vars_01_3.cc | 48 +++++++++++++ ...lper_vector_1_indep_1_dep_vars_01_3.output | 4 ++ .../helper_vector_1_indep_1_dep_vars_01_4.cc | 48 +++++++++++++ ...lper_vector_1_indep_1_dep_vars_01_4.output | 4 ++ .../helper_vector_1_indep_2_dep_vars_01_1.cc | 47 +++++++++++++ ...lper_vector_1_indep_2_dep_vars_01_1.output | 4 ++ .../helper_vector_1_indep_2_dep_vars_01_2.cc | 47 +++++++++++++ ...lper_vector_1_indep_2_dep_vars_01_2.output | 4 ++ .../helper_vector_1_indep_2_dep_vars_01_3.cc | 47 +++++++++++++ ...lper_vector_1_indep_2_dep_vars_01_3.output | 4 ++ .../helper_vector_1_indep_2_dep_vars_01_4.cc | 47 +++++++++++++ ...lper_vector_1_indep_2_dep_vars_01_4.output | 4 ++ .../helper_vector_2_indep_1_dep_vars_01_1.cc | 47 +++++++++++++ ...lper_vector_2_indep_1_dep_vars_01_1.output | 4 ++ .../helper_vector_2_indep_1_dep_vars_01_2.cc | 47 +++++++++++++ ...lper_vector_2_indep_1_dep_vars_01_2.output | 4 ++ .../helper_vector_2_indep_1_dep_vars_01_3.cc | 47 +++++++++++++ ...lper_vector_2_indep_1_dep_vars_01_3.output | 4 ++ .../helper_vector_2_indep_1_dep_vars_01_4.cc | 47 +++++++++++++ ...lper_vector_2_indep_1_dep_vars_01_4.output | 4 ++ .../helper_vector_2_indep_2_dep_vars_01_1.cc | 47 +++++++++++++ ...lper_vector_2_indep_2_dep_vars_01_1.output | 4 ++ .../helper_vector_2_indep_2_dep_vars_01_2.cc | 47 +++++++++++++ ...lper_vector_2_indep_2_dep_vars_01_2.output | 4 ++ .../helper_vector_2_indep_2_dep_vars_01_3.cc | 47 +++++++++++++ ...lper_vector_2_indep_2_dep_vars_01_3.output | 4 ++ .../helper_vector_2_indep_2_dep_vars_01_4.cc | 47 +++++++++++++ ...lper_vector_2_indep_2_dep_vars_01_4.output | 4 ++ tests/sacado/step-44-helper_scalar_01_1.cc | 68 +++++++++++++++++++ .../sacado/step-44-helper_scalar_01_1.output | 11 +++ tests/sacado/step-44-helper_scalar_01_2.cc | 68 +++++++++++++++++++ .../sacado/step-44-helper_scalar_01_2.output | 11 +++ tests/sacado/step-44-helper_vector_01_1.cc | 68 +++++++++++++++++++ .../sacado/step-44-helper_vector_01_1.output | 11 +++ tests/sacado/step-44-helper_vector_01_2.cc | 68 +++++++++++++++++++ .../sacado/step-44-helper_vector_01_2.output | 11 +++ tests/sacado/step-44-helper_vector_01_3.cc | 68 +++++++++++++++++++ .../sacado/step-44-helper_vector_01_3.output | 11 +++ tests/sacado/step-44-helper_vector_01_4.cc | 68 +++++++++++++++++++ .../sacado/step-44-helper_vector_01_4.output | 11 +++ .../sacado/symmetric_tensor_functions_02_1.cc | 40 +++++++++++ .../symmetric_tensor_functions_02_1.output | 3 + .../sacado/symmetric_tensor_functions_02_2.cc | 40 +++++++++++ .../symmetric_tensor_functions_02_2.output | 3 + .../sacado/symmetric_tensor_functions_02_3.cc | 40 +++++++++++ .../symmetric_tensor_functions_02_3.output | 3 + .../sacado/symmetric_tensor_functions_02_4.cc | 40 +++++++++++ .../symmetric_tensor_functions_02_4.output | 3 + .../sacado/symmetric_tensor_functions_03_1.cc | 40 +++++++++++ .../symmetric_tensor_functions_03_1.output | 3 + .../sacado/symmetric_tensor_functions_03_2.cc | 40 +++++++++++ .../symmetric_tensor_functions_03_2.output | 3 + .../sacado/symmetric_tensor_functions_03_3.cc | 40 +++++++++++ .../symmetric_tensor_functions_03_3.output | 3 + .../sacado/symmetric_tensor_functions_03_4.cc | 40 +++++++++++ .../symmetric_tensor_functions_03_4.output | 3 + .../sacado/symmetric_tensor_functions_04_1.cc | 40 +++++++++++ .../symmetric_tensor_functions_04_1.output | 3 + .../sacado/symmetric_tensor_functions_04_2.cc | 40 +++++++++++ .../symmetric_tensor_functions_04_2.output | 3 + .../sacado/symmetric_tensor_functions_04_3.cc | 40 +++++++++++ .../symmetric_tensor_functions_04_3.output | 3 + .../sacado/symmetric_tensor_functions_04_4.cc | 40 +++++++++++ .../symmetric_tensor_functions_04_4.output | 3 + tests/sacado/tensor_functions_02_1.cc | 40 +++++++++++ tests/sacado/tensor_functions_02_1.output | 3 + tests/sacado/tensor_functions_02_2.cc | 40 +++++++++++ tests/sacado/tensor_functions_02_2.output | 3 + tests/sacado/tensor_functions_02_3.cc | 40 +++++++++++ tests/sacado/tensor_functions_02_3.output | 3 + tests/sacado/tensor_functions_02_4.cc | 40 +++++++++++ tests/sacado/tensor_functions_02_4.output | 3 + 194 files changed, 5160 insertions(+) create mode 100644 tests/sacado/ad_number_traits_02c.output.1 create mode 100644 tests/sacado/ad_number_traits_02d.output.1 create mode 100644 tests/sacado/helper_scalar_coupled_2_components_01_1.cc create mode 100644 tests/sacado/helper_scalar_coupled_2_components_01_1.output create mode 100644 tests/sacado/helper_scalar_coupled_2_components_01_2.cc create mode 100644 tests/sacado/helper_scalar_coupled_2_components_01_2.output create mode 100644 tests/sacado/helper_scalar_coupled_2_components_01_3.cc create mode 100644 tests/sacado/helper_scalar_coupled_2_components_01_3.output create mode 100644 tests/sacado/helper_scalar_coupled_2_components_01_4.cc create mode 100644 tests/sacado/helper_scalar_coupled_2_components_01_4.output create mode 100644 tests/sacado/helper_scalar_coupled_2_components_02_1.cc create mode 100644 tests/sacado/helper_scalar_coupled_2_components_02_1.output create mode 100644 tests/sacado/helper_scalar_coupled_2_components_02_2.cc create mode 100644 tests/sacado/helper_scalar_coupled_2_components_02_2.output create mode 100644 tests/sacado/helper_scalar_coupled_2_components_02_3.cc create mode 100644 tests/sacado/helper_scalar_coupled_2_components_02_3.output create mode 100644 tests/sacado/helper_scalar_coupled_2_components_02_4.cc create mode 100644 tests/sacado/helper_scalar_coupled_2_components_02_4.output create mode 100644 tests/sacado/helper_scalar_coupled_2_components_03_1.cc create mode 100644 tests/sacado/helper_scalar_coupled_2_components_03_1.output create mode 100644 tests/sacado/helper_scalar_coupled_2_components_03_2.cc create mode 100644 tests/sacado/helper_scalar_coupled_2_components_03_2.output create mode 100644 tests/sacado/helper_scalar_coupled_2_components_03_3.cc create mode 100644 tests/sacado/helper_scalar_coupled_2_components_03_3.output create mode 100644 tests/sacado/helper_scalar_coupled_2_components_03_4.cc create mode 100644 tests/sacado/helper_scalar_coupled_2_components_03_4.output create mode 100644 tests/sacado/helper_scalar_coupled_2_components_04_1.cc create mode 100644 tests/sacado/helper_scalar_coupled_2_components_04_1.output create mode 100644 tests/sacado/helper_scalar_coupled_2_components_04_2.cc create mode 100644 tests/sacado/helper_scalar_coupled_2_components_04_2.output create mode 100644 tests/sacado/helper_scalar_coupled_2_components_04_3.cc create mode 100644 tests/sacado/helper_scalar_coupled_2_components_04_3.output create mode 100644 tests/sacado/helper_scalar_coupled_2_components_04_4.cc create mode 100644 tests/sacado/helper_scalar_coupled_2_components_04_4.output create mode 100644 tests/sacado/helper_scalar_coupled_2_components_05_1.cc create mode 100644 tests/sacado/helper_scalar_coupled_2_components_05_1.output create mode 100644 tests/sacado/helper_scalar_coupled_2_components_05_2.cc create mode 100644 tests/sacado/helper_scalar_coupled_2_components_05_2.output create mode 100644 tests/sacado/helper_scalar_coupled_2_components_05_3.cc create mode 100644 tests/sacado/helper_scalar_coupled_2_components_05_3.output create mode 100644 tests/sacado/helper_scalar_coupled_2_components_05_4.cc create mode 100644 tests/sacado/helper_scalar_coupled_2_components_05_4.output create mode 100644 tests/sacado/helper_scalar_coupled_2_components_06_1.cc create mode 100644 tests/sacado/helper_scalar_coupled_2_components_06_1.output create mode 100644 tests/sacado/helper_scalar_coupled_2_components_06_2.cc create mode 100644 tests/sacado/helper_scalar_coupled_2_components_06_2.output create mode 100644 tests/sacado/helper_scalar_coupled_2_components_06_3.cc create mode 100644 tests/sacado/helper_scalar_coupled_2_components_06_3.output create mode 100644 tests/sacado/helper_scalar_coupled_2_components_06_4.cc create mode 100644 tests/sacado/helper_scalar_coupled_2_components_06_4.output create mode 100644 tests/sacado/helper_scalar_coupled_2_components_07_1.cc create mode 100644 tests/sacado/helper_scalar_coupled_2_components_07_1.output create mode 100644 tests/sacado/helper_scalar_coupled_2_components_07_2.cc create mode 100644 tests/sacado/helper_scalar_coupled_2_components_07_2.output create mode 100644 tests/sacado/helper_scalar_coupled_2_components_07_3.cc create mode 100644 tests/sacado/helper_scalar_coupled_2_components_07_3.output create mode 100644 tests/sacado/helper_scalar_coupled_2_components_07_4.cc create mode 100644 tests/sacado/helper_scalar_coupled_2_components_07_4.output create mode 100644 tests/sacado/helper_scalar_coupled_2_components_08_1.cc create mode 100644 tests/sacado/helper_scalar_coupled_2_components_08_1.output create mode 100644 tests/sacado/helper_scalar_coupled_2_components_08_2.cc create mode 100644 tests/sacado/helper_scalar_coupled_2_components_08_2.output create mode 100644 tests/sacado/helper_scalar_coupled_2_components_08_3.cc create mode 100644 tests/sacado/helper_scalar_coupled_2_components_08_3.output create mode 100644 tests/sacado/helper_scalar_coupled_2_components_08_4.cc create mode 100644 tests/sacado/helper_scalar_coupled_2_components_08_4.output create mode 100644 tests/sacado/helper_scalar_coupled_3_components_01_1.cc create mode 100644 tests/sacado/helper_scalar_coupled_3_components_01_1.output create mode 100644 tests/sacado/helper_scalar_coupled_3_components_01_1.with_mpi=true.mpirun=2.output create mode 100644 tests/sacado/helper_scalar_coupled_3_components_01_2.cc create mode 100644 tests/sacado/helper_scalar_coupled_3_components_01_2.output create mode 100644 tests/sacado/helper_scalar_coupled_3_components_01_2.with_mpi=true.mpirun=2.output create mode 100644 tests/sacado/helper_scalar_coupled_3_components_01_3.cc create mode 100644 tests/sacado/helper_scalar_coupled_3_components_01_3.output create mode 100644 tests/sacado/helper_scalar_coupled_3_components_01_3.with_mpi=true.mpirun=2.output create mode 100644 tests/sacado/helper_scalar_coupled_3_components_01_4.cc create mode 100644 tests/sacado/helper_scalar_coupled_3_components_01_4.output create mode 100644 tests/sacado/helper_scalar_coupled_3_components_01_4.with_mpi=true.mpirun=2.output create mode 100644 tests/sacado/helper_scalar_coupled_3_components_01_tapeless_only_1.cc create mode 100644 tests/sacado/helper_scalar_coupled_3_components_01_tapeless_only_1.output create mode 100644 tests/sacado/helper_scalar_coupled_3_components_01_tapeless_only_2.cc create mode 100644 tests/sacado/helper_scalar_coupled_3_components_01_tapeless_only_2.output create mode 100644 tests/sacado/helper_scalar_coupled_3_components_01_tapeless_only_3.cc create mode 100644 tests/sacado/helper_scalar_coupled_3_components_01_tapeless_only_3.output create mode 100644 tests/sacado/helper_scalar_coupled_3_components_01_tapeless_only_4.cc create mode 100644 tests/sacado/helper_scalar_coupled_3_components_01_tapeless_only_4.output create mode 100644 tests/sacado/helper_scalar_single_component_01_1.cc create mode 100644 tests/sacado/helper_scalar_single_component_01_1.output create mode 100644 tests/sacado/helper_scalar_single_component_01_2.cc create mode 100644 tests/sacado/helper_scalar_single_component_01_2.output create mode 100644 tests/sacado/helper_scalar_single_component_01_3.cc create mode 100644 tests/sacado/helper_scalar_single_component_01_3.output create mode 100644 tests/sacado/helper_scalar_single_component_01_4.cc create mode 100644 tests/sacado/helper_scalar_single_component_01_4.output create mode 100644 tests/sacado/helper_scalar_single_component_02_1.cc create mode 100644 tests/sacado/helper_scalar_single_component_02_1.output create mode 100644 tests/sacado/helper_scalar_single_component_02_2.cc create mode 100644 tests/sacado/helper_scalar_single_component_02_2.output create mode 100644 tests/sacado/helper_scalar_single_component_02_3.cc create mode 100644 tests/sacado/helper_scalar_single_component_02_3.output create mode 100644 tests/sacado/helper_scalar_single_component_02_4.cc create mode 100644 tests/sacado/helper_scalar_single_component_02_4.output create mode 100644 tests/sacado/helper_scalar_single_component_03_1.cc create mode 100644 tests/sacado/helper_scalar_single_component_03_1.output create mode 100644 tests/sacado/helper_scalar_single_component_03_2.cc create mode 100644 tests/sacado/helper_scalar_single_component_03_2.output create mode 100644 tests/sacado/helper_scalar_single_component_03_3.cc create mode 100644 tests/sacado/helper_scalar_single_component_03_3.output create mode 100644 tests/sacado/helper_scalar_single_component_03_4.cc create mode 100644 tests/sacado/helper_scalar_single_component_03_4.output create mode 100644 tests/sacado/helper_scalar_single_component_04_1.cc create mode 100644 tests/sacado/helper_scalar_single_component_04_1.output create mode 100644 tests/sacado/helper_scalar_single_component_04_2.cc create mode 100644 tests/sacado/helper_scalar_single_component_04_2.output create mode 100644 tests/sacado/helper_scalar_single_component_04_3.cc create mode 100644 tests/sacado/helper_scalar_single_component_04_3.output create mode 100644 tests/sacado/helper_scalar_single_component_04_4.cc create mode 100644 tests/sacado/helper_scalar_single_component_04_4.output create mode 100644 tests/sacado/helper_vector_1_indep_1_dep_vars_01_1.cc create mode 100644 tests/sacado/helper_vector_1_indep_1_dep_vars_01_1.output create mode 100644 tests/sacado/helper_vector_1_indep_1_dep_vars_01_2.cc create mode 100644 tests/sacado/helper_vector_1_indep_1_dep_vars_01_2.output create mode 100644 tests/sacado/helper_vector_1_indep_1_dep_vars_01_3.cc create mode 100644 tests/sacado/helper_vector_1_indep_1_dep_vars_01_3.output create mode 100644 tests/sacado/helper_vector_1_indep_1_dep_vars_01_4.cc create mode 100644 tests/sacado/helper_vector_1_indep_1_dep_vars_01_4.output create mode 100644 tests/sacado/helper_vector_1_indep_2_dep_vars_01_1.cc create mode 100644 tests/sacado/helper_vector_1_indep_2_dep_vars_01_1.output create mode 100644 tests/sacado/helper_vector_1_indep_2_dep_vars_01_2.cc create mode 100644 tests/sacado/helper_vector_1_indep_2_dep_vars_01_2.output create mode 100644 tests/sacado/helper_vector_1_indep_2_dep_vars_01_3.cc create mode 100644 tests/sacado/helper_vector_1_indep_2_dep_vars_01_3.output create mode 100644 tests/sacado/helper_vector_1_indep_2_dep_vars_01_4.cc create mode 100644 tests/sacado/helper_vector_1_indep_2_dep_vars_01_4.output create mode 100644 tests/sacado/helper_vector_2_indep_1_dep_vars_01_1.cc create mode 100644 tests/sacado/helper_vector_2_indep_1_dep_vars_01_1.output create mode 100644 tests/sacado/helper_vector_2_indep_1_dep_vars_01_2.cc create mode 100644 tests/sacado/helper_vector_2_indep_1_dep_vars_01_2.output create mode 100644 tests/sacado/helper_vector_2_indep_1_dep_vars_01_3.cc create mode 100644 tests/sacado/helper_vector_2_indep_1_dep_vars_01_3.output create mode 100644 tests/sacado/helper_vector_2_indep_1_dep_vars_01_4.cc create mode 100644 tests/sacado/helper_vector_2_indep_1_dep_vars_01_4.output create mode 100644 tests/sacado/helper_vector_2_indep_2_dep_vars_01_1.cc create mode 100644 tests/sacado/helper_vector_2_indep_2_dep_vars_01_1.output create mode 100644 tests/sacado/helper_vector_2_indep_2_dep_vars_01_2.cc create mode 100644 tests/sacado/helper_vector_2_indep_2_dep_vars_01_2.output create mode 100644 tests/sacado/helper_vector_2_indep_2_dep_vars_01_3.cc create mode 100644 tests/sacado/helper_vector_2_indep_2_dep_vars_01_3.output create mode 100644 tests/sacado/helper_vector_2_indep_2_dep_vars_01_4.cc create mode 100644 tests/sacado/helper_vector_2_indep_2_dep_vars_01_4.output create mode 100644 tests/sacado/step-44-helper_scalar_01_1.cc create mode 100644 tests/sacado/step-44-helper_scalar_01_1.output create mode 100644 tests/sacado/step-44-helper_scalar_01_2.cc create mode 100644 tests/sacado/step-44-helper_scalar_01_2.output create mode 100644 tests/sacado/step-44-helper_vector_01_1.cc create mode 100644 tests/sacado/step-44-helper_vector_01_1.output create mode 100644 tests/sacado/step-44-helper_vector_01_2.cc create mode 100644 tests/sacado/step-44-helper_vector_01_2.output create mode 100644 tests/sacado/step-44-helper_vector_01_3.cc create mode 100644 tests/sacado/step-44-helper_vector_01_3.output create mode 100644 tests/sacado/step-44-helper_vector_01_4.cc create mode 100644 tests/sacado/step-44-helper_vector_01_4.output create mode 100644 tests/sacado/symmetric_tensor_functions_02_1.cc create mode 100644 tests/sacado/symmetric_tensor_functions_02_1.output create mode 100644 tests/sacado/symmetric_tensor_functions_02_2.cc create mode 100644 tests/sacado/symmetric_tensor_functions_02_2.output create mode 100644 tests/sacado/symmetric_tensor_functions_02_3.cc create mode 100644 tests/sacado/symmetric_tensor_functions_02_3.output create mode 100644 tests/sacado/symmetric_tensor_functions_02_4.cc create mode 100644 tests/sacado/symmetric_tensor_functions_02_4.output create mode 100644 tests/sacado/symmetric_tensor_functions_03_1.cc create mode 100644 tests/sacado/symmetric_tensor_functions_03_1.output create mode 100644 tests/sacado/symmetric_tensor_functions_03_2.cc create mode 100644 tests/sacado/symmetric_tensor_functions_03_2.output create mode 100644 tests/sacado/symmetric_tensor_functions_03_3.cc create mode 100644 tests/sacado/symmetric_tensor_functions_03_3.output create mode 100644 tests/sacado/symmetric_tensor_functions_03_4.cc create mode 100644 tests/sacado/symmetric_tensor_functions_03_4.output create mode 100644 tests/sacado/symmetric_tensor_functions_04_1.cc create mode 100644 tests/sacado/symmetric_tensor_functions_04_1.output create mode 100644 tests/sacado/symmetric_tensor_functions_04_2.cc create mode 100644 tests/sacado/symmetric_tensor_functions_04_2.output create mode 100644 tests/sacado/symmetric_tensor_functions_04_3.cc create mode 100644 tests/sacado/symmetric_tensor_functions_04_3.output create mode 100644 tests/sacado/symmetric_tensor_functions_04_4.cc create mode 100644 tests/sacado/symmetric_tensor_functions_04_4.output create mode 100644 tests/sacado/tensor_functions_02_1.cc create mode 100644 tests/sacado/tensor_functions_02_1.output create mode 100644 tests/sacado/tensor_functions_02_2.cc create mode 100644 tests/sacado/tensor_functions_02_2.output create mode 100644 tests/sacado/tensor_functions_02_3.cc create mode 100644 tests/sacado/tensor_functions_02_3.output create mode 100644 tests/sacado/tensor_functions_02_4.cc create mode 100644 tests/sacado/tensor_functions_02_4.output diff --git a/tests/sacado/ad_number_traits_02c.output.1 b/tests/sacado/ad_number_traits_02c.output.1 new file mode 100644 index 0000000000..714b05562f --- /dev/null +++ b/tests/sacado/ad_number_traits_02c.output.1 @@ -0,0 +1,63 @@ + +DEAL:NumberTraits:float::type_code: 4 +DEAL:NumberTraits:float::is_taped: 0 +DEAL:NumberTraits:float::is_tapeless: 1 +DEAL:NumberTraits:float::is_real_valued: 1 +DEAL:NumberTraits:float::is_complex_valued: 0 +DEAL:NumberTraits:float::n_supported_derivative_levels: 1 +DEAL:NumberTraits:float::is_ad_number: 1 +DEAL:NumberTraits:float::is_sacado_number: 1 +DEAL:NumberTraits:float::is_taped_ad_number: 0 +DEAL:NumberTraits:float::is_tapeless_ad_number: 1 +DEAL:NumberTraits:double::type_code: 4 +DEAL:NumberTraits:double::is_taped: 0 +DEAL:NumberTraits:double::is_tapeless: 1 +DEAL:NumberTraits:double::is_real_valued: 1 +DEAL:NumberTraits:double::is_complex_valued: 0 +DEAL:NumberTraits:double::n_supported_derivative_levels: 1 +DEAL:NumberTraits:double::is_ad_number: 1 +DEAL:NumberTraits:double::is_sacado_number: 1 +DEAL:NumberTraits:double::is_taped_ad_number: 0 +DEAL:NumberTraits:double::is_tapeless_ad_number: 1 +DEAL:NumberTraits:Sacado::Rad::ADvar::type_code: 4 +DEAL:NumberTraits:Sacado::Rad::ADvar::is_taped: 0 +DEAL:NumberTraits:Sacado::Rad::ADvar::is_tapeless: 1 +DEAL:NumberTraits:Sacado::Rad::ADvar::is_real_valued: 1 +DEAL:NumberTraits:Sacado::Rad::ADvar::is_complex_valued: 0 +DEAL:NumberTraits:Sacado::Rad::ADvar::n_supported_derivative_levels: 1 +DEAL:NumberTraits:Sacado::Rad::ADvar::is_ad_number: 1 +DEAL:NumberTraits:Sacado::Rad::ADvar::is_sacado_number: 1 +DEAL:NumberTraits:Sacado::Rad::ADvar::is_taped_ad_number: 0 +DEAL:NumberTraits:Sacado::Rad::ADvar::is_tapeless_ad_number: 1 +DEAL:NumberTraits:Sacado::Rad::ADvar::type_code: 4 +DEAL:NumberTraits:Sacado::Rad::ADvar::is_taped: 0 +DEAL:NumberTraits:Sacado::Rad::ADvar::is_tapeless: 1 +DEAL:NumberTraits:Sacado::Rad::ADvar::is_real_valued: 1 +DEAL:NumberTraits:Sacado::Rad::ADvar::is_complex_valued: 0 +DEAL:NumberTraits:Sacado::Rad::ADvar::n_supported_derivative_levels: 1 +DEAL:NumberTraits:Sacado::Rad::ADvar::is_ad_number: 1 +DEAL:NumberTraits:Sacado::Rad::ADvar::is_sacado_number: 1 +DEAL:NumberTraits:Sacado::Rad::ADvar::is_taped_ad_number: 0 +DEAL:NumberTraits:Sacado::Rad::ADvar::is_tapeless_ad_number: 1 +DEAL:: +DEAL:ADNumberTraits:Sacado::Rad::ADvar::type_code: 4 +DEAL:ADNumberTraits:Sacado::Rad::ADvar::is_taped: 0 +DEAL:ADNumberTraits:Sacado::Rad::ADvar::is_tapeless: 1 +DEAL:ADNumberTraits:Sacado::Rad::ADvar::is_real_valued: 1 +DEAL:ADNumberTraits:Sacado::Rad::ADvar::is_complex_valued: 0 +DEAL:ADNumberTraits:Sacado::Rad::ADvar::n_supported_derivative_levels: 1 +DEAL:ADNumberTraits:Sacado::Rad::ADvar::is_ad_number: 1 +DEAL:ADNumberTraits:Sacado::Rad::ADvar::is_sacado_number: 1 +DEAL:ADNumberTraits:Sacado::Rad::ADvar::is_taped_ad_number: 0 +DEAL:ADNumberTraits:Sacado::Rad::ADvar::is_tapeless_ad_number: 1 +DEAL:ADNumberTraits:Sacado::Rad::ADvar::type_code: 4 +DEAL:ADNumberTraits:Sacado::Rad::ADvar::is_taped: 0 +DEAL:ADNumberTraits:Sacado::Rad::ADvar::is_tapeless: 1 +DEAL:ADNumberTraits:Sacado::Rad::ADvar::is_real_valued: 1 +DEAL:ADNumberTraits:Sacado::Rad::ADvar::is_complex_valued: 0 +DEAL:ADNumberTraits:Sacado::Rad::ADvar::n_supported_derivative_levels: 1 +DEAL:ADNumberTraits:Sacado::Rad::ADvar::is_ad_number: 1 +DEAL:ADNumberTraits:Sacado::Rad::ADvar::is_sacado_number: 1 +DEAL:ADNumberTraits:Sacado::Rad::ADvar::is_taped_ad_number: 0 +DEAL:ADNumberTraits:Sacado::Rad::ADvar::is_tapeless_ad_number: 1 +DEAL::OK diff --git a/tests/sacado/ad_number_traits_02d.output.1 b/tests/sacado/ad_number_traits_02d.output.1 new file mode 100644 index 0000000000..38016dbd17 --- /dev/null +++ b/tests/sacado/ad_number_traits_02d.output.1 @@ -0,0 +1,63 @@ + +DEAL:NumberTraits:float::type_code: 5 +DEAL:NumberTraits:float::is_taped: 0 +DEAL:NumberTraits:float::is_tapeless: 1 +DEAL:NumberTraits:float::is_real_valued: 1 +DEAL:NumberTraits:float::is_complex_valued: 0 +DEAL:NumberTraits:float::n_supported_derivative_levels: 2 +DEAL:NumberTraits:float::is_ad_number: 1 +DEAL:NumberTraits:float::is_sacado_number: 1 +DEAL:NumberTraits:float::is_taped_ad_number: 0 +DEAL:NumberTraits:float::is_tapeless_ad_number: 1 +DEAL:NumberTraits:double::type_code: 5 +DEAL:NumberTraits:double::is_taped: 0 +DEAL:NumberTraits:double::is_tapeless: 1 +DEAL:NumberTraits:double::is_real_valued: 1 +DEAL:NumberTraits:double::is_complex_valued: 0 +DEAL:NumberTraits:double::n_supported_derivative_levels: 2 +DEAL:NumberTraits:double::is_ad_number: 1 +DEAL:NumberTraits:double::is_sacado_number: 1 +DEAL:NumberTraits:double::is_taped_ad_number: 0 +DEAL:NumberTraits:double::is_tapeless_ad_number: 1 +DEAL:NumberTraits:Sacado::Rad::ADvar >::type_code: 5 +DEAL:NumberTraits:Sacado::Rad::ADvar >::is_taped: 0 +DEAL:NumberTraits:Sacado::Rad::ADvar >::is_tapeless: 1 +DEAL:NumberTraits:Sacado::Rad::ADvar >::is_real_valued: 1 +DEAL:NumberTraits:Sacado::Rad::ADvar >::is_complex_valued: 0 +DEAL:NumberTraits:Sacado::Rad::ADvar >::n_supported_derivative_levels: 2 +DEAL:NumberTraits:Sacado::Rad::ADvar >::is_ad_number: 1 +DEAL:NumberTraits:Sacado::Rad::ADvar >::is_sacado_number: 1 +DEAL:NumberTraits:Sacado::Rad::ADvar >::is_taped_ad_number: 0 +DEAL:NumberTraits:Sacado::Rad::ADvar >::is_tapeless_ad_number: 1 +DEAL:NumberTraits:Sacado::Rad::ADvar >::type_code: 5 +DEAL:NumberTraits:Sacado::Rad::ADvar >::is_taped: 0 +DEAL:NumberTraits:Sacado::Rad::ADvar >::is_tapeless: 1 +DEAL:NumberTraits:Sacado::Rad::ADvar >::is_real_valued: 1 +DEAL:NumberTraits:Sacado::Rad::ADvar >::is_complex_valued: 0 +DEAL:NumberTraits:Sacado::Rad::ADvar >::n_supported_derivative_levels: 2 +DEAL:NumberTraits:Sacado::Rad::ADvar >::is_ad_number: 1 +DEAL:NumberTraits:Sacado::Rad::ADvar >::is_sacado_number: 1 +DEAL:NumberTraits:Sacado::Rad::ADvar >::is_taped_ad_number: 0 +DEAL:NumberTraits:Sacado::Rad::ADvar >::is_tapeless_ad_number: 1 +DEAL:: +DEAL:ADNumberTraits:Sacado::Rad::ADvar >::type_code: 5 +DEAL:ADNumberTraits:Sacado::Rad::ADvar >::is_taped: 0 +DEAL:ADNumberTraits:Sacado::Rad::ADvar >::is_tapeless: 1 +DEAL:ADNumberTraits:Sacado::Rad::ADvar >::is_real_valued: 1 +DEAL:ADNumberTraits:Sacado::Rad::ADvar >::is_complex_valued: 0 +DEAL:ADNumberTraits:Sacado::Rad::ADvar >::n_supported_derivative_levels: 2 +DEAL:ADNumberTraits:Sacado::Rad::ADvar >::is_ad_number: 1 +DEAL:ADNumberTraits:Sacado::Rad::ADvar >::is_sacado_number: 1 +DEAL:ADNumberTraits:Sacado::Rad::ADvar >::is_taped_ad_number: 0 +DEAL:ADNumberTraits:Sacado::Rad::ADvar >::is_tapeless_ad_number: 1 +DEAL:ADNumberTraits:Sacado::Rad::ADvar >::type_code: 5 +DEAL:ADNumberTraits:Sacado::Rad::ADvar >::is_taped: 0 +DEAL:ADNumberTraits:Sacado::Rad::ADvar >::is_tapeless: 1 +DEAL:ADNumberTraits:Sacado::Rad::ADvar >::is_real_valued: 1 +DEAL:ADNumberTraits:Sacado::Rad::ADvar >::is_complex_valued: 0 +DEAL:ADNumberTraits:Sacado::Rad::ADvar >::n_supported_derivative_levels: 2 +DEAL:ADNumberTraits:Sacado::Rad::ADvar >::is_ad_number: 1 +DEAL:ADNumberTraits:Sacado::Rad::ADvar >::is_sacado_number: 1 +DEAL:ADNumberTraits:Sacado::Rad::ADvar >::is_taped_ad_number: 0 +DEAL:ADNumberTraits:Sacado::Rad::ADvar >::is_tapeless_ad_number: 1 +DEAL::OK diff --git a/tests/sacado/helper_scalar_coupled_2_components_01_1.cc b/tests/sacado/helper_scalar_coupled_2_components_01_1.cc new file mode 100644 index 0000000000..3548f1fd28 --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_01_1.cc @@ -0,0 +1,47 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a coupled system (scalar + scalar components) +// using a helper class +// +// AD number type: Sacado DFad + +#include "../ad_common_tests/helper_scalar_coupled_2_components_01.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_scalar_scalar_coupled<2, double, AD::NumberTypes::sacado_dfad>(); + test_scalar_scalar_coupled<3, double, AD::NumberTypes::sacado_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_scalar_scalar_coupled<2, float, AD::NumberTypes::sacado_dfad>(); + test_scalar_scalar_coupled<3, float, AD::NumberTypes::sacado_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_coupled_2_components_01_1.output b/tests/sacado/helper_scalar_coupled_2_components_01_1.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_01_1.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_coupled_2_components_01_2.cc b/tests/sacado/helper_scalar_coupled_2_components_01_2.cc new file mode 100644 index 0000000000..348ff16548 --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_01_2.cc @@ -0,0 +1,47 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a coupled system (scalar + scalar components) +// using a helper class +// +// AD number type: Sacado DFad-DFad + +#include "../ad_common_tests/helper_scalar_coupled_2_components_01.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_scalar_scalar_coupled<2, double, AD::NumberTypes::sacado_dfad_dfad>(); + test_scalar_scalar_coupled<3, double, AD::NumberTypes::sacado_dfad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_scalar_scalar_coupled<2, float, AD::NumberTypes::sacado_dfad_dfad>(); + test_scalar_scalar_coupled<3, float, AD::NumberTypes::sacado_dfad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_coupled_2_components_01_2.output b/tests/sacado/helper_scalar_coupled_2_components_01_2.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_01_2.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_coupled_2_components_01_3.cc b/tests/sacado/helper_scalar_coupled_2_components_01_3.cc new file mode 100644 index 0000000000..e7248f3f94 --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_01_3.cc @@ -0,0 +1,47 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a coupled system (scalar + scalar components) +// using a helper class +// +// AD number type: Sacado Rad + +#include "../ad_common_tests/helper_scalar_coupled_2_components_01.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_scalar_scalar_coupled<2, double, AD::NumberTypes::sacado_rad>(); + test_scalar_scalar_coupled<3, double, AD::NumberTypes::sacado_rad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_scalar_scalar_coupled<2, float, AD::NumberTypes::sacado_rad>(); + test_scalar_scalar_coupled<3, float, AD::NumberTypes::sacado_rad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_coupled_2_components_01_3.output b/tests/sacado/helper_scalar_coupled_2_components_01_3.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_01_3.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_coupled_2_components_01_4.cc b/tests/sacado/helper_scalar_coupled_2_components_01_4.cc new file mode 100644 index 0000000000..2ec5f918b3 --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_01_4.cc @@ -0,0 +1,47 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a coupled system (scalar + scalar components) +// using a helper class +// +// AD number type: Sacado Rad-DFad + +#include "../ad_common_tests/helper_scalar_coupled_2_components_01.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_scalar_scalar_coupled<2, double, AD::NumberTypes::sacado_rad_dfad>(); + test_scalar_scalar_coupled<3, double, AD::NumberTypes::sacado_rad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_scalar_scalar_coupled<2, float, AD::NumberTypes::sacado_rad_dfad>(); + test_scalar_scalar_coupled<3, float, AD::NumberTypes::sacado_rad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_coupled_2_components_01_4.output b/tests/sacado/helper_scalar_coupled_2_components_01_4.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_01_4.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_coupled_2_components_02_1.cc b/tests/sacado/helper_scalar_coupled_2_components_02_1.cc new file mode 100644 index 0000000000..924288f014 --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_02_1.cc @@ -0,0 +1,47 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a coupled system (vector + scalar components) +// using a helper class +// +// AD number type: Sacado DFad + +#include "../ad_common_tests/helper_scalar_coupled_2_components_02.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_vector_scalar_coupled<2, double, AD::NumberTypes::sacado_dfad>(); + test_vector_scalar_coupled<3, double, AD::NumberTypes::sacado_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_vector_scalar_coupled<2, float, AD::NumberTypes::sacado_dfad>(); + test_vector_scalar_coupled<3, float, AD::NumberTypes::sacado_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_coupled_2_components_02_1.output b/tests/sacado/helper_scalar_coupled_2_components_02_1.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_02_1.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_coupled_2_components_02_2.cc b/tests/sacado/helper_scalar_coupled_2_components_02_2.cc new file mode 100644 index 0000000000..0e43703980 --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_02_2.cc @@ -0,0 +1,47 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a coupled system (vector + scalar components) +// using a helper class +// +// AD number type: Sacado DFad-DFad + +#include "../ad_common_tests/helper_scalar_coupled_2_components_02.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_vector_scalar_coupled<2, double, AD::NumberTypes::sacado_dfad_dfad>(); + test_vector_scalar_coupled<3, double, AD::NumberTypes::sacado_dfad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_vector_scalar_coupled<2, float, AD::NumberTypes::sacado_dfad_dfad>(); + test_vector_scalar_coupled<3, float, AD::NumberTypes::sacado_dfad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_coupled_2_components_02_2.output b/tests/sacado/helper_scalar_coupled_2_components_02_2.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_02_2.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_coupled_2_components_02_3.cc b/tests/sacado/helper_scalar_coupled_2_components_02_3.cc new file mode 100644 index 0000000000..7727992255 --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_02_3.cc @@ -0,0 +1,47 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a coupled system (vector + scalar components) +// using a helper class +// +// AD number type: Sacado Rad + +#include "../ad_common_tests/helper_scalar_coupled_2_components_02.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_vector_scalar_coupled<2, double, AD::NumberTypes::sacado_rad>(); + test_vector_scalar_coupled<3, double, AD::NumberTypes::sacado_rad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_vector_scalar_coupled<2, float, AD::NumberTypes::sacado_rad>(); + test_vector_scalar_coupled<3, float, AD::NumberTypes::sacado_rad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_coupled_2_components_02_3.output b/tests/sacado/helper_scalar_coupled_2_components_02_3.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_02_3.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_coupled_2_components_02_4.cc b/tests/sacado/helper_scalar_coupled_2_components_02_4.cc new file mode 100644 index 0000000000..5c2ccb3491 --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_02_4.cc @@ -0,0 +1,47 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a coupled system (vector + scalar components) +// using a helper class +// +// AD number type: Sacado Rad-DFad + +#include "../ad_common_tests/helper_scalar_coupled_2_components_02.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_vector_scalar_coupled<2, double, AD::NumberTypes::sacado_rad_dfad>(); + test_vector_scalar_coupled<3, double, AD::NumberTypes::sacado_rad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_vector_scalar_coupled<2, float, AD::NumberTypes::sacado_rad_dfad>(); + test_vector_scalar_coupled<3, float, AD::NumberTypes::sacado_rad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_coupled_2_components_02_4.output b/tests/sacado/helper_scalar_coupled_2_components_02_4.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_02_4.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_coupled_2_components_03_1.cc b/tests/sacado/helper_scalar_coupled_2_components_03_1.cc new file mode 100644 index 0000000000..e941e99313 --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_03_1.cc @@ -0,0 +1,47 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a coupled system (tensor + scalar components) +// using a helper class +// +// AD number type: Sacado DFad + +#include "../ad_common_tests/helper_scalar_coupled_2_components_03.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_tensor_scalar_coupled<2, double, AD::NumberTypes::sacado_dfad>(); + test_tensor_scalar_coupled<3, double, AD::NumberTypes::sacado_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_tensor_scalar_coupled<2, float, AD::NumberTypes::sacado_dfad>(); + test_tensor_scalar_coupled<3, float, AD::NumberTypes::sacado_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_coupled_2_components_03_1.output b/tests/sacado/helper_scalar_coupled_2_components_03_1.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_03_1.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_coupled_2_components_03_2.cc b/tests/sacado/helper_scalar_coupled_2_components_03_2.cc new file mode 100644 index 0000000000..b70268b806 --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_03_2.cc @@ -0,0 +1,47 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a coupled system (tensor + scalar components) +// using a helper class +// +// AD number type: Sacado DFad-DFad + +#include "../ad_common_tests/helper_scalar_coupled_2_components_03.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_tensor_scalar_coupled<2, double, AD::NumberTypes::sacado_dfad_dfad>(); + test_tensor_scalar_coupled<3, double, AD::NumberTypes::sacado_dfad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_tensor_scalar_coupled<2, float, AD::NumberTypes::sacado_dfad_dfad>(); + test_tensor_scalar_coupled<3, float, AD::NumberTypes::sacado_dfad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_coupled_2_components_03_2.output b/tests/sacado/helper_scalar_coupled_2_components_03_2.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_03_2.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_coupled_2_components_03_3.cc b/tests/sacado/helper_scalar_coupled_2_components_03_3.cc new file mode 100644 index 0000000000..e8c7be62a5 --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_03_3.cc @@ -0,0 +1,47 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a coupled system (tensor + scalar components) +// using a helper class +// +// AD number type: Sacado Rad + +#include "../ad_common_tests/helper_scalar_coupled_2_components_03.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_tensor_scalar_coupled<2, double, AD::NumberTypes::sacado_rad>(); + test_tensor_scalar_coupled<3, double, AD::NumberTypes::sacado_rad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_tensor_scalar_coupled<2, float, AD::NumberTypes::sacado_rad>(); + test_tensor_scalar_coupled<3, float, AD::NumberTypes::sacado_rad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_coupled_2_components_03_3.output b/tests/sacado/helper_scalar_coupled_2_components_03_3.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_03_3.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_coupled_2_components_03_4.cc b/tests/sacado/helper_scalar_coupled_2_components_03_4.cc new file mode 100644 index 0000000000..144275e8b6 --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_03_4.cc @@ -0,0 +1,47 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a coupled system (tensor + scalar components) +// using a helper class +// +// AD number type: Sacado Rad-DFad + +#include "../ad_common_tests/helper_scalar_coupled_2_components_03.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_tensor_scalar_coupled<2, double, AD::NumberTypes::sacado_rad_dfad>(); + test_tensor_scalar_coupled<3, double, AD::NumberTypes::sacado_rad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_tensor_scalar_coupled<2, float, AD::NumberTypes::sacado_rad_dfad>(); + test_tensor_scalar_coupled<3, float, AD::NumberTypes::sacado_rad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_coupled_2_components_03_4.output b/tests/sacado/helper_scalar_coupled_2_components_03_4.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_03_4.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_coupled_2_components_04_1.cc b/tests/sacado/helper_scalar_coupled_2_components_04_1.cc new file mode 100644 index 0000000000..ac17fe0e23 --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_04_1.cc @@ -0,0 +1,47 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a coupled system (vector + vector components) +// using a helper class +// +// AD number type: Sacado DFad + +#include "../ad_common_tests/helper_scalar_coupled_2_components_04.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_vector_vector_coupled<2, double, AD::NumberTypes::sacado_dfad>(); + test_vector_vector_coupled<3, double, AD::NumberTypes::sacado_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_vector_vector_coupled<2, float, AD::NumberTypes::sacado_dfad>(); + test_vector_vector_coupled<3, float, AD::NumberTypes::sacado_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_coupled_2_components_04_1.output b/tests/sacado/helper_scalar_coupled_2_components_04_1.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_04_1.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_coupled_2_components_04_2.cc b/tests/sacado/helper_scalar_coupled_2_components_04_2.cc new file mode 100644 index 0000000000..e0a85ecba8 --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_04_2.cc @@ -0,0 +1,47 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a coupled system (vector + vector components) +// using a helper class +// +// AD number type: Sacado DFad-DFad + +#include "../ad_common_tests/helper_scalar_coupled_2_components_04.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_vector_vector_coupled<2, double, AD::NumberTypes::sacado_dfad_dfad>(); + test_vector_vector_coupled<3, double, AD::NumberTypes::sacado_dfad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_vector_vector_coupled<2, float, AD::NumberTypes::sacado_dfad_dfad>(); + test_vector_vector_coupled<3, float, AD::NumberTypes::sacado_dfad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_coupled_2_components_04_2.output b/tests/sacado/helper_scalar_coupled_2_components_04_2.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_04_2.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_coupled_2_components_04_3.cc b/tests/sacado/helper_scalar_coupled_2_components_04_3.cc new file mode 100644 index 0000000000..0d6355287f --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_04_3.cc @@ -0,0 +1,47 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a coupled system (vector + vector components) +// using a helper class +// +// AD number type: Sacado Rad + +#include "../ad_common_tests/helper_scalar_coupled_2_components_04.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_vector_vector_coupled<2, double, AD::NumberTypes::sacado_rad>(); + test_vector_vector_coupled<3, double, AD::NumberTypes::sacado_rad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_vector_vector_coupled<2, float, AD::NumberTypes::sacado_rad>(); + test_vector_vector_coupled<3, float, AD::NumberTypes::sacado_rad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_coupled_2_components_04_3.output b/tests/sacado/helper_scalar_coupled_2_components_04_3.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_04_3.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_coupled_2_components_04_4.cc b/tests/sacado/helper_scalar_coupled_2_components_04_4.cc new file mode 100644 index 0000000000..96314c1157 --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_04_4.cc @@ -0,0 +1,47 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a coupled system (vector + vector components) +// using a helper class +// +// AD number type: Sacado Rad-DFad + +#include "../ad_common_tests/helper_scalar_coupled_2_components_04.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_vector_vector_coupled<2, double, AD::NumberTypes::sacado_rad_dfad>(); + test_vector_vector_coupled<3, double, AD::NumberTypes::sacado_rad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_vector_vector_coupled<2, float, AD::NumberTypes::sacado_rad_dfad>(); + test_vector_vector_coupled<3, float, AD::NumberTypes::sacado_rad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_coupled_2_components_04_4.output b/tests/sacado/helper_scalar_coupled_2_components_04_4.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_04_4.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_coupled_2_components_05_1.cc b/tests/sacado/helper_scalar_coupled_2_components_05_1.cc new file mode 100644 index 0000000000..06737ac041 --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_05_1.cc @@ -0,0 +1,47 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a coupled system (tensor + vector components) +// using a helper class +// +// AD number type: Sacado DFad + +#include "../ad_common_tests/helper_scalar_coupled_2_components_05.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_tensor_vector_coupled<2, double, AD::NumberTypes::sacado_dfad>(); + test_tensor_vector_coupled<3, double, AD::NumberTypes::sacado_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_tensor_vector_coupled<2, float, AD::NumberTypes::sacado_dfad>(); + test_tensor_vector_coupled<3, float, AD::NumberTypes::sacado_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_coupled_2_components_05_1.output b/tests/sacado/helper_scalar_coupled_2_components_05_1.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_05_1.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_coupled_2_components_05_2.cc b/tests/sacado/helper_scalar_coupled_2_components_05_2.cc new file mode 100644 index 0000000000..d76a2e67e9 --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_05_2.cc @@ -0,0 +1,47 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a coupled system (tensor + vector components) +// using a helper class +// +// AD number type: Sacado DFad-DFad + +#include "../ad_common_tests/helper_scalar_coupled_2_components_05.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_tensor_vector_coupled<2, double, AD::NumberTypes::sacado_dfad_dfad>(); + test_tensor_vector_coupled<3, double, AD::NumberTypes::sacado_dfad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_tensor_vector_coupled<2, float, AD::NumberTypes::sacado_dfad_dfad>(); + test_tensor_vector_coupled<3, float, AD::NumberTypes::sacado_dfad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_coupled_2_components_05_2.output b/tests/sacado/helper_scalar_coupled_2_components_05_2.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_05_2.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_coupled_2_components_05_3.cc b/tests/sacado/helper_scalar_coupled_2_components_05_3.cc new file mode 100644 index 0000000000..b5c6d90efb --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_05_3.cc @@ -0,0 +1,47 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a coupled system (tensor + vector components) +// using a helper class +// +// AD number type: Sacado Rad + +#include "../ad_common_tests/helper_scalar_coupled_2_components_05.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_tensor_vector_coupled<2, double, AD::NumberTypes::sacado_rad>(); + test_tensor_vector_coupled<3, double, AD::NumberTypes::sacado_rad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_tensor_vector_coupled<2, float, AD::NumberTypes::sacado_rad>(); + test_tensor_vector_coupled<3, float, AD::NumberTypes::sacado_rad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_coupled_2_components_05_3.output b/tests/sacado/helper_scalar_coupled_2_components_05_3.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_05_3.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_coupled_2_components_05_4.cc b/tests/sacado/helper_scalar_coupled_2_components_05_4.cc new file mode 100644 index 0000000000..79f4b5c29f --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_05_4.cc @@ -0,0 +1,47 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a coupled system (tensor + vector components) +// using a helper class +// +// AD number type: Sacado Rad-DFad + +#include "../ad_common_tests/helper_scalar_coupled_2_components_05.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_tensor_vector_coupled<2, double, AD::NumberTypes::sacado_rad_dfad>(); + test_tensor_vector_coupled<3, double, AD::NumberTypes::sacado_rad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_tensor_vector_coupled<2, float, AD::NumberTypes::sacado_rad_dfad>(); + test_tensor_vector_coupled<3, float, AD::NumberTypes::sacado_rad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_coupled_2_components_05_4.output b/tests/sacado/helper_scalar_coupled_2_components_05_4.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_05_4.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_coupled_2_components_06_1.cc b/tests/sacado/helper_scalar_coupled_2_components_06_1.cc new file mode 100644 index 0000000000..132acc5936 --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_06_1.cc @@ -0,0 +1,55 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a coupled system (symmetric tensor + vector components) +// using a helper class +// +// AD number type: Sacado DFad + +#include "../ad_common_tests/helper_scalar_coupled_2_components_06.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_symmetric_tensor_vector_coupled<2, + double, + AD::NumberTypes::sacado_dfad>(); + test_symmetric_tensor_vector_coupled<3, + double, + AD::NumberTypes::sacado_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_symmetric_tensor_vector_coupled<2, + float, + AD::NumberTypes::sacado_dfad>(); + test_symmetric_tensor_vector_coupled<3, + float, + AD::NumberTypes::sacado_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_coupled_2_components_06_1.output b/tests/sacado/helper_scalar_coupled_2_components_06_1.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_06_1.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_coupled_2_components_06_2.cc b/tests/sacado/helper_scalar_coupled_2_components_06_2.cc new file mode 100644 index 0000000000..06239113e6 --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_06_2.cc @@ -0,0 +1,55 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a coupled system (symmetric tensor + vector components) +// using a helper class +// +// AD number type: Sacado DFad-DFad + +#include "../ad_common_tests/helper_scalar_coupled_2_components_06.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_symmetric_tensor_vector_coupled<2, + double, + AD::NumberTypes::sacado_dfad_dfad>(); + test_symmetric_tensor_vector_coupled<3, + double, + AD::NumberTypes::sacado_dfad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_symmetric_tensor_vector_coupled<2, + float, + AD::NumberTypes::sacado_dfad_dfad>(); + test_symmetric_tensor_vector_coupled<3, + float, + AD::NumberTypes::sacado_dfad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_coupled_2_components_06_2.output b/tests/sacado/helper_scalar_coupled_2_components_06_2.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_06_2.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_coupled_2_components_06_3.cc b/tests/sacado/helper_scalar_coupled_2_components_06_3.cc new file mode 100644 index 0000000000..52a9ed1656 --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_06_3.cc @@ -0,0 +1,55 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a coupled system (symmetric tensor + vector components) +// using a helper class +// +// AD number type: Sacado Rad + +#include "../ad_common_tests/helper_scalar_coupled_2_components_06.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_symmetric_tensor_vector_coupled<2, + double, + AD::NumberTypes::sacado_rad>(); + test_symmetric_tensor_vector_coupled<3, + double, + AD::NumberTypes::sacado_rad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_symmetric_tensor_vector_coupled<2, + float, + AD::NumberTypes::sacado_rad>(); + test_symmetric_tensor_vector_coupled<3, + float, + AD::NumberTypes::sacado_rad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_coupled_2_components_06_3.output b/tests/sacado/helper_scalar_coupled_2_components_06_3.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_06_3.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_coupled_2_components_06_4.cc b/tests/sacado/helper_scalar_coupled_2_components_06_4.cc new file mode 100644 index 0000000000..46b00b7757 --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_06_4.cc @@ -0,0 +1,55 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a coupled system (symmetric tensor + vector components) +// using a helper class +// +// AD number type: Sacado Rad-DFad + +#include "../ad_common_tests/helper_scalar_coupled_2_components_06.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_symmetric_tensor_vector_coupled<2, + double, + AD::NumberTypes::sacado_rad_dfad>(); + test_symmetric_tensor_vector_coupled<3, + double, + AD::NumberTypes::sacado_rad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_symmetric_tensor_vector_coupled<2, + float, + AD::NumberTypes::sacado_rad_dfad>(); + test_symmetric_tensor_vector_coupled<3, + float, + AD::NumberTypes::sacado_rad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_coupled_2_components_06_4.output b/tests/sacado/helper_scalar_coupled_2_components_06_4.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_06_4.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_coupled_2_components_07_1.cc b/tests/sacado/helper_scalar_coupled_2_components_07_1.cc new file mode 100644 index 0000000000..538c218225 --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_07_1.cc @@ -0,0 +1,55 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a coupled system (symmetric tensor + tensor components) +// using a helper class +// +// AD number type: Sacado DFad + +#include "../ad_common_tests/helper_scalar_coupled_2_components_07.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_symmetric_tensor_tensor_coupled<2, + double, + AD::NumberTypes::sacado_dfad>(); + test_symmetric_tensor_tensor_coupled<3, + double, + AD::NumberTypes::sacado_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_symmetric_tensor_tensor_coupled<2, + float, + AD::NumberTypes::sacado_dfad>(); + test_symmetric_tensor_tensor_coupled<3, + float, + AD::NumberTypes::sacado_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_coupled_2_components_07_1.output b/tests/sacado/helper_scalar_coupled_2_components_07_1.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_07_1.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_coupled_2_components_07_2.cc b/tests/sacado/helper_scalar_coupled_2_components_07_2.cc new file mode 100644 index 0000000000..695c395ccd --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_07_2.cc @@ -0,0 +1,55 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a coupled system (symmetric tensor + tensor components) +// using a helper class +// +// AD number type: Sacado DFad-DFad + +#include "../ad_common_tests/helper_scalar_coupled_2_components_07.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_symmetric_tensor_tensor_coupled<2, + double, + AD::NumberTypes::sacado_dfad_dfad>(); + test_symmetric_tensor_tensor_coupled<3, + double, + AD::NumberTypes::sacado_dfad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_symmetric_tensor_tensor_coupled<2, + float, + AD::NumberTypes::sacado_dfad_dfad>(); + test_symmetric_tensor_tensor_coupled<3, + float, + AD::NumberTypes::sacado_dfad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_coupled_2_components_07_2.output b/tests/sacado/helper_scalar_coupled_2_components_07_2.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_07_2.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_coupled_2_components_07_3.cc b/tests/sacado/helper_scalar_coupled_2_components_07_3.cc new file mode 100644 index 0000000000..5d23debb52 --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_07_3.cc @@ -0,0 +1,55 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a coupled system (symmetric tensor + tensor components) +// using a helper class +// +// AD number type: Sacado Rad + +#include "../ad_common_tests/helper_scalar_coupled_2_components_07.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_symmetric_tensor_tensor_coupled<2, + double, + AD::NumberTypes::sacado_rad>(); + test_symmetric_tensor_tensor_coupled<3, + double, + AD::NumberTypes::sacado_rad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_symmetric_tensor_tensor_coupled<2, + float, + AD::NumberTypes::sacado_rad>(); + test_symmetric_tensor_tensor_coupled<3, + float, + AD::NumberTypes::sacado_rad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_coupled_2_components_07_3.output b/tests/sacado/helper_scalar_coupled_2_components_07_3.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_07_3.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_coupled_2_components_07_4.cc b/tests/sacado/helper_scalar_coupled_2_components_07_4.cc new file mode 100644 index 0000000000..d263f01363 --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_07_4.cc @@ -0,0 +1,55 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a coupled system (symmetric tensor + tensor components) +// using a helper class +// +// AD number type: Sacado Rad-DFad + +#include "../ad_common_tests/helper_scalar_coupled_2_components_07.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_symmetric_tensor_tensor_coupled<2, + double, + AD::NumberTypes::sacado_rad_dfad>(); + test_symmetric_tensor_tensor_coupled<3, + double, + AD::NumberTypes::sacado_rad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_symmetric_tensor_tensor_coupled<2, + float, + AD::NumberTypes::sacado_rad_dfad>(); + test_symmetric_tensor_tensor_coupled<3, + float, + AD::NumberTypes::sacado_rad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_coupled_2_components_07_4.output b/tests/sacado/helper_scalar_coupled_2_components_07_4.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_07_4.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_coupled_2_components_08_1.cc b/tests/sacado/helper_scalar_coupled_2_components_08_1.cc new file mode 100644 index 0000000000..b9f9e3bcd2 --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_08_1.cc @@ -0,0 +1,59 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a coupled system (symmetric tensor + symmetric tensor +// components) using a helper class +// +// AD number type: Sacado DFad + +#include "../ad_common_tests/helper_scalar_coupled_2_components_08.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_symmetric_tensor_symmetric_tensor_coupled< + 2, + double, + AD::NumberTypes::sacado_dfad>(); + test_symmetric_tensor_symmetric_tensor_coupled< + 3, + double, + AD::NumberTypes::sacado_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_symmetric_tensor_symmetric_tensor_coupled< + 2, + float, + AD::NumberTypes::sacado_dfad>(); + test_symmetric_tensor_symmetric_tensor_coupled< + 3, + float, + AD::NumberTypes::sacado_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_coupled_2_components_08_1.output b/tests/sacado/helper_scalar_coupled_2_components_08_1.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_08_1.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_coupled_2_components_08_2.cc b/tests/sacado/helper_scalar_coupled_2_components_08_2.cc new file mode 100644 index 0000000000..d75c1068f0 --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_08_2.cc @@ -0,0 +1,59 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a coupled system (symmetric tensor + symmetric tensor +// components) using a helper class +// +// AD number type: Sacado DFad-DFad + +#include "../ad_common_tests/helper_scalar_coupled_2_components_08.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_symmetric_tensor_symmetric_tensor_coupled< + 2, + double, + AD::NumberTypes::sacado_dfad_dfad>(); + test_symmetric_tensor_symmetric_tensor_coupled< + 3, + double, + AD::NumberTypes::sacado_dfad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_symmetric_tensor_symmetric_tensor_coupled< + 2, + float, + AD::NumberTypes::sacado_dfad_dfad>(); + test_symmetric_tensor_symmetric_tensor_coupled< + 3, + float, + AD::NumberTypes::sacado_dfad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_coupled_2_components_08_2.output b/tests/sacado/helper_scalar_coupled_2_components_08_2.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_08_2.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_coupled_2_components_08_3.cc b/tests/sacado/helper_scalar_coupled_2_components_08_3.cc new file mode 100644 index 0000000000..8bbd1c08f9 --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_08_3.cc @@ -0,0 +1,59 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a coupled system (symmetric tensor + symmetric tensor +// components) using a helper class +// +// AD number type: Sacado Rad + +#include "../ad_common_tests/helper_scalar_coupled_2_components_08.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_symmetric_tensor_symmetric_tensor_coupled< + 2, + double, + AD::NumberTypes::sacado_rad>(); + test_symmetric_tensor_symmetric_tensor_coupled< + 3, + double, + AD::NumberTypes::sacado_rad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_symmetric_tensor_symmetric_tensor_coupled< + 2, + float, + AD::NumberTypes::sacado_rad>(); + test_symmetric_tensor_symmetric_tensor_coupled< + 3, + float, + AD::NumberTypes::sacado_rad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_coupled_2_components_08_3.output b/tests/sacado/helper_scalar_coupled_2_components_08_3.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_08_3.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_coupled_2_components_08_4.cc b/tests/sacado/helper_scalar_coupled_2_components_08_4.cc new file mode 100644 index 0000000000..6c5526ba55 --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_08_4.cc @@ -0,0 +1,59 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a coupled system (symmetric tensor + symmetric tensor +// components) using a helper class +// +// AD number type: Sacado Rad-DFad + +#include "../ad_common_tests/helper_scalar_coupled_2_components_08.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_symmetric_tensor_symmetric_tensor_coupled< + 2, + double, + AD::NumberTypes::sacado_rad_dfad>(); + test_symmetric_tensor_symmetric_tensor_coupled< + 3, + double, + AD::NumberTypes::sacado_rad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_symmetric_tensor_symmetric_tensor_coupled< + 2, + float, + AD::NumberTypes::sacado_rad_dfad>(); + test_symmetric_tensor_symmetric_tensor_coupled< + 3, + float, + AD::NumberTypes::sacado_rad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_coupled_2_components_08_4.output b/tests/sacado/helper_scalar_coupled_2_components_08_4.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_2_components_08_4.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_coupled_3_components_01_1.cc b/tests/sacado/helper_scalar_coupled_3_components_01_1.cc new file mode 100644 index 0000000000..c5a94dc0cc --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_3_components_01_1.cc @@ -0,0 +1,52 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a coupled system (tensor + vector + scalar components) +// using a helper class +// +// AD number type: Sacado DFad + +#include "../ad_common_tests/helper_scalar_coupled_3_components_01.h" +#include "../tests.h" + +int +main(int argc, char **argv) +{ + Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1); + MPILogInitAll mpi_log; + + deallog.push("Double"); + { + test_tensor_vector_scalar_coupled<2, + double, + AD::NumberTypes::sacado_dfad>(); + test_tensor_vector_scalar_coupled<3, + double, + AD::NumberTypes::sacado_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_tensor_vector_scalar_coupled<2, float, AD::NumberTypes::sacado_dfad>(); + test_tensor_vector_scalar_coupled<3, float, AD::NumberTypes::sacado_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_coupled_3_components_01_1.output b/tests/sacado/helper_scalar_coupled_3_components_01_1.output new file mode 100644 index 0000000000..80d2ce744d --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_3_components_01_1.output @@ -0,0 +1,4 @@ + +DEAL:0:Double:OK +DEAL:0:Float:OK +DEAL:0:OK diff --git a/tests/sacado/helper_scalar_coupled_3_components_01_1.with_mpi=true.mpirun=2.output b/tests/sacado/helper_scalar_coupled_3_components_01_1.with_mpi=true.mpirun=2.output new file mode 100644 index 0000000000..2cc2d546a7 --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_3_components_01_1.with_mpi=true.mpirun=2.output @@ -0,0 +1,8 @@ + +DEAL:0:Double::OK +DEAL:0:Float:OK +DEAL:0:OK + +DEAL:1:Double::OK +DEAL:1:Float:OK +DEAL:1:OK \ No newline at end of file diff --git a/tests/sacado/helper_scalar_coupled_3_components_01_2.cc b/tests/sacado/helper_scalar_coupled_3_components_01_2.cc new file mode 100644 index 0000000000..8b26832805 --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_3_components_01_2.cc @@ -0,0 +1,56 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a coupled system (tensor + vector + scalar components) +// using a helper class +// +// AD number type: Sacado DFad-DFad + +#include "../ad_common_tests/helper_scalar_coupled_3_components_01.h" +#include "../tests.h" + +int +main(int argc, char **argv) +{ + Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1); + MPILogInitAll mpi_log; + + deallog.push("Double"); + { + test_tensor_vector_scalar_coupled<2, + double, + AD::NumberTypes::sacado_dfad_dfad>(); + test_tensor_vector_scalar_coupled<3, + double, + AD::NumberTypes::sacado_dfad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_tensor_vector_scalar_coupled<2, + float, + AD::NumberTypes::sacado_dfad_dfad>(); + test_tensor_vector_scalar_coupled<3, + float, + AD::NumberTypes::sacado_dfad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_coupled_3_components_01_2.output b/tests/sacado/helper_scalar_coupled_3_components_01_2.output new file mode 100644 index 0000000000..80d2ce744d --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_3_components_01_2.output @@ -0,0 +1,4 @@ + +DEAL:0:Double:OK +DEAL:0:Float:OK +DEAL:0:OK diff --git a/tests/sacado/helper_scalar_coupled_3_components_01_2.with_mpi=true.mpirun=2.output b/tests/sacado/helper_scalar_coupled_3_components_01_2.with_mpi=true.mpirun=2.output new file mode 100644 index 0000000000..2cc2d546a7 --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_3_components_01_2.with_mpi=true.mpirun=2.output @@ -0,0 +1,8 @@ + +DEAL:0:Double::OK +DEAL:0:Float:OK +DEAL:0:OK + +DEAL:1:Double::OK +DEAL:1:Float:OK +DEAL:1:OK \ No newline at end of file diff --git a/tests/sacado/helper_scalar_coupled_3_components_01_3.cc b/tests/sacado/helper_scalar_coupled_3_components_01_3.cc new file mode 100644 index 0000000000..a4ccb95942 --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_3_components_01_3.cc @@ -0,0 +1,48 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a coupled system (tensor + vector + scalar components) +// using a helper class +// +// AD number type: Sacado Rad + +#include "../ad_common_tests/helper_scalar_coupled_3_components_01.h" +#include "../tests.h" + +int +main(int argc, char **argv) +{ + Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1); + MPILogInitAll mpi_log; + + deallog.push("Double"); + { + test_tensor_vector_scalar_coupled<2, double, AD::NumberTypes::sacado_rad>(); + test_tensor_vector_scalar_coupled<3, double, AD::NumberTypes::sacado_rad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_tensor_vector_scalar_coupled<2, float, AD::NumberTypes::sacado_rad>(); + test_tensor_vector_scalar_coupled<3, float, AD::NumberTypes::sacado_rad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_coupled_3_components_01_3.output b/tests/sacado/helper_scalar_coupled_3_components_01_3.output new file mode 100644 index 0000000000..80d2ce744d --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_3_components_01_3.output @@ -0,0 +1,4 @@ + +DEAL:0:Double:OK +DEAL:0:Float:OK +DEAL:0:OK diff --git a/tests/sacado/helper_scalar_coupled_3_components_01_3.with_mpi=true.mpirun=2.output b/tests/sacado/helper_scalar_coupled_3_components_01_3.with_mpi=true.mpirun=2.output new file mode 100644 index 0000000000..2cc2d546a7 --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_3_components_01_3.with_mpi=true.mpirun=2.output @@ -0,0 +1,8 @@ + +DEAL:0:Double::OK +DEAL:0:Float:OK +DEAL:0:OK + +DEAL:1:Double::OK +DEAL:1:Float:OK +DEAL:1:OK \ No newline at end of file diff --git a/tests/sacado/helper_scalar_coupled_3_components_01_4.cc b/tests/sacado/helper_scalar_coupled_3_components_01_4.cc new file mode 100644 index 0000000000..1a7383d8d9 --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_3_components_01_4.cc @@ -0,0 +1,56 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a coupled system (tensor + vector + scalar components) +// using a helper class +// +// AD number type: Sacado Rad-DFad + +#include "../ad_common_tests/helper_scalar_coupled_3_components_01.h" +#include "../tests.h" + +int +main(int argc, char **argv) +{ + Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1); + MPILogInitAll mpi_log; + + deallog.push("Double"); + { + test_tensor_vector_scalar_coupled<2, + double, + AD::NumberTypes::sacado_rad_dfad>(); + test_tensor_vector_scalar_coupled<3, + double, + AD::NumberTypes::sacado_rad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_tensor_vector_scalar_coupled<2, + float, + AD::NumberTypes::sacado_rad_dfad>(); + test_tensor_vector_scalar_coupled<3, + float, + AD::NumberTypes::sacado_rad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_coupled_3_components_01_4.output b/tests/sacado/helper_scalar_coupled_3_components_01_4.output new file mode 100644 index 0000000000..80d2ce744d --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_3_components_01_4.output @@ -0,0 +1,4 @@ + +DEAL:0:Double:OK +DEAL:0:Float:OK +DEAL:0:OK diff --git a/tests/sacado/helper_scalar_coupled_3_components_01_4.with_mpi=true.mpirun=2.output b/tests/sacado/helper_scalar_coupled_3_components_01_4.with_mpi=true.mpirun=2.output new file mode 100644 index 0000000000..2cc2d546a7 --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_3_components_01_4.with_mpi=true.mpirun=2.output @@ -0,0 +1,8 @@ + +DEAL:0:Double::OK +DEAL:0:Float:OK +DEAL:0:OK + +DEAL:1:Double::OK +DEAL:1:Float:OK +DEAL:1:OK \ No newline at end of file diff --git a/tests/sacado/helper_scalar_coupled_3_components_01_tapeless_only_1.cc b/tests/sacado/helper_scalar_coupled_3_components_01_tapeless_only_1.cc new file mode 100644 index 0000000000..2768054367 --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_3_components_01_tapeless_only_1.cc @@ -0,0 +1,56 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a coupled system (tensor + vector + scalar components) +// using a helper class. +// This test is based off of helper_scalar_coupled_3_components_01.h, and checks +// that everything still works in tapeless only mode (i.e. when the +// start_recording_operations and stop_recording_operations calls are +// removed). +// +// AD number type: Sacado DFad + +#include "../ad_common_tests/helper_scalar_coupled_3_components_01_tapeless_only.h" +#include "../tests.h" + +int +main(int argc, char **argv) +{ + Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1); + MPILogInitAll mpi_log; + + deallog.push("Double"); + { + test_tensor_vector_scalar_coupled<2, + double, + AD::NumberTypes::sacado_dfad>(); + test_tensor_vector_scalar_coupled<3, + double, + AD::NumberTypes::sacado_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_tensor_vector_scalar_coupled<2, float, AD::NumberTypes::sacado_dfad>(); + test_tensor_vector_scalar_coupled<3, float, AD::NumberTypes::sacado_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_coupled_3_components_01_tapeless_only_1.output b/tests/sacado/helper_scalar_coupled_3_components_01_tapeless_only_1.output new file mode 100644 index 0000000000..80d2ce744d --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_3_components_01_tapeless_only_1.output @@ -0,0 +1,4 @@ + +DEAL:0:Double:OK +DEAL:0:Float:OK +DEAL:0:OK diff --git a/tests/sacado/helper_scalar_coupled_3_components_01_tapeless_only_2.cc b/tests/sacado/helper_scalar_coupled_3_components_01_tapeless_only_2.cc new file mode 100644 index 0000000000..85c16c51eb --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_3_components_01_tapeless_only_2.cc @@ -0,0 +1,60 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a coupled system (tensor + vector + scalar components) +// using a helper class. +// This test is based off of helper_scalar_coupled_3_components_01.h, and checks +// that everything still works in tapeless only mode (i.e. when the +// start_recording_operations and stop_recording_operations calls are +// removed). +// +// AD number type: Sacado DFad-DFad + +#include "../ad_common_tests/helper_scalar_coupled_3_components_01_tapeless_only.h" +#include "../tests.h" + +int +main(int argc, char **argv) +{ + Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1); + MPILogInitAll mpi_log; + + deallog.push("Double"); + { + test_tensor_vector_scalar_coupled<2, + double, + AD::NumberTypes::sacado_dfad_dfad>(); + test_tensor_vector_scalar_coupled<3, + double, + AD::NumberTypes::sacado_dfad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_tensor_vector_scalar_coupled<2, + float, + AD::NumberTypes::sacado_dfad_dfad>(); + test_tensor_vector_scalar_coupled<3, + float, + AD::NumberTypes::sacado_dfad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_coupled_3_components_01_tapeless_only_2.output b/tests/sacado/helper_scalar_coupled_3_components_01_tapeless_only_2.output new file mode 100644 index 0000000000..80d2ce744d --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_3_components_01_tapeless_only_2.output @@ -0,0 +1,4 @@ + +DEAL:0:Double:OK +DEAL:0:Float:OK +DEAL:0:OK diff --git a/tests/sacado/helper_scalar_coupled_3_components_01_tapeless_only_3.cc b/tests/sacado/helper_scalar_coupled_3_components_01_tapeless_only_3.cc new file mode 100644 index 0000000000..97c18fe80b --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_3_components_01_tapeless_only_3.cc @@ -0,0 +1,52 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a coupled system (tensor + vector + scalar components) +// using a helper class. +// This test is based off of helper_scalar_coupled_3_components_01.h, and checks +// that everything still works in tapeless only mode (i.e. when the +// start_recording_operations and stop_recording_operations calls are +// removed). +// +// AD number type: Sacado Rad + +#include "../ad_common_tests/helper_scalar_coupled_3_components_01_tapeless_only.h" +#include "../tests.h" + +int +main(int argc, char **argv) +{ + Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1); + MPILogInitAll mpi_log; + + deallog.push("Double"); + { + test_tensor_vector_scalar_coupled<2, double, AD::NumberTypes::sacado_rad>(); + test_tensor_vector_scalar_coupled<3, double, AD::NumberTypes::sacado_rad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_tensor_vector_scalar_coupled<2, float, AD::NumberTypes::sacado_rad>(); + test_tensor_vector_scalar_coupled<3, float, AD::NumberTypes::sacado_rad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_coupled_3_components_01_tapeless_only_3.output b/tests/sacado/helper_scalar_coupled_3_components_01_tapeless_only_3.output new file mode 100644 index 0000000000..80d2ce744d --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_3_components_01_tapeless_only_3.output @@ -0,0 +1,4 @@ + +DEAL:0:Double:OK +DEAL:0:Float:OK +DEAL:0:OK diff --git a/tests/sacado/helper_scalar_coupled_3_components_01_tapeless_only_4.cc b/tests/sacado/helper_scalar_coupled_3_components_01_tapeless_only_4.cc new file mode 100644 index 0000000000..b5d33b46d9 --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_3_components_01_tapeless_only_4.cc @@ -0,0 +1,60 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a coupled system (tensor + vector + scalar components) +// using a helper class. +// This test is based off of helper_scalar_coupled_3_components_01.h, and checks +// that everything still works in tapeless only mode (i.e. when the +// start_recording_operations and stop_recording_operations calls are +// removed). +// +// AD number type: Sacado Rad-DFad + +#include "../ad_common_tests/helper_scalar_coupled_3_components_01_tapeless_only.h" +#include "../tests.h" + +int +main(int argc, char **argv) +{ + Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1); + MPILogInitAll mpi_log; + + deallog.push("Double"); + { + test_tensor_vector_scalar_coupled<2, + double, + AD::NumberTypes::sacado_rad_dfad>(); + test_tensor_vector_scalar_coupled<3, + double, + AD::NumberTypes::sacado_rad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_tensor_vector_scalar_coupled<2, + float, + AD::NumberTypes::sacado_rad_dfad>(); + test_tensor_vector_scalar_coupled<3, + float, + AD::NumberTypes::sacado_rad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_coupled_3_components_01_tapeless_only_4.output b/tests/sacado/helper_scalar_coupled_3_components_01_tapeless_only_4.output new file mode 100644 index 0000000000..80d2ce744d --- /dev/null +++ b/tests/sacado/helper_scalar_coupled_3_components_01_tapeless_only_4.output @@ -0,0 +1,4 @@ + +DEAL:0:Double:OK +DEAL:0:Float:OK +DEAL:0:OK diff --git a/tests/sacado/helper_scalar_single_component_01_1.cc b/tests/sacado/helper_scalar_single_component_01_1.cc new file mode 100644 index 0000000000..dcecd2e818 --- /dev/null +++ b/tests/sacado/helper_scalar_single_component_01_1.cc @@ -0,0 +1,46 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a single component (scalar) system using a helper class +// +// AD number type: Sacado DFad + +#include "../ad_common_tests/helper_scalar_single_component_01.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_scalar<2, double, AD::NumberTypes::sacado_dfad>(); + test_scalar<3, double, AD::NumberTypes::sacado_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_scalar<2, float, AD::NumberTypes::sacado_dfad>(); + test_scalar<3, float, AD::NumberTypes::sacado_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_single_component_01_1.output b/tests/sacado/helper_scalar_single_component_01_1.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_single_component_01_1.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_single_component_01_2.cc b/tests/sacado/helper_scalar_single_component_01_2.cc new file mode 100644 index 0000000000..895674acfd --- /dev/null +++ b/tests/sacado/helper_scalar_single_component_01_2.cc @@ -0,0 +1,46 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a single component (scalar) system using a helper class +// +// AD number type: Sacado DFad-DFad + +#include "../ad_common_tests/helper_scalar_single_component_01.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_scalar<2, double, AD::NumberTypes::sacado_dfad_dfad>(); + test_scalar<3, double, AD::NumberTypes::sacado_dfad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_scalar<2, float, AD::NumberTypes::sacado_dfad_dfad>(); + test_scalar<3, float, AD::NumberTypes::sacado_dfad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_single_component_01_2.output b/tests/sacado/helper_scalar_single_component_01_2.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_single_component_01_2.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_single_component_01_3.cc b/tests/sacado/helper_scalar_single_component_01_3.cc new file mode 100644 index 0000000000..1a8c76d9df --- /dev/null +++ b/tests/sacado/helper_scalar_single_component_01_3.cc @@ -0,0 +1,46 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a single component (scalar) system using a helper class +// +// AD number type: Sacado Rad + +#include "../ad_common_tests/helper_scalar_single_component_01.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_scalar<2, double, AD::NumberTypes::sacado_rad>(); + test_scalar<3, double, AD::NumberTypes::sacado_rad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_scalar<2, float, AD::NumberTypes::sacado_rad>(); + test_scalar<3, float, AD::NumberTypes::sacado_rad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_single_component_01_3.output b/tests/sacado/helper_scalar_single_component_01_3.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_single_component_01_3.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_single_component_01_4.cc b/tests/sacado/helper_scalar_single_component_01_4.cc new file mode 100644 index 0000000000..084d0bfd6a --- /dev/null +++ b/tests/sacado/helper_scalar_single_component_01_4.cc @@ -0,0 +1,46 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a single component (scalar) system using a helper class +// +// AD number type: Sacado Rad-DFad + +#include "../ad_common_tests/helper_scalar_single_component_01.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_scalar<2, double, AD::NumberTypes::sacado_rad_dfad>(); + test_scalar<3, double, AD::NumberTypes::sacado_rad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_scalar<2, float, AD::NumberTypes::sacado_rad_dfad>(); + test_scalar<3, float, AD::NumberTypes::sacado_rad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_single_component_01_4.output b/tests/sacado/helper_scalar_single_component_01_4.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_single_component_01_4.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_single_component_02_1.cc b/tests/sacado/helper_scalar_single_component_02_1.cc new file mode 100644 index 0000000000..8af18c8e4c --- /dev/null +++ b/tests/sacado/helper_scalar_single_component_02_1.cc @@ -0,0 +1,46 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a single component (vector) system using a helper class +// +// AD number type: Sacado DFad + +#include "../ad_common_tests/helper_scalar_single_component_02.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_vector<2, double, AD::NumberTypes::sacado_dfad>(); + test_vector<3, double, AD::NumberTypes::sacado_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_vector<2, float, AD::NumberTypes::sacado_dfad>(); + test_vector<3, float, AD::NumberTypes::sacado_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_single_component_02_1.output b/tests/sacado/helper_scalar_single_component_02_1.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_single_component_02_1.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_single_component_02_2.cc b/tests/sacado/helper_scalar_single_component_02_2.cc new file mode 100644 index 0000000000..599acfd755 --- /dev/null +++ b/tests/sacado/helper_scalar_single_component_02_2.cc @@ -0,0 +1,46 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a single component (vector) system using a helper class +// +// AD number type: Sacado DFad-DFad + +#include "../ad_common_tests/helper_scalar_single_component_02.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_vector<2, double, AD::NumberTypes::sacado_dfad_dfad>(); + test_vector<3, double, AD::NumberTypes::sacado_dfad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_vector<2, float, AD::NumberTypes::sacado_dfad_dfad>(); + test_vector<3, float, AD::NumberTypes::sacado_dfad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_single_component_02_2.output b/tests/sacado/helper_scalar_single_component_02_2.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_single_component_02_2.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_single_component_02_3.cc b/tests/sacado/helper_scalar_single_component_02_3.cc new file mode 100644 index 0000000000..6617050bac --- /dev/null +++ b/tests/sacado/helper_scalar_single_component_02_3.cc @@ -0,0 +1,46 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a single component (vector) system using a helper class +// +// AD number type: Sacado Rad + +#include "../ad_common_tests/helper_scalar_single_component_02.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_vector<2, double, AD::NumberTypes::sacado_rad>(); + test_vector<3, double, AD::NumberTypes::sacado_rad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_vector<2, float, AD::NumberTypes::sacado_rad>(); + test_vector<3, float, AD::NumberTypes::sacado_rad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_single_component_02_3.output b/tests/sacado/helper_scalar_single_component_02_3.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_single_component_02_3.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_single_component_02_4.cc b/tests/sacado/helper_scalar_single_component_02_4.cc new file mode 100644 index 0000000000..bf790fe8e4 --- /dev/null +++ b/tests/sacado/helper_scalar_single_component_02_4.cc @@ -0,0 +1,46 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a single component (vector) system using a helper class +// +// AD number type: Sacado Rad-DFad + +#include "../ad_common_tests/helper_scalar_single_component_02.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_vector<2, double, AD::NumberTypes::sacado_rad_dfad>(); + test_vector<3, double, AD::NumberTypes::sacado_rad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_vector<2, float, AD::NumberTypes::sacado_rad_dfad>(); + test_vector<3, float, AD::NumberTypes::sacado_rad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_single_component_02_4.output b/tests/sacado/helper_scalar_single_component_02_4.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_single_component_02_4.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_single_component_03_1.cc b/tests/sacado/helper_scalar_single_component_03_1.cc new file mode 100644 index 0000000000..034f070e6b --- /dev/null +++ b/tests/sacado/helper_scalar_single_component_03_1.cc @@ -0,0 +1,46 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a single component (tensor) system using a helper class +// +// AD number type: Sacado DFad + +#include "../ad_common_tests/helper_scalar_single_component_03.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_tensor<2, double, AD::NumberTypes::sacado_dfad>(); + test_tensor<3, double, AD::NumberTypes::sacado_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_tensor<2, float, AD::NumberTypes::sacado_dfad>(); + test_tensor<3, float, AD::NumberTypes::sacado_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_single_component_03_1.output b/tests/sacado/helper_scalar_single_component_03_1.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_single_component_03_1.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_single_component_03_2.cc b/tests/sacado/helper_scalar_single_component_03_2.cc new file mode 100644 index 0000000000..53a56d3da2 --- /dev/null +++ b/tests/sacado/helper_scalar_single_component_03_2.cc @@ -0,0 +1,46 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a single component (tensor) system using a helper class +// +// AD number type: Sacado DFad-DFad + +#include "../ad_common_tests/helper_scalar_single_component_03.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_tensor<2, double, AD::NumberTypes::sacado_dfad_dfad>(); + test_tensor<3, double, AD::NumberTypes::sacado_dfad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_tensor<2, float, AD::NumberTypes::sacado_dfad_dfad>(); + test_tensor<3, float, AD::NumberTypes::sacado_dfad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_single_component_03_2.output b/tests/sacado/helper_scalar_single_component_03_2.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_single_component_03_2.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_single_component_03_3.cc b/tests/sacado/helper_scalar_single_component_03_3.cc new file mode 100644 index 0000000000..b0e08d08ad --- /dev/null +++ b/tests/sacado/helper_scalar_single_component_03_3.cc @@ -0,0 +1,46 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a single component (tensor) system using a helper class +// +// AD number type: Sacado Rad + +#include "../ad_common_tests/helper_scalar_single_component_03.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_tensor<2, double, AD::NumberTypes::sacado_rad>(); + test_tensor<3, double, AD::NumberTypes::sacado_rad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_tensor<2, float, AD::NumberTypes::sacado_rad>(); + test_tensor<3, float, AD::NumberTypes::sacado_rad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_single_component_03_3.output b/tests/sacado/helper_scalar_single_component_03_3.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_single_component_03_3.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_single_component_03_4.cc b/tests/sacado/helper_scalar_single_component_03_4.cc new file mode 100644 index 0000000000..03e05c1959 --- /dev/null +++ b/tests/sacado/helper_scalar_single_component_03_4.cc @@ -0,0 +1,46 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a single component (tensor) system using a helper class +// +// AD number type: Sacado Rad-DFad + +#include "../ad_common_tests/helper_scalar_single_component_03.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_tensor<2, double, AD::NumberTypes::sacado_rad_dfad>(); + test_tensor<3, double, AD::NumberTypes::sacado_rad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_tensor<2, float, AD::NumberTypes::sacado_rad_dfad>(); + test_tensor<3, float, AD::NumberTypes::sacado_rad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_single_component_03_4.output b/tests/sacado/helper_scalar_single_component_03_4.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_single_component_03_4.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_single_component_04_1.cc b/tests/sacado/helper_scalar_single_component_04_1.cc new file mode 100644 index 0000000000..742df39ef1 --- /dev/null +++ b/tests/sacado/helper_scalar_single_component_04_1.cc @@ -0,0 +1,47 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a single component (symmetric tensor) system using a helper +// class +// +// AD number type: Sacado DFad + +#include "../ad_common_tests/helper_scalar_single_component_04.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_symmetric_tensor<2, double, AD::NumberTypes::sacado_dfad>(); + test_symmetric_tensor<3, double, AD::NumberTypes::sacado_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_symmetric_tensor<2, float, AD::NumberTypes::sacado_dfad>(); + test_symmetric_tensor<3, float, AD::NumberTypes::sacado_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_single_component_04_1.output b/tests/sacado/helper_scalar_single_component_04_1.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_single_component_04_1.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_single_component_04_2.cc b/tests/sacado/helper_scalar_single_component_04_2.cc new file mode 100644 index 0000000000..967bc339c4 --- /dev/null +++ b/tests/sacado/helper_scalar_single_component_04_2.cc @@ -0,0 +1,47 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a single component (symmetric tensor) system using a helper +// class +// +// AD number type: Sacado DFad-DFad + +#include "../ad_common_tests/helper_scalar_single_component_04.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_symmetric_tensor<2, double, AD::NumberTypes::sacado_dfad_dfad>(); + test_symmetric_tensor<3, double, AD::NumberTypes::sacado_dfad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_symmetric_tensor<2, float, AD::NumberTypes::sacado_dfad_dfad>(); + test_symmetric_tensor<3, float, AD::NumberTypes::sacado_dfad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_single_component_04_2.output b/tests/sacado/helper_scalar_single_component_04_2.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_single_component_04_2.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_single_component_04_3.cc b/tests/sacado/helper_scalar_single_component_04_3.cc new file mode 100644 index 0000000000..9f6bdd6afd --- /dev/null +++ b/tests/sacado/helper_scalar_single_component_04_3.cc @@ -0,0 +1,47 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a single component (symmetric tensor) system using a helper +// class +// +// AD number type: Sacado Rad + +#include "../ad_common_tests/helper_scalar_single_component_04.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_symmetric_tensor<2, double, AD::NumberTypes::sacado_rad>(); + test_symmetric_tensor<3, double, AD::NumberTypes::sacado_rad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_symmetric_tensor<2, float, AD::NumberTypes::sacado_rad>(); + test_symmetric_tensor<3, float, AD::NumberTypes::sacado_rad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_single_component_04_3.output b/tests/sacado/helper_scalar_single_component_04_3.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_single_component_04_3.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_scalar_single_component_04_4.cc b/tests/sacado/helper_scalar_single_component_04_4.cc new file mode 100644 index 0000000000..68d57908b7 --- /dev/null +++ b/tests/sacado/helper_scalar_single_component_04_4.cc @@ -0,0 +1,47 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a single component (symmetric tensor) system using a helper +// class +// +// AD number type: Sacado Rad-DFad + +#include "../ad_common_tests/helper_scalar_single_component_04.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_symmetric_tensor<2, double, AD::NumberTypes::sacado_rad_dfad>(); + test_symmetric_tensor<3, double, AD::NumberTypes::sacado_rad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_symmetric_tensor<2, float, AD::NumberTypes::sacado_rad_dfad>(); + test_symmetric_tensor<3, float, AD::NumberTypes::sacado_rad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_scalar_single_component_04_4.output b/tests/sacado/helper_scalar_single_component_04_4.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_scalar_single_component_04_4.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_vector_1_indep_1_dep_vars_01_1.cc b/tests/sacado/helper_vector_1_indep_1_dep_vars_01_1.cc new file mode 100644 index 0000000000..3492c83548 --- /dev/null +++ b/tests/sacado/helper_vector_1_indep_1_dep_vars_01_1.cc @@ -0,0 +1,48 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a single component (scalar) system using a helper class +// This is the equivalent of helper_scalar_single_component_01, but for +// the other (vector) helper class +// +// AD number type: Sacado DFad + +#include "../ad_common_tests/helper_vector_1_indep_1_dep_vars_01.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_AD_vector_jacobian<2, double, AD::NumberTypes::sacado_dfad>(); + test_AD_vector_jacobian<3, double, AD::NumberTypes::sacado_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_AD_vector_jacobian<2, float, AD::NumberTypes::sacado_dfad>(); + test_AD_vector_jacobian<3, float, AD::NumberTypes::sacado_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_vector_1_indep_1_dep_vars_01_1.output b/tests/sacado/helper_vector_1_indep_1_dep_vars_01_1.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_vector_1_indep_1_dep_vars_01_1.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_vector_1_indep_1_dep_vars_01_2.cc b/tests/sacado/helper_vector_1_indep_1_dep_vars_01_2.cc new file mode 100644 index 0000000000..11a6612af3 --- /dev/null +++ b/tests/sacado/helper_vector_1_indep_1_dep_vars_01_2.cc @@ -0,0 +1,48 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a single component (scalar) system using a helper class +// This is the equivalent of helper_scalar_single_component_01, but for +// the other (vector) helper class +// +// AD number type: Sacado DFad-DFad + +#include "../ad_common_tests/helper_vector_1_indep_1_dep_vars_01.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_AD_vector_jacobian<2, double, AD::NumberTypes::sacado_dfad_dfad>(); + test_AD_vector_jacobian<3, double, AD::NumberTypes::sacado_dfad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_AD_vector_jacobian<2, float, AD::NumberTypes::sacado_dfad_dfad>(); + test_AD_vector_jacobian<3, float, AD::NumberTypes::sacado_dfad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_vector_1_indep_1_dep_vars_01_2.output b/tests/sacado/helper_vector_1_indep_1_dep_vars_01_2.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_vector_1_indep_1_dep_vars_01_2.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_vector_1_indep_1_dep_vars_01_3.cc b/tests/sacado/helper_vector_1_indep_1_dep_vars_01_3.cc new file mode 100644 index 0000000000..aa4649ae92 --- /dev/null +++ b/tests/sacado/helper_vector_1_indep_1_dep_vars_01_3.cc @@ -0,0 +1,48 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a single component (scalar) system using a helper class +// This is the equivalent of helper_scalar_single_component_01, but for +// the other (vector) helper class +// +// AD number type: Sacado Rad + +#include "../ad_common_tests/helper_vector_1_indep_1_dep_vars_01.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_AD_vector_jacobian<2, double, AD::NumberTypes::sacado_rad>(); + test_AD_vector_jacobian<3, double, AD::NumberTypes::sacado_rad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_AD_vector_jacobian<2, float, AD::NumberTypes::sacado_rad>(); + test_AD_vector_jacobian<3, float, AD::NumberTypes::sacado_rad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_vector_1_indep_1_dep_vars_01_3.output b/tests/sacado/helper_vector_1_indep_1_dep_vars_01_3.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_vector_1_indep_1_dep_vars_01_3.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_vector_1_indep_1_dep_vars_01_4.cc b/tests/sacado/helper_vector_1_indep_1_dep_vars_01_4.cc new file mode 100644 index 0000000000..14d4f100fa --- /dev/null +++ b/tests/sacado/helper_vector_1_indep_1_dep_vars_01_4.cc @@ -0,0 +1,48 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a single component (scalar) system using a helper class +// This is the equivalent of helper_scalar_single_component_01, but for +// the other (vector) helper class +// +// AD number type: Sacado Rad-DFad + +#include "../ad_common_tests/helper_vector_1_indep_1_dep_vars_01.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_AD_vector_jacobian<2, double, AD::NumberTypes::sacado_rad_dfad>(); + test_AD_vector_jacobian<3, double, AD::NumberTypes::sacado_rad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_AD_vector_jacobian<2, float, AD::NumberTypes::sacado_rad_dfad>(); + test_AD_vector_jacobian<3, float, AD::NumberTypes::sacado_rad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_vector_1_indep_1_dep_vars_01_4.output b/tests/sacado/helper_vector_1_indep_1_dep_vars_01_4.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_vector_1_indep_1_dep_vars_01_4.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_vector_1_indep_2_dep_vars_01_1.cc b/tests/sacado/helper_vector_1_indep_2_dep_vars_01_1.cc new file mode 100644 index 0000000000..98306465de --- /dev/null +++ b/tests/sacado/helper_vector_1_indep_2_dep_vars_01_1.cc @@ -0,0 +1,47 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a vector of 2 dependent and 1 independent variables +// using a helper class +// +// AD number type: Sacado DFad + +#include "../ad_common_tests/helper_vector_1_indep_2_dep_vars_01.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_AD_vector_jacobian<2, double, AD::NumberTypes::sacado_dfad>(); + test_AD_vector_jacobian<3, double, AD::NumberTypes::sacado_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_AD_vector_jacobian<2, float, AD::NumberTypes::sacado_dfad>(); + test_AD_vector_jacobian<3, float, AD::NumberTypes::sacado_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_vector_1_indep_2_dep_vars_01_1.output b/tests/sacado/helper_vector_1_indep_2_dep_vars_01_1.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_vector_1_indep_2_dep_vars_01_1.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_vector_1_indep_2_dep_vars_01_2.cc b/tests/sacado/helper_vector_1_indep_2_dep_vars_01_2.cc new file mode 100644 index 0000000000..2b01d071ce --- /dev/null +++ b/tests/sacado/helper_vector_1_indep_2_dep_vars_01_2.cc @@ -0,0 +1,47 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a vector of 2 dependent and 1 independent variables +// using a helper class +// +// AD number type: Sacado DFad-DFad + +#include "../ad_common_tests/helper_vector_1_indep_2_dep_vars_01.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_AD_vector_jacobian<2, double, AD::NumberTypes::sacado_dfad_dfad>(); + test_AD_vector_jacobian<3, double, AD::NumberTypes::sacado_dfad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_AD_vector_jacobian<2, float, AD::NumberTypes::sacado_dfad_dfad>(); + test_AD_vector_jacobian<3, float, AD::NumberTypes::sacado_dfad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_vector_1_indep_2_dep_vars_01_2.output b/tests/sacado/helper_vector_1_indep_2_dep_vars_01_2.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_vector_1_indep_2_dep_vars_01_2.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_vector_1_indep_2_dep_vars_01_3.cc b/tests/sacado/helper_vector_1_indep_2_dep_vars_01_3.cc new file mode 100644 index 0000000000..0d88049ddb --- /dev/null +++ b/tests/sacado/helper_vector_1_indep_2_dep_vars_01_3.cc @@ -0,0 +1,47 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a vector of 2 dependent and 1 independent variables +// using a helper class +// +// AD number type: Sacado Rad + +#include "../ad_common_tests/helper_vector_1_indep_2_dep_vars_01.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_AD_vector_jacobian<2, double, AD::NumberTypes::sacado_rad>(); + test_AD_vector_jacobian<3, double, AD::NumberTypes::sacado_rad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_AD_vector_jacobian<2, float, AD::NumberTypes::sacado_rad>(); + test_AD_vector_jacobian<3, float, AD::NumberTypes::sacado_rad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_vector_1_indep_2_dep_vars_01_3.output b/tests/sacado/helper_vector_1_indep_2_dep_vars_01_3.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_vector_1_indep_2_dep_vars_01_3.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_vector_1_indep_2_dep_vars_01_4.cc b/tests/sacado/helper_vector_1_indep_2_dep_vars_01_4.cc new file mode 100644 index 0000000000..1eabc5be1d --- /dev/null +++ b/tests/sacado/helper_vector_1_indep_2_dep_vars_01_4.cc @@ -0,0 +1,47 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a vector of 2 dependent and 1 independent variables +// using a helper class +// +// AD number type: Sacado Rad-DFad + +#include "../ad_common_tests/helper_vector_1_indep_2_dep_vars_01.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_AD_vector_jacobian<2, double, AD::NumberTypes::sacado_rad_dfad>(); + test_AD_vector_jacobian<3, double, AD::NumberTypes::sacado_rad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_AD_vector_jacobian<2, float, AD::NumberTypes::sacado_rad_dfad>(); + test_AD_vector_jacobian<3, float, AD::NumberTypes::sacado_rad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_vector_1_indep_2_dep_vars_01_4.output b/tests/sacado/helper_vector_1_indep_2_dep_vars_01_4.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_vector_1_indep_2_dep_vars_01_4.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_vector_2_indep_1_dep_vars_01_1.cc b/tests/sacado/helper_vector_2_indep_1_dep_vars_01_1.cc new file mode 100644 index 0000000000..fe17e7e4c5 --- /dev/null +++ b/tests/sacado/helper_vector_2_indep_1_dep_vars_01_1.cc @@ -0,0 +1,47 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a vector of 1 dependent and 2 independent variables +// using a helper class +// +// AD number type: Sacado DFad + +#include "../ad_common_tests/helper_vector_2_indep_1_dep_vars_01.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_AD_vector_jacobian<2, double, AD::NumberTypes::sacado_dfad>(); + test_AD_vector_jacobian<3, double, AD::NumberTypes::sacado_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_AD_vector_jacobian<2, float, AD::NumberTypes::sacado_dfad>(); + test_AD_vector_jacobian<3, float, AD::NumberTypes::sacado_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_vector_2_indep_1_dep_vars_01_1.output b/tests/sacado/helper_vector_2_indep_1_dep_vars_01_1.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_vector_2_indep_1_dep_vars_01_1.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_vector_2_indep_1_dep_vars_01_2.cc b/tests/sacado/helper_vector_2_indep_1_dep_vars_01_2.cc new file mode 100644 index 0000000000..825cfd1839 --- /dev/null +++ b/tests/sacado/helper_vector_2_indep_1_dep_vars_01_2.cc @@ -0,0 +1,47 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a vector of 1 dependent and 2 independent variables +// using a helper class +// +// AD number type: Sacado DFad-DFad + +#include "../ad_common_tests/helper_vector_2_indep_1_dep_vars_01.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_AD_vector_jacobian<2, double, AD::NumberTypes::sacado_dfad_dfad>(); + test_AD_vector_jacobian<3, double, AD::NumberTypes::sacado_dfad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_AD_vector_jacobian<2, float, AD::NumberTypes::sacado_dfad_dfad>(); + test_AD_vector_jacobian<3, float, AD::NumberTypes::sacado_dfad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_vector_2_indep_1_dep_vars_01_2.output b/tests/sacado/helper_vector_2_indep_1_dep_vars_01_2.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_vector_2_indep_1_dep_vars_01_2.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_vector_2_indep_1_dep_vars_01_3.cc b/tests/sacado/helper_vector_2_indep_1_dep_vars_01_3.cc new file mode 100644 index 0000000000..aebd1a1325 --- /dev/null +++ b/tests/sacado/helper_vector_2_indep_1_dep_vars_01_3.cc @@ -0,0 +1,47 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a vector of 1 dependent and 2 independent variables +// using a helper class +// +// AD number type: Sacado Rad + +#include "../ad_common_tests/helper_vector_2_indep_1_dep_vars_01.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_AD_vector_jacobian<2, double, AD::NumberTypes::sacado_rad>(); + test_AD_vector_jacobian<3, double, AD::NumberTypes::sacado_rad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_AD_vector_jacobian<2, float, AD::NumberTypes::sacado_rad>(); + test_AD_vector_jacobian<3, float, AD::NumberTypes::sacado_rad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_vector_2_indep_1_dep_vars_01_3.output b/tests/sacado/helper_vector_2_indep_1_dep_vars_01_3.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_vector_2_indep_1_dep_vars_01_3.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_vector_2_indep_1_dep_vars_01_4.cc b/tests/sacado/helper_vector_2_indep_1_dep_vars_01_4.cc new file mode 100644 index 0000000000..5b10e8fd88 --- /dev/null +++ b/tests/sacado/helper_vector_2_indep_1_dep_vars_01_4.cc @@ -0,0 +1,47 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a vector of 1 dependent and 2 independent variables +// using a helper class +// +// AD number type: Sacado Rad-DFad + +#include "../ad_common_tests/helper_vector_2_indep_1_dep_vars_01.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_AD_vector_jacobian<2, double, AD::NumberTypes::sacado_rad_dfad>(); + test_AD_vector_jacobian<3, double, AD::NumberTypes::sacado_rad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_AD_vector_jacobian<2, float, AD::NumberTypes::sacado_rad_dfad>(); + test_AD_vector_jacobian<3, float, AD::NumberTypes::sacado_rad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_vector_2_indep_1_dep_vars_01_4.output b/tests/sacado/helper_vector_2_indep_1_dep_vars_01_4.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_vector_2_indep_1_dep_vars_01_4.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_vector_2_indep_2_dep_vars_01_1.cc b/tests/sacado/helper_vector_2_indep_2_dep_vars_01_1.cc new file mode 100644 index 0000000000..6bde0dc5e6 --- /dev/null +++ b/tests/sacado/helper_vector_2_indep_2_dep_vars_01_1.cc @@ -0,0 +1,47 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a vector of 2 dependent and 2 independent variables +// using a helper class +// +// AD number type: Sacado DFad + +#include "../ad_common_tests/helper_vector_2_indep_2_dep_vars_01.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_AD_vector_jacobian<2, double, AD::NumberTypes::sacado_dfad>(); + test_AD_vector_jacobian<3, double, AD::NumberTypes::sacado_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_AD_vector_jacobian<2, float, AD::NumberTypes::sacado_dfad>(); + test_AD_vector_jacobian<3, float, AD::NumberTypes::sacado_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_vector_2_indep_2_dep_vars_01_1.output b/tests/sacado/helper_vector_2_indep_2_dep_vars_01_1.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_vector_2_indep_2_dep_vars_01_1.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_vector_2_indep_2_dep_vars_01_2.cc b/tests/sacado/helper_vector_2_indep_2_dep_vars_01_2.cc new file mode 100644 index 0000000000..32de0c8697 --- /dev/null +++ b/tests/sacado/helper_vector_2_indep_2_dep_vars_01_2.cc @@ -0,0 +1,47 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a vector of 2 dependent and 2 independent variables +// using a helper class +// +// AD number type: Sacado DFad-DFad + +#include "../ad_common_tests/helper_vector_2_indep_2_dep_vars_01.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_AD_vector_jacobian<2, double, AD::NumberTypes::sacado_dfad_dfad>(); + test_AD_vector_jacobian<3, double, AD::NumberTypes::sacado_dfad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_AD_vector_jacobian<2, float, AD::NumberTypes::sacado_dfad_dfad>(); + test_AD_vector_jacobian<3, float, AD::NumberTypes::sacado_dfad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_vector_2_indep_2_dep_vars_01_2.output b/tests/sacado/helper_vector_2_indep_2_dep_vars_01_2.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_vector_2_indep_2_dep_vars_01_2.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_vector_2_indep_2_dep_vars_01_3.cc b/tests/sacado/helper_vector_2_indep_2_dep_vars_01_3.cc new file mode 100644 index 0000000000..26fdea7138 --- /dev/null +++ b/tests/sacado/helper_vector_2_indep_2_dep_vars_01_3.cc @@ -0,0 +1,47 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a vector of 2 dependent and 2 independent variables +// using a helper class +// +// AD number type: Sacado Rad + +#include "../ad_common_tests/helper_vector_2_indep_2_dep_vars_01.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_AD_vector_jacobian<2, double, AD::NumberTypes::sacado_rad>(); + test_AD_vector_jacobian<3, double, AD::NumberTypes::sacado_rad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_AD_vector_jacobian<2, float, AD::NumberTypes::sacado_rad>(); + test_AD_vector_jacobian<3, float, AD::NumberTypes::sacado_rad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_vector_2_indep_2_dep_vars_01_3.output b/tests/sacado/helper_vector_2_indep_2_dep_vars_01_3.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_vector_2_indep_2_dep_vars_01_3.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/helper_vector_2_indep_2_dep_vars_01_4.cc b/tests/sacado/helper_vector_2_indep_2_dep_vars_01_4.cc new file mode 100644 index 0000000000..36c1426b03 --- /dev/null +++ b/tests/sacado/helper_vector_2_indep_2_dep_vars_01_4.cc @@ -0,0 +1,47 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Evaluation of a vector of 2 dependent and 2 independent variables +// using a helper class +// +// AD number type: Sacado Rad-DFad + +#include "../ad_common_tests/helper_vector_2_indep_2_dep_vars_01.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_AD_vector_jacobian<2, double, AD::NumberTypes::sacado_rad_dfad>(); + test_AD_vector_jacobian<3, double, AD::NumberTypes::sacado_rad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog.push("Float"); + { + test_AD_vector_jacobian<2, float, AD::NumberTypes::sacado_rad_dfad>(); + test_AD_vector_jacobian<3, float, AD::NumberTypes::sacado_rad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/helper_vector_2_indep_2_dep_vars_01_4.output b/tests/sacado/helper_vector_2_indep_2_dep_vars_01_4.output new file mode 100644 index 0000000000..ea4ec510fe --- /dev/null +++ b/tests/sacado/helper_vector_2_indep_2_dep_vars_01_4.output @@ -0,0 +1,4 @@ + +DEAL::Double:OK +DEAL::Float:OK +DEAL::OK diff --git a/tests/sacado/step-44-helper_scalar_01_1.cc b/tests/sacado/step-44-helper_scalar_01_1.cc new file mode 100644 index 0000000000..4941fe57ce --- /dev/null +++ b/tests/sacado/step-44-helper_scalar_01_1.cc @@ -0,0 +1,68 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + +// This is a modified version of step-44, which tests the implementation of +// QP-level auto-differentiation. +// +// AD number type: Sacado DFad-DFad + +#include "../ad_common_tests/step-44-helper_scalar_01.h" +#include "../tests.h" + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + using namespace dealii; + namespace AD = dealii::Differentiation::AD; + using namespace Step44; + try + { + const unsigned int dim = 2; + Solid solid( + SOURCE_DIR "/prm/parameters-step-44.prm"); + solid.run(); + } + catch (std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + } + return 0; +} diff --git a/tests/sacado/step-44-helper_scalar_01_1.output b/tests/sacado/step-44-helper_scalar_01_1.output new file mode 100644 index 0000000000..8ba79aecc8 --- /dev/null +++ b/tests/sacado/step-44-helper_scalar_01_1.output @@ -0,0 +1,11 @@ + +DEAL::Timestep 1: 0.00 -0.000119 +DEAL::Timestep 2: 0.00 -0.000228 +DEAL::Timestep 3: 0.00 -0.000322 +DEAL::Timestep 4: 0.00 -0.000402 +DEAL::Timestep 5: 0.00 -0.000470 +DEAL::Timestep 6: 0.00 -0.000527 +DEAL::Timestep 7: 0.00 -0.000576 +DEAL::Timestep 8: 0.00 -0.000617 +DEAL::Timestep 9: 0.00 -0.000653 +DEAL::Timestep 10: 0.00 -0.000683 diff --git a/tests/sacado/step-44-helper_scalar_01_2.cc b/tests/sacado/step-44-helper_scalar_01_2.cc new file mode 100644 index 0000000000..95f8bc4445 --- /dev/null +++ b/tests/sacado/step-44-helper_scalar_01_2.cc @@ -0,0 +1,68 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + +// This is a modified version of step-44, which tests the implementation of +// QP-level auto-differentiation. +// +// AD number type: Sacado Rad-DFad + +#include "../ad_common_tests/step-44-helper_scalar_01.h" +#include "../tests.h" + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + using namespace dealii; + namespace AD = dealii::Differentiation::AD; + using namespace Step44; + try + { + const unsigned int dim = 2; + Solid solid( + SOURCE_DIR "/prm/parameters-step-44.prm"); + solid.run(); + } + catch (std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + } + return 0; +} diff --git a/tests/sacado/step-44-helper_scalar_01_2.output b/tests/sacado/step-44-helper_scalar_01_2.output new file mode 100644 index 0000000000..8ba79aecc8 --- /dev/null +++ b/tests/sacado/step-44-helper_scalar_01_2.output @@ -0,0 +1,11 @@ + +DEAL::Timestep 1: 0.00 -0.000119 +DEAL::Timestep 2: 0.00 -0.000228 +DEAL::Timestep 3: 0.00 -0.000322 +DEAL::Timestep 4: 0.00 -0.000402 +DEAL::Timestep 5: 0.00 -0.000470 +DEAL::Timestep 6: 0.00 -0.000527 +DEAL::Timestep 7: 0.00 -0.000576 +DEAL::Timestep 8: 0.00 -0.000617 +DEAL::Timestep 9: 0.00 -0.000653 +DEAL::Timestep 10: 0.00 -0.000683 diff --git a/tests/sacado/step-44-helper_vector_01_1.cc b/tests/sacado/step-44-helper_vector_01_1.cc new file mode 100644 index 0000000000..e7538aaffe --- /dev/null +++ b/tests/sacado/step-44-helper_vector_01_1.cc @@ -0,0 +1,68 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + +// This is a modified version of step-44, which tests the implementation of +// cell-level auto-differentiation (linearisation of a residual vector). +// +// AD number type: Sacado DFad + +#include "../ad_common_tests/step-44-helper_vector_01.h" +#include "../tests.h" + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + using namespace dealii; + namespace AD = dealii::Differentiation::AD; + using namespace Step44; + try + { + const unsigned int dim = 2; + Solid solid( + SOURCE_DIR "/prm/parameters-step-44.prm"); + solid.run(); + } + catch (std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + } + return 0; +} diff --git a/tests/sacado/step-44-helper_vector_01_1.output b/tests/sacado/step-44-helper_vector_01_1.output new file mode 100644 index 0000000000..8ba79aecc8 --- /dev/null +++ b/tests/sacado/step-44-helper_vector_01_1.output @@ -0,0 +1,11 @@ + +DEAL::Timestep 1: 0.00 -0.000119 +DEAL::Timestep 2: 0.00 -0.000228 +DEAL::Timestep 3: 0.00 -0.000322 +DEAL::Timestep 4: 0.00 -0.000402 +DEAL::Timestep 5: 0.00 -0.000470 +DEAL::Timestep 6: 0.00 -0.000527 +DEAL::Timestep 7: 0.00 -0.000576 +DEAL::Timestep 8: 0.00 -0.000617 +DEAL::Timestep 9: 0.00 -0.000653 +DEAL::Timestep 10: 0.00 -0.000683 diff --git a/tests/sacado/step-44-helper_vector_01_2.cc b/tests/sacado/step-44-helper_vector_01_2.cc new file mode 100644 index 0000000000..17aba571dc --- /dev/null +++ b/tests/sacado/step-44-helper_vector_01_2.cc @@ -0,0 +1,68 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + +// This is a modified version of step-44, which tests the implementation of +// cell-level auto-differentiation (linearisation of a residual vector). +// +// AD number type: Sacado DFad-DFad + +#include "../ad_common_tests/step-44-helper_vector_01.h" +#include "../tests.h" + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + using namespace dealii; + namespace AD = dealii::Differentiation::AD; + using namespace Step44; + try + { + const unsigned int dim = 2; + Solid solid( + SOURCE_DIR "/prm/parameters-step-44.prm"); + solid.run(); + } + catch (std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + } + return 0; +} diff --git a/tests/sacado/step-44-helper_vector_01_2.output b/tests/sacado/step-44-helper_vector_01_2.output new file mode 100644 index 0000000000..8ba79aecc8 --- /dev/null +++ b/tests/sacado/step-44-helper_vector_01_2.output @@ -0,0 +1,11 @@ + +DEAL::Timestep 1: 0.00 -0.000119 +DEAL::Timestep 2: 0.00 -0.000228 +DEAL::Timestep 3: 0.00 -0.000322 +DEAL::Timestep 4: 0.00 -0.000402 +DEAL::Timestep 5: 0.00 -0.000470 +DEAL::Timestep 6: 0.00 -0.000527 +DEAL::Timestep 7: 0.00 -0.000576 +DEAL::Timestep 8: 0.00 -0.000617 +DEAL::Timestep 9: 0.00 -0.000653 +DEAL::Timestep 10: 0.00 -0.000683 diff --git a/tests/sacado/step-44-helper_vector_01_3.cc b/tests/sacado/step-44-helper_vector_01_3.cc new file mode 100644 index 0000000000..9b0bda6059 --- /dev/null +++ b/tests/sacado/step-44-helper_vector_01_3.cc @@ -0,0 +1,68 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + +// This is a modified version of step-44, which tests the implementation of +// cell-level auto-differentiation (linearisation of a residual vector). +// +// AD number type: Sacado Rad + +#include "../ad_common_tests/step-44-helper_vector_01.h" +#include "../tests.h" + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + using namespace dealii; + namespace AD = dealii::Differentiation::AD; + using namespace Step44; + try + { + const unsigned int dim = 2; + Solid solid( + SOURCE_DIR "/prm/parameters-step-44.prm"); + solid.run(); + } + catch (std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + } + return 0; +} diff --git a/tests/sacado/step-44-helper_vector_01_3.output b/tests/sacado/step-44-helper_vector_01_3.output new file mode 100644 index 0000000000..8ba79aecc8 --- /dev/null +++ b/tests/sacado/step-44-helper_vector_01_3.output @@ -0,0 +1,11 @@ + +DEAL::Timestep 1: 0.00 -0.000119 +DEAL::Timestep 2: 0.00 -0.000228 +DEAL::Timestep 3: 0.00 -0.000322 +DEAL::Timestep 4: 0.00 -0.000402 +DEAL::Timestep 5: 0.00 -0.000470 +DEAL::Timestep 6: 0.00 -0.000527 +DEAL::Timestep 7: 0.00 -0.000576 +DEAL::Timestep 8: 0.00 -0.000617 +DEAL::Timestep 9: 0.00 -0.000653 +DEAL::Timestep 10: 0.00 -0.000683 diff --git a/tests/sacado/step-44-helper_vector_01_4.cc b/tests/sacado/step-44-helper_vector_01_4.cc new file mode 100644 index 0000000000..5b1288c020 --- /dev/null +++ b/tests/sacado/step-44-helper_vector_01_4.cc @@ -0,0 +1,68 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + +// This is a modified version of step-44, which tests the implementation of +// cell-level auto-differentiation (linearisation of a residual vector). +// +// AD number type: Sacado Rad-DFad + +#include "../ad_common_tests/step-44-helper_vector_01.h" +#include "../tests.h" + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + using namespace dealii; + namespace AD = dealii::Differentiation::AD; + using namespace Step44; + try + { + const unsigned int dim = 2; + Solid solid( + SOURCE_DIR "/prm/parameters-step-44.prm"); + solid.run(); + } + catch (std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + } + return 0; +} diff --git a/tests/sacado/step-44-helper_vector_01_4.output b/tests/sacado/step-44-helper_vector_01_4.output new file mode 100644 index 0000000000..8ba79aecc8 --- /dev/null +++ b/tests/sacado/step-44-helper_vector_01_4.output @@ -0,0 +1,11 @@ + +DEAL::Timestep 1: 0.00 -0.000119 +DEAL::Timestep 2: 0.00 -0.000228 +DEAL::Timestep 3: 0.00 -0.000322 +DEAL::Timestep 4: 0.00 -0.000402 +DEAL::Timestep 5: 0.00 -0.000470 +DEAL::Timestep 6: 0.00 -0.000527 +DEAL::Timestep 7: 0.00 -0.000576 +DEAL::Timestep 8: 0.00 -0.000617 +DEAL::Timestep 9: 0.00 -0.000653 +DEAL::Timestep 10: 0.00 -0.000683 diff --git a/tests/sacado/symmetric_tensor_functions_02_1.cc b/tests/sacado/symmetric_tensor_functions_02_1.cc new file mode 100644 index 0000000000..d10c13f668 --- /dev/null +++ b/tests/sacado/symmetric_tensor_functions_02_1.cc @@ -0,0 +1,40 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Test to check that tensor functions both compile and produce the right +// result when differentiated using the various auto-differentiable number +// types: Tensor inverse +// +// AD number type: Sacado DFad + +#include "../ad_common_tests/symmetric_tensor_functions_02.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_symmetric_tensor<2, double, AD::NumberTypes::sacado_dfad>(); + test_symmetric_tensor<3, double, AD::NumberTypes::sacado_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/symmetric_tensor_functions_02_1.output b/tests/sacado/symmetric_tensor_functions_02_1.output new file mode 100644 index 0000000000..3c6dd257b1 --- /dev/null +++ b/tests/sacado/symmetric_tensor_functions_02_1.output @@ -0,0 +1,3 @@ + +DEAL::Double:OK +DEAL::OK diff --git a/tests/sacado/symmetric_tensor_functions_02_2.cc b/tests/sacado/symmetric_tensor_functions_02_2.cc new file mode 100644 index 0000000000..58907ea008 --- /dev/null +++ b/tests/sacado/symmetric_tensor_functions_02_2.cc @@ -0,0 +1,40 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Test to check that tensor functions both compile and produce the right +// result when differentiated using the various auto-differentiable number +// types: Tensor inverse +// +// AD number type: Sacado DFad-DFad + +#include "../ad_common_tests/symmetric_tensor_functions_02.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_symmetric_tensor<2, double, AD::NumberTypes::sacado_dfad_dfad>(); + test_symmetric_tensor<3, double, AD::NumberTypes::sacado_dfad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/symmetric_tensor_functions_02_2.output b/tests/sacado/symmetric_tensor_functions_02_2.output new file mode 100644 index 0000000000..3c6dd257b1 --- /dev/null +++ b/tests/sacado/symmetric_tensor_functions_02_2.output @@ -0,0 +1,3 @@ + +DEAL::Double:OK +DEAL::OK diff --git a/tests/sacado/symmetric_tensor_functions_02_3.cc b/tests/sacado/symmetric_tensor_functions_02_3.cc new file mode 100644 index 0000000000..ff09bda389 --- /dev/null +++ b/tests/sacado/symmetric_tensor_functions_02_3.cc @@ -0,0 +1,40 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Test to check that tensor functions both compile and produce the right +// result when differentiated using the various auto-differentiable number +// types: Tensor inverse +// +// AD number type: Sacado Rad + +#include "../ad_common_tests/symmetric_tensor_functions_02.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_symmetric_tensor<2, double, AD::NumberTypes::sacado_rad>(); + test_symmetric_tensor<3, double, AD::NumberTypes::sacado_rad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/symmetric_tensor_functions_02_3.output b/tests/sacado/symmetric_tensor_functions_02_3.output new file mode 100644 index 0000000000..3c6dd257b1 --- /dev/null +++ b/tests/sacado/symmetric_tensor_functions_02_3.output @@ -0,0 +1,3 @@ + +DEAL::Double:OK +DEAL::OK diff --git a/tests/sacado/symmetric_tensor_functions_02_4.cc b/tests/sacado/symmetric_tensor_functions_02_4.cc new file mode 100644 index 0000000000..7760020624 --- /dev/null +++ b/tests/sacado/symmetric_tensor_functions_02_4.cc @@ -0,0 +1,40 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Test to check that tensor functions both compile and produce the right +// result when differentiated using the various auto-differentiable number +// types: Tensor inverse +// +// AD number type: Sacado Rad-DFad + +#include "../ad_common_tests/symmetric_tensor_functions_02.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_symmetric_tensor<2, double, AD::NumberTypes::sacado_rad_dfad>(); + test_symmetric_tensor<3, double, AD::NumberTypes::sacado_rad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/symmetric_tensor_functions_02_4.output b/tests/sacado/symmetric_tensor_functions_02_4.output new file mode 100644 index 0000000000..3c6dd257b1 --- /dev/null +++ b/tests/sacado/symmetric_tensor_functions_02_4.output @@ -0,0 +1,3 @@ + +DEAL::Double:OK +DEAL::OK diff --git a/tests/sacado/symmetric_tensor_functions_03_1.cc b/tests/sacado/symmetric_tensor_functions_03_1.cc new file mode 100644 index 0000000000..c82266a99c --- /dev/null +++ b/tests/sacado/symmetric_tensor_functions_03_1.cc @@ -0,0 +1,40 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Test to check that tensor functions both compile and produce the right +// result when differentiated using the various auto-differentiable number +// types: Eigenvalues +// +// AD number type: Sacado DFad + +#include "../ad_common_tests/symmetric_tensor_functions_03.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_symmetric_tensor<2, double, AD::NumberTypes::sacado_dfad>(); + test_symmetric_tensor<3, double, AD::NumberTypes::sacado_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/symmetric_tensor_functions_03_1.output b/tests/sacado/symmetric_tensor_functions_03_1.output new file mode 100644 index 0000000000..3c6dd257b1 --- /dev/null +++ b/tests/sacado/symmetric_tensor_functions_03_1.output @@ -0,0 +1,3 @@ + +DEAL::Double:OK +DEAL::OK diff --git a/tests/sacado/symmetric_tensor_functions_03_2.cc b/tests/sacado/symmetric_tensor_functions_03_2.cc new file mode 100644 index 0000000000..09725a655e --- /dev/null +++ b/tests/sacado/symmetric_tensor_functions_03_2.cc @@ -0,0 +1,40 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Test to check that tensor functions both compile and produce the right +// result when differentiated using the various auto-differentiable number +// types: Eigenvalues +// +// AD number type: Sacado DFad-DFad + +#include "../ad_common_tests/symmetric_tensor_functions_03.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_symmetric_tensor<2, double, AD::NumberTypes::sacado_dfad_dfad>(); + test_symmetric_tensor<3, double, AD::NumberTypes::sacado_dfad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/symmetric_tensor_functions_03_2.output b/tests/sacado/symmetric_tensor_functions_03_2.output new file mode 100644 index 0000000000..3c6dd257b1 --- /dev/null +++ b/tests/sacado/symmetric_tensor_functions_03_2.output @@ -0,0 +1,3 @@ + +DEAL::Double:OK +DEAL::OK diff --git a/tests/sacado/symmetric_tensor_functions_03_3.cc b/tests/sacado/symmetric_tensor_functions_03_3.cc new file mode 100644 index 0000000000..4c0424527a --- /dev/null +++ b/tests/sacado/symmetric_tensor_functions_03_3.cc @@ -0,0 +1,40 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Test to check that tensor functions both compile and produce the right +// result when differentiated using the various auto-differentiable number +// types: Eigenvalues +// +// AD number type: Sacado Rad + +#include "../ad_common_tests/symmetric_tensor_functions_03.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_symmetric_tensor<2, double, AD::NumberTypes::sacado_rad>(); + test_symmetric_tensor<3, double, AD::NumberTypes::sacado_rad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/symmetric_tensor_functions_03_3.output b/tests/sacado/symmetric_tensor_functions_03_3.output new file mode 100644 index 0000000000..3c6dd257b1 --- /dev/null +++ b/tests/sacado/symmetric_tensor_functions_03_3.output @@ -0,0 +1,3 @@ + +DEAL::Double:OK +DEAL::OK diff --git a/tests/sacado/symmetric_tensor_functions_03_4.cc b/tests/sacado/symmetric_tensor_functions_03_4.cc new file mode 100644 index 0000000000..7992f1c937 --- /dev/null +++ b/tests/sacado/symmetric_tensor_functions_03_4.cc @@ -0,0 +1,40 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Test to check that tensor functions both compile and produce the right +// result when differentiated using the various auto-differentiable number +// types: Eigenvalues +// +// AD number type: Sacado Rad-DFad + +#include "../ad_common_tests/symmetric_tensor_functions_03.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_symmetric_tensor<2, double, AD::NumberTypes::sacado_rad_dfad>(); + test_symmetric_tensor<3, double, AD::NumberTypes::sacado_rad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/symmetric_tensor_functions_03_4.output b/tests/sacado/symmetric_tensor_functions_03_4.output new file mode 100644 index 0000000000..3c6dd257b1 --- /dev/null +++ b/tests/sacado/symmetric_tensor_functions_03_4.output @@ -0,0 +1,3 @@ + +DEAL::Double:OK +DEAL::OK diff --git a/tests/sacado/symmetric_tensor_functions_04_1.cc b/tests/sacado/symmetric_tensor_functions_04_1.cc new file mode 100644 index 0000000000..aca53a98a9 --- /dev/null +++ b/tests/sacado/symmetric_tensor_functions_04_1.cc @@ -0,0 +1,40 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Test to check that tensor functions both compile and produce the right +// result when differentiated using the various auto-differentiable number +// types: Eigenvalues and eignvectors +// +// AD number type: Sacado DFad + +#include "../ad_common_tests/symmetric_tensor_functions_04.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_symmetric_tensor<2, double, AD::NumberTypes::sacado_dfad>(); + test_symmetric_tensor<3, double, AD::NumberTypes::sacado_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/symmetric_tensor_functions_04_1.output b/tests/sacado/symmetric_tensor_functions_04_1.output new file mode 100644 index 0000000000..3c6dd257b1 --- /dev/null +++ b/tests/sacado/symmetric_tensor_functions_04_1.output @@ -0,0 +1,3 @@ + +DEAL::Double:OK +DEAL::OK diff --git a/tests/sacado/symmetric_tensor_functions_04_2.cc b/tests/sacado/symmetric_tensor_functions_04_2.cc new file mode 100644 index 0000000000..f14c0d9e90 --- /dev/null +++ b/tests/sacado/symmetric_tensor_functions_04_2.cc @@ -0,0 +1,40 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Test to check that tensor functions both compile and produce the right +// result when differentiated using the various auto-differentiable number +// types: Eigenvalues and eignvectors +// +// AD number type: Sacado DFad-DFad + +#include "../ad_common_tests/symmetric_tensor_functions_04.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_symmetric_tensor<2, double, AD::NumberTypes::sacado_dfad_dfad>(); + test_symmetric_tensor<3, double, AD::NumberTypes::sacado_dfad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/symmetric_tensor_functions_04_2.output b/tests/sacado/symmetric_tensor_functions_04_2.output new file mode 100644 index 0000000000..3c6dd257b1 --- /dev/null +++ b/tests/sacado/symmetric_tensor_functions_04_2.output @@ -0,0 +1,3 @@ + +DEAL::Double:OK +DEAL::OK diff --git a/tests/sacado/symmetric_tensor_functions_04_3.cc b/tests/sacado/symmetric_tensor_functions_04_3.cc new file mode 100644 index 0000000000..f3479264c7 --- /dev/null +++ b/tests/sacado/symmetric_tensor_functions_04_3.cc @@ -0,0 +1,40 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Test to check that tensor functions both compile and produce the right +// result when differentiated using the various auto-differentiable number +// types: Eigenvalues and eignvectors +// +// AD number type: Sacado Rad + +#include "../ad_common_tests/symmetric_tensor_functions_04.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_symmetric_tensor<2, double, AD::NumberTypes::sacado_rad>(); + test_symmetric_tensor<3, double, AD::NumberTypes::sacado_rad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/symmetric_tensor_functions_04_3.output b/tests/sacado/symmetric_tensor_functions_04_3.output new file mode 100644 index 0000000000..3c6dd257b1 --- /dev/null +++ b/tests/sacado/symmetric_tensor_functions_04_3.output @@ -0,0 +1,3 @@ + +DEAL::Double:OK +DEAL::OK diff --git a/tests/sacado/symmetric_tensor_functions_04_4.cc b/tests/sacado/symmetric_tensor_functions_04_4.cc new file mode 100644 index 0000000000..2aa76842e0 --- /dev/null +++ b/tests/sacado/symmetric_tensor_functions_04_4.cc @@ -0,0 +1,40 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Test to check that tensor functions both compile and produce the right +// result when differentiated using the various auto-differentiable number +// types: Eigenvalues and eignvectors +// +// AD number type: Sacado Rad-DFad + +#include "../ad_common_tests/symmetric_tensor_functions_04.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_symmetric_tensor<2, double, AD::NumberTypes::sacado_rad_dfad>(); + test_symmetric_tensor<3, double, AD::NumberTypes::sacado_rad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/symmetric_tensor_functions_04_4.output b/tests/sacado/symmetric_tensor_functions_04_4.output new file mode 100644 index 0000000000..3c6dd257b1 --- /dev/null +++ b/tests/sacado/symmetric_tensor_functions_04_4.output @@ -0,0 +1,3 @@ + +DEAL::Double:OK +DEAL::OK diff --git a/tests/sacado/tensor_functions_02_1.cc b/tests/sacado/tensor_functions_02_1.cc new file mode 100644 index 0000000000..4a1a8db734 --- /dev/null +++ b/tests/sacado/tensor_functions_02_1.cc @@ -0,0 +1,40 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Test to check that tensor functions both compile and produce the right +// result when differentiated using the various auto-differentiable number +// types: Tensor inverse +// +// AD number type: Sacado DFad + +#include "../ad_common_tests/tensor_functions_02.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_tensor<2, double, AD::NumberTypes::sacado_dfad>(); + test_tensor<3, double, AD::NumberTypes::sacado_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/tensor_functions_02_1.output b/tests/sacado/tensor_functions_02_1.output new file mode 100644 index 0000000000..3c6dd257b1 --- /dev/null +++ b/tests/sacado/tensor_functions_02_1.output @@ -0,0 +1,3 @@ + +DEAL::Double:OK +DEAL::OK diff --git a/tests/sacado/tensor_functions_02_2.cc b/tests/sacado/tensor_functions_02_2.cc new file mode 100644 index 0000000000..5ddcaa201d --- /dev/null +++ b/tests/sacado/tensor_functions_02_2.cc @@ -0,0 +1,40 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Test to check that tensor functions both compile and produce the right +// result when differentiated using the various auto-differentiable number +// types: Tensor inverse +// +// AD number type: Sacado DFad-DFad + +#include "../ad_common_tests/tensor_functions_02.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_tensor<2, double, AD::NumberTypes::sacado_dfad_dfad>(); + test_tensor<3, double, AD::NumberTypes::sacado_dfad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/tensor_functions_02_2.output b/tests/sacado/tensor_functions_02_2.output new file mode 100644 index 0000000000..3c6dd257b1 --- /dev/null +++ b/tests/sacado/tensor_functions_02_2.output @@ -0,0 +1,3 @@ + +DEAL::Double:OK +DEAL::OK diff --git a/tests/sacado/tensor_functions_02_3.cc b/tests/sacado/tensor_functions_02_3.cc new file mode 100644 index 0000000000..28a2980647 --- /dev/null +++ b/tests/sacado/tensor_functions_02_3.cc @@ -0,0 +1,40 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Test to check that tensor functions both compile and produce the right +// result when differentiated using the various auto-differentiable number +// types: Tensor inverse +// +// AD number type: Sacado Rad + +#include "../ad_common_tests/tensor_functions_02.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_tensor<2, double, AD::NumberTypes::sacado_rad>(); + test_tensor<3, double, AD::NumberTypes::sacado_rad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/tensor_functions_02_3.output b/tests/sacado/tensor_functions_02_3.output new file mode 100644 index 0000000000..3c6dd257b1 --- /dev/null +++ b/tests/sacado/tensor_functions_02_3.output @@ -0,0 +1,3 @@ + +DEAL::Double:OK +DEAL::OK diff --git a/tests/sacado/tensor_functions_02_4.cc b/tests/sacado/tensor_functions_02_4.cc new file mode 100644 index 0000000000..4ce066f81f --- /dev/null +++ b/tests/sacado/tensor_functions_02_4.cc @@ -0,0 +1,40 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + + +// Test to check that tensor functions both compile and produce the right +// result when differentiated using the various auto-differentiable number +// types: Tensor inverse +// +// AD number type: Sacado Rad-DFad + +#include "../ad_common_tests/tensor_functions_02.h" +#include "../tests.h" + +int +main() +{ + initlog(); + + deallog.push("Double"); + { + test_tensor<2, double, AD::NumberTypes::sacado_rad_dfad>(); + test_tensor<3, double, AD::NumberTypes::sacado_rad_dfad>(); + deallog << "OK" << std::endl; + } + deallog.pop(); + + deallog << "OK" << std::endl; +} diff --git a/tests/sacado/tensor_functions_02_4.output b/tests/sacado/tensor_functions_02_4.output new file mode 100644 index 0000000000..3c6dd257b1 --- /dev/null +++ b/tests/sacado/tensor_functions_02_4.output @@ -0,0 +1,3 @@ + +DEAL::Double:OK +DEAL::OK -- 2.39.5