OilfieldToolsNet/opm-common
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
19ecc3d30e6dd81cba571afbfe464d3df09133a6
opm-common/tests/parser/GroupTests.cpp
Bård Skaflestad 19ecc3d30e Consider Active Phases When Initializing Satfunc Endpoints 
This commit passes the run's notion of its active phases, an object
of type Opm::Phases, through to the initialisation layer for the
saturation functions' scaling properties.  In particular, this
allows us to discriminate between the phases and to not index into
tables or properties that would not be appropriate (e.g., maximum
gas saturation (SGU) in a simulation run without active gas).

Moreover, we now have enough information to know to look for SOF2 in
two-phase run using family II saturation function keywords.  These
changes are necessary in order to extend Flow's support for the
FILLEPS output request to two-phase runs.
2020-01-29 16:34:15 +01:00

446 lines
14 KiB
C++
Raw Blame History

/*
Copyright 2013 Statoil 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/>.
*/
#include <stdexcept>
#include <iostream>
#include <boost/filesystem.hpp>
#define BOOST_TEST_MODULE GroupTests
#include <boost/test/unit_test.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <opm/parser/eclipse/Deck/Deck.hpp>
#include <opm/parser/eclipse/Parser/Parser.hpp>
#include <opm/parser/eclipse/Parser/ParseContext.hpp>
#include <opm/parser/eclipse/EclipseState/Util/Value.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/FieldPropsManager.hpp>
#include <opm/parser/eclipse/EclipseState/Runspec.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Group/Group.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Group/GuideRateModel.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Group/GuideRate.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/SummaryState.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/WellProductionProperties.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/WellInjectionProperties.hpp>
using namespace Opm;
BOOST_AUTO_TEST_CASE(CreateGroup_CorrectNameAndDefaultValues) {
Opm::Group group("G1" , 1, 0, 0, UnitSystem::newMETRIC());
BOOST_CHECK_EQUAL( "G1" , group.name() );
}
BOOST_AUTO_TEST_CASE(CreateGroupCreateTimeOK) {
Opm::Group group("G1" , 1, 5, 0, UnitSystem::newMETRIC());
BOOST_CHECK_EQUAL( false, group.defined( 4 ));
BOOST_CHECK_EQUAL( true, group.defined( 5 ));
BOOST_CHECK_EQUAL( true, group.defined( 6 ));
}
BOOST_AUTO_TEST_CASE(CreateGroup_SetInjectorProducer_CorrectStatusSet) {
Opm::Group group1("IGROUP" , 1, 0, 0, UnitSystem::newMETRIC());
Opm::Group group2("PGROUP" , 2, 0, 0, UnitSystem::newMETRIC());
group1.setProductionGroup();
BOOST_CHECK(group1.isProductionGroup());
BOOST_CHECK(!group1.isInjectionGroup());
group2.setInjectionGroup();
BOOST_CHECK(!group2.isProductionGroup());
BOOST_CHECK(group2.isInjectionGroup());
}
BOOST_AUTO_TEST_CASE(ControlModeOK) {
Opm::Group group("G1" , 1, 0, 0, UnitSystem::newMETRIC());
Opm::SummaryState st(std::chrono::system_clock::now());
const auto& inj = group.injectionControls(st);
BOOST_CHECK( Opm::Group::InjectionCMode::NONE == inj.cmode);
}
BOOST_AUTO_TEST_CASE(GroupChangePhaseSameTimeThrows) {
Opm::Group group("G1" , 1, 0, 0, UnitSystem::newMETRIC());
Opm::SummaryState st(std::chrono::system_clock::now());
const auto& inj = group.injectionControls(st);
BOOST_CHECK_EQUAL( Opm::Phase::WATER , inj.phase); // Default phase - assumed WATER
}
BOOST_AUTO_TEST_CASE(GroupDoesNotHaveWell) {
Opm::Group group("G1" , 1, 0, 0, UnitSystem::newMETRIC());
BOOST_CHECK_EQUAL(false , group.hasWell("NO"));
BOOST_CHECK_EQUAL(0U , group.numWells());
}
BOOST_AUTO_TEST_CASE(createDeckWithGEFAC) {
Opm::Parser parser;
std::string input =
"START -- 0 \n"
"19 JUN 2007 / \n"
"SCHEDULE\n"
"WELSPECS\n"
" 'B-37T2' 'PRODUC' 9 9 1* 'OIL' 1* 1* 1* 1* 1* 1* 1* / \n"
" 'B-43A' 'PRODUC' 8 8 1* 'OIL' 1* 1* 1* 1* 1* 1* 1* / \n"
"/\n"
"COMPDAT\n"
" 'B-37T2' 9 9 1 1 'OPEN' 1* 32.948 0.311 3047.839 1* 1* 'X' 22.100 / \n"
" 'B-43A' 8 8 2 2 'OPEN' 1* 46.825 0.311 4332.346 1* 1* 'X' 22.123 / \n"
"/\n"
"GEFAC\n"
" 'PRODUC' 0.85 / \n"
"/\n";
auto deck = parser.parseString(input);
EclipseGrid grid(10,10,10);
TableManager table ( deck );
Runspec runspec (deck );
FieldPropsManager fp( deck, Phases{true, true, true}, grid, table);
Opm::Schedule schedule(deck, grid, fp, runspec);
auto group_names = schedule.groupNames("PRODUC");
BOOST_CHECK_EQUAL(group_names.size(), 1);
BOOST_CHECK_EQUAL(group_names[0], "PRODUC");
const auto& group1 = schedule.getGroup("PRODUC", 0);
BOOST_CHECK_EQUAL(group1.getGroupEfficiencyFactor(), 0.85);
BOOST_CHECK(group1.getTransferGroupEfficiencyFactor());
}
BOOST_AUTO_TEST_CASE(createDeckWithWGRUPCONandWCONPROD) {
/* Test deck with well guide rates for group control:
GRUPCON (well guide rates for group control)
WCONPROD (conrol data for production wells) with GRUP control mode */
Opm::Parser parser;
std::string input =
"START -- 0 \n"
"19 JUN 2007 / \n"
"SCHEDULE\n"
"WELSPECS\n"
" 'B-37T2' 'PRODUC' 9 9 1* 'OIL' 1* 1* 1* 1* 1* 1* 1* / \n"
" 'B-43A' 'PRODUC' 8 8 1* 'OIL' 1* 1* 1* 1* 1* 1* 1* / \n"
"/\n"
"COMPDAT\n"
" 'B-37T2' 9 9 1 1 'OPEN' 1* 32.948 0.311 3047.839 1* 1* 'X' 22.100 / \n"
" 'B-43A' 8 8 2 2 'OPEN' 1* 46.825 0.311 4332.346 1* 1* 'X' 22.123 / \n"
"/\n"
"WGRUPCON\n"
" 'B-37T2' YES 30 OIL / \n"
" 'B-43A' YES 30 OIL / \n"
"/\n"
"WCONPROD\n"
" 'B-37T2' 'OPEN' 'GRUP' 1000 2* 2000.000 2* 1* 10 200000.000 5* / / \n"
" 'B-43A' 'OPEN' 'GRUP' 1200 2* 3000.000 2* 1* 11 0.000 5* / / \n"
"/\n";
auto deck = parser.parseString(input);
EclipseGrid grid(10,10,10);
TableManager table ( deck );
FieldPropsManager fp( deck, Phases{true, true, true}, grid, table);
Runspec runspec (deck );
Opm::Schedule schedule(deck, grid, fp, runspec);
const auto& currentWell = schedule.getWell("B-37T2", 0);
const Opm::Well::WellProductionProperties& wellProductionProperties = currentWell.getProductionProperties();
BOOST_CHECK(wellProductionProperties.controlMode == Opm::Well::ProducerCMode::GRUP);
BOOST_CHECK_EQUAL(currentWell.isAvailableForGroupControl(), true);
BOOST_CHECK_EQUAL(currentWell.getGuideRate(), 30);
BOOST_CHECK(currentWell.getGuideRatePhase() == Opm::Well::GuideRateTarget::OIL);
BOOST_CHECK_EQUAL(currentWell.getGuideRateScalingFactor(), 1.0);
}
BOOST_AUTO_TEST_CASE(createDeckWithGRUPNET) {
Opm::Parser parser;
std::string input =
"START -- 0 \n"
"31 AUG 1993 / \n"
"SCHEDULE\n"
"GRUPNET \n"
" 'FIELD' 20.000 5* / \n"
" 'PROD' 20.000 5* / \n"
" 'MANI-B2' 1* 8 1* 'NO' 2* / \n"
" 'MANI-B1' 1* 8 1* 'NO' 2* / \n"
" 'MANI-K1' 1* 9999 4* / \n"
" 'B1-DUMMY' 1* 9999 4* / \n"
" 'MANI-D1' 1* 8 1* 'NO' 2* / \n"
" 'MANI-D2' 1* 8 1* 'NO' 2* / \n"
" 'MANI-K2' 1* 9999 4* / \n"
" 'D2-DUMMY' 1* 9999 4* / \n"
" 'MANI-E1' 1* 9 1* 'NO' 2* / \n"
" 'MANI-E2' 1* 9 4* / \n"
"/\n";
auto deck = parser.parseString(input);
EclipseGrid grid(10,10,10);
TableManager table ( deck );
FieldPropsManager fp( deck, Phases{true, true, true}, grid, table);
Runspec runspec (deck );
Opm::Schedule schedule(deck, grid, fp, runspec);
const auto& group1 = schedule.getGroup("PROD", 0);
const auto& group2 = schedule.getGroup("MANI-E2", 0);
const auto& group3 = schedule.getGroup("MANI-K1", 0);
BOOST_CHECK_EQUAL(group1.getGroupNetVFPTable(), 0);
BOOST_CHECK_EQUAL(group2.getGroupNetVFPTable(), 9);
BOOST_CHECK_EQUAL(group3.getGroupNetVFPTable(), 9999);
}
BOOST_AUTO_TEST_CASE(GroupCreate) {
Opm::Group g1("NAME", 1, 1, 0, UnitSystem::newMETRIC());
Opm::Group g2("NAME", 1, 1, 0, UnitSystem::newMETRIC());
BOOST_CHECK( g1.addWell("W1") );
BOOST_CHECK( !g1.addWell("W1") );
BOOST_CHECK( g1.addWell("W2") );
BOOST_CHECK( g1.hasWell("W1"));
BOOST_CHECK( g1.hasWell("W2"));
BOOST_CHECK( !g1.hasWell("W3"));
BOOST_CHECK_EQUAL( g1.numWells(), 2);
BOOST_CHECK_THROW(g1.delWell("W3"), std::invalid_argument);
BOOST_CHECK_NO_THROW(g1.delWell("W1"));
BOOST_CHECK_EQUAL( g1.numWells(), 1);
BOOST_CHECK( g2.addGroup("G1") );
BOOST_CHECK( !g2.addGroup("G1") );
BOOST_CHECK( g2.addGroup("G2") );
// The children must be either all wells - or all groups.
BOOST_CHECK_THROW(g1.addGroup("G1"), std::logic_error);
BOOST_CHECK_THROW(g2.addWell("W1"), std::logic_error);
}
BOOST_AUTO_TEST_CASE(createDeckWithGCONPROD) {
Opm::Parser parser;
std::string input = R"(
START -- 0
31 AUG 1993 /
SCHEDULE
GRUPTREE
'G1' 'FIELD' /
'G2' 'FIELD' /
/
GCONPROD
'G1' 'ORAT' 10000 3* 'CON' /
'G2' 'RESV' 10000 3* 'CON' /
/)";
auto deck = parser.parseString(input);
EclipseGrid grid(10,10,10);
TableManager table ( deck );
FieldPropsManager fp( deck, Phases{true, true, true}, grid, table);
Runspec runspec (deck );
Opm::Schedule schedule(deck, grid, fp, runspec);
SummaryState st(std::chrono::system_clock::now());
const auto& group1 = schedule.getGroup("G1", 0);
const auto& group2 = schedule.getGroup("G2", 0);
auto ctrl1 = group1.productionControls(st);
auto ctrl2 = group2.productionControls(st);
BOOST_CHECK(ctrl1.exceed_action == Group::ExceedAction::RATE);
BOOST_CHECK(ctrl2.exceed_action == Group::ExceedAction::CON);
}
BOOST_AUTO_TEST_CASE(TESTGuideRateModel) {
Opm::GuideRateModel grc_default;
BOOST_CHECK_THROW(Opm::GuideRateModel(0.0,GuideRateModel::Target::OIL, -5,0,0,0,0,0,true,1,true), std::invalid_argument);
BOOST_CHECK_THROW(grc_default.eval(1,0.50,0.50), std::invalid_argument);
Opm::GuideRateModel grc_delay(10, GuideRateModel::Target::OIL, 1,1,0,0,0,0,true,1,true);
BOOST_CHECK_NO_THROW(grc_delay.eval(1.0, 0.5, 0.5));
}
BOOST_AUTO_TEST_CASE(TESTGuideRateLINCOM) {
Parser parser;
std::string input = R"(
START -- 0
31 AUG 1993 /
SCHEDULE
GRUPTREE
'G1' 'FIELD' /
'G2' 'FIELD' /
/
GCONPROD
'G1' 'ORAT' 10000 3* 'CON' /
'G2' 'RESV' 10000 3* 'CON' /
/
GUIDERAT
1* 'COMB' 1.0 1.0 /
LINCOM
1 2 'WWCT:OPX' /
)";
auto deck = parser.parseString(input);
EclipseGrid grid(10,10,10);
TableManager table ( deck );
FieldPropsManager fp( deck, Phases{true, true, true}, grid, table);
Runspec runspec (deck );
/* The 'COMB' target mode is not supported */
BOOST_CHECK_THROW(Opm::Schedule schedule(deck, grid, fp, runspec), std::logic_error);
}
BOOST_AUTO_TEST_CASE(TESTGuideRate) {
Parser parser;
std::string input = R"(
START -- 0
31 AUG 1993 /
SCHEDULE
GRUPTREE
'G1' 'FIELD' /
'G2' 'FIELD' /
/
GCONPROD
'G1' 'ORAT' 10000 3* 'CON' /
'G2' 'RESV' 10000 3* 'CON' /
/
GUIDERAT
1* 'OIL' 1.0 1.0 /
LINCOM
1 2 'WWCT:OPX' /
TSTEP
1 1 1 1 1 1 1 1 1 1 1 /
)";
auto deck = parser.parseString(input);
EclipseGrid grid(10,10,10);
TableManager table ( deck );
FieldPropsManager fp( deck, Phases{true, true, true}, grid, table);
Runspec runspec (deck );
Schedule schedule(deck, grid, fp, runspec);
GuideRate gr(schedule);
}
BOOST_AUTO_TEST_CASE(TESTGCONSALE) {
Parser parser;
std::string input = R"(
START -- 0
31 AUG 1993 /
SCHEDULE
GRUPTREE
'G1' 'FIELD' /
'G2' 'FIELD' /
/
GCONSALE
'G1' 50000 55000 45000 WELL /
/
GCONSUMP
'G1' 20 50 'a_node' /
'G2' 30 60 /
/
)";
auto deck = parser.parseString(input);
EclipseGrid grid(10,10,10);
TableManager table ( deck );
FieldPropsManager fp( deck, Phases{true, true, true}, grid, table);
Runspec runspec (deck );
Schedule schedule(deck, grid, fp, runspec);
double metric_to_si = 1.0 / (24.0 * 3600.0); //cubic meters / day
const auto& gconsale = schedule.gConSale(0);
BOOST_CHECK_EQUAL(gconsale.size(), 1);
BOOST_CHECK(gconsale.has("G1"));
BOOST_CHECK(!gconsale.has("G2"));
const GConSale::GCONSALEGroup& group = gconsale.get("G1");
BOOST_CHECK_EQUAL(group.sales_target.get<double>(), 50000);
BOOST_CHECK_EQUAL(group.max_sales_rate.get<double>(), 55000);
BOOST_CHECK_EQUAL(group.min_sales_rate.get<double>(), 45000);
BOOST_CHECK_EQUAL(group.sales_target.getSI(), 50000 * metric_to_si);
BOOST_CHECK_EQUAL(group.max_sales_rate.getSI(), 55000 * metric_to_si);
BOOST_CHECK_EQUAL(group.min_sales_rate.getSI(), 45000 * metric_to_si);
BOOST_CHECK(group.max_proc == GConSale::MaxProcedure::WELL);
const auto& gconsump = schedule.gConSump(0);
BOOST_CHECK_EQUAL(gconsump.size(), 2);
BOOST_CHECK(gconsump.has("G1"));
BOOST_CHECK(gconsump.has("G2"));
const GConSump::GCONSUMPGroup group1 = gconsump.get("G1");
BOOST_CHECK_EQUAL(group1.consumption_rate.get<double>(), 20);
BOOST_CHECK_EQUAL(group1.import_rate.get<double>(), 50);
BOOST_CHECK_EQUAL(group1.consumption_rate.getSI(), 20 * metric_to_si);
BOOST_CHECK_EQUAL(group1.import_rate.getSI(), 50 * metric_to_si);
BOOST_CHECK( group1.network_node == "a_node" );
const GConSump::GCONSUMPGroup group2 = gconsump.get("G2");
BOOST_CHECK_EQUAL( group2.network_node.size(), 0 );
}
Reference in New Issue View Git Blame Copy Permalink