OilfieldToolsNet/opm-common
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Added new Tuning class.

Browse Source
This commit is contained in:
chflo
2015-04-17 18:50:33 +02:00
committed by Joakim Hove
parent 3775cb69dd
commit 78fee8b0ca
4 changed files with 700 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
opm/parser/eclipse/CMakeLists.txt
View File

@@ -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

206
opm/parser/eclipse/EclipseState/Schedule/Tuning.cpp Normal file
View File

@@ -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 <http://www.gnu.org/licenses/>.
*/
#include <opm/parser/eclipse/EclipseState/Schedule/Tuning.hpp>
#include <opm/parser/eclipse/Units/ConversionFactors.hpp>
namespace Opm {
Tuning::Tuning(TimeMapConstPtr timemap):
/* Hardcoding default values to support getting defaults before any TUNING keyword has occured */
m_TSINIT( new DynamicState<double>(timemap, 1.0 * Metric::Time)),
m_TSMAXZ( new DynamicState<double>(timemap, 365.0 * Metric::Time)),
m_TSMINZ( new DynamicState<double>(timemap, 0.1 * Metric::Time)),
m_TSMCHP( new DynamicState<double>(timemap, 0.15 * Metric::Time)),
m_TSFMAX( new DynamicState<double>(timemap, 3.0)),
m_TSFMIN( new DynamicState<double>(timemap, 0.3)),
m_TSFCNV( new DynamicState<double>(timemap, 0.1)),
m_TFDIFF( new DynamicState<double>(timemap, 1.25)),
m_THRUPT( new DynamicState<double>(timemap, 1.0E20)),
m_TMAXWC( new DynamicState<double>(timemap, 0.0 * Metric::Time)),
m_TMAXWC_has_value( new DynamicState<bool>(timemap, false)),
m_TRGTTE( new DynamicState<double>(timemap, 0.1)),
m_TRGCNV( new DynamicState<double>(timemap, 0.001)),
m_TRGMBE( new DynamicState<double>(timemap, 1.0E-7)),
m_TRGLCV( new DynamicState<double>(timemap, 0.0001)),
m_XXXTTE( new DynamicState<double>(timemap, 10.0)),
m_XXXCNV( new DynamicState<double>(timemap, 0.01)),
m_XXXMBE( new DynamicState<double>(timemap, 1.0E-6)),
m_XXXLCV( new DynamicState<double>(timemap, 0.001)),
m_XXXWFL( new DynamicState<double>(timemap, 0.001)),
m_TRGFIP( new DynamicState<double>(timemap, 0.025)),
m_TRGSFT( new DynamicState<double>(timemap, 0.0)),
m_TRGSFT_has_value( new DynamicState<bool>(timemap, false)),
m_THIONX( new DynamicState<double>(timemap, 0.01)),
m_TRWGHT( new DynamicState<int>(timemap, 1)),
m_NEWTMX( new DynamicState<int>(timemap, 12)),
m_NEWTMN( new DynamicState<int>(timemap, 1)),
m_LITMAX( new DynamicState<int>(timemap, 25)),
m_LITMIN( new DynamicState<int>(timemap, 1)),
m_MXWSIT( new DynamicState<int>(timemap, 8)),
m_MXWPIT( new DynamicState<int>(timemap, 8)),
m_DDPLIM( new DynamicState<double>(timemap, 1.0E6 * Metric::Pressure)),
m_DDSLIM( new DynamicState<double>(timemap, 1.0E6)),
m_TRGDPR( new DynamicState<double>(timemap, 1.0E6 * Metric::Pressure)),
m_XXXDPR( new DynamicState<double>(timemap, 0.0 * Metric::Pressure)),
m_XXXDPR_has_value( new DynamicState<bool>(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

176
opm/parser/eclipse/EclipseState/Schedule/Tuning.hpp Normal file
View File

@@ -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 <http://www.gnu.org/licenses/>.
*/
#ifndef OPM_TUNING_HPP
#define OPM_TUNING_HPP
#include <opm/parser/eclipse/EclipseState/Schedule/TimeMap.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/DynamicState.hpp>
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 <itemname>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<DynamicState<double>> m_TSINIT;
std::shared_ptr<DynamicState<double>> m_TSMAXZ;
std::shared_ptr<DynamicState<double>> m_TSMINZ;
std::shared_ptr<DynamicState<double>> m_TSMCHP;
std::shared_ptr<DynamicState<double>> m_TSFMAX;
std::shared_ptr<DynamicState<double>> m_TSFMIN;
std::shared_ptr<DynamicState<double>> m_TSFCNV;
std::shared_ptr<DynamicState<double>> m_TFDIFF;
std::shared_ptr<DynamicState<double>> m_THRUPT;
std::shared_ptr<DynamicState<double>> m_TMAXWC;
std::shared_ptr<DynamicState<bool>> m_TMAXWC_has_value;
/* Record 2 */
std::shared_ptr<DynamicState<double>> m_TRGTTE;
std::shared_ptr<DynamicState<double>> m_TRGCNV;
std::shared_ptr<DynamicState<double>> m_TRGMBE;
std::shared_ptr<DynamicState<double>> m_TRGLCV;
std::shared_ptr<DynamicState<double>> m_XXXTTE;
std::shared_ptr<DynamicState<double>> m_XXXCNV;
std::shared_ptr<DynamicState<double>> m_XXXMBE;
std::shared_ptr<DynamicState<double>> m_XXXLCV;
std::shared_ptr<DynamicState<double>> m_XXXWFL;
std::shared_ptr<DynamicState<double>> m_TRGFIP;
std::shared_ptr<DynamicState<double>> m_TRGSFT;
std::shared_ptr<DynamicState<bool>> m_TRGSFT_has_value;
std::shared_ptr<DynamicState<double>> m_THIONX;
std::shared_ptr<DynamicState<int>> m_TRWGHT;
/* Record 3 */
std::shared_ptr<DynamicState<int>> m_NEWTMX;
std::shared_ptr<DynamicState<int>> m_NEWTMN;
std::shared_ptr<DynamicState<int>> m_LITMAX;
std::shared_ptr<DynamicState<int>> m_LITMIN;
std::shared_ptr<DynamicState<int>> m_MXWSIT;
std::shared_ptr<DynamicState<int>> m_MXWPIT;
std::shared_ptr<DynamicState<double>> m_DDPLIM;
std::shared_ptr<DynamicState<double>> m_DDSLIM;
std::shared_ptr<DynamicState<double>> m_TRGDPR;
std::shared_ptr<DynamicState<double>> m_XXXDPR;
std::shared_ptr<DynamicState<bool>> m_XXXDPR_has_value;
};
typedef std::shared_ptr<Tuning> TuningPtr;
typedef std::shared_ptr<const Tuning> TuningConstPtr;
} //namespace Opm
#endif

315
opm/parser/eclipse/EclipseState/Schedule/tests/TuningTests.cpp Normal file
View File

@@ -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 <http://www.gnu.org/licenses/>.
*/
#define BOOST_TEST_MODULE TuningTests
#include <boost/test/unit_test.hpp>
#include <opm/parser/eclipse/Parser/Parser.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Tuning.hpp>
#include <opm/parser/eclipse/Units/ConversionFactors.hpp>
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<const EclipseGrid> grid = std::make_shared<const EclipseGrid>( 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);
}