OilfieldToolsNet/opm-simulators
4
0
Fork 0
mirror of https://github.com/OPM/opm-simulators.git synced 2025-02-25 18:55:30 -06:00
Code Issues Packages Projects Releases Wiki Activity

Rename ConvergenceStatus -> ConvergenceReport.

Browse Source
This commit is contained in:
Atgeirr Flø Rasmussen 2018-10-25 11:57:47 +02:00
parent 2bef8d7017
commit 2bf4d15285
9 changed files with 77 additions and 77 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
CMakeLists_files.cmake
View File

@ -131,7 +131,7 @@ list (APPEND TEST_SOURCE_FILES
tests/test_blackoil_amg.cpp tests/test_blackoil_amg.cpp
tests/test_block.cpp tests/test_block.cpp
tests/test_boprops_ad.cpp tests/test_boprops_ad.cpp
tests/test_convergencestatus.cpp tests/test_convergencereport.cpp
tests/test_graphcoloring.cpp tests/test_graphcoloring.cpp
tests/test_rateconverter.cpp tests/test_rateconverter.cpp
tests/test_span.cpp tests/test_span.cpp
@ -445,7 +445,7 @@ list (APPEND PUBLIC_HEADER_FILES
opm/simulators/timestepping/AdaptiveTimeStepping.hpp opm/simulators/timestepping/AdaptiveTimeStepping.hpp
opm/simulators/timestepping/AdaptiveTimeStepping_impl.hpp opm/simulators/timestepping/AdaptiveTimeStepping_impl.hpp
opm/simulators/timestepping/AdaptiveTimeSteppingEbos.hpp opm/simulators/timestepping/AdaptiveTimeSteppingEbos.hpp
opm/simulators/timestepping/ConvergenceStatus.hpp opm/simulators/timestepping/ConvergenceReport.hpp
opm/simulators/timestepping/TimeStepControl.hpp opm/simulators/timestepping/TimeStepControl.hpp
opm/simulators/timestepping/TimeStepControlInterface.hpp opm/simulators/timestepping/TimeStepControlInterface.hpp
opm/simulators/timestepping/SimulatorTimer.hpp opm/simulators/timestepping/SimulatorTimer.hpp

10
opm/autodiff/BlackoilWellModel_impl.hpp
View File

@ -660,7 +660,7 @@ namespace Opm {
BlackoilWellModel<TypeTag>:: BlackoilWellModel<TypeTag>::
getWellConvergence(const std::vector<Scalar>& B_avg) const getWellConvergence(const std::vector<Scalar>& B_avg) const
{ {
ConvergenceStatus report; ConvergenceReport report;
for (const auto& well : well_container_) { for (const auto& well : well_container_) {
report += well->getWellConvergence(B_avg); report += well->getWellConvergence(B_avg);
@ -671,13 +671,13 @@ namespace Opm {
{ {
// Debug reporting. // Debug reporting.
for (const auto& f : report.wellFailures()) { for (const auto& f : report.wellFailures()) {
if (f.severity == ConvergenceStatus::Severity::NotANumber) { if (f.severity == ConvergenceReport::Severity::NotANumber) {
OpmLog::debug("NaN residual found with phase " + std::to_string(f.phase) + " for well " + f.well_name); OpmLog::debug("NaN residual found with phase " + std::to_string(f.phase) + " for well " + f.well_name);
} }
} }
// Throw if any nan residual found. // Throw if any nan residual found.
bool nan_residual_found = (severity == ConvergenceStatus::Severity::NotANumber); bool nan_residual_found = (severity == ConvergenceReport::Severity::NotANumber);
const auto& grid = ebosSimulator_.vanguard().grid(); const auto& grid = ebosSimulator_.vanguard().grid();
int value = nan_residual_found ? 1 : 0; int value = nan_residual_found ? 1 : 0;
nan_residual_found = grid.comm().max(value); nan_residual_found = grid.comm().max(value);
@ -690,13 +690,13 @@ namespace Opm {
{ {
// Debug reporting. // Debug reporting.
for (const auto& f : report.wellFailures()) { for (const auto& f : report.wellFailures()) {
if (f.severity == ConvergenceStatus::Severity::TooLarge) { if (f.severity == ConvergenceReport::Severity::TooLarge) {
OpmLog::debug("Too large residual found with phase " + std::to_string(f.phase) + " for well " + f.well_name); OpmLog::debug("Too large residual found with phase " + std::to_string(f.phase) + " for well " + f.well_name);
} }
} }
// Throw if any too large residual found. // Throw if any too large residual found.
bool too_large_residual_found = (severity == ConvergenceStatus::Severity::TooLarge); bool too_large_residual_found = (severity == ConvergenceReport::Severity::TooLarge);
const auto& grid = ebosSimulator_.vanguard().grid(); const auto& grid = ebosSimulator_.vanguard().grid();
int value = too_large_residual_found ? 1 : 0; int value = too_large_residual_found ? 1 : 0;
too_large_residual_found = grid.comm().max(value); too_large_residual_found = grid.comm().max(value);

2
opm/autodiff/MultisegmentWell.hpp
View File

@ -122,7 +122,7 @@ namespace Opm
virtual void updateWellStateWithTarget(WellState& well_state) const; virtual void updateWellStateWithTarget(WellState& well_state) const;
/// check whether the well equations get converged for this well /// check whether the well equations get converged for this well
virtual ConvergenceStatus getWellConvergence(const std::vector<double>& B_avg) const; virtual ConvergenceReport getWellConvergence(const std::vector<double>& B_avg) const;
/// Ax = Ax - C D^-1 B x /// Ax = Ax - C D^-1 B x
virtual void apply(const BVector& x, BVector& Ax) const; virtual void apply(const BVector& x, BVector& Ax) const;

32
opm/autodiff/MultisegmentWell_impl.hpp
View File

@ -405,7 +405,7 @@ namespace Opm
template <typename TypeTag> template <typename TypeTag>
ConvergenceStatus ConvergenceReport
MultisegmentWell<TypeTag>:: MultisegmentWell<TypeTag>::
getWellConvergence(const std::vector<double>& B_avg) const getWellConvergence(const std::vector<double>& B_avg) const
{ {
@ -419,18 +419,18 @@ namespace Opm
} }
} }
using CS = ConvergenceStatus; using CR = ConvergenceReport;
CS::WellFailure::Type ctrltype = CS::WellFailure::Type::Mb; CR::WellFailure::Type ctrltype = CR::WellFailure::Type::Mb;
switch(well_controls_get_current_type(well_controls_)) { switch(well_controls_get_current_type(well_controls_)) {
case THP: case THP:
ctrltype = CS::WellFailure::Type::CtrlTHP; ctrltype = CR::WellFailure::Type::CtrlTHP;
break; break;
case BHP: case BHP:
ctrltype = CS::WellFailure::Type::CtrlBHP; ctrltype = CR::WellFailure::Type::CtrlBHP;
break; break;
case RESERVOIR_RATE: case RESERVOIR_RATE:
case SURFACE_RATE: case SURFACE_RATE:
ctrltype = CS::WellFailure::Type::CtrlRate; ctrltype = CR::WellFailure::Type::CtrlRate;
break; break;
default: default:
OPM_THROW(std::runtime_error, "Unknown well control control types for well " << name()); OPM_THROW(std::runtime_error, "Unknown well control control types for well " << name());
@ -438,7 +438,7 @@ namespace Opm
std::vector<double> maximum_residual(numWellEq, 0.0); std::vector<double> maximum_residual(numWellEq, 0.0);
ConvergenceStatus report; ConvergenceReport report;
// TODO: the following is a little complicated, maybe can be simplified in some way? // TODO: the following is a little complicated, maybe can be simplified in some way?
for (int eq_idx = 0; eq_idx < numWellEq; ++eq_idx) { for (int eq_idx = 0; eq_idx < numWellEq; ++eq_idx) {
for (int seg = 0; seg < numberOfSegments(); ++seg) { for (int seg = 0; seg < numberOfSegments(); ++seg) {
@ -452,11 +452,11 @@ namespace Opm
// Control equation // Control equation
const double control_residual = abs_residual[seg][eq_idx]; const double control_residual = abs_residual[seg][eq_idx];
if (std::isnan(control_residual)) { if (std::isnan(control_residual)) {
report.setWellFailed({ctrltype, CS::Severity::NotANumber, -1, name()}); report.setWellFailed({ctrltype, CR::Severity::NotANumber, -1, name()});
} else if (control_residual > param_.max_residual_allowed_) { } else if (control_residual > param_.max_residual_allowed_) {
report.setWellFailed({ctrltype, CS::Severity::TooLarge, -1, name()}); report.setWellFailed({ctrltype, CR::Severity::TooLarge, -1, name()});
} else if (control_residual > param_.tolerance_wells_) { } else if (control_residual > param_.tolerance_wells_) {
report.setWellFailed({ctrltype, CS::Severity::Normal, -1, name()}); report.setWellFailed({ctrltype, CR::Severity::Normal, -1, name()});
} }
} else { } else {
// Pressure equation // Pressure equation
@ -474,20 +474,20 @@ namespace Opm
const double flux_residual = maximum_residual[eq_idx]; const double flux_residual = maximum_residual[eq_idx];
// TODO: the report can not handle the segment number yet. // TODO: the report can not handle the segment number yet.
if (std::isnan(flux_residual)) { if (std::isnan(flux_residual)) {
report.setWellFailed({CS::WellFailure::Type::Mb, CS::Severity::NotANumber, eq_idx, name()}); report.setWellFailed({CR::WellFailure::Type::Mb, CR::Severity::NotANumber, eq_idx, name()});
} else if (flux_residual > param_.max_residual_allowed_) { } else if (flux_residual > param_.max_residual_allowed_) {
report.setWellFailed({CS::WellFailure::Type::Mb, CS::Severity::TooLarge, eq_idx, name()}); report.setWellFailed({CR::WellFailure::Type::Mb, CR::Severity::TooLarge, eq_idx, name()});
} else if (flux_residual > param_.tolerance_wells_) { } else if (flux_residual > param_.tolerance_wells_) {
report.setWellFailed({CS::WellFailure::Type::Mb, CS::Severity::Normal, eq_idx, name()}); report.setWellFailed({CR::WellFailure::Type::Mb, CR::Severity::Normal, eq_idx, name()});
} }
} else { // pressure equation } else { // pressure equation
const double pressure_residual = maximum_residual[eq_idx]; const double pressure_residual = maximum_residual[eq_idx];
if (std::isnan(pressure_residual)) { if (std::isnan(pressure_residual)) {
report.setWellFailed({CS::WellFailure::Type::Pressure, CS::Severity::NotANumber, -1, name()}); report.setWellFailed({CR::WellFailure::Type::Pressure, CR::Severity::NotANumber, -1, name()});
} else if (std::isinf(pressure_residual)) { } else if (std::isinf(pressure_residual)) {
report.setWellFailed({CS::WellFailure::Type::Pressure, CS::Severity::TooLarge, -1, name()}); report.setWellFailed({CR::WellFailure::Type::Pressure, CR::Severity::TooLarge, -1, name()});
} else if (pressure_residual > param_.tolerance_pressure_ms_wells_) { } else if (pressure_residual > param_.tolerance_pressure_ms_wells_) {
report.setWellFailed({CS::WellFailure::Type::Pressure, CS::Severity::Normal, -1, name()}); report.setWellFailed({CR::WellFailure::Type::Pressure, CR::Severity::Normal, -1, name()});
} }
} }
} }

2
opm/autodiff/StandardWell.hpp
View File

@ -144,7 +144,7 @@ namespace Opm
virtual void updateWellStateWithTarget(WellState& well_state) const; virtual void updateWellStateWithTarget(WellState& well_state) const;
/// check whether the well equations get converged for this well /// check whether the well equations get converged for this well
virtual ConvergenceStatus getWellConvergence(const std::vector<double>& B_avg) const; virtual ConvergenceReport getWellConvergence(const std::vector<double>& B_avg) const;
/// Ax = Ax - C D^-1 B x /// Ax = Ax - C D^-1 B x
virtual void apply(const BVector& x, BVector& Ax) const; virtual void apply(const BVector& x, BVector& Ax) const;

26
opm/autodiff/StandardWell_impl.hpp
View File

@ -1483,7 +1483,7 @@ namespace Opm
template<typename TypeTag> template<typename TypeTag>
ConvergenceStatus ConvergenceReport
StandardWell<TypeTag>:: StandardWell<TypeTag>::
getWellConvergence(const std::vector<double>& B_avg) const getWellConvergence(const std::vector<double>& B_avg) const
{ {
@ -1508,9 +1508,9 @@ namespace Opm
well_flux_residual[compIdx] = B_avg[compIdx] * res[compIdx]; well_flux_residual[compIdx] = B_avg[compIdx] * res[compIdx];
} }
ConvergenceStatus report; ConvergenceReport report;
using CS = ConvergenceStatus; using CR = ConvergenceReport;
CS::WellFailure::Type type = CS::WellFailure::Type::Mb; CR::WellFailure::Type type = CR::WellFailure::Type::Mb;
// checking if any NaN or too large residuals found // checking if any NaN or too large residuals found
for (unsigned phaseIdx = 0; phaseIdx < FluidSystem::numPhases; ++phaseIdx) { for (unsigned phaseIdx = 0; phaseIdx < FluidSystem::numPhases; ++phaseIdx) {
if (!FluidSystem::phaseIsActive(phaseIdx)) { if (!FluidSystem::phaseIsActive(phaseIdx)) {
@ -1522,11 +1522,11 @@ namespace Opm
const int compIdx = Indices::canonicalToActiveComponentIndex(canonicalCompIdx); const int compIdx = Indices::canonicalToActiveComponentIndex(canonicalCompIdx);
if (std::isnan(well_flux_residual[compIdx])) { if (std::isnan(well_flux_residual[compIdx])) {
report.setWellFailed({type, CS::Severity::NotANumber, compIdx, name()}); report.setWellFailed({type, CR::Severity::NotANumber, compIdx, name()});
} else if (well_flux_residual[compIdx] > maxResidualAllowed) { } else if (well_flux_residual[compIdx] > maxResidualAllowed) {
report.setWellFailed({type, CS::Severity::TooLarge, compIdx, name()}); report.setWellFailed({type, CR::Severity::TooLarge, compIdx, name()});
} else if (well_flux_residual[compIdx] > tol_wells) { } else if (well_flux_residual[compIdx] > tol_wells) {
report.setWellFailed({type, CS::Severity::Normal, compIdx, name()}); report.setWellFailed({type, CR::Severity::Normal, compIdx, name()});
} }
} }
@ -1536,16 +1536,16 @@ namespace Opm
double control_tolerance = 0.; double control_tolerance = 0.;
switch(well_controls_get_current_type(well_controls_)) { switch(well_controls_get_current_type(well_controls_)) {
case THP: case THP:
type = CS::WellFailure::Type::CtrlTHP; type = CR::WellFailure::Type::CtrlTHP;
control_tolerance = 1.e3; // 0.01 bar control_tolerance = 1.e3; // 0.01 bar
break; break;
case BHP: // pressure type of control case BHP: // pressure type of control
type = CS::WellFailure::Type::CtrlBHP; type = CR::WellFailure::Type::CtrlBHP;
control_tolerance = 1.e3; // 0.01 bar control_tolerance = 1.e3; // 0.01 bar
break; break;
case RESERVOIR_RATE: case RESERVOIR_RATE:
case SURFACE_RATE: case SURFACE_RATE:
type = CS::WellFailure::Type::CtrlRate; type = CR::WellFailure::Type::CtrlRate;
control_tolerance = 1.e-4; // smaller tolerance for rate control control_tolerance = 1.e-4; // smaller tolerance for rate control
break; break;
default: default:
@ -1554,11 +1554,11 @@ namespace Opm
const int dummy_component = -1; const int dummy_component = -1;
if (std::isnan(well_control_residual)) { if (std::isnan(well_control_residual)) {
report.setWellFailed({type, CS::Severity::NotANumber, dummy_component, name()}); report.setWellFailed({type, CR::Severity::NotANumber, dummy_component, name()});
} else if (well_control_residual > maxResidualAllowed * 10.) { } else if (well_control_residual > maxResidualAllowed * 10.) {
report.setWellFailed({type, CS::Severity::TooLarge, dummy_component, name()}); report.setWellFailed({type, CR::Severity::TooLarge, dummy_component, name()});
} else if ( well_control_residual > control_tolerance) { } else if ( well_control_residual > control_tolerance) {
report.setWellFailed({type, CS::Severity::Normal, dummy_component, name()}); report.setWellFailed({type, CR::Severity::Normal, dummy_component, name()});
} }
return report; return report;

4
opm/autodiff/WellInterface.hpp
View File

@ -44,7 +44,7 @@
#include <opm/autodiff/BlackoilModelParametersEbos.hpp> #include <opm/autodiff/BlackoilModelParametersEbos.hpp>
#include <opm/autodiff/RateConverter.hpp> #include <opm/autodiff/RateConverter.hpp>
#include <opm/simulators/timestepping/ConvergenceStatus.hpp> #include <opm/simulators/timestepping/ConvergenceReport.hpp>
#include <opm/simulators/WellSwitchingLogger.hpp> #include <opm/simulators/WellSwitchingLogger.hpp>
#include<dune/common/fmatrix.hh> #include<dune/common/fmatrix.hh>
@ -138,7 +138,7 @@ namespace Opm
virtual void initPrimaryVariablesEvaluation() const = 0; virtual void initPrimaryVariablesEvaluation() const = 0;
virtual ConvergenceStatus getWellConvergence(const std::vector<double>& B_avg) const = 0; virtual ConvergenceReport getWellConvergence(const std::vector<double>& B_avg) const = 0;
virtual void solveEqAndUpdateWellState(WellState& well_state) = 0; virtual void solveEqAndUpdateWellState(WellState& well_state) = 0;

12
opm/simulators/timestepping/ConvergenceStatus.hpp → opm/simulators/timestepping/ConvergenceReport.hpp
View File

@ -18,8 +18,8 @@
along with OPM. If not, see <http://www.gnu.org/licenses/>. along with OPM. If not, see <http://www.gnu.org/licenses/>.
*/ */
#ifndef OPM_CONVERGENCESTATUS_HEADER_INCLUDED #ifndef OPM_CONVERGENCEREPORT_HEADER_INCLUDED
#define OPM_CONVERGENCESTATUS_HEADER_INCLUDED #define OPM_CONVERGENCEREPORT_HEADER_INCLUDED
#include <cassert> #include <cassert>
#include <numeric> #include <numeric>
@ -32,7 +32,7 @@ namespace Opm
/// Represents the convergence status of the whole simulator, to /// Represents the convergence status of the whole simulator, to
/// make it possible to query and store the reasons for /// make it possible to query and store the reasons for
/// convergence failures. /// convergence failures.
class ConvergenceStatus class ConvergenceReport
{ {
public: public:
@ -64,7 +64,7 @@ namespace Opm
// ----------- Mutating member functions ----------- // ----------- Mutating member functions -----------
ConvergenceStatus() ConvergenceReport()
: status_{AllGood} : status_{AllGood}
, res_failures_{} , res_failures_{}
, well_failures_{} , well_failures_{}
@ -90,7 +90,7 @@ namespace Opm
well_failures_.push_back(wf); well_failures_.push_back(wf);
} }
ConvergenceStatus& operator+=(const ConvergenceStatus& other) ConvergenceReport& operator+=(const ConvergenceReport& other)
{ {
status_ = static_cast<Status>(status_ | other.status_); status_ = static_cast<Status>(status_ | other.status_);
res_failures_.insert(res_failures_.end(), other.res_failures_.begin(), other.res_failures_.end()); res_failures_.insert(res_failures_.end(), other.res_failures_.begin(), other.res_failures_.end());
@ -153,4 +153,4 @@ namespace Opm
} // namespace Opm } // namespace Opm
#endif // OPM_CONVERGENCESTATUS_HEADER_INCLUDED #endif // OPM_CONVERGENCEREPORT_HEADER_INCLUDED

62
tests/test_convergencestatus.cpp → tests/test_convergencereport.cpp
View File

@ -19,43 +19,43 @@
*/ */
#include <config.h> #include <config.h>
#define BOOST_TEST_MODULE ConvergenceStatusTest #define BOOST_TEST_MODULE ConvergenceReportTest
#include <boost/test/unit_test.hpp> #include <boost/test/unit_test.hpp>
#include <opm/simulators/timestepping/ConvergenceStatus.hpp> #include <opm/simulators/timestepping/ConvergenceReport.hpp>
using CS = Opm::ConvergenceStatus; using CR = Opm::ConvergenceReport;
BOOST_AUTO_TEST_CASE(DefaultConstructor) BOOST_AUTO_TEST_CASE(DefaultConstructor)
{ {
Opm::ConvergenceStatus s; Opm::ConvergenceReport s;
BOOST_CHECK(s.converged()); BOOST_CHECK(s.converged());
BOOST_CHECK(!s.reservoirFailed()); BOOST_CHECK(!s.reservoirFailed());
BOOST_CHECK(!s.wellFailed()); BOOST_CHECK(!s.wellFailed());
BOOST_CHECK(s.severityOfWorstFailure() == CS::Severity::None); BOOST_CHECK(s.severityOfWorstFailure() == CR::Severity::None);
} }
BOOST_AUTO_TEST_CASE(Failures) BOOST_AUTO_TEST_CASE(Failures)
{ {
Opm::ConvergenceStatus s1; Opm::ConvergenceReport s1;
s1.setReservoirFailed({CS::ReservoirFailure::Type::Cnv, CS::Severity::Normal, 2, 100}); s1.setReservoirFailed({CR::ReservoirFailure::Type::Cnv, CR::Severity::Normal, 2, 100});
{ {
BOOST_CHECK(!s1.converged()); BOOST_CHECK(!s1.converged());
BOOST_CHECK(s1.reservoirFailed()); BOOST_CHECK(s1.reservoirFailed());
BOOST_CHECK(!s1.wellFailed()); BOOST_CHECK(!s1.wellFailed());
BOOST_REQUIRE(s1.reservoirFailures().size() == 1); BOOST_REQUIRE(s1.reservoirFailures().size() == 1);
const auto f = s1.reservoirFailures()[0]; const auto f = s1.reservoirFailures()[0];
BOOST_CHECK(f.type == CS::ReservoirFailure::Type::Cnv); BOOST_CHECK(f.type == CR::ReservoirFailure::Type::Cnv);
BOOST_CHECK(f.severity == CS::Severity::Normal); BOOST_CHECK(f.severity == CR::Severity::Normal);
BOOST_CHECK(f.phase == 2); BOOST_CHECK(f.phase == 2);
BOOST_CHECK(f.cell_index == 100); BOOST_CHECK(f.cell_index == 100);
BOOST_CHECK(s1.wellFailures().empty()); BOOST_CHECK(s1.wellFailures().empty());
BOOST_CHECK(s1.severityOfWorstFailure() == CS::Severity::Normal); BOOST_CHECK(s1.severityOfWorstFailure() == CR::Severity::Normal);
} }
Opm::ConvergenceStatus s2; Opm::ConvergenceReport s2;
s2.setWellFailed({CS::WellFailure::Type::CtrlTHP, CS::Severity::Normal, -1, "PRODUCER-123"}); s2.setWellFailed({CR::WellFailure::Type::CtrlTHP, CR::Severity::Normal, -1, "PRODUCER-123"});
s2.setWellFailed({CS::WellFailure::Type::Mb, CS::Severity::TooLarge, 2, "INJECTOR-XYZ"}); s2.setWellFailed({CR::WellFailure::Type::Mb, CR::Severity::TooLarge, 2, "INJECTOR-XYZ"});
{ {
BOOST_CHECK(!s2.converged()); BOOST_CHECK(!s2.converged());
BOOST_CHECK(!s2.reservoirFailed()); BOOST_CHECK(!s2.reservoirFailed());
@ -63,16 +63,16 @@ BOOST_AUTO_TEST_CASE(Failures)
BOOST_CHECK(s2.reservoirFailures().empty()); BOOST_CHECK(s2.reservoirFailures().empty());
BOOST_REQUIRE(s2.wellFailures().size() == 2); BOOST_REQUIRE(s2.wellFailures().size() == 2);
const auto f0 = s2.wellFailures()[0]; const auto f0 = s2.wellFailures()[0];
BOOST_CHECK(f0.type == CS::WellFailure::Type::CtrlTHP); BOOST_CHECK(f0.type == CR::WellFailure::Type::CtrlTHP);
BOOST_CHECK(f0.severity == CS::Severity::Normal); BOOST_CHECK(f0.severity == CR::Severity::Normal);
BOOST_CHECK(f0.phase == -1); BOOST_CHECK(f0.phase == -1);
BOOST_CHECK(f0.well_name == "PRODUCER-123"); BOOST_CHECK(f0.well_name == "PRODUCER-123");
const auto f1 = s2.wellFailures()[1]; const auto f1 = s2.wellFailures()[1];
BOOST_CHECK(f1.type == CS::WellFailure::Type::Mb); BOOST_CHECK(f1.type == CR::WellFailure::Type::Mb);
BOOST_CHECK(f1.severity == CS::Severity::TooLarge); BOOST_CHECK(f1.severity == CR::Severity::TooLarge);
BOOST_CHECK(f1.phase == 2); BOOST_CHECK(f1.phase == 2);
BOOST_CHECK(f1.well_name == "INJECTOR-XYZ"); BOOST_CHECK(f1.well_name == "INJECTOR-XYZ");
BOOST_CHECK(s2.severityOfWorstFailure() == CS::Severity::TooLarge); BOOST_CHECK(s2.severityOfWorstFailure() == CR::Severity::TooLarge);
} }
s1 += s2; s1 += s2;
@ -82,22 +82,22 @@ BOOST_AUTO_TEST_CASE(Failures)
BOOST_CHECK(s1.wellFailed()); BOOST_CHECK(s1.wellFailed());
BOOST_REQUIRE(s1.reservoirFailures().size() == 1); BOOST_REQUIRE(s1.reservoirFailures().size() == 1);
const auto f = s1.reservoirFailures()[0]; const auto f = s1.reservoirFailures()[0];
BOOST_CHECK(f.type == CS::ReservoirFailure::Type::Cnv); BOOST_CHECK(f.type == CR::ReservoirFailure::Type::Cnv);
BOOST_CHECK(f.severity == CS::Severity::Normal); BOOST_CHECK(f.severity == CR::Severity::Normal);
BOOST_CHECK(f.phase == 2); BOOST_CHECK(f.phase == 2);
BOOST_CHECK(f.cell_index == 100); BOOST_CHECK(f.cell_index == 100);
BOOST_REQUIRE(s1.wellFailures().size() == 2); BOOST_REQUIRE(s1.wellFailures().size() == 2);
const auto f0 = s1.wellFailures()[0]; const auto f0 = s1.wellFailures()[0];
BOOST_CHECK(f0.type == CS::WellFailure::Type::CtrlTHP); BOOST_CHECK(f0.type == CR::WellFailure::Type::CtrlTHP);
BOOST_CHECK(f0.severity == CS::Severity::Normal); BOOST_CHECK(f0.severity == CR::Severity::Normal);
BOOST_CHECK(f0.phase == -1); BOOST_CHECK(f0.phase == -1);
BOOST_CHECK(f0.well_name == "PRODUCER-123"); BOOST_CHECK(f0.well_name == "PRODUCER-123");
const auto f1 = s1.wellFailures()[1]; const auto f1 = s1.wellFailures()[1];
BOOST_CHECK(f1.type == CS::WellFailure::Type::Mb); BOOST_CHECK(f1.type == CR::WellFailure::Type::Mb);
BOOST_CHECK(f1.severity == CS::Severity::TooLarge); BOOST_CHECK(f1.severity == CR::Severity::TooLarge);
BOOST_CHECK(f1.phase == 2); BOOST_CHECK(f1.phase == 2);
BOOST_CHECK(f1.well_name == "INJECTOR-XYZ"); BOOST_CHECK(f1.well_name == "INJECTOR-XYZ");
BOOST_CHECK(s1.severityOfWorstFailure() == CS::Severity::TooLarge); BOOST_CHECK(s1.severityOfWorstFailure() == CR::Severity::TooLarge);
} }
s1.clear(); s1.clear();
@ -105,7 +105,7 @@ BOOST_AUTO_TEST_CASE(Failures)
BOOST_CHECK(s1.converged()); BOOST_CHECK(s1.converged());
BOOST_CHECK(!s1.reservoirFailed()); BOOST_CHECK(!s1.reservoirFailed());
BOOST_CHECK(!s1.wellFailed()); BOOST_CHECK(!s1.wellFailed());
BOOST_CHECK(s1.severityOfWorstFailure() == CS::Severity::None); BOOST_CHECK(s1.severityOfWorstFailure() == CR::Severity::None);
} }
s1 += s2; s1 += s2;
@ -116,16 +116,16 @@ BOOST_AUTO_TEST_CASE(Failures)
BOOST_CHECK(s1.reservoirFailures().empty()); BOOST_CHECK(s1.reservoirFailures().empty());
BOOST_REQUIRE(s1.wellFailures().size() == 2); BOOST_REQUIRE(s1.wellFailures().size() == 2);
const auto f0 = s1.wellFailures()[0]; const auto f0 = s1.wellFailures()[0];
BOOST_CHECK(f0.type == CS::WellFailure::Type::CtrlTHP); BOOST_CHECK(f0.type == CR::WellFailure::Type::CtrlTHP);
BOOST_CHECK(f0.severity == CS::Severity::Normal); BOOST_CHECK(f0.severity == CR::Severity::Normal);
BOOST_CHECK(f0.phase == -1); BOOST_CHECK(f0.phase == -1);
BOOST_CHECK(f0.well_name == "PRODUCER-123"); BOOST_CHECK(f0.well_name == "PRODUCER-123");
const auto f1 = s1.wellFailures()[1]; const auto f1 = s1.wellFailures()[1];
BOOST_CHECK(f1.type == CS::WellFailure::Type::Mb); BOOST_CHECK(f1.type == CR::WellFailure::Type::Mb);
BOOST_CHECK(f1.severity == CS::Severity::TooLarge); BOOST_CHECK(f1.severity == CR::Severity::TooLarge);
BOOST_CHECK(f1.phase == 2); BOOST_CHECK(f1.phase == 2);
BOOST_CHECK(f1.well_name == "INJECTOR-XYZ"); BOOST_CHECK(f1.well_name == "INJECTOR-XYZ");
BOOST_CHECK(s1.severityOfWorstFailure() == CS::Severity::TooLarge); BOOST_CHECK(s1.severityOfWorstFailure() == CR::Severity::TooLarge);
} }
} }