From 78fee8b0ca095d65e55dd11e62e4fe9833764dd9 Mon Sep 17 00:00:00 2001 From: chflo Date: Fri, 17 Apr 2015 18:50:33 +0200 Subject: [PATCH] Added new Tuning class. --- opm/parser/eclipse/CMakeLists.txt | 3 + .../eclipse/EclipseState/Schedule/Tuning.cpp | 206 ++++++++++++ .../eclipse/EclipseState/Schedule/Tuning.hpp | 176 ++++++++++ .../Schedule/tests/TuningTests.cpp | 315 ++++++++++++++++++ 4 files changed, 700 insertions(+) create mode 100644 opm/parser/eclipse/EclipseState/Schedule/Tuning.cpp create mode 100644 opm/parser/eclipse/EclipseState/Schedule/Tuning.hpp create mode 100644 opm/parser/eclipse/EclipseState/Schedule/tests/TuningTests.cpp diff --git a/opm/parser/eclipse/CMakeLists.txt b/opm/parser/eclipse/CMakeLists.txt index b98fde343..478dd2633 100644 --- a/opm/parser/eclipse/CMakeLists.txt +++ b/opm/parser/eclipse/CMakeLists.txt @@ -88,6 +88,7 @@ EclipseState/Schedule/CompletionSet.cpp EclipseState/Schedule/ScheduleEnums.cpp EclipseState/Schedule/GroupTreeNode.cpp EclipseState/Schedule/GroupTree.cpp +EclipseState/Schedule/Tuning.cpp # EclipseState/Tables/SingleRecordTable.cpp EclipseState/Tables/MultiRecordTable.cpp @@ -106,6 +107,7 @@ EclipseState/Grid/FaultCollection.cpp EclipseState/SimulationConfig/SimulationConfig.cpp EclipseState/SimulationConfig/ThresholdPressure.cpp) + set( HEADER_FILES OpmLog/LogBackend.hpp OpmLog/TimerLog.hpp @@ -163,6 +165,7 @@ EclipseState/Schedule/CompletionSet.hpp EclipseState/Schedule/ScheduleEnums.hpp EclipseState/Schedule/GroupTreeNode.hpp EclipseState/Schedule/GroupTree.hpp +EclipseState/Schedule/Tuning.hpp # EclipseState/Util/ElasticVector.hpp EclipseState/Util/OrderedMap.hpp diff --git a/opm/parser/eclipse/EclipseState/Schedule/Tuning.cpp b/opm/parser/eclipse/EclipseState/Schedule/Tuning.cpp new file mode 100644 index 000000000..ee3bd7d5a --- /dev/null +++ b/opm/parser/eclipse/EclipseState/Schedule/Tuning.cpp @@ -0,0 +1,206 @@ +/* + Copyright 2015 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 . + */ + + +#include +#include + +namespace Opm { + + Tuning::Tuning(TimeMapConstPtr timemap): + /* Hardcoding default values to support getting defaults before any TUNING keyword has occured */ + m_TSINIT( new DynamicState(timemap, 1.0 * Metric::Time)), + m_TSMAXZ( new DynamicState(timemap, 365.0 * Metric::Time)), + m_TSMINZ( new DynamicState(timemap, 0.1 * Metric::Time)), + m_TSMCHP( new DynamicState(timemap, 0.15 * Metric::Time)), + m_TSFMAX( new DynamicState(timemap, 3.0)), + m_TSFMIN( new DynamicState(timemap, 0.3)), + m_TSFCNV( new DynamicState(timemap, 0.1)), + m_TFDIFF( new DynamicState(timemap, 1.25)), + m_THRUPT( new DynamicState(timemap, 1.0E20)), + m_TMAXWC( new DynamicState(timemap, 0.0 * Metric::Time)), + m_TMAXWC_has_value( new DynamicState(timemap, false)), + m_TRGTTE( new DynamicState(timemap, 0.1)), + m_TRGCNV( new DynamicState(timemap, 0.001)), + m_TRGMBE( new DynamicState(timemap, 1.0E-7)), + m_TRGLCV( new DynamicState(timemap, 0.0001)), + m_XXXTTE( new DynamicState(timemap, 10.0)), + m_XXXCNV( new DynamicState(timemap, 0.01)), + m_XXXMBE( new DynamicState(timemap, 1.0E-6)), + m_XXXLCV( new DynamicState(timemap, 0.001)), + m_XXXWFL( new DynamicState(timemap, 0.001)), + m_TRGFIP( new DynamicState(timemap, 0.025)), + m_TRGSFT( new DynamicState(timemap, 0.0)), + m_TRGSFT_has_value( new DynamicState(timemap, false)), + m_THIONX( new DynamicState(timemap, 0.01)), + m_TRWGHT( new DynamicState(timemap, 1)), + m_NEWTMX( new DynamicState(timemap, 12)), + m_NEWTMN( new DynamicState(timemap, 1)), + m_LITMAX( new DynamicState(timemap, 25)), + m_LITMIN( new DynamicState(timemap, 1)), + m_MXWSIT( new DynamicState(timemap, 8)), + m_MXWPIT( new DynamicState(timemap, 8)), + m_DDPLIM( new DynamicState(timemap, 1.0E6 * Metric::Pressure)), + m_DDSLIM( new DynamicState(timemap, 1.0E6)), + m_TRGDPR( new DynamicState(timemap, 1.0E6 * Metric::Pressure)), + m_XXXDPR( new DynamicState(timemap, 0.0 * Metric::Pressure)), + m_XXXDPR_has_value( new DynamicState(timemap, false)) + { + } + + + void Tuning::getTuningItemValue(const std::string& tuningItem, size_t timestep, double& value) { + /*The following code diverges from coding standard to improve readabillity*/ + if ("TSINIT" == tuningItem) { value = m_TSINIT->get(timestep); } //RECORD 1 + else if ("TSMAXZ" == tuningItem) { value = m_TSMAXZ->get(timestep); } + else if ("TSMINZ" == tuningItem) { value = m_TSMINZ->get(timestep); } + else if ("TSMCHP" == tuningItem) { value = m_TSMCHP->get(timestep); } + else if ("TSFMAX" == tuningItem) { value = m_TSFMAX->get(timestep); } + else if ("TSFMIN" == tuningItem) { value = m_TSFMIN->get(timestep); } + else if ("TSFCNV" == tuningItem) { value = m_TSFCNV->get(timestep); } + else if ("TFDIFF" == tuningItem) { value = m_TFDIFF->get(timestep); } + else if ("THRUPT" == tuningItem) { value = m_THRUPT->get(timestep); } + else if ("TMAXWC" == tuningItem) { value = m_TMAXWC->get(timestep); } + + else if ("TRGTTE" == tuningItem) { value = m_TRGTTE->get(timestep); } //RECORD 2 + else if ("TRGCNV" == tuningItem) { value = m_TRGCNV->get(timestep); } + else if ("TRGMBE" == tuningItem) { value = m_TRGMBE->get(timestep); } + else if ("TRGLCV" == tuningItem) { value = m_TRGLCV->get(timestep); } + else if ("XXXTTE" == tuningItem) { value = m_XXXTTE->get(timestep); } + else if ("XXXCNV" == tuningItem) { value = m_XXXCNV->get(timestep); } + else if ("XXXMBE" == tuningItem) { value = m_XXXMBE->get(timestep); } + else if ("XXXLCV" == tuningItem) { value = m_XXXLCV->get(timestep); } + else if ("XXXWFL" == tuningItem) { value = m_XXXWFL->get(timestep); } + else if ("TRGFIP" == tuningItem) { value = m_TRGFIP->get(timestep); } + else if ("TRGSFT" == tuningItem) { value = m_TRGSFT->get(timestep); } + else if ("THIONX" == tuningItem) { value = m_THIONX->get(timestep); } + + else if ("DDPLIM" == tuningItem) { value = m_DDPLIM->get(timestep); } //RECORD 3 + else if ("DDSLIM" == tuningItem) { value = m_DDSLIM->get(timestep); } + else if ("TRGDPR" == tuningItem) { value = m_TRGDPR->get(timestep); } + else if ("XXXDPR" == tuningItem) { value = m_XXXDPR->get(timestep); } + + else { + throw std::invalid_argument("Method getTuningItemValue(): The TUNING keyword item: " + tuningItem + " was not recognized or has wrong type"); + } + } + + + + void Tuning::getTuningItemValue(const std::string& tuningItem, size_t timestep, int& value) { + + /*The following code diverges from coding standard to improve readabillity*/ + if ("TRWGHT" == tuningItem) { value = m_TRWGHT->get(timestep); } //RECORD 2 + + else if ("NEWTMX" == tuningItem) { value = m_NEWTMX->get(timestep); } //RECORD 3 + else if ("NEWTMN" == tuningItem) { value = m_NEWTMN->get(timestep); } + else if ("LITMAX" == tuningItem) { value = m_LITMAX->get(timestep); } + else if ("LITMIN" == tuningItem) { value = m_LITMIN->get(timestep); } + else if ("MXWSIT" == tuningItem) { value = m_MXWSIT->get(timestep); } + else if ("MXWPIT" == tuningItem) { value = m_MXWPIT->get(timestep); } + + else { + throw std::invalid_argument("Method getTuningItemValue(): The TUNING keyword item: " + tuningItem + " was not recognized or has wrong type"); + } + } + + + + + + /*The following "get" method declarations diverges from coding standard to improve readability*/ + double Tuning::getTSINIT(size_t timestep) const { return m_TSINIT->get(timestep); } + double Tuning::getTSMAXZ(size_t timestep) const { return m_TSMAXZ->get(timestep); } + double Tuning::getTSMINZ(size_t timestep) const { return m_TSMINZ->get(timestep); } + double Tuning::getTSMCHP(size_t timestep) const { return m_TSMCHP->get(timestep); } + double Tuning::getTSFMAX(size_t timestep) const { return m_TSFMAX->get(timestep); } + double Tuning::getTSFMIN(size_t timestep) const { return m_TSFMIN->get(timestep); } + double Tuning::getTSFCNV(size_t timestep) const { return m_TSFCNV->get(timestep); } + double Tuning::getTFDIFF(size_t timestep) const { return m_TFDIFF->get(timestep); } + double Tuning::getTHRUPT(size_t timestep) const { return m_THRUPT->get(timestep); } + double Tuning::getTMAXWC(size_t timestep) const { return m_TMAXWC->get(timestep); } + bool Tuning::getTMAXWChasValue(size_t timestep) const { return m_TMAXWC_has_value->get(timestep); } + double Tuning::getTRGTTE(size_t timestep) const { return m_TRGTTE->get(timestep); } + double Tuning::getTRGCNV(size_t timestep) const { return m_TRGCNV->get(timestep); } + double Tuning::getTRGMBE(size_t timestep) const { return m_TRGMBE->get(timestep); } + double Tuning::getTRGLCV(size_t timestep) const { return m_TRGLCV->get(timestep); } + double Tuning::getXXXTTE(size_t timestep) const { return m_XXXTTE->get(timestep); } + double Tuning::getXXXCNV(size_t timestep) const { return m_XXXCNV->get(timestep); } + double Tuning::getXXXMBE(size_t timestep) const { return m_XXXMBE->get(timestep); } + double Tuning::getXXXLCV(size_t timestep) const { return m_XXXLCV->get(timestep); } + double Tuning::getXXXWFL(size_t timestep) const { return m_XXXWFL->get(timestep); } + double Tuning::getTRGFIP(size_t timestep) const { return m_TRGFIP->get(timestep); } + double Tuning::getTRGSFT(size_t timestep) const { return m_TRGSFT->get(timestep); } + bool Tuning::getTRGSFThasValue(size_t timestep) const { return m_TRGSFT_has_value->get(timestep); } + double Tuning::getTHIONX(size_t timestep) const { return m_THIONX->get(timestep); } + int Tuning::getTRWGHT(size_t timestep) const { return m_TRWGHT->get(timestep); } + int Tuning::getNEWTMX(size_t timestep) const { return m_NEWTMX->get(timestep); } + int Tuning::getNEWTMN(size_t timestep) const { return m_NEWTMN->get(timestep); } + int Tuning::getLITMAX(size_t timestep) const { return m_LITMAX->get(timestep); } + int Tuning::getLITMIN(size_t timestep) const { return m_LITMIN->get(timestep); } + int Tuning::getMXWSIT(size_t timestep) const { return m_MXWSIT->get(timestep); } + int Tuning::getMXWPIT(size_t timestep) const { return m_MXWPIT->get(timestep); } + double Tuning::getDDPLIM(size_t timestep) const { return m_DDPLIM->get(timestep); } + double Tuning::getDDSLIM(size_t timestep) const { return m_DDSLIM->get(timestep); } + double Tuning::getTRGDPR(size_t timestep) const { return m_TRGDPR->get(timestep); } + double Tuning::getXXXDPR(size_t timestep) const { return m_XXXDPR->get(timestep); } + bool Tuning::getXXXDPRhasValue(size_t timestep) const { return m_XXXDPR_has_value->get(timestep); + } + + /*The following "set" method declarations diverges from coding standard to improve readability*/ + void Tuning::setTSINIT(size_t timestep, double TSINIT) { m_TSINIT->add(timestep, TSINIT); } + void Tuning::setTSMAXZ(size_t timestep, double TSMAXZ) { m_TSMAXZ->add(timestep, TSMAXZ); } + void Tuning::setTSMINZ(size_t timestep, double TSMINZ) { m_TSMINZ->add(timestep, TSMINZ); } + void Tuning::setTSMCHP(size_t timestep, double TSMCHP) { m_TSMCHP->add(timestep, TSMCHP); } + void Tuning::setTSFMAX(size_t timestep, double TSFMAX) { m_TSFMAX->add(timestep, TSFMAX); } + void Tuning::setTSFMIN(size_t timestep, double TSFMIN) { m_TSFMIN->add(timestep, TSFMIN); } + void Tuning::setTSFCNV(size_t timestep, double TSFCNV) { m_TSFCNV->add(timestep, TSFCNV); } + void Tuning::setTFDIFF(size_t timestep, double TFDIFF) { m_TFDIFF->add(timestep, TFDIFF); } + void Tuning::setTHRUPT(size_t timestep, double THRUPT) { m_THRUPT->add(timestep, THRUPT); } + void Tuning::setTMAXWC(size_t timestep, double TMAXWC) { m_TMAXWC->add(timestep, TMAXWC); m_TMAXWC_has_value->add(timestep, true); } + void Tuning::setTRGTTE(size_t timestep, double TRGTTE) { m_TRGTTE->add(timestep, TRGTTE); } + void Tuning::setTRGCNV(size_t timestep, double TRGCNV) { m_TRGCNV->add(timestep, TRGCNV); } + void Tuning::setTRGMBE(size_t timestep, double TRGMBE) { m_TRGMBE->add(timestep, TRGMBE); } + void Tuning::setTRGLCV(size_t timestep, double TRGLCV) { m_TRGLCV->add(timestep, TRGLCV); } + void Tuning::setXXXTTE(size_t timestep, double XXXTTE) { m_XXXTTE->add(timestep, XXXTTE); } + void Tuning::setXXXCNV(size_t timestep, double XXXCNV) { m_XXXCNV->add(timestep, XXXCNV); } + void Tuning::setXXXMBE(size_t timestep, double XXXMBE) { m_XXXMBE->add(timestep, XXXMBE); } + void Tuning::setXXXLCV(size_t timestep, double XXXLCV) { m_XXXLCV->add(timestep, XXXLCV); } + void Tuning::setXXXWFL(size_t timestep, double XXXWFL) { m_XXXWFL->add(timestep, XXXWFL); } + void Tuning::setTRGFIP(size_t timestep, double TRGFIP) { m_TRGFIP->add(timestep, TRGFIP); } + void Tuning::setTRGSFT(size_t timestep, double TRGSFT) { m_TRGSFT->add(timestep, TRGSFT); m_TRGSFT_has_value->add(timestep, true); } + void Tuning::setTHIONX(size_t timestep, double THIONX) { m_THIONX->add(timestep, THIONX); } + void Tuning::setTRWGHT(size_t timestep, int TRWGHT) { m_TRWGHT->add(timestep, TRWGHT); } + void Tuning::setNEWTMX(size_t timestep, int NEWTMX) { m_NEWTMX->add(timestep, NEWTMX); } + void Tuning::setNEWTMN(size_t timestep, int NEWTMN) { m_NEWTMN->add(timestep, NEWTMN); } + void Tuning::setLITMAX(size_t timestep, int LITMAX) { m_LITMAX->add(timestep, LITMAX); } + void Tuning::setLITMIN(size_t timestep, int LITMIN) { m_LITMIN->add(timestep, LITMIN); } + void Tuning::setMXWSIT(size_t timestep, int MXWSIT) { m_MXWSIT->add(timestep, MXWSIT); } + void Tuning::setMXWPIT(size_t timestep, int MXWPIT) { m_MXWPIT->add(timestep, MXWPIT); } + void Tuning::setDDPLIM(size_t timestep, double DDPLIM) { m_DDPLIM->add(timestep, DDPLIM); } + void Tuning::setDDSLIM(size_t timestep, double DDSLIM) { m_DDSLIM->add(timestep, DDSLIM); } + void Tuning::setTRGDPR(size_t timestep, double TRGDPR) { m_TRGDPR->add(timestep, TRGDPR); } + void Tuning::setXXXDPR(size_t timestep, double XXXDPR) { m_XXXDPR->add(timestep, XXXDPR); m_XXXDPR_has_value->add(timestep, true); } + +} //namespace Opm + + + + + diff --git a/opm/parser/eclipse/EclipseState/Schedule/Tuning.hpp b/opm/parser/eclipse/EclipseState/Schedule/Tuning.hpp new file mode 100644 index 000000000..48c723b1e --- /dev/null +++ b/opm/parser/eclipse/EclipseState/Schedule/Tuning.hpp @@ -0,0 +1,176 @@ +/* + Copyright 2015 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 . + */ + +#ifndef OPM_TUNING_HPP +#define OPM_TUNING_HPP + +#include +#include + + +namespace Opm { + + class Tuning { + + /* + When the TUNING keyword has occured in the Schedule section and + has been handled by the Schedule::handleTUNING() method, + the value for each TUNING keyword item is either + set from the keyword occurence or a default is set if specified in + the keyword description. Items that do not have a specified default + has got a separate hasValue() method. + + Before any TUNING keyword has occured in the Schedule section, + the different TUNING keyword items has got hardcoded default values + (See Tuning constructor) + Hardcoded values are set as the same as specified in the keyword description, + or 0 if no default is specified in the description. + */ + + public: + Tuning(TimeMapConstPtr timemap); + + void getTuningItemValue(const std::string& tuningItem, size_t timestep, double& value); + void getTuningItemValue(const std::string& tuningItem, size_t timestep, int& value); + + + /* Record 1 */ + double getTSINIT(size_t timestep) const; + double getTSMAXZ(size_t timestep) const; + double getTSMINZ(size_t timestep) const; + double getTSMCHP(size_t timestep) const; + double getTSFMAX(size_t timestep) const; + double getTSFMIN(size_t timestep) const; + double getTSFCNV(size_t timestep) const; + double getTFDIFF(size_t timestep) const; + double getTHRUPT(size_t timestep) const; + double getTMAXWC(size_t timestep) const; + bool getTMAXWChasValue(size_t timestep) const; + void setTSINIT(size_t timestep, double TSINIT); + void setTSMAXZ(size_t timestep, double TSMAXZ); + void setTSMINZ(size_t timestep, double TSMINZ); + void setTSMCHP(size_t timestep, double TSMCHP); + void setTSFMAX(size_t timestep, double TSFMAX); + void setTSFMIN(size_t timestep, double TSFMIN); + void setTSFCNV(size_t timestep, double TSFCNV); + void setTFDIFF(size_t timestep, double TFDIFF); + void setTHRUPT(size_t timestep, double THRUPT); + void setTMAXWC(size_t timestep, double TMAXWC); + /* Record 2 */ + double getTRGTTE(size_t timestep) const; + double getTRGCNV(size_t timestep) const; + double getTRGMBE(size_t timestep) const; + double getTRGLCV(size_t timestep) const; + double getXXXTTE(size_t timestep) const; + double getXXXCNV(size_t timestep) const; + double getXXXMBE(size_t timestep) const; + double getXXXLCV(size_t timestep) const; + double getXXXWFL(size_t timestep) const; + double getTRGFIP(size_t timestep) const; + double getTRGSFT(size_t timestep) const; + bool getTRGSFThasValue(size_t timestep) const; + double getTHIONX(size_t timestep) const; + int getTRWGHT(size_t timestep) const; + void setTRGTTE(size_t timestep, double TRGTTE); + void setTRGCNV(size_t timestep, double TRGCNV); + void setTRGMBE(size_t timestep, double TRGMBE); + void setTRGLCV(size_t timestep, double TRGLCV); + void setXXXTTE(size_t timestep, double XXXTTE); + void setXXXCNV(size_t timestep, double XXXCNV); + void setXXXMBE(size_t timestep, double XXXMBE); + void setXXXLCV(size_t timestep, double XXXLCV); + void setXXXWFL(size_t timestep, double XXXWFL); + void setTRGFIP(size_t timestep, double TRGFIP); + void setTRGSFT(size_t timestep, double TRGFIP); + void setTHIONX(size_t timestep, double THIONX); + void setTRWGHT(size_t timestep, int TRWGHT); + /* Record 3 */ + int getNEWTMX(size_t timestep) const; + int getNEWTMN(size_t timestep) const; + int getLITMAX(size_t timestep) const; + int getLITMIN(size_t timestep) const; + int getMXWSIT(size_t timestep) const; + int getMXWPIT(size_t timestep) const; + double getDDPLIM(size_t timestep) const; + double getDDSLIM(size_t timestep) const; + double getTRGDPR(size_t timestep) const; + double getXXXDPR(size_t timestep) const; + bool getXXXDPRhasValue(size_t timestep) const; + void setNEWTMX(size_t timestep, int NEWTMX); + void setNEWTMN(size_t timestep, int NEWTMN); + void setLITMAX(size_t timestep, int LITMAX); + void setLITMIN(size_t timestep, int LITMIN); + void setMXWSIT(size_t timestep, int MXWSIT); + void setMXWPIT(size_t timestep, int MXWPIT); + void setDDPLIM(size_t timestep, double DDPLIM); + void setDDSLIM(size_t timestep, double DDSLIM); + void setTRGDPR(size_t timestep, double TRGDPR); + void setXXXDPR(size_t timestep, double XXXDPR); + + + private: + /* Record1 */ + std::shared_ptr> m_TSINIT; + std::shared_ptr> m_TSMAXZ; + std::shared_ptr> m_TSMINZ; + std::shared_ptr> m_TSMCHP; + std::shared_ptr> m_TSFMAX; + std::shared_ptr> m_TSFMIN; + std::shared_ptr> m_TSFCNV; + std::shared_ptr> m_TFDIFF; + std::shared_ptr> m_THRUPT; + std::shared_ptr> m_TMAXWC; + std::shared_ptr> m_TMAXWC_has_value; + /* Record 2 */ + std::shared_ptr> m_TRGTTE; + std::shared_ptr> m_TRGCNV; + std::shared_ptr> m_TRGMBE; + std::shared_ptr> m_TRGLCV; + std::shared_ptr> m_XXXTTE; + std::shared_ptr> m_XXXCNV; + std::shared_ptr> m_XXXMBE; + std::shared_ptr> m_XXXLCV; + std::shared_ptr> m_XXXWFL; + std::shared_ptr> m_TRGFIP; + std::shared_ptr> m_TRGSFT; + std::shared_ptr> m_TRGSFT_has_value; + std::shared_ptr> m_THIONX; + std::shared_ptr> m_TRWGHT; + /* Record 3 */ + std::shared_ptr> m_NEWTMX; + std::shared_ptr> m_NEWTMN; + std::shared_ptr> m_LITMAX; + std::shared_ptr> m_LITMIN; + std::shared_ptr> m_MXWSIT; + std::shared_ptr> m_MXWPIT; + std::shared_ptr> m_DDPLIM; + std::shared_ptr> m_DDSLIM; + std::shared_ptr> m_TRGDPR; + std::shared_ptr> m_XXXDPR; + std::shared_ptr> m_XXXDPR_has_value; + + }; + + + typedef std::shared_ptr TuningPtr; + typedef std::shared_ptr TuningConstPtr; + +} //namespace Opm + +#endif diff --git a/opm/parser/eclipse/EclipseState/Schedule/tests/TuningTests.cpp b/opm/parser/eclipse/EclipseState/Schedule/tests/TuningTests.cpp new file mode 100644 index 000000000..eeca18e5a --- /dev/null +++ b/opm/parser/eclipse/EclipseState/Schedule/tests/TuningTests.cpp @@ -0,0 +1,315 @@ +/* + Copyright 2015 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 . + */ + + +#define BOOST_TEST_MODULE TuningTests + +#include + +#include +#include +#include +#include + + +using namespace Opm; + + +const std::string& deckStr = "START\n" + " 21 MAY 1981 /\n" + "\n" + "TSTEP\n" + " 1 2 3 4 5 /\n" + "\n" + "TUNING\n" + "2 300 0.3 0.30 6 0.6 0.2 2.25 2E20 /\n" + "0.2 0.002 2E-7 0.0002 11 0.02 2.0E-6 0.002 0.002 0.035 66 0.02 2/\n" + "13 2 26 2 9 9 4.0E6 4.0E6 4.0E6 1/\n" + "DATES\n" + " 1 JAN 1982 /\n" + " 1 JAN 1982 13:55:44 /\n" + " 3 JAN 1982 14:56:45.123 /\n" + "/\n" + "TSTEP\n" + " 9 10 /\n" + "\n" + "TUNING\n" + "2 300 0.3 0.30 6 0.6 0.2 2.25 2E20 10.0/\n" + "/\n" + "/\n"; + + + +static DeckPtr createDeck(const std::string& input) { + Opm::Parser parser; + return parser.parseString(input); +} + + + +BOOST_AUTO_TEST_CASE(TuningTest) { + + DeckPtr deck = createDeck(deckStr); + std::shared_ptr grid = std::make_shared( 10 , 10 , 10 ); + Schedule schedule(grid , deck); + TuningPtr tuning = schedule.getTuning(); + + + const double diff = 1.0e-14; + + /*** TIMESTEP 4***/ + /********* Record 1 ***********/ + size_t timestep = 4; + double TSINIT_default = tuning->getTSINIT(timestep); + BOOST_CHECK_CLOSE(TSINIT_default, 1 * Metric::Time, diff); + + double TSMAXZ_default = tuning->getTSMAXZ(timestep); + BOOST_CHECK_CLOSE(TSMAXZ_default, 365 * Metric::Time, diff); + + double TSMINZ_default = tuning->getTSMINZ(timestep); + BOOST_CHECK_CLOSE(TSMINZ_default, 0.1 * Metric::Time, diff); + + double TSMCHP_default = tuning->getTSMCHP(timestep); + BOOST_CHECK_CLOSE(TSMCHP_default, 0.15 * Metric::Time, diff); + + double TSFMAX_default = tuning->getTSFMAX(timestep); + BOOST_CHECK_CLOSE(TSFMAX_default, 3.0, diff); + + double TSFMIN_default = tuning->getTSFMIN(timestep); + BOOST_CHECK_CLOSE(TSFMIN_default, 0.3, diff); + + double TSFCNV_default = tuning->getTSFCNV(timestep); + BOOST_CHECK_CLOSE(TSFCNV_default, 0.1, diff); + + double TFDIFF_default = tuning->getTFDIFF(timestep); + BOOST_CHECK_CLOSE(TFDIFF_default, 1.25, diff); + + double THRUPT_default = tuning->getTHRUPT(timestep); + BOOST_CHECK_CLOSE(THRUPT_default, 1E20, diff); + + bool TMAXWC_has_value = tuning->getTMAXWChasValue(timestep); + double TMAXWC_default = tuning->getTMAXWC(timestep); + BOOST_CHECK_EQUAL(false, TMAXWC_has_value); + BOOST_CHECK_CLOSE(TMAXWC_default, 0.0 * Metric::Time, diff); + + + /********* Record 2 ************/ + double TRGTTE_default = tuning->getTRGTTE(timestep); + BOOST_CHECK_CLOSE(TRGTTE_default, 0.1, diff); + + double TRGCNV_default = tuning->getTRGCNV(timestep); + BOOST_CHECK_CLOSE(TRGCNV_default, 0.001, diff); + + double TRGMBE_default = tuning->getTRGMBE(timestep); + BOOST_CHECK_CLOSE(TRGMBE_default, 1.0E-7, diff); + + double TRGLCV_default = tuning->getTRGLCV(timestep); + BOOST_CHECK_CLOSE(TRGLCV_default, 0.0001, diff); + + double XXXTTE_default = tuning->getXXXTTE(timestep); + BOOST_CHECK_CLOSE(XXXTTE_default, 10.0, diff); + + double XXXCNV_default = tuning->getXXXCNV(timestep); + BOOST_CHECK_CLOSE(XXXCNV_default, 0.01, diff); + + double XXXMBE_default = tuning->getXXXMBE(timestep); + BOOST_CHECK_CLOSE(XXXMBE_default, 1.0E-6, diff); + + double XXXLCV_default = tuning->getXXXLCV(timestep); + BOOST_CHECK_CLOSE(XXXLCV_default, 0.001, diff); + + double XXXWFL_default = tuning->getXXXWFL(timestep); + BOOST_CHECK_CLOSE(XXXWFL_default, 0.001, diff); + + double TRGFIP_default = tuning->getTRGFIP(timestep); + BOOST_CHECK_CLOSE(TRGFIP_default, 0.025, diff); + + bool TRGSFT_has_value = tuning->getTRGSFThasValue(timestep); + double TRGSFT_default = tuning->getTRGSFT(timestep); + BOOST_CHECK_EQUAL(false, TRGSFT_has_value); + BOOST_CHECK_CLOSE(TRGSFT_default, 0.0, diff); + + double THIONX_default = tuning->getTHIONX(timestep); + BOOST_CHECK_CLOSE(THIONX_default, 0.01, diff); + + int TRWGHT_default = tuning->getTRWGHT(timestep); + BOOST_CHECK_EQUAL(TRWGHT_default, 1); + + + /********* Record 3 ************/ + int NEWTMX_default = tuning->getNEWTMX(timestep); + BOOST_CHECK_EQUAL(NEWTMX_default, 12); + + int NEWTMN_default = tuning->getNEWTMN(timestep); + BOOST_CHECK_EQUAL(NEWTMN_default, 1); + + int LITMAX_default = tuning->getLITMAX(timestep); + BOOST_CHECK_EQUAL(LITMAX_default, 25); + + int LITMIN_default = tuning->getLITMIN(timestep); + BOOST_CHECK_EQUAL(LITMIN_default, 1); + + int MXWSIT_default = tuning->getMXWSIT(timestep); + BOOST_CHECK_EQUAL(MXWSIT_default, 8); + + int MXWPIT_default = tuning->getMXWPIT(timestep); + BOOST_CHECK_EQUAL(MXWPIT_default, 8); + + double DDPLIM_default = tuning->getDDPLIM(timestep); + BOOST_CHECK_CLOSE(DDPLIM_default, 1.0E6 * Metric::Pressure, diff); + + double DDSLIM_default = tuning->getDDSLIM(timestep); + BOOST_CHECK_CLOSE(DDSLIM_default, 1.0E6, diff); + + double TRGDPR_default = tuning->getTRGDPR(timestep); + BOOST_CHECK_CLOSE(TRGDPR_default, 1.0E6 * Metric::Pressure, diff); + + bool XXXDPR_has_value = tuning->getXXXDPRhasValue(timestep); + double XXXDPR_default = tuning->getXXXDPR(timestep); + BOOST_CHECK_EQUAL(false, XXXDPR_has_value); + BOOST_CHECK_CLOSE(XXXDPR_default, 0.0, diff); + + + + + /*** TIMESTEP 5***/ + /********* Record 1 ***********/ + timestep = 5; + double TSINIT = tuning->getTSINIT(timestep); + BOOST_CHECK_CLOSE(TSINIT, 2 * Metric::Time, diff); + + double TSMAXZ = tuning->getTSMAXZ(timestep); + BOOST_CHECK_CLOSE(TSMAXZ, 300 * Metric::Time, diff); + + double TSMINZ = tuning->getTSMINZ(timestep); + BOOST_CHECK_CLOSE(TSMINZ, 0.3 * Metric::Time, diff); + + double TSMCHP = tuning->getTSMCHP(timestep); + BOOST_CHECK_CLOSE(TSMCHP, 0.30 * Metric::Time, diff); + + double TSFMAX = tuning->getTSFMAX(timestep); + BOOST_CHECK_CLOSE(TSFMAX, 6.0, 1.0); + + double TSFMIN = tuning->getTSFMIN(timestep); + BOOST_CHECK_CLOSE(TSFMIN, 0.6, 1.0); + + double TSFCNV = tuning->getTSFCNV(timestep); + BOOST_CHECK_CLOSE(TSFCNV, 0.2, diff); + + double TFDIFF = tuning->getTFDIFF(timestep); + BOOST_CHECK_CLOSE(TFDIFF, 2.25, diff); + + double THRUPT = tuning->getTHRUPT(timestep); + BOOST_CHECK_CLOSE(THRUPT, 2E20, diff); + + TMAXWC_has_value = tuning->getTMAXWChasValue(timestep); + TMAXWC_default = tuning->getTMAXWC(timestep); + BOOST_CHECK_EQUAL(false, TMAXWC_has_value); + BOOST_CHECK_CLOSE(TMAXWC_default, 0.0 * Metric::Time, diff); + + /********* Record 2 ***********/ + double TRGTTE = tuning->getTRGTTE(timestep); + BOOST_CHECK_CLOSE(TRGTTE, 0.2, diff); + + double TRGCNV = tuning->getTRGCNV(timestep); + BOOST_CHECK_CLOSE(TRGCNV, 0.002, diff); + + double TRGMBE = tuning->getTRGMBE(timestep); + BOOST_CHECK_CLOSE(TRGMBE, 2.0E-7, diff); + + double TRGLCV = tuning->getTRGLCV(timestep); + BOOST_CHECK_CLOSE(TRGLCV, 0.0002, diff); + + double XXXTTE = tuning->getXXXTTE(timestep); + BOOST_CHECK_CLOSE(XXXTTE, 11.0, diff); + + double XXXCNV = tuning->getXXXCNV(timestep); + BOOST_CHECK_CLOSE(XXXCNV, 0.02, diff); + + double XXXMBE = tuning->getXXXMBE(timestep); + BOOST_CHECK_CLOSE(XXXMBE, 2.0E-6, diff); + + double XXXLCV = tuning->getXXXLCV(timestep); + BOOST_CHECK_CLOSE(XXXLCV, 0.002, diff); + + double XXXWFL = tuning->getXXXWFL(timestep); + BOOST_CHECK_CLOSE(XXXWFL, 0.002, diff); + + double TRGFIP = tuning->getTRGFIP(timestep); + BOOST_CHECK_CLOSE(TRGFIP, 0.035, diff); + + TRGSFT_has_value = tuning->getTRGSFThasValue(timestep); + double TRGSFT = tuning->getTRGSFT(timestep); + BOOST_CHECK_EQUAL(true, TRGSFT_has_value); + BOOST_CHECK_CLOSE(TRGSFT, 66.0, diff); + + double THIONX = tuning->getTHIONX(timestep); + BOOST_CHECK_CLOSE(THIONX, 0.02, diff); + + int TRWGHT = tuning->getTRWGHT(timestep); + BOOST_CHECK_EQUAL(TRWGHT, 2); + + /********* Record 3 ***********/ + int NEWTMX = tuning->getNEWTMX(timestep); + BOOST_CHECK_EQUAL(NEWTMX, 13); + + int NEWTMN = tuning->getNEWTMN(timestep); + BOOST_CHECK_EQUAL(NEWTMN, 2); + + int LITMAX = tuning->getLITMAX(timestep); + BOOST_CHECK_EQUAL(LITMAX, 26); + + int LITMIN = tuning->getLITMIN(timestep); + BOOST_CHECK_EQUAL(LITMIN, 2); + + int MXWSIT = tuning->getMXWSIT(timestep); + BOOST_CHECK_EQUAL(MXWSIT, 9); + + int MXWPIT = tuning->getMXWPIT(timestep); + BOOST_CHECK_EQUAL(MXWPIT, 9); + + double DDPLIM= tuning->getDDPLIM(timestep); + BOOST_CHECK_CLOSE(DDPLIM, 4.0E6 * Metric::Pressure, diff); + + double DDSLIM= tuning->getDDSLIM(timestep); + BOOST_CHECK_CLOSE(DDSLIM, 4.0E6, diff); + + double TRGDPR = tuning->getTRGDPR(timestep); + BOOST_CHECK_CLOSE(TRGDPR, 4.0E6 * Metric::Pressure, diff); + + XXXDPR_has_value = tuning->getXXXDPRhasValue(timestep); + double XXXDPR = tuning->getXXXDPR(timestep); + BOOST_CHECK_EQUAL(true, XXXDPR_has_value); + BOOST_CHECK_CLOSE(XXXDPR, 1.0 * Metric::Pressure, diff); + + + + + /*** TIMESTEP 10 ***/ + /********* Record 1 ***********/ + timestep = 10; + TMAXWC_has_value = tuning->getTMAXWChasValue(timestep); + TMAXWC_default = tuning->getTMAXWC(timestep); + BOOST_CHECK_EQUAL(true, TMAXWC_has_value); + BOOST_CHECK_CLOSE(TMAXWC_default, 10.0 * Metric::Time, diff); + + + +} +