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

Merge pull request #126 from AtleH/floatitem

Browse Source 
Added DeckFloatItem, ParserFloatItem
This commit is contained in:
Joakim Hove
2014-02-20 12:56:43 +01:00
parent 3a3e40efb1 0d134e8dcd
commit d49ff37891
84 changed files with 949 additions and 179 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -25,6 +25,7 @@ Deck/DeckRecord.cpp
Deck/DeckItem.cpp
Deck/DeckIntItem.cpp
Deck/DeckDoubleItem.cpp
Deck/DeckFloatItem.cpp
Deck/DeckStringItem.cpp
Deck/KeywordContainer.cpp
)
@@ -37,7 +38,8 @@ Parser/ParserRecord.cpp
Parser/ParserItem.cpp
Parser/ParserIntItem.cpp
Parser/ParserBoolItem.cpp
Parser/ParserDoubleItem.cpp
Parser/ParserFloatItem.cpp
Parser/ParserDoubleItem.cpp
Parser/ParserStringItem.cpp
${PROJECT_BINARY_DIR}/generated-source/DefaultKeywordList.cpp
)
@@ -49,7 +51,8 @@ Parser/ParserRecord.cpp
Parser/ParserItem.cpp
Parser/ParserIntItem.cpp
Parser/ParserBoolItem.cpp
Parser/ParserDoubleItem.cpp
Parser/ParserFloatItem.cpp
Parser/ParserDoubleItem.cpp
Parser/ParserStringItem.cpp
)
@@ -84,6 +87,7 @@ Deck/DeckRecord.hpp
Deck/DeckItem.hpp
Deck/DeckIntItem.hpp
Deck/DeckDoubleItem.hpp
Deck/DeckFloatItem.hpp
Deck/DeckStringItem.hpp
Deck/KeywordContainer.hpp
#
@@ -94,8 +98,9 @@ Parser/ParserRecord.hpp
Parser/ParserItem.hpp
Parser/ParserIntItem.hpp
Parser/ParserBoolItem.hpp
Parser/ParserDoubleItem.hpp
Parser/ParserStringItem.hpp
Parser/ParserFloatItem.hpp
Parser/ParserDoubleItem.hpp
Parser/ParserStringItem.hpp
#
Units/UnitSystem.hpp
Units/Dimension.hpp

111
opm/parser/eclipse/Deck/DeckFloatItem.cpp Normal file
View File

@@ -0,0 +1,111 @@
/*
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 <opm/parser/eclipse/Deck/DeckFloatItem.hpp>
#include <boost/lexical_cast.hpp>
#include <algorithm>
#include <iostream>
#include <cmath>
namespace Opm {
float DeckFloatItem::getRawFloat(size_t index) const {
if (index < m_data.size()) {
return m_data[index];
} else
throw std::out_of_range("Out of range, index must be lower than " + boost::lexical_cast<std::string>(m_data.size()));
}
size_t DeckFloatItem::size() const {
return m_data.size();
}
float DeckFloatItem::getSIFloat(size_t index) const {
assertSIData();
{
if (index < m_data.size()) {
return m_SIdata[index];
} else
throw std::out_of_range("Out of range, index must be lower than " + boost::lexical_cast<std::string>(m_data.size()));
}
}
const std::vector<float>& DeckFloatItem::getSIFloatData() const {
assertSIData();
return m_SIdata;
}
void DeckFloatItem::assertSIData() const {
if (m_dimensions.size() > 0) {
if (m_SIdata.size() > 0) {
// we already converted this item to SI!
return;
}
m_SIdata.resize( m_data.size() );
if (m_dimensions.size() == 1) {
float SIfactor = m_dimensions[0]->getSIScaling();
std::transform( m_data.begin() , m_data.end() , m_SIdata.begin() , std::bind1st(std::multiplies<float>(),SIfactor));
} else {
for (size_t index=0; index < m_data.size(); index++) {
size_t dimIndex = (index % m_dimensions.size());
float SIfactor = m_dimensions[dimIndex]->getSIScaling();
m_SIdata[index] = m_data[index] * SIfactor;
}
}
} else
throw std::invalid_argument("No dimension has been set for item:" + name() + " can not ask for SI data");
}
void DeckFloatItem::push_back(std::deque<float> data , size_t items) {
for (size_t i=0; i<items; i++) {
m_data.push_back(data[i]);
}
}
void DeckFloatItem::push_back(std::deque<float> data) {
push_back( data , data.size() );
}
void DeckFloatItem::push_back(float data) {
m_data.push_back( data );
}
void DeckFloatItem::push_backDefault(float data) {
m_data.push_back( data );
m_defaultApplied = true;
}
void DeckFloatItem::push_backMultiple(float value, size_t numValues) {
for (size_t i = 0; i < numValues; i++)
m_data.push_back( value );
}
void DeckFloatItem::push_backDimension(std::shared_ptr<const Dimension> activeDimension , std::shared_ptr<const Dimension> defaultDimension) {
if (m_defaultApplied)
m_dimensions.push_back( defaultDimension );
else
m_dimensions.push_back( activeDimension );
}
}

63
opm/parser/eclipse/Deck/DeckFloatItem.hpp Normal file
View File

@@ -0,0 +1,63 @@
/*
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/>.
*/
#ifndef DECKFLOATITEM_HPP
#define DECKFLOATITEM_HPP
#include <vector>
#include <string>
#include <deque>
#include <memory>
#include <opm/parser/eclipse/Deck/DeckItem.hpp>
#include <opm/parser/eclipse/Units/Dimension.hpp>
namespace Opm {
class DeckFloatItem : public DeckItem {
public:
DeckFloatItem(std::string name) : DeckItem(name) {}
float getRawFloat(size_t index) const;
//const std::vector<float>& getRawFloatData() const;
float getSIFloat(size_t index) const;
const std::vector<float>& getSIFloatData() const;
void push_back(std::deque<float> data , size_t items);
void push_back(std::deque<float> data);
void push_back(float value);
void push_backDefault(float value);
void push_backMultiple(float value, size_t numValues);
void push_backDimension(std::shared_ptr<const Dimension> activeDimension , std::shared_ptr<const Dimension> defaultDimension);
size_t size() const;
private:
void assertSIData() const;
std::vector<float> m_data;
// mutable is required because the data is "lazily" converted
// to SI units in asserSIData() which needs to be callable by
// 'const'-decorated methods
mutable std::vector<float> m_SIdata;
std::vector<std::shared_ptr<const Dimension> > m_dimensions;
};
typedef std::shared_ptr<DeckFloatItem> DeckFloatItemPtr;
typedef std::shared_ptr< const DeckFloatItem> DeckFloatItemConstPtr;
}
#endif // DECKFLOATITEM_HPP

20
opm/parser/eclipse/Deck/DeckItem.hpp
View File

@@ -40,15 +40,23 @@ namespace Opm {
virtual int getInt(size_t index) const {
throw std::logic_error("This implementation of DeckItem does not support int");
};
}
virtual float getSIFloat(size_t index) const {
throw std::logic_error("This implementation of DeckItem does not support float");
}
virtual float getRawFloat(size_t index) const {
throw std::logic_error("This implementation of DeckItem does not support float");
}
virtual double getSIDouble(size_t index) const {
throw std::logic_error("This implementation of DeckItem does not support double");
};
}
virtual double getRawDouble(size_t index) const {
throw std::logic_error("This implementation of DeckItem does not support double");
};
}
virtual bool getBool(size_t index) const {
throw std::logic_error("This implementation of DeckItem does not support bool");
@@ -62,15 +70,15 @@ namespace Opm {
virtual const std::vector<int>& getIntData( ) const {
throw std::logic_error("This implementation of DeckItem does not support int");
};
}
virtual const std::vector<double>& getSIDoubleData() const {
throw std::logic_error("This implementation of DeckItem does not support double");
};
}
virtual const std::vector<double>& getRawDoubleData() const {
throw std::logic_error("This implementation of DeckItem does not support double");
};
}
virtual const std::vector<std::string>& getStringData() const {
throw std::logic_error("This implementation of DeckItem does not support string");

4
opm/parser/eclipse/Deck/tests/CMakeLists.txt
View File

@@ -10,6 +10,10 @@ add_executable(runDeckDoubleItemTests DeckDoubleItemTests.cpp)
target_link_libraries(runDeckDoubleItemTests Parser ${Boost_LIBRARIES})
add_test(NAME runDeckDoubleItemTests COMMAND ${TEST_MEMCHECK_TOOL} ${EXECUTABLE_OUTPUT_PATH}/runDeckDoubleItemTests )
add_executable(runDeckFloatItemTests DeckFloatItemTests.cpp)
target_link_libraries(runDeckFloatItemTests Parser ${Boost_LIBRARIES})
add_test(NAME runDeckFloatItemTests COMMAND ${TEST_MEMCHECK_TOOL} ${EXECUTABLE_OUTPUT_PATH}/runDeckFloatItemTests )
add_executable(runDeckStringItemTests DeckStringItemTests.cpp)
target_link_libraries(runDeckStringItemTests Parser ${Boost_LIBRARIES})
add_test(NAME runDeckStringItemTests COMMAND ${TEST_MEMCHECK_TOOL} ${EXECUTABLE_OUTPUT_PATH}/runDeckStringItemTests )

176
opm/parser/eclipse/Deck/tests/DeckFloatItemTests.cpp Normal file
View File

@@ -0,0 +1,176 @@
/*
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/>.
*/
#define BOOST_TEST_MODULE DeckItemTests
#include <stdexcept>
#include <boost/test/unit_test.hpp>
#include <opm/parser/eclipse/Deck/DeckItem.hpp>
#include <opm/parser/eclipse/Deck/DeckIntItem.hpp>
#include <opm/parser/eclipse/Deck/DeckFloatItem.hpp>
#include <opm/parser/eclipse/Units/Dimension.hpp>
using namespace Opm;
BOOST_AUTO_TEST_CASE(InitializeFloat) {
BOOST_REQUIRE_NO_THROW(DeckFloatItem deckFloatItem("TEST"));
}
BOOST_AUTO_TEST_CASE(GetFloatAtIndex_NoData_ExceptionThrown) {
const DeckFloatItem deckFloatItem("TEST");
BOOST_CHECK_THROW(deckFloatItem.getRawFloat(0), std::out_of_range);
}
BOOST_AUTO_TEST_CASE(PushBackFloat_VectorPushed_ElementsCorrect) {
DeckFloatItem deckFloatItem("TEST");
std::deque<float> pushThese;
pushThese.push_back(13);
pushThese.push_back(33);
deckFloatItem.push_back(pushThese);
BOOST_CHECK_EQUAL(13, deckFloatItem.getRawFloat(0));
BOOST_CHECK_EQUAL(33, deckFloatItem.getRawFloat(1));
}
BOOST_AUTO_TEST_CASE(PushBackFloat_subVectorPushed_ElementsCorrect) {
DeckFloatItem deckFloatItem("TEST");
std::deque<float> pushThese;
pushThese.push_back(13);
pushThese.push_back(33);
pushThese.push_back(47);
deckFloatItem.push_back(pushThese , 2);
BOOST_CHECK_EQUAL(13 , deckFloatItem.getRawFloat(0));
BOOST_CHECK_EQUAL(33 , deckFloatItem.getRawFloat(1));
BOOST_CHECK_EQUAL( 2U , deckFloatItem.size());
}
BOOST_AUTO_TEST_CASE(sizeFloat_correct) {
DeckFloatItem deckFloatItem("TEST");
BOOST_CHECK_EQUAL( 0U , deckFloatItem.size());
deckFloatItem.push_back( 100 );
BOOST_CHECK_EQUAL( 1U , deckFloatItem.size());
deckFloatItem.push_back( 100 );
deckFloatItem.push_back( 100 );
BOOST_CHECK_EQUAL( 3U , deckFloatItem.size());
}
BOOST_AUTO_TEST_CASE(DefaultApplied) {
DeckFloatItem deckFloatItem("TEST");
BOOST_CHECK_EQUAL( false , deckFloatItem.defaultApplied() );
deckFloatItem.push_backDefault( 1 );
BOOST_CHECK_EQUAL( true , deckFloatItem.defaultApplied() );
}
BOOST_AUTO_TEST_CASE(PushBackMultiple) {
DeckFloatItem item("HEI");
item.push_backMultiple(10.22 , 100 );
BOOST_CHECK_EQUAL( 100U , item.size() );
for (size_t i=0; i < 100; i++)
BOOST_CHECK_EQUAL(10.22F , item.getRawFloat(i));
}
BOOST_AUTO_TEST_CASE(PushBackDimension) {
DeckFloatItem item("HEI");
std::shared_ptr<Dimension> activeDimension(new Dimension("Length" , 100));
std::shared_ptr<Dimension> defaultDimension(new Dimension("Length" , 10));
item.push_backDimension( activeDimension , defaultDimension);
}
BOOST_AUTO_TEST_CASE(PushBackDimensionInvalidType) {
DeckIntItem item("HEI");
std::shared_ptr<Dimension> dim(new Dimension("Length" , 100));
BOOST_CHECK_THROW( item.push_backDimension( dim , dim ) , std::invalid_argument );
}
BOOST_AUTO_TEST_CASE(GetSIWithoutDimensionThrows) {
DeckFloatItem item("HEI");
item.push_backMultiple(10.22 , 100 );
BOOST_CHECK_THROW( item.getSIFloat(0) , std::invalid_argument );
BOOST_CHECK_THROW( item.getSIFloatData( ) , std::invalid_argument );
}
BOOST_AUTO_TEST_CASE(GetSISingleDimensionCorrect) {
DeckFloatItem item("HEI");
std::shared_ptr<Dimension> dim(new Dimension("Length" , 100));
item.push_backMultiple(1 , 100 );
item.push_backDimension( dim , dim );
BOOST_CHECK_EQUAL( 1 , item.getRawFloat(0) );
BOOST_CHECK_EQUAL( 100 , item.getSIFloat(0) );
}
BOOST_AUTO_TEST_CASE(GetSISingleDefault) {
DeckFloatItem item("HEI");
std::shared_ptr<Dimension> dim(new Dimension("Length" , 1));
std::shared_ptr<Dimension> defaultDim(new Dimension("Length" , 100));
item.push_backDefault(1 );
item.push_backDimension( dim , defaultDim );
BOOST_CHECK_EQUAL( 1 , item.getRawFloat(0) );
BOOST_CHECK_EQUAL( 100 , item.getSIFloat(0) );
}
BOOST_AUTO_TEST_CASE(GetSIMultipleDim) {
DeckFloatItem item("HEI");
std::shared_ptr<Dimension> dim1(new Dimension("Length" , 2));
std::shared_ptr<Dimension> dim2(new Dimension("Length" , 4));
std::shared_ptr<Dimension> dim3(new Dimension("Length" , 8));
std::shared_ptr<Dimension> dim4(new Dimension("Length" ,16));
std::shared_ptr<Dimension> defaultDim(new Dimension("Length" , 100));
item.push_backMultiple( 1 , 16 );
item.push_backDimension( dim1 , defaultDim );
item.push_backDimension( dim2 , defaultDim );
item.push_backDimension( dim3 , defaultDim );
item.push_backDimension( dim4 , defaultDim );
for (size_t i=0; i < 16; i+= 4) {
BOOST_CHECK_EQUAL( 2 , item.getSIFloat(i) );
BOOST_CHECK_EQUAL( 4 , item.getSIFloat(i+ 1) );
BOOST_CHECK_EQUAL( 8 , item.getSIFloat(i+2) );
BOOST_CHECK_EQUAL(16 , item.getSIFloat(i+3) );
}
}

2
opm/parser/eclipse/Parser/ParserEnums.cpp
View File

@@ -108,6 +108,8 @@ namespace Opm {
return INT;
else if (stringValue == "FLOAT")
return FLOAT;
else if (stringValue == "DOUBLE")
return DOUBLE;
else if (stringValue == "STRING")
return STRING;
else

3
opm/parser/eclipse/Parser/ParserEnums.hpp
View File

@@ -44,7 +44,8 @@ namespace Opm {
enum ParserValueTypeEnum {
INT = 0,
FLOAT = 1,
STRING = 2
STRING = 2,
DOUBLE = 3
};

184
opm/parser/eclipse/Parser/ParserFloatItem.cpp Normal file
View File

@@ -0,0 +1,184 @@
/*
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 <opm/json/JsonObject.hpp>
#include <opm/parser/eclipse/Parser/ParserItem.hpp>
#include <opm/parser/eclipse/Parser/ParserFloatItem.hpp>
#include <opm/parser/eclipse/Parser/ParserEnums.hpp>
#include <opm/parser/eclipse/RawDeck/RawRecord.hpp>
#include <opm/parser/eclipse/RawDeck/StarToken.hpp>
#include <opm/parser/eclipse/Deck/DeckFloatItem.hpp>
namespace Opm
{
ParserFloatItem::ParserFloatItem(const std::string& itemName,
ParserItemSizeEnum sizeType) :
ParserItem(itemName, sizeType)
{
m_default = defaultFloat();
}
ParserFloatItem::ParserFloatItem(const std::string& itemName) : ParserItem(itemName)
{
m_default = defaultFloat();
}
ParserFloatItem::ParserFloatItem(const std::string& itemName, float defaultValue) : ParserItem(itemName)
{
setDefault( defaultValue );
}
ParserFloatItem::ParserFloatItem(const std::string& itemName, ParserItemSizeEnum sizeType, float defaultValue) : ParserItem(itemName, sizeType)
{
setDefault( defaultValue );
}
float ParserFloatItem::getDefault() const {
return m_default;
}
void ParserFloatItem::setDefault(float defaultValue) {
m_default = defaultValue;
m_defaultSet = true;
}
ParserFloatItem::ParserFloatItem(const Json::JsonObject& jsonConfig) :
ParserItem(jsonConfig)
{
if (jsonConfig.has_item("default"))
setDefault( jsonConfig.get_double("default"));
else
m_default = defaultFloat();
}
bool ParserFloatItem::equal(const ParserItem& other) const
{
// cast to a pointer to avoid bad_cast exception
const ParserFloatItem* rhs = dynamic_cast<const ParserFloatItem*>(&other);
if (rhs && ParserItem::equal(other) && (getDefault() == rhs->getDefault())) {
return equalDimensions( other );
}
else
return false;
}
bool ParserFloatItem::equalDimensions(const ParserItem& other) const {
bool equal=false;
if (other.numDimensions() == numDimensions()) {
equal = true;
for (size_t idim=0; idim < numDimensions(); idim++) {
if (other.getDimension(idim) != getDimension(idim))
equal = false;
}
}
return equal;
}
void ParserFloatItem::push_backDimension(const std::string& dimension) {
if ((sizeType() == SINGLE) && (m_dimensions.size() > 0))
throw std::invalid_argument("Internal error - can not add more than one dimension to a Item os size 1");
m_dimensions.push_back( dimension );
}
bool ParserFloatItem::hasDimension() const {
return (m_dimensions.size() > 0);
}
size_t ParserFloatItem::numDimensions() const {
return m_dimensions.size();
}
const std::string& ParserFloatItem::getDimension(size_t index) const {
if (index < m_dimensions.size())
return m_dimensions[index];
else
throw std::invalid_argument("Invalid index ");
}
/// Scans the rawRecords data according to the ParserItems definition.
/// returns a DeckItem object.
/// NOTE: data are popped from the rawRecords deque!
DeckItemPtr ParserFloatItem::scan(RawRecordPtr rawRecord) const {
DeckFloatItemPtr deckItem(new DeckFloatItem(name()));
float defaultValue = m_default;
if (sizeType() == ALL) { // This can probably not be combined with a default value ....
// The '*' should be interpreted as a multiplication sign
while (rawRecord->size() > 0) {
std::string token = rawRecord->pop_front();
if (tokenContainsStar( token )) {
StarToken<float> st(token);
float value = defaultValue; // This probably does never apply
if (st.hasValue())
value = st.value();
deckItem->push_backMultiple( value , st.multiplier() );
} else {
float value = readValueToken<float>(token);
deckItem->push_back(value);
}
}
} else {
// The '*' should be interpreted as a default indicator
if (rawRecord->size() > 0) {
std::string token = rawRecord->pop_front();
if (tokenContainsStar( token )) {
StarToken<float> st(token);
if (st.hasValue()) { // Probably never true
deckItem->push_back( st.value() );
std::string stringValue = boost::lexical_cast<std::string>(st.value());
for (size_t i=1; i < st.multiplier(); i++)
rawRecord->push_front( stringValue );
} else {
deckItem->push_backDefault( defaultValue );
for (size_t i=1; i < st.multiplier(); i++)
rawRecord->push_front( "*" );
}
} else {
float value = readValueToken<float>(token);
deckItem->push_back(value);
}
} else
deckItem->push_backDefault( defaultValue );
}
return deckItem;
}
void ParserFloatItem::inlineNew(std::ostream& os) const {
os << "new ParserFloatItem(" << "\"" << name() << "\"" << "," << ParserItemSizeEnum2String( sizeType() );
if (m_defaultSet)
os << "," << getDefault();
os << ")";
}
}

66
opm/parser/eclipse/Parser/ParserFloatItem.hpp Normal file
View File

@@ -0,0 +1,66 @@
/*
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/>.
*/
#ifndef PARSERFLOATITEM_HPP
#define PARSERFLOATITEM_HPP
#include <memory>
#include <opm/json/JsonObject.hpp>
#include <opm/parser/eclipse/Parser/ParserItem.hpp>
#include <opm/parser/eclipse/Parser/ParserEnums.hpp>
#include <opm/parser/eclipse/RawDeck/RawRecord.hpp>
namespace Opm {
class ParserFloatItem : public ParserItem
{
public:
ParserFloatItem(const std::string& itemName);
ParserFloatItem(const std::string& itemName, ParserItemSizeEnum sizeType);
ParserFloatItem(const std::string& itemName, float defaultValue);
ParserFloatItem(const std::string& itemName, ParserItemSizeEnum sizeType, float defaultValue);
explicit ParserFloatItem( const Json::JsonObject& jsonConfig);
size_t numDimensions() const;
bool hasDimension() const;
void push_backDimension(const std::string& dimension);
const std::string& getDimension(size_t index) const;
bool equalDimensions(const ParserItem& other) const;
DeckItemPtr scan(RawRecordPtr rawRecord) const;
bool equal(const ParserItem& other) const;
void inlineNew(std::ostream& os) const;
void setDefault(float defaultValue);
float getDefault() const;
size_t dimensionSize() const;
private:
float m_default;
std::vector<std::string> m_dimensions;
};
typedef std::shared_ptr<const ParserFloatItem> ParserFloatItemConstPtr;
typedef std::shared_ptr<ParserFloatItem> ParserFloatItemPtr;
}
#endif // PARSERFLOATITEM_HPP

4
opm/parser/eclipse/Parser/ParserItem.cpp
View File

@@ -96,6 +96,10 @@ namespace Opm {
return 0;
}
float ParserItem::defaultFloat() {
return 0.0F;
}
double ParserItem::defaultDouble() {
return 0.0;
}

1
opm/parser/eclipse/Parser/ParserItem.hpp
View File

@@ -54,6 +54,7 @@ namespace Opm {
static int defaultInt();
static std::string defaultString();
static float defaultFloat();
static double defaultDouble();
virtual bool equal(const ParserItem& other) const;

4
opm/parser/eclipse/Parser/ParserKeyword.cpp
View File

@@ -250,7 +250,7 @@ namespace Opm {
addItem(item);
}
break;
case FLOAT:
case DOUBLE:
{
ParserDoubleItemPtr item = ParserDoubleItemPtr(new ParserDoubleItem(itemConfig));
initItemDimension( item , itemConfig );
@@ -316,7 +316,7 @@ namespace Opm {
addDataItem(item);
}
break;
case FLOAT:
case DOUBLE:
{
ParserDoubleItemPtr item = ParserDoubleItemPtr(new ParserDoubleItem(itemName, ALL));
if (hasDefault) {

108
opm/parser/eclipse/Parser/tests/ParserItemTests.cpp
View File

@@ -28,6 +28,7 @@
#include <opm/parser/eclipse/Parser/ParserIntItem.hpp>
#include <opm/parser/eclipse/Parser/ParserBoolItem.hpp>
#include <opm/parser/eclipse/Parser/ParserDoubleItem.hpp>
#include <opm/parser/eclipse/Parser/ParserFloatItem.hpp>
#include <opm/parser/eclipse/Parser/ParserStringItem.hpp>
#include <opm/parser/eclipse/RawDeck/RawRecord.hpp>
@@ -41,16 +42,19 @@ BOOST_AUTO_TEST_CASE(Initialize) {
BOOST_CHECK_NO_THROW(ParserIntItem item1("ITEM1", sizeType));
BOOST_CHECK_NO_THROW(ParserStringItem item1("ITEM1", sizeType));
BOOST_CHECK_NO_THROW(ParserDoubleItem item1("ITEM1", sizeType));
BOOST_CHECK_NO_THROW(ParserFloatItem item1("ITEM1", sizeType));
}
BOOST_AUTO_TEST_CASE(Initialize_DefaultSizeType) {
ParserIntItem item1(std::string("ITEM1"));
ParserStringItem item2(std::string("ITEM1"));
ParserDoubleItem item3(std::string("ITEM1"));
ParserFloatItem item4(std::string("ITEM1"));
BOOST_CHECK_EQUAL( SINGLE , item1.sizeType());
BOOST_CHECK_EQUAL( SINGLE , item2.sizeType());
BOOST_CHECK_EQUAL( SINGLE , item3.sizeType());
BOOST_CHECK_EQUAL( SINGLE , item4.sizeType());
}
@@ -70,6 +74,13 @@ BOOST_AUTO_TEST_CASE(Initialize_Default_Double) {
BOOST_CHECK_EQUAL( 88.91 , item2.getDefault());
}
BOOST_AUTO_TEST_CASE(Initialize_Default_Float) {
ParserFloatItem item1(std::string("ITEM1"));
ParserFloatItem item2("ITEM1", 88.91F);
BOOST_CHECK_EQUAL(item1.getDefault(), ParserItem::defaultFloat());
BOOST_CHECK_EQUAL( 88.91F , item2.getDefault());
}
BOOST_AUTO_TEST_CASE(scan_PreMatureTerminator_defaultUsed) {
ParserIntItem itemInt(std::string("ITEM2"));
@@ -184,6 +195,17 @@ BOOST_AUTO_TEST_CASE(DoubleItem_Equal_ReturnsTrue) {
}
BOOST_AUTO_TEST_CASE(FloatItem_Equal_ReturnsTrue) {
ParserItemSizeEnum sizeType = ALL;
ParserFloatItem item1("ITEM1", sizeType);
ParserFloatItem item2("ITEM1", sizeType);
ParserFloatItem item3 = item1;
BOOST_CHECK( item1.equal( item2 ));
BOOST_CHECK( item1.equal( item3 ));
}
BOOST_AUTO_TEST_CASE(DoubleItem_DimEqual_ReturnsTrue) {
ParserItemSizeEnum sizeType = ALL;
ParserDoubleItem item1("ITEM1", sizeType);
@@ -196,6 +218,18 @@ BOOST_AUTO_TEST_CASE(DoubleItem_DimEqual_ReturnsTrue) {
}
BOOST_AUTO_TEST_CASE(FloatItem_DimEqual_ReturnsTrue) {
ParserItemSizeEnum sizeType = ALL;
ParserFloatItem item1("ITEM1", sizeType);
ParserFloatItem item2("ITEM1", sizeType);
item1.push_backDimension("Length*Length");
item2.push_backDimension("Length*Length");
BOOST_CHECK( item1.equal( item2 ));
}
BOOST_AUTO_TEST_CASE(DoubleItem_DimDifferent_ReturnsFalse) {
ParserItemSizeEnum sizeType = ALL;
ParserDoubleItem item1("ITEM1", sizeType); // Dim: []
@@ -210,6 +244,30 @@ BOOST_AUTO_TEST_CASE(DoubleItem_DimDifferent_ReturnsFalse) {
item4.push_backDimension("Time");
BOOST_CHECK_EQUAL(false , item1.equal( item2 ));
BOOST_CHECK_EQUAL(false , item2.equal( item3 ));
BOOST_CHECK_EQUAL(false , item2.equal( item1 ));
BOOST_CHECK_EQUAL(false , item2.equal( item4 ));
BOOST_CHECK_EQUAL(false , item1.equal( item3 ));
BOOST_CHECK_EQUAL(false , item3.equal( item1 ));
BOOST_CHECK_EQUAL(false , item4.equal( item2 ));
}
BOOST_AUTO_TEST_CASE(FloatItem_DimDifferent_ReturnsFalse) {
ParserItemSizeEnum sizeType = ALL;
ParserFloatItem item1("ITEM1", sizeType); // Dim: []
ParserFloatItem item2("ITEM1", sizeType); // Dim: [Length]
ParserFloatItem item3("ITEM1", sizeType); // Dim: [Length ,Length]
ParserFloatItem item4("ITEM1", sizeType); // Dim: [t]
item2.push_backDimension("Length");
item3.push_backDimension("Length");
item3.push_backDimension("Length");
item4.push_backDimension("Time");
BOOST_CHECK_EQUAL(false , item1.equal( item2 ));
BOOST_CHECK_EQUAL(false , item2.equal( item3 ));
BOOST_CHECK_EQUAL(false , item2.equal( item1 ));
@@ -234,6 +292,19 @@ BOOST_AUTO_TEST_CASE(DoubleItem_Different_ReturnsFalse) {
}
BOOST_AUTO_TEST_CASE(FloatItem_Different_ReturnsFalse) {
ParserFloatItem item1("ITEM1", ALL);
ParserFloatItem item2("ITEM2", ALL);
ParserFloatItem item3(std::string("ITEM1") );
ParserFloatItem item4("ITEM1" , 42.89);
BOOST_CHECK( !item1.equal( item2 ));
BOOST_CHECK( !item1.equal( item3 ));
BOOST_CHECK( !item2.equal( item3 ));
BOOST_CHECK( !item4.equal( item3 ));
}
BOOST_AUTO_TEST_CASE(StringItem_Equal_ReturnsTrue) {
ParserItemSizeEnum sizeType = ALL;
ParserStringItem item1("ITEM1", sizeType);
@@ -577,10 +648,12 @@ BOOST_AUTO_TEST_CASE(ParserDefaultHasDimensionReturnsFalse) {
ParserIntItem intItem(std::string("SOMEINTS"));
ParserStringItem stringItem(std::string("SOMESTRING"));
ParserDoubleItem doubleItem(std::string("SOMEDOUBLE"));
ParserFloatItem floatItem(std::string("SOMEFLOAT"));
BOOST_CHECK_EQUAL( false, intItem.hasDimension());
BOOST_CHECK_EQUAL( false, stringItem.hasDimension());
BOOST_CHECK_EQUAL( false, doubleItem.hasDimension());
BOOST_CHECK_EQUAL( false, floatItem.hasDimension());
}
BOOST_AUTO_TEST_CASE(ParserIntItemGetDimensionThrows) {
@@ -600,6 +673,14 @@ BOOST_AUTO_TEST_CASE(ParserDoubleItemAddMultipleDimensionToSIngleSizeThrows) {
}
BOOST_AUTO_TEST_CASE(ParserFloatItemAddMultipleDimensionToSIngleSizeThrows) {
ParserFloatItem floatItem(std::string("SOMEFLOAT"));
floatItem.push_backDimension("Length*Length");
BOOST_CHECK_THROW( floatItem.push_backDimension("Length*Length"), std::invalid_argument);
}
BOOST_AUTO_TEST_CASE(ParserDoubleItemWithDimensionHasReturnsCorrect) {
ParserDoubleItem doubleItem(std::string("SOMEDOUBLE"));
@@ -609,6 +690,15 @@ BOOST_AUTO_TEST_CASE(ParserDoubleItemWithDimensionHasReturnsCorrect) {
}
BOOST_AUTO_TEST_CASE(ParserFloatItemWithDimensionHasReturnsCorrect) {
ParserFloatItem floatItem(std::string("SOMEFLOAT"));
BOOST_CHECK_EQUAL( false , floatItem.hasDimension() );
floatItem.push_backDimension("Length*Length");
BOOST_CHECK_EQUAL( true , floatItem.hasDimension() );
}
BOOST_AUTO_TEST_CASE(ParserDoubleItemGetDimension) {
ParserDoubleItem doubleItem(std::string("SOMEDOUBLE") , ALL);
@@ -625,3 +715,19 @@ BOOST_AUTO_TEST_CASE(ParserDoubleItemGetDimension) {
BOOST_CHECK_THROW( doubleItem.getDimension( 3 ) , std::invalid_argument );
}
BOOST_AUTO_TEST_CASE(ParserFloatItemGetDimension) {
ParserFloatItem floatItem(std::string("SOMEFLOAT") , ALL);
BOOST_CHECK_THROW( floatItem.getDimension( 10 ) , std::invalid_argument );
BOOST_CHECK_THROW( floatItem.getDimension( 0 ) , std::invalid_argument );
floatItem.push_backDimension("Length");
floatItem.push_backDimension("Length*Length");
floatItem.push_backDimension("Length*Length*Length");
BOOST_CHECK_EQUAL( "Length" , floatItem.getDimension(0));
BOOST_CHECK_EQUAL( "Length*Length" , floatItem.getDimension(1));
BOOST_CHECK_EQUAL( "Length*Length*Length" , floatItem.getDimension(2));
BOOST_CHECK_THROW( floatItem.getDimension( 3 ) , std::invalid_argument );
}

12
opm/parser/eclipse/Parser/tests/ParserKeywordTests.cpp
View File

@@ -179,7 +179,7 @@ BOOST_AUTO_TEST_CASE(ConstructFromJsonObjectWithAction) {
BOOST_AUTO_TEST_CASE(ConstructFromJsonObject_withSize) {
Json::JsonObject jsonObject("{\"name\": \"BPR\", \"size\" : 100 , \"items\" :[{\"name\":\"ItemX\" , \"size_type\":\"SINGLE\" , \"value_type\" : \"FLOAT\"}]}");
Json::JsonObject jsonObject("{\"name\": \"BPR\", \"size\" : 100 , \"items\" :[{\"name\":\"ItemX\" , \"size_type\":\"SINGLE\" , \"value_type\" : \"DOUBLE\"}]}");
ParserKeyword parserKeyword(jsonObject);
BOOST_CHECK_EQUAL("BPR" , parserKeyword.getName());
@@ -211,7 +211,7 @@ BOOST_AUTO_TEST_CASE(ConstructFromJsonObject_nosize_notItems_OK) {
BOOST_AUTO_TEST_CASE(ConstructFromJsonObject_withSizeOther) {
Json::JsonObject jsonObject("{\"name\": \"BPR\", \"size\" : {\"keyword\" : \"Bjarne\" , \"item\": \"BjarneIgjen\"}, \"items\" :[{\"name\":\"ItemX\" , \"value_type\" : \"FLOAT\"}]}");
Json::JsonObject jsonObject("{\"name\": \"BPR\", \"size\" : {\"keyword\" : \"Bjarne\" , \"item\": \"BjarneIgjen\"}, \"items\" :[{\"name\":\"ItemX\" , \"value_type\" : \"DOUBLE\"}]}");
ParserKeyword parserKeyword(jsonObject);
const std::pair<std::string,std::string>& sizeKW = parserKeyword.getSizeDefinitionPair();
BOOST_CHECK_EQUAL("BPR" , parserKeyword.getName());
@@ -271,7 +271,7 @@ BOOST_AUTO_TEST_CASE(ConstructFromJsonObjectItemsOK) {
BOOST_AUTO_TEST_CASE(ConstructFromJsonObject_sizeFromOther) {
Json::JsonObject jsonConfig("{\"name\": \"EQUILX\", \"size\" : {\"keyword\":\"EQLDIMS\" , \"item\" : \"NTEQUL\"}, \"items\" :[{\"name\":\"ItemX\" ,\"value_type\" : \"FLOAT\"}]}");
Json::JsonObject jsonConfig("{\"name\": \"EQUILX\", \"size\" : {\"keyword\":\"EQLDIMS\" , \"item\" : \"NTEQUL\"}, \"items\" :[{\"name\":\"ItemX\" ,\"value_type\" : \"DOUBLE\"}]}");
BOOST_CHECK_NO_THROW( ParserKeyword parserKeyword(jsonConfig) );
}
@@ -308,7 +308,7 @@ BOOST_AUTO_TEST_CASE(AddkeywordFromJson_numTables_incoorect_throw) {
BOOST_AUTO_TEST_CASE(AddkeywordFromJson_isTableCollection) {
Json::JsonObject jsonConfig("{\"name\": \"PVTG\", \"num_tables\" : {\"keyword\": \"TABDIMS\" , \"item\" : \"NTPVT\"} , \"items\" : [{\"name\" : \"data\", \"value_type\" : \"FLOAT\"}]}");
Json::JsonObject jsonConfig("{\"name\": \"PVTG\", \"num_tables\" : {\"keyword\": \"TABDIMS\" , \"item\" : \"NTPVT\"} , \"items\" : [{\"name\" : \"data\", \"value_type\" : \"DOUBLE\"}]}");
ParserKeyword parserKeyword(jsonConfig);
ParserRecordConstPtr parserRecord = parserKeyword.getRecord();
@@ -472,7 +472,7 @@ BOOST_AUTO_TEST_CASE(ParseKeywordHasDimensionCorrect) {
BOOST_AUTO_TEST_CASE(ConstructFromJsonObject_withDimension) {
Json::JsonObject jsonObject("{\"name\": \"BPR\", \"size\" : 100 , \"items\" :[{\"name\":\"ItemX\" , \"size_type\":\"SINGLE\" , \"value_type\" : \"FLOAT\" , \"dimension\" : \"Length*Length/Time\"}]}");
Json::JsonObject jsonObject("{\"name\": \"BPR\", \"size\" : 100 , \"items\" :[{\"name\":\"ItemX\" , \"size_type\":\"SINGLE\" , \"value_type\" : \"DOUBLE\" , \"dimension\" : \"Length*Length/Time\"}]}");
ParserKeyword parserKeyword(jsonObject);
ParserRecordConstPtr record = parserKeyword.getRecord();
ParserItemConstPtr item = record->get("ItemX");
@@ -490,7 +490,7 @@ BOOST_AUTO_TEST_CASE(ConstructFromJsonObject_withDimension) {
BOOST_AUTO_TEST_CASE(ConstructFromJsonObject_withDimensionList) {
Json::JsonObject jsonObject("{\"name\": \"BPR\", \"size\" : 100 , \"items\" :[{\"name\":\"ItemX\" , \"size_type\":\"ALL\" , \"value_type\" : \"FLOAT\" , \"dimension\" : [\"Length*Length/Time\" , \"Time\", \"1\"]}]}");
Json::JsonObject jsonObject("{\"name\": \"BPR\", \"size\" : 100 , \"items\" :[{\"name\":\"ItemX\" , \"size_type\":\"ALL\" , \"value_type\" : \"DOUBLE\" , \"dimension\" : [\"Length*Length/Time\" , \"Time\", \"1\"]}]}");
ParserKeyword parserKeyword(jsonObject);
ParserRecordConstPtr record = parserKeyword.getRecord();
ParserItemConstPtr item = record->get("ItemX");

8
opm/parser/eclipse/Parser/tests/ParserTests.cpp
View File

@@ -95,7 +95,7 @@ BOOST_AUTO_TEST_CASE(getAllKeywords_hasNoKeywords_returnsEmptyList) {
BOOST_AUTO_TEST_CASE(addKeywordJSON_canParseKeyword_returnstrue) {
ParserPtr parser(new Parser());
Json::JsonObject jsonConfig("{\"name\": \"BPR\", \"size\" : 100 , \"items\" :[{\"name\":\"ItemX\" , \"size_type\":\"SINGLE\" , \"value_type\" : \"FLOAT\"}]}");
Json::JsonObject jsonConfig("{\"name\": \"BPR\", \"size\" : 100 , \"items\" :[{\"name\":\"ItemX\" , \"size_type\":\"SINGLE\" , \"value_type\" : \"DOUBLE\"}]}");
parser->addKeyword(ParserKeywordConstPtr(new ParserKeyword( jsonConfig )));
BOOST_CHECK(parser->canParseKeyword("BPR"));
}
@@ -103,7 +103,7 @@ BOOST_AUTO_TEST_CASE(addKeywordJSON_canParseKeyword_returnstrue) {
BOOST_AUTO_TEST_CASE(addKeywordJSON_size_isObject_allGood) {
ParserPtr parser(new Parser());
Json::JsonObject jsonConfig("{\"name\": \"EQUIXL\", \"size\" : {\"keyword\":\"EQLDIMS\" , \"item\" : \"NTEQUL\"}, \"items\" :[{\"name\":\"ItemX\" , \"size_type\":\"SINGLE\" , \"value_type\" : \"FLOAT\"}]}");
Json::JsonObject jsonConfig("{\"name\": \"EQUIXL\", \"size\" : {\"keyword\":\"EQLDIMS\" , \"item\" : \"NTEQUL\"}, \"items\" :[{\"name\":\"ItemX\" , \"size_type\":\"SINGLE\" , \"value_type\" : \"DOUBLE\"}]}");
parser->addKeyword(ParserKeywordConstPtr(new ParserKeyword( jsonConfig )));
BOOST_CHECK(parser->canParseKeyword("EQUIXL"));
}
@@ -121,7 +121,7 @@ BOOST_AUTO_TEST_CASE(loadKeywordsJSON_notArray_throw) {
BOOST_AUTO_TEST_CASE(loadKeywordsJSON_canParseKeyword_returnstrue) {
ParserPtr parser(new Parser());
Json::JsonObject jsonConfig( "[{\"name\" : \"BPR\" , \"size\" : 100, \"items\" :[{\"name\":\"ItemX\" , \"size_type\":\"SINGLE\" , \"value_type\" : \"FLOAT\"}]}]");
Json::JsonObject jsonConfig( "[{\"name\" : \"BPR\" , \"size\" : 100, \"items\" :[{\"name\":\"ItemX\" , \"size_type\":\"SINGLE\" , \"value_type\" : \"DOUBLE\"}]}]");
parser->loadKeywords( jsonConfig );
BOOST_CHECK(parser->canParseKeyword("BPR"));
@@ -137,7 +137,7 @@ BOOST_AUTO_TEST_CASE(empty_sizeReturns0) {
BOOST_AUTO_TEST_CASE(loadKeywordsJSON_manyKeywords_returnstrue) {
ParserPtr parser(new Parser( false ));
Json::JsonObject jsonConfig( "[{\"name\" : \"BPR\" , \"size\" : 100 , \"items\" :[{\"name\":\"ItemX\" , \"size_type\":\"SINGLE\" , \"value_type\" : \"FLOAT\"}]}, {\"name\" : \"WWCT\", \"size\" : 0} , {\"name\" : \"EQUIL\" , \"size\" : 0}]");
Json::JsonObject jsonConfig( "[{\"name\" : \"BPR\" , \"size\" : 100 , \"items\" :[{\"name\":\"ItemX\" , \"size_type\":\"SINGLE\" , \"value_type\" : \"DOUBLE\"}]}, {\"name\" : \"WWCT\", \"size\" : 0} , {\"name\" : \"EQUIL\" , \"size\" : 0}]");
parser->loadKeywords( jsonConfig );
BOOST_CHECK(parser->canParseKeyword("BPR"));

37
opm/parser/eclipse/Parser/tests/createInlineItemTest.cpp
View File

@@ -7,6 +7,7 @@
#include <opm/parser/eclipse/Parser/ParserIntItem.hpp>
#include <opm/parser/eclipse/Parser/ParserStringItem.hpp>
#include <opm/parser/eclipse/Parser/ParserDoubleItem.hpp>
#include <opm/parser/eclipse/Parser/ParserFloatItem.hpp>
using namespace Opm;
@@ -17,6 +18,7 @@ void createHeader(std::ofstream& of , const std::string& test_module) {
of << "#include <opm/parser/eclipse/Parser/ParserIntItem.hpp>" << std::endl;
of << "#include <opm/parser/eclipse/Parser/ParserStringItem.hpp>" << std::endl;
of << "#include <opm/parser/eclipse/Parser/ParserDoubleItem.hpp>" << std::endl;
of << "#include <opm/parser/eclipse/Parser/ParserFloatItem.hpp>" << std::endl;
of << "using namespace Opm;" << std::endl << std::endl;
}
@@ -93,6 +95,38 @@ void endTest(std::ofstream& of) {
endTest(of);
}
/*****************************************************************/
void FloatItem(std::ofstream& of) {
startTest(of , "FloatItem");
of << " ParserFloatItem * item = new ParserFloatItem(\"NAME\" , ALL);" << std::endl;
of << " ParserFloatItem * inlineItem = ";
{
ParserFloatItem * item = new ParserFloatItem("NAME" , ALL);
item->inlineNew( of );
of << ";" << std::endl;
delete item;
}
of << " BOOST_CHECK( item->equal( *inlineItem ) );" << std::endl;
endTest(of);
}
void FloatItemWithDefault(std::ofstream& of) {
startTest(of , "FloatItemWithDefault");
of << " ParserFloatItem * item = new ParserFloatItem(\"NAME\" , SINGLE , 100.89);" << std::endl;
of << " ParserFloatItem * inlineItem = ";
{
ParserFloatItem * item = new ParserFloatItem("NAME" , SINGLE , 100.89);
item->inlineNew( of );
of << ";" << std::endl;
delete item;
}
of << " BOOST_CHECK( item->equal( *inlineItem ) );" << std::endl;
endTest(of);
}
/*****************************************************************/
void stringItem(std::ofstream& of) {
@@ -137,6 +171,9 @@ int main(int argc , char ** argv) {
DoubleItem( of );
DoubleItemWithDefault( of );
FloatItem( of );
FloatItemWithDefault( of );
stringItem( of );
stringItemWithDefault( of );

2
opm/parser/eclipse/Parser/tests/createInlineKeywordTest.cpp
View File

@@ -8,6 +8,7 @@
#include <opm/parser/eclipse/Parser/ParserIntItem.hpp>
#include <opm/parser/eclipse/Parser/ParserStringItem.hpp>
#include <opm/parser/eclipse/Parser/ParserDoubleItem.hpp>
#include <opm/parser/eclipse/Parser/ParserFloatItem.hpp>
#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
#include <opm/parser/eclipse/Parser/ParserRecord.hpp>
@@ -22,6 +23,7 @@ void createHeader(std::ofstream& of , const std::string& test_module) {
of << "#include <opm/parser/eclipse/Parser/ParserIntItem.hpp>" << std::endl;
of << "#include <opm/parser/eclipse/Parser/ParserStringItem.hpp>" << std::endl;
of << "#include <opm/parser/eclipse/Parser/ParserDoubleItem.hpp>" << std::endl;
of << "#include <opm/parser/eclipse/Parser/ParserFloatItem.hpp>" << std::endl;
of << "#include <opm/parser/eclipse/Parser/ParserRecord.hpp>" << std::endl;
of << "#include <opm/parser/eclipse/Units/UnitSystem.hpp>" << std::endl;
of << "using namespace Opm;" << std::endl << std::endl;

2
opm/parser/share/keywords/A/ADD
View File

@@ -1,6 +1,6 @@
{"name" : "ADD", "items" : [
{"name" : "field" , "value_type" : "STRING"},
{"name" : "shift" , "value_type" : "FLOAT"},
{"name" : "shift" , "value_type" : "DOUBLE"},
{"name" : "I1" , "value_type" : "INT"},
{"name" : "I2" , "value_type" : "INT"},
{"name" : "J1" , "value_type" : "INT"},

12
opm/parser/share/keywords/C/COMPDAT
View File

@@ -6,10 +6,10 @@
{"name" : "K2" , "value_type" : "INT" },
{"name" : "STATE" , "value_type" : "STRING" , "default" : "OPEN"},
{"name" : "SAT_TABLE" , "value_type" : "INT" , "default" : 0},
{"name" : "CF" , "value_type" : "FLOAT", "dimension" : "Viscosity*LiquidVolume/Time*Pressure"},
{"name" : "DIAMETER" , "value_type" : "FLOAT", "dimension" : "Length"},
{"name" : "Kh" , "value_type" : "FLOAT", "dimension" : "Permeability" , "default" : -1},
{"name" : "SKIN" , "value_type" : "FLOAT", "dimension" : "1" , "default" : 0},
{"name" : "D_FACTOR" , "value_type" : "FLOAT", "dimension" : "1" },
{"name" : "CF" , "value_type" : "DOUBLE", "dimension" : "Viscosity*LiquidVolume/Time*Pressure"},
{"name" : "DIAMETER" , "value_type" : "DOUBLE", "dimension" : "Length"},
{"name" : "Kh" , "value_type" : "DOUBLE", "dimension" : "Permeability" , "default" : -1},
{"name" : "SKIN" , "value_type" : "DOUBLE", "dimension" : "1" , "default" : 0},
{"name" : "D_FACTOR" , "value_type" : "DOUBLE", "dimension" : "1" },
{"name" : "DIR" , "value_type" : "STRING" , "default" : "Z"},
{"name" : "PR" , "value_type" : "FLOAT", "dimension" : "Pressure" }]}
{"name" : "PR" , "value_type" : "DOUBLE", "dimension" : "Pressure" }]}

2
opm/parser/share/keywords/C/COORD
View File

@@ -1 +1 @@
{"name" : "COORD", "data" : {"value_type" : "FLOAT", "dimension" : "Length" }}
{"name" : "COORD", "data" : {"value_type" : "DOUBLE", "dimension" : "Length" }}

6
opm/parser/share/keywords/D/DENSITY
View File

@@ -1,4 +1,4 @@
{"name" : "DENSITY", "size" : {"keyword":"TABDIMS", "item":"NTPVT" }, "items" :
[{"name": "OIL" , "value_type" : "FLOAT" , "default": 600 , "dimension" : "Density"},
{"name": "WATER" , "value_type" : "FLOAT" , "default": 999.014 , "dimension" : "Density"},
{"name": "GAS" , "value_type" : "FLOAT" , "default": 1 , "dimension" : "Density"}]}
[{"name": "OIL" , "value_type" : "DOUBLE" , "default": 600 , "dimension" : "Density"},
{"name": "WATER" , "value_type" : "DOUBLE" , "default": 999.014 , "dimension" : "Density"},
{"name": "GAS" , "value_type" : "DOUBLE" , "default": 1 , "dimension" : "Density"}]}

2
opm/parser/share/keywords/D/DEPTH
View File

@@ -1 +1 @@
{"name":"DEPTHZ", "data": {"value_type" : "FLOAT"}}
{"name":"DEPTHZ", "data": {"value_type" : "DOUBLE"}}

2
opm/parser/share/keywords/D/DEPTHZ
View File

@@ -1,3 +1,3 @@
{"name" : "DEPTHZ" , "data" : {"value_type" : "FLOAT" , "dimension" : "Length"},
{"name" : "DEPTHZ" , "data" : {"value_type" : "DOUBLE" , "dimension" : "Length"},
"comment" : "DEPTHZ is not documented in the Eclipse manual, but found in the SPE1 case"
}

2
opm/parser/share/keywords/D/DRSDT
View File

@@ -1,4 +1,4 @@
{"name" : "DRSDT", "size" : 1, "items" :
[{"name" : "DRSDT" , "value_type" : "FLOAT"},
[{"name" : "DRSDT" , "value_type" : "DOUBLE"},
{"name" : "Option" , "value_type" : "STRING", "default" : "ALL"}]
}

2
opm/parser/share/keywords/D/DXV
View File

@@ -1 +1 @@
{"name":"DXV", "data" : {"value_type" : "FLOAT", "dimension":"Length" }}
{"name":"DXV", "data" : {"value_type" : "DOUBLE", "dimension":"Length" }}

2
opm/parser/share/keywords/D/DYV
View File

@@ -1 +1 @@
{"name":"DYV", "data" : {"value_type" : "FLOAT", "dimension":"Length" }}
{"name":"DYV", "data" : {"value_type" : "DOUBLE", "dimension":"Length" }}

2
opm/parser/share/keywords/D/DZV
View File

@@ -1 +1 @@
{"name":"DZV", "data" : {"value_type" : "FLOAT", "dimension":"Length" }}
{"name":"DZV", "data" : {"value_type" : "DOUBLE", "dimension":"Length" }}

8
opm/parser/share/keywords/E/EHYSTR
View File

@@ -1,9 +1,9 @@
{"name" : "EHYSTR" , "size" : 1, "items" :
[
{"name" : "curvature_caplillary_pressure_hyst", "value_type" : "FLOAT", "default" : 0.1},
{"name" : "curvature_caplillary_pressure_hyst", "value_type" : "DOUBLE", "default" : 0.1},
{"name" : "relative_perm_hyst", "value_type" : "INT", "default" : 0, "comment" : "Default is 2 for Eclipse300"},
{"name" : "curvature_param_killough_wetting", "value_type" : "FLOAT", "default" : 1.0},
{"name" : "mod_param_trapped", "value_type" : "FLOAT", "default" : 0.1},
{"name" : "curvature_param_killough_wetting", "value_type" : "DOUBLE", "default" : 1.0},
{"name" : "mod_param_trapped", "value_type" : "DOUBLE", "default" : 0.1},
{"name" : "limiting_hyst_flag", "value_type" : "STRING", "default" : "BOTH"},
{"name" : "shape_cap_press_flag", "value_type" : "STRING", "default" : "RETR"},
{"name" : "init_fluid_mob_flag", "value_type" : "STRING", "default" : "DRAIN"},
@@ -11,5 +11,5 @@
{"name" : "baker_flag_oil", "value_type" : "STRING", "default" : "NO"},
{"name" : "baker_flag_gas", "value_type" : "STRING", "default" : "NO"},
{"name" : "baker_flag_water", "value_type" : "STRING", "default" : "NO"},
{"name" : "threshold_saturation", "value_type" : "FLOAT", "default" : 0.0}
{"name" : "threshold_saturation", "value_type" : "DOUBLE", "default" : 0.0}
]}

2
opm/parser/share/keywords/E/ENKRVD
View File

@@ -1,5 +1,5 @@
{"name" : "ENKRVD" , "size" : {"keyword" : "ENDSCALE" , "item" : "NUM_TABLES"},
"items" : [
{"name":"DATA", "value_type":"FLOAT", "size_type" : "ALL" , "dimension" : ["Length","1","1","1","1","1","1","1"]}
{"name":"DATA", "value_type":"DOUBLE", "size_type" : "ALL" , "dimension" : ["Length","1","1","1","1","1","1","1"]}
]
}

2
opm/parser/share/keywords/E/ENPTVD
View File

@@ -1,5 +1,5 @@
{"name" : "ENPTVD" , "size" : {"keyword" : "ENDSCALE" , "item" : "NUM_TABLES"},
"items" : [
{"name":"DATA", "value_type":"FLOAT", "size_type" : "ALL" , "dimension" : ["Length","1","1","1","1","1","1","1","1"]}
{"name":"DATA", "value_type":"DOUBLE", "size_type" : "ALL" , "dimension" : ["Length","1","1","1","1","1","1","1","1"]}
]
}

2
opm/parser/share/keywords/E/EQUALS
View File

@@ -1,6 +1,6 @@
{"name" : "EQUALS", "items" : [
{"name" : "field" , "value_type" : "STRING"},
{"name" : "value" , "value_type" : "FLOAT"},
{"name" : "value" , "value_type" : "DOUBLE"},
{"name" : "I1" , "value_type" : "INT"},
{"name" : "I2" , "value_type" : "INT"},
{"name" : "J1" , "value_type" : "INT"},

12
opm/parser/share/keywords/E/EQUIL
View File

@@ -1,13 +1,13 @@
{"name" : "EQUIL" , "size" : {"keyword":"EQLDIMS" , "item":"NTEQUL"},
"description": "The EQUIL item is used when equilibrationg the model. The item should consist of one record for each PVT region",
"items" :
[{"name" : "DATUM_DEPTH" , "value_type" : "FLOAT" , "default" : 0.0 , "dimension" : "Length"},
{"name" : "DATUM_PRESSURE" , "value_type" : "FLOAT" , "dimension" : "Pressure"} ,
{"name" : "OWC" , "value_type" : "FLOAT" , "default" : 0.0 , "dimension" : "Length",
[{"name" : "DATUM_DEPTH" , "value_type" : "DOUBLE" , "default" : 0.0 , "dimension" : "Length"},
{"name" : "DATUM_PRESSURE" , "value_type" : "DOUBLE" , "dimension" : "Pressure"} ,
{"name" : "OWC" , "value_type" : "DOUBLE" , "default" : 0.0 , "dimension" : "Length",
"description" : "The OWC item is depth of the OIL Water contact. This should ..."} ,
{"name" : "PC_OWC" , "value_type" : "FLOAT" , "default" : 0.0 , "dimension" : "Pressure"} ,
{"name" : "GOC" , "value_type" : "FLOAT" , "default" : 0.0 , "dimension" : "Length"} ,
{"name" : "PC_GOC" , "value_type" : "FLOAT" , "default" : 0.0 , "dimension" : "Pressure"} ,
{"name" : "PC_OWC" , "value_type" : "DOUBLE" , "default" : 0.0 , "dimension" : "Pressure"} ,
{"name" : "GOC" , "value_type" : "DOUBLE" , "default" : 0.0 , "dimension" : "Length"} ,
{"name" : "PC_GOC" , "value_type" : "DOUBLE" , "default" : 0.0 , "dimension" : "Pressure"} ,
{"name" : "BLACK_OIL_INIT" , "value_type" : "INT" , "default" : 0} ,
{"name" : "BLACK_OIL_INIT_WG" , "value_type" : "INT" , "default" : 0} ,
{"name" : "OIP_INIT" , "value_type" : "INT" , "default" : -5 , "comment":"The default is a state variable"}]}

12
opm/parser/share/keywords/G/GCONINJE
View File

@@ -2,14 +2,14 @@
{"name" : "GROUP" , "value_type" : "STRING" },
{"name" : "PHASE" , "value_type" : "STRING"},
{"name" : "CONTROL_MODE" , "value_type" : "STRING" , "default" : "NONE"},
{"name" : "SURFACE_TARGET" , "value_type" : "FLOAT" , "default" : 0 , "dimension" : "ContextDependent"},
{"name" : "RESV_TARGET" , "value_type" : "FLOAT" , "default" : 0 , "dimension" : "ContextDependent"},
{"name" : "REINJ_TARGET" , "value_type" : "FLOAT" , "default" : 0, "dimension":"1"},
{"name" : "VOIDAGE_TARGET" , "value_type" : "FLOAT" , "default" : 0, "dimension":"1"},
{"name" : "SURFACE_TARGET" , "value_type" : "DOUBLE" , "default" : 0 , "dimension" : "ContextDependent"},
{"name" : "RESV_TARGET" , "value_type" : "DOUBLE" , "default" : 0 , "dimension" : "ContextDependent"},
{"name" : "REINJ_TARGET" , "value_type" : "DOUBLE" , "default" : 0, "dimension":"1"},
{"name" : "VOIDAGE_TARGET" , "value_type" : "DOUBLE" , "default" : 0, "dimension":"1"},
{"name" : "FREE" , "value_type" : "STRING" , "default" : "YES"},
{"name" : "GUIDE_FRACTION" , "value_type" : "FLOAT" , "default" : 0, "dimension":"1"},
{"name" : "GUIDE_FRACTION" , "value_type" : "DOUBLE" , "default" : 0, "dimension":"1"},
{"name" : "GUIDE_DEF" , "value_type" : "STRING"},
{"name" : "REINJECT_GROUP" , "value_type" : "STRING"},
{"name" : "VOIDAGE_GROUP" , "value_type" : "STRING"},
{"name" : "WETGAS_TARGET", "value_type" : "FLOAT" , "dimension" : "GasVolume/Time"}
{"name" : "WETGAS_TARGET", "value_type" : "DOUBLE" , "dimension" : "GasVolume/Time"}
]}

14
opm/parser/share/keywords/G/GCONPROD
View File

@@ -1,16 +1,16 @@
{"name" : "GCONPROD" , "items" : [
{"name" : "GROUP" , "value_type" : "STRING" },
{"name" : "CONTROL_MODE" , "value_type" : "STRING" , "default" : "NONE"},
{"name" : "OIL_TARGET" , "value_type" : "FLOAT" , "dimension" : "LiquidVolume/Time"},
{"name" : "WATER_TARGET" , "value_type" : "FLOAT" , "dimension" : "LiquidVolume/Time"},
{"name" : "GAS_TARGET" , "value_type" : "FLOAT" , "dimension" : "GasVolume/Time"},
{"name" : "LIQUID_TARGET" , "value_type" : "FLOAT" , "dimension" : "LiquidVolume/Time"},
{"name" : "OIL_TARGET" , "value_type" : "DOUBLE" , "dimension" : "LiquidVolume/Time"},
{"name" : "WATER_TARGET" , "value_type" : "DOUBLE" , "dimension" : "LiquidVolume/Time"},
{"name" : "GAS_TARGET" , "value_type" : "DOUBLE" , "dimension" : "GasVolume/Time"},
{"name" : "LIQUID_TARGET" , "value_type" : "DOUBLE" , "dimension" : "LiquidVolume/Time"},
{"name" : "EXCEED_PROC" , "value_type" : "STRING" , "default" : "NONE"},
{"name" : "RESPOND_TO_PARENT" , "value_type" : "STRING" , "default" : "YES"},
{"name" : "GUIDE_RATE" , "value_type" : "FLOAT"},
{"name" : "GUIDE_RATE" , "value_type" : "DOUBLE"},
{"name" : "GUIDE_RATE_DEF" , "value_type" : "STRING"},
{"name" : "WATER_EXCEED_PROCEDURE" , "value_type" : "STRING"},
{"name" : "GAS_EXCEED_PROCEDURE" , "value_type" : "STRING"},
{"name" : "LIQUID_EXCEED_PROCEDURE" , "value_type" : "STRING"},
{"name" : "RESERVOIR_FLUID_TARGET" , "value_type" : "FLOAT"},
{"name" : "RESERVOIR_VOLUME_BALANCE" , "value_type" : "FLOAT"}]}
{"name" : "RESERVOIR_FLUID_TARGET" , "value_type" : "DOUBLE"},
{"name" : "RESERVOIR_VOLUME_BALANCE" , "value_type" : "DOUBLE"}]}

10
opm/parser/share/keywords/G/GECON
View File

@@ -1,10 +1,10 @@
{"name" : "GECON" , "items" : [
{"name" : "GROUP" , "value_type" : "STRING"},
{"name" : "MIN_OIL_RATE" , "value_type" : "FLOAT" , "default" : 0.0},
{"name" : "MIN_GAS_RATE" , "value_type" : "FLOAT" , "default" : 0.0},
{"name" : "MAX_WCT" , "value_type" : "FLOAT" , "default" : 0.0},
{"name" : "MAX_GOR" , "value_type" : "FLOAT" , "default" : 0.0},
{"name" : "MAX_WATER_GAS_RATIO" , "value_type" : "FLOAT" , "default" : 0.0},
{"name" : "MIN_OIL_RATE" , "value_type" : "DOUBLE" , "default" : 0.0},
{"name" : "MIN_GAS_RATE" , "value_type" : "DOUBLE" , "default" : 0.0},
{"name" : "MAX_WCT" , "value_type" : "DOUBLE" , "default" : 0.0},
{"name" : "MAX_GOR" , "value_type" : "DOUBLE" , "default" : 0.0},
{"name" : "MAX_WATER_GAS_RATIO" , "value_type" : "DOUBLE" , "default" : 0.0},
{"name" : "WORKOVER" , "value_type" : "STRING" , "default" : "NONE"},
{"name" : "END_RUN" , "value_type" : "STRING" , "default" : "NO"},
{"name" : "MAX_OPEN_WELLS" , "value_type" : "INT" , "default" : 0}

4
opm/parser/share/keywords/G/GRUPNET
View File

@@ -1,8 +1,8 @@
{"name" : "GRUPNET" , "items" : [
{"name" : "NAME" , "value_type" : "STRING"},
{"name" : "TERMINAL_PRESSURE" , "value_type" : "FLOAT"},
{"name" : "TERMINAL_PRESSURE" , "value_type" : "DOUBLE"},
{"name" : "VFP_TABLE" , "value_type" : "INT" , "default" : 0},
{"name" : "ALQ" , "value_type" : "FLOAT" , "default" : 0},
{"name" : "ALQ" , "value_type" : "DOUBLE" , "default" : 0},
{"name" : "SUB_SEA_MANIFOLD" , "value_type" : "STRING" , "default" : "NO"},
{"name" : "LIFT_GAS_FLOW_THROUGH" , "value_type" : "STRING" , "default" : "NO"},
{"name" : "ALQ_SURFACE_EQV" , "value_type" : "STRING" , "default" : "NONE"}]}

12
opm/parser/share/keywords/M/MAPAXES
View File

@@ -1,7 +1,7 @@
{"name" : "MAPAXES" , "size" : 1 , "items" : [
{"name" : "X1" , "value_type" : "FLOAT", "dimension" : "Length" },
{"name" : "Y1" , "value_type" : "FLOAT", "dimension" : "Length" },
{"name" : "X2" , "value_type" : "FLOAT", "dimension" : "Length" },
{"name" : "Y2" , "value_type" : "FLOAT", "dimension" : "Length" },
{"name" : "X3" , "value_type" : "FLOAT", "dimension" : "Length" },
{"name" : "Y3" , "value_type" : "FLOAT", "dimension" : "Length" }]}
{"name" : "X1" , "value_type" : "DOUBLE", "dimension" : "Length" },
{"name" : "Y1" , "value_type" : "DOUBLE", "dimension" : "Length" },
{"name" : "X2" , "value_type" : "DOUBLE", "dimension" : "Length" },
{"name" : "Y2" , "value_type" : "DOUBLE", "dimension" : "Length" },
{"name" : "X3" , "value_type" : "DOUBLE", "dimension" : "Length" },
{"name" : "Y3" , "value_type" : "DOUBLE", "dimension" : "Length" }]}

2
opm/parser/share/keywords/M/MAXVALUE
View File

@@ -1,6 +1,6 @@
{"name" : "MAXVALUE", "items" : [
{"name" : "field" , "value_type" : "STRING"},
{"name" : "value" , "value_type" : "FLOAT"},
{"name" : "value" , "value_type" : "DOUBLE"},
{"name" : "I1" , "value_type" : "INT"},
{"name" : "I2" , "value_type" : "INT"},
{"name" : "J1" , "value_type" : "INT"},

2
opm/parser/share/keywords/M/MINPV
View File

@@ -1 +1 @@
{"name" : "MINPV" , "size" : 1 , "items" : [{"name" : "MINPV" , "value_type" : "FLOAT" , "default" : 0.000001}]}
{"name" : "MINPV" , "size" : 1 , "items" : [{"name" : "MINPV" , "value_type" : "DOUBLE" , "default" : 0.000001}]}

2
opm/parser/share/keywords/M/MINVALUE
View File

@@ -1,6 +1,6 @@
{"name" : "MINVALUE", "items" : [
{"name" : "field" , "value_type" : "STRING"},
{"name" : "value" , "value_type" : "FLOAT"},
{"name" : "value" , "value_type" : "DOUBLE"},
{"name" : "I1" , "value_type" : "INT"},
{"name" : "I2" , "value_type" : "INT"},
{"name" : "J1" , "value_type" : "INT"},

2
opm/parser/share/keywords/M/MULTFLT
View File

@@ -1,3 +1,3 @@
{"name" : "MULTFLT", "items" : [
{"name" : "fault" , "value_type" : "STRING"},
{"name" : "factor" , "value_type" : "FLOAT"}]}
{"name" : "factor" , "value_type" : "DOUBLE"}]}

2
opm/parser/share/keywords/M/MULTIPLY
View File

@@ -1,6 +1,6 @@
{"name" : "MULTIPLY", "items" : [
{"name" : "field" , "value_type" : "STRING"},
{"name" : "factor" , "value_type" : "FLOAT"},
{"name" : "factor" , "value_type" : "DOUBLE"},
{"name" : "I1" , "value_type" : "INT"},
{"name" : "I2" , "value_type" : "INT"},
{"name" : "J1" , "value_type" : "INT"},

2
opm/parser/share/keywords/M/MULTREGT
View File

@@ -1,7 +1,7 @@
{"name" : "MULTREGT" , "items" : [
{"name" : "SRC_REGION" , "value_type" : "INT" , "default" : -1},
{"name" : "TARGET_REGION" , "value_type" : "INT" , "default" : -1},
{"name" : "TRAN_MULT" , "value_type" : "FLOAT" },
{"name" : "TRAN_MULT" , "value_type" : "DOUBLE" },
{"name" : "DIRECTIONS" , "value_type" : "STRING" , "default" : "XYZ"},
{"name" : "NNC_MULT" , "value_type" : "STRING" , "default" : "ALL"},
{"name" : "REGION_DEF" , "value_type" : "STRING" , "default" : "M"}]}

2
opm/parser/share/keywords/M/MULTZ
View File

@@ -1 +1 @@
{"name" : "MULTZ" , "data" : {"value_type" : "FLOAT"}}
{"name" : "MULTZ" , "data" : {"value_type" : "DOUBLE"}}

12
opm/parser/share/keywords/N/NETBALAN
View File

@@ -1,10 +1,10 @@
{"name" : "NETBALAN" , "size" : 1 , "items" : [
{"name" : "TIME_INTERVAL" , "value_type" : "FLOAT" , "default" : 0.0},
{"name" : "PRESSURE_CONVERGENCE_LIMT" , "value_type" : "FLOAT" , "default" : 0.00001 },
{"name" : "TIME_INTERVAL" , "value_type" : "DOUBLE" , "default" : 0.0},
{"name" : "PRESSURE_CONVERGENCE_LIMT" , "value_type" : "DOUBLE" , "default" : 0.00001 },
{"name" : "MAX_ITER" , "value_type" : "INT" , "default" : 10},
{"name" : "THP_CONVERGENCE_LIMIT" , "value_type" : "FLOAT" , "default" : 0.01 },
{"name" : "THP_CONVERGENCE_LIMIT" , "value_type" : "DOUBLE" , "default" : 0.01 },
{"name" : "MAX_ITER_THP" , "value_type" : "INT" , "default" : 10},
{"name" : "TARGET_BALANCE_ERROR" , "value_type" : "FLOAT" , "default" : 1e20},
{"name" : "MAX_BALANCE_ERROR" , "value_type" : "FLOAT" , "default" : 1e20},
{"name" : "MIN_TIME_STEP" , "value_type" : "FLOAT"}
{"name" : "TARGET_BALANCE_ERROR" , "value_type" : "DOUBLE" , "default" : 1e20},
{"name" : "MAX_BALANCE_ERROR" , "value_type" : "DOUBLE" , "default" : 1e20},
{"name" : "MIN_TIME_STEP" , "value_type" : "DOUBLE"}
]}

2
opm/parser/share/keywords/N/NTG
View File

@@ -1 +1 @@
{"name" : "NTG" , "data" : {"value_type" : "FLOAT"}}
{"name" : "NTG" , "data" : {"value_type" : "DOUBLE"}}

2
opm/parser/share/keywords/P/PERMX
View File

@@ -1 +1 @@
{"name" : "PERMX" , "data" : {"value_type" : "FLOAT" , "dimension" : "Permeability"}}
{"name" : "PERMX" , "data" : {"value_type" : "DOUBLE" , "dimension" : "Permeability"}}

2
opm/parser/share/keywords/P/PERMXY
View File

@@ -1 +1 @@
{"name" : "PERMXY" , "data" : {"value_type" : "FLOAT" , "dimension" : "Permeability"}}
{"name" : "PERMXY" , "data" : {"value_type" : "DOUBLE" , "dimension" : "Permeability"}}

2
opm/parser/share/keywords/P/PERMY
View File

@@ -1 +1 @@
{"name" : "PERMY" , "data" : {"value_type" : "FLOAT" , "default" : 0 , "dimension" : "Permeability"}}
{"name" : "PERMY" , "data" : {"value_type" : "DOUBLE" , "default" : 0 , "dimension" : "Permeability"}}

2
opm/parser/share/keywords/P/PERMYX
View File

@@ -1 +1 @@
{"name" : "PERMYX" , "data" : {"value_type" : "FLOAT" , "dimension" : "Permeability"}}
{"name" : "PERMYX" , "data" : {"value_type" : "DOUBLE" , "dimension" : "Permeability"}}

2
opm/parser/share/keywords/P/PERMYZ
View File

@@ -1 +1 @@
{"name" : "PERMYZ" , "data" : {"value_type" : "FLOAT" , "dimension" : "Permeability"}}
{"name" : "PERMYZ" , "data" : {"value_type" : "DOUBLE" , "dimension" : "Permeability"}}

2
opm/parser/share/keywords/P/PERMZ
View File

@@ -1 +1 @@
{"name" : "PERMZ" , "data" : {"value_type" : "FLOAT" , "default" : 0 , "dimension" : "Permeability"}}
{"name" : "PERMZ" , "data" : {"value_type" : "DOUBLE" , "default" : 0 , "dimension" : "Permeability"}}

2
opm/parser/share/keywords/P/PERMZX
View File

@@ -1 +1 @@
{"name" : "PERMZX" , "data" : {"value_type" : "FLOAT" , "dimension" : "Permeability"}}
{"name" : "PERMZX" , "data" : {"value_type" : "DOUBLE" , "dimension" : "Permeability"}}

2
opm/parser/share/keywords/P/PIMULTAB
View File

@@ -1,2 +1,2 @@
{"name" : "PIMULTAB" , "size" : {"keyword" : "PIMTDIMS" , "item" : "NTPIMT"}, "items" :
[{"name" : "TABLE" , "value_type" : "FLOAT" , "size_type" : "ALL"}]}
[{"name" : "TABLE" , "value_type" : "DOUBLE" , "size_type" : "ALL"}]}

4
opm/parser/share/keywords/P/PINCH
View File

@@ -1,6 +1,6 @@
{"name" : "PINCH" , "size" : 1 , "items" : [
{"name" : "THRESHOLD_THICKNESS" , "value_type" : "FLOAT" , "default" : 0.001},
{"name" : "THRESHOLD_THICKNESS" , "value_type" : "DOUBLE" , "default" : 0.001},
{"name" : "CONTROL_OPTION", "value_type" : "STRING" , "default" : "GAP"},
{"name" : "MAX_EMPTY_GAP" , "value_type" : "FLOAT" , "default" : 1e20},
{"name" : "MAX_EMPTY_GAP" , "value_type" : "DOUBLE" , "default" : 1e20},
{"name" : "PINCHOUT_OPTION" , "value_type" : "STRING" , "default" : "TOPBOT"},
{"name" : "MULTZ_OPTION" , "value_type" : "STRING" , "default" : "TOP"}]}

2
opm/parser/share/keywords/P/PORO
View File

@@ -1 +1 @@
{"name" : "PORO" , "data" : {"value_type" : "FLOAT" , "default" : 0 , "dimension":"1"}}
{"name" : "PORO" , "data" : {"value_type" : "DOUBLE" , "default" : 0 , "dimension":"1"}}

2
opm/parser/share/keywords/P/PRESSURE
View File

@@ -1 +1 @@
{"name" : "PRESSURE" , "data" : {"value_type" : "FLOAT", "dimension" : "Pressure"}}
{"name" : "PRESSURE" , "data" : {"value_type" : "DOUBLE", "dimension" : "Pressure"}}

2
opm/parser/share/keywords/P/PVDG
View File

@@ -1,4 +1,4 @@
{"name" : "PVDG" , "size" : {"keyword" : "TABDIMS" , "item" : "NTPVT"} , "items" : [
{"name" : "data" , "size_type" : "ALL" , "value_type" : "FLOAT" , "dimension" : ["Pressure","OilDissolutionFactor","Viscosity"]}]}
{"name" : "data" , "size_type" : "ALL" , "value_type" : "DOUBLE" , "dimension" : ["Pressure","OilDissolutionFactor","Viscosity"]}]}

4
opm/parser/share/keywords/P/PVTG
View File

@@ -1,6 +1,6 @@
{"name" : "PVTG" , "num_tables" : {"keyword":"TABDIMS" , "item":"NTPVT"},
"items" : [
{"name":"GAS_PRESSURE", "value_type" : "FLOAT", "dimension":"Pressure" },
{"name":"DATA", "size_type" : "ALL" , "value_type":"FLOAT" , "dimension" : ["OilDissolutionFactor","1","Viscosity"]}
{"name":"GAS_PRESSURE", "value_type" : "DOUBLE", "dimension":"Pressure" },
{"name":"DATA", "size_type" : "ALL" , "value_type":"DOUBLE" , "dimension" : ["OilDissolutionFactor","1","Viscosity"]}
]
}

4
opm/parser/share/keywords/P/PVTO
View File

@@ -1,6 +1,6 @@
{"name" : "PVTO" , "num_tables" : {"keyword" : "TABDIMS" , "item" : "NTPVT"},
"items" : [
{"name":"RS", "value_type" : "FLOAT", "dimension":"GasDissolutionFactor" },
{"name":"DATA", "value_type":"FLOAT", "size_type" : "ALL" , "dimension" : ["Pressure","1","Viscosity"]}
{"name":"RS", "value_type" : "DOUBLE", "dimension":"GasDissolutionFactor" },
{"name":"DATA", "value_type":"DOUBLE", "size_type" : "ALL" , "dimension" : ["Pressure","1","Viscosity"]}
]
}

10
opm/parser/share/keywords/P/PVTW
View File

@@ -1,8 +1,8 @@
{"name" : "PVTW" , "size" : {"keyword":"TABDIMS" , "item":"NTPVT"}, "items":
[ {"name":"P_REF", "value_type" : "FLOAT", "dimension":"Pressure" },
{"name":"WATER_VOL_FACTOR", "value_type" : "FLOAT", "default" : 1.0,"dimension":"1"},
{"name":"WATER_COMPRESSIBILITY", "value_type" : "FLOAT", "default" : 0.00004, "dimension":"1/Pressure"},
{"name":"WATER_VISCOSITY", "value_type" : "FLOAT", "default" : 0.5, "dimension":"Viscosity", "comment" : "Default is 0.3 in Eclipse300"},
{"name":"WATER_VISCOSIBILITY", "value_type" : "FLOAT", "default" : 0.0, "dimension":"1/Pressure"}
[ {"name":"P_REF", "value_type" : "DOUBLE", "dimension":"Pressure" },
{"name":"WATER_VOL_FACTOR", "value_type" : "DOUBLE", "default" : 1.0,"dimension":"1"},
{"name":"WATER_COMPRESSIBILITY", "value_type" : "DOUBLE", "default" : 0.00004, "dimension":"1/Pressure"},
{"name":"WATER_VISCOSITY", "value_type" : "DOUBLE", "default" : 0.5, "dimension":"Viscosity", "comment" : "Default is 0.3 in Eclipse300"},
{"name":"WATER_VISCOSIBILITY", "value_type" : "DOUBLE", "default" : 0.0, "dimension":"1/Pressure"}
]}

4
opm/parser/share/keywords/R/ROCK
View File

@@ -1,3 +1,3 @@
{"name" : "ROCK" , "size" : {"keyword":"TABDIMS" , "item":"NTPVT"}, "items" : [
{"name" : "PREF" , "value_type" : "FLOAT" , "default" : 1.0132 , "dimension" : "Pressure"},
{"name" : "COMPRESSIBILITY" , "value_type" : "FLOAT" , "default" : 0 , "dimension" : "1/Pressure"}]}
{"name" : "PREF" , "value_type" : "DOUBLE" , "default" : 1.0132 , "dimension" : "Pressure"},
{"name" : "COMPRESSIBILITY" , "value_type" : "DOUBLE" , "default" : 0 , "dimension" : "1/Pressure"}]}

2
opm/parser/share/keywords/R/RS
View File

@@ -1 +1 @@
{"name" : "RS" , "data" : {"value_type" : "FLOAT", "dimension" : "GasDissolutionFactor"}}
{"name" : "RS" , "data" : {"value_type" : "DOUBLE", "dimension" : "GasDissolutionFactor"}}

2
opm/parser/share/keywords/R/RSVD
View File

@@ -1,6 +1,6 @@
{"name" : "RSVD" , "size" : {"keyword" : "EQLDIMS" , "item" : "NTEQUL"},
"items" : [{"name" : "table" ,
"value_type" : "FLOAT" ,
"value_type" : "DOUBLE" ,
"size_type" : "ALL",
"dimension" : ["Length" , "GasDissolutionFactor"]}]}

2
opm/parser/share/keywords/S/SGAS
View File

@@ -1 +1 @@
{"name" : "SGAS" , "data" : {"value_type" : "FLOAT", "dimension" : "1"}}
{"name" : "SGAS" , "data" : {"value_type" : "DOUBLE", "dimension" : "1"}}

2
opm/parser/share/keywords/S/SGOF
View File

@@ -1,5 +1,5 @@
{"name" : "SGOF" , "size" : {"keyword" : "TABDIMS" , "item" : "NTSFUN"},
"items" : [
{"name":"table", "value_type":"FLOAT", "size_type" : "ALL", "dimension" : ["1","1","1","Pressure"]}
{"name":"table", "value_type":"DOUBLE", "size_type" : "ALL", "dimension" : ["1","1","1","Pressure"]}
]
}

2
opm/parser/share/keywords/S/SWAT
View File

@@ -1 +1 @@
{"name" : "SWAT" , "data" : {"value_type" : "FLOAT", "dimension" : "1"}}
{"name" : "SWAT" , "data" : {"value_type" : "DOUBLE", "dimension" : "1"}}

2
opm/parser/share/keywords/S/SWATINIT
View File

@@ -1 +1 @@
{"name" : "SWATINIT" , "data" : {"value_type" : "FLOAT" , "default" : 0}}
{"name" : "SWATINIT" , "data" : {"value_type" : "DOUBLE" , "default" : 0}}

2
opm/parser/share/keywords/S/SWOF
View File

@@ -1,5 +1,5 @@
{"name" : "SWOF" , "size" : {"keyword" : "TABDIMS" , "item" : "NTSFUN"},
"items" : [
{"name":"DATA", "value_type":"FLOAT", "size_type" : "ALL" , "dimension" : ["1","1","1","Pressure"]}
{"name":"DATA", "value_type":"DOUBLE", "size_type" : "ALL" , "dimension" : ["1","1","1","Pressure"]}
]
}

2
opm/parser/share/keywords/T/THPRES
View File

@@ -1,4 +1,4 @@
{"name" : "THPRES" , "items" : [
{"name" : "REGION1" , "value_type" : "INT"},
{"name" : "REGION2" , "value_type" : "INT"},
{"name" : "THPRES" , "value_type" : "FLOAT"}]}
{"name" : "THPRES" , "value_type" : "DOUBLE"}]}

2
opm/parser/share/keywords/T/TSTEP
View File

@@ -2,6 +2,6 @@
"size" : 1,
"items" : [{
"name" : "step_list" ,
"value_type" : "FLOAT" ,
"value_type" : "DOUBLE" ,
"dimension" : "Timestep",
"size_type" : "ALL"}]}

2
opm/parser/share/keywords/T/TVDP
View File

@@ -1,2 +1,2 @@
{"name" : "TVDP*" , "size" : {"keyword":"EQLDIMS" , "item":"NTTRVD"}, "items" :
[ {"name" : "table" , "value_type" : "FLOAT" , "size_type" : "ALL" , "dimension" : ["Length" , "ContextDependent"]}]}
[ {"name" : "table" , "value_type" : "DOUBLE" , "size_type" : "ALL" , "dimension" : ["Length" , "ContextDependent"]}]}

4
opm/parser/share/keywords/V/VAPPARS
View File

@@ -1,3 +1,3 @@
{"name" : "VAPPARS" , "size" : 1 , "items" : [
{"name" : "OIL_VAP_PROPENSITY" , "value_type" : "FLOAT"},
{"name" : "OIL_DENSITY_PROPENSITY" , "value_type" : "FLOAT"}]}
{"name" : "OIL_VAP_PROPENSITY" , "value_type" : "DOUBLE"},
{"name" : "OIL_DENSITY_PROPENSITY" , "value_type" : "DOUBLE"}]}

14
opm/parser/share/keywords/W/WCONHIST
View File

@@ -2,11 +2,11 @@
[{"name" : "WELL" , "value_type" : "STRING"},
{"name" : "STATUS" , "value_type" : "STRING" , "default" : "OPEN"},
{"name" : "CMODE" , "value_type" : "STRING"},
{"name" : "ORAT" , "value_type" : "FLOAT", "default" : 0.0, "dimension" : "LiquidVolume/Time"},
{"name" : "WRAT" , "value_type" : "FLOAT" , "default" : 0.0, "dimension" : "LiquidVolume/Time"},
{"name" : "GRAT" , "value_type" : "FLOAT" , "default" : 0.0, "dimension" : "GasVolume/Time"},
{"name" : "ORAT" , "value_type" : "DOUBLE", "default" : 0.0, "dimension" : "LiquidVolume/Time"},
{"name" : "WRAT" , "value_type" : "DOUBLE" , "default" : 0.0, "dimension" : "LiquidVolume/Time"},
{"name" : "GRAT" , "value_type" : "DOUBLE" , "default" : 0.0, "dimension" : "GasVolume/Time"},
{"name" : "VFPTable" , "value_type" : "INT" , "default" : 0.0 , "comment":"The default is a state variable"},
{"name" : "Lift" , "value_type" : "FLOAT" , "default" : 0.0 , "comment":"The default is a state variable"},
{"name" : "THP" , "value_type" : "FLOAT" , "default" : 0.0 , "dimension" : "Pressure"},
{"name" : "BHP" , "value_type" : "FLOAT" , "default" : 0.0 ,"dimension" : "Pressure"},
{"name" : "NGLRAT" , "value_type" : "FLOAT" , "default" : 0.0 ,"dimension" : "LiquidVolume/Time"}]}
{"name" : "Lift" , "value_type" : "DOUBLE" , "default" : 0.0 , "comment":"The default is a state variable"},
{"name" : "THP" , "value_type" : "DOUBLE" , "default" : 0.0 , "dimension" : "Pressure"},
{"name" : "BHP" , "value_type" : "DOUBLE" , "default" : 0.0 ,"dimension" : "Pressure"},
{"name" : "NGLRAT" , "value_type" : "DOUBLE" , "default" : 0.0 ,"dimension" : "LiquidVolume/Time"}]}

18
opm/parser/share/keywords/W/WCONINJE
View File

@@ -3,14 +3,14 @@
{"name" : "TYPE" , "value_type" : "STRING" },
{"name" : "STATUS" , "value_type" : "STRING" , "default" : "OPEN"},
{"name" : "CMODE" , "value_type" : "STRING" },
{"name" : "RATE" , "value_type" : "FLOAT" , "dimension" : "ContextDependent"},
{"name" : "RESV" , "value_type" : "FLOAT" , "dimension" : "ContextDependent"},
{"name" : "BHP" , "value_type" : "FLOAT" , "dimension" : "Pressure" , "default" : 6891},
{"name" : "THP" , "value_type" : "FLOAT" , "dimension" : "Pressure"},
{"name" : "RATE" , "value_type" : "DOUBLE" , "dimension" : "ContextDependent"},
{"name" : "RESV" , "value_type" : "DOUBLE" , "dimension" : "ContextDependent"},
{"name" : "BHP" , "value_type" : "DOUBLE" , "dimension" : "Pressure" , "default" : 6891},
{"name" : "THP" , "value_type" : "DOUBLE" , "dimension" : "Pressure"},
{"name" : "VFP_TABLE" , "value_type" : "INT" , "default" : 0},
{"name" : "VAPOIL_C" , "value_type" : "FLOAT" , "default" : 0},
{"name" : "GAS_STEAM_RATIO" , "value_type" : "FLOAT" , "default" : 0},
{"name" : "SURFACE_OIL_FRACTION" , "value_type" : "FLOAT" , "default" : 0},
{"name" : "SURFACE_GAS_FRACTION" , "value_type" : "FLOAT" , "default" : 0},
{"name" : "OIL_STEAM_RATIO" , "value_type" : "FLOAT" , "default" : 0}
{"name" : "VAPOIL_C" , "value_type" : "DOUBLE" , "default" : 0},
{"name" : "GAS_STEAM_RATIO" , "value_type" : "DOUBLE" , "default" : 0},
{"name" : "SURFACE_OIL_FRACTION" , "value_type" : "DOUBLE" , "default" : 0},
{"name" : "SURFACE_GAS_FRACTION" , "value_type" : "DOUBLE" , "default" : 0},
{"name" : "OIL_STEAM_RATIO" , "value_type" : "DOUBLE" , "default" : 0}
]}

14
opm/parser/share/keywords/W/WCONINJH
View File

@@ -2,13 +2,13 @@
{"name" : "WELL" , "value_type" : "STRING" },
{"name" : "TYPE" , "value_type" : "STRING" },
{"name" : "STATUS" , "value_type" : "STRING" , "default" : "OPEN"},
{"name" : "RATE" , "value_type" : "FLOAT" , "dimension" : "ContextDependent"},
{"name" : "BHP" , "value_type" : "FLOAT" , "dimension" : "Pressure"},
{"name" : "THP" , "value_type" : "FLOAT" , "dimension" : "Pressure"},
{"name" : "RATE" , "value_type" : "DOUBLE" , "dimension" : "ContextDependent"},
{"name" : "BHP" , "value_type" : "DOUBLE" , "dimension" : "Pressure"},
{"name" : "THP" , "value_type" : "DOUBLE" , "dimension" : "Pressure"},
{"name" : "VFP_TABLE" , "value_type" : "INT" , "default" : 0},
{"name" : "VAPOIL_C" , "value_type" : "FLOAT" , "default" : 0},
{"name" : "SURFACE_OIL_FRACTION" , "value_type" : "FLOAT" , "default" : 0},
{"name" : "SURFACE_WATER_FRACTION" , "value_type" : "FLOAT" , "default" : 0},
{"name" : "SURFACE_GAS_FRACTION" , "value_type" : "FLOAT" , "default" : 0},
{"name" : "VAPOIL_C" , "value_type" : "DOUBLE" , "default" : 0},
{"name" : "SURFACE_OIL_FRACTION" , "value_type" : "DOUBLE" , "default" : 0},
{"name" : "SURFACE_WATER_FRACTION" , "value_type" : "DOUBLE" , "default" : 0},
{"name" : "SURFACE_GAS_FRACTION" , "value_type" : "DOUBLE" , "default" : 0},
{"name" : "CMODE" , "value_type" : "STRING" }
]}

32
opm/parser/share/keywords/W/WCONPROD
View File

@@ -2,21 +2,21 @@
[{"name" : "WELL" , "value_type" : "STRING"},
{"name" : "STATUS" , "value_type" : "STRING" , "default" : "OPEN"},
{"name" : "CMODE" , "value_type" : "STRING"},
{"name" : "ORAT" , "value_type" : "FLOAT", "default" : 0.0 , "dimension" : "LiquidVolume/Time"},
{"name" : "WRAT" , "value_type" : "FLOAT" , "default" : 0.0 , "dimension" : "LiquidVolume/Time"},
{"name" : "GRAT" , "value_type" : "FLOAT" , "default" : 0.0 , "dimension" : "GasVolume/Time"},
{"name" : "LRAT" , "value_type" : "FLOAT" , "default" : 0.0 , "dimension" : "LiquidVolume/Time"},
{"name" : "RESV" , "value_type" : "FLOAT" , "default" : 0.0 , "dimension" : "LiquidVolume/Time"},
{"name" : "BHP" , "value_type" : "FLOAT" , "default" : 0.0 , "dimension" : "Pressure"},
{"name" : "THP" , "value_type" : "FLOAT" , "default" : 0.0 , "dimension" : "Pressure"},
{"name" : "ORAT" , "value_type" : "DOUBLE", "default" : 0.0 , "dimension" : "LiquidVolume/Time"},
{"name" : "WRAT" , "value_type" : "DOUBLE" , "default" : 0.0 , "dimension" : "LiquidVolume/Time"},
{"name" : "GRAT" , "value_type" : "DOUBLE" , "default" : 0.0 , "dimension" : "GasVolume/Time"},
{"name" : "LRAT" , "value_type" : "DOUBLE" , "default" : 0.0 , "dimension" : "LiquidVolume/Time"},
{"name" : "RESV" , "value_type" : "DOUBLE" , "default" : 0.0 , "dimension" : "LiquidVolume/Time"},
{"name" : "BHP" , "value_type" : "DOUBLE" , "default" : 0.0 , "dimension" : "Pressure"},
{"name" : "THP" , "value_type" : "DOUBLE" , "default" : 0.0 , "dimension" : "Pressure"},
{"name" : "VFPTable" , "value_type" : "INT" , "default" : 0.0 , "comment":"The default is a state variable"},
{"name" : "ALQ" , "value_type" : "FLOAT" , "default" : 0.0 , "comment":"The default is a state variable"},
{"name" : "E300_ITEM13" , "value_type" : "FLOAT"},
{"name" : "E300_ITEM14" , "value_type" : "FLOAT"},
{"name" : "E300_ITEM15" , "value_type" : "FLOAT"},
{"name" : "E300_ITEM16" , "value_type" : "FLOAT"},
{"name" : "E300_ITEM17" , "value_type" : "FLOAT"},
{"name" : "E300_ITEM18" , "value_type" : "FLOAT"},
{"name" : "E300_ITEM19" , "value_type" : "FLOAT"},
{"name" : "E300_ITEM20" , "value_type" : "FLOAT"}]}
{"name" : "ALQ" , "value_type" : "DOUBLE" , "default" : 0.0 , "comment":"The default is a state variable"},
{"name" : "E300_ITEM13" , "value_type" : "DOUBLE"},
{"name" : "E300_ITEM14" , "value_type" : "DOUBLE"},
{"name" : "E300_ITEM15" , "value_type" : "DOUBLE"},
{"name" : "E300_ITEM16" , "value_type" : "DOUBLE"},
{"name" : "E300_ITEM17" , "value_type" : "DOUBLE"},
{"name" : "E300_ITEM18" , "value_type" : "DOUBLE"},
{"name" : "E300_ITEM19" , "value_type" : "DOUBLE"},
{"name" : "E300_ITEM20" , "value_type" : "DOUBLE"}]}

4
opm/parser/share/keywords/W/WELSPECS
View File

@@ -3,9 +3,9 @@
{"name" : "GROUP" , "value_type" : "STRING" },
{"name" : "HEAD_I" , "value_type" : "INT"},
{"name" : "HEAD_J" , "value_type" : "INT"},
{"name" : "REF_DEPTH" , "value_type" : "FLOAT", "dimension" : "Length"},
{"name" : "REF_DEPTH" , "value_type" : "DOUBLE", "dimension" : "Length"},
{"name" : "PHASE" , "value_type" : "STRING"},
{"name" : "D_RADIUS" , "value_type" : "FLOAT" , "default" : 0, "dimension" : "Length"},
{"name" : "D_RADIUS" , "value_type" : "DOUBLE" , "default" : 0, "dimension" : "Length"},
{"name" : "INFLOW_EQ" , "value_type" : "STRING" , "default" : "STD"},
{"name" : "AUTO_SHUTIN" , "value_type" : "STRING" , "default" : "SHUT"},
{"name" : "CROSSFLOW" , "value_type" : "STRING" , "default" : "YES"},

4
opm/parser/share/keywords/W/WPAVE
View File

@@ -1,6 +1,6 @@
{"name" : "WPAVE" , "size" : 1 , "items" : [
{"name" : "WEIGTH_FACTOR1" , "value_type" : "FLOAT" , "default" : 0.5},
{"name" : "WEIGTH_FACTOR2" , "value_type" : "FLOAT" , "default" : 1.0},
{"name" : "WEIGTH_FACTOR1" , "value_type" : "DOUBLE" , "default" : 0.5},
{"name" : "WEIGTH_FACTOR2" , "value_type" : "DOUBLE" , "default" : 1.0},
{"name" : "DEPTH_CORRECTION" , "value_type" : "STRING" , "default" : "WELL"},
{"name" : "CONNECTION" , "value_type" : "STRING" , "default" : "OPEN"}
]}

2
opm/parser/share/keywords/W/WPITAB
View File

@@ -1,3 +1,3 @@
{"name" : "WPITAB" , "items" : [
{"name" : "WELL" , "value_type" : "STRING" },
{"name" : "PI" , "value_type" : "FLOAT" , "default" : 0}]}
{"name" : "PI" , "value_type" : "DOUBLE" , "default" : 0}]}

4
opm/parser/share/keywords/W/WTEST
View File

@@ -1,7 +1,7 @@
{"name" : "WTEST" , "items" : [
{"name" : "well" , "value_type" : "STRING"},
{"name" : "interval" , "value_type" : "FLOAT" },
{"name" : "interval" , "value_type" : "DOUBLE" },
{"name" : "reason" , "value_type" : "STRING"},
{"name" : "TEST_NUM" , "value_type" : "INT" , "default" : 0},
{"name" : "START_TIME" , "value_type" : "FLOAT" , "default" : 0}]}
{"name" : "START_TIME" , "value_type" : "DOUBLE" , "default" : 0}]}

4
opm/parser/share/keywords/W/WTRACER
View File

@@ -1,7 +1,7 @@
{"name" : "WTRACER" , "items" : [
{"name" : "WELL" , "value_type" : "STRING"},
{"name" : "TRACER" , "value_type" : "STRING"},
{"name" : "CONCENTRATION" , "value_type" : "FLOAT"},
{"name" : "CUM_TRACER_FACTOR" , "value_type" : "FLOAT"},
{"name" : "CONCENTRATION" , "value_type" : "DOUBLE"},
{"name" : "CUM_TRACER_FACTOR" , "value_type" : "DOUBLE"},
{"name" : "PRODUCTION_GROUP" , "value_type" : "STRING"}]}

2
opm/parser/share/keywords/Z/ZCORN
View File

@@ -1 +1 @@
{"name" : "ZCORN", "data" : {"value_type" : "FLOAT", "dimension" : "Length" }}
{"name" : "ZCORN", "data" : {"value_type" : "DOUBLE", "dimension" : "Length" }}