From dc1fcce7e60fa715cda00ea4bf3a0d6e773d190c Mon Sep 17 00:00:00 2001
From: Dmitri Naumov <dmitri.naumov@ufz.de>
Date: Mon, 23 Sep 2019 18:06:44 +0200
Subject: [PATCH] [PL] Use process_id from process_data, not local.
Avoid local variables `process_id' when looping over
all processes.
Move numbering of the processes to the ProcessData ctor.
---
ProcessLib/CreateProcessData.cpp | 13 ++++---
ProcessLib/ProcessData.h | 7 ++--
ProcessLib/TimeLoop.cpp | 60 +++++++++++++-------------------
3 files changed, 36 insertions(+), 44 deletions(-)
diff --git a/ProcessLib/CreateProcessData.cpp b/ProcessLib/CreateProcessData.cpp
index fcf42bafd3c..4f46cae448f 100644
--- a/ProcessLib/CreateProcessData.cpp
+++ b/ProcessLib/CreateProcessData.cpp
@@ -20,6 +20,7 @@ namespace ProcessLib
static std::unique_ptr<ProcessData> makeProcessData(
std::unique_ptr<NumLib::TimeStepAlgorithm>&& timestepper,
NumLib::NonlinearSolverBase& nonlinear_solver,
+ int const process_id,
Process& process,
std::unique_ptr<NumLib::TimeDiscretization>&& time_disc,
std::unique_ptr<NumLib::ConvergenceCriterion>&& conv_crit)
@@ -32,7 +33,7 @@ static std::unique_ptr<ProcessData> makeProcessData(
{
return std::make_unique<ProcessData>(
std::move(timestepper), *nonlinear_solver_picard,
- std::move(conv_crit), std::move(time_disc), process);
+ std::move(conv_crit), std::move(time_disc), process_id, process);
}
if (auto* nonlinear_solver_newton =
dynamic_cast<NumLib::NonlinearSolver<Tag::Newton>*>(
@@ -40,7 +41,7 @@ static std::unique_ptr<ProcessData> makeProcessData(
{
return std::make_unique<ProcessData>(
std::move(timestepper), *nonlinear_solver_newton,
- std::move(conv_crit), std::move(time_disc), process);
+ std::move(conv_crit), std::move(time_disc), process_id, process);
}
OGS_FATAL("Encountered unknown nonlinear solver type. Aborting");
@@ -53,6 +54,7 @@ std::vector<std::unique_ptr<ProcessData>> createPerProcessData(
nonlinear_solvers)
{
std::vector<std::unique_ptr<ProcessData>> per_process_data;
+ int process_id = 0;
//! \ogs_file_param{prj__time_loop__processes__process}
for (auto pcs_config : config.getConfigSubtreeList("process"))
@@ -99,9 +101,10 @@ std::vector<std::unique_ptr<ProcessData>> createPerProcessData(
"in the current project file!");
}
- per_process_data.emplace_back(makeProcessData(
- std::move(timestepper), nl_slv, pcs, std::move(time_disc),
- std::move(conv_crit)));
+ per_process_data.emplace_back(
+ makeProcessData(std::move(timestepper), nl_slv, process_id, pcs,
+ std::move(time_disc), std::move(conv_crit)));
+ ++process_id;
}
if (per_process_data.size() != processes.size())
diff --git a/ProcessLib/ProcessData.h b/ProcessLib/ProcessData.h
index 69415ff11aa..ad26f9e7547 100644
--- a/ProcessLib/ProcessData.h
+++ b/ProcessLib/ProcessData.h
@@ -27,6 +27,7 @@ struct ProcessData
NumLib::NonlinearSolver<NLTag>& nonlinear_solver,
std::unique_ptr<NumLib::ConvergenceCriterion>&& conv_crit_,
std::unique_ptr<NumLib::TimeDiscretization>&& time_disc_,
+ int const process_id_,
Process& process_)
: timestepper(std::move(timestepper_)),
nonlinear_solver_tag(NLTag),
@@ -34,6 +35,7 @@ struct ProcessData
nonlinear_solver_status{true, 0},
conv_crit(std::move(conv_crit_)),
time_disc(std::move(time_disc_)),
+ process_id(process_id_),
process(process_)
{
}
@@ -47,6 +49,7 @@ struct ProcessData
time_disc(std::move(pd.time_disc)),
tdisc_ode_sys(std::move(pd.tdisc_ode_sys)),
mat_strg(pd.mat_strg),
+ process_id(pd.process_id),
process(pd.process)
{
pd.mat_strg = nullptr;
@@ -67,9 +70,7 @@ struct ProcessData
//! cast of \c tdisc_ode_sys to NumLib::InternalMatrixStorage
NumLib::InternalMatrixStorage* mat_strg = nullptr;
- /// Process ID. It is alway 0 when the monolithic scheme is used or
- /// a single process is modelled.
- int process_id = 0;
+ int const process_id;
Process& process;
};
diff --git a/ProcessLib/TimeLoop.cpp b/ProcessLib/TimeLoop.cpp
index 33fe66b1204..065f4e42616 100644
--- a/ProcessLib/TimeLoop.cpp
+++ b/ProcessLib/TimeLoop.cpp
@@ -130,10 +130,10 @@ std::vector<GlobalVector*> setInitialConditions(
{
std::vector<GlobalVector*> process_solutions;
- int process_id = 0;
for (auto& process_data : per_process_data)
{
auto& pcs = process_data->process;
+ auto const process_id = process_data->process_id;
auto& time_disc = *process_data->time_disc;
auto& ode_sys = *process_data->tdisc_ode_sys;
@@ -162,16 +162,14 @@ std::vector<GlobalVector*> setInitialConditions(
t0, x0,
mat_strg); // TODO: that might do duplicate work
}
-
- ++process_id;
}
return process_solutions;
}
NumLib::NonlinearSolverStatus solveOneTimeStepOneProcess(
- int const process_id, GlobalVector& x, std::size_t const timestep,
- double const t, double const delta_t, ProcessData const& process_data,
+ GlobalVector& x, std::size_t const timestep, double const t,
+ double const delta_t, ProcessData const& process_data,
Output& output_control)
{
auto& process = process_data.process;
@@ -192,8 +190,8 @@ NumLib::NonlinearSolverStatus solveOneTimeStepOneProcess(
auto const post_iteration_callback = [&](int iteration,
GlobalVector const& x) {
- output_control.doOutputNonlinearIteration(process, process_id, timestep,
- t, x, iteration);
+ output_control.doOutputNonlinearIteration(
+ process, process_data.process_id, timestep, t, x, iteration);
};
auto const nonlinear_solver_status =
@@ -201,7 +199,7 @@ NumLib::NonlinearSolverStatus solveOneTimeStepOneProcess(
if (nonlinear_solver_status.error_norms_met)
{
- process.postNonLinearSolver(x, t, delta_t, process_id);
+ process.postNonLinearSolver(x, t, delta_t, process_data.process_id);
}
return nonlinear_solver_status;
@@ -228,10 +226,9 @@ TimeLoop::TimeLoop(
void TimeLoop::setCoupledSolutions()
{
_solutions_of_coupled_processes.reserve(_per_process_data.size());
- for (unsigned process_id = 0; process_id < _per_process_data.size();
- process_id++)
+ for (auto& process_data : _per_process_data)
{
- auto const& x = *_process_solutions[process_id];
+ auto const& x = *_process_solutions[process_data->process_id];
_solutions_of_coupled_processes.emplace_back(x);
// Create a vector to store the solution of the last coupling iteration
@@ -383,13 +380,12 @@ double TimeLoop::computeTimeStepping(const double prev_dt, double& t,
/// initialize output, convergence criterion, etc.
void TimeLoop::initialize()
{
- int process_id = 0;
for (auto& process_data : _per_process_data)
{
auto& pcs = process_data->process;
+ int const process_id = process_data->process_id;
_output->addProcess(pcs, process_id);
- process_data->process_id = process_id;
setTimeDiscretizedODESystem(*process_data);
if (auto* conv_crit =
@@ -405,8 +401,6 @@ void TimeLoop::initialize()
// the fixed times.
auto& timestepper = process_data->timestepper;
timestepper->addFixedOutputTimes(_output->getFixedOutputTimes());
-
- ++process_id;
}
// init solution storage
@@ -465,11 +459,10 @@ bool TimeLoop::loop()
timesteps, t, dt);
// Check element deactivation:
- int process_id = 0;
for (auto& process_data : _per_process_data)
{
- process_data->process.updateDeactivatedSubdomains(t, process_id);
- ++process_id;
+ process_data->process.updateDeactivatedSubdomains(
+ t, process_data->process_id);
}
if (is_staggered_coupling)
@@ -549,8 +542,8 @@ static NumLib::NonlinearSolverStatus solveMonolithicProcess(
BaseLib::RunTime time_timestep_process;
time_timestep_process.start();
- auto const nonlinear_solver_status = solveOneTimeStepOneProcess(
- process_data.process_id, x, timestep_id, t, dt, process_data, output);
+ auto const nonlinear_solver_status =
+ solveOneTimeStepOneProcess(x, timestep_id, t, dt, process_data, output);
INFO("[time] Solving process #%u took %g s in time step #%u ",
process_data.process_id, time_timestep_process.elapsed(), timestep_id);
@@ -598,24 +591,24 @@ NumLib::NonlinearSolverStatus TimeLoop::solveUncoupledEquationSystems(
NumLib::NonlinearSolverStatus nonlinear_solver_status;
for (auto& process_data : _per_process_data)
{
- nonlinear_solver_status = solveMonolithicProcess(
- t, dt, timestep_id, *process_data,
- *_process_solutions[process_data->process_id], *_output);
+ auto const process_id = process_data->process_id;
+ nonlinear_solver_status =
+ solveMonolithicProcess(t, dt, timestep_id, *process_data,
+ *_process_solutions[process_id], *_output);
process_data->nonlinear_solver_status = nonlinear_solver_status;
if (!nonlinear_solver_status.error_norms_met)
{
ERR("The nonlinear solver failed in time step #%u at t = %g s for "
"process #%u.",
- timestep_id, t, process_data->process_id);
+ timestep_id, t, process_id);
if (!process_data->timestepper->isSolutionErrorComputationNeeded())
{
// save unsuccessful solution
- _output->doOutputAlways(
- process_data->process, process_data->process_id,
- timestep_id, t,
- *_process_solutions[process_data->process_id]);
+ _output->doOutputAlways(process_data->process, process_id,
+ timestep_id, t,
+ *_process_solutions[process_id]);
OGS_FATAL(nonlinear_fixed_dt_fails_info.data());
}
@@ -659,10 +652,10 @@ TimeLoop::solveCoupledEquationSystemsByStaggeredScheme(
{
// TODO(wenqing): use process name
coupling_iteration_converged = true;
- int process_id = 0;
int const last_process_id = _per_process_data.size() - 1;
for (auto& process_data : _per_process_data)
{
+ auto const process_id = process_data->process_id;
BaseLib::RunTime time_timestep_process;
time_timestep_process.start();
@@ -675,7 +668,7 @@ TimeLoop::solveCoupledEquationSystemsByStaggeredScheme(
&coupled_solutions);
nonlinear_solver_status = solveOneTimeStepOneProcess(
- process_id, x, timestep_id, t, dt, *process_data, *_output);
+ x, timestep_id, t, dt, *process_data, *_output);
process_data->nonlinear_solver_status = nonlinear_solver_status;
INFO(
@@ -719,8 +712,6 @@ TimeLoop::solveCoupledEquationSystemsByStaggeredScheme(
}
}
MathLib::LinAlg::copy(x, x_old);
-
- ++process_id;
} // end of for (auto& process_data : _per_process_data)
if (coupling_iteration_converged && global_coupling_iteration > 0)
@@ -771,15 +762,14 @@ void TimeLoop::outputSolutions(bool const output_initial_condition,
bool const is_staggered_coupling =
!isMonolithicProcess(*_per_process_data[0]);
- unsigned process_id = 0;
for (auto& process_data : _per_process_data)
{
+ auto const process_id = process_data->process_id;
auto& pcs = process_data->process;
// If nonlinear solver diverged, the solution has already been
// saved.
if (!process_data->nonlinear_solver_status.error_norms_met)
{
- ++process_id;
continue;
}
@@ -805,8 +795,6 @@ void TimeLoop::outputSolutions(bool const output_initial_condition,
.setCoupledTermForTheStaggeredSchemeToLocalAssemblers();
}
(output_object.*output_class_member)(pcs, process_id, timestep, t, x);
-
- ++process_id;
}
}
--
GitLab