opm-common/tests/test_SegmentMatcher.cpp
Bård Skaflestad 1a1ba1f7a1 Add Facility For Identifying Specific Well Segments
The primary use case is identifying UDQ sets when the model defines
UDQs at the segment level (SU*).  The call site will construct a
SegmentMatcher object backed by a specific ScheduleState, and then
segment-level UDQs will match against this to determine the correct
UDQ set on which to define the quantity.
2022-12-20 12:57:00 +01:00

1593 lines
60 KiB
C++

/*
Copyright 2022 Equinor ASA
This file is part of the Open Porous Media project (OPM).
OPM is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OPM is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OPM. If not, see <http://www.gnu.org/licenses/>.
*/
#define BOOST_TEST_MODULE Segment_Matcher
#include <boost/test/unit_test.hpp>
#include <opm/input/eclipse/Schedule/MSW/SegmentMatcher.hpp>
#include <opm/input/eclipse/EclipseState/Runspec.hpp>
#include <opm/input/eclipse/Schedule/MSW/Segment.hpp>
#include <opm/input/eclipse/Schedule/MSW/WellSegments.hpp>
#include <opm/input/eclipse/Schedule/ScheduleState.hpp>
#include <opm/input/eclipse/Schedule/ScheduleTypes.hpp>
#include <opm/input/eclipse/Schedule/Well/Connection.hpp>
#include <opm/input/eclipse/Schedule/Well/NameOrder.hpp>
#include <opm/input/eclipse/Schedule/Well/Well.hpp>
#include <opm/input/eclipse/Units/UnitSystem.hpp>
#include <opm/common/utility/TimeService.hpp>
#include <cstddef>
#include <memory>
#include <stdexcept>
#include <string>
#include <string_view>
#include <vector>
BOOST_AUTO_TEST_SUITE(Set_Descriptor)
BOOST_AUTO_TEST_CASE(Default)
{
const auto request = Opm::SegmentMatcher::SetDescriptor{};
BOOST_CHECK_MESSAGE(! request.segmentNumber().has_value(),
"Defaulted SetDescriptor must NOT "
"have a specific segment number");
BOOST_CHECK_MESSAGE(! request.wellNames().has_value(),
"Defaulted SetDescriptor must NOT "
"have a specific well name pattern");
}
BOOST_AUTO_TEST_SUITE(Segment_Number)
BOOST_AUTO_TEST_SUITE(Integer_Overload)
BOOST_AUTO_TEST_CASE(Specific)
{
auto request = Opm::SegmentMatcher::SetDescriptor{}
.segmentNumber(123);
BOOST_REQUIRE_MESSAGE(request.segmentNumber().has_value(),
"Assigned SetDescriptor must "
"have a specific segment number");
BOOST_CHECK_EQUAL(request.segmentNumber().value(), 123);
request.segmentNumber(1729);
BOOST_CHECK_EQUAL(request.segmentNumber().value(), 1729);
}
BOOST_AUTO_TEST_CASE(NonPositive)
{
auto request = Opm::SegmentMatcher::SetDescriptor{}
.segmentNumber(0);
BOOST_CHECK_MESSAGE(! request.segmentNumber().has_value(),
"Zero segment number must NOT "
"have a specifc segment number "
"in the final descriptor");
request.segmentNumber(-1);
BOOST_CHECK_MESSAGE(! request.segmentNumber().has_value(),
"Negative segment number must NOT "
"have a specifc segment number "
"in the final descriptor");
}
BOOST_AUTO_TEST_CASE(Positve_To_Negative)
{
auto request = Opm::SegmentMatcher::SetDescriptor{}
.segmentNumber(11);
BOOST_REQUIRE_MESSAGE(request.segmentNumber().has_value(),
"Assigned SetDescriptor must "
"have a specific segment number");
BOOST_CHECK_EQUAL(request.segmentNumber().value(), 11);
request.segmentNumber(-1);
BOOST_CHECK_MESSAGE(! request.segmentNumber().has_value(),
"Negative segment number must NOT "
"have a specifc segment number "
"in the final descriptor");
}
BOOST_AUTO_TEST_SUITE_END() // Integer_Overload
// ---------------------------------------------------------------------------
BOOST_AUTO_TEST_SUITE(StringView_Overload)
BOOST_AUTO_TEST_CASE(Specific)
{
using namespace std::literals;
auto request = Opm::SegmentMatcher::SetDescriptor{}
.segmentNumber("123"sv);
BOOST_REQUIRE_MESSAGE(request.segmentNumber().has_value(),
"Assigned SetDescriptor must "
"have a specific segment number");
BOOST_CHECK_EQUAL(request.segmentNumber().value(), 123);
request.segmentNumber("'1729'"sv);
BOOST_CHECK_EQUAL(request.segmentNumber().value(), 1729);
}
BOOST_AUTO_TEST_CASE(NonPositive)
{
using namespace std::literals;
auto request = Opm::SegmentMatcher::SetDescriptor{}
.segmentNumber("0"sv);
BOOST_CHECK_MESSAGE(! request.segmentNumber().has_value(),
"Zero segment number must NOT "
"have a specifc segment number "
"in the final descriptor");
request.segmentNumber("'-1'");
BOOST_CHECK_MESSAGE(! request.segmentNumber().has_value(),
"Negative segment number must NOT "
"have a specifc segment number "
"in the final descriptor");
}
BOOST_AUTO_TEST_CASE(Asterisk)
{
using namespace std::literals;
auto request = Opm::SegmentMatcher::SetDescriptor{}
.segmentNumber("*"sv);
BOOST_CHECK_MESSAGE(! request.segmentNumber().has_value(),
"Defaulted segment number must NOT "
"have a specifc segment number "
"in the final descriptor");
}
BOOST_AUTO_TEST_CASE(Positve_To_Negative)
{
using namespace std::literals;
auto request = Opm::SegmentMatcher::SetDescriptor{}
.segmentNumber("'11'"sv);
BOOST_REQUIRE_MESSAGE(request.segmentNumber().has_value(),
"Assigned SetDescriptor must "
"have a specific segment number");
BOOST_CHECK_EQUAL(request.segmentNumber().value(), 11);
request.segmentNumber("-1"sv);
BOOST_CHECK_MESSAGE(! request.segmentNumber().has_value(),
"Negative segment number must NOT "
"have a specifc segment number "
"in the final descriptor");
}
BOOST_AUTO_TEST_CASE(Invalid)
{
using namespace std::literals;
BOOST_CHECK_THROW(const auto request = Opm::SegmentMatcher::SetDescriptor{}
.segmentNumber("'1*'"sv), std::invalid_argument);
BOOST_CHECK_THROW(const auto request = Opm::SegmentMatcher::SetDescriptor{}
.segmentNumber("'123;'"sv), std::invalid_argument);
BOOST_CHECK_THROW(const auto request = Opm::SegmentMatcher::SetDescriptor{}
.segmentNumber("x"sv), std::invalid_argument);
BOOST_CHECK_THROW(const auto request = Opm::SegmentMatcher::SetDescriptor{}
.segmentNumber("-123-"sv), std::invalid_argument);
}
BOOST_AUTO_TEST_CASE(Leading_And_Trailing_Blanks)
{
using namespace std::literals;
BOOST_CHECK_THROW(const auto request = Opm::SegmentMatcher::SetDescriptor{}
.segmentNumber(" 123 "sv), std::invalid_argument);
BOOST_CHECK_THROW(const auto request = Opm::SegmentMatcher::SetDescriptor{}
.segmentNumber("' 1729'"sv), std::invalid_argument);
BOOST_CHECK_THROW(const auto request = Opm::SegmentMatcher::SetDescriptor{}
.segmentNumber("'27 '"sv), std::invalid_argument);
}
BOOST_AUTO_TEST_SUITE_END() // StringView_Overload
BOOST_AUTO_TEST_SUITE_END() // Segment_Number
// ---------------------------------------------------------------------------
BOOST_AUTO_TEST_SUITE(Well_Name_Pattern)
BOOST_AUTO_TEST_CASE(Single_Well)
{
const auto request = Opm::SegmentMatcher::SetDescriptor{}
.wellNames("OP01");
BOOST_REQUIRE_MESSAGE(request.wellNames().has_value(),
"Assigned SetDescriptor must "
"have a specific well name");
BOOST_CHECK_EQUAL(request.wellNames().value(), "OP01");
}
BOOST_AUTO_TEST_CASE(Well_Pattern)
{
const auto request = Opm::SegmentMatcher::SetDescriptor{}
.wellNames("OP01*");
BOOST_REQUIRE_MESSAGE(request.wellNames().has_value(),
"Assigned SetDescriptor must "
"have a specific well name");
BOOST_CHECK_EQUAL(request.wellNames().value(), "OP01*");
}
BOOST_AUTO_TEST_CASE(Asterisk)
{
const auto request = Opm::SegmentMatcher::SetDescriptor{}
.wellNames("*");
BOOST_CHECK_MESSAGE(request.wellNames().has_value(),
"Assigned SetDescriptor must "
"have a specific well name");
BOOST_CHECK_EQUAL(request.wellNames().value(), "*");
}
BOOST_AUTO_TEST_CASE(Invalid_Characters_Unchecked)
{
const auto request = Opm::SegmentMatcher::SetDescriptor{}
.wellNames("Ab+C;E^F/");
BOOST_CHECK_MESSAGE(request.wellNames().has_value(),
"Assigned SetDescriptor must "
"have a specific well name");
BOOST_CHECK_EQUAL(request.wellNames().value(), "Ab+C;E^F/");
}
BOOST_AUTO_TEST_SUITE_END() // Well_Name_Pattern
BOOST_AUTO_TEST_SUITE_END() // Set_Descriptor
// ===========================================================================
BOOST_AUTO_TEST_SUITE(Matcher)
namespace {
Opm::Segment makeSegment(const int segmentNumber)
{
return { segmentNumber, 1, 1, 1.0, 0.0, 0.5, 0.01, 0.25, 1.23, true, 0.0, 0.0 };
}
std::shared_ptr<Opm::WellSegments> makeSegments(const int numSegments)
{
auto segments = std::vector<Opm::Segment>{};
segments.reserve(numSegments);
for (auto segment = 0; segment < numSegments; ++segment) {
segments.push_back(makeSegment(segment + 1));
}
return std::make_shared<Opm::WellSegments>
(Opm::WellSegments::CompPressureDrop::HFA, segments);
}
Opm::Well makeProducerWell(const std::string& wname,
const std::size_t insert,
const int numSegments)
{
auto w = Opm::Well {
wname, "G", 0, insert, 1, 2, {},
Opm::WellType { true, Opm::Phase::OIL }, // Oil producer
Opm::Well::ProducerCMode::ORAT,
Opm::Connection::Order::INPUT,
Opm::UnitSystem::newMETRIC(),
-3.0e+20, // UDQ undefined
0.0, true, true, 0,
Opm::Well::GasInflowEquation::STD
};
if (numSegments > 0) {
w.updateSegments(makeSegments(numSegments));
}
return w;
}
Opm::Well makeInjectionWell(const std::string& wname,
const std::size_t insert,
const int numSegments)
{
auto w = Opm::Well {
wname, "G", 0, insert, 1, 2, {},
Opm::WellType { false, Opm::Phase::GAS }, // Gas injector
Opm::Well::ProducerCMode::ORAT,
Opm::Connection::Order::INPUT,
Opm::UnitSystem::newMETRIC(),
-3.0e+20, // UDQ undefined
0.0, true, true, 0,
Opm::Well::GasInflowEquation::STD
};
if (numSegments > 0) {
w.updateSegments(makeSegments(numSegments));
}
return w;
}
// Collection of wells
// OP-01: Producer, MSW, 20 segments (1 .. 20)
// OP-02: Producer, MSW, 5 segments (1 .. 5)
// OP-06: Producer, Standard well
// OPROD: Producer, MSW, 2 segments (1 .. 2)
//
// GI-01: Injector, MSW, 10 segments (1 .. 10)
// GI-08: Injector, Standard well
// I-45: Injector, MSW, 1 segment (1)
Opm::ScheduleState dynamicInputData()
{
auto block = Opm::ScheduleState { Opm::TimeService::now() };
block.wells.update(makeProducerWell("OP-01", 0, 20));
block.wells.update(makeProducerWell("OP-02", 1, 5));
block.wells.update(makeProducerWell("OP-06", 2, 0));
block.wells.update(makeProducerWell("OPROD", 3, 2));
block.wells.update(makeInjectionWell("GI-01", 4, 10));
block.wells.update(makeInjectionWell("GI-08", 5, 0));
block.wells.update(makeInjectionWell("I-45", 6, 1));
block.well_order.update(Opm::NameOrder {
"OP-01", "OP-02", "OP-06", "OPROD", "GI-01", "GI-08", "I-45",
});
return block;
}
}
BOOST_AUTO_TEST_SUITE(Indexed_Lookup)
BOOST_AUTO_TEST_CASE(Single_Well_Single_Segment)
{
// Note: Lifetime of input data must exceed that of matcher object
const auto mswInputData = dynamicInputData();
const auto matcher = Opm::SegmentMatcher { mswInputData };
{
const auto request = Opm::SegmentMatcher::SetDescriptor{}
.wellNames("OP-01").segmentNumber(17);
const auto segSet = matcher.findSegments(request);
BOOST_CHECK_MESSAGE(! segSet.empty(), "Resulting segment set must not be empty");
BOOST_CHECK_MESSAGE( segSet.isScalar(), "Resulting segment set must be scalar");
BOOST_CHECK_EQUAL(segSet.numWells(), std::size_t{1});
const auto expectWells = std::vector<std::string> { "OP-01" };
const auto expectSeg = std::vector<int> { 17 };
const auto segments = segSet.segments(0);
BOOST_CHECK_EQUAL(segments.well(), expectWells[0]);
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
{
const auto request = Opm::SegmentMatcher::SetDescriptor{}
.wellNames("OP-02").segmentNumber("5");
const auto segSet = matcher.findSegments(request);
BOOST_CHECK_MESSAGE(! segSet.empty(), "Resulting segment set must not be empty");
BOOST_CHECK_MESSAGE( segSet.isScalar(), "Resulting segment set must be scalar");
BOOST_CHECK_EQUAL(segSet.numWells(), std::size_t{1});
const auto expectWells = std::vector<std::string> { "OP-02" };
const auto expectSeg = std::vector<int> { 5 };
const auto segments = segSet.segments(0);
BOOST_CHECK_EQUAL(segments.well(), expectWells[0]);
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
}
BOOST_AUTO_TEST_CASE(Single_Well_All_Segments)
{
// Note: Lifetime of input data must exceed that of matcher object
const auto mswInputData = dynamicInputData();
const auto matcher = Opm::SegmentMatcher { mswInputData };
{
const auto request = Opm::SegmentMatcher::SetDescriptor{}
.wellNames("OP-01");
const auto segSet = matcher.findSegments(request);
BOOST_CHECK_MESSAGE(! segSet.empty(), "Resulting segment set must not be empty");
BOOST_CHECK_MESSAGE(! segSet.isScalar(), "Resulting segment set must not be scalar");
BOOST_CHECK_EQUAL(segSet.numWells(), std::size_t{1});
const auto expectWells = std::vector<std::string> { "OP-01" };
const auto expectSeg = std::vector<int> {
1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
};
const auto segments = segSet.segments(0);
BOOST_CHECK_EQUAL(segments.well(), expectWells[0]);
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
{
const auto request = Opm::SegmentMatcher::SetDescriptor{}
.wellNames("OP-02").segmentNumber("*");
const auto segSet = matcher.findSegments(request);
BOOST_CHECK_MESSAGE(! segSet.empty(), "Resulting segment set must not be empty");
BOOST_CHECK_MESSAGE(! segSet.isScalar(), "Resulting segment set must not be scalar");
BOOST_CHECK_EQUAL(segSet.numWells(), std::size_t{1});
const auto expectWells = std::vector<std::string> { "OP-02" };
const auto expectSeg = std::vector<int> { 1, 2, 3, 4, 5, };
const auto segments = segSet.segments(0);
BOOST_CHECK_EQUAL(segments.well(), expectWells[0]);
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
{
const auto request = Opm::SegmentMatcher::SetDescriptor{}
.wellNames("GI-01").segmentNumber("'-1'");
const auto segSet = matcher.findSegments(request);
BOOST_CHECK_MESSAGE(! segSet.empty(), "Resulting segment set must not be empty");
BOOST_CHECK_MESSAGE(! segSet.isScalar(), "Resulting segment set must be scalar");
const auto expectWells = std::vector<std::string> { "GI-01" };
const auto expectSeg = std::vector<int> {
1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
};
const auto segments = segSet.segments(0);
BOOST_CHECK_EQUAL(segments.well(), expectWells[0]);
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
}
BOOST_AUTO_TEST_CASE(Single_Well_Missing_Segments)
{
// Note: Lifetime of input data must exceed that of matcher object
const auto mswInputData = dynamicInputData();
const auto matcher = Opm::SegmentMatcher { mswInputData };
{
const auto request = Opm::SegmentMatcher::SetDescriptor{}
.wellNames("OP-01").segmentNumber(42);
const auto segSet = matcher.findSegments(request);
BOOST_CHECK_MESSAGE(segSet.empty(), "Resulting segment set must be empty");
}
{
const auto request = Opm::SegmentMatcher::SetDescriptor{}
.wellNames("OP-02").segmentNumber("'6'");
const auto segSet = matcher.findSegments(request);
BOOST_CHECK_MESSAGE(segSet.empty(), "Resulting segment set must be empty");
}
}
BOOST_AUTO_TEST_CASE(All_Wells_Single_Segment)
{
// Note: Lifetime of input data must exceed that of matcher object
const auto mswInputData = dynamicInputData();
const auto matcher = Opm::SegmentMatcher { mswInputData };
// Case 1: Unset wellNames(), filtered down to MS wells
{
const auto request = Opm::SegmentMatcher::SetDescriptor{}
.segmentNumber(1);
const auto segSet = matcher.findSegments(request);
BOOST_CHECK_MESSAGE(! segSet.empty(), "Resulting segment set must not be empty");
BOOST_CHECK_MESSAGE(! segSet.isScalar(), "Resulting segment set must not be scalar");
const auto expectWells = std::vector<std::string> {
"OP-01", "OP-02", "OPROD", "GI-01", "I-45",
};
BOOST_CHECK_EQUAL(segSet.numWells(), expectWells.size());
for (auto well = 0*segSet.numWells(); well < segSet.numWells(); ++well) {
const auto expectSeg = std::vector<int> { 1 };
const auto segments = segSet.segments(well);
BOOST_CHECK_EQUAL(segments.well(), expectWells[well]);
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
}
// Case 2: Pattern matching all wells, filtered down to MS wells
{
const auto request = Opm::SegmentMatcher::SetDescriptor{}
.wellNames("*").segmentNumber("'1'");
const auto segSet = matcher.findSegments(request);
BOOST_CHECK_MESSAGE(! segSet.empty(), "Resulting segment set must not be empty");
BOOST_CHECK_MESSAGE(! segSet.isScalar(), "Resulting segment set must not be scalar");
const auto expectWells = std::vector<std::string> {
"OP-01", "OP-02", "OPROD", "GI-01", "I-45",
};
BOOST_CHECK_EQUAL(segSet.numWells(), expectWells.size());
for (auto well = 0*segSet.numWells(); well < segSet.numWells(); ++well) {
const auto expectSeg = std::vector<int> { 1 };
const auto segments = segSet.segments(well);
BOOST_CHECK_EQUAL(segments.well(), expectWells[well]);
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
}
}
BOOST_AUTO_TEST_CASE(All_Wells_Single_Segment_Scalar)
{
// Note: Lifetime of input data must exceed that of matcher object
const auto mswInputData = dynamicInputData();
const auto matcher = Opm::SegmentMatcher { mswInputData };
const auto request = Opm::SegmentMatcher::SetDescriptor{}
.segmentNumber(14);
const auto segSet = matcher.findSegments(request);
BOOST_CHECK_MESSAGE(! segSet.empty(), "Resulting segment set must not be empty");
BOOST_CHECK_MESSAGE( segSet.isScalar(), "Resulting segment set must be scalar");
const auto expectWells = std::vector<std::string> {
"OP-01",
};
BOOST_CHECK_EQUAL(segSet.numWells(), expectWells.size());
for (auto well = 0*segSet.numWells(); well < segSet.numWells(); ++well) {
const auto expectSeg = std::vector<int> { 14 };
const auto segments = segSet.segments(well);
BOOST_CHECK_EQUAL(segments.well(), expectWells[well]);
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
}
BOOST_AUTO_TEST_CASE(All_Wells_Partially_Missing_Single_Segment)
{
// Note: Lifetime of input data must exceed that of matcher object
const auto mswInputData = dynamicInputData();
const auto matcher = Opm::SegmentMatcher { mswInputData };
// Case 1: Unset wellNames(), filtered down to MS wells whose segment
// set contains segment 2.
{
const auto request = Opm::SegmentMatcher::SetDescriptor{}
.segmentNumber(2);
const auto segSet = matcher.findSegments(request);
BOOST_CHECK_MESSAGE(! segSet.empty(), "Resulting segment set must not be empty");
BOOST_CHECK_MESSAGE(! segSet.isScalar(), "Resulting segment set must not be scalar");
const auto expectWells = std::vector<std::string> {
"OP-01", "OP-02", "OPROD", "GI-01"
};
BOOST_CHECK_EQUAL(segSet.numWells(), expectWells.size());
for (auto well = 0*segSet.numWells(); well < segSet.numWells(); ++well) {
const auto expectSeg = std::vector<int> { 2 };
const auto segments = segSet.segments(well);
BOOST_CHECK_EQUAL(segments.well(), expectWells[well]);
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
}
// Case 2: Pattern matching all wells, filtered down to MS wells whose
// segment set contains segment 7.
{
const auto request = Opm::SegmentMatcher::SetDescriptor{}
.wellNames("*").segmentNumber("'7'");
const auto segSet = matcher.findSegments(request);
BOOST_CHECK_MESSAGE(! segSet.empty(), "Resulting segment set must not be empty");
BOOST_CHECK_MESSAGE(! segSet.isScalar(), "Resulting segment set must not be scalar");
const auto expectWells = std::vector<std::string> {
"OP-01", "GI-01",
};
BOOST_CHECK_EQUAL(segSet.numWells(), expectWells.size());
for (auto well = 0*segSet.numWells(); well < segSet.numWells(); ++well) {
const auto expectSeg = std::vector<int> { 7 };
const auto segments = segSet.segments(well);
BOOST_CHECK_EQUAL(segments.well(), expectWells[well]);
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
}
}
BOOST_AUTO_TEST_CASE(All_Wells_All_Segments)
{
// Note: Lifetime of input data must exceed that of matcher object
const auto mswInputData = dynamicInputData();
const auto matcher = Opm::SegmentMatcher { mswInputData };
// Case 1: Unset wellNames(), unset segmentNumber(), filtered down to
// all segments in all MS wells.
{
const auto request = Opm::SegmentMatcher::SetDescriptor{};
const auto segSet = matcher.findSegments(request);
BOOST_CHECK_MESSAGE(! segSet.empty(), "Resulting segment set must not be empty");
BOOST_CHECK_MESSAGE(! segSet.isScalar(), "Resulting segment set must not be scalar");
const auto expectWells = std::vector<std::string> {
"OP-01", "OP-02", "OPROD", "GI-01", "I-45",
};
BOOST_CHECK_EQUAL(segSet.numWells(), expectWells.size());
// OP-01
{
const auto expectSeg = std::vector<int> {
1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
};
const auto segments = segSet.segments(0);
BOOST_CHECK_EQUAL(segments.well(), "OP-01");
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
// OP-02
{
const auto expectSeg = std::vector<int> { 1, 2, 3, 4, 5, };
const auto segments = segSet.segments(1);
BOOST_CHECK_EQUAL(segments.well(), "OP-02");
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
// OPROD
{
const auto expectSeg = std::vector<int> { 1, 2, };
const auto segments = segSet.segments(2);
BOOST_CHECK_EQUAL(segments.well(), "OPROD");
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
// GI-01
{
const auto expectSeg = std::vector<int> {
1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
};
const auto segments = segSet.segments(3);
BOOST_CHECK_EQUAL(segments.well(), "GI-01");
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
// I-45
{
const auto expectSeg = std::vector<int> { 1 };
const auto segments = segSet.segments(4);
BOOST_CHECK_EQUAL(segments.well(), "I-45");
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
}
// Case 2: Pattern matching all wells, unset segmentNumber(), filtered
// down to all segments in all MS wells..
{
const auto request = Opm::SegmentMatcher::SetDescriptor{}
.wellNames("*");
const auto segSet = matcher.findSegments(request);
BOOST_CHECK_MESSAGE(! segSet.empty(), "Resulting segment set must not be empty");
BOOST_CHECK_MESSAGE(! segSet.isScalar(), "Resulting segment set must not be scalar");
const auto expectWells = std::vector<std::string> {
"OP-01", "OP-02", "OPROD", "GI-01", "I-45",
};
BOOST_CHECK_EQUAL(segSet.numWells(), expectWells.size());
// OP-01
{
const auto expectSeg = std::vector<int> {
1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
};
const auto segments = segSet.segments(0);
BOOST_CHECK_EQUAL(segments.well(), "OP-01");
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
// OP-02
{
const auto expectSeg = std::vector<int> { 1, 2, 3, 4, 5, };
const auto segments = segSet.segments(1);
BOOST_CHECK_EQUAL(segments.well(), "OP-02");
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
// OPROD
{
const auto expectSeg = std::vector<int> { 1, 2, };
const auto segments = segSet.segments(2);
BOOST_CHECK_EQUAL(segments.well(), "OPROD");
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
// GI-01
{
const auto expectSeg = std::vector<int> {
1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
};
const auto segments = segSet.segments(3);
BOOST_CHECK_EQUAL(segments.well(), "GI-01");
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
// I-45
{
const auto expectSeg = std::vector<int> { 1 };
const auto segments = segSet.segments(4);
BOOST_CHECK_EQUAL(segments.well(), "I-45");
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
}
}
BOOST_AUTO_TEST_CASE(Select_Wells_Single_Segment)
{
// Note: Lifetime of input data must exceed that of matcher object
const auto mswInputData = dynamicInputData();
const auto matcher = Opm::SegmentMatcher { mswInputData };
// Case 1: Selected wells, specific segmentNumber(), filtered down to
// those MS wells which match the pattern and which have that segment.
{
const auto request = Opm::SegmentMatcher::SetDescriptor{}
.wellNames("OP-*").segmentNumber(3);
const auto segSet = matcher.findSegments(request);
BOOST_CHECK_MESSAGE(! segSet.empty(), "Resulting segment set must not be empty");
BOOST_CHECK_MESSAGE(! segSet.isScalar(), "Resulting segment set must not be scalar");
const auto expectWells = std::vector<std::string> {
"OP-01", "OP-02",
};
BOOST_CHECK_EQUAL(segSet.numWells(), expectWells.size());
for (auto well = 0*segSet.numWells(); well < segSet.numWells(); ++well) {
const auto expectSeg = std::vector<int> { 3 };
const auto segments = segSet.segments(well);
BOOST_CHECK_EQUAL(segments.well(), expectWells[well]);
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
}
// Case 2: Selected wells, specific segmentNumber(), filtered down to
// those MS wells which match the pattern and which have that segment.
{
const auto request = Opm::SegmentMatcher::SetDescriptor{}
.wellNames("I*").segmentNumber(1);
const auto segSet = matcher.findSegments(request);
BOOST_CHECK_MESSAGE(! segSet.empty(), "Resulting segment set must not be empty");
BOOST_CHECK_MESSAGE( segSet.isScalar(), "Resulting segment set must not be scalar");
const auto expectWells = std::vector<std::string> {
"I-45",
};
BOOST_CHECK_EQUAL(segSet.numWells(), expectWells.size());
for (auto well = 0*segSet.numWells(); well < segSet.numWells(); ++well) {
const auto expectSeg = std::vector<int> { 1 };
const auto segments = segSet.segments(well);
BOOST_CHECK_EQUAL(segments.well(), expectWells[well]);
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
}
}
BOOST_AUTO_TEST_CASE(Select_Wells_Partially_Missing_Segment)
{
// Note: Lifetime of input data must exceed that of matcher object
const auto mswInputData = dynamicInputData();
const auto matcher = Opm::SegmentMatcher { mswInputData };
// Selected wells, specific segmentNumber(), filtered down to those MS
// wells which match the pattern and which have that segment.
const auto request = Opm::SegmentMatcher::SetDescriptor{}
.wellNames("OP*").segmentNumber(3);
const auto segSet = matcher.findSegments(request);
BOOST_CHECK_MESSAGE(! segSet.empty(), "Resulting segment set must not be empty");
BOOST_CHECK_MESSAGE(! segSet.isScalar(), "Resulting segment set must not be scalar");
const auto expectWells = std::vector<std::string> {
"OP-01", "OP-02",
};
BOOST_CHECK_EQUAL(segSet.numWells(), expectWells.size());
for (auto well = 0*segSet.numWells(); well < segSet.numWells(); ++well) {
const auto expectSeg = std::vector<int> { 3 };
const auto segments = segSet.segments(well);
BOOST_CHECK_EQUAL(segments.well(), expectWells[well]);
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
}
BOOST_AUTO_TEST_CASE(Select_Wells_All_Segments)
{
// Note: Lifetime of input data must exceed that of matcher object
const auto mswInputData = dynamicInputData();
const auto matcher = Opm::SegmentMatcher { mswInputData };
// Producer wells, unset segmentNumber(), filtered down to all segments
// in those MS producer wells which match the well name pattern.
{
const auto request = Opm::SegmentMatcher::SetDescriptor{}
.wellNames("OP*");
const auto segSet = matcher.findSegments(request);
BOOST_CHECK_MESSAGE(! segSet.empty(), "Resulting segment set must not be empty");
BOOST_CHECK_MESSAGE(! segSet.isScalar(), "Resulting segment set must not be scalar");
const auto expectWells = std::vector<std::string> {
"OP-01", "OP-02", "OPROD",
};
BOOST_CHECK_EQUAL(segSet.numWells(), expectWells.size());
// OP-01
{
const auto expectSeg = std::vector<int> {
1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
};
const auto segments = segSet.segments(0);
BOOST_CHECK_EQUAL(segments.well(), "OP-01");
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
// OP-02
{
const auto expectSeg = std::vector<int> { 1, 2, 3, 4, 5, };
const auto segments = segSet.segments(1);
BOOST_CHECK_EQUAL(segments.well(), "OP-02");
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
// OPROD
{
const auto expectSeg = std::vector<int> { 1, 2, };
const auto segments = segSet.segments(2);
BOOST_CHECK_EQUAL(segments.well(), "OPROD");
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
}
// Selected producer wells, defaulted segmentNumber(), filtered down to
// all segments in those MS producer wells which match the well name
// pattern.
{
const auto request = Opm::SegmentMatcher::SetDescriptor{}
.wellNames("OPR*").segmentNumber("'-1'");
const auto segSet = matcher.findSegments(request);
BOOST_CHECK_MESSAGE(! segSet.empty(), "Resulting segment set must not be empty");
BOOST_CHECK_MESSAGE(! segSet.isScalar(), "Resulting segment set must not be scalar");
const auto expectWells = std::vector<std::string> {
"OPROD",
};
BOOST_CHECK_EQUAL(segSet.numWells(), expectWells.size());
// OPROD
{
const auto expectSeg = std::vector<int> { 1, 2, };
const auto segments = segSet.segments(0);
BOOST_CHECK_EQUAL(segments.well(), "OPROD");
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
}
}
BOOST_AUTO_TEST_CASE(Select_Wells_Missing_Segments)
{
// Note: Lifetime of input data must exceed that of matcher object
const auto mswInputData = dynamicInputData();
const auto matcher = Opm::SegmentMatcher { mswInputData };
const auto request = Opm::SegmentMatcher::SetDescriptor{}
.wellNames("OP*").segmentNumber(42);
const auto segSet = matcher.findSegments(request);
BOOST_CHECK_MESSAGE(segSet.empty(), "Resulting segment set must be empty");
}
BOOST_AUTO_TEST_SUITE_END() // Indexed_Lookup
// ---------------------------------------------------------------------------
BOOST_AUTO_TEST_SUITE(WellName_Lookup)
BOOST_AUTO_TEST_CASE(Single_Well_Single_Segment)
{
// Note: Lifetime of input data must exceed that of matcher object
const auto mswInputData = dynamicInputData();
const auto matcher = Opm::SegmentMatcher { mswInputData };
{
const auto request = Opm::SegmentMatcher::SetDescriptor{}
.wellNames("OP-01").segmentNumber(17);
const auto segSet = matcher.findSegments(request);
BOOST_CHECK_MESSAGE(! segSet.empty(), "Resulting segment set must not be empty");
BOOST_CHECK_MESSAGE( segSet.isScalar(), "Resulting segment set must be scalar");
const auto expectWells = std::vector<std::string> { "OP-01" };
const auto wells = segSet.wells();
BOOST_CHECK_EQUAL_COLLECTIONS(wells .begin(), wells .end(),
expectWells.begin(), expectWells.end());
const auto expectSeg = std::vector<int> { 17 };
const auto segments = segSet.segments(wells[0]);
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
{
const auto request = Opm::SegmentMatcher::SetDescriptor{}
.wellNames("OP-02").segmentNumber("5");
const auto segSet = matcher.findSegments(request);
BOOST_CHECK_MESSAGE(! segSet.empty(), "Resulting segment set must not be empty");
BOOST_CHECK_MESSAGE( segSet.isScalar(), "Resulting segment set must be scalar");
const auto expectWells = std::vector<std::string> { "OP-02" };
const auto wells = segSet.wells();
BOOST_CHECK_EQUAL_COLLECTIONS(wells .begin(), wells .end(),
expectWells.begin(), expectWells.end());
const auto expectSeg = std::vector<int> { 5 };
const auto segments = segSet.segments(wells[0]);
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
}
BOOST_AUTO_TEST_CASE(Single_Well_All_Segments)
{
// Note: Lifetime of input data must exceed that of matcher object
const auto mswInputData = dynamicInputData();
const auto matcher = Opm::SegmentMatcher { mswInputData };
{
const auto request = Opm::SegmentMatcher::SetDescriptor{}
.wellNames("OP-01");
const auto segSet = matcher.findSegments(request);
BOOST_CHECK_MESSAGE(! segSet.empty(), "Resulting segment set must not be empty");
BOOST_CHECK_MESSAGE(! segSet.isScalar(), "Resulting segment set must not be scalar");
const auto expectWells = std::vector<std::string> { "OP-01" };
const auto wells = segSet.wells();
BOOST_CHECK_EQUAL_COLLECTIONS(wells .begin(), wells .end(),
expectWells.begin(), expectWells.end());
const auto expectSeg = std::vector<int> {
1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
};
const auto segments = segSet.segments(wells[0]);
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
{
const auto request = Opm::SegmentMatcher::SetDescriptor{}
.wellNames("OP-02").segmentNumber("*");
const auto segSet = matcher.findSegments(request);
BOOST_CHECK_MESSAGE(! segSet.empty(), "Resulting segment set must not be empty");
BOOST_CHECK_MESSAGE(! segSet.isScalar(), "Resulting segment set must not be scalar");
const auto expectWells = std::vector<std::string> { "OP-02" };
const auto wells = segSet.wells();
BOOST_CHECK_EQUAL_COLLECTIONS(wells .begin(), wells .end(),
expectWells.begin(), expectWells.end());
const auto expectSeg = std::vector<int> { 1, 2, 3, 4, 5, };
const auto segments = segSet.segments(wells[0]);
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
{
const auto request = Opm::SegmentMatcher::SetDescriptor{}
.wellNames("GI-01").segmentNumber("'-1'");
const auto segSet = matcher.findSegments(request);
BOOST_CHECK_MESSAGE(! segSet.empty(), "Resulting segment set must not be empty");
BOOST_CHECK_MESSAGE(! segSet.isScalar(), "Resulting segment set must be scalar");
const auto expectWells = std::vector<std::string> { "GI-01" };
const auto wells = segSet.wells();
BOOST_CHECK_EQUAL_COLLECTIONS(wells .begin(), wells .end(),
expectWells.begin(), expectWells.end());
const auto expectSeg = std::vector<int> {
1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
};
const auto segments = segSet.segments(wells[0]);
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
}
BOOST_AUTO_TEST_CASE(All_Wells_Single_Segment)
{
// Note: Lifetime of input data must exceed that of matcher object
const auto mswInputData = dynamicInputData();
const auto matcher = Opm::SegmentMatcher { mswInputData };
// Case 1: Unset wellNames(), filtered down to MS wells
{
const auto request = Opm::SegmentMatcher::SetDescriptor{}
.segmentNumber(1);
const auto segSet = matcher.findSegments(request);
BOOST_CHECK_MESSAGE(! segSet.empty(), "Resulting segment set must not be empty");
BOOST_CHECK_MESSAGE(! segSet.isScalar(), "Resulting segment set must not be scalar");
const auto expectWells = std::vector<std::string> {
"OP-01", "OP-02", "OPROD", "GI-01", "I-45",
};
const auto wells = segSet.wells();
BOOST_CHECK_EQUAL_COLLECTIONS(wells .begin(), wells .end(),
expectWells.begin(), expectWells.end());
for (const auto& well : wells) {
const auto expectSeg = std::vector<int> { 1 };
const auto segments = segSet.segments(well);
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
}
// Case 2: Pattern matching all wells, filtered down to MS wells
{
const auto request = Opm::SegmentMatcher::SetDescriptor{}
.wellNames("*").segmentNumber("'1'");
const auto segSet = matcher.findSegments(request);
BOOST_CHECK_MESSAGE(! segSet.empty(), "Resulting segment set must not be empty");
BOOST_CHECK_MESSAGE(! segSet.isScalar(), "Resulting segment set must not be scalar");
const auto expectWells = std::vector<std::string> {
"OP-01", "OP-02", "OPROD", "GI-01", "I-45",
};
const auto wells = segSet.wells();
BOOST_CHECK_EQUAL_COLLECTIONS(wells .begin(), wells .end(),
expectWells.begin(), expectWells.end());
for (const auto& well : wells) {
const auto expectSeg = std::vector<int> { 1 };
const auto segments = segSet.segments(well);
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
}
}
BOOST_AUTO_TEST_CASE(All_Wells_Single_Segment_Scalar)
{
// Note: Lifetime of input data must exceed that of matcher object
const auto mswInputData = dynamicInputData();
const auto matcher = Opm::SegmentMatcher { mswInputData };
const auto request = Opm::SegmentMatcher::SetDescriptor{}
.segmentNumber(14);
const auto segSet = matcher.findSegments(request);
BOOST_CHECK_MESSAGE(! segSet.empty(), "Resulting segment set must not be empty");
BOOST_CHECK_MESSAGE( segSet.isScalar(), "Resulting segment set must be scalar");
const auto expectWells = std::vector<std::string> {
"OP-01",
};
const auto wells = segSet.wells();
BOOST_CHECK_EQUAL_COLLECTIONS(wells .begin(), wells .end(),
expectWells.begin(), expectWells.end());
for (const auto& well : wells) {
const auto expectSeg = std::vector<int> { 14 };
const auto segments = segSet.segments(well);
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
}
BOOST_AUTO_TEST_CASE(All_Wells_Partially_Missing_Single_Segment)
{
// Note: Lifetime of input data must exceed that of matcher object
const auto mswInputData = dynamicInputData();
const auto matcher = Opm::SegmentMatcher { mswInputData };
// Case 1: Unset wellNames(), filtered down to MS wells whose segment
// set contains segment 2.
{
const auto request = Opm::SegmentMatcher::SetDescriptor{}
.segmentNumber(2);
const auto segSet = matcher.findSegments(request);
BOOST_CHECK_MESSAGE(! segSet.empty(), "Resulting segment set must not be empty");
BOOST_CHECK_MESSAGE(! segSet.isScalar(), "Resulting segment set must not be scalar");
const auto expectWells = std::vector<std::string> {
"OP-01", "OP-02", "OPROD", "GI-01"
};
const auto wells = segSet.wells();
BOOST_CHECK_EQUAL_COLLECTIONS(wells .begin(), wells .end(),
expectWells.begin(), expectWells.end());
for (const auto& well : wells) {
const auto expectSeg = std::vector<int> { 2 };
const auto segments = segSet.segments(well);
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
}
// Case 2: Pattern matching all wells, filtered down to MS wells whose
// segment set contains segment 7.
{
const auto request = Opm::SegmentMatcher::SetDescriptor{}
.wellNames("*").segmentNumber("'7'");
const auto segSet = matcher.findSegments(request);
BOOST_CHECK_MESSAGE(! segSet.empty(), "Resulting segment set must not be empty");
BOOST_CHECK_MESSAGE(! segSet.isScalar(), "Resulting segment set must not be scalar");
const auto expectWells = std::vector<std::string> {
"OP-01", "GI-01",
};
const auto wells = segSet.wells();
BOOST_CHECK_EQUAL_COLLECTIONS(wells .begin(), wells .end(),
expectWells.begin(), expectWells.end());
for (const auto& well : wells) {
const auto expectSeg = std::vector<int> { 7 };
const auto segments = segSet.segments(well);
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
}
}
BOOST_AUTO_TEST_CASE(All_Wells_All_Segments)
{
// Note: Lifetime of input data must exceed that of matcher object
const auto mswInputData = dynamicInputData();
const auto matcher = Opm::SegmentMatcher { mswInputData };
// Case 1: Unset wellNames(), unset segmentNumber(), filtered down to
// all segments in all MS wells.
{
const auto request = Opm::SegmentMatcher::SetDescriptor{};
const auto segSet = matcher.findSegments(request);
BOOST_CHECK_MESSAGE(! segSet.empty(), "Resulting segment set must not be empty");
BOOST_CHECK_MESSAGE(! segSet.isScalar(), "Resulting segment set must not be scalar");
const auto expectWells = std::vector<std::string> {
"OP-01", "OP-02", "OPROD", "GI-01", "I-45",
};
const auto wells = segSet.wells();
BOOST_CHECK_EQUAL_COLLECTIONS(wells .begin(), wells .end(),
expectWells.begin(), expectWells.end());
// OP-01
{
const auto expectSeg = std::vector<int> {
1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
};
const auto segments = segSet.segments("OP-01");
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
// OP-02
{
const auto expectSeg = std::vector<int> { 1, 2, 3, 4, 5, };
const auto segments = segSet.segments("OP-02");
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
// OPROD
{
const auto expectSeg = std::vector<int> { 1, 2, };
const auto segments = segSet.segments("OPROD");
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
// GI-01
{
const auto expectSeg = std::vector<int> {
1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
};
const auto segments = segSet.segments("GI-01");
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
// I-45
{
const auto expectSeg = std::vector<int> { 1 };
const auto segments = segSet.segments("I-45");
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
}
// Case 2: Pattern matching all wells, unset segmentNumber(), filtered
// down to all segments in all MS wells..
{
const auto request = Opm::SegmentMatcher::SetDescriptor{}
.wellNames("*");
const auto segSet = matcher.findSegments(request);
BOOST_CHECK_MESSAGE(! segSet.empty(), "Resulting segment set must not be empty");
BOOST_CHECK_MESSAGE(! segSet.isScalar(), "Resulting segment set must not be scalar");
const auto expectWells = std::vector<std::string> {
"OP-01", "OP-02", "OPROD", "GI-01", "I-45",
};
const auto wells = segSet.wells();
BOOST_CHECK_EQUAL_COLLECTIONS(wells .begin(), wells .end(),
expectWells.begin(), expectWells.end());
// OP-01
{
const auto expectSeg = std::vector<int> {
1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
};
const auto segments = segSet.segments("OP-01");
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
// OP-02
{
const auto expectSeg = std::vector<int> { 1, 2, 3, 4, 5, };
const auto segments = segSet.segments("OP-02");
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
// OPROD
{
const auto expectSeg = std::vector<int> { 1, 2, };
const auto segments = segSet.segments("OPROD");
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
// GI-01
{
const auto expectSeg = std::vector<int> {
1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
};
const auto segments = segSet.segments("GI-01");
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
// I-45
{
const auto expectSeg = std::vector<int> { 1 };
const auto segments = segSet.segments("I-45");
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
}
}
BOOST_AUTO_TEST_CASE(All_Wells_Missing_Segments)
{
// Note: Lifetime of input data must exceed that of matcher object
const auto mswInputData = dynamicInputData();
const auto matcher = Opm::SegmentMatcher { mswInputData };
const auto request = Opm::SegmentMatcher::SetDescriptor{}
.segmentNumber(42);
const auto segSet = matcher.findSegments(request);
BOOST_CHECK_MESSAGE(segSet.empty(), "Resulting segment set must be empty");
}
BOOST_AUTO_TEST_CASE(Select_Wells_Single_Segment)
{
// Note: Lifetime of input data must exceed that of matcher object
const auto mswInputData = dynamicInputData();
const auto matcher = Opm::SegmentMatcher { mswInputData };
// Case 1: Selected wells, specific segmentNumber(), filtered down to
// those MS wells which match the pattern and which have that segment.
{
const auto request = Opm::SegmentMatcher::SetDescriptor{}
.wellNames("OP-*").segmentNumber(3);
const auto segSet = matcher.findSegments(request);
BOOST_CHECK_MESSAGE(! segSet.empty(), "Resulting segment set must not be empty");
BOOST_CHECK_MESSAGE(! segSet.isScalar(), "Resulting segment set must not be scalar");
const auto expectWells = std::vector<std::string> {
"OP-01", "OP-02",
};
const auto wells = segSet.wells();
BOOST_CHECK_EQUAL_COLLECTIONS(wells .begin(), wells .end(),
expectWells.begin(), expectWells.end());
for (const auto& well : wells) {
const auto expectSeg = std::vector<int> { 3 };
const auto segments = segSet.segments(well);
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
}
// Case 2: Selected wells, specific segmentNumber(), filtered down to
// those MS wells which match the pattern and which have that segment.
{
const auto request = Opm::SegmentMatcher::SetDescriptor{}
.wellNames("I*").segmentNumber(1);
const auto segSet = matcher.findSegments(request);
BOOST_CHECK_MESSAGE(! segSet.empty(), "Resulting segment set must not be empty");
BOOST_CHECK_MESSAGE( segSet.isScalar(), "Resulting segment set must not be scalar");
const auto expectWells = std::vector<std::string> {
"I-45",
};
const auto wells = segSet.wells();
BOOST_CHECK_EQUAL_COLLECTIONS(wells .begin(), wells .end(),
expectWells.begin(), expectWells.end());
for (const auto& well : wells) {
const auto expectSeg = std::vector<int> { 1 };
const auto segments = segSet.segments(well);
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
}
}
BOOST_AUTO_TEST_CASE(Select_Wells_Partially_Missing_Segment)
{
// Note: Lifetime of input data must exceed that of matcher object
const auto mswInputData = dynamicInputData();
const auto matcher = Opm::SegmentMatcher { mswInputData };
// Selected wells, specific segmentNumber(), filtered down to those MS
// wells which match the pattern and which have that segment.
const auto request = Opm::SegmentMatcher::SetDescriptor{}
.wellNames("OP*").segmentNumber(3);
const auto segSet = matcher.findSegments(request);
BOOST_CHECK_MESSAGE(! segSet.empty(), "Resulting segment set must not be empty");
BOOST_CHECK_MESSAGE(! segSet.isScalar(), "Resulting segment set must not be scalar");
const auto expectWells = std::vector<std::string> {
"OP-01", "OP-02",
};
const auto wells = segSet.wells();
BOOST_CHECK_EQUAL_COLLECTIONS(wells .begin(), wells .end(),
expectWells.begin(), expectWells.end());
for (const auto& well : wells) {
const auto expectSeg = std::vector<int> { 3 };
const auto segments = segSet.segments(well);
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
}
BOOST_AUTO_TEST_CASE(Select_Wells_All_Segments)
{
// Note: Lifetime of input data must exceed that of matcher object
const auto mswInputData = dynamicInputData();
const auto matcher = Opm::SegmentMatcher { mswInputData };
// Producer wells, unset segmentNumber(), filtered down to all segments
// in those MS producer wells which match the well name pattern.
{
const auto request = Opm::SegmentMatcher::SetDescriptor{}
.wellNames("OP*");
const auto segSet = matcher.findSegments(request);
BOOST_CHECK_MESSAGE(! segSet.empty(), "Resulting segment set must not be empty");
BOOST_CHECK_MESSAGE(! segSet.isScalar(), "Resulting segment set must not be scalar");
const auto expectWells = std::vector<std::string> {
"OP-01", "OP-02", "OPROD",
};
const auto wells = segSet.wells();
BOOST_CHECK_EQUAL_COLLECTIONS(wells .begin(), wells .end(),
expectWells.begin(), expectWells.end());
// OP-01
{
const auto expectSeg = std::vector<int> {
1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
};
const auto segments = segSet.segments("OP-01");
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
// OP-02
{
const auto expectSeg = std::vector<int> { 1, 2, 3, 4, 5, };
const auto segments = segSet.segments("OP-02");
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
// OPROD
{
const auto expectSeg = std::vector<int> { 1, 2, };
const auto segments = segSet.segments("OPROD");
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
}
// Selected producer wells, defaulted segmentNumber(), filtered down to
// all segments in those MS producer wells which match the well name
// pattern.
{
const auto request = Opm::SegmentMatcher::SetDescriptor{}
.wellNames("OPR*").segmentNumber("'-1'");
const auto segSet = matcher.findSegments(request);
BOOST_CHECK_MESSAGE(! segSet.empty(), "Resulting segment set must not be empty");
BOOST_CHECK_MESSAGE(! segSet.isScalar(), "Resulting segment set must not be scalar");
const auto expectWells = std::vector<std::string> {
"OPROD",
};
const auto wells = segSet.wells();
BOOST_CHECK_EQUAL_COLLECTIONS(wells .begin(), wells .end(),
expectWells.begin(), expectWells.end());
// OPROD
{
const auto expectSeg = std::vector<int> { 1, 2, };
const auto segments = segSet.segments("OPROD");
BOOST_CHECK_EQUAL_COLLECTIONS(segments .begin(), segments .end(),
expectSeg.begin(), expectSeg.end());
}
}
}
BOOST_AUTO_TEST_CASE(Missing_Wells_Specific_Segments)
{
// Note: Lifetime of input data must exceed that of matcher object
const auto mswInputData = dynamicInputData();
const auto matcher = Opm::SegmentMatcher { mswInputData };
{
const auto request = Opm::SegmentMatcher::SetDescriptor{}
.wellNames("Hello").segmentNumber(2);
const auto segSet = matcher.findSegments(request);
BOOST_CHECK_MESSAGE(segSet.empty(), "Resulting segment set must be empty");
}
{
const auto request = Opm::SegmentMatcher::SetDescriptor{}
.wellNames("OIL*").segmentNumber("11");
const auto segSet = matcher.findSegments(request);
BOOST_CHECK_MESSAGE(segSet.empty(), "Resulting segment set must be empty");
}
}
BOOST_AUTO_TEST_SUITE_END() // WellName_Lookup
BOOST_AUTO_TEST_SUITE_END() // Matcher