diff --git a/NumLib/DOF/MatrixProviderUser.h b/NumLib/DOF/MatrixProviderUser.h
index c0d3c9cccdc58b057ac1841cbf0ea6ea4f876543..f12f7b8dadc92607ec16b3f9baf2bb4e2b815f86 100644
--- a/NumLib/DOF/MatrixProviderUser.h
+++ b/NumLib/DOF/MatrixProviderUser.h
@@ -20,7 +20,7 @@ class MatrixSpecificationsProvider
{
public:
virtual MathLib::MatrixSpecifications getMatrixSpecifications(
- const int equation_id) const = 0;
+ const int process_id) const = 0;
virtual ~MatrixSpecificationsProvider() = default;
};
diff --git a/NumLib/ODESolver/TimeDiscretizedODESystem.cpp b/NumLib/ODESolver/TimeDiscretizedODESystem.cpp
index eaad9a12bf878aa54deed3cf6d4181989c819d10..5c597a88e5f55e557feb2cf37291a4d7d642ae02 100644
--- a/NumLib/ODESolver/TimeDiscretizedODESystem.cpp
+++ b/NumLib/ODESolver/TimeDiscretizedODESystem.cpp
@@ -40,20 +40,20 @@ namespace NumLib
{
TimeDiscretizedODESystem<ODESystemTag::FirstOrderImplicitQuasilinear,
NonlinearSolverTag::Newton>::
- TimeDiscretizedODESystem(const int equation_id,
+ TimeDiscretizedODESystem(const int process_id,
ODE& ode, TimeDisc& time_discretization)
: _ode(ode),
_time_disc(time_discretization),
_mat_trans(createMatrixTranslator<ODETag>(time_discretization))
{
_Jac = &NumLib::GlobalMatrixProvider::provider.getMatrix(
- _ode.getMatrixSpecifications(equation_id), _Jac_id);
+ _ode.getMatrixSpecifications(process_id), _Jac_id);
_M = &NumLib::GlobalMatrixProvider::provider.getMatrix(
- _ode.getMatrixSpecifications(equation_id), _M_id);
+ _ode.getMatrixSpecifications(process_id), _M_id);
_K = &NumLib::GlobalMatrixProvider::provider.getMatrix(
- _ode.getMatrixSpecifications(equation_id), _K_id);
+ _ode.getMatrixSpecifications(process_id), _K_id);
_b = &NumLib::GlobalVectorProvider::provider.getVector(
- _ode.getMatrixSpecifications(equation_id), _b_id);
+ _ode.getMatrixSpecifications(process_id), _b_id);
}
TimeDiscretizedODESystem<
@@ -153,18 +153,18 @@ void TimeDiscretizedODESystem<ODESystemTag::FirstOrderImplicitQuasilinear,
TimeDiscretizedODESystem<ODESystemTag::FirstOrderImplicitQuasilinear,
NonlinearSolverTag::Picard>::
- TimeDiscretizedODESystem(const int equation_id, ODE& ode,
+ TimeDiscretizedODESystem(const int process_id, ODE& ode,
TimeDisc& time_discretization)
: _ode(ode),
_time_disc(time_discretization),
_mat_trans(createMatrixTranslator<ODETag>(time_discretization))
{
_M = &NumLib::GlobalMatrixProvider::provider.getMatrix(
- ode.getMatrixSpecifications(equation_id), _M_id);
+ ode.getMatrixSpecifications(process_id), _M_id);
_K = &NumLib::GlobalMatrixProvider::provider.getMatrix(
- ode.getMatrixSpecifications(equation_id), _K_id);
+ ode.getMatrixSpecifications(process_id), _K_id);
_b = &NumLib::GlobalVectorProvider::provider.getVector(
- ode.getMatrixSpecifications(equation_id), _b_id);
+ ode.getMatrixSpecifications(process_id), _b_id);
}
TimeDiscretizedODESystem<
diff --git a/NumLib/ODESolver/TimeDiscretizedODESystem.h b/NumLib/ODESolver/TimeDiscretizedODESystem.h
index 68ec900cad00d81ef992d5fee1e7e7cf476c933b..0533c66334712996eedd298ea379b02e0003a7a5 100644
--- a/NumLib/ODESolver/TimeDiscretizedODESystem.h
+++ b/NumLib/ODESolver/TimeDiscretizedODESystem.h
@@ -73,11 +73,11 @@ public:
/*! Constructs a new instance.
*
- * \param equation_id ID of the ODE to be solved.
+ * \param process_id ID of the ODE to be solved.
* \param ode the ODE to be wrapped.
* \param time_discretization the time discretization to be used.
*/
- explicit TimeDiscretizedODESystem(const int equation_id, ODE& ode,
+ explicit TimeDiscretizedODESystem(const int process_id, ODE& ode,
TimeDisc& time_discretization);
~TimeDiscretizedODESystem() override;
@@ -116,9 +116,9 @@ public:
TimeDisc& getTimeDiscretization() override { return _time_disc; }
MathLib::MatrixSpecifications getMatrixSpecifications(
- const int equation_id) const override
+ const int process_id) const override
{
- return _ode.getMatrixSpecifications(equation_id);
+ return _ode.getMatrixSpecifications(process_id);
}
private:
@@ -171,7 +171,7 @@ public:
* \param ode the ODE to be wrapped.
* \param time_discretization the time discretization to be used.
*/
- explicit TimeDiscretizedODESystem(const int equation_id, ODE& ode,
+ explicit TimeDiscretizedODESystem(const int process_id, ODE& ode,
TimeDisc& time_discretization);
~TimeDiscretizedODESystem() override;
@@ -215,9 +215,9 @@ public:
TimeDisc& getTimeDiscretization() override { return _time_disc; }
MathLib::MatrixSpecifications getMatrixSpecifications(
- const int equation_id) const override
+ const int process_id) const override
{
- return _ode.getMatrixSpecifications(equation_id);
+ return _ode.getMatrixSpecifications(process_id);
}
private:
diff --git a/ProcessLib/HydroMechanics/HydroMechanicsProcess-impl.h b/ProcessLib/HydroMechanics/HydroMechanicsProcess-impl.h
index 97a80e0b9715efc889b923c0e1412f54c93e0a61..07c3a78e3b1ab9b82d164ccd10dfc718b6b19142 100644
--- a/ProcessLib/HydroMechanics/HydroMechanicsProcess-impl.h
+++ b/ProcessLib/HydroMechanics/HydroMechanicsProcess-impl.h
@@ -233,22 +233,22 @@ void HydroMechanicsProcess<DisplacementDim>::initializeBoundaryConditions()
{
if (_use_monolithic_scheme)
{
- const int equation_id_of_up = 0;
+ const int process_id_of_up = 0;
initializeProcessBoundaryCondition(*_local_to_global_index_map,
- equation_id_of_up);
+ process_id_of_up);
return;
}
// Staggered scheme:
// for the equations of pressure
- const int equation_id_of_p = 0;
+ const int process_id_of_p = 0;
initializeProcessBoundaryCondition(
- *_local_to_global_index_map_with_base_nodes, equation_id_of_p);
+ *_local_to_global_index_map_with_base_nodes, process_id_of_p);
// for the equations of deformation.
- const int equation_id_of_u = 1;
+ const int process_id_of_u = 1;
initializeProcessBoundaryCondition(*_local_to_global_index_map,
- equation_id_of_u);
+ process_id_of_u);
}
template <int DisplacementDim>
diff --git a/ProcessLib/Process.cpp b/ProcessLib/Process.cpp
index d332dd9048627084bc4dc1803dca6b75009a4de3..217be2524953a0795e94d81ae50d519df4c38580 100644
--- a/ProcessLib/Process.cpp
+++ b/ProcessLib/Process.cpp
@@ -167,7 +167,7 @@ void Process::setInitialConditions(const int process_id, double const t,
}
MathLib::MatrixSpecifications Process::getMatrixSpecifications(
- const int /*equation_id*/) const
+ const int /*process_id*/) const
{
auto const& l = *_local_to_global_index_map;
return {l.dofSizeWithoutGhosts(), l.dofSizeWithoutGhosts(),
diff --git a/ProcessLib/Process.h b/ProcessLib/Process.h
index 546780f9e9ff49e0c0f65b70e2172825c5acde75..7074ccadf242c5dbcb250176089d570e9daaaf89 100644
--- a/ProcessLib/Process.h
+++ b/ProcessLib/Process.h
@@ -79,7 +79,7 @@ public:
GlobalVector& x);
virtual MathLib::MatrixSpecifications getMatrixSpecifications(
- const int equation_id) const override;
+ const int process_id) const override;
void setCoupledSolutionsForStaggeredScheme(
CoupledSolutionsForStaggeredScheme* const coupled_solutions)
diff --git a/ProcessLib/UncoupledProcessesTimeLoop.cpp b/ProcessLib/UncoupledProcessesTimeLoop.cpp
index cb08c01047c907656600846ac4b212f29ac219cb..479fc1d48d9451d21e84e19684858974fc94167d 100644
--- a/ProcessLib/UncoupledProcessesTimeLoop.cpp
+++ b/ProcessLib/UncoupledProcessesTimeLoop.cpp
@@ -128,7 +128,7 @@ struct SingleProcessData
/// Process ID. It is alway 0 when the monolithic scheme is used or
/// a single process is modelled.
- int equation_id = 0;
+ int process_id = 0;
Process& process;
ProcessOutput process_output;
@@ -187,7 +187,7 @@ void setTimeDiscretizedODESystem(
spd.tdisc_ode_sys = std::make_unique<
NumLib::TimeDiscretizedODESystem<ODETag, Tag::Picard>>(
- spd.equation_id, ode_sys, *spd.time_disc);
+ spd.process_id, ode_sys, *spd.time_disc);
}
else if (dynamic_cast<NonlinearSolverNewton*>(&spd.nonlinear_solver))
{
@@ -198,7 +198,7 @@ void setTimeDiscretizedODESystem(
{
spd.tdisc_ode_sys = std::make_unique<
NumLib::TimeDiscretizedODESystem<ODETag, Tag::Newton>>(
- spd.equation_id, *ode_newton, *spd.time_disc);
+ spd.process_id, *ode_newton, *spd.time_disc);
}
else
{
@@ -385,7 +385,7 @@ std::vector<GlobalVector*> setInitialConditions(
{
std::vector<GlobalVector*> process_solutions;
- int pcs_idx = 0;
+ int process_id = 0;
for (auto& spd : per_process_data)
{
auto& pcs = spd->process;
@@ -397,10 +397,10 @@ std::vector<GlobalVector*> setInitialConditions(
// append a solution vector of suitable size
process_solutions.emplace_back(
&NumLib::GlobalVectorProvider::provider.getVector(
- ode_sys.getMatrixSpecifications(pcs_idx)));
+ ode_sys.getMatrixSpecifications(process_id)));
- auto& x0 = *process_solutions[pcs_idx];
- pcs.setInitialConditions(pcs_idx, t0, x0);
+ auto& x0 = *process_solutions[process_id];
+ pcs.setInitialConditions(process_id, t0, x0);
MathLib::LinAlg::finalizeAssembly(x0);
time_disc.setInitialState(t0, x0); // push IC
@@ -418,7 +418,7 @@ std::vector<GlobalVector*> setInitialConditions(
mat_strg); // TODO: that might do duplicate work
}
- ++pcs_idx;
+ ++process_id;
}
return process_solutions;
@@ -493,9 +493,10 @@ bool UncoupledProcessesTimeLoop::setCoupledSolutions()
}
_solutions_of_coupled_processes.reserve(_per_process_data.size());
- for (unsigned pcs_idx = 0; pcs_idx < _per_process_data.size(); pcs_idx++)
+ for (unsigned process_id = 0; process_id < _per_process_data.size();
+ process_id++)
{
- auto const& x = *_process_solutions[pcs_idx];
+ auto const& x = *_process_solutions[process_id];
_solutions_of_coupled_processes.emplace_back(x);
// Create a vector to store the solution of the last coupling iteration
@@ -673,23 +674,24 @@ bool UncoupledProcessesTimeLoop::loop()
{
// initialize output, convergence criterion, etc.
{
- unsigned pcs_idx = 0;
+ unsigned process_id = 0;
for (auto& spd : _per_process_data)
{
auto& pcs = spd->process;
- _output->addProcess(pcs, pcs_idx);
+ _output->addProcess(pcs, process_id);
- spd->equation_id = pcs_idx;
+ spd->process_id = process_id;
setTimeDiscretizedODESystem(*spd);
if (auto* conv_crit =
dynamic_cast<NumLib::ConvergenceCriterionPerComponent*>(
spd->conv_crit.get()))
{
- conv_crit->setDOFTable(pcs.getDOFTable(pcs_idx), pcs.getMesh());
+ conv_crit->setDOFTable(pcs.getDOFTable(process_id),
+ pcs.getMesh());
}
- ++pcs_idx;
+ ++process_id;
}
}
@@ -804,40 +806,40 @@ bool UncoupledProcessesTimeLoop::solveUncoupledEquationSystems(
const double t, const double dt, const std::size_t timestep_id)
{
// TODO(wenqing): use process name
- unsigned pcs_idx = 0;
+ unsigned process_id = 0;
for (auto& spd : _per_process_data)
{
if (spd->skip_time_stepping)
{
- INFO("Process %u is skipped in the time stepping.", pcs_idx);
- ++pcs_idx;
+ INFO("Process %u is skipped in the time stepping.", process_id);
+ ++process_id;
continue;
}
BaseLib::RunTime time_timestep_process;
time_timestep_process.start();
- auto& x = *_process_solutions[pcs_idx];
+ auto& x = *_process_solutions[process_id];
auto& pcs = spd->process;
- pcs.preTimestep(x, t, dt, pcs_idx);
+ pcs.preTimestep(x, t, dt, process_id);
const auto nonlinear_solver_succeeded = solveOneTimeStepOneProcess(
- pcs_idx, x, timestep_id, t, dt, *spd, *_output);
+ process_id, x, timestep_id, t, dt, *spd, *_output);
spd->nonlinear_solver_converged = nonlinear_solver_succeeded;
- pcs.postTimestep(x, pcs_idx);
+ pcs.postTimestep(x, process_id);
pcs.computeSecondaryVariable(t, x);
- INFO("[time] Solving process #%u took %g s in time step #%u ", pcs_idx,
- time_timestep_process.elapsed(), timestep_id);
+ INFO("[time] Solving process #%u took %g s in time step #%u ",
+ process_id, time_timestep_process.elapsed(), timestep_id);
if (!nonlinear_solver_succeeded)
{
ERR("The nonlinear solver failed in time step #%u at t = %g "
"s for process #%u.",
- timestep_id, t, pcs_idx);
+ timestep_id, t, process_id);
// save unsuccessful solution
- _output->doOutputAlways(pcs, pcs_idx, spd->process_output,
+ _output->doOutputAlways(pcs, process_id, spd->process_output,
timestep_id, t, x);
if (!spd->timestepper->isSolutionErrorComputationNeeded())
@@ -848,9 +850,10 @@ bool UncoupledProcessesTimeLoop::solveUncoupledEquationSystems(
return false;
}
- _output->doOutput(pcs, pcs_idx, spd->process_output, timestep_id, t, x);
+ _output->doOutput(pcs, process_id, spd->process_output, timestep_id, t,
+ x);
- ++pcs_idx;
+ ++process_id;
} // end of for (auto& spd : _per_process_data)
return true;
@@ -883,43 +886,43 @@ bool UncoupledProcessesTimeLoop::solveCoupledEquationSystemsByStaggeredScheme(
// TODO(wenqing): use process name
bool nonlinear_solver_succeeded = true;
coupling_iteration_converged = true;
- unsigned pcs_idx = 0;
+ unsigned process_id = 0;
for (auto& spd : _per_process_data)
{
if (spd->skip_time_stepping)
{
- INFO("Process %u is skipped in the time stepping.", pcs_idx);
- ++pcs_idx;
+ INFO("Process %u is skipped in the time stepping.", process_id);
+ ++process_id;
continue;
}
BaseLib::RunTime time_timestep_process;
time_timestep_process.start();
- auto& x = *_process_solutions[pcs_idx];
+ auto& x = *_process_solutions[process_id];
if (global_coupling_iteration == 0)
{
// Copy the solution of the previous time step to a vector that
// belongs to process. For some problems, both of the current
// solution and the solution of the previous time step are
// required for the coupling computation.
- spd->process.preTimestep(x, t, dt, pcs_idx);
+ spd->process.preTimestep(x, t, dt, process_id);
}
CoupledSolutionsForStaggeredScheme coupled_solutions(
- _solutions_of_coupled_processes, dt, pcs_idx);
+ _solutions_of_coupled_processes, dt, process_id);
spd->process.setCoupledSolutionsForStaggeredScheme(
&coupled_solutions);
const auto nonlinear_solver_succeeded = solveOneTimeStepOneProcess(
- pcs_idx, x, timestep_id, t, dt, *spd, *_output);
+ process_id, x, timestep_id, t, dt, *spd, *_output);
spd->nonlinear_solver_converged = nonlinear_solver_succeeded;
INFO(
"[time] Solving process #%u took %g s in time step #%u "
" coupling iteration #%u",
- pcs_idx, time_timestep_process.elapsed(), timestep_id,
+ process_id, time_timestep_process.elapsed(), timestep_id,
global_coupling_iteration);
if (!nonlinear_solver_succeeded)
@@ -927,10 +930,10 @@ bool UncoupledProcessesTimeLoop::solveCoupledEquationSystemsByStaggeredScheme(
ERR("The nonlinear solver failed in time step #%u at t = %g "
"s"
" for process #%u.",
- timestep_id, t, pcs_idx);
+ timestep_id, t, process_id);
// save unsuccessful solution
- _output->doOutputAlways(spd->process, pcs_idx,
+ _output->doOutputAlways(spd->process, process_id,
spd->process_output, timestep_id, t, x);
if (!spd->timestepper->isSolutionErrorComputationNeeded())
@@ -942,14 +945,14 @@ bool UncoupledProcessesTimeLoop::solveCoupledEquationSystemsByStaggeredScheme(
}
// Check the convergence of the coupling iteration
- auto& x_old = *_solutions_of_last_cpl_iteration[pcs_idx];
+ auto& x_old = *_solutions_of_last_cpl_iteration[process_id];
if (global_coupling_iteration > 0)
{
- MathLib::LinAlg::axpy(x_old, -1.0, x); // save dx to x_old
- _global_coupling_conv_crit[pcs_idx]->checkDeltaX(x_old, x);
+ MathLib::LinAlg::axpy(x_old, -1.0, x); // save dx to x_old
+ _global_coupling_conv_crit[process_id]->checkDeltaX(x_old, x);
coupling_iteration_converged =
coupling_iteration_converged &&
- _global_coupling_conv_crit[pcs_idx]->isSatisfied();
+ _global_coupling_conv_crit[process_id]->isSatisfied();
}
MathLib::LinAlg::copy(x, x_old);
@@ -958,7 +961,7 @@ bool UncoupledProcessesTimeLoop::solveCoupledEquationSystemsByStaggeredScheme(
break;
}
- ++pcs_idx;
+ ++process_id;
} // end of for (auto& spd : _per_process_data)
if (coupling_iteration_converged && global_coupling_iteration > 0)
@@ -980,20 +983,20 @@ bool UncoupledProcessesTimeLoop::solveCoupledEquationSystemsByStaggeredScheme(
timestep_id, t);
}
- unsigned pcs_idx = 0;
+ unsigned process_id = 0;
for (auto& spd : _per_process_data)
{
if (spd->skip_time_stepping)
{
- ++pcs_idx;
+ ++process_id;
continue;
}
auto& pcs = spd->process;
- auto& x = *_process_solutions[pcs_idx];
- pcs.postTimestep(x, pcs_idx);
+ auto& x = *_process_solutions[process_id];
+ pcs.postTimestep(x, process_id);
pcs.computeSecondaryVariable(t, x);
- ++pcs_idx;
+ ++process_id;
}
{
@@ -1012,7 +1015,7 @@ void UncoupledProcessesTimeLoop::outputSolutions(
unsigned timestep, const double t, OutputClass& output_object,
OutputClassMember output_class_member) const
{
- unsigned pcs_idx = 0;
+ unsigned process_id = 0;
for (auto& spd : _per_process_data)
{
auto& pcs = spd->process;
@@ -1020,35 +1023,35 @@ void UncoupledProcessesTimeLoop::outputSolutions(
// saved.
if ((!spd->nonlinear_solver_converged) || spd->skip_time_stepping)
{
- ++pcs_idx;
+ ++process_id;
continue;
}
- auto const& x = *_process_solutions[pcs_idx];
+ auto const& x = *_process_solutions[process_id];
if (output_initial_condition)
{
pcs.preTimestep(x, _start_time,
- spd->timestepper->getTimeStep().dt(), pcs_idx);
+ spd->timestepper->getTimeStep().dt(), process_id);
}
if (is_staggered_coupling)
{
CoupledSolutionsForStaggeredScheme coupled_solutions(
- _solutions_of_coupled_processes, 0.0, pcs_idx);
+ _solutions_of_coupled_processes, 0.0, process_id);
spd->process.setCoupledSolutionsForStaggeredScheme(
&coupled_solutions);
spd->process.setCoupledTermForTheStaggeredSchemeToLocalAssemblers();
(output_object.*output_class_member)(
- pcs, pcs_idx, spd->process_output, timestep, t, x);
+ pcs, process_id, spd->process_output, timestep, t, x);
}
else
{
(output_object.*output_class_member)(
- pcs, pcs_idx, spd->process_output, timestep, t, x);
+ pcs, process_id, spd->process_output, timestep, t, x);
}
- ++pcs_idx;
+ ++process_id;
}
}
diff --git a/Tests/NumLib/ODEs.h b/Tests/NumLib/ODEs.h
index b270f5241dec6b03fb6dfa6bd9ca79459b0cb319..cd12d81fd52e00347a5b25fca1cede671843fc3b 100644
--- a/Tests/NumLib/ODEs.h
+++ b/Tests/NumLib/ODEs.h
@@ -59,7 +59,7 @@ public:
}
MathLib::MatrixSpecifications getMatrixSpecifications(
- const int /*equation_id*/) const override
+ const int /*process_id*/) const override
{
return { N, N, nullptr, nullptr };
}
@@ -143,7 +143,7 @@ public:
}
MathLib::MatrixSpecifications getMatrixSpecifications(
- const int /*equation_id*/) const override
+ const int /*process_id*/) const override
{
return { N, N, nullptr, nullptr };
}
@@ -270,7 +270,7 @@ public:
}
MathLib::MatrixSpecifications getMatrixSpecifications(
- const int /*equation_id*/) const override
+ const int /*process_id*/) const override
{
return { N, N, nullptr, nullptr };
}
diff --git a/Tests/NumLib/TestODEInt.cpp b/Tests/NumLib/TestODEInt.cpp
index ca936a30a538d964bb796e1bfbceb3dcf68ddb76..396ab73532d554a052311e765d6d082e30243870 100644
--- a/Tests/NumLib/TestODEInt.cpp
+++ b/Tests/NumLib/TestODEInt.cpp
@@ -68,9 +68,9 @@ public:
Solution sol;
- const int equation_id = 0;
+ const int process_id = 0;
NumLib::TimeDiscretizedODESystem<ODE_::ODETag, NLTag>
- ode_sys(equation_id, ode, timeDisc);
+ ode_sys(process_id, ode, timeDisc);
auto linear_solver = createLinearSolver();
auto conv_crit = std::make_unique<NumLib::ConvergenceCriterionDeltaX>(
@@ -91,7 +91,7 @@ public:
delta_t);
// initial condition
- GlobalVector x0(ode.getMatrixSpecifications(equation_id).nrows);
+ GlobalVector x0(ode.getMatrixSpecifications(process_id).nrows);
ODET::setIC(x0);
sol.ts.push_back(t0);