From fdc126a0de5097f003fb88475be19925e2bf1c59 Mon Sep 17 00:00:00 2001 From: Haibing Shao Date: Sat, 2 Dec 2023 19:11:36 +0100 Subject: [PATCH 1/7] add FCT to numerical stabilization add FCT function pass address add function bugfix clang-format trim trailing whitespace trim trailing whitespace switch off when OGS_USE_PETSC defined switch off when OGS_USE_PETSC switch off when OGS_USE_PETSC USE_PETSC USE_PETSC USE_PETSC USE_PETSC clang-format move ifdef fix error msg clang-format clang-format clang-format fix error fix error in no_unity setting fix error in no-unity setting set maybe_unused clang-format --- .../CreateNumericalStabilization.cpp | 4 + .../CreateNumericalStabilization.h | 5 +- .../FluxCorrectedTransport.h | 252 ++++++++++++++++++ .../NumericalStabilization.h | 25 +- 4 files changed, 284 insertions(+), 2 deletions(-) create mode 100644 NumLib/NumericalStability/FluxCorrectedTransport.h diff --git a/NumLib/NumericalStability/CreateNumericalStabilization.cpp b/NumLib/NumericalStability/CreateNumericalStabilization.cpp index e87a2812b0e..a2df730902c 100644 --- a/NumLib/NumericalStability/CreateNumericalStabilization.cpp +++ b/NumLib/NumericalStability/CreateNumericalStabilization.cpp @@ -56,6 +56,10 @@ NumericalStabilization createNumericalStabilization( return FullUpwind{cutoff_velocity}; } + if (type == "FluxCorrectedTransport") + { + return FluxCorrectedTransport(); + } OGS_FATAL("The stabilization type {:s} is not available.", type); } diff --git a/NumLib/NumericalStability/CreateNumericalStabilization.h b/NumLib/NumericalStability/CreateNumericalStabilization.h index d989312d9a4..2d524d5d4b4 100644 --- a/NumLib/NumericalStability/CreateNumericalStabilization.h +++ b/NumLib/NumericalStability/CreateNumericalStabilization.h @@ -26,8 +26,11 @@ namespace NumLib struct NoStabilization; class IsotropicDiffusionStabilization; class FullUpwind; +class FluxCorrectedTransport; + using NumericalStabilization = - std::variant; + std::variant; } // namespace NumLib namespace NumLib diff --git a/NumLib/NumericalStability/FluxCorrectedTransport.h b/NumLib/NumericalStability/FluxCorrectedTransport.h new file mode 100644 index 00000000000..341e86a60d1 --- /dev/null +++ b/NumLib/NumericalStability/FluxCorrectedTransport.h @@ -0,0 +1,252 @@ +/** + * \file + * \copyright + * Copyright (c) 2012-2023, OpenGeoSys Community (http://www.opengeosys.org) + * Distributed under a Modified BSD License. + * See accompanying file LICENSE.txt or + * http://www.opengeosys.org/project/license + */ + +#pragma once + +#include +#include + +#include "NumericalStabilization.h" + +namespace NumLib +{ +namespace detail +{ + +void calculateFluxCorrectedTransport( + [[maybe_unused]] const double t, [[maybe_unused]] const double dt, + [[maybe_unused]] std::vector const& x, + [[maybe_unused]] std::vector const& x_prev, + [[maybe_unused]] int const process_id, + [[maybe_unused]] const MathLib::MatrixSpecifications& matrix_specification, + [[maybe_unused]] GlobalMatrix& M, [[maybe_unused]] GlobalMatrix& K, + [[maybe_unused]] GlobalVector& b) +{ +#ifndef USE_PETSC + // declare and initialize the matrix D and F + std::size_t matrix_id = 0u; + auto& D = NumLib::GlobalMatrixProvider::provider.getMatrix( + matrix_specification, matrix_id); + auto& F = NumLib::GlobalMatrixProvider::provider.getMatrix( + matrix_specification, matrix_id); + D.setZero(); + F.setZero(); + + // compute artificial diffusion operator D + using RawMatrixType = Eigen::SparseMatrix; + auto& K_raw = K.getRawMatrix(); + K_raw *= -1; + for (int k = 0; k < K_raw.outerSize(); ++k) + { + for (RawMatrixType::InnerIterator it(K_raw, k); it; ++it) + { + if (it.row() != it.col()) + { + double const kij = it.value(); + double const kji = K.get(it.col(), it.row()); + double const dij = std::max({-kij, 0., -kji}); + D.setValue(it.row(), it.col(), dij); + } + } + } + auto& D_raw = D.getRawMatrix(); + D_raw -= (D_raw * Eigen::VectorXd::Ones(D_raw.cols())).eval().asDiagonal(); + + // compute F + for (int k = 0; k < D_raw.outerSize(); ++k) + { + for (RawMatrixType::InnerIterator it(D_raw, k); it; ++it) + { + double const dij = it.value(); + double const xj = x[process_id]->get(it.col()); + double const xi = x[process_id]->get(it.row()); + double const fij = -dij * (xj - xi); + F.setValue(it.row(), it.col(), fij); + } + } + + auto& M_raw = M.getRawMatrix(); + for (int k = 0; k < M_raw.outerSize(); ++k) + { + for (RawMatrixType::InnerIterator it(M_raw, k); it; ++it) + { + double const mij = it.value(); + double const xdotj = (x[process_id]->get(it.col()) - + x_prev[process_id]->get(it.col())) / + dt; + double const xdoti = (x[process_id]->get(it.row()) - + x_prev[process_id]->get(it.row())) / + dt; + double const fij = -mij * (xdotj - xdoti); + F.add(it.row(), it.col(), fij); + } + } + + auto& P_plus = + NumLib::GlobalVectorProvider::provider.getVector(matrix_specification); + auto& P_minus = + NumLib::GlobalVectorProvider::provider.getVector(matrix_specification); + auto& Q_plus = + NumLib::GlobalVectorProvider::provider.getVector(matrix_specification); + auto& Q_minus = + NumLib::GlobalVectorProvider::provider.getVector(matrix_specification); + auto& R_plus = + NumLib::GlobalVectorProvider::provider.getVector(matrix_specification); + auto& R_minus = + NumLib::GlobalVectorProvider::provider.getVector(matrix_specification); + + P_plus.setZero(); + P_minus.setZero(); + Q_plus.setZero(); + Q_minus.setZero(); + R_plus.setZero(); + R_minus.setZero(); + + auto& F_raw = F.getRawMatrix(); + for (int k = 0; k < F_raw.outerSize(); ++k) + { + for (RawMatrixType::InnerIterator it(F_raw, k); it; ++it) + { + if (it.row() != it.col()) + { + double const fij = it.value(); + P_plus.add(it.row(), std::max(0., fij)); + P_minus.add(it.row(), std::min(0., fij)); + + double const x_prev_i = x_prev[process_id]->get(it.row()); + double const x_prev_j = x_prev[process_id]->get(it.col()); + + double const Q_plus_i = Q_plus.get(it.row()); + double Q_plus_i_tmp = + std::max({Q_plus_i, 0., x_prev_j - x_prev_i}); + Q_plus.set(it.row(), Q_plus_i_tmp); + + double const Q_minus_i = Q_minus.get(it.row()); + double Q_minus_i_tmp = + std::min({Q_minus_i, 0., x_prev_j - x_prev_i}); + Q_minus.set(it.row(), Q_minus_i_tmp); + } + } + } + + Eigen::VectorXd const M_L = + (M_raw * Eigen::VectorXd::Ones(M_raw.cols())).eval(); + for (auto k = R_plus.getRangeBegin(); k < R_plus.getRangeEnd(); ++k) + { + double const mi = M_L(k); + double const Q_plus_i = Q_plus.get(k); + double const P_plus_i = P_plus.get(k); + + double const tmp = + P_plus_i == 0. ? 0.0 : std::min(1.0, mi * Q_plus_i / dt / P_plus_i); + + R_plus.set(k, tmp); + } + + for (auto k = R_minus.getRangeBegin(); k < R_minus.getRangeEnd(); ++k) + { + double const mi = M_L(k); + double const Q_minus_i = Q_minus.get(k); + double const P_minus_i = P_minus.get(k); + + double const tmp = P_minus_i == 0. + ? 0.0 + : std::min(1.0, mi * Q_minus_i / dt / P_minus_i); + R_minus.set(k, tmp); + } + + auto& alpha = NumLib::GlobalMatrixProvider::provider.getMatrix( + matrix_specification, matrix_id); + alpha.setZero(); + for (int k = 0; k < F_raw.outerSize(); ++k) + { + for (RawMatrixType::InnerIterator it(F_raw, k); it; ++it) + { + double const fij = it.value(); + if (fij > 0.) + { + double const R_plus_i = R_plus.get(it.row()); + double const R_minus_j = R_minus.get(it.col()); + double const alpha_ij = std::min(R_plus_i, R_minus_j); + + alpha.setValue(it.row(), it.col(), alpha_ij); + } + else + { + double const R_minus_i = R_minus.get(it.row()); + double const R_plus_j = R_plus.get(it.col()); + double const alpha_ij = std::min(R_minus_i, R_plus_j); + + alpha.setValue(it.row(), it.col(), alpha_ij); + } + } + } + + // compute limited antidiffusive fluxes + for (int k = 0; k < F_raw.outerSize(); ++k) + { + for (RawMatrixType::InnerIterator it(F_raw, k); it; ++it) + { + if (it.row() != it.col()) + { + double const fij = it.value(); + double const alpha_ij = alpha.get(it.row(), it.col()); + + b.add(it.row(), alpha_ij * fij); + } + } + } + + // compute low-order operator + K_raw += D_raw; + K_raw *= -1; + + // overwrite with the lumped mass matrix + M.setZero(); + for (int k = 0; k < M.getNumberOfRows(); ++k) + { + M.setValue(k, k, M_L(k)); + } + + NumLib::GlobalVectorProvider::provider.releaseVector(P_plus); + NumLib::GlobalVectorProvider::provider.releaseVector(P_minus); + NumLib::GlobalVectorProvider::provider.releaseVector(Q_plus); + NumLib::GlobalVectorProvider::provider.releaseVector(Q_minus); + NumLib::GlobalVectorProvider::provider.releaseVector(R_plus); + NumLib::GlobalVectorProvider::provider.releaseVector(R_minus); + NumLib::GlobalMatrixProvider::provider.releaseMatrix(alpha); + NumLib::GlobalMatrixProvider::provider.releaseMatrix(D); + NumLib::GlobalMatrixProvider::provider.releaseMatrix(F); +#endif // end of ifndef USE_PETSC +} +} // namespace detail + +inline void computeFluxCorrectedTransport( + NumericalStabilization const& stabilizer, const double t, const double dt, + std::vector const& x, + std::vector const& x_prev, int const process_id, + const MathLib::MatrixSpecifications& matrix_specification, GlobalMatrix& M, + GlobalMatrix& K, GlobalVector& b) +{ + // if needed, calling the Flux-Corrected-Transport function + return std::visit( + [&](auto&& stabilizer) + { + using Stabilizer = std::decay_t; + if constexpr (std::is_same_v) + { + return detail::calculateFluxCorrectedTransport( + t, dt, x, x_prev, process_id, matrix_specification, M, K, + b); + } + }, + stabilizer); +} +} // namespace NumLib \ No newline at end of file diff --git a/NumLib/NumericalStability/NumericalStabilization.h b/NumLib/NumericalStability/NumericalStabilization.h index c9f32340c70..621bb9de3c7 100644 --- a/NumLib/NumericalStability/NumericalStabilization.h +++ b/NumLib/NumericalStability/NumericalStabilization.h @@ -15,6 +15,9 @@ #include #include +#include "BaseLib/Error.h" +#include "NumLib/DOF/GlobalMatrixProviders.h" + namespace NumLib { /** It defines stabilization method for solving the advection diffusion @@ -170,6 +173,26 @@ class FullUpwind final double const cutoff_velocity_; }; +class FluxCorrectedTransport final +{ +public: + explicit FluxCorrectedTransport() + { +#ifdef USE_PETSC + OGS_FATAL( + "FluxCorrectedTransport scheme is not implemented to work with MPI " + "parallelization."); +#endif + } + + void calculateFluxCorrectedTransport( + const double t, const double dt, std::vector const& x, + std::vector const& x_prev, int const process_id, + const MathLib::MatrixSpecifications& matrix_specification, + GlobalMatrix& M, GlobalMatrix& K, GlobalVector& b); +}; + using NumericalStabilization = - std::variant; + std::variant; } // namespace NumLib From d376034e727dd44549d95e491aaa2d3b97d2da7a Mon Sep 17 00:00:00 2001 From: Haibing Shao Date: Sat, 2 Dec 2023 19:11:36 +0100 Subject: [PATCH 2/7] call FCT in ComponentTransport process fixup! calculate D and F in ComponentTransport remove the pass of D and F matrix declare and reclaim D and F locally move FCT feature to a separate function activate the switch use the switch built in stabilizer move to stabilizer add include clean not needed lib clang-format clang-format switch off when OGS_USE_PETSC USE_PETSC move ifdef to FluxCorrectedTransport class --- .../ComponentTransportProcess.cpp | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/ProcessLib/ComponentTransport/ComponentTransportProcess.cpp b/ProcessLib/ComponentTransport/ComponentTransportProcess.cpp index bdf611726c1..fdd0b9ea028 100644 --- a/ProcessLib/ComponentTransport/ComponentTransportProcess.cpp +++ b/ProcessLib/ComponentTransport/ComponentTransportProcess.cpp @@ -18,9 +18,12 @@ #include "MathLib/LinAlg/Eigen/EigenTools.h" #include "MathLib/LinAlg/FinalizeMatrixAssembly.h" #include "MathLib/LinAlg/FinalizeVectorAssembly.h" +#include "MathLib/LinAlg/GlobalMatrixVectorTypes.h" #include "MathLib/LinAlg/LinAlg.h" #include "MeshLib/Utils/getOrCreateMeshProperty.h" #include "NumLib/DOF/ComputeSparsityPattern.h" +#include "NumLib/NumericalStability/FluxCorrectedTransport.h" +#include "NumLib/NumericalStability/NumericalStabilization.h" #include "NumLib/ODESolver/NonlinearSystem.h" #include "ProcessLib/CoupledSolutionsForStaggeredScheme.h" #include "ProcessLib/SurfaceFlux/SurfaceFlux.h" @@ -220,6 +223,16 @@ void ComponentTransportProcess::assembleConcreteProcess( _asm_mat_cache.assemble(t, dt, x, x_prev, process_id, M, K, b, dof_tables, _global_assembler, _local_assemblers, pv.getActiveElementIDs()); + + if (process_id == _process_data.hydraulic_process_id) + { + return; + } + auto const matrix_specification = getMatrixSpecifications(process_id); + + NumLib::computeFluxCorrectedTransport(_process_data.stabilizer, t, dt, x, + x_prev, process_id, + matrix_specification, M, K, b); } void ComponentTransportProcess::assembleWithJacobianConcreteProcess( @@ -515,6 +528,5 @@ void ComponentTransportProcess::preOutputConcreteProcess( INFO("[time] Computing residuum flow rates took {:g} s", time_residuum.elapsed()); } - } // namespace ComponentTransport } // namespace ProcessLib From af44cc2e344a87fdf1ba7c3c956b48ed28a941b1 Mon Sep 17 00:00:00 2001 From: Haibing Shao Date: Sat, 2 Dec 2023 19:11:36 +0100 Subject: [PATCH 3/7] [T] benchmark of FCT feature change output prefix update results remove LIS and PETSc config switch on vtkdiff in OgsTest --- ProcessLib/ComponentTransport/Tests.cmake | 4 + .../FCT_test/1d_step_func.prj | 277 ++++++++++++++++++ .../FCT_test/1d_step_func.pvd | 16 + .../FCT_test/1d_step_func.vtu | 32 ++ .../FCT_test/1d_step_func_inlet.vtu | 24 ++ .../FCT_test/1d_step_func_outlet.vtu | 24 ++ .../FCT_test/1d_step_func_ts_0_t_0.000000.vtu | 27 ++ .../1d_step_func_ts_100_t_0.100000.vtu | 27 ++ .../1d_step_func_ts_150_t_0.150000.vtu | 27 ++ .../1d_step_func_ts_200_t_0.200000.vtu | 27 ++ .../1d_step_func_ts_250_t_0.250000.vtu | 27 ++ .../1d_step_func_ts_300_t_0.300000.vtu | 27 ++ .../1d_step_func_ts_350_t_0.350000.vtu | 27 ++ .../1d_step_func_ts_400_t_0.400000.vtu | 27 ++ .../1d_step_func_ts_450_t_0.450000.vtu | 27 ++ .../1d_step_func_ts_500_t_0.500000.vtu | 27 ++ .../1d_step_func_ts_50_t_0.050000.vtu | 27 ++ 17 files changed, 674 insertions(+) create mode 100644 Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func.prj create mode 100644 Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func.pvd create mode 100644 Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func.vtu create mode 100644 Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_inlet.vtu create mode 100644 Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_outlet.vtu create mode 100644 Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_0_t_0.000000.vtu create mode 100644 Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_100_t_0.100000.vtu create mode 100644 Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_150_t_0.150000.vtu create mode 100644 Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_200_t_0.200000.vtu create mode 100644 Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_250_t_0.250000.vtu create mode 100644 Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_300_t_0.300000.vtu create mode 100644 Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_350_t_0.350000.vtu create mode 100644 Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_400_t_0.400000.vtu create mode 100644 Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_450_t_0.450000.vtu create mode 100644 Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_500_t_0.500000.vtu create mode 100644 Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_50_t_0.050000.vtu diff --git a/ProcessLib/ComponentTransport/Tests.cmake b/ProcessLib/ComponentTransport/Tests.cmake index 6e1c8cf0174..fe6955a43fb 100644 --- a/ProcessLib/ComponentTransport/Tests.cmake +++ b/ProcessLib/ComponentTransport/Tests.cmake @@ -807,6 +807,10 @@ if (NOT OGS_USE_MPI) OgsTest(PROJECTFILE Parabolic/ComponentTransport/ThermalDiffusion/TemperatureField_transport.prj RUNTIME 27) endif() +if(NOT OGS_USE_PETSC) + OgsTest(PROJECTFILE Parabolic/ComponentTransport/FCT_test/1d_step_func.prj RUNTIME 5) +endif() + if(NOT OGS_USE_PETSC) NotebookTest( NOTEBOOKFILE Parabolic/ComponentTransport/ReactiveTransport/DecayChain/GlobalImplicitApproach/performance_measurements.ipynb diff --git a/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func.prj b/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func.prj new file mode 100644 index 00000000000..69e99fd7679 --- /dev/null +++ b/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func.prj @@ -0,0 +1,277 @@ + + + + 1d_step_func.vtu + 1d_step_func_inlet.vtu + 1d_step_func_outlet.vtu + + + + hc + ComponentTransport + 2 + staggered + + Cs_w_FCT + pressure + + 0 + + FluxCorrectedTransport + + + + + + + + AqueousLiquid + + + Cs_w_FCT + + + pore_diffusion + Constant + 0 + + + retardation_factor + Constant + 1 + + + decay_rate + Parameter + decay + + + + + + + density + Constant + 1e3 + + + viscosity + Constant + 1e-3 + + + + + + + permeability + Parameter + kappa + + + porosity + Parameter + porosity + + + longitudinal_dispersivity + Constant + 0 + + + transversal_dispersivity + Constant + 0 + + + + + + + 6 + + + + DeltaX + NORM2 + 1e-8 + + + + DeltaX + NORM2 + 1e-8 + + + + + + + basic_picard + + DeltaX + NORM2 + 1e-8 + + + BackwardEuler + + + FixedTimeStepping + 0.0 + 0.5 + + + 500 + 0.001 + + + + + + + basic_picard + + DeltaX + NORM2 + 1e-10 + + + BackwardEuler + + + FixedTimeStepping + 0.0 + 0.5 + + + 500 + 0.001 + + + + + + + VTK + 1d_step_func + + + 10 + 50 + + + + Cs_w_FCT + pressure + darcy_velocity + + _ts_{:timestep}_t_{:time} + + + + + kappa + Constant + 1.0e-8 + + + porosity + Constant + 1 + + + retardation + Constant + + 1 + + + decay + Constant + 0 + + + p0 + Constant + 1e5 + + + p_Neumann_left + Constant + 1e3 + + + c0 + MeshNode + 1d_step_func + c_ini + + + c_inlet + Constant + 0 + + + + + pressure + 1 + 1 + p0 + + + 1d_step_func_inlet + Neumann + p_Neumann_left + + + 1d_step_func_outlet + Dirichlet + p0 + + + + + Cs_w_FCT + 1 + 1 + c0 + + + 1d_step_func_inlet + Dirichlet + c_inlet + + + + + + + basic_picard + Picard + 50 + general_linear_solver + + + + + general_linear_solver + + + BiCGSTAB + ILUT + 1000 + 1e-14 + + + + + + 1d_step_func_ts_[0-9]*_t_0.[0-9]*0000.vtu + Cs_w_FCT + 1e-10 + 1e-14 + + + diff --git a/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func.pvd b/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func.pvd new file mode 100644 index 00000000000..6e879926270 --- /dev/null +++ b/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func.pvd @@ -0,0 +1,16 @@ + + + + + + + + + + + + + + + + diff --git a/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func.vtu b/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func.vtu new file mode 100644 index 00000000000..44ee852cfab --- /dev/null +++ b/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func.vtu @@ -0,0 +1,32 @@ + + + + + + KAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8D8AAAAAAADwPwAAAAAAAPA/AAAAAAAA8D8AAAAAAADwPwAAAAAAAPA/AAAAAAAA8D8AAAAAAADwPwAAAAAAAPA/AAAAAAAA8D8AAAAAAADwPwAAAAAAAPA/AAAAAAAA8D8AAAAAAADwPwAAAAAAAPA/AAAAAAAA8D8AAAAAAADwPwAAAAAAAPA/AAAAAAAA8D8AAAAAAADwPwAAAAAAAPA/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + + + + + kAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + + + + + 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 + + + + + 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 + + + IAMAAAAAAAACAAAAAAAAAAQAAAAAAAAABgAAAAAAAAAIAAAAAAAAAAoAAAAAAAAADAAAAAAAAAAOAAAAAAAAABAAAAAAAAAAEgAAAAAAAAAUAAAAAAAAABYAAAAAAAAAGAAAAAAAAAAaAAAAAAAAABwAAAAAAAAAHgAAAAAAAAAgAAAAAAAAACIAAAAAAAAAJAAAAAAAAAAmAAAAAAAAACgAAAAAAAAAKgAAAAAAAAAsAAAAAAAAAC4AAAAAAAAAMAAAAAAAAAAyAAAAAAAAADQAAAAAAAAANgAAAAAAAAA4AAAAAAAAADoAAAAAAAAAPAAAAAAAAAA+AAAAAAAAAEAAAAAAAAAAQgAAAAAAAABEAAAAAAAAAEYAAAAAAAAASAAAAAAAAABKAAAAAAAAAEwAAAAAAAAATgAAAAAAAABQAAAAAAAAAFIAAAAAAAAAVAAAAAAAAABWAAAAAAAAAFgAAAAAAAAAWgAAAAAAAABcAAAAAAAAAF4AAAAAAAAAYAAAAAAAAABiAAAAAAAAAGQAAAAAAAAAZgAAAAAAAABoAAAAAAAAAGoAAAAAAAAAbAAAAAAAAABuAAAAAAAAAHAAAAAAAAAAcgAAAAAAAAB0AAAAAAAAAHYAAAAAAAAAeAAAAAAAAAB6AAAAAAAAAHwAAAAAAAAAfgAAAAAAAACAAAAAAAAAAIIAAAAAAAAAhAAAAAAAAACGAAAAAAAAAIgAAAAAAAAAigAAAAAAAACMAAAAAAAAAI4AAAAAAAAAkAAAAAAAAACSAAAAAAAAAJQAAAAAAAAAlgAAAAAAAACYAAAAAAAAAJoAAAAAAAAAnAAAAAAAAACeAAAAAAAAAKAAAAAAAAAAogAAAAAAAACkAAAAAAAAAKYAAAAAAAAAqAAAAAAAAACqAAAAAAAAAKwAAAAAAAAArgAAAAAAAACwAAAAAAAAALIAAAAAAAAAtAAAAAAAAAC2AAAAAAAAALgAAAAAAAAAugAAAAAAAAC8AAAAAAAAAL4AAAAAAAAAwAAAAAAAAADCAAAAAAAAAMQAAAAAAAAAxgAAAAAAAADIAAAAAAAAAA== + + + ZAAAAAAAAAADAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMD + + + + + diff --git a/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_inlet.vtu b/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_inlet.vtu new file mode 100644 index 00000000000..8c015078872 --- /dev/null +++ b/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_inlet.vtu @@ -0,0 +1,24 @@ + + + + + + + + + + + + + + + + + + + + + + _CAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==CAAAAAAAAAAAAAAACAAAAAEAAAAAAAAAAQAAAAE= + + diff --git a/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_outlet.vtu b/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_outlet.vtu new file mode 100644 index 00000000000..a4a2e97b57b --- /dev/null +++ b/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_outlet.vtu @@ -0,0 +1,24 @@ + + + + + + + + + + + + + + + + + + + + + + _CAAAAAEAAAAAAAAACAAAAGMAAAAAAAAAGAAAAAAAAAAAAPA/AAAAAAAAAAAAAAAAAAAAAA==CAAAAAAAAAAAAAAACAAAAAEAAAAAAAAAAQAAAAE= + + diff --git a/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_0_t_0.000000.vtu b/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_0_t_0.000000.vtu new file mode 100644 index 00000000000..d0e4ea13bac --- /dev/null +++ b/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_0_t_0.000000.vtu @@ -0,0 +1,27 @@ + + + + + + + + + + + + + + + + + + + + + + + + + _AQAAAAAAAAAAgAAAAAAAABQAAAAAAAAAHAAAAAAAAAA=eF4z0zPRM9E1NLMw0E23NLBIMjNINgYALH8Eig==AQAAAAAAAAAAgAAAAAAAACgDAAAAAAAAFQAAAAAAAAA=eF5jYKAl+GA/NOhRMArwAwCP7hjcAQAAAAAAAAAAgAAAAAAAACgDAAAAAAAAFgAAAAAAAAA=eF5jYACCrB8ODKP0KD1K46QBGluk6w==AQAAAAAAAAAAgAAAAAAAAHgJAAAAAAAAmwIAAAAAAAA=eF591FtI02Ech3FJKmchJutAgRdGsA4UVHS4sAPloQRrIBkoVBdGQaRBdLEirBxSIUssJcKIFh0gpROp0UGdacpMy+nUbLWVNtMyCosuzN6vlz3Qe/lB9v7f3/u8RkT8b31b/6+0D1akBB0F8LEJPw8/FCgYsldfhu8K6++vwX/uvmjWLfiMXv1OJbxoUXW8c+guvHni9x/Ao2648xKjq+CpOdq3Bl4431U/ansMzw/qe57Cw+mJ0X53LXz1En1nHedgWWGWB+4a0Pc3wB95bNmu+ufwgSs6VxM87rjZ1v4Cnpil8zbD96+xVqYEW+AXZmoOXnjtd4vfndcKH2nTfF7CZ1eMm9UGT0jS3NrhVfcd5oNewbclaJ70/nOjZkCv4UfHl5s5d8BjD5qx+enX+zR/H3xdmjlWfCfcV6N7oe+z7TWrC/6nVPflh5dMDpoD0xcf1j12w+tCWeZi6Jl23W8PfPhZl9m4F35yqe6dPrfcHNf5Bn5nmnrogyc7vGbRe8Pq5C08N9OM2RqAT21UP/TylWbb7HfwX251Re85o7m9h8/ZrN7oO8c0T3rZQ3UYhHflas70WQvVJ31HSPMPwUsvqVt6Z4a2pVtj9H/jAzyjSfdFL8lXbvSOtbrHj/C4H+qfbr+t+6UX5+hd9MPb482Y8+ix3Xov9O3F6mEA7tqqd0RvizTXW02PeaL39QmefkT90IuW6d3RvWF1RZ9+VV2F4WlZ6op+1mqOO0pvaVVXg3BLobqib9mgruinf6urz/Dme+qKHnVAXdFTF6irIXhhQF3RG8vUFX2KXV0Nw5OizbYOutOjrugNx9TVF3jkKnVF3zSiruinbqqrr3DPHnVFnzRPXdE3+tTVCPxEkbqi1yarK/pf1SGdig==AQAAAAAAAAAAgAAAAAAAAEAGAAAAAAAAvgAAAAAAAAA=eF5dxcciAgAAANAohOyZUhq2bLJ3yB4hiaz//waHnN67vECgrpGDHOImbuYWDnMrt3E7R7iDO7mLu7mHe7mP+3mAB3mIhznKIxzjOI9ygpM8xilOc4azPM4TPMlTPM0zPMtznON5XuBFXuJlXuFVXuN1zvMGb/IWb/MO7/Ie7/MBH/IRH/MJF/iUz/ici3zBl3zF13zDt3zH9/zAj1ziJ37mFy7zK1f4jav8zh9c40/+4m/+4V9u+P8PcvwndA==AQAAAAAAAAAAgAAAAAAAACADAAAAAAAAxwAAAAAAAAA=eF4txdFGAwAAAMAkmUwymUySSZIkmWQySZJJkiQzmSTJJEmSTJKZZJJJkkmSmSRJkkkm6bN62N3LNTc1tLjVAbc56HZ3OOROh93liLvd415H3ed+D3jQQx72iEcd85jHHfeEE570lKc941knPed5L3jRS172ilNOe9UZr3ndG970lrPe9o53ved9H/jQR8752Cc+dd4Fn/ncRV/40iVf+do3vnXZd773gx9dcdVPfvaLX/3md3/40zV/+dt1//jXf/4H8McndQ==AQAAAAAAAAAAgAAAAAAAAGQAAAAAAAAADAAAAAAAAAA=eF5jZqY9AAA7kgEt + + diff --git a/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_100_t_0.100000.vtu b/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_100_t_0.100000.vtu new file mode 100644 index 00000000000..ba44a205d69 --- /dev/null +++ b/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_100_t_0.100000.vtu @@ -0,0 +1,27 @@ + + + + + + + + + + + + + + + + + + + + + + + + + _AQAAAAAAAAAAgAAAAAAAABQAAAAAAAAAHAAAAAAAAAA=eF4z0zPRM9E1NLMw0E23NLBIMjNINgYALH8Eig==AQAAAAAAAAAAgAAAAAAAACgDAAAAAAAAMwMAAAAAAAA=eF4BKAPX/AAAAAAAAAAApunVHISdODQAAAAAAAAAAE2k/Ya9y2E9YFMrCojiKT0BhxrLxKnePcCBbSJS6bQ9ZxLYiNxrNT7Q4+yRZ19sPuB9inoWToc+aFsJ4G58sj6kxTZOz6zLPmqPvzUfPfE+WWLntvdPET8v3uuNnU4mP8t0Ttpx81E/8dWzRO1iUD88+YkwEiCPPzo7vzuJDJE/lszS5TU7tD9X3kXVdFnWP837yxkajeU/C9Knf1R17D+bZLjZPEjvP+4zNW956+8/Th3pZ9L97z+3RLF3xP/vPxC/lE35/+8/IMgK6f7/7z8MNyGR///vPywVA3X//+8/SkXIrv3/7z9mK9EY+f/vPxso44Hd/+8/aQ1ThnX/7z+wTcsRm/7vP4P/v0cG9+8/jrlHhM737z8YXv22f4PvPyN2ltObd+8/UuVlxZh47T80LjFVRtPkP2Svr9LK5dQ/WqR8C1pVvD/+9XzWmfiWP3HyM7ZKh2Q/2JAYWDhqMT/MJcnDkY39Ph9NSvVhFMk+y1UzRjhJlT6yQjpFYxFiPgyS1gG4rC4+zlKyNDYK+j1TrF1OFBvGPTK6ph0ZxJI9nvfTi2/cXz1kqr6V0QsrPT/M1gM89fY8wo/pzpl8wzyUEgU/F4qQPKciCDj2Elw8I8LP6jPTJzxJKqGQvjf0O/0x/QLSJ8E7t0epv8kcjTu9Y1niMLNYOw4JrQp99CQ7pU96nuPG8TrtgtLK9yi+OlywalVTlYk61+r4tjyzVTr+jWpu2mciOvcfcr6+OO85mibfHN56ujlSZsl0MnWGOcRTkZfSC1M5kLccTQ0nIDkHOTNQjWXrOFE0mIPbO7c4wYZqbg60gziDETSakrVQOOhrUlwcVxw41kexiqEI6DcNZKr0sWG0N4dVSc/YSIE3mZWLYf1QTTfPGNs4p9wYN+BZxW6fFeU2xPkye47hsTZbG+xDO1R+NsRAn662uEk2Qyarc27QFTY/1asjJIDiNSDpdTh7Ya81LqsGYkedejVh/MQxb5JGNTdCWjGfJBM17pHCnPk64DSLF0NDrXyrNEuYG0BIenc09qyu+QbPSTTtbYKGAQAAAAAAAAAAgAAAAAAAACgDAAAAAAAAVgIAAAAAAAA=eF4V011ozXEYB/Df//3YG3thaLZahCnhwrRmnm8ktCJ1Rlkr2oWd8nKx1hqtf1prucDFSKZkCuUlMRfbUv8omYi8lKUYtXahrUax8+77nJtPz/me8/s/z/k9p8I2xiRiMPpKLEicdbQvhkEabojhE5WiGKod5rMBEjR6G2CEhg8DzFO5GKDWZX46QJxGBwIM0HBzgDEqZfyc5n98NHrMP/oYouGIjwyVyz5afeZdPsZp1OJjZcC83kcPleU+JqlJetgWYz7p4SoNxzz8pTLkoWUR87MeRmjU6qG0gPl2DyeoVHt4TU3exdpC5t9d9NEwcjFF5aaLhiLm51wM0uiYizka7nSxp5j5ahfD1HguMjSadnCohPlLB4+p3HFQspj5gIMOGh138JyGex1ULWFe56CLmkIH72n0y0ZdKfM3NvqpPLDxk5oLNnaUMT9po5uG+200Udlk45vmpTZ6aTRvoUa//8FCpOc/sXBUzx+0YOv5nRZu6fPjFnZR2Wphmn2aSgv9NPpnsE77/2LwSucbNejQ+a4ZFOh8PQb3dP4jBs1UGg1m+TuZVQZVlXw/nZe2Zayf5eXGUta9eZmqYC15qaWhlZf2ctYvcnJb5+jLyYz2vzsn67XvICcJ7XciK/e1z/NZmdP+mrOyUfsqzsop7eddRh5pH5cy8luffzAjW/TeyjPSqff5OS1Ped/hlbToHpjDaanXvViRlm7dl68pGeU+hddTkuKembaUNOje1aTkjO7jj6SM6x4PJyWr/4P2pDTp3q9JSq/FemZBIhLeXZD/7y/E5w==AQAAAAAAAAAAgAAAAAAAAHgJAAAAAAAAmwIAAAAAAAA=eF591FtI02Ech3FJKmchJutAgRdGsA4UVHS4sAPloQRrIBkoVBdGQaRBdLEirBxSIUssJcKIFh0gpROp0UGdacpMy+nUbLWVNtMyCosuzN6vlz3Qe/lB9v7f3/u8RkT8b31b/6+0D1akBB0F8LEJPw8/FCgYsldfhu8K6++vwX/uvmjWLfiMXv1OJbxoUXW8c+guvHni9x/Ao2648xKjq+CpOdq3Bl4431U/ansMzw/qe57Cw+mJ0X53LXz1En1nHedgWWGWB+4a0Pc3wB95bNmu+ufwgSs6VxM87rjZ1v4Cnpil8zbD96+xVqYEW+AXZmoOXnjtd4vfndcKH2nTfF7CZ1eMm9UGT0jS3NrhVfcd5oNewbclaJ70/nOjZkCv4UfHl5s5d8BjD5qx+enX+zR/H3xdmjlWfCfcV6N7oe+z7TWrC/6nVPflh5dMDpoD0xcf1j12w+tCWeZi6Jl23W8PfPhZl9m4F35yqe6dPrfcHNf5Bn5nmnrogyc7vGbRe8Pq5C08N9OM2RqAT21UP/TylWbb7HfwX251Re85o7m9h8/ZrN7oO8c0T3rZQ3UYhHflas70WQvVJ31HSPMPwUsvqVt6Z4a2pVtj9H/jAzyjSfdFL8lXbvSOtbrHj/C4H+qfbr+t+6UX5+hd9MPb482Y8+ix3Xov9O3F6mEA7tqqd0RvizTXW02PeaL39QmefkT90IuW6d3RvWF1RZ9+VV2F4WlZ6op+1mqOO0pvaVVXg3BLobqib9mgruinf6urz/Dme+qKHnVAXdFTF6irIXhhQF3RG8vUFX2KXV0Nw5OizbYOutOjrugNx9TVF3jkKnVF3zSiruinbqqrr3DPHnVFnzRPXdE3+tTVCPxEkbqi1yarK/pf1SGdig==AQAAAAAAAAAAgAAAAAAAAEAGAAAAAAAAvgAAAAAAAAA=eF5dxcciAgAAANAohOyZUhq2bLJ3yB4hiaz//waHnN67vECgrpGDHOImbuYWDnMrt3E7R7iDO7mLu7mHe7mP+3mAB3mIhznKIxzjOI9ygpM8xilOc4azPM4TPMlTPM0zPMtznON5XuBFXuJlXuFVXuN1zvMGb/IWb/MO7/Ie7/MBH/IRH/MJF/iUz/ici3zBl3zF13zDt3zH9/zAj1ziJ37mFy7zK1f4jav8zh9c40/+4m/+4V9u+P8PcvwndA==AQAAAAAAAAAAgAAAAAAAACADAAAAAAAAxwAAAAAAAAA=eF4txdFGAwAAAMAkmUwymUySSZIkmWQySZJJkiQzmSTJJEmSTJKZZJJJkkmSmSRJkkkm6bN62N3LNTc1tLjVAbc56HZ3OOROh93liLvd415H3ed+D3jQQx72iEcd85jHHfeEE570lKc941knPed5L3jRS172ilNOe9UZr3ndG970lrPe9o53ved9H/jQR8752Cc+dd4Fn/ncRV/40iVf+do3vnXZd773gx9dcdVPfvaLX/3md3/40zV/+dt1//jXf/4H8McndQ==AQAAAAAAAAAAgAAAAAAAAGQAAAAAAAAADAAAAAAAAAA=eF5jZqY9AAA7kgEt + + diff --git a/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_150_t_0.150000.vtu b/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_150_t_0.150000.vtu new file mode 100644 index 00000000000..107cdee4080 --- /dev/null +++ b/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_150_t_0.150000.vtu @@ -0,0 +1,27 @@ + + + + + + + + + + + + + + + + + + + + + + + + + _AQAAAAAAAAAAgAAAAAAAABQAAAAAAAAAHAAAAAAAAAA=eF4z0zPRM9E1NLMw0E23NLBIMjNINgYALH8Eig==AQAAAAAAAAAAgAAAAAAAACgDAAAAAAAAMwMAAAAAAAA=eF4BKAPX/AAAAAAAAAAA+fvt1AyLVTWtymnN5SrqPPbRbQTeh+w8eT2yPt9qQT0azwa6avJCPa0fP809pbA9PYdQ8RdJsj32ARABqWUBPshKDq/cAgM+jR5Dz4lFRz6jufQeK1FJPvD+aPK9GIU+SSvM+hQ6lD4rLh+k/9O5PntL6AymMdU+hUbeHjn25j6E+fGVMoUUP2S5mzs4ehQ/KjQcWqUlTj/uYzjJ7FJQP/YTJrlUJHs/+AGp2d0akj8e4IOtIYWVPxNOZVzKNsA/VAK/g8+61z/FqRlzVM/kP5jzMEEdXus/PGR9A5an7j8Afezx0sLvP9k1e7hx+e8/IKzmAEz/7z9uKbMX6//vPxuyw4X7/+8/rprs0vz/7z866ywO/P/vP88W1970/+8/SE4tYun/7z8mTkNIXP/vP+zrEsdc/+8/pUgW4HX47z9909xr1vfvPxXHeP+3ye8/T9tF7idv7z8LtLL311PvPz7Xm+9L8us/0/9XfZoi5D/HEqEVVGHWP3QixtSKh8I/TF7xbLOGpT9vKdWKaJp+P/hTPDgDOUo/IeS/CuNJFj8OQw45VvHiPp+9OCXjGLA+rnIl6ttaez4T36FBaz1HPgWH9ivLvRM+lDTV+3DE4D2hDbxhpXqsPW0Klm7CLng9o5+5wy2IRD3Ezv/nLW4RPcROIWRul908Y1uGTsAdqTxIr8Qs1VB1POSRN5+8FkI8esjzXMuyDjzF2ndiFwzaOyHiy9VxGaY71eXPWre/cjsSxUkOrc8/O4dN+URp/Ao7mAAwulLk1jqe+b44HGujOqcP7/i7eHA6CsMAR5DxOzo0txlF17MHOiY83VbfGtQ59JO+5a0NoTmkvxm8H+5sOVcSA7QPijg54KcJTKTQBDng/KG+9qfROIcv7KAb9J04eeARV4toaTjX3Q9NnY01OOAmehR/SAI4Yl2upOEEzzfbPLwxTlCaNxR36V6JUmY3WqywXNHvMjelE2u6mxAANyJ8WuHiQcs2SMSaUMcflzbejPU5KJ5jNjZIKyWHpDA2IOo8ysE6/DXr/nboY+nHNWknZRBLb5Q1cML6RKqEZjVFSocqAQAAAAAAAAAAgAAAAAAAACgDAAAAAAAAVgIAAAAAAAA=eF4V011ozXEYB/Df//3YG3thaLZahCnhwrRmnm8ktCJ1Rlkr2oWd8nKx1hqtf1prucDFSKZkCuUlMRfbUv8omYi8lKUYtXahrUax8+77nJtPz/me8/s/z/k9p8I2xiRiMPpKLEicdbQvhkEabojhE5WiGKod5rMBEjR6G2CEhg8DzFO5GKDWZX46QJxGBwIM0HBzgDEqZfyc5n98NHrMP/oYouGIjwyVyz5afeZdPsZp1OJjZcC83kcPleU+JqlJetgWYz7p4SoNxzz8pTLkoWUR87MeRmjU6qG0gPl2DyeoVHt4TU3exdpC5t9d9NEwcjFF5aaLhiLm51wM0uiYizka7nSxp5j5ahfD1HguMjSadnCohPlLB4+p3HFQspj5gIMOGh138JyGex1ULWFe56CLmkIH72n0y0ZdKfM3NvqpPLDxk5oLNnaUMT9po5uG+200Udlk45vmpTZ6aTRvoUa//8FCpOc/sXBUzx+0YOv5nRZu6fPjFnZR2Wphmn2aSgv9NPpnsE77/2LwSucbNejQ+a4ZFOh8PQb3dP4jBs1UGg1m+TuZVQZVlXw/nZe2Zayf5eXGUta9eZmqYC15qaWhlZf2ctYvcnJb5+jLyYz2vzsn67XvICcJ7XciK/e1z/NZmdP+mrOyUfsqzsop7eddRh5pH5cy8luffzAjW/TeyjPSqff5OS1Ped/hlbToHpjDaanXvViRlm7dl68pGeU+hddTkuKembaUNOje1aTkjO7jj6SM6x4PJyWr/4P2pDTp3q9JSq/FemZBIhLeXZD/7y/E5w==AQAAAAAAAAAAgAAAAAAAAHgJAAAAAAAAmwIAAAAAAAA=eF591FtI02Ech3FJKmchJutAgRdGsA4UVHS4sAPloQRrIBkoVBdGQaRBdLEirBxSIUssJcKIFh0gpROp0UGdacpMy+nUbLWVNtMyCosuzN6vlz3Qe/lB9v7f3/u8RkT8b31b/6+0D1akBB0F8LEJPw8/FCgYsldfhu8K6++vwX/uvmjWLfiMXv1OJbxoUXW8c+guvHni9x/Ao2648xKjq+CpOdq3Bl4431U/ansMzw/qe57Cw+mJ0X53LXz1En1nHedgWWGWB+4a0Pc3wB95bNmu+ufwgSs6VxM87rjZ1v4Cnpil8zbD96+xVqYEW+AXZmoOXnjtd4vfndcKH2nTfF7CZ1eMm9UGT0jS3NrhVfcd5oNewbclaJ70/nOjZkCv4UfHl5s5d8BjD5qx+enX+zR/H3xdmjlWfCfcV6N7oe+z7TWrC/6nVPflh5dMDpoD0xcf1j12w+tCWeZi6Jl23W8PfPhZl9m4F35yqe6dPrfcHNf5Bn5nmnrogyc7vGbRe8Pq5C08N9OM2RqAT21UP/TylWbb7HfwX251Re85o7m9h8/ZrN7oO8c0T3rZQ3UYhHflas70WQvVJ31HSPMPwUsvqVt6Z4a2pVtj9H/jAzyjSfdFL8lXbvSOtbrHj/C4H+qfbr+t+6UX5+hd9MPb482Y8+ix3Xov9O3F6mEA7tqqd0RvizTXW02PeaL39QmefkT90IuW6d3RvWF1RZ9+VV2F4WlZ6op+1mqOO0pvaVVXg3BLobqib9mgruinf6urz/Dme+qKHnVAXdFTF6irIXhhQF3RG8vUFX2KXV0Nw5OizbYOutOjrugNx9TVF3jkKnVF3zSiruinbqqrr3DPHnVFnzRPXdE3+tTVCPxEkbqi1yarK/pf1SGdig==AQAAAAAAAAAAgAAAAAAAAEAGAAAAAAAAvgAAAAAAAAA=eF5dxcciAgAAANAohOyZUhq2bLJ3yB4hiaz//waHnN67vECgrpGDHOImbuYWDnMrt3E7R7iDO7mLu7mHe7mP+3mAB3mIhznKIxzjOI9ygpM8xilOc4azPM4TPMlTPM0zPMtznON5XuBFXuJlXuFVXuN1zvMGb/IWb/MO7/Ie7/MBH/IRH/MJF/iUz/ici3zBl3zF13zDt3zH9/zAj1ziJ37mFy7zK1f4jav8zh9c40/+4m/+4V9u+P8PcvwndA==AQAAAAAAAAAAgAAAAAAAACADAAAAAAAAxwAAAAAAAAA=eF4txdFGAwAAAMAkmUwymUySSZIkmWQySZJJkiQzmSTJJEmSTJKZZJJJkkmSmSRJkkkm6bN62N3LNTc1tLjVAbc56HZ3OOROh93liLvd415H3ed+D3jQQx72iEcd85jHHfeEE570lKc941knPed5L3jRS172ilNOe9UZr3ndG970lrPe9o53ved9H/jQR8752Cc+dd4Fn/ncRV/40iVf+do3vnXZd773gx9dcdVPfvaLX/3md3/40zV/+dt1//jXf/4H8McndQ==AQAAAAAAAAAAgAAAAAAAAGQAAAAAAAAADAAAAAAAAAA=eF5jZqY9AAA7kgEt + + diff --git a/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_200_t_0.200000.vtu b/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_200_t_0.200000.vtu new file mode 100644 index 00000000000..40512c13efa --- /dev/null +++ b/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_200_t_0.200000.vtu @@ -0,0 +1,27 @@ + + + + + + + + + + + + + + + + + + + + + + + + + _AQAAAAAAAAAAgAAAAAAAABQAAAAAAAAAHAAAAAAAAAA=eF4z0zPRM9E1NLMw0E23NLBIMjNINgYALH8Eig==AQAAAAAAAAAAgAAAAAAAACgDAAAAAAAAMwMAAAAAAAA=eF4BKAPX/AAAAAAAAAAAtIT/vU69cTa+CByZ6V9TPA6N4W4dF1E8Y1YdSrJS4TxvSByH7JjgPIHnaVk5PUg9jw3uhbbXST0glvlhXHiTPfeTjfwnRZU9FJyfrXFH1T2oK5gmwRjXPdKewhFXAxQ+epktye6aFz6mBHH0YixNPsYOAo04JFs+Z4qCMaWVgD5JOklgl1ycPmzLoLQ736c+q4tlDECi1z6nzkqZbv7VPjwsBWZjIBA//5REq/LYED+a34ZDsSdBPyzI/gFqNFM/et597VubXz/zYtr6T8+IP2lzBCxtlos/wqjTvp1DpD/lSDzwdKnEP44cyDdaotg/lV+mGDhP5D/u1pfzrIbqP8t65/IHDe4/pcE+WViC7z8Iu+gN/ezvPx41c7Dx/e8/PFOSdL3/7z+6GVF17f/vP2i3edLx/+8/EfIPsPD/7z/cGXzM8P/vP6OMLKuD/+8/7G2GQHv/7z/tyLd1tvvvP9zWK79k9u8/os2JujLw7z8qGMOdwZzvP5nqkOCoke8/9WmVH8S77j+nHDIyo9XqPzGritnRruM/l3YTRZJh1z9pek0VTOXFP/jmj0VbL68/Qn6uBZZtjz+IuMDdOSFjP7qo/2DzPTA/IqtY8HOT+z6JiqwS/GfHPpT8nWlE3ZM+MlgivT/bYD4GEi2u45osPop6wUDTRPg9J6elR52WxD2WtNte/naRPQjQhcbyoF09lRelG5EhKT0PMM7axlD1PD+153ktFMI8+qYUB66qjjzj3hHvbAJaPKQhUgo9DyY8Pw8Yv6a18jtTZaiPs7y/O7lD670a64o7/H54avDUVjuxUn5ouV0jO8RoCCBNbfA6omVOZVzeuzqEk+2F+KOHOo+6xEb2DVQ6h/JXeFgDITqDAprB3d3sOd2zCMCEfbg5o/Pb8i7HhDmIEEnKB6FROb56BihR6h05+YJOv/5h6ThJZChZmom1OOTxcrNvRoI4v3PpXrMDTzgyxN1FSFEaOICveYILVeY3XPyxqVzzsjfXE88YyhSAN7rEltWuSks3VkEMkOomFzc2+FRhnJ3jNtM6rWAAxbA2k+pCztWBgjYrPI+MAQAAAAAAAAAAgAAAAAAAACgDAAAAAAAAVgIAAAAAAAA=eF4V011ozXEYB/Df//3YG3thaLZahCnhwrRmnm8ktCJ1Rlkr2oWd8nKx1hqtf1prucDFSKZkCuUlMRfbUv8omYi8lKUYtXahrUax8+77nJtPz/me8/s/z/k9p8I2xiRiMPpKLEicdbQvhkEabojhE5WiGKod5rMBEjR6G2CEhg8DzFO5GKDWZX46QJxGBwIM0HBzgDEqZfyc5n98NHrMP/oYouGIjwyVyz5afeZdPsZp1OJjZcC83kcPleU+JqlJetgWYz7p4SoNxzz8pTLkoWUR87MeRmjU6qG0gPl2DyeoVHt4TU3exdpC5t9d9NEwcjFF5aaLhiLm51wM0uiYizka7nSxp5j5ahfD1HguMjSadnCohPlLB4+p3HFQspj5gIMOGh138JyGex1ULWFe56CLmkIH72n0y0ZdKfM3NvqpPLDxk5oLNnaUMT9po5uG+200Udlk45vmpTZ6aTRvoUa//8FCpOc/sXBUzx+0YOv5nRZu6fPjFnZR2Wphmn2aSgv9NPpnsE77/2LwSucbNejQ+a4ZFOh8PQb3dP4jBs1UGg1m+TuZVQZVlXw/nZe2Zayf5eXGUta9eZmqYC15qaWhlZf2ctYvcnJb5+jLyYz2vzsn67XvICcJ7XciK/e1z/NZmdP+mrOyUfsqzsop7eddRh5pH5cy8luffzAjW/TeyjPSqff5OS1Ped/hlbToHpjDaanXvViRlm7dl68pGeU+hddTkuKembaUNOje1aTkjO7jj6SM6x4PJyWr/4P2pDTp3q9JSq/FemZBIhLeXZD/7y/E5w==AQAAAAAAAAAAgAAAAAAAAHgJAAAAAAAAmwIAAAAAAAA=eF591FtI02Ech3FJKmchJutAgRdGsA4UVHS4sAPloQRrIBkoVBdGQaRBdLEirBxSIUssJcKIFh0gpROp0UGdacpMy+nUbLWVNtMyCosuzN6vlz3Qe/lB9v7f3/u8RkT8b31b/6+0D1akBB0F8LEJPw8/FCgYsldfhu8K6++vwX/uvmjWLfiMXv1OJbxoUXW8c+guvHni9x/Ao2648xKjq+CpOdq3Bl4431U/ansMzw/qe57Cw+mJ0X53LXz1En1nHedgWWGWB+4a0Pc3wB95bNmu+ufwgSs6VxM87rjZ1v4Cnpil8zbD96+xVqYEW+AXZmoOXnjtd4vfndcKH2nTfF7CZ1eMm9UGT0jS3NrhVfcd5oNewbclaJ70/nOjZkCv4UfHl5s5d8BjD5qx+enX+zR/H3xdmjlWfCfcV6N7oe+z7TWrC/6nVPflh5dMDpoD0xcf1j12w+tCWeZi6Jl23W8PfPhZl9m4F35yqe6dPrfcHNf5Bn5nmnrogyc7vGbRe8Pq5C08N9OM2RqAT21UP/TylWbb7HfwX251Re85o7m9h8/ZrN7oO8c0T3rZQ3UYhHflas70WQvVJ31HSPMPwUsvqVt6Z4a2pVtj9H/jAzyjSfdFL8lXbvSOtbrHj/C4H+qfbr+t+6UX5+hd9MPb482Y8+ix3Xov9O3F6mEA7tqqd0RvizTXW02PeaL39QmefkT90IuW6d3RvWF1RZ9+VV2F4WlZ6op+1mqOO0pvaVVXg3BLobqib9mgruinf6urz/Dme+qKHnVAXdFTF6irIXhhQF3RG8vUFX2KXV0Nw5OizbYOutOjrugNx9TVF3jkKnVF3zSiruinbqqrr3DPHnVFnzRPXdE3+tTVCPxEkbqi1yarK/pf1SGdig==AQAAAAAAAAAAgAAAAAAAAEAGAAAAAAAAvgAAAAAAAAA=eF5dxcciAgAAANAohOyZUhq2bLJ3yB4hiaz//waHnN67vECgrpGDHOImbuYWDnMrt3E7R7iDO7mLu7mHe7mP+3mAB3mIhznKIxzjOI9ygpM8xilOc4azPM4TPMlTPM0zPMtznON5XuBFXuJlXuFVXuN1zvMGb/IWb/MO7/Ie7/MBH/IRH/MJF/iUz/ici3zBl3zF13zDt3zH9/zAj1ziJ37mFy7zK1f4jav8zh9c40/+4m/+4V9u+P8PcvwndA==AQAAAAAAAAAAgAAAAAAAACADAAAAAAAAxwAAAAAAAAA=eF4txdFGAwAAAMAkmUwymUySSZIkmWQySZJJkiQzmSTJJEmSTJKZZJJJkkmSmSRJkkkm6bN62N3LNTc1tLjVAbc56HZ3OOROh93liLvd415H3ed+D3jQQx72iEcd85jHHfeEE570lKc941knPed5L3jRS172ilNOe9UZr3ndG970lrPe9o53ved9H/jQR8752Cc+dd4Fn/ncRV/40iVf+do3vnXZd773gx9dcdVPfvaLX/3md3/40zV/+dt1//jXf/4H8McndQ==AQAAAAAAAAAAgAAAAAAAAGQAAAAAAAAADAAAAAAAAAA=eF5jZqY9AAA7kgEt + + diff --git a/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_250_t_0.250000.vtu b/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_250_t_0.250000.vtu new file mode 100644 index 00000000000..93c66191026 --- /dev/null +++ b/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_250_t_0.250000.vtu @@ -0,0 +1,27 @@ + + + + + + + + + + + + + + + + + + + + + + + + + _AQAAAAAAAAAAgAAAAAAAABQAAAAAAAAAHAAAAAAAAAA=eF4z0zPRM9E1NLMw0E23NLBIMjNINgYALH8Eig==AQAAAAAAAAAAgAAAAAAAACgDAAAAAAAAMwMAAAAAAAA=eF4BKAPX/AAAAAAAAAAAC3xB4/oljDdI/OWO4GDnOyF16tB5p9k781pW1Iw0iDxAcaA7kYZ8PCm6g6rvdeI8ccLAoywz5DyveN9kH9gmPSCymIeh/ig9fA36c6+7ZD0dWfXoSpxmPfwCxD40daM9qjf4ru8WpT0gjnXOJBHfPfoSA9Wh2OA99QkBY4K4Fj4PrTUxUacYPgU4UOaGGFA+d316/+RWUj4uYl2hA8WAPtB+iQRDk5U+0vcG6k1GqD59Av/3md3RPh/IWG57dNI+Yic2EVeYBz/fbrwcf6gMPzHMXKUKVi8/nIIoj8FgTz+sGQ84JH5QP5k9fuAXB3U/cXX1+93jhj/JX87Vw+qQP9USjaE/ua4/e+iw5qIFyD/DFOkuSEjZP1f7bkO18OM/E72lel/Z6T8JIXPzqX7tP/MILEwqOO8/p1fWsp3U7z/IaOwkcfrvP8KcP05O/+8/5uDb1tH/7z96DxWL3//vP2/8Asrg/+8/4ErJgaX/7z+ws/uZmP/vPwHHiE0G/u8/jgdjBi347z/ASt0fvvfvPynuyWLw1e8/1T9ES3Kk7z8jxRoyqXjvPwYBt6ZqFO4/DKOEzpr+6T/IWNwA1VvjPx6r3CWkHtg/BOpI8nuayD/bEBVDgAq0P479Puds/Zg/9OVbcCrHdT8l0YlROpNGP2pooKRHIxM/ksQ8T1c54D45z4S7GIKrPr5pv0c6Unc+iQ+cSrvFQz7uUpuWtsMQPo+QN5Edbtw94AY5IrkbqD3FVxo35XF0Pfq5Yt3nVkE9V4ITUehpDT0LrGHiIvPYPNfoeB0zKqU8/GTDTZX0cTxPFh6upnc+PHtFzirM2Qk8ES9Ewl3v1TuHJBksC52iO92dMhRgl2871nPbsmDPOjt/puXm28AGO3HM9pemT9M6BlSYW+BjoDoxDrPOltJrOv8D+p18nTc6o6blL1cLBDoj0ACNdwPROe/iCjPc4Zw5+SZNzvCDaDl9/7PQCs80OVXNICSZqQE5MTUFr9P7zThjZETMInOZOLAZ2AazmWU4Edp7zOJTMjh61zLS8w//N9s5XBW/j8o3hzx+2EtWnTdf7oZQAQAAAAAAAAAAgAAAAAAAACgDAAAAAAAAVgIAAAAAAAA=eF4V011ozXEYB/Df//3YG3thaLZahCnhwrRmnm8ktCJ1Rlkr2oWd8nKx1hqtf1prucDFSKZkCuUlMRfbUv8omYi8lKUYtXahrUax8+77nJtPz/me8/s/z/k9p8I2xiRiMPpKLEicdbQvhkEabojhE5WiGKod5rMBEjR6G2CEhg8DzFO5GKDWZX46QJxGBwIM0HBzgDEqZfyc5n98NHrMP/oYouGIjwyVyz5afeZdPsZp1OJjZcC83kcPleU+JqlJetgWYz7p4SoNxzz8pTLkoWUR87MeRmjU6qG0gPl2DyeoVHt4TU3exdpC5t9d9NEwcjFF5aaLhiLm51wM0uiYizka7nSxp5j5ahfD1HguMjSadnCohPlLB4+p3HFQspj5gIMOGh138JyGex1ULWFe56CLmkIH72n0y0ZdKfM3NvqpPLDxk5oLNnaUMT9po5uG+200Udlk45vmpTZ6aTRvoUa//8FCpOc/sXBUzx+0YOv5nRZu6fPjFnZR2Wphmn2aSgv9NPpnsE77/2LwSucbNejQ+a4ZFOh8PQb3dP4jBs1UGg1m+TuZVQZVlXw/nZe2Zayf5eXGUta9eZmqYC15qaWhlZf2ctYvcnJb5+jLyYz2vzsn67XvICcJ7XciK/e1z/NZmdP+mrOyUfsqzsop7eddRh5pH5cy8luffzAjW/TeyjPSqff5OS1Ped/hlbToHpjDaanXvViRlm7dl68pGeU+hddTkuKembaUNOje1aTkjO7jj6SM6x4PJyWr/4P2pDTp3q9JSq/FemZBIhLeXZD/7y/E5w==AQAAAAAAAAAAgAAAAAAAAHgJAAAAAAAAmwIAAAAAAAA=eF591FtI02Ech3FJKmchJutAgRdGsA4UVHS4sAPloQRrIBkoVBdGQaRBdLEirBxSIUssJcKIFh0gpROp0UGdacpMy+nUbLWVNtMyCosuzN6vlz3Qe/lB9v7f3/u8RkT8b31b/6+0D1akBB0F8LEJPw8/FCgYsldfhu8K6++vwX/uvmjWLfiMXv1OJbxoUXW8c+guvHni9x/Ao2648xKjq+CpOdq3Bl4431U/ansMzw/qe57Cw+mJ0X53LXz1En1nHedgWWGWB+4a0Pc3wB95bNmu+ufwgSs6VxM87rjZ1v4Cnpil8zbD96+xVqYEW+AXZmoOXnjtd4vfndcKH2nTfF7CZ1eMm9UGT0jS3NrhVfcd5oNewbclaJ70/nOjZkCv4UfHl5s5d8BjD5qx+enX+zR/H3xdmjlWfCfcV6N7oe+z7TWrC/6nVPflh5dMDpoD0xcf1j12w+tCWeZi6Jl23W8PfPhZl9m4F35yqe6dPrfcHNf5Bn5nmnrogyc7vGbRe8Pq5C08N9OM2RqAT21UP/TylWbb7HfwX251Re85o7m9h8/ZrN7oO8c0T3rZQ3UYhHflas70WQvVJ31HSPMPwUsvqVt6Z4a2pVtj9H/jAzyjSfdFL8lXbvSOtbrHj/C4H+qfbr+t+6UX5+hd9MPb482Y8+ix3Xov9O3F6mEA7tqqd0RvizTXW02PeaL39QmefkT90IuW6d3RvWF1RZ9+VV2F4WlZ6op+1mqOO0pvaVVXg3BLobqib9mgruinf6urz/Dme+qKHnVAXdFTF6irIXhhQF3RG8vUFX2KXV0Nw5OizbYOutOjrugNx9TVF3jkKnVF3zSiruinbqqrr3DPHnVFnzRPXdE3+tTVCPxEkbqi1yarK/pf1SGdig==AQAAAAAAAAAAgAAAAAAAAEAGAAAAAAAAvgAAAAAAAAA=eF5dxcciAgAAANAohOyZUhq2bLJ3yB4hiaz//waHnN67vECgrpGDHOImbuYWDnMrt3E7R7iDO7mLu7mHe7mP+3mAB3mIhznKIxzjOI9ygpM8xilOc4azPM4TPMlTPM0zPMtznON5XuBFXuJlXuFVXuN1zvMGb/IWb/MO7/Ie7/MBH/IRH/MJF/iUz/ici3zBl3zF13zDt3zH9/zAj1ziJ37mFy7zK1f4jav8zh9c40/+4m/+4V9u+P8PcvwndA==AQAAAAAAAAAAgAAAAAAAACADAAAAAAAAxwAAAAAAAAA=eF4txdFGAwAAAMAkmUwymUySSZIkmWQySZJJkiQzmSTJJEmSTJKZZJJJkkmSmSRJkkkm6bN62N3LNTc1tLjVAbc56HZ3OOROh93liLvd415H3ed+D3jQQx72iEcd85jHHfeEE570lKc941knPed5L3jRS172ilNOe9UZr3ndG970lrPe9o53ved9H/jQR8752Cc+dd4Fn/ncRV/40iVf+do3vnXZd773gx9dcdVPfvaLX/3md3/40zV/+dt1//jXf/4H8McndQ==AQAAAAAAAAAAgAAAAAAAAGQAAAAAAAAADAAAAAAAAAA=eF5jZqY9AAA7kgEt + + diff --git a/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_300_t_0.300000.vtu b/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_300_t_0.300000.vtu new file mode 100644 index 00000000000..aab5bcea2ef --- /dev/null +++ b/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_300_t_0.300000.vtu @@ -0,0 +1,27 @@ + + + + + + + + + + + + + + + + + + + + + + + + + _AQAAAAAAAAAAgAAAAAAAABQAAAAAAAAAHAAAAAAAAAA=eF4z0zPRM9E1NLMw0E23NLBIMjNINgYALH8Eig==AQAAAAAAAAAAgAAAAAAAACgDAAAAAAAAMwMAAAAAAAA=eF4BKAPX/AAAAAAAAAAA3y6LfS6/pTgAAAAAAAAAABgghjc2IuI7ApeXaDnk4ztoKbUsL5ROPK/9T2uSvlA8Mlw0EsGblzwehKnwiLWZPKhb7lIJ/ds8udi51z9q3jyW6ndJmRkWPSbMhUsw1CM9a8tgKE64Sz0sWB7lKlJmPa02CTNhGXc9xX7oQHmOpD30BoAn+kykPdybZ9Uk8N09VJtcefQm4D0iNMIjdwAUPvXBglcLyBU+JZ50T9ruSD7H7IAOuP1TPqbComvGf3Q+vyzvmugwlD6lkek7JcqXPjqEpEZNBcw+D903XnYEzT6F9IvZfHP6Ps5mdMG1xA0/wJEpvIO1Fz/SGVcR291DPziAl64uFko/h2+JFFUiWj9G8QnLX7h7P/Lk7T7J7oY/XebehVg/mD+kuaGHSji0P1b/9Nygqso/Rw6wt67G2T/jXmU/4KbjPwD0oTjXSek/ozVXnvz87D9shRGdRuruP4VlNHT8s+8/mS1DQzzy7z8qb3TqUf7vPx1AFvaU/+8/dlcKp7D/7z94Uonxr//vPzAqbaWG/+8/NMwceEn/7z9nm7tTDfvvPw3U5g59+e8/zNl9s/Hy7z9djMVai8jvP8it+Y9BpO8/GAAangk+7z8dy0CW8njtP36eyiRYVek/GyNRWasc4z/Mh228OLLYP5D35Our2Mo/Qd/8y0sYuD9P6Dfa31uhP+y3EPaxDIM/38PercZVXD/v4627c4IpP9RIgTlspPU+KoRvm19dwj5pvQhWIiyPPjJE6ZTDdVo+QFJ4/312Jj5WNpfLUBLzPSMpGZeQMcA9zofCiHKAiz3aq2HitlpXPbyzzmdC1SM976xM2szX8DzQRnYuhpu8PLU1yXRoS4g8N6NP0quhVDzjK58YOIUhPB13rmaDwe07yFEHRGpEuTs0UA31cnSFO/vvJZmMN1I74rKrXCfvHjuiF6YAdEPqOia/D58LTLY6OzMFKcntgjpQEkevnBFQOuvP+DrcRxs67A1CIy8o5zmFQeKb5KezOedDF63RroA5TJ7vUmJPTDm7HJYOa/0XORIAS/GUg+Q4tvyBCTaptjg2t4HhAQAAAAAAAAAAgAAAAAAAACgDAAAAAAAAVgIAAAAAAAA=eF4V011ozXEYB/Df//3YG3thaLZahCnhwrRmnm8ktCJ1Rlkr2oWd8nKx1hqtf1prucDFSKZkCuUlMRfbUv8omYi8lKUYtXahrUax8+77nJtPz/me8/s/z/k9p8I2xiRiMPpKLEicdbQvhkEabojhE5WiGKod5rMBEjR6G2CEhg8DzFO5GKDWZX46QJxGBwIM0HBzgDEqZfyc5n98NHrMP/oYouGIjwyVyz5afeZdPsZp1OJjZcC83kcPleU+JqlJetgWYz7p4SoNxzz8pTLkoWUR87MeRmjU6qG0gPl2DyeoVHt4TU3exdpC5t9d9NEwcjFF5aaLhiLm51wM0uiYizka7nSxp5j5ahfD1HguMjSadnCohPlLB4+p3HFQspj5gIMOGh138JyGex1ULWFe56CLmkIH72n0y0ZdKfM3NvqpPLDxk5oLNnaUMT9po5uG+200Udlk45vmpTZ6aTRvoUa//8FCpOc/sXBUzx+0YOv5nRZu6fPjFnZR2Wphmn2aSgv9NPpnsE77/2LwSucbNejQ+a4ZFOh8PQb3dP4jBs1UGg1m+TuZVQZVlXw/nZe2Zayf5eXGUta9eZmqYC15qaWhlZf2ctYvcnJb5+jLyYz2vzsn67XvICcJ7XciK/e1z/NZmdP+mrOyUfsqzsop7eddRh5pH5cy8luffzAjW/TeyjPSqff5OS1Ped/hlbToHpjDaanXvViRlm7dl68pGeU+hddTkuKembaUNOje1aTkjO7jj6SM6x4PJyWr/4P2pDTp3q9JSq/FemZBIhLeXZD/7y/E5w==AQAAAAAAAAAAgAAAAAAAAHgJAAAAAAAAmwIAAAAAAAA=eF591FtI02Ech3FJKmchJutAgRdGsA4UVHS4sAPloQRrIBkoVBdGQaRBdLEirBxSIUssJcKIFh0gpROp0UGdacpMy+nUbLWVNtMyCosuzN6vlz3Qe/lB9v7f3/u8RkT8b31b/6+0D1akBB0F8LEJPw8/FCgYsldfhu8K6++vwX/uvmjWLfiMXv1OJbxoUXW8c+guvHni9x/Ao2648xKjq+CpOdq3Bl4431U/ansMzw/qe57Cw+mJ0X53LXz1En1nHedgWWGWB+4a0Pc3wB95bNmu+ufwgSs6VxM87rjZ1v4Cnpil8zbD96+xVqYEW+AXZmoOXnjtd4vfndcKH2nTfF7CZ1eMm9UGT0jS3NrhVfcd5oNewbclaJ70/nOjZkCv4UfHl5s5d8BjD5qx+enX+zR/H3xdmjlWfCfcV6N7oe+z7TWrC/6nVPflh5dMDpoD0xcf1j12w+tCWeZi6Jl23W8PfPhZl9m4F35yqe6dPrfcHNf5Bn5nmnrogyc7vGbRe8Pq5C08N9OM2RqAT21UP/TylWbb7HfwX251Re85o7m9h8/ZrN7oO8c0T3rZQ3UYhHflas70WQvVJ31HSPMPwUsvqVt6Z4a2pVtj9H/jAzyjSfdFL8lXbvSOtbrHj/C4H+qfbr+t+6UX5+hd9MPb482Y8+ix3Xov9O3F6mEA7tqqd0RvizTXW02PeaL39QmefkT90IuW6d3RvWF1RZ9+VV2F4WlZ6op+1mqOO0pvaVVXg3BLobqib9mgruinf6urz/Dme+qKHnVAXdFTF6irIXhhQF3RG8vUFX2KXV0Nw5OizbYOutOjrugNx9TVF3jkKnVF3zSiruinbqqrr3DPHnVFnzRPXdE3+tTVCPxEkbqi1yarK/pf1SGdig==AQAAAAAAAAAAgAAAAAAAAEAGAAAAAAAAvgAAAAAAAAA=eF5dxcciAgAAANAohOyZUhq2bLJ3yB4hiaz//waHnN67vECgrpGDHOImbuYWDnMrt3E7R7iDO7mLu7mHe7mP+3mAB3mIhznKIxzjOI9ygpM8xilOc4azPM4TPMlTPM0zPMtznON5XuBFXuJlXuFVXuN1zvMGb/IWb/MO7/Ie7/MBH/IRH/MJF/iUz/ici3zBl3zF13zDt3zH9/zAj1ziJ37mFy7zK1f4jav8zh9c40/+4m/+4V9u+P8PcvwndA==AQAAAAAAAAAAgAAAAAAAACADAAAAAAAAxwAAAAAAAAA=eF4txdFGAwAAAMAkmUwymUySSZIkmWQySZJJkiQzmSTJJEmSTJKZZJJJkkmSmSRJkkkm6bN62N3LNTc1tLjVAbc56HZ3OOROh93liLvd415H3ed+D3jQQx72iEcd85jHHfeEE570lKc941knPed5L3jRS172ilNOe9UZr3ndG970lrPe9o53ved9H/jQR8752Cc+dd4Fn/ncRV/40iVf+do3vnXZd773gx9dcdVPfvaLX/3md3/40zV/+dt1//jXf/4H8McndQ==AQAAAAAAAAAAgAAAAAAAAGQAAAAAAAAADAAAAAAAAAA=eF5jZqY9AAA7kgEt + + diff --git a/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_350_t_0.350000.vtu b/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_350_t_0.350000.vtu new file mode 100644 index 00000000000..68a037520b6 --- /dev/null +++ b/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_350_t_0.350000.vtu @@ -0,0 +1,27 @@ + + + + + + + + + + + + + + + + + + + + + + + + + _AQAAAAAAAAAAgAAAAAAAABQAAAAAAAAAHAAAAAAAAAA=eF4z0zPRM9E1NLMw0E23NLBIMjNINgYALH8Eig==AQAAAAAAAAAAgAAAAAAAACgDAAAAAAAAMwMAAAAAAAA=eF4BKAPX/AAAAAAAAAAA7q9UE0p1wDkAAAAAAAAAAKsX/RJIV4w7W0+kEq3JgDtpgJJ7Mh7iO/I4UVS0KuQ7KiTh9E1pKDxrZWoVpN4qPEe7YImoom08pHcwI4szcDx2LhXMBs+rPOFS+p6bRK48q0+w6f6t4zxYaGZ9WT7lPNOR0zKZAB097VBZFYdEHz0XcuiIzCRTPUzKmZxnN189dOxTPHBThD0/z2h3xhOcPXpOAtv3lLA9S3+6I+3L2T0cfmXYW7fXPTjQRHMTuxA+2/+2B1hIET7qC1NuPLZDPs1DZdejQ0o+pcGBdzrtaj7tHmdB3z2OPu0+VMJ2+I8+60WP3ihqvz7vU7c8hTLRPtx+mJCt2dw+VH2kr5JBCz8gemFEA7cMP39fpeIl7S8/JQDg59Z9Rz8YoPjFLvNHP6MESnOQCmY/ObjoYlFYfj9V7JLnNFSKP20Bp4g8raA/3W1n3YyfuD/MMm+r6dTMP8dNUtFPK9o/iPJDuP5q4z+snMZCPdDoP+zk45kTh+w/FOPjQ9mb7j+LmAT0t43vPyqh56s+5e8/zcOoqRv87z/TvyUuBf/vP9vxZuVS/+8/buCS7Vn/7z8Ar7aZWv/vP5fez0oc/u8/bQw9wzP67z+9M+rBFfrvP/aJvlPn6e8/Bv40mVPD7z/AnSHBp5bvP0F0eh4x9e4/gw8RNAvs7D9iascwxMroPxRC3m9d6uI/gQ716vgp2T+YXOVqA7/MP7h9AtwLyLs/agBmFXVCpj9Q82nEFZaMPxKXoMaYgWs/UMwd9kEUQT87iveTvAcNP4lmhgz1qtg+AmmreiD1pD73hTWKds1xPqZ16AWpPT4+jjWafmquCT60+++Cec7VPRTxYTSpg6I9KAtK5Fpvbz0suhRYEq86PRow17gjpgY9Udr0PQo50zzu+yuSW1CgPNHcwh1ZsGs8F14SWhl/NzwkPs7FKfADPJo5ezwO69A7Ba8Nx++1nDsySi6VcVxoOxmBhoyYqzQ7z/a/xuGJATtPXw03QcPNOvLtSlKsQJk661Lm8n9rZToe/uHyiyUyOqZGDWPcB/85rCxmJ9wk0Tnh3H9bAQAAAAAAAAAAgAAAAAAAACgDAAAAAAAAVgIAAAAAAAA=eF4V011ozXEYB/Df//3YG3thaLZahCnhwrRmnm8ktCJ1Rlkr2oWd8nKx1hqtf1prucDFSKZkCuUlMRfbUv8omYi8lKUYtXahrUax8+77nJtPz/me8/s/z/k9p8I2xiRiMPpKLEicdbQvhkEabojhE5WiGKod5rMBEjR6G2CEhg8DzFO5GKDWZX46QJxGBwIM0HBzgDEqZfyc5n98NHrMP/oYouGIjwyVyz5afeZdPsZp1OJjZcC83kcPleU+JqlJetgWYz7p4SoNxzz8pTLkoWUR87MeRmjU6qG0gPl2DyeoVHt4TU3exdpC5t9d9NEwcjFF5aaLhiLm51wM0uiYizka7nSxp5j5ahfD1HguMjSadnCohPlLB4+p3HFQspj5gIMOGh138JyGex1ULWFe56CLmkIH72n0y0ZdKfM3NvqpPLDxk5oLNnaUMT9po5uG+200Udlk45vmpTZ6aTRvoUa//8FCpOc/sXBUzx+0YOv5nRZu6fPjFnZR2Wphmn2aSgv9NPpnsE77/2LwSucbNejQ+a4ZFOh8PQb3dP4jBs1UGg1m+TuZVQZVlXw/nZe2Zayf5eXGUta9eZmqYC15qaWhlZf2ctYvcnJb5+jLyYz2vzsn67XvICcJ7XciK/e1z/NZmdP+mrOyUfsqzsop7eddRh5pH5cy8luffzAjW/TeyjPSqff5OS1Ped/hlbToHpjDaanXvViRlm7dl68pGeU+hddTkuKembaUNOje1aTkjO7jj6SM6x4PJyWr/4P2pDTp3q9JSq/FemZBIhLeXZD/7y/E5w==AQAAAAAAAAAAgAAAAAAAAHgJAAAAAAAAmwIAAAAAAAA=eF591FtI02Ech3FJKmchJutAgRdGsA4UVHS4sAPloQRrIBkoVBdGQaRBdLEirBxSIUssJcKIFh0gpROp0UGdacpMy+nUbLWVNtMyCosuzN6vlz3Qe/lB9v7f3/u8RkT8b31b/6+0D1akBB0F8LEJPw8/FCgYsldfhu8K6++vwX/uvmjWLfiMXv1OJbxoUXW8c+guvHni9x/Ao2648xKjq+CpOdq3Bl4431U/ansMzw/qe57Cw+mJ0X53LXz1En1nHedgWWGWB+4a0Pc3wB95bNmu+ufwgSs6VxM87rjZ1v4Cnpil8zbD96+xVqYEW+AXZmoOXnjtd4vfndcKH2nTfF7CZ1eMm9UGT0jS3NrhVfcd5oNewbclaJ70/nOjZkCv4UfHl5s5d8BjD5qx+enX+zR/H3xdmjlWfCfcV6N7oe+z7TWrC/6nVPflh5dMDpoD0xcf1j12w+tCWeZi6Jl23W8PfPhZl9m4F35yqe6dPrfcHNf5Bn5nmnrogyc7vGbRe8Pq5C08N9OM2RqAT21UP/TylWbb7HfwX251Re85o7m9h8/ZrN7oO8c0T3rZQ3UYhHflas70WQvVJ31HSPMPwUsvqVt6Z4a2pVtj9H/jAzyjSfdFL8lXbvSOtbrHj/C4H+qfbr+t+6UX5+hd9MPb482Y8+ix3Xov9O3F6mEA7tqqd0RvizTXW02PeaL39QmefkT90IuW6d3RvWF1RZ9+VV2F4WlZ6op+1mqOO0pvaVVXg3BLobqib9mgruinf6urz/Dme+qKHnVAXdFTF6irIXhhQF3RG8vUFX2KXV0Nw5OizbYOutOjrugNx9TVF3jkKnVF3zSiruinbqqrr3DPHnVFnzRPXdE3+tTVCPxEkbqi1yarK/pf1SGdig==AQAAAAAAAAAAgAAAAAAAAEAGAAAAAAAAvgAAAAAAAAA=eF5dxcciAgAAANAohOyZUhq2bLJ3yB4hiaz//waHnN67vECgrpGDHOImbuYWDnMrt3E7R7iDO7mLu7mHe7mP+3mAB3mIhznKIxzjOI9ygpM8xilOc4azPM4TPMlTPM0zPMtznON5XuBFXuJlXuFVXuN1zvMGb/IWb/MO7/Ie7/MBH/IRH/MJF/iUz/ici3zBl3zF13zDt3zH9/zAj1ziJ37mFy7zK1f4jav8zh9c40/+4m/+4V9u+P8PcvwndA==AQAAAAAAAAAAgAAAAAAAACADAAAAAAAAxwAAAAAAAAA=eF4txdFGAwAAAMAkmUwymUySSZIkmWQySZJJkiQzmSTJJEmSTJKZZJJJkkmSmSRJkkkm6bN62N3LNTc1tLjVAbc56HZ3OOROh93liLvd415H3ed+D3jQQx72iEcd85jHHfeEE570lKc941knPed5L3jRS172ilNOe9UZr3ndG970lrPe9o53ved9H/jQR8752Cc+dd4Fn/ncRV/40iVf+do3vnXZd773gx9dcdVPfvaLX/3md3/40zV/+dt1//jXf/4H8McndQ==AQAAAAAAAAAAgAAAAAAAAGQAAAAAAAAADAAAAAAAAAA=eF5jZqY9AAA7kgEt + + diff --git a/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_400_t_0.400000.vtu b/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_400_t_0.400000.vtu new file mode 100644 index 00000000000..e362abdd2dc --- /dev/null +++ b/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_400_t_0.400000.vtu @@ -0,0 +1,27 @@ + + + + + + + + + + + + + + + + + + + + + + + + + _AQAAAAAAAAAAgAAAAAAAABQAAAAAAAAAHAAAAAAAAAA=eF4z0zPRM9E1NLMw0E23NLBIMjNINgYALH8Eig==AQAAAAAAAAAAgAAAAAAAACgDAAAAAAAAMwMAAAAAAAA=eF4BKAPX/AAAAAAAAAAAFlOgYXKJ2Dr+3nAuoOehN8fqm1xQjCI7lRgehXQfJDtCRX2lPjhzO4UxNlv06HQ74tzdheKWvDuVypbjA827O6gYSRC9wPw7o8TOrTCiATxtRE/lfxg6PJv3EHP69jw8wzhqtngrdTwlINCfWZN3PCi7xuas1a48I+LWyKDOsDxTOiLN5zbkPP232z761eU81QbAzPYSGj1hS/gw0ckgPZkUpEJKIE49hd/KyyE4YT37jcGuOLx2PUOsc/4fhp89Ozk9lxJvoD1qZZ00XHzVPXBnq5vh2dY9CO7qrL7tBT5Alyaw6/0PPgvai7BDJjA+iOTkcdeQUT4OwUnTe+ZSPlCP5+mNzoY+0Mv3Q9L9iz6TpnrVnGevPlihbSeo9M4+KaRKiFou0D7aMYtXrAT8PsMV41aY6Q0/GRYVMmXIEz8o7bzY6EU9PwG6j/4e2UM/KJis3FBFTj+FrhTCoE1uP4RBBogMiYA/xA/Lda5CkD8p2aFpDpSlP+jxIh0sl7w/ePVcK8Wmzj+KSVCkJ37aPy2O9MQaOeM/cc9EYXZn6D9lYBmXnxvsP+LbQnCcTu4/DgsSD75j7z/HoFrIE9TvP7eRWaiR9+8/5AkSzDb+7z8iYLNL3/7vPyiGTDP0/u8/d1bpP/b+7z8zuMw1ofzvP8OBD2Qh++8/MaploYz47z8K2g+yqOHvP5YqKBvSve8/9ehRLut97z+GYhv2vKbuP9tXHJUZbew/6WrnaFBW6D8drpA67cDiP6kW5bbBjdk/6zKx1TBizj+YbGTepSO/P4swkdO3Fqs/3ZElQ5eIkz9FKFQTpmJ2P79rJrj6pFI/vFHVgOA1Iz8OfqYmWErwPmeJYlHYoLs+hjxRX8Zthz7II1XION5TPnwGLZRY2SA+LP3/2SCU7D0BYyb9+Dy4Pa63XUzfjoQ9ET3VrxVwUT0kUQtFkJUdPZtfB0zqGOk8dDptwdlKtTwIWB8jxxCCPCW0vvdRqE48iLwhVcsDGjxYRqeqlhPmO3GrQkIdvLI7jOwiEE7Kfzs6S2QJgfBKO+CAuJLjChc7n1mA/TaB6TqbuoTRAQAAAAAAAAAAgAAAAAAAACgDAAAAAAAAVgIAAAAAAAA=eF4V011ozXEYB/Df//3YG3thaLZahCnhwrRmnm8ktCJ1Rlkr2oWd8nKx1hqtf1prucDFSKZkCuUlMRfbUv8omYi8lKUYtXahrUax8+77nJtPz/me8/s/z/k9p8I2xiRiMPpKLEicdbQvhkEabojhE5WiGKod5rMBEjR6G2CEhg8DzFO5GKDWZX46QJxGBwIM0HBzgDEqZfyc5n98NHrMP/oYouGIjwyVyz5afeZdPsZp1OJjZcC83kcPleU+JqlJetgWYz7p4SoNxzz8pTLkoWUR87MeRmjU6qG0gPl2DyeoVHt4TU3exdpC5t9d9NEwcjFF5aaLhiLm51wM0uiYizka7nSxp5j5ahfD1HguMjSadnCohPlLB4+p3HFQspj5gIMOGh138JyGex1ULWFe56CLmkIH72n0y0ZdKfM3NvqpPLDxk5oLNnaUMT9po5uG+200Udlk45vmpTZ6aTRvoUa//8FCpOc/sXBUzx+0YOv5nRZu6fPjFnZR2Wphmn2aSgv9NPpnsE77/2LwSucbNejQ+a4ZFOh8PQb3dP4jBs1UGg1m+TuZVQZVlXw/nZe2Zayf5eXGUta9eZmqYC15qaWhlZf2ctYvcnJb5+jLyYz2vzsn67XvICcJ7XciK/e1z/NZmdP+mrOyUfsqzsop7eddRh5pH5cy8luffzAjW/TeyjPSqff5OS1Ped/hlbToHpjDaanXvViRlm7dl68pGeU+hddTkuKembaUNOje1aTkjO7jj6SM6x4PJyWr/4P2pDTp3q9JSq/FemZBIhLeXZD/7y/E5w==AQAAAAAAAAAAgAAAAAAAAHgJAAAAAAAAmwIAAAAAAAA=eF591FtI02Ech3FJKmchJutAgRdGsA4UVHS4sAPloQRrIBkoVBdGQaRBdLEirBxSIUssJcKIFh0gpROp0UGdacpMy+nUbLWVNtMyCosuzN6vlz3Qe/lB9v7f3/u8RkT8b31b/6+0D1akBB0F8LEJPw8/FCgYsldfhu8K6++vwX/uvmjWLfiMXv1OJbxoUXW8c+guvHni9x/Ao2648xKjq+CpOdq3Bl4431U/ansMzw/qe57Cw+mJ0X53LXz1En1nHedgWWGWB+4a0Pc3wB95bNmu+ufwgSs6VxM87rjZ1v4Cnpil8zbD96+xVqYEW+AXZmoOXnjtd4vfndcKH2nTfF7CZ1eMm9UGT0jS3NrhVfcd5oNewbclaJ70/nOjZkCv4UfHl5s5d8BjD5qx+enX+zR/H3xdmjlWfCfcV6N7oe+z7TWrC/6nVPflh5dMDpoD0xcf1j12w+tCWeZi6Jl23W8PfPhZl9m4F35yqe6dPrfcHNf5Bn5nmnrogyc7vGbRe8Pq5C08N9OM2RqAT21UP/TylWbb7HfwX251Re85o7m9h8/ZrN7oO8c0T3rZQ3UYhHflas70WQvVJ31HSPMPwUsvqVt6Z4a2pVtj9H/jAzyjSfdFL8lXbvSOtbrHj/C4H+qfbr+t+6UX5+hd9MPb482Y8+ix3Xov9O3F6mEA7tqqd0RvizTXW02PeaL39QmefkT90IuW6d3RvWF1RZ9+VV2F4WlZ6op+1mqOO0pvaVVXg3BLobqib9mgruinf6urz/Dme+qKHnVAXdFTF6irIXhhQF3RG8vUFX2KXV0Nw5OizbYOutOjrugNx9TVF3jkKnVF3zSiruinbqqrr3DPHnVFnzRPXdE3+tTVCPxEkbqi1yarK/pf1SGdig==AQAAAAAAAAAAgAAAAAAAAEAGAAAAAAAAvgAAAAAAAAA=eF5dxcciAgAAANAohOyZUhq2bLJ3yB4hiaz//waHnN67vECgrpGDHOImbuYWDnMrt3E7R7iDO7mLu7mHe7mP+3mAB3mIhznKIxzjOI9ygpM8xilOc4azPM4TPMlTPM0zPMtznON5XuBFXuJlXuFVXuN1zvMGb/IWb/MO7/Ie7/MBH/IRH/MJF/iUz/ici3zBl3zF13zDt3zH9/zAj1ziJ37mFy7zK1f4jav8zh9c40/+4m/+4V9u+P8PcvwndA==AQAAAAAAAAAAgAAAAAAAACADAAAAAAAAxwAAAAAAAAA=eF4txdFGAwAAAMAkmUwymUySSZIkmWQySZJJkiQzmSTJJEmSTJKZZJJJkkmSmSRJkkkm6bN62N3LNTc1tLjVAbc56HZ3OOROh93liLvd415H3ed+D3jQQx72iEcd85jHHfeEE570lKc941knPed5L3jRS172ilNOe9UZr3ndG970lrPe9o53ved9H/jQR8752Cc+dd4Fn/ncRV/40iVf+do3vnXZd773gx9dcdVPfvaLX/3md3/40zV/+dt1//jXf/4H8McndQ==AQAAAAAAAAAAgAAAAAAAAGQAAAAAAAAADAAAAAAAAAA=eF5jZqY9AAA7kgEt + + diff --git a/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_450_t_0.450000.vtu b/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_450_t_0.450000.vtu new file mode 100644 index 00000000000..1a64d05ffae --- /dev/null +++ b/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_450_t_0.450000.vtu @@ -0,0 +1,27 @@ + + + + + + + + + + + + + + + + + + + + + + + + + _AQAAAAAAAAAAgAAAAAAAABQAAAAAAAAAHAAAAAAAAAA=eF4z0zPRM9E1NLMw0E23NLBIMjNINgYALH8Eig==AQAAAAAAAAAAgAAAAAAAACgDAAAAAAAAMwMAAAAAAAA=eF4BKAPX/AAAAAAAAAAAB5DZ7vsa8jutorynPZgtN6eNnqzU6Kg62QHSVf8WoDoIqSzPS3AGO9l8JOALbgg7e9s7ngEzUDtUyLSNJJlRO1ke/pu+Io87d3iUktLykDu87ACZIV/KO+1KmNhyt8w7Q7IjvcFOBTy59x3vMDEHPO4B2x8NZz88NcA7vd4MQTwqq0BR6SB1PJYq+Ber4XY8BdkOE9sdqzzd468oq5iyPLq1loj+Gt08AYFu3EC48DzrLZmLrJoHPWaNMYacRS89tyUAlMctMD3UfU7EFqdlPeYKq5MueWY9Z8bXaX2omj3Ma+LEpmGePfUP8ucTscc9grzZPryI3z1ctUVSPpDrPZSzZ5af7BY+7o6rErhcGD4jLXQku6hHPoPxbWarRlY+5gl72lEobz5hv1Vy+iaTPmXlte21q5M+2DKWeWlXxT7fWs+q/mTOPjDjvT5U9OQ+G2He2RoECD+NbqqqANIIP829bF2SYSc/vg4yLLs0QD+GjyAk7qdAP19FGpU0llc/4c9W5kcwcj/b4LTt/beCPxgQStw/YZQ/qHcOv5qPqj8SD3xZSxXAP8AgTff9GtA/m4aovijE2j8h57mgog7jP2C9Au/+C+g/I9s6R2S56z+2NHLhYwPuP4gnBJCkN+8/WlqljjO/7z8HL8AifPDvP4oF0erq/O8/HyYt213+7z/tHB9af/7vP5wB5E4q/u8/Klomqy/87z+lXnb6APzvP+P24JJJ9O8/92wV4pXb7z/7uo2dHbXvP+ycYZHsXO8/0mC+UQ9X7j+wef84oPrrP+zAGTCL8uc/RhszMu6d4j/Duq2vkOLZP8kgNhKC0M8/ddcCu4EawT9rJ6hnLcmvPwX1oWsrFZk/l7D0ZNJUgD/r/UIRzp5gP8rKKnytczc/fLLjOvLEBD84AZyFc6HRPi57B477750+6WmNCLZraT5BQtwKfZY1PnuW8YGdVQI+HEEvEAklzz3jvJo2MnSaPQl4kBxheGY98rT8dzIWMz0IT11hbTYAPVmo5jaOiss89V3vE69ilzxgUQQrztRjPH3RRq7z+DA8+l/yOwrNAjzt6YK3AQAAAAAAAAAAgAAAAAAAACgDAAAAAAAAVgIAAAAAAAA=eF4V011ozXEYB/Df//3YG3thaLZahCnhwrRmnm8ktCJ1Rlkr2oWd8nKx1hqtf1prucDFSKZkCuUlMRfbUv8omYi8lKUYtXahrUax8+77nJtPz/me8/s/z/k9p8I2xiRiMPpKLEicdbQvhkEabojhE5WiGKod5rMBEjR6G2CEhg8DzFO5GKDWZX46QJxGBwIM0HBzgDEqZfyc5n98NHrMP/oYouGIjwyVyz5afeZdPsZp1OJjZcC83kcPleU+JqlJetgWYz7p4SoNxzz8pTLkoWUR87MeRmjU6qG0gPl2DyeoVHt4TU3exdpC5t9d9NEwcjFF5aaLhiLm51wM0uiYizka7nSxp5j5ahfD1HguMjSadnCohPlLB4+p3HFQspj5gIMOGh138JyGex1ULWFe56CLmkIH72n0y0ZdKfM3NvqpPLDxk5oLNnaUMT9po5uG+200Udlk45vmpTZ6aTRvoUa//8FCpOc/sXBUzx+0YOv5nRZu6fPjFnZR2Wphmn2aSgv9NPpnsE77/2LwSucbNejQ+a4ZFOh8PQb3dP4jBs1UGg1m+TuZVQZVlXw/nZe2Zayf5eXGUta9eZmqYC15qaWhlZf2ctYvcnJb5+jLyYz2vzsn67XvICcJ7XciK/e1z/NZmdP+mrOyUfsqzsop7eddRh5pH5cy8luffzAjW/TeyjPSqff5OS1Ped/hlbToHpjDaanXvViRlm7dl68pGeU+hddTkuKembaUNOje1aTkjO7jj6SM6x4PJyWr/4P2pDTp3q9JSq/FemZBIhLeXZD/7y/E5w==AQAAAAAAAAAAgAAAAAAAAHgJAAAAAAAAmwIAAAAAAAA=eF591FtI02Ech3FJKmchJutAgRdGsA4UVHS4sAPloQRrIBkoVBdGQaRBdLEirBxSIUssJcKIFh0gpROp0UGdacpMy+nUbLWVNtMyCosuzN6vlz3Qe/lB9v7f3/u8RkT8b31b/6+0D1akBB0F8LEJPw8/FCgYsldfhu8K6++vwX/uvmjWLfiMXv1OJbxoUXW8c+guvHni9x/Ao2648xKjq+CpOdq3Bl4431U/ansMzw/qe57Cw+mJ0X53LXz1En1nHedgWWGWB+4a0Pc3wB95bNmu+ufwgSs6VxM87rjZ1v4Cnpil8zbD96+xVqYEW+AXZmoOXnjtd4vfndcKH2nTfF7CZ1eMm9UGT0jS3NrhVfcd5oNewbclaJ70/nOjZkCv4UfHl5s5d8BjD5qx+enX+zR/H3xdmjlWfCfcV6N7oe+z7TWrC/6nVPflh5dMDpoD0xcf1j12w+tCWeZi6Jl23W8PfPhZl9m4F35yqe6dPrfcHNf5Bn5nmnrogyc7vGbRe8Pq5C08N9OM2RqAT21UP/TylWbb7HfwX251Re85o7m9h8/ZrN7oO8c0T3rZQ3UYhHflas70WQvVJ31HSPMPwUsvqVt6Z4a2pVtj9H/jAzyjSfdFL8lXbvSOtbrHj/C4H+qfbr+t+6UX5+hd9MPb482Y8+ix3Xov9O3F6mEA7tqqd0RvizTXW02PeaL39QmefkT90IuW6d3RvWF1RZ9+VV2F4WlZ6op+1mqOO0pvaVVXg3BLobqib9mgruinf6urz/Dme+qKHnVAXdFTF6irIXhhQF3RG8vUFX2KXV0Nw5OizbYOutOjrugNx9TVF3jkKnVF3zSiruinbqqrr3DPHnVFnzRPXdE3+tTVCPxEkbqi1yarK/pf1SGdig==AQAAAAAAAAAAgAAAAAAAAEAGAAAAAAAAvgAAAAAAAAA=eF5dxcciAgAAANAohOyZUhq2bLJ3yB4hiaz//waHnN67vECgrpGDHOImbuYWDnMrt3E7R7iDO7mLu7mHe7mP+3mAB3mIhznKIxzjOI9ygpM8xilOc4azPM4TPMlTPM0zPMtznON5XuBFXuJlXuFVXuN1zvMGb/IWb/MO7/Ie7/MBH/IRH/MJF/iUz/ici3zBl3zF13zDt3zH9/zAj1ziJ37mFy7zK1f4jav8zh9c40/+4m/+4V9u+P8PcvwndA==AQAAAAAAAAAAgAAAAAAAACADAAAAAAAAxwAAAAAAAAA=eF4txdFGAwAAAMAkmUwymUySSZIkmWQySZJJkiQzmSTJJEmSTJKZZJJJkkmSmSRJkkkm6bN62N3LNTc1tLjVAbc56HZ3OOROh93liLvd415H3ed+D3jQQx72iEcd85jHHfeEE570lKc941knPed5L3jRS172ilNOe9UZr3ndG970lrPe9o53ved9H/jQR8752Cc+dd4Fn/ncRV/40iVf+do3vnXZd773gx9dcdVPfvaLX/3md3/40zV/+dt1//jXf/4H8McndQ==AQAAAAAAAAAAgAAAAAAAAGQAAAAAAAAADAAAAAAAAAA=eF5jZqY9AAA7kgEt + + diff --git a/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_500_t_0.500000.vtu b/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_500_t_0.500000.vtu new file mode 100644 index 00000000000..0ac76529858 --- /dev/null +++ b/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_500_t_0.500000.vtu @@ -0,0 +1,27 @@ + + + + + + + + + + + + + + + + + + + + + + + + + _AQAAAAAAAAAAgAAAAAAAABQAAAAAAAAAHAAAAAAAAAA=eF4z0zPRM9E1NLMw0E23NLBIMjNINgYALH8Eig==AQAAAAAAAAAAgAAAAAAAACgDAAAAAAAAMwMAAAAAAAA=eF4BKAPX/AAAAAAAAAAA7eqWOQ1pCj0J3/D2UBkJOmoVBiCPhQs6OY5pzPFbdzr6Cs8gMJR5Oqffcna/R8E689U9THfOwjpVsAf8vIADO7hB2KYJHwU7uBNcw/oMPDvfM0oXgSZNO4Koq45hm3I7jqQkO2pMjjtesxtKN7mlO4eBILMpBs07UVV7xnhi1zvBBWnlFI0GPCqpNnKbyQg8tEEacH9zPjzApnKjCs1APMpiURYVlHI8pLBPOF1+eDwrpKsMipSiPBogU34UDrg8OwgJp/FxzDwOyj8EP6j0POJwZnfd0vM83ScAzELDKz3izXmNb6gtPZGWo5CuyF49SRMo8I23aD31COfuAQCHPVunYOBfaqk9jK9oywk8rD0ITGBeWAzfPURJFdMKQ+E9smoyWAdnED7pirZyhnEWPqqNAdLvIzo+P1aBI+g8VD6lYT/KfvZaPlbxMuR55Ys+20jP57LXjD54ZbGcB0C1PsZZu8D2xc0+csybtjEW0D4JQ8shySX5PjGvAJTVwgo/GFLxPyikCT8VoN+OJEAzP5qrbRmFyDo/V07Zjx/jQz8/M19a4W5gP98XDsOiCXU/OAjgqofkhT9nIUXzlzmZP7yK6fe5d68/TgbXBRm0wT829kS1dcjQPwhJ5zRIANs/EsdX/yvq4j/eD+F6+7rnP9xDkQ9FX+s/v5w5SCO77T9twNberwnvP/xM7RqVp+8/JijGornn7z/jErOjxvrvP5ilkkdb/e8/HW14Vpf97z/pKvXJRv3vP+vb6y7N/O8/L1pZNTn77z8LE/I1pO/vP5O2ozfo1e8/2WbQuG2o7z8b9+a8MjbvP0zrolR2CO4/9fbs6weT6z8rpeEawpvnPwXfDxLPf+I/4bLS2MUr2j9ztJ0TIorQP/uzYUOOgsI/B6QczNQosj/nbB4KPtGeP0RosjFeJoY/lm65DwMFaj84pLsP7j1HP336QCpqChs/vLKEwkL35j5lt/KZpYCzPvS834o5j4A+hTEZVTMeTD4qD64lo94XPpJOfmG8QuQ9eS66HOYwsT0CmOGKiCJ9PdCQj+PN6Ug9sBhPukmFGz0RTnesAQAAAAAAAAAAgAAAAAAAACgDAAAAAAAAVgIAAAAAAAA=eF4V011ozXEYB/Df//3YG3thaLZahCnhwrRmnm8ktCJ1Rlkr2oWd8nKx1hqtf1prucDFSKZkCuUlMRfbUv8omYi8lKUYtXahrUax8+77nJtPz/me8/s/z/k9p8I2xiRiMPpKLEicdbQvhkEabojhE5WiGKod5rMBEjR6G2CEhg8DzFO5GKDWZX46QJxGBwIM0HBzgDEqZfyc5n98NHrMP/oYouGIjwyVyz5afeZdPsZp1OJjZcC83kcPleU+JqlJetgWYz7p4SoNxzz8pTLkoWUR87MeRmjU6qG0gPl2DyeoVHt4TU3exdpC5t9d9NEwcjFF5aaLhiLm51wM0uiYizka7nSxp5j5ahfD1HguMjSadnCohPlLB4+p3HFQspj5gIMOGh138JyGex1ULWFe56CLmkIH72n0y0ZdKfM3NvqpPLDxk5oLNnaUMT9po5uG+200Udlk45vmpTZ6aTRvoUa//8FCpOc/sXBUzx+0YOv5nRZu6fPjFnZR2Wphmn2aSgv9NPpnsE77/2LwSucbNejQ+a4ZFOh8PQb3dP4jBs1UGg1m+TuZVQZVlXw/nZe2Zayf5eXGUta9eZmqYC15qaWhlZf2ctYvcnJb5+jLyYz2vzsn67XvICcJ7XciK/e1z/NZmdP+mrOyUfsqzsop7eddRh5pH5cy8luffzAjW/TeyjPSqff5OS1Ped/hlbToHpjDaanXvViRlm7dl68pGeU+hddTkuKembaUNOje1aTkjO7jj6SM6x4PJyWr/4P2pDTp3q9JSq/FemZBIhLeXZD/7y/E5w==AQAAAAAAAAAAgAAAAAAAAHgJAAAAAAAAmwIAAAAAAAA=eF591FtI02Ech3FJKmchJutAgRdGsA4UVHS4sAPloQRrIBkoVBdGQaRBdLEirBxSIUssJcKIFh0gpROp0UGdacpMy+nUbLWVNtMyCosuzN6vlz3Qe/lB9v7f3/u8RkT8b31b/6+0D1akBB0F8LEJPw8/FCgYsldfhu8K6++vwX/uvmjWLfiMXv1OJbxoUXW8c+guvHni9x/Ao2648xKjq+CpOdq3Bl4431U/ansMzw/qe57Cw+mJ0X53LXz1En1nHedgWWGWB+4a0Pc3wB95bNmu+ufwgSs6VxM87rjZ1v4Cnpil8zbD96+xVqYEW+AXZmoOXnjtd4vfndcKH2nTfF7CZ1eMm9UGT0jS3NrhVfcd5oNewbclaJ70/nOjZkCv4UfHl5s5d8BjD5qx+enX+zR/H3xdmjlWfCfcV6N7oe+z7TWrC/6nVPflh5dMDpoD0xcf1j12w+tCWeZi6Jl23W8PfPhZl9m4F35yqe6dPrfcHNf5Bn5nmnrogyc7vGbRe8Pq5C08N9OM2RqAT21UP/TylWbb7HfwX251Re85o7m9h8/ZrN7oO8c0T3rZQ3UYhHflas70WQvVJ31HSPMPwUsvqVt6Z4a2pVtj9H/jAzyjSfdFL8lXbvSOtbrHj/C4H+qfbr+t+6UX5+hd9MPb482Y8+ix3Xov9O3F6mEA7tqqd0RvizTXW02PeaL39QmefkT90IuW6d3RvWF1RZ9+VV2F4WlZ6op+1mqOO0pvaVVXg3BLobqib9mgruinf6urz/Dme+qKHnVAXdFTF6irIXhhQF3RG8vUFX2KXV0Nw5OizbYOutOjrugNx9TVF3jkKnVF3zSiruinbqqrr3DPHnVFnzRPXdE3+tTVCPxEkbqi1yarK/pf1SGdig==AQAAAAAAAAAAgAAAAAAAAEAGAAAAAAAAvgAAAAAAAAA=eF5dxcciAgAAANAohOyZUhq2bLJ3yB4hiaz//waHnN67vECgrpGDHOImbuYWDnMrt3E7R7iDO7mLu7mHe7mP+3mAB3mIhznKIxzjOI9ygpM8xilOc4azPM4TPMlTPM0zPMtznON5XuBFXuJlXuFVXuN1zvMGb/IWb/MO7/Ie7/MBH/IRH/MJF/iUz/ici3zBl3zF13zDt3zH9/zAj1ziJ37mFy7zK1f4jav8zh9c40/+4m/+4V9u+P8PcvwndA==AQAAAAAAAAAAgAAAAAAAACADAAAAAAAAxwAAAAAAAAA=eF4txdFGAwAAAMAkmUwymUySSZIkmWQySZJJkiQzmSTJJEmSTJKZZJJJkkmSmSRJkkkm6bN62N3LNTc1tLjVAbc56HZ3OOROh93liLvd415H3ed+D3jQQx72iEcd85jHHfeEE570lKc941knPed5L3jRS172ilNOe9UZr3ndG970lrPe9o53ved9H/jQR8752Cc+dd4Fn/ncRV/40iVf+do3vnXZd773gx9dcdVPfvaLX/3md3/40zV/+dt1//jXf/4H8McndQ==AQAAAAAAAAAAgAAAAAAAAGQAAAAAAAAADAAAAAAAAAA=eF5jZqY9AAA7kgEt + + diff --git a/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_50_t_0.050000.vtu b/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_50_t_0.050000.vtu new file mode 100644 index 00000000000..be1b4503204 --- /dev/null +++ b/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_ts_50_t_0.050000.vtu @@ -0,0 +1,27 @@ + + + + + + + + + + + + + + + + + + + + + + + + + _AQAAAAAAAAAAgAAAAAAAABQAAAAAAAAAHAAAAAAAAAA=eF4z0zPRM9E1NLMw0E23NLBIMjNINgYALH8Eig==AQAAAAAAAAAAgAAAAAAAACgDAAAAAAAAFQMAAAAAAAA=eF5jYICAMivBv0rLJIwZiARx9/f7flTdaBequetP3McKu8Wbuyad38pkP92znPv2PDl7O+/POxIPetn//s5858KcVPvJd07PC+acbP9TQVx56vrp9pvqOn4d/XvZ3k++Y0nStWf2TZuUnOb/eGuvuSVs3bqj7+0v3XFpv/jzvf3iLBfLiP/v7R1Fy03fAenZCd9l/gFprvIjZ/4D6VcSE3+B6MMbcv6D6BMhH8H0bPd/YPpRkMPtv0D6zG6ZcyC+L8Mhja1A+u18dU5uIH3u+MTl/kB7zP4p6ye/em9ftYAzeWv6e/s+v+dhzU7v7VuC9jDJMj6zX3Dl3Tar4Ev2p42/v2O13mD/sUzuygqNWvvdyjdePdrpYd8QvTbv+g8R++M/7//uOPXQ7uDBuSm9BuvsLuUdtns7t9Luec+2jf/2uNp96smtn1YkZCfv7VXT7H/fVnFF/RajSats963rbUnpKbPdlctW56XkbNvKYnQ4xEbANoezb5dQ722bv7Z/ZN7GL7dx7TtoUX6l2GbZeZutHpccbBQk4yYHdvLYXM0u+frX+IZ1hc2xa5vblljHxjc1CmYUWmvu6Nsk0GprfTqcYeckdk7rDXemfu23uGq1uH/zovl/F1p1q7IvX9mQZ3VrSbO+121Lq5ZJvkFnXrFaTbn+IGDf5EuWU6b8fLiydr5l1C/Jx9M2ZFlOiTvOsn2emeWZ/dd8JmszW945O/0Jq/0FC3+X81ZqnbMtbt3oUN4emm4RdOWRo/sxY4u9vrmqtw4yWFgeM1ndkHbGvCUxI5ddcIZ50ZcHFVdSUsy/CxgpiHsYmi94UeF42/Ov2fFPHD+mXzxhZjL/iOgX9qlmVTWnJnpdSjQrrthRzGuiZ/bjeH8U94yfpqozdj6X33DU9OzsPKHzCZNM28zc2eeqxpvGXNKdezhFy3RyeaLt/NhvJguEfsje+HzI5FKK8+NM/gkm9U8Sn34xjzbh7HTeN1FA3WRPWbe3Z/dnY56urVei+g4Yc2z3PVXK3GNs+XzTEu4n4cYqPX4B4iJaxgA64oFZAQAAAAAAAAAAgAAAAAAAACgDAAAAAAAAVgIAAAAAAAA=eF4V011ozXEYB/Df//3YG3thaLZahCnhwrRmnm8ktCJ1Rlkr2oWd8nKx1hqtf1prucDFSKZkCuUlMRfbUv8omYi8lKUYtXahrUax8+77nJtPz/me8/s/z/k9p8I2xiRiMPpKLEicdbQvhkEabojhE5WiGKod5rMBEjR6G2CEhg8DzFO5GKDWZX46QJxGBwIM0HBzgDEqZfyc5n98NHrMP/oYouGIjwyVyz5afeZdPsZp1OJjZcC83kcPleU+JqlJetgWYz7p4SoNxzz8pTLkoWUR87MeRmjU6qG0gPl2DyeoVHt4TU3exdpC5t9d9NEwcjFF5aaLhiLm51wM0uiYizka7nSxp5j5ahfD1HguMjSadnCohPlLB4+p3HFQspj5gIMOGh138JyGex1ULWFe56CLmkIH72n0y0ZdKfM3NvqpPLDxk5oLNnaUMT9po5uG+200Udlk45vmpTZ6aTRvoUa//8FCpOc/sXBUzx+0YOv5nRZu6fPjFnZR2Wphmn2aSgv9NPpnsE77/2LwSucbNejQ+a4ZFOh8PQb3dP4jBs1UGg1m+TuZVQZVlXw/nZe2Zayf5eXGUta9eZmqYC15qaWhlZf2ctYvcnJb5+jLyYz2vzsn67XvICcJ7XciK/e1z/NZmdP+mrOyUfsqzsop7eddRh5pH5cy8luffzAjW/TeyjPSqff5OS1Ped/hlbToHpjDaanXvViRlm7dl68pGeU+hddTkuKembaUNOje1aTkjO7jj6SM6x4PJyWr/4P2pDTp3q9JSq/FemZBIhLeXZD/7y/E5w==AQAAAAAAAAAAgAAAAAAAAHgJAAAAAAAAmwIAAAAAAAA=eF591FtI02Ech3FJKmchJutAgRdGsA4UVHS4sAPloQRrIBkoVBdGQaRBdLEirBxSIUssJcKIFh0gpROp0UGdacpMy+nUbLWVNtMyCosuzN6vlz3Qe/lB9v7f3/u8RkT8b31b/6+0D1akBB0F8LEJPw8/FCgYsldfhu8K6++vwX/uvmjWLfiMXv1OJbxoUXW8c+guvHni9x/Ao2648xKjq+CpOdq3Bl4431U/ansMzw/qe57Cw+mJ0X53LXz1En1nHedgWWGWB+4a0Pc3wB95bNmu+ufwgSs6VxM87rjZ1v4Cnpil8zbD96+xVqYEW+AXZmoOXnjtd4vfndcKH2nTfF7CZ1eMm9UGT0jS3NrhVfcd5oNewbclaJ70/nOjZkCv4UfHl5s5d8BjD5qx+enX+zR/H3xdmjlWfCfcV6N7oe+z7TWrC/6nVPflh5dMDpoD0xcf1j12w+tCWeZi6Jl23W8PfPhZl9m4F35yqe6dPrfcHNf5Bn5nmnrogyc7vGbRe8Pq5C08N9OM2RqAT21UP/TylWbb7HfwX251Re85o7m9h8/ZrN7oO8c0T3rZQ3UYhHflas70WQvVJ31HSPMPwUsvqVt6Z4a2pVtj9H/jAzyjSfdFL8lXbvSOtbrHj/C4H+qfbr+t+6UX5+hd9MPb482Y8+ix3Xov9O3F6mEA7tqqd0RvizTXW02PeaL39QmefkT90IuW6d3RvWF1RZ9+VV2F4WlZ6op+1mqOO0pvaVVXg3BLobqib9mgruinf6urz/Dme+qKHnVAXdFTF6irIXhhQF3RG8vUFX2KXV0Nw5OizbYOutOjrugNx9TVF3jkKnVF3zSiruinbqqrr3DPHnVFnzRPXdE3+tTVCPxEkbqi1yarK/pf1SGdig==AQAAAAAAAAAAgAAAAAAAAEAGAAAAAAAAvgAAAAAAAAA=eF5dxcciAgAAANAohOyZUhq2bLJ3yB4hiaz//waHnN67vECgrpGDHOImbuYWDnMrt3E7R7iDO7mLu7mHe7mP+3mAB3mIhznKIxzjOI9ygpM8xilOc4azPM4TPMlTPM0zPMtznON5XuBFXuJlXuFVXuN1zvMGb/IWb/MO7/Ie7/MBH/IRH/MJF/iUz/ici3zBl3zF13zDt3zH9/zAj1ziJ37mFy7zK1f4jav8zh9c40/+4m/+4V9u+P8PcvwndA==AQAAAAAAAAAAgAAAAAAAACADAAAAAAAAxwAAAAAAAAA=eF4txdFGAwAAAMAkmUwymUySSZIkmWQySZJJkiQzmSTJJEmSTJKZZJJJkkmSmSRJkkkm6bN62N3LNTc1tLjVAbc56HZ3OOROh93liLvd415H3ed+D3jQQx72iEcd85jHHfeEE570lKc941knPed5L3jRS172ilNOe9UZr3ndG970lrPe9o53ved9H/jQR8752Cc+dd4Fn/ncRV/40iVf+do3vnXZd773gx9dcdVPfvaLX/3md3/40zV/+dt1//jXf/4H8McndQ==AQAAAAAAAAAAgAAAAAAAAGQAAAAAAAAADAAAAAAAAAA=eF5jZqY9AAA7kgEt + + From e2a11238a68999f29f26dee83bcfc5038fd1bfbe Mon Sep 17 00:00:00 2001 From: Haibing Shao Date: Sat, 2 Dec 2023 19:11:36 +0100 Subject: [PATCH 4/7] documentation of FCT feature fix spelling errors trim trailing whitespace fix markdownlint fix markdownlint avoid vale false error fix vale add limitation fix vale fix language issues break into separate lines improve benchmark doc --- .../fct_comp_t0.1_t0.5.png | Bin 0 -> 49483 bytes .../fct_comp_time_initial.png | Bin 0 -> 17863 bytes .../fct_comp_time_t1.png | Bin 0 -> 28835 bytes .../flux_corrected_transport/index.md | 82 ++++++++++++++++++ 4 files changed, 82 insertions(+) create mode 100644 web/content/docs/benchmarks/hydro-component/flux_corrected_transport/fct_comp_t0.1_t0.5.png create mode 100644 web/content/docs/benchmarks/hydro-component/flux_corrected_transport/fct_comp_time_initial.png create mode 100644 web/content/docs/benchmarks/hydro-component/flux_corrected_transport/fct_comp_time_t1.png create mode 100644 web/content/docs/benchmarks/hydro-component/flux_corrected_transport/index.md diff --git a/web/content/docs/benchmarks/hydro-component/flux_corrected_transport/fct_comp_t0.1_t0.5.png b/web/content/docs/benchmarks/hydro-component/flux_corrected_transport/fct_comp_t0.1_t0.5.png new file mode 100644 index 0000000000000000000000000000000000000000..6196d68071161cb6c9b149e81a099125f66e4910 GIT binary patch literal 49483 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 e}bI literal 0 HcmV?d00001 diff --git a/web/content/docs/benchmarks/hydro-component/flux_corrected_transport/fct_comp_time_initial.png b/web/content/docs/benchmarks/hydro-component/flux_corrected_transport/fct_comp_time_initial.png new file mode 100644 index 0000000000000000000000000000000000000000..8e644fe314c839f478c48749c71ea6bd15e941a5 GIT binary patch literal 17863 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 literal 0 HcmV?d00001 diff --git a/web/content/docs/benchmarks/hydro-component/flux_corrected_transport/index.md b/web/content/docs/benchmarks/hydro-component/flux_corrected_transport/index.md new file mode 100644 index 00000000000..ec4c6bc5846 --- /dev/null +++ b/web/content/docs/benchmarks/hydro-component/flux_corrected_transport/index.md @@ -0,0 +1,82 @@ ++++ +author = "Renchao Lu and Haibing Shao" +weight = 163 +project = ["Parabolic/ComponentTransport/FCT_test/1d_step_func.prj"] +date = "2023-11-28T11:30:09+01:00" +title = "Flux Corrected Transport (FCT)" +image = "fct_comp_time_t1.png" ++++ + +{{< data-link >}} + +## Motivation + +In many ComponentTransport or reactive transport applications, a common issue is the oscillation in the concentration profile, especially when a strong advection is applied versus the diffusion/dispersion. +Such oscillation is undesirable, particularly in the reactive transport process, as the resulting negative concentrations will not be accepted by chemical solvers. + +In order to mitigate this problem, the Flux Corrected Transport (FCT) feature is introduced as one of the numerical stabilization schemes. +The feature is implemented following two publications listed in the references. +This benchmark shows how to use the FCT feature and its effect on suppressing the oscillation. + +## Using the FCT feature + +By default, the FCT feature will NOT be applied. +To activate it, the user needs to define the type of numerical stabilization in the input file as follows. + +```xml + + + hc + ComponentTransport + 2 + staggered + + Cs_w_FCT + pressure + + 0 + + FluxCorrectedTransport + + + +``` + +Currently, the FCT scheme has been implemented in the ComponentTransport process only. +Another limitation is that the FCT scheme was not implemented to work with the MPI parallelization as of now. + +With the above configuration, FCT will take effect after the global mass (M) and conductance (K) matrices have been assembled. +The physical meaning is to modify the M and K matrices, so that only fluxes in the same direction as the concentration gradient are allowed. +This effectively suppresses the oscillation in the concentration profile, and also avoids negative concentration values. +On the other side, when FCT is applied, numerical dispersion will be introduced, as mass lumping in the M matrix has been applied. +Also, several non-linear iterations are expected, which might slow down the simulation. + +## Model configuration + +![Initial concentration distribution](fct_comp_time_initial.png) + +The benchmark domain is a 1-m long 1D column, discretized into 100 elements and 101 nodes. +The porosity of the column is set to 1.0. +The flow field is from left to right. +On the right end of the column, the pressure is set to 1e5 Pa. +On the left end, a fixed flux of 1e3 m3/sec is imposed, resulting in a Darcy velocity of 1 m/sec towards the right. +From 0.1 m to 0.3 m, the initial concentration of Cs is set to 1.0, producing a sharp gradient in the concentration profile (see above figure). +The dispersion and diffusion are both set to zero in the model, with the purpose to generate oscillation. +The benchmark runs from 0 to 0.5 seconds, with a fixed time step size of 0.001 seconds. + +## Model result + +![Comparison of analytical (black) and simulated concentration profile, with (blue) and without (red) FCT scheme, at 0.1 and 0.5 sec](fct_comp_t0.1_t0.5.png) + +The above figure compares the simulated concentration profiles with or without the FCT stabilization scheme at different times. +It is clearly shown that strong oscillation is present when FCT feature is turned off (red curve). +With the FCT stabilization (blue), the oscillation is suppressed, and all concentration values are non-negative. +It is also found that numerical dispersion, no matter FCT is applied or not, is always present when compared to the analytical profiles (black). + +## References + + + +Kuzmin, D., 2009. Explicit and implicit FEM-FCT algorithms with flux linearization. Journal of Computational Physics, Volume 228(7), 2517-2534. [doi](https://doi.org/10.1016/j.jcp.2008.12.011) + +Watanabe, N., and Kolditz, O., 2015. Numerical stability analysis of two-dimensional solute transport along a discrete fracture in a porous rock matrix, Water Resour. Res., 51, 5855–5868, [doi](https://doi.org/10.1002/2015WR017164). From ea0f1c7240e658bca0db68edd2d9efa03a31e1e7 Mon Sep 17 00:00:00 2001 From: Dmitri Naumov Date: Sat, 2 Dec 2023 19:11:36 +0100 Subject: [PATCH 5/7] [NL/FCT] Extract matrix creation Directly allocate matrix w/o using the matrix-vector-provider. --- .../FluxCorrectedTransport.h | 117 ++++++++---------- 1 file changed, 49 insertions(+), 68 deletions(-) diff --git a/NumLib/NumericalStability/FluxCorrectedTransport.h b/NumLib/NumericalStability/FluxCorrectedTransport.h index 341e86a60d1..54a41cb8bbd 100644 --- a/NumLib/NumericalStability/FluxCorrectedTransport.h +++ b/NumLib/NumericalStability/FluxCorrectedTransport.h @@ -12,6 +12,8 @@ #include #include +#include "MathLib/LinAlg/MatrixSpecifications.h" +#include "MathLib/LinAlg/MatrixVectorTraits.h" #include "NumericalStabilization.h" namespace NumLib @@ -19,6 +21,16 @@ namespace NumLib namespace detail { +template +std::unique_ptr newZeroedInstance( + MathLib::MatrixSpecifications const& matrix_specification) +{ + auto result = MathLib::MatrixVectorTraits::newInstance( + matrix_specification); + result->setZero(); + return result; +} + void calculateFluxCorrectedTransport( [[maybe_unused]] const double t, [[maybe_unused]] const double dt, [[maybe_unused]] std::vector const& x, @@ -29,14 +41,8 @@ void calculateFluxCorrectedTransport( [[maybe_unused]] GlobalVector& b) { #ifndef USE_PETSC - // declare and initialize the matrix D and F - std::size_t matrix_id = 0u; - auto& D = NumLib::GlobalMatrixProvider::provider.getMatrix( - matrix_specification, matrix_id); - auto& F = NumLib::GlobalMatrixProvider::provider.getMatrix( - matrix_specification, matrix_id); - D.setZero(); - F.setZero(); + auto D = newZeroedInstance(matrix_specification); + auto F = newZeroedInstance(matrix_specification); // compute artificial diffusion operator D using RawMatrixType = Eigen::SparseMatrix; @@ -51,11 +57,11 @@ void calculateFluxCorrectedTransport( double const kij = it.value(); double const kji = K.get(it.col(), it.row()); double const dij = std::max({-kij, 0., -kji}); - D.setValue(it.row(), it.col(), dij); + D->setValue(it.row(), it.col(), dij); } } } - auto& D_raw = D.getRawMatrix(); + auto& D_raw = D->getRawMatrix(); D_raw -= (D_raw * Eigen::VectorXd::Ones(D_raw.cols())).eval().asDiagonal(); // compute F @@ -67,7 +73,7 @@ void calculateFluxCorrectedTransport( double const xj = x[process_id]->get(it.col()); double const xi = x[process_id]->get(it.row()); double const fij = -dij * (xj - xi); - F.setValue(it.row(), it.col(), fij); + F->setValue(it.row(), it.col(), fij); } } @@ -84,31 +90,18 @@ void calculateFluxCorrectedTransport( x_prev[process_id]->get(it.row())) / dt; double const fij = -mij * (xdotj - xdoti); - F.add(it.row(), it.col(), fij); + F->add(it.row(), it.col(), fij); } } - auto& P_plus = - NumLib::GlobalVectorProvider::provider.getVector(matrix_specification); - auto& P_minus = - NumLib::GlobalVectorProvider::provider.getVector(matrix_specification); - auto& Q_plus = - NumLib::GlobalVectorProvider::provider.getVector(matrix_specification); - auto& Q_minus = - NumLib::GlobalVectorProvider::provider.getVector(matrix_specification); - auto& R_plus = - NumLib::GlobalVectorProvider::provider.getVector(matrix_specification); - auto& R_minus = - NumLib::GlobalVectorProvider::provider.getVector(matrix_specification); - - P_plus.setZero(); - P_minus.setZero(); - Q_plus.setZero(); - Q_minus.setZero(); - R_plus.setZero(); - R_minus.setZero(); - - auto& F_raw = F.getRawMatrix(); + auto P_plus = newZeroedInstance(matrix_specification); + auto P_minus = newZeroedInstance(matrix_specification); + auto Q_plus = newZeroedInstance(matrix_specification); + auto Q_minus = newZeroedInstance(matrix_specification); + auto R_plus = newZeroedInstance(matrix_specification); + auto R_minus = newZeroedInstance(matrix_specification); + + auto& F_raw = F->getRawMatrix(); for (int k = 0; k < F_raw.outerSize(); ++k) { for (RawMatrixType::InnerIterator it(F_raw, k); it; ++it) @@ -116,54 +109,52 @@ void calculateFluxCorrectedTransport( if (it.row() != it.col()) { double const fij = it.value(); - P_plus.add(it.row(), std::max(0., fij)); - P_minus.add(it.row(), std::min(0., fij)); + P_plus->add(it.row(), std::max(0., fij)); + P_minus->add(it.row(), std::min(0., fij)); double const x_prev_i = x_prev[process_id]->get(it.row()); double const x_prev_j = x_prev[process_id]->get(it.col()); - double const Q_plus_i = Q_plus.get(it.row()); + double const Q_plus_i = Q_plus->get(it.row()); double Q_plus_i_tmp = std::max({Q_plus_i, 0., x_prev_j - x_prev_i}); - Q_plus.set(it.row(), Q_plus_i_tmp); + Q_plus->set(it.row(), Q_plus_i_tmp); - double const Q_minus_i = Q_minus.get(it.row()); + double const Q_minus_i = Q_minus->get(it.row()); double Q_minus_i_tmp = std::min({Q_minus_i, 0., x_prev_j - x_prev_i}); - Q_minus.set(it.row(), Q_minus_i_tmp); + Q_minus->set(it.row(), Q_minus_i_tmp); } } } Eigen::VectorXd const M_L = (M_raw * Eigen::VectorXd::Ones(M_raw.cols())).eval(); - for (auto k = R_plus.getRangeBegin(); k < R_plus.getRangeEnd(); ++k) + for (auto k = R_plus->getRangeBegin(); k < R_plus->getRangeEnd(); ++k) { double const mi = M_L(k); - double const Q_plus_i = Q_plus.get(k); - double const P_plus_i = P_plus.get(k); + double const Q_plus_i = Q_plus->get(k); + double const P_plus_i = P_plus->get(k); double const tmp = P_plus_i == 0. ? 0.0 : std::min(1.0, mi * Q_plus_i / dt / P_plus_i); - R_plus.set(k, tmp); + R_plus->set(k, tmp); } - for (auto k = R_minus.getRangeBegin(); k < R_minus.getRangeEnd(); ++k) + for (auto k = R_minus->getRangeBegin(); k < R_minus->getRangeEnd(); ++k) { double const mi = M_L(k); - double const Q_minus_i = Q_minus.get(k); - double const P_minus_i = P_minus.get(k); + double const Q_minus_i = Q_minus->get(k); + double const P_minus_i = P_minus->get(k); double const tmp = P_minus_i == 0. ? 0.0 : std::min(1.0, mi * Q_minus_i / dt / P_minus_i); - R_minus.set(k, tmp); + R_minus->set(k, tmp); } - auto& alpha = NumLib::GlobalMatrixProvider::provider.getMatrix( - matrix_specification, matrix_id); - alpha.setZero(); + auto alpha = newZeroedInstance(matrix_specification); for (int k = 0; k < F_raw.outerSize(); ++k) { for (RawMatrixType::InnerIterator it(F_raw, k); it; ++it) @@ -171,19 +162,19 @@ void calculateFluxCorrectedTransport( double const fij = it.value(); if (fij > 0.) { - double const R_plus_i = R_plus.get(it.row()); - double const R_minus_j = R_minus.get(it.col()); + double const R_plus_i = R_plus->get(it.row()); + double const R_minus_j = R_minus->get(it.col()); double const alpha_ij = std::min(R_plus_i, R_minus_j); - alpha.setValue(it.row(), it.col(), alpha_ij); + alpha->setValue(it.row(), it.col(), alpha_ij); } else { - double const R_minus_i = R_minus.get(it.row()); - double const R_plus_j = R_plus.get(it.col()); + double const R_minus_i = R_minus->get(it.row()); + double const R_plus_j = R_plus->get(it.col()); double const alpha_ij = std::min(R_minus_i, R_plus_j); - alpha.setValue(it.row(), it.col(), alpha_ij); + alpha->setValue(it.row(), it.col(), alpha_ij); } } } @@ -196,7 +187,7 @@ void calculateFluxCorrectedTransport( if (it.row() != it.col()) { double const fij = it.value(); - double const alpha_ij = alpha.get(it.row(), it.col()); + double const alpha_ij = alpha->get(it.row(), it.col()); b.add(it.row(), alpha_ij * fij); } @@ -213,16 +204,6 @@ void calculateFluxCorrectedTransport( { M.setValue(k, k, M_L(k)); } - - NumLib::GlobalVectorProvider::provider.releaseVector(P_plus); - NumLib::GlobalVectorProvider::provider.releaseVector(P_minus); - NumLib::GlobalVectorProvider::provider.releaseVector(Q_plus); - NumLib::GlobalVectorProvider::provider.releaseVector(Q_minus); - NumLib::GlobalVectorProvider::provider.releaseVector(R_plus); - NumLib::GlobalVectorProvider::provider.releaseVector(R_minus); - NumLib::GlobalMatrixProvider::provider.releaseMatrix(alpha); - NumLib::GlobalMatrixProvider::provider.releaseMatrix(D); - NumLib::GlobalMatrixProvider::provider.releaseMatrix(F); #endif // end of ifndef USE_PETSC } } // namespace detail @@ -249,4 +230,4 @@ inline void computeFluxCorrectedTransport( }, stabilizer); } -} // namespace NumLib \ No newline at end of file +} // namespace NumLib From 4fc3886c87e2b66a8da1ad557cb750614a8337f6 Mon Sep 17 00:00:00 2001 From: Haibing Shao Date: Sat, 2 Dec 2023 19:11:36 +0100 Subject: [PATCH 6/7] [T] benchmark of FCT feature change output prefix update results remove LIS and PETSc config switch on vtkdiff in OgsTest --- .../FCT_test/1d_step_func_wo_FCT.prj | 266 ++++++++++++++++++ 1 file changed, 266 insertions(+) create mode 100644 Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_wo_FCT.prj diff --git a/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_wo_FCT.prj b/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_wo_FCT.prj new file mode 100644 index 00000000000..9b813605a2c --- /dev/null +++ b/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_wo_FCT.prj @@ -0,0 +1,266 @@ + + + + 1d_step_func.vtu + 1d_step_func_inlet.vtu + 1d_step_func_outlet.vtu + + + + hc + ComponentTransport + 2 + staggered + + Cs_wo_FCT + pressure + + 0 + + + + + + + AqueousLiquid + + + Cs_wo_FCT + + + pore_diffusion + Constant + 0 + + + retardation_factor + Constant + 1 + + + decay_rate + Parameter + decay + + + + + + + density + Constant + 1e3 + + + viscosity + Constant + 1e-3 + + + + + + + permeability + Parameter + kappa + + + porosity + Parameter + porosity + + + longitudinal_dispersivity + Constant + 0 + + + transversal_dispersivity + Constant + 0 + + + + + + + 6 + + + + DeltaX + NORM2 + 1e-8 + + + + DeltaX + NORM2 + 1e-8 + + + + + + + basic_picard + + DeltaX + NORM2 + 1e-8 + + + BackwardEuler + + + FixedTimeStepping + 0.0 + 0.5 + + + 500 + 0.001 + + + + + + + basic_picard + + DeltaX + NORM2 + 1e-10 + + + BackwardEuler + + + FixedTimeStepping + 0.0 + 0.5 + + + 500 + 0.001 + + + + + + + VTK + 1d_step_func_wo_FCT + + + 10 + 50 + + + + Cs_wo_FCT + pressure + darcy_velocity + + _ts_{:timestep}_t_{:time} + + + + + kappa + Constant + 1.0e-8 + + + porosity + Constant + 1 + + + retardation + Constant + + 1 + + + decay + Constant + 0 + + + p0 + Constant + 1e5 + + + p_Neumann_left + Constant + 1e3 + + + c0 + MeshNode + 1d_step_func + c_ini + + + c_inlet + Constant + 0 + + + + + pressure + 1 + 1 + p0 + + + 1d_step_func_inlet + Neumann + p_Neumann_left + + + 1d_step_func_outlet + Dirichlet + p0 + + + + + Cs_wo_FCT + 1 + 1 + c0 + + + 1d_step_func_inlet + Dirichlet + c_inlet + + + + + + + basic_picard + Picard + 50 + general_linear_solver + + + + + general_linear_solver + + + BiCGSTAB + ILUT + 1000 + 1e-14 + + + + From c04d54d1730fcbf0658a4e2b8f7efeb164dc5a9f Mon Sep 17 00:00:00 2001 From: Haibing Shao Date: Sat, 2 Dec 2023 19:11:36 +0100 Subject: [PATCH 7/7] remove no_fct prj file --- .../FCT_test/1d_step_func.prj | 1 + .../FCT_test/1d_step_func_wo_FCT.prj | 266 ------------------ 2 files changed, 1 insertion(+), 266 deletions(-) delete mode 100644 Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_wo_FCT.prj diff --git a/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func.prj b/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func.prj index 69e99fd7679..b3fec102131 100644 --- a/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func.prj +++ b/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func.prj @@ -16,6 +16,7 @@ pressure 0 + FluxCorrectedTransport diff --git a/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_wo_FCT.prj b/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_wo_FCT.prj deleted file mode 100644 index 9b813605a2c..00000000000 --- a/Tests/Data/Parabolic/ComponentTransport/FCT_test/1d_step_func_wo_FCT.prj +++ /dev/null @@ -1,266 +0,0 @@ - - - - 1d_step_func.vtu - 1d_step_func_inlet.vtu - 1d_step_func_outlet.vtu - - - - hc - ComponentTransport - 2 - staggered - - Cs_wo_FCT - pressure - - 0 - - - - - - - AqueousLiquid - - - Cs_wo_FCT - - - pore_diffusion - Constant - 0 - - - retardation_factor - Constant - 1 - - - decay_rate - Parameter - decay - - - - - - - density - Constant - 1e3 - - - viscosity - Constant - 1e-3 - - - - - - - permeability - Parameter - kappa - - - porosity - Parameter - porosity - - - longitudinal_dispersivity - Constant - 0 - - - transversal_dispersivity - Constant - 0 - - - - - - - 6 - - - - DeltaX - NORM2 - 1e-8 - - - - DeltaX - NORM2 - 1e-8 - - - - - - - basic_picard - - DeltaX - NORM2 - 1e-8 - - - BackwardEuler - - - FixedTimeStepping - 0.0 - 0.5 - - - 500 - 0.001 - - - - - - - basic_picard - - DeltaX - NORM2 - 1e-10 - - - BackwardEuler - - - FixedTimeStepping - 0.0 - 0.5 - - - 500 - 0.001 - - - - - - - VTK - 1d_step_func_wo_FCT - - - 10 - 50 - - - - Cs_wo_FCT - pressure - darcy_velocity - - _ts_{:timestep}_t_{:time} - - - - - kappa - Constant - 1.0e-8 - - - porosity - Constant - 1 - - - retardation - Constant - - 1 - - - decay - Constant - 0 - - - p0 - Constant - 1e5 - - - p_Neumann_left - Constant - 1e3 - - - c0 - MeshNode - 1d_step_func - c_ini - - - c_inlet - Constant - 0 - - - - - pressure - 1 - 1 - p0 - - - 1d_step_func_inlet - Neumann - p_Neumann_left - - - 1d_step_func_outlet - Dirichlet - p0 - - - - - Cs_wo_FCT - 1 - 1 - c0 - - - 1d_step_func_inlet - Dirichlet - c_inlet - - - - - - - basic_picard - Picard - 50 - general_linear_solver - - - - - general_linear_solver - - - BiCGSTAB - ILUT - 1000 - 1e-14 - - - -