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

Cleans up headers to improve build preformance

Browse Source 
This is an effort to improve build performance.  Several includes
scattered across the project are either unused or partially used (i.e.
just used to import a type name, not depending on the actual contents of
the header file).

Replaces a lot of these includes with forward declarations.
This commit is contained in:
Jørgen Kvalsvik
2016-01-15 08:42:57 +01:00
parent c2eb0ea934
commit f404828d63
144 changed files with 728 additions and 444 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
opm/json/JsonObject.hpp
View File

@@ -22,10 +22,14 @@
#include <string>
#include <boost/filesystem/path.hpp>
struct cJSON;
namespace boost {
namespace filesystem {
class path;
}
}
namespace Json {
class JsonObject {

2
opm/json/tests/jsonTests.cpp
View File

@@ -24,6 +24,8 @@
#include <boost/test/unit_test.hpp>
#include <boost/test/test_tools.hpp>
#include <boost/filesystem/path.hpp>
#include <opm/json/JsonObject.hpp>

2
opm/parser/eclipse/Applications/Schedule.cpp
View File

@@ -9,7 +9,9 @@
#include <opm/parser/eclipse/Parser/Parser.hpp>
#include <opm/parser/eclipse/Parser/ParseMode.hpp>
#include <opm/parser/eclipse/Deck/Deck.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
#include <opm/parser/eclipse/EclipseState/IOConfig/IOConfig.hpp>
int main(int /* argc */, char** argv) {

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

@@ -115,6 +115,8 @@ EclipseState/Tables/TableColumn.cpp
EclipseState/Tables/ColumnSchema.cpp
EclipseState/Tables/TableSchema.cpp
EclipseState/Tables/TableIndex.cpp
EclipseState/Tables/PvtgTable.cpp
EclipseState/Tables/PvtoTable.cpp
EclipseState/Tables/PvtxTable.cpp
#
EclipseState/Grid/GridProperty.cpp

1
opm/parser/eclipse/Deck/Deck.cpp
View File

@@ -21,6 +21,7 @@
#include <iostream>
#include <opm/parser/eclipse/Deck/Deck.hpp>
#include <opm/parser/eclipse/Units/UnitSystem.hpp>
namespace Opm {

6
opm/parser/eclipse/Deck/Deck.hpp
View File

@@ -20,14 +20,16 @@
#ifndef DECK_HPP
#define DECK_HPP
#include <vector>
#include <map>
#include <memory>
#include <vector>
#include <opm/parser/eclipse/Deck/DeckKeyword.hpp>
#include <opm/parser/eclipse/Units/UnitSystem.hpp>
namespace Opm {
class UnitSystem;
class Deck {
public:
Deck();

2
opm/parser/eclipse/Deck/DeckDoubleItem.cpp
View File

@@ -19,8 +19,6 @@
#include <opm/parser/eclipse/Deck/DeckDoubleItem.hpp>
#include <boost/lexical_cast.hpp>
#include <algorithm>
#include <iostream>
#include <cmath>

2
opm/parser/eclipse/Deck/DeckFloatItem.cpp
View File

@@ -19,8 +19,6 @@
#include <opm/parser/eclipse/Deck/DeckFloatItem.hpp>
#include <boost/lexical_cast.hpp>
#include <algorithm>
#include <iostream>
#include <cmath>

2
opm/parser/eclipse/Deck/DeckKeyword.cpp
View File

@@ -18,6 +18,8 @@
*/
#include "DeckKeyword.hpp"
#include "DeckRecord.hpp"
#include "DeckItem.hpp"
namespace Opm {

15
opm/parser/eclipse/Deck/DeckKeyword.hpp
View File

@@ -12,10 +12,9 @@
#include <vector>
#include <memory>
#include <opm/parser/eclipse/Deck/DeckRecord.hpp>
namespace Opm {
class ParserKeyword;
class DeckRecord;
class DeckKeyword {
public:
@@ -40,9 +39,9 @@ namespace Opm {
void setParserKeyword(std::shared_ptr<const ParserKeyword> &parserKeyword);
size_t size() const;
void addRecord(DeckRecordConstPtr record);
DeckRecordConstPtr getRecord(size_t index) const;
DeckRecordConstPtr getDataRecord() const;
void addRecord(std::shared_ptr< const DeckRecord > record);
std::shared_ptr< const DeckRecord > getRecord(size_t index) const;
std::shared_ptr< const DeckRecord > getDataRecord() const;
void setDataKeyword(bool isDataKeyword = true);
bool isKnown() const;
bool isDataKeyword() const;
@@ -63,15 +62,15 @@ namespace Opm {
return false;
}
std::vector<DeckRecordConstPtr>::const_iterator begin() const;
std::vector<DeckRecordConstPtr>::const_iterator end() const;
std::vector<std::shared_ptr< const DeckRecord >>::const_iterator begin() const;
std::vector<std::shared_ptr< const DeckRecord >>::const_iterator end() const;
private:
std::string m_keywordName;
std::string m_fileName;
int m_lineNumber;
std::shared_ptr<const ParserKeyword> m_parserKeyword;
std::vector<DeckRecordConstPtr> m_recordList;
std::vector<std::shared_ptr< const DeckRecord >> m_recordList;
bool m_knownKeyword;
bool m_isDataKeyword;
};

2
opm/parser/eclipse/Deck/SCHEDULESection.cpp
View File

@@ -18,6 +18,8 @@
*/
#include <opm/parser/eclipse/Deck/DeckItem.hpp>
#include <opm/parser/eclipse/Deck/DeckRecord.hpp>
#include <opm/parser/eclipse/Deck/SCHEDULESection.hpp>
namespace Opm {

1
opm/parser/eclipse/Deck/SCHEDULESection.hpp
View File

@@ -21,7 +21,6 @@
#define SCHEDULESECTION_HPP
#include <iostream>
#include <string>
#include <memory>

4
opm/parser/eclipse/Deck/Section.hpp
View File

@@ -22,15 +22,11 @@
#include <iostream>
#include <string>
#include <memory>
#include <boost/iterator/iterator_facade.hpp>
#include <opm/parser/eclipse/Deck/Deck.hpp>
namespace Opm {
class Section : public Deck

1
opm/parser/eclipse/Deck/tests/DeckKeywordTests.cpp
View File

@@ -28,6 +28,7 @@
#include <opm/parser/eclipse/Deck/DeckKeyword.hpp>
#include <opm/parser/eclipse/Deck/DeckRecord.hpp>
using namespace Opm;

20
opm/parser/eclipse/EclipseState/EclipseState.cpp
View File

@@ -17,23 +17,25 @@
along with OPM. If not, see <http://www.gnu.org/licenses/>.
*/
#include <iostream>
#include <sstream>
#include <math.h>
#include <boost/algorithm/string/join.hpp>
#include <opm/parser/eclipse/EclipseState/EclipseState.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/MULTREGTScanner.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/GridProperties.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/Box.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/BoxManager.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/FaultCollection.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/Fault.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/GridProperties.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/MULTREGTScanner.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/NNC.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/SatfuncPropertyInitializers.hpp>
#include <opm/parser/eclipse/EclipseState/InitConfig/InitConfig.hpp>
#include <opm/parser/eclipse/EclipseState/IOConfig/IOConfig.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp>
#include <opm/parser/eclipse/EclipseState/SimulationConfig/SimulationConfig.hpp>
#include <opm/parser/eclipse/Parser/ParserKeywords.hpp>
#include <opm/parser/eclipse/Units/UnitSystem.hpp>
#include <opm/parser/eclipse/OpmLog/OpmLog.hpp>

123
opm/parser/eclipse/EclipseState/EclipseState.hpp
View File

@@ -20,33 +20,30 @@
#ifndef OPM_ECLIPSE_STATE_HPP
#define OPM_ECLIPSE_STATE_HPP
#include <opm/parser/eclipse/Deck/Deck.hpp>
#include <opm/parser/eclipse/OpmLog/OpmLog.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/Box.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/BoxManager.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/GridProperties.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/NNC.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/TransMult.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/FaultCollection.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/NNC.hpp>
#include <opm/parser/eclipse/EclipseState/Tables/TableManager.hpp>
#include <opm/parser/eclipse/EclipseState/InitConfig/InitConfig.hpp>
#include <opm/parser/eclipse/EclipseState/SimulationConfig/SimulationConfig.hpp>
#include <opm/parser/eclipse/EclipseState/IOConfig/IOConfig.hpp>
#include <opm/parser/eclipse/Parser/ParseMode.hpp>
#include <set>
#include <memory>
#include <iostream>
#include <map>
#include <vector>
namespace Opm {
template< typename > class GridProperty;
template< typename > class GridProperties;
class Deck;
class DeckItem;
class Fault;
class FaultCollection;
class InitConfig;
class IOConfig;
class ParseMode;
class Schedule;
class Section;
class SimulationConfig;
class TableManager;
class EclipseState {
public:
enum EnabledTypes {
@@ -56,21 +53,21 @@ namespace Opm {
AllProperties = IntProperties | DoubleProperties
};
EclipseState(DeckConstPtr deck , const ParseMode& parseMode);
EclipseState(std::shared_ptr< const Deck > deck , const ParseMode& parseMode);
const ParseMode& getParseMode() const;
ScheduleConstPtr getSchedule() const;
IOConfigConstPtr getIOConfigConst() const;
IOConfigPtr getIOConfig() const;
InitConfigConstPtr getInitConfig() const;
SimulationConfigConstPtr getSimulationConfig() const;
EclipseGridConstPtr getEclipseGrid() const;
EclipseGridPtr getEclipseGridCopy() const;
std::shared_ptr< const Schedule > getSchedule() const;
std::shared_ptr< const IOConfig > getIOConfigConst() const;
std::shared_ptr< IOConfig > getIOConfig() const;
std::shared_ptr< const InitConfig > getInitConfig() const;
std::shared_ptr< const SimulationConfig > getSimulationConfig() const;
std::shared_ptr< const EclipseGrid > getEclipseGrid() const;
std::shared_ptr< EclipseGrid > getEclipseGridCopy() const;
bool hasPhase(enum Phase::PhaseEnum phase) const;
std::string getTitle() const;
bool supportsGridProperty(const std::string& keyword, int enabledTypes=AllProperties) const;
std::shared_ptr<GridProperty<int> > getRegion(DeckItemConstPtr regionItem) const;
std::shared_ptr<GridProperty<int> > getRegion(std::shared_ptr< const DeckItem > regionItem) const;
std::shared_ptr<GridProperty<int> > getDefaultRegion() const;
std::shared_ptr<GridProperty<int> > getIntGridProperty( const std::string& keyword ) const;
std::shared_ptr<GridProperty<double> > getDoubleGridProperty( const std::string& keyword ) const;
@@ -78,7 +75,7 @@ namespace Opm {
bool hasDoubleGridProperty(const std::string& keyword) const;
void loadGridPropertyFromDeckKeyword(std::shared_ptr<const Box> inputBox,
DeckKeywordConstPtr deckKeyword,
std::shared_ptr< const DeckKeyword > deckKeyword,
int enabledTypes = AllProperties);
std::shared_ptr<const FaultCollection> getFaults() const;
@@ -96,54 +93,54 @@ namespace Opm {
void applyModifierDeck( std::shared_ptr<const Deck> deck);
private:
void initTabdims(DeckConstPtr deck);
void initTables(DeckConstPtr deck);
void initIOConfig(DeckConstPtr deck);
void initSchedule(DeckConstPtr deck);
void initIOConfigPostSchedule(DeckConstPtr deck);
void initInitConfig(DeckConstPtr deck);
void initSimulationConfig(DeckConstPtr deck);
void initEclipseGrid(DeckConstPtr deck);
void initGridopts(DeckConstPtr deck);
void initPhases(DeckConstPtr deck);
void initTitle(DeckConstPtr deck);
void initProperties(DeckConstPtr deck);
void initTabdims(std::shared_ptr< const Deck > deck);
void initTables(std::shared_ptr< const Deck > deck);
void initIOConfig(std::shared_ptr< const Deck > deck);
void initSchedule(std::shared_ptr< const Deck > deck);
void initIOConfigPostSchedule(std::shared_ptr< const Deck > deck);
void initInitConfig(std::shared_ptr< const Deck > deck);
void initSimulationConfig(std::shared_ptr< const Deck > deck);
void initEclipseGrid(std::shared_ptr< const Deck > deck);
void initGridopts(std::shared_ptr< const Deck > deck);
void initPhases(std::shared_ptr< const Deck > deck);
void initTitle(std::shared_ptr< const Deck > deck);
void initProperties(std::shared_ptr< const Deck > deck);
void initTransMult();
void initFaults(DeckConstPtr deck);
void initNNC(DeckConstPtr deck);
void initFaults(std::shared_ptr< const Deck > deck);
void initNNC(std::shared_ptr< const Deck > deck);
void setMULTFLT(std::shared_ptr<const Section> section) const;
void initMULTREGT(DeckConstPtr deck);
void setMULTFLT(std::shared_ptr<const Opm::Section> section) const;
void initMULTREGT(std::shared_ptr< const Deck > deck);
double getSIScaling(const std::string &dimensionString) const;
void processGridProperties(Opm::DeckConstPtr deck, int enabledTypes);
void processGridProperties(std::shared_ptr< const Deck > deck, int enabledTypes);
void scanSection(std::shared_ptr<Opm::Section> section , int enabledTypes);
void handleADDKeyword(DeckKeywordConstPtr deckKeyword , BoxManager& boxManager, int enabledTypes);
void handleBOXKeyword(DeckKeywordConstPtr deckKeyword , BoxManager& boxManager);
void handleCOPYKeyword(DeckKeywordConstPtr deckKeyword , BoxManager& boxManager, int enabledTypes);
void handleADDKeyword(std::shared_ptr< const DeckKeyword > deckKeyword , BoxManager& boxManager, int enabledTypes);
void handleBOXKeyword(std::shared_ptr< const DeckKeyword > deckKeyword , BoxManager& boxManager);
void handleCOPYKeyword(std::shared_ptr< const DeckKeyword > deckKeyword , BoxManager& boxManager, int enabledTypes);
void handleENDBOXKeyword(BoxManager& boxManager);
void handleEQUALSKeyword(DeckKeywordConstPtr deckKeyword , BoxManager& boxManager, int enabledTypes);
void handleMULTIPLYKeyword(DeckKeywordConstPtr deckKeyword , BoxManager& boxManager, int enabledTypes);
void handleEQUALSKeyword(std::shared_ptr< const DeckKeyword > deckKeyword , BoxManager& boxManager, int enabledTypes);
void handleMULTIPLYKeyword(std::shared_ptr< const DeckKeyword > deckKeyword , BoxManager& boxManager, int enabledTypes);
void handleEQUALREGKeyword(DeckKeywordConstPtr deckKeyword, int enabledTypes);
void handleMULTIREGKeyword(DeckKeywordConstPtr deckKeyword, int enabledTypes);
void handleADDREGKeyword(DeckKeywordConstPtr deckKeyword , int enabledTypes);
void handleCOPYREGKeyword(DeckKeywordConstPtr deckKeyword , int enabledTypes);
void handleEQUALREGKeyword(std::shared_ptr< const DeckKeyword > deckKeyword, int enabledTypes);
void handleMULTIREGKeyword(std::shared_ptr< const DeckKeyword > deckKeyword, int enabledTypes);
void handleADDREGKeyword(std::shared_ptr< const DeckKeyword > deckKeyword , int enabledTypes);
void handleCOPYREGKeyword(std::shared_ptr< const DeckKeyword > deckKeyword , int enabledTypes);
void setKeywordBox(DeckKeywordConstPtr deckKeyword, size_t recordIdx, BoxManager& boxManager);
void setKeywordBox(std::shared_ptr< const DeckKeyword > deckKeyword, size_t recordIdx, BoxManager& boxManager);
void copyIntKeyword(const std::string& srcField , const std::string& targetField , std::shared_ptr<const Box> inputBox);
void copyDoubleKeyword(const std::string& srcField , const std::string& targetField , std::shared_ptr<const Box> inputBox);
void complainAboutAmbiguousKeyword(DeckConstPtr deck, const std::string& keywordName) const;
void complainAboutAmbiguousKeyword(std::shared_ptr< const Deck > deck, const std::string& keywordName) const;
EclipseGridConstPtr m_eclipseGrid;
IOConfigPtr m_ioConfig;
InitConfigConstPtr m_initConfig;
ScheduleConstPtr schedule;
SimulationConfigConstPtr m_simulationConfig;
std::shared_ptr< const EclipseGrid > m_eclipseGrid;
std::shared_ptr< IOConfig > m_ioConfig;
std::shared_ptr< const InitConfig > m_initConfig;
std::shared_ptr< const Schedule > schedule;
std::shared_ptr< const SimulationConfig > m_simulationConfig;
std::shared_ptr<const TableManager> m_tables;

4
opm/parser/eclipse/EclipseState/Grid/Fault.hpp
View File

@@ -23,10 +23,10 @@
#include <memory>
#include <vector>
#include <opm/parser/eclipse/EclipseState/Grid/FaultFace.hpp>
namespace Opm {
class FaultFace;
class Fault {
public:

4
opm/parser/eclipse/EclipseState/Grid/FaultCollection.cpp
View File

@@ -21,7 +21,11 @@
#include <opm/parser/eclipse/Parser/ParserKeywords.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/FaceDir.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/FaultCollection.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/FaultFace.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/Fault.hpp>
namespace Opm {

13
opm/parser/eclipse/EclipseState/Grid/FaultCollection.hpp
View File

@@ -22,20 +22,15 @@
#include <cstddef>
#include <string>
#include <memory>
#include <map>
#include <opm/parser/eclipse/EclipseState/Util/OrderedMap.hpp>
#include <opm/parser/eclipse/Deck/Deck.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/Fault.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/FaultFace.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/FaceDir.hpp>
namespace Opm {
class Deck;
class EclipseGrid;
class Fault;
class FaultCollection {
public:

4
opm/parser/eclipse/EclipseState/Grid/GridProperties.hpp
View File

@@ -22,10 +22,8 @@
#include <string>
#include <vector>
#include <tuple>
#include <unordered_map>
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/GridProperty.hpp>
/*
@@ -47,6 +45,8 @@
namespace Opm {
class EclipseGrid;
template <typename T>
class GridProperties {
public:

2
opm/parser/eclipse/EclipseState/Grid/GridProperty.hpp
View File

@@ -19,11 +19,9 @@
#ifndef ECLIPSE_GRIDPROPERTY_HPP_
#define ECLIPSE_GRIDPROPERTY_HPP_
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <unordered_map>
#include <boost/lexical_cast.hpp>
#include <ert/ecl/EclKW.hpp>

2
opm/parser/eclipse/EclipseState/Grid/GridPropertyInitializers.hpp
View File

@@ -30,7 +30,6 @@
#include <cassert>
#include <opm/parser/eclipse/EclipseState/Tables/RtempvdTable.hpp>
#include <opm/parser/eclipse/EclipseState/Tables/TableContainer.hpp>
#include <opm/parser/eclipse/EclipseState/Tables/TableManager.hpp>
@@ -47,6 +46,7 @@ class Deck;
class EclipseState;
class EnptvdTable;
class ImptvdTable;
class TableContainer;
template <class ValueType>
class GridPropertyBaseInitializer

5
opm/parser/eclipse/EclipseState/Grid/MULTREGTScanner.cpp
View File

@@ -21,8 +21,11 @@
#include <map>
#include <set>
#include <opm/parser/eclipse/EclipseState/Grid/MULTREGTScanner.hpp>
#include <opm/parser/eclipse/Deck/DeckItem.hpp>
#include <opm/parser/eclipse/Deck/DeckRecord.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/FaceDir.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/GridProperties.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/MULTREGTScanner.hpp>
namespace Opm {

3
opm/parser/eclipse/EclipseState/Grid/MULTREGTScanner.hpp
View File

@@ -22,13 +22,14 @@
#define MULTREGTSCANNER_HPP
#include <opm/parser/eclipse/Deck/DeckKeyword.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/GridProperties.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/FaceDir.hpp>
#include <opm/parser/eclipse/EclipseState/Util/Value.hpp>
namespace Opm {
template< typename > class GridProperties;
namespace MULTREGT {

1
opm/parser/eclipse/EclipseState/Grid/NNC.cpp
View File

@@ -18,6 +18,7 @@
*/
#include <array>
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/NNC.hpp>
#include <opm/parser/eclipse/Parser/ParserKeywords.hpp>

7
opm/parser/eclipse/EclipseState/Grid/NNC.hpp
View File

@@ -20,12 +20,13 @@
#ifndef NNC_HPP
#define NNC_HPP
#include <opm/parser/eclipse/Deck/Deck.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
#include <vector>
#include <opm/parser/eclipse/Deck/Deck.hpp>
namespace Opm
{
class EclipseGrid;
struct NNCdata {
size_t cell1;
@@ -38,7 +39,7 @@ class NNC
public:
/// Construct from input deck.
NNC();
NNC(Opm::DeckConstPtr deck, EclipseGridConstPtr eclipseGrid);
NNC(Opm::DeckConstPtr deck, std::shared_ptr< const EclipseGrid > eclipseGrid);
void addNNC(const size_t cell1, const size_t cell2, const double trans);
const std::vector<NNCdata>& nncdata() const { return m_nnc; }
size_t numNNC() const;

6
opm/parser/eclipse/EclipseState/Grid/SatfuncPropertyInitializers.hpp
View File

@@ -25,18 +25,16 @@
#include <memory>
#include <limits>
#include <algorithm>
#include <cmath>
#include <cassert>
#include <opm/parser/eclipse/EclipseState/Tables/Tabdims.hpp>
#include <opm/parser/eclipse/EclipseState/Tables/SwofTable.hpp>
#include <opm/parser/eclipse/EclipseState/Tables/SgofTable.hpp>
#include <opm/parser/eclipse/EclipseState/Tables/SwfnTable.hpp>
#include <opm/parser/eclipse/EclipseState/Tables/SgfnTable.hpp>
#include <opm/parser/eclipse/EclipseState/Tables/Sof3Table.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/GridPropertyInitializers.hpp>
namespace Opm {
// forward definitions

5
opm/parser/eclipse/EclipseState/Grid/TransMult.cpp
View File

@@ -19,7 +19,12 @@
#include <stdexcept>
#include <iostream>
#include <opm/parser/eclipse/EclipseState/Grid/GridProperty.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/Fault.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/FaultFace.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/FaultCollection.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/TransMult.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/MULTREGTScanner.hpp>
namespace Opm {

9
opm/parser/eclipse/EclipseState/Grid/TransMult.hpp
View File

@@ -35,13 +35,14 @@
#include <memory>
#include <opm/parser/eclipse/EclipseState/Grid/FaceDir.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/GridProperty.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/GridProperties.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/FaultCollection.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/MULTREGTScanner.hpp>
namespace Opm {
template< typename > class GridProperty;
class Fault;
class FaultCollection;
class MULTREGTScanner;
class TransMult {
public:

1
opm/parser/eclipse/EclipseState/Grid/tests/ADDREGTests.cpp
View File

@@ -36,6 +36,7 @@
#include <opm/parser/eclipse/Deck/DeckKeyword.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/GridProperty.hpp>
#include <opm/parser/eclipse/EclipseState/EclipseState.hpp>

1
opm/parser/eclipse/EclipseState/Grid/tests/CopyRegTests.cpp
View File

@@ -35,6 +35,7 @@
#include <opm/parser/eclipse/Deck/DeckKeyword.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/GridProperty.hpp>
#include <opm/parser/eclipse/EclipseState/EclipseState.hpp>

1
opm/parser/eclipse/EclipseState/Grid/tests/EqualRegTests.cpp
View File

@@ -35,6 +35,7 @@
#include <opm/parser/eclipse/Deck/DeckKeyword.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/GridProperty.hpp>
#include <opm/parser/eclipse/EclipseState/EclipseState.hpp>

2
opm/parser/eclipse/EclipseState/Grid/tests/GridPropertyTests.cpp
View File

@@ -38,7 +38,7 @@
#include <opm/parser/eclipse/Deck/Deck.hpp>
#include <opm/parser/eclipse/Deck/DeckKeyword.hpp>
#include <opm/parser/eclipse/EclipseState/EclipseState.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/GridProperty.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/GridProperties.hpp>
// forward declarations to avoid some pedantic warnings
Opm::DeckKeywordConstPtr createSATNUMKeyword( );

1
opm/parser/eclipse/EclipseState/Grid/tests/MultiRegTests.cpp
View File

@@ -35,6 +35,7 @@
#include <opm/parser/eclipse/Deck/DeckKeyword.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/GridProperty.hpp>
#include <opm/parser/eclipse/EclipseState/EclipseState.hpp>

1
opm/parser/eclipse/EclipseState/Grid/tests/SatfuncPropertyInitializersTests.cpp
View File

@@ -26,6 +26,7 @@
#include <boost/test/unit_test.hpp>
#include <opm/parser/eclipse/EclipseState/EclipseState.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/GridProperty.hpp>
#include <opm/parser/eclipse/Parser/Parser.hpp>
#include <opm/parser/eclipse/Parser/ParseMode.hpp>

6
opm/parser/eclipse/EclipseState/IOConfig/IOConfig.cpp
View File

@@ -18,10 +18,14 @@
*/
#include <stdio.h>
#include <iostream>
#include <iterator>
#include <opm/parser/eclipse/EclipseState/IOConfig/IOConfig.hpp>
#include <boost/lexical_cast.hpp>
#include <opm/parser/eclipse/Deck/Section.hpp>
#include <opm/parser/eclipse/EclipseState/IOConfig/IOConfig.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/DynamicState.hpp>
#include <ert/ecl/ecl_util.h>

20
opm/parser/eclipse/EclipseState/IOConfig/IOConfig.hpp
View File

@@ -21,12 +21,14 @@
#define OPM_IO_CONFIG_HPP
#include <opm/parser/eclipse/Deck/Section.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/TimeMap.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/DynamicState.hpp>
#include <boost/date_time/gregorian/gregorian_types.hpp>
namespace Opm {
template< typename > class DynamicState;
class TimeMap;
/*The IOConfig class holds data about input / ouput configurations
Amongst these configuration settings, a IOConfig object knows if
@@ -126,14 +128,14 @@ namespace Opm {
void overrideRestartWriteInterval(size_t interval);
void handleRPTRSTBasic(TimeMapConstPtr timemap,
void handleRPTRSTBasic(std::shared_ptr< const TimeMap > timemap,
size_t timestep,
size_t basic,
size_t frequency = 1,
bool update_default = false,
bool reset_global = false);
void handleRPTSCHEDRestart(TimeMapConstPtr timemap, size_t timestep, size_t restart);
void handleSolutionSection(TimeMapConstPtr timemap, std::shared_ptr<const SOLUTIONSection> solutionSection);
void handleRPTSCHEDRestart(std::shared_ptr< const TimeMap > timemap, size_t timestep, size_t restart);
void handleSolutionSection(std::shared_ptr< const TimeMap > timemap, std::shared_ptr<const SOLUTIONSection> solutionSection);
void handleGridSection(std::shared_ptr<const GRIDSection> gridSection);
void handleRunspecSection(std::shared_ptr<const RUNSPECSection> runspecSection);
void setWriteInitialRestartFile(bool writeInitialRestartFile);
@@ -145,16 +147,16 @@ namespace Opm {
private:
void assertTimeMap(TimeMapConstPtr timemap);
void assertTimeMap(std::shared_ptr< const TimeMap > timemap);
bool getWriteRestartFileFrequency(size_t timestep,
size_t start_timestep,
size_t frequency,
bool years = false,
bool months = false) const;
void handleRPTSOL(DeckKeywordConstPtr keyword);
void handleRPTSOL(std::shared_ptr< const DeckKeyword > keyword);
TimeMapConstPtr m_timemap;
std::shared_ptr< const TimeMap > m_timemap;
bool m_write_INIT_file;
bool m_write_EGRID_file;
bool m_write_initial_RST_file;

3
opm/parser/eclipse/EclipseState/IOConfig/tests/IOConfigTest.cpp
View File

@@ -26,7 +26,10 @@
#include <opm/parser/eclipse/Parser/Parser.hpp>
#include <opm/parser/eclipse/Parser/ParseMode.hpp>
#include <opm/parser/eclipse/EclipseState/EclipseState.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
#include <opm/parser/eclipse/EclipseState/IOConfig/IOConfig.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/TimeMap.hpp>
using namespace Opm;

4
opm/parser/eclipse/EclipseState/InitConfig/InitConfig.cpp
View File

@@ -17,8 +17,10 @@
along with OPM. If not, see <http://www.gnu.org/licenses/>.
*/
#include <opm/parser/eclipse/EclipseState/InitConfig/InitConfig.hpp>
#include <opm/parser/eclipse/Deck/Deck.hpp>
#include <opm/parser/eclipse/Deck/DeckItem.hpp>
#include <opm/parser/eclipse/Deck/DeckRecord.hpp>
#include <opm/parser/eclipse/EclipseState/InitConfig/InitConfig.hpp>
#include <iostream>

5
opm/parser/eclipse/EclipseState/Schedule/Completion.cpp
View File

@@ -17,6 +17,11 @@
along with OPM. If not, see <http://www.gnu.org/licenses/>.
*/
#include <cassert>
#include <vector>
#include <opm/parser/eclipse/Deck/DeckKeyword.hpp>
#include <opm/parser/eclipse/Deck/DeckRecord.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Completion.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp>
#include <opm/parser/eclipse/EclipseState/Util/Value.hpp>

12
opm/parser/eclipse/EclipseState/Schedule/Completion.hpp
View File

@@ -21,18 +21,20 @@
#ifndef COMPLETION_HPP_
#define COMPLETION_HPP_
#include <map>
#include <memory>
#include <string>
#include <boost/date_time.hpp>
#include <vector>
#include <opm/parser/eclipse/Deck/DeckKeyword.hpp>
#include <opm/parser/eclipse/Deck/DeckRecord.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp>
#include <opm/parser/eclipse/EclipseState/Util/Value.hpp>
namespace Opm {
class DeckKeyword;
class DeckRecord;
class Completion {
public:
Completion(int i, int j , int k , WellCompletion::StateEnum state ,
@@ -65,8 +67,8 @@ namespace Opm {
WellCompletion::DirectionEnum getDirection() const;
static std::map<std::string , std::vector<std::shared_ptr<Completion> > > completionsFromCOMPDATKeyword( DeckKeywordConstPtr compdatKeyword );
static std::pair<std::string , std::vector<std::shared_ptr<Completion> > > completionsFromCOMPDATRecord( DeckRecordConstPtr compdatRecord );
static std::map<std::string , std::vector<std::shared_ptr<Completion> > > completionsFromCOMPDATKeyword( std::shared_ptr< const DeckKeyword > compdatKeyword );
static std::pair<std::string , std::vector<std::shared_ptr<Completion> > > completionsFromCOMPDATRecord( std::shared_ptr< const DeckRecord > compdatRecord );
private:
int m_i, m_j, m_k;

6
opm/parser/eclipse/EclipseState/Schedule/CompletionSet.cpp
View File

@@ -17,10 +17,14 @@
along with OPM. If not, see <http://www.gnu.org/licenses/>.
*/
#include <cassert>
#include <cmath>
#include <limits>
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Completion.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/CompletionSet.hpp>
#include <limits>
namespace Opm {

20
opm/parser/eclipse/EclipseState/Schedule/CompletionSet.hpp
View File

@@ -23,24 +23,20 @@
#include <memory>
#include <boost/date_time.hpp>
#include <opm/parser/eclipse/Deck/DeckKeyword.hpp>
#include <opm/parser/eclipse/Deck/DeckRecord.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Completion.hpp>
namespace Opm {
class EclipseGrid;
class CompletionSet {
public:
CompletionSet();
void add(CompletionConstPtr completion);
void add(std::shared_ptr< const Completion > completion);
size_t size() const;
CompletionSet * shallowCopy() const;
CompletionConstPtr get(size_t index) const;
CompletionConstPtr getFromIJK(const int i, const int j, const int k) const;
std::shared_ptr< const Completion > get(size_t index) const;
std::shared_ptr< const Completion > getFromIJK(const int i, const int j, const int k) const;
bool allCompletionsShut() const;
/// Order completions irrespective of input order.
/// The algorithm used is the following:
@@ -54,10 +50,10 @@ namespace Opm {
/// \param[in] well_i logical cartesian i-coordinate of well head
/// \param[in] well_j logical cartesian j-coordinate of well head
/// \param[in] grid EclipseGrid object, used for cell depths
void orderCompletions(size_t well_i, size_t well_j, EclipseGridConstPtr grid);
void orderCompletions(size_t well_i, size_t well_j, std::shared_ptr< const EclipseGrid > grid);
private:
std::vector<CompletionConstPtr> m_completions;
size_t findClosestCompletion(int oi, int oj, EclipseGridConstPtr grid,
std::vector<std::shared_ptr< const Completion >> m_completions;
size_t findClosestCompletion(int oi, int oj, std::shared_ptr< const EclipseGrid > grid,
double oz, size_t start_pos);
};

8
opm/parser/eclipse/EclipseState/Schedule/DynamicState.hpp
View File

@@ -21,11 +21,9 @@
#ifndef DYNAMICSTATE_HPP_
#define DYNAMICSTATE_HPP_
#include <opm/parser/eclipse/EclipseState/Schedule/TimeMap.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/date_time.hpp>
#include <stdexcept>
#include <opm/parser/eclipse/EclipseState/Schedule/TimeMap.hpp>
namespace Opm {
@@ -57,7 +55,7 @@ namespace Opm {
public:
DynamicState(const TimeMapConstPtr timeMap, T initialValue) {
DynamicState(const std::shared_ptr< const TimeMap > timeMap, T initialValue) {
m_timeMap = timeMap;
init( initialValue );
}
@@ -157,7 +155,7 @@ namespace Opm {
std::vector<T> m_data;
TimeMapConstPtr m_timeMap;
std::shared_ptr< const TimeMap > m_timeMap;
T m_currentValue;
T m_initialValue;
size_t m_initialRange;

5
opm/parser/eclipse/EclipseState/Schedule/DynamicVector.hpp
View File

@@ -25,7 +25,6 @@
#include <stdexcept>
#include <opm/common/utility/platform_dependent/disable_warnings.h>
#include <boost/date_time.hpp>
#include <opm/common/utility/platform_dependent/reenable_warnings.h>
#include <opm/parser/eclipse/EclipseState/Schedule/TimeMap.hpp>
@@ -53,7 +52,7 @@ namespace Opm {
public:
DynamicVector(const TimeMapConstPtr timeMap, T defaultValue) {
DynamicVector(const std::shared_ptr< const TimeMap > timeMap, T defaultValue) {
m_timeMap = timeMap;
m_defaultValue = defaultValue;
}
@@ -97,7 +96,7 @@ namespace Opm {
std::vector<T> m_data;
TimeMapConstPtr m_timeMap;
std::shared_ptr< const TimeMap > m_timeMap;
T m_defaultValue;
};
}

1
opm/parser/eclipse/EclipseState/Schedule/Events.hpp
View File

@@ -20,7 +20,6 @@
#define SCHEDULE_EVENTS_HPP
#include <cstdint>
#include <vector>
#include <opm/parser/eclipse/EclipseState/Schedule/DynamicVector.hpp>

3
opm/parser/eclipse/EclipseState/Schedule/Group.cpp
View File

@@ -19,8 +19,9 @@
#include <boost/date_time.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/DynamicState.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Group.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/WellSet.hpp>
#define INVALID_GROUP_RATE -999e100

20
opm/parser/eclipse/EclipseState/Schedule/Group.hpp
View File

@@ -21,17 +21,19 @@
#ifndef GROUP_HPP_
#define GROUP_HPP_
#include <opm/parser/eclipse/EclipseState/Schedule/TimeMap.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/DynamicState.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/WellSet.hpp>
#include <memory>
#include <string>
namespace Opm {
template< typename > class DynamicState;
class TimeMap;
class Well;
class WellSet;
namespace GroupInjection {
struct InjectionData;
}
@@ -43,7 +45,7 @@ namespace Opm {
class Group {
public:
Group(const std::string& name, TimeMapConstPtr timeMap , size_t creationTimeStep);
Group(const std::string& name, std::shared_ptr< const TimeMap > timeMap , size_t creationTimeStep);
bool hasBeenDefined(size_t timeStep) const;
const std::string& name() const;
bool isProductionGroup(size_t timeStep) const;
@@ -94,18 +96,18 @@ namespace Opm {
/*****************************************************************/
bool hasWell(const std::string& wellName , size_t time_step) const;
WellConstPtr getWell(const std::string& wellName , size_t time_step) const;
std::shared_ptr< const Well > getWell(const std::string& wellName , size_t time_step) const;
size_t numWells(size_t time_step) const;
void addWell(size_t time_step , WellPtr well);
void addWell(size_t time_step , std::shared_ptr< Well > well);
void delWell(size_t time_step, const std::string& wellName );
private:
WellSetConstPtr wellMap(size_t time_step) const;
std::shared_ptr< const WellSet > wellMap(size_t time_step) const;
size_t m_creationTimeStep;
std::string m_name;
std::shared_ptr<GroupInjection::InjectionData> m_injection;
std::shared_ptr<GroupProduction::ProductionData> m_production;
std::shared_ptr<DynamicState<WellSetConstPtr> > m_wells;
std::shared_ptr<DynamicState<std::shared_ptr< const WellSet >> > m_wells;
std::shared_ptr<DynamicState<bool> > m_isProductionGroup;
};
typedef std::shared_ptr<Group> GroupPtr;

1
opm/parser/eclipse/EclipseState/Schedule/OilVaporizationProperties.hpp
View File

@@ -3,6 +3,7 @@
#include <iostream>
#include <string>
#include <memory>
#include <opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp>
namespace Opm

27
opm/parser/eclipse/EclipseState/Schedule/Schedule.cpp
View File

@@ -22,21 +22,32 @@
#include <stdexcept>
#include <boost/algorithm/string.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <opm/parser/eclipse/OpmLog/OpmLog.hpp>
#include <opm/parser/eclipse/Deck/Section.hpp>
#include <opm/parser/eclipse/Deck/SCHEDULESection.hpp>
#include <opm/parser/eclipse/Parser/ParserKeywords.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/TimeMap.hpp>
#include <opm/parser/eclipse/EclipseState/EclipseState.hpp>
#include <opm/parser/eclipse/EclipseState/IOConfig/IOConfig.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/DynamicState.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/DynamicVector.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/WellProductionProperties.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Events.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Group.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/GroupTree.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/MSW/Compsegs.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/OilVaporizationProperties.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/TimeMap.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Tuning.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/WellInjectionProperties.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/WellPolymerProperties.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/MSW/Compsegs.hpp>
#include <opm/parser/eclipse/EclipseState/EclipseState.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/WellProductionProperties.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/WellSet.hpp>
#include <opm/parser/eclipse/Units/UnitSystem.hpp>
namespace Opm {
@@ -46,6 +57,10 @@ namespace Opm {
initFromDeck(parseMode , deck, ioConfig);
}
boost::posix_time::ptime Schedule::getStartTime() const {
return m_timeMap->getStartTime(/*timeStepIdx=*/0);
}
void Schedule::initFromDeck(const ParseMode& parseMode , DeckConstPtr deck, IOConfigPtr ioConfig) {
initializeNOSIM(deck);
createTimeMap(deck);

156
opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp
View File

@@ -19,54 +19,58 @@
#ifndef SCHEDULE_HPP
#define SCHEDULE_HPP
#include <opm/parser/eclipse/EclipseState/Schedule/Events.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/TimeMap.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/GroupTree.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/DynamicState.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Group.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Tuning.hpp>
#include <opm/parser/eclipse/EclipseState/IOConfig/IOConfig.hpp>
#include <opm/parser/eclipse/EclipseState/Util/OrderedMap.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
#include <opm/parser/eclipse/Deck/Deck.hpp>
#include <opm/parser/eclipse/Deck/SCHEDULESection.hpp>
#include <opm/parser/eclipse/Parser/ParseMode.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/OilVaporizationProperties.hpp>
#include <memory>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <map>
#include <memory>
#include <boost/date_time/posix_time/posix_time_types.hpp>
#include <opm/parser/eclipse/Deck/Deck.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp>
#include <opm/parser/eclipse/EclipseState/Util/OrderedMap.hpp>
namespace Opm
{
template< typename > class DynamicState;
template< typename > class DynamicVector;
class EclipseGrid;
class Events;
class Group;
class GroupTree;
class IOConfig;
class OilVaporizationProperties;
class ParseMode;
class SCHEDULESection;
class TimeMap;
class Tuning;
class Well;
const boost::gregorian::date defaultStartDate( 1983 , boost::gregorian::Jan , 1);
class Schedule {
public:
Schedule(const ParseMode& parseMode , std::shared_ptr<const EclipseGrid> grid , DeckConstPtr deck, IOConfigPtr ioConfig);
boost::posix_time::ptime getStartTime() const
{ return m_timeMap->getStartTime(/*timeStepIdx=*/0); }
TimeMapConstPtr getTimeMap() const;
Schedule(const ParseMode& parseMode , std::shared_ptr<const EclipseGrid> grid , std::shared_ptr< const Deck > deck, std::shared_ptr< IOConfig > ioConfig);
boost::posix_time::ptime getStartTime() const;
std::shared_ptr< const TimeMap > getTimeMap() const;
size_t numWells() const;
size_t numWells(size_t timestep) const;
size_t getMaxNumCompletionsForWells(size_t timestep) const;
bool hasWell(const std::string& wellName) const;
WellPtr getWell(const std::string& wellName);
std::vector<WellPtr> getOpenWells(size_t timeStep);
std::vector<WellConstPtr> getWells() const;
std::vector<WellConstPtr> getWells(size_t timeStep) const;
std::vector<WellPtr> getWells(const std::string& wellNamePattern);
OilVaporizationPropertiesConstPtr getOilVaporizationProperties(size_t timestep);
std::shared_ptr< Well > getWell(const std::string& wellName);
std::vector<std::shared_ptr< Well >> getOpenWells(size_t timeStep);
std::vector<std::shared_ptr< const Well >> getWells() const;
std::vector<std::shared_ptr< const Well >> getWells(size_t timeStep) const;
std::vector<std::shared_ptr< Well >> getWells(const std::string& wellNamePattern);
std::shared_ptr< const OilVaporizationProperties > getOilVaporizationProperties(size_t timestep);
GroupTreePtr getGroupTree(size_t t) const;
std::shared_ptr< GroupTree > getGroupTree(size_t t) const;
size_t numGroups() const;
bool hasGroup(const std::string& groupName) const;
GroupPtr getGroup(const std::string& groupName) const;
TuningPtr getTuning() const;
std::shared_ptr< Group > getGroup(const std::string& groupName) const;
std::shared_ptr< Tuning > getTuning() const;
bool initOnly() const;
const Events& getEvents() const;
@@ -76,60 +80,60 @@ namespace Opm
private:
TimeMapPtr m_timeMap;
OrderedMap<WellPtr> m_wells;
std::shared_ptr< TimeMap > m_timeMap;
OrderedMap<std::shared_ptr< Well >> m_wells;
std::shared_ptr<const EclipseGrid> m_grid;
std::map<std::string , GroupPtr> m_groups;
std::shared_ptr<DynamicState<GroupTreePtr> > m_rootGroupTree;
std::shared_ptr<DynamicState<OilVaporizationPropertiesPtr> > m_oilvaporizationproperties;
std::map<std::string , std::shared_ptr< Group >> m_groups;
std::shared_ptr<DynamicState<std::shared_ptr< GroupTree >> > m_rootGroupTree;
std::shared_ptr<DynamicState<std::shared_ptr< OilVaporizationProperties > > > m_oilvaporizationproperties;
std::shared_ptr<Events> m_events;
std::shared_ptr<DynamicVector<std::shared_ptr<Deck> > > m_modifierDeck;
TuningPtr m_tuning;
std::shared_ptr< Tuning > m_tuning;
bool nosim;
void updateWellStatus(std::shared_ptr<Well> well, size_t reportStep , WellCommon::StatusEnum status);
void addWellToGroup( GroupPtr newGroup , WellPtr well , size_t timeStep);
void initFromDeck(const ParseMode& parseMode , DeckConstPtr deck, IOConfigPtr ioConfig);
void initializeNOSIM(DeckConstPtr deck);
void createTimeMap(DeckConstPtr deck);
void initRootGroupTreeNode(TimeMapConstPtr timeMap);
void initOilVaporization(TimeMapConstPtr timeMap);
void iterateScheduleSection(const ParseMode& parseMode , std::shared_ptr<const SCHEDULESection> section, IOConfigPtr ioConfig);
bool handleGroupFromWELSPECS(const std::string& groupName, GroupTreePtr newTree) const;
void addWellToGroup( std::shared_ptr< Group > newGroup , std::shared_ptr< Well > well , size_t timeStep);
void initFromDeck(const ParseMode& parseMode , std::shared_ptr< const Deck > deck, std::shared_ptr< IOConfig > ioConfig);
void initializeNOSIM(std::shared_ptr< const Deck > deck);
void createTimeMap(std::shared_ptr< const Deck > deck);
void initRootGroupTreeNode(std::shared_ptr< const TimeMap > timeMap);
void initOilVaporization(std::shared_ptr< const TimeMap > timeMap);
void iterateScheduleSection(const ParseMode& parseMode , std::shared_ptr<const SCHEDULESection> section, std::shared_ptr< IOConfig > ioConfig);
bool handleGroupFromWELSPECS(const std::string& groupName, std::shared_ptr< GroupTree > newTree) const;
void addGroup(const std::string& groupName , size_t timeStep);
void addWell(const std::string& wellName, DeckRecordConstPtr record, size_t timeStep, WellCompletion::CompletionOrderEnum wellCompletionOrder);
void addWell(const std::string& wellName, std::shared_ptr< const DeckRecord > record, size_t timeStep, WellCompletion::CompletionOrderEnum wellCompletionOrder);
void handleCOMPORD(const ParseMode& parseMode, std::shared_ptr<const DeckKeyword> compordKeyword, size_t currentStep);
void checkWELSPECSConsistency(WellConstPtr well, DeckKeywordConstPtr keyword, size_t recordIdx) const;
void handleWELSPECS(std::shared_ptr<const SCHEDULESection> section, DeckKeywordConstPtr keyword, size_t currentStep);
void handleWCONProducer(DeckKeywordConstPtr keyword, size_t currentStep, bool isPredictionMode);
void handleWCONHIST(DeckKeywordConstPtr keyword, size_t currentStep);
void handleWCONPROD(DeckKeywordConstPtr keyword, size_t currentStep);
void handleWGRUPCON(DeckKeywordConstPtr keyword, size_t currentStep);
void handleCOMPDAT(DeckKeywordConstPtr keyword, size_t currentStep);
void handleWELSEGS(DeckKeywordConstPtr keyword, size_t currentStep);
void handleCOMPSEGS(DeckKeywordConstPtr keyword, size_t currentStep);
void handleWCONINJE(std::shared_ptr<const SCHEDULESection> section, DeckKeywordConstPtr keyword, size_t currentStep);
void handleWPOLYMER(DeckKeywordConstPtr keyword, size_t currentStep);
void handleWSOLVENT(DeckKeywordConstPtr keyword, size_t currentStep);
void handleWCONINJH(std::shared_ptr<const SCHEDULESection> section, DeckKeywordConstPtr keyword, size_t currentStep);
void handleWELOPEN(DeckKeywordConstPtr keyword, size_t currentStep, bool hascomplump);
void handleWELTARG(std::shared_ptr<const SCHEDULESection> section, DeckKeywordConstPtr keyword, size_t currentStep);
void handleGCONINJE(std::shared_ptr<const SCHEDULESection> section, DeckKeywordConstPtr keyword, size_t currentStep);
void handleGCONPROD(DeckKeywordConstPtr keyword, size_t currentStep);
void handleTUNING(DeckKeywordConstPtr keyword, size_t currentStep);
void checkWELSPECSConsistency(std::shared_ptr< const Well > well, std::shared_ptr< const DeckKeyword > keyword, size_t recordIdx) const;
void handleWELSPECS(std::shared_ptr<const SCHEDULESection> section, std::shared_ptr< const DeckKeyword > keyword, size_t currentStep);
void handleWCONProducer(std::shared_ptr< const DeckKeyword > keyword, size_t currentStep, bool isPredictionMode);
void handleWCONHIST(std::shared_ptr< const DeckKeyword > keyword, size_t currentStep);
void handleWCONPROD(std::shared_ptr< const DeckKeyword > keyword, size_t currentStep);
void handleWGRUPCON(std::shared_ptr< const DeckKeyword > keyword, size_t currentStep);
void handleCOMPDAT(std::shared_ptr< const DeckKeyword > keyword, size_t currentStep);
void handleWELSEGS(std::shared_ptr< const DeckKeyword > keyword, size_t currentStep);
void handleCOMPSEGS(std::shared_ptr< const DeckKeyword > keyword, size_t currentStep);
void handleWCONINJE(std::shared_ptr<const SCHEDULESection> section, std::shared_ptr< const DeckKeyword > keyword, size_t currentStep);
void handleWPOLYMER(std::shared_ptr< const DeckKeyword > keyword, size_t currentStep);
void handleWSOLVENT(std::shared_ptr< const DeckKeyword > keyword, size_t currentStep);
void handleWCONINJH(std::shared_ptr<const SCHEDULESection> section, std::shared_ptr< const DeckKeyword > keyword, size_t currentStep);
void handleWELOPEN(std::shared_ptr< const DeckKeyword > keyword, size_t currentStep, bool hascomplump);
void handleWELTARG(std::shared_ptr<const SCHEDULESection> section, std::shared_ptr< const DeckKeyword > keyword, size_t currentStep);
void handleGCONINJE(std::shared_ptr<const SCHEDULESection> section, std::shared_ptr< const DeckKeyword > keyword, size_t currentStep);
void handleGCONPROD(std::shared_ptr< const DeckKeyword > keyword, size_t currentStep);
void handleTUNING(std::shared_ptr< const DeckKeyword > keyword, size_t currentStep);
void handleNOSIM();
void handleRPTRST(DeckKeywordConstPtr keyword, size_t currentStep, IOConfigPtr ioConfig);
void handleRPTSCHED(DeckKeywordConstPtr keyword, size_t currentStep, IOConfigPtr ioConfig);
void handleDATES(DeckKeywordConstPtr keyword);
void handleTSTEP(DeckKeywordConstPtr keyword);
void handleGRUPTREE(DeckKeywordConstPtr keyword, size_t currentStep);
void handleWRFT(DeckKeywordConstPtr keyword, size_t currentStep);
void handleWRFTPLT(DeckKeywordConstPtr keyword, size_t currentStep);
void handleWPIMULT(DeckKeywordConstPtr keyword, size_t currentStep);
void handleDRSDT(DeckKeywordConstPtr keyword, size_t currentStep);
void handleDRVDT(DeckKeywordConstPtr keyword, size_t currentStep);
void handleVAPPARS(DeckKeywordConstPtr keyword, size_t currentStep);
void handleRPTRST(std::shared_ptr< const DeckKeyword > keyword, size_t currentStep, std::shared_ptr< IOConfig > ioConfig);
void handleRPTSCHED(std::shared_ptr< const DeckKeyword > keyword, size_t currentStep, std::shared_ptr< IOConfig > ioConfig);
void handleDATES(std::shared_ptr< const DeckKeyword > keyword);
void handleTSTEP(std::shared_ptr< const DeckKeyword > keyword);
void handleGRUPTREE(std::shared_ptr< const DeckKeyword > keyword, size_t currentStep);
void handleWRFT(std::shared_ptr< const DeckKeyword > keyword, size_t currentStep);
void handleWRFTPLT(std::shared_ptr< const DeckKeyword > keyword, size_t currentStep);
void handleWPIMULT(std::shared_ptr< const DeckKeyword > keyword, size_t currentStep);
void handleDRSDT(std::shared_ptr< const DeckKeyword > keyword, size_t currentStep);
void handleDRVDT(std::shared_ptr< const DeckKeyword > keyword, size_t currentStep);
void handleVAPPARS(std::shared_ptr< const DeckKeyword > keyword, size_t currentStep);
void checkUnhandledKeywords(std::shared_ptr<const SCHEDULESection> section) const;
@@ -138,7 +142,7 @@ namespace Opm
static bool convertEclipseStringToBool(const std::string& eclipseString);
void setOilVaporizationProperties(const OilVaporizationPropertiesPtr vapor, size_t timestep);
void setOilVaporizationProperties(const std::shared_ptr< OilVaporizationProperties > vapor, size_t timestep);
};
typedef std::shared_ptr<Schedule> SchedulePtr;

1
opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp
View File

@@ -21,7 +21,6 @@
#define SCHEDULE_ENUMS_H
#include <string>
#include <stdexcept>
namespace Opm {
namespace WellCommon {

5
opm/parser/eclipse/EclipseState/Schedule/TimeMap.cpp
View File

@@ -17,10 +17,11 @@
along with OPM. If not, see <http://www.gnu.org/licenses/>.
*/
#include <opm/parser/eclipse/Deck/DeckIntItem.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/TimeMap.hpp>
#include <opm/parser/eclipse/Deck/DeckDoubleItem.hpp>
#include <opm/parser/eclipse/Deck/DeckIntItem.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/TimeMap.hpp>
namespace Opm {

2
opm/parser/eclipse/EclipseState/Schedule/TimeMap.hpp
View File

@@ -23,7 +23,7 @@
#include <vector>
#include <boost/date_time.hpp>
#include <boost/date_time/posix_time/posix_time_types.hpp>
#include <opm/parser/eclipse/Deck/Deck.hpp>
#include <opm/parser/eclipse/Deck/DeckKeyword.hpp>

2
opm/parser/eclipse/EclipseState/Schedule/Tuning.cpp
View File

@@ -18,6 +18,8 @@
*/
#include <opm/parser/eclipse/EclipseState/Schedule/DynamicState.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/TimeMap.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Tuning.hpp>
#include <opm/parser/eclipse/Units/ConversionFactors.hpp>

10
opm/parser/eclipse/EclipseState/Schedule/Tuning.hpp
View File

@@ -20,12 +20,12 @@
#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 {
template< typename > class DynamicState;
class TimeMap;
class Tuning {
/*
@@ -44,7 +44,7 @@ namespace Opm {
*/
public:
Tuning(TimeMapConstPtr timemap);
Tuning(std::shared_ptr< const TimeMap > timemap);
void setTuningInitialValue(const std::string tuningItem, double value,bool resetVector);
void setTuningInitialValue(const std::string tuningItem, int value, bool resetVector);

13
opm/parser/eclipse/EclipseState/Schedule/Well.cpp
View File

@@ -17,15 +17,18 @@
along with OPM. If not, see <http://www.gnu.org/licenses/>.
*/
#include <boost/date_time.hpp>
#include <iostream>
#include <opm/parser/eclipse/EclipseState/Util/Value.hpp>
#include <opm/parser/eclipse/Deck/DeckRecord.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/DynamicState.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/CompletionSet.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Completion.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/CompletionSet.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/DynamicState.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/MSW/SegmentSet.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well.hpp>
#include <opm/parser/eclipse/EclipseState/Util/Value.hpp>
#include <ert/ecl/ecl_grid.h>
namespace Opm {

42
opm/parser/eclipse/EclipseState/Schedule/Well.hpp
View File

@@ -21,35 +21,29 @@
#ifndef WELL_HPP_
#define WELL_HPP_
#include <opm/parser/eclipse/EclipseState/Schedule/TimeMap.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/DynamicState.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/CompletionSet.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Completion.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/MSW/SegmentSet.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/MSW/Segment.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/WellProductionProperties.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/WellInjectionProperties.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/WellPolymerProperties.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
#include <opm/common/utility/platform_dependent/disable_warnings.h>
#include <boost/optional.hpp>
#include <opm/common/utility/platform_dependent/reenable_warnings.h>
#include <opm/parser/eclipse/EclipseState/Util/Value.hpp>
#include <memory>
#include <string>
#include <limits>
namespace Opm {
template< typename > class DynamicState;
class Completion;
class CompletionSet;
class EclipseGrid;
class Segment;
class SegmentSet;
class TimeMap;
class Well {
public:
Well(const std::string& name, std::shared_ptr<const EclipseGrid> grid , int headI, int headJ, Value<double> refDepth , Phase::PhaseEnum preferredPhase,
TimeMapConstPtr timeMap, size_t creationTimeStep, WellCompletion::CompletionOrderEnum completionOrdering = WellCompletion::TRACK, bool allowCrossFlow = true);
std::shared_ptr< const TimeMap > timeMap, size_t creationTimeStep, WellCompletion::CompletionOrderEnum completionOrdering = WellCompletion::TRACK, bool allowCrossFlow = true);
const std::string& name() const;
bool hasBeenDefined(size_t timeStep) const;
@@ -78,10 +72,10 @@ namespace Opm {
bool isProducer(size_t timeStep) const;
bool isInjector(size_t timeStep) const;
void addWELSPECS(DeckRecordConstPtr deckRecord);
void addCompletions(size_t time_step , const std::vector<CompletionPtr>& newCompletions);
void addCompletionSet(size_t time_step, const CompletionSetConstPtr newCompletionSet);
CompletionSetConstPtr getCompletions(size_t timeStep) const;
void addWELSPECS(std::shared_ptr< const DeckRecord > deckRecord);
void addCompletions(size_t time_step , const std::vector<std::shared_ptr< Completion >>& newCompletions);
void addCompletionSet(size_t time_step, const std::shared_ptr< const CompletionSet > newCompletionSet);
std::shared_ptr< const CompletionSet > getCompletions(size_t timeStep) const;
bool setProductionProperties(size_t timeStep , const WellProductionProperties properties);
WellProductionProperties getProductionPropertiesCopy(size_t timeStep) const;
@@ -115,9 +109,9 @@ namespace Opm {
// for multi-segment wells
bool isMultiSegment(size_t time_step) const;
SegmentSetConstPtr getSegmentSet(size_t time_step) const;
std::shared_ptr< const SegmentSet > getSegmentSet(size_t time_step) const;
void addSegmentSet(size_t time_step, SegmentSetConstPtr new_segmentset);
void addSegmentSet(size_t time_step, std::shared_ptr< const SegmentSet > new_segmentset);
private:
void setRefDepthFromCompletions() const;
@@ -132,7 +126,7 @@ namespace Opm {
std::shared_ptr<DynamicState<double> > m_guideRateScalingFactor;
std::shared_ptr<DynamicState<bool> > m_isProducer;
std::shared_ptr<DynamicState<CompletionSetConstPtr> > m_completions;
std::shared_ptr<DynamicState<std::shared_ptr< const CompletionSet >> > m_completions;
std::shared_ptr<DynamicState<WellProductionProperties> > m_productionProperties;
std::shared_ptr<DynamicState<WellInjectionProperties> > m_injectionProperties;
std::shared_ptr<DynamicState<WellPolymerProperties> > m_polymerProperties;
@@ -143,7 +137,7 @@ namespace Opm {
// WELSPECS data - assumes this is not dynamic
TimeMapConstPtr m_timeMap;
std::shared_ptr< const TimeMap > m_timeMap;
int m_headI;
int m_headJ;
mutable Value<double> m_refDepth;
@@ -155,7 +149,7 @@ namespace Opm {
// WELSEGS DATA - for mutli-segment wells
// flag indicating if the well is a multi-segment well
std::shared_ptr<DynamicState<SegmentSetConstPtr>> m_segmentset;
std::shared_ptr<DynamicState<std::shared_ptr< const SegmentSet >>> m_segmentset;
};
typedef std::shared_ptr<Well> WellPtr;
typedef std::shared_ptr<const Well> WellConstPtr;

8
opm/parser/eclipse/EclipseState/Schedule/WellSet.cpp
View File

@@ -17,7 +17,9 @@
along with OPM. If not, see <http://www.gnu.org/licenses/>.
*/
#include <opm/parser/eclipse/EclipseState/Schedule/Well.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/WellSet.hpp>
namespace Opm {
@@ -34,7 +36,7 @@ namespace Opm {
}
WellConstPtr WellSet::getWell(const std::string& wellName) const {
std::shared_ptr< const Well > WellSet::getWell(const std::string& wellName) const {
if (hasWell(wellName))
return m_wells.find(wellName)->second;
else
@@ -42,7 +44,7 @@ namespace Opm {
}
void WellSet::addWell(WellPtr well) {
void WellSet::addWell(std::shared_ptr< Well > well) {
const std::string& wellName = well->name();
if (!hasWell(wellName))
m_wells[wellName] = well;
@@ -62,7 +64,7 @@ namespace Opm {
WellSet * WellSet::shallowCopy() const {
WellSet * copy = new WellSet();
for (std::map<std::string , WellPtr>::const_iterator iter=m_wells.begin(); iter != m_wells.end(); ++iter)
for (std::map<std::string , std::shared_ptr< Well >>::const_iterator iter=m_wells.begin(); iter != m_wells.end(); ++iter)
copy->addWell( (*iter).second );
return copy;

17
opm/parser/eclipse/EclipseState/Schedule/WellSet.hpp
View File

@@ -19,14 +19,11 @@
#ifndef WELLSET_HPP
#define WELLSET_HPP
#include <opm/parser/eclipse/EclipseState/Schedule/TimeMap.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/DynamicState.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well.hpp>
#include <memory>
#include <string>
#include <map>
#include <memory>
#include <string>
#include <opm/parser/eclipse/EclipseState/Schedule/Well.hpp>
namespace Opm {
@@ -35,12 +32,12 @@ namespace Opm {
WellSet();
size_t size() const;
bool hasWell(const std::string& wellName) const;
WellConstPtr getWell(const std::string& wellName) const;
void addWell(WellPtr well);
std::shared_ptr< const Well > getWell(const std::string& wellName) const;
void addWell(std::shared_ptr< Well > well);
void delWell(const std::string& wellName);
WellSet * shallowCopy() const;
private:
std::map<std::string , WellPtr> m_wells;
std::map<std::string , std::shared_ptr< Well >> m_wells;
};
typedef std::shared_ptr<WellSet> WellSetPtr;

1
opm/parser/eclipse/EclipseState/Schedule/tests/GeomodifierTests.cpp
View File

@@ -31,6 +31,7 @@
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Events.hpp>
#include <opm/parser/eclipse/EclipseState/IOConfig/IOConfig.hpp>
using namespace Opm;

1
opm/parser/eclipse/EclipseState/Schedule/tests/GroupTests.cpp
View File

@@ -28,6 +28,7 @@
#include <opm/parser/eclipse/EclipseState/Util/Value.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Group.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/TimeMap.hpp>

7
opm/parser/eclipse/EclipseState/Schedule/tests/ScheduleTests.cpp
View File

@@ -28,12 +28,19 @@
#include <boost/date_time/posix_time/posix_time.hpp>
#include <opm/common/utility/platform_dependent/reenable_warnings.h>
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/GroupTree.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/CompletionSet.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/OilVaporizationProperties.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well.hpp>
#include <opm/parser/eclipse/Deck/DeckIntItem.hpp>
#include <opm/parser/eclipse/Deck/DeckStringItem.hpp>
#include <opm/parser/eclipse/Deck/Deck.hpp>
#include <opm/parser/eclipse/EclipseState/IOConfig/IOConfig.hpp>
#include <opm/parser/eclipse/Parser/Parser.hpp>
#include <opm/parser/eclipse/Parser/ParseMode.hpp>
#include <opm/parser/eclipse/Units/UnitSystem.hpp>
using namespace Opm;

2
opm/parser/eclipse/EclipseState/Schedule/tests/TuningTests.cpp
View File

@@ -24,6 +24,8 @@
#include <opm/parser/eclipse/Parser/Parser.hpp>
#include <opm/parser/eclipse/Parser/ParseMode.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
#include <opm/parser/eclipse/EclipseState/IOConfig/IOConfig.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Tuning.hpp>
#include <opm/parser/eclipse/Units/ConversionFactors.hpp>

1
opm/parser/eclipse/EclipseState/Schedule/tests/WellSetTests.cpp
View File

@@ -25,6 +25,7 @@
#include <boost/test/unit_test.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/WellSet.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/TimeMap.hpp>

3
opm/parser/eclipse/EclipseState/Schedule/tests/WellSolventTests.cpp
View File

@@ -24,7 +24,10 @@
#include <boost/test/unit_test.hpp>
#include <opm/common/utility/platform_dependent/reenable_warnings.h>
#include <opm/parser/eclipse/EclipseState/IOConfig/IOConfig.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well.hpp>
#include <opm/parser/eclipse/Deck/DeckIntItem.hpp>
#include <opm/parser/eclipse/Deck/DeckStringItem.hpp>
#include <opm/parser/eclipse/Deck/Deck.hpp>

2
opm/parser/eclipse/EclipseState/Schedule/tests/WellTests.cpp
View File

@@ -31,7 +31,9 @@
#include <opm/parser/eclipse/Deck/DeckStringItem.hpp>
#include <opm/parser/eclipse/EclipseState/EclipseState.hpp>
#include <opm/parser/eclipse/EclipseState/IOConfig/IOConfig.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/CompletionSet.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well.hpp>

4
opm/parser/eclipse/EclipseState/SimulationConfig/SimulationConfig.cpp
View File

@@ -18,8 +18,10 @@
*/
#include <opm/parser/eclipse/EclipseState/SimulationConfig/SimulationConfig.hpp>
#include <opm/parser/eclipse/Deck/Deck.hpp>
#include <opm/parser/eclipse/Deck/Section.hpp>
#include <opm/parser/eclipse/EclipseState/SimulationConfig/SimulationConfig.hpp>
#include <opm/parser/eclipse/EclipseState/SimulationConfig/ThresholdPressure.hpp>
#include <opm/parser/eclipse/Parser/ParserKeywords.hpp>

9
opm/parser/eclipse/EclipseState/SimulationConfig/SimulationConfig.hpp
View File

@@ -21,11 +21,14 @@
#define OPM_SIMULATION_CONFIG_HPP
#include <opm/parser/eclipse/Deck/Deck.hpp>
#include <opm/parser/eclipse/EclipseState/SimulationConfig/ThresholdPressure.hpp>
#include <opm/parser/eclipse/Parser/ParseMode.hpp>
namespace Opm {
template< typename > class GridProperties;
class ThresholdPressure;
class ParseMode;
class SimulationConfig {
public:
@@ -42,7 +45,7 @@ namespace Opm {
void initThresholdPressure(const ParseMode& parseMode , DeckConstPtr deck, std::shared_ptr<GridProperties<int>> gridProperties);
ThresholdPressureConstPtr m_ThresholdPressure;
std::shared_ptr< const ThresholdPressure > m_ThresholdPressure;
bool m_useCPR;
bool m_DISGAS;
bool m_VAPOIL;

5
opm/parser/eclipse/EclipseState/SimulationConfig/ThresholdPressure.cpp
View File

@@ -16,11 +16,12 @@
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/SimulationConfig/ThresholdPressure.hpp>
#include <opm/parser/eclipse/Deck/Deck.hpp>
#include <opm/parser/eclipse/Deck/Section.hpp>
#include <opm/parser/eclipse/Parser/ParserKeywords.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/GridProperties.hpp>
#include <opm/parser/eclipse/EclipseState/SimulationConfig/ThresholdPressure.hpp>
#include <opm/parser/eclipse/OpmLog/OpmLog.hpp>
#include <opm/parser/eclipse/Parser/ParserKeywords.hpp>
namespace Opm {

6
opm/parser/eclipse/EclipseState/SimulationConfig/ThresholdPressure.hpp
View File

@@ -24,12 +24,14 @@
#include <opm/parser/eclipse/Deck/Deck.hpp>
#include <opm/parser/eclipse/Deck/Section.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/GridProperties.hpp>
#include <opm/parser/eclipse/Parser/ParseMode.hpp>
namespace Opm {
template< typename > class GridProperties;
class ParseMode;
class ThresholdPressure {
public:

2
opm/parser/eclipse/EclipseState/SimulationConfig/tests/SimulationConfigTest.cpp
View File

@@ -29,7 +29,9 @@
#include <opm/parser/eclipse/Parser/Parser.hpp>
#include <opm/parser/eclipse/Deck/Section.hpp>
#include <opm/parser/eclipse/Parser/ParseMode.hpp>
#include <opm/parser/eclipse/Parser/ParserKeywords.hpp>
#include <opm/parser/eclipse/EclipseState/EclipseState.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/GridProperties.hpp>
#include <opm/parser/eclipse/EclipseState/SimulationConfig/SimulationConfig.hpp>

2
opm/parser/eclipse/EclipseState/Tables/ColumnSchema.hpp
View File

@@ -25,8 +25,6 @@
#include <vector>
#include <opm/parser/eclipse/EclipseState/Tables/TableEnums.hpp>
#include <opm/parser/eclipse/EclipseState/Util/Value.hpp>
namespace Opm {

5
opm/parser/eclipse/EclipseState/Tables/EnkrvdTable.hpp
View File

@@ -25,10 +25,13 @@
namespace Opm {
class DeckItem;
class EnkrvdTable : public SimpleTable {
public:
EnkrvdTable(Opm::DeckItemConstPtr item)
EnkrvdTable(std::shared_ptr< const DeckItem > item)
{
m_schema = std::make_shared<TableSchema>( );

5
opm/parser/eclipse/EclipseState/Tables/EnptvdTable.hpp
View File

@@ -23,9 +23,12 @@
#include <opm/parser/eclipse/EclipseState/Tables/TableEnums.hpp>
namespace Opm {
class DeckItem;
class EnptvdTable : public SimpleTable {
public:
EnptvdTable(Opm::DeckItemConstPtr item)
EnptvdTable(std::shared_ptr< const DeckItem > item)
{
m_schema = std::make_shared<TableSchema>( );
m_schema->addColumn( ColumnSchema( "DEPTH" , Table::STRICTLY_INCREASING , Table::DEFAULT_NONE ) );

6
opm/parser/eclipse/EclipseState/Tables/GasvisctTable.hpp
View File

@@ -23,11 +23,15 @@
#include <opm/parser/eclipse/Parser/ParserKeywords.hpp>
#include "SimpleTable.hpp"
#include <opm/parser/eclipse/EclipseState/Tables/TableEnums.hpp>
#include <opm/parser/eclipse/Units/UnitSystem.hpp>
namespace Opm {
class DeckItem;
class GasvisctTable : public SimpleTable {
public:
GasvisctTable(const Deck& deck, Opm::DeckItemConstPtr deckItem)
GasvisctTable(const Deck& deck, std::shared_ptr< const DeckItem > deckItem)
{
int numComponents = deck.getKeyword<ParserKeywords::COMPS>()->getRecord(0)->getItem(0)->getInt(0);

5
opm/parser/eclipse/EclipseState/Tables/ImkrvdTable.hpp
View File

@@ -24,9 +24,12 @@
namespace Opm {
class DeckItem;
class ImkrvdTable : public SimpleTable {
public:
ImkrvdTable(Opm::DeckItemConstPtr item)
ImkrvdTable(std::shared_ptr< const DeckItem > item)
{
m_schema = std::make_shared<TableSchema>( );
m_schema->addColumn( ColumnSchema( "DEPTH" , Table::STRICTLY_INCREASING , Table::DEFAULT_NONE ) );

5
opm/parser/eclipse/EclipseState/Tables/ImptvdTable.hpp
View File

@@ -24,10 +24,13 @@
#include <opm/parser/eclipse/EclipseState/Tables/TableEnums.hpp>
namespace Opm {
class DeckItem;
class ImptvdTable : public SimpleTable {
public:
ImptvdTable(Opm::DeckItemConstPtr item)
ImptvdTable(std::shared_ptr< const DeckItem > item)
{
m_schema = std::make_shared<TableSchema>( );
m_schema->addColumn( ColumnSchema( "DEPTH" , Table::STRICTLY_INCREASING , Table::DEFAULT_NONE ) );

4
opm/parser/eclipse/EclipseState/Tables/MiscTable.hpp
View File

@@ -25,9 +25,11 @@
namespace Opm {
class DeckItem;
class MiscTable : public SimpleTable {
public:
MiscTable(Opm::DeckItemConstPtr item)
MiscTable(std::shared_ptr< const DeckItem > item)
{
m_schema = std::make_shared<TableSchema>();
m_schema->addColumn( ColumnSchema( "SolventFraction" , Table::STRICTLY_INCREASING , Table::DEFAULT_NONE) );

5
opm/parser/eclipse/EclipseState/Tables/MsfnTable.hpp
View File

@@ -24,9 +24,12 @@
#include <opm/parser/eclipse/EclipseState/Tables/TableEnums.hpp>
namespace Opm {
class DeckItem;
class MsfnTable : public SimpleTable {
public:
MsfnTable(Opm::DeckItemConstPtr item)
MsfnTable(std::shared_ptr< const DeckItem > item)
{
m_schema = std::make_shared<TableSchema>( );
m_schema->addColumn( ColumnSchema( "GasPhaseFraction", Table::STRICTLY_INCREASING , Table::DEFAULT_NONE));

5
opm/parser/eclipse/EclipseState/Tables/OilvisctTable.hpp
View File

@@ -23,10 +23,13 @@
#include <opm/parser/eclipse/EclipseState/Tables/TableEnums.hpp>
namespace Opm {
class DeckItem;
class OilvisctTable : public SimpleTable {
public:
OilvisctTable(Opm::DeckItemConstPtr item)
OilvisctTable(std::shared_ptr< const DeckItem > item)
{
m_schema = std::make_shared<TableSchema>( );
m_schema->addColumn( ColumnSchema("Temperature" , Table::STRICTLY_INCREASING , Table::DEFAULT_NONE) );

5
opm/parser/eclipse/EclipseState/Tables/PlyadsTable.hpp
View File

@@ -23,10 +23,13 @@
#include <opm/parser/eclipse/EclipseState/Tables/TableEnums.hpp>
namespace Opm {
class DeckItem;
class PlyadsTable : public SimpleTable {
public:
PlyadsTable(Opm::DeckItemConstPtr item)
PlyadsTable(std::shared_ptr< const DeckItem > item)
{
m_schema = std::make_shared<TableSchema>();
m_schema->addColumn( ColumnSchema("PolymerConcentration" , Table::STRICTLY_INCREASING , Table::DEFAULT_NONE ));

5
opm/parser/eclipse/EclipseState/Tables/PlydhflfTable.hpp
View File

@@ -24,10 +24,13 @@
namespace Opm {
class DeckItem;
class PlydhflfTable : public SimpleTable {
public:
PlydhflfTable(DeckItemConstPtr item)
PlydhflfTable(std::shared_ptr< const DeckItem > item)
{
m_schema = std::make_shared<TableSchema>( );
m_schema->addColumn( ColumnSchema("Temperature" , Table::STRICTLY_INCREASING , Table::DEFAULT_NONE ) );

4
opm/parser/eclipse/EclipseState/Tables/PlymaxTable.hpp
View File

@@ -21,11 +21,13 @@
#include "SimpleTable.hpp"
#include <opm/parser/eclipse/EclipseState/Tables/TableEnums.hpp>
#include <opm/parser/eclipse/Deck/DeckRecord.hpp>
namespace Opm {
class PlymaxTable : public SimpleTable {
public:
PlymaxTable(Opm::DeckRecordConstPtr record)
PlymaxTable(std::shared_ptr< const DeckRecord > record)
{
m_schema = std::make_shared<TableSchema>( );

5
opm/parser/eclipse/EclipseState/Tables/PlyrockTable.hpp
View File

@@ -24,11 +24,14 @@
#include <opm/parser/eclipse/EclipseState/Tables/ColumnSchema.hpp>
namespace Opm {
class DeckItem;
class PlyrockTable : public SimpleTable {
public:
// This is not really a table; every column has only one element.
PlyrockTable(DeckRecordConstPtr record)
PlyrockTable(std::shared_ptr< const DeckRecord > record)
{
m_schema = std::make_shared<TableSchema>( );
m_schema->addColumn( ColumnSchema("DeadPoreVolume", Table::RANDOM , Table::DEFAULT_NONE) );

7
opm/parser/eclipse/EclipseState/Tables/PlyshlogTable.hpp
View File

@@ -19,20 +19,21 @@
#ifndef OPM_PARSER_PLYSHLOG_TABLE_HPP
#define OPM_PARSER_PLYSHLOG_TABLE_HPP
#include <opm/parser/eclipse/Parser/ParserKeywords.hpp>
#include "SimpleTable.hpp"
#include <opm/parser/eclipse/Deck/DeckRecord.hpp>
#include <opm/parser/eclipse/Parser/ParserKeywords/P.hpp>
#include <opm/parser/eclipse/EclipseState/Tables/TableEnums.hpp>
namespace Opm {
// forward declaration
class TableManager;
class PlyshlogTable : public SimpleTable {
public:
friend class TableManager;
PlyshlogTable(Opm::DeckRecordConstPtr indexRecord, Opm::DeckRecordConstPtr dataRecord) {
PlyshlogTable(std::shared_ptr< const DeckRecord > indexRecord, std::shared_ptr< const DeckRecord > dataRecord) {
{
const auto item = indexRecord->getItem<ParserKeywords::PLYSHLOG::REF_POLYMER_CONCENTRATION>();
setRefPolymerConcentration(item->getRawDouble(0));

5
opm/parser/eclipse/EclipseState/Tables/PlyviscTable.hpp
View File

@@ -24,9 +24,12 @@
namespace Opm {
class DeckItem;
class PlyviscTable : public SimpleTable {
public:
PlyviscTable(Opm::DeckItemConstPtr item)
PlyviscTable(std::shared_ptr< const DeckItem > item)
{
m_schema = std::make_shared<TableSchema>();
m_schema->addColumn( ColumnSchema( "PolymerConcentration" , Table::STRICTLY_INCREASING , Table::DEFAULT_NONE));

5
opm/parser/eclipse/EclipseState/Tables/PmiscTable.hpp
View File

@@ -24,10 +24,13 @@
#include <opm/parser/eclipse/EclipseState/Tables/TableEnums.hpp>
namespace Opm {
class DeckItem;
class PmiscTable : public SimpleTable {
public:
PmiscTable(Opm::DeckItemConstPtr item)
PmiscTable(std::shared_ptr< const DeckItem > item)
{
m_schema = std::make_shared<TableSchema>();
m_schema->addColumn( ColumnSchema( "OilPhasePressure" , Table::STRICTLY_INCREASING , Table::DEFAULT_NONE) );

5
opm/parser/eclipse/EclipseState/Tables/PvdgTable.hpp
View File

@@ -23,10 +23,13 @@
#include <opm/parser/eclipse/EclipseState/Tables/TableEnums.hpp>
namespace Opm {
class DeckItem;
class PvdgTable : public SimpleTable {
public:
PvdgTable(Opm::DeckItemConstPtr item)
PvdgTable(std::shared_ptr< const DeckItem > item)
{
m_schema = std::make_shared<TableSchema>();
m_schema->addColumn( ColumnSchema( "P" , Table::STRICTLY_INCREASING , Table::DEFAULT_NONE ));

5
opm/parser/eclipse/EclipseState/Tables/PvdoTable.hpp
View File

@@ -23,10 +23,13 @@
#include <opm/parser/eclipse/EclipseState/Tables/TableEnums.hpp>
namespace Opm {
class DeckItem;
class PvdoTable : public SimpleTable {
public:
PvdoTable(Opm::DeckItemConstPtr item)
PvdoTable(std::shared_ptr< const DeckItem > item)
{
m_schema = std::make_shared<TableSchema>( );

5
opm/parser/eclipse/EclipseState/Tables/PvdsTable.hpp
View File

@@ -24,9 +24,12 @@
#include <opm/parser/eclipse/EclipseState/Tables/TableEnums.hpp>
namespace Opm {
class DeckItem;
class PvdsTable : public SimpleTable {
public:
PvdsTable(Opm::DeckItemConstPtr item)
PvdsTable(std::shared_ptr< const DeckItem > item)
{
m_schema = std::make_shared<TableSchema>();

42
opm/parser/eclipse/EclipseState/Tables/PvtgTable.cpp Normal file
View File

@@ -0,0 +1,42 @@
/*
Copyright (C) 2013 by Andreas Lauser
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/DeckKeyword.hpp>
#include <opm/parser/eclipse/EclipseState/Tables/ColumnSchema.hpp>
#include <opm/parser/eclipse/EclipseState/Tables/TableSchema.hpp>
#include <opm/parser/eclipse/EclipseState/Tables/PvtgTable.hpp>
namespace Opm {
PvtgTable::PvtgTable(Opm::DeckKeywordConstPtr keyword, size_t tableIdx ) : PvtxTable("P")
{
m_underSaturatedSchema = std::make_shared<TableSchema>( );
m_underSaturatedSchema->addColumn( ColumnSchema( "RV" , Table::STRICTLY_DECREASING , Table::DEFAULT_NONE ));
m_underSaturatedSchema->addColumn( ColumnSchema( "BG" , Table::RANDOM , Table::DEFAULT_LINEAR ));
m_underSaturatedSchema->addColumn( ColumnSchema( "MUG" , Table::RANDOM , Table::DEFAULT_LINEAR ));
m_saturatedSchema = std::make_shared<TableSchema>( );
m_saturatedSchema->addColumn( ColumnSchema( "PG" , Table::STRICTLY_INCREASING , Table::DEFAULT_NONE ));
m_saturatedSchema->addColumn( ColumnSchema( "RV" , Table::RANDOM , Table::DEFAULT_NONE ));
m_saturatedSchema->addColumn( ColumnSchema( "BG" , Table::RANDOM , Table::DEFAULT_LINEAR ));
m_saturatedSchema->addColumn( ColumnSchema( "MUG" , Table::RANDOM , Table::DEFAULT_LINEAR ));
PvtxTable::init(keyword , tableIdx);
}
}

23
opm/parser/eclipse/EclipseState/Tables/PvtgTable.hpp
View File

@@ -22,27 +22,12 @@
#include <opm/parser/eclipse/EclipseState/Tables/PvtxTable.hpp>
namespace Opm {
class DeckKeyword;
class PvtgTable : public PvtxTable {
public:
PvtgTable(Opm::DeckKeywordConstPtr keyword , size_t tableIdx) : PvtxTable("P")
{
m_underSaturatedSchema = std::make_shared<TableSchema>( );
m_underSaturatedSchema->addColumn( ColumnSchema( "RV" , Table::STRICTLY_DECREASING , Table::DEFAULT_NONE ));
m_underSaturatedSchema->addColumn( ColumnSchema( "BG" , Table::RANDOM , Table::DEFAULT_LINEAR ));
m_underSaturatedSchema->addColumn( ColumnSchema( "MUG" , Table::RANDOM , Table::DEFAULT_LINEAR ));
m_saturatedSchema = std::make_shared<TableSchema>( );
m_saturatedSchema->addColumn( ColumnSchema( "PG" , Table::STRICTLY_INCREASING , Table::DEFAULT_NONE ));
m_saturatedSchema->addColumn( ColumnSchema( "RV" , Table::RANDOM , Table::DEFAULT_NONE ));
m_saturatedSchema->addColumn( ColumnSchema( "BG" , Table::RANDOM , Table::DEFAULT_LINEAR ));
m_saturatedSchema->addColumn( ColumnSchema( "MUG" , Table::RANDOM , Table::DEFAULT_LINEAR ));
PvtxTable::init(keyword , tableIdx);
}
PvtgTable(std::shared_ptr< const DeckKeyword > keyword, size_t tableIdx);
};
}

24
opm/parser/eclipse/EclipseState/Tables/PvtoTable.cpp Normal file
View File

@@ -0,0 +1,24 @@
#include <opm/parser/eclipse/Deck/DeckKeyword.hpp>
#include <opm/parser/eclipse/EclipseState/Tables/ColumnSchema.hpp>
#include <opm/parser/eclipse/EclipseState/Tables/PvtoTable.hpp>
#include <opm/parser/eclipse/EclipseState/Tables/TableSchema.hpp>
namespace Opm {
PvtoTable::PvtoTable(Opm::DeckKeywordConstPtr keyword , size_t tableIdx) : PvtxTable("RS") {
m_underSaturatedSchema = std::make_shared<TableSchema>( );
m_underSaturatedSchema->addColumn( ColumnSchema( "P" , Table::STRICTLY_INCREASING , Table::DEFAULT_NONE ));
m_underSaturatedSchema->addColumn( ColumnSchema( "BO" , Table::RANDOM , Table::DEFAULT_LINEAR ));
m_underSaturatedSchema->addColumn( ColumnSchema( "MU" , Table::RANDOM , Table::DEFAULT_LINEAR ));
m_saturatedSchema = std::make_shared<TableSchema>( );
m_saturatedSchema->addColumn( ColumnSchema( "RS" , Table::STRICTLY_INCREASING , Table::DEFAULT_NONE ));
m_saturatedSchema->addColumn( ColumnSchema( "P" , Table::RANDOM , Table::DEFAULT_NONE ));
m_saturatedSchema->addColumn( ColumnSchema( "BO" , Table::RANDOM , Table::DEFAULT_LINEAR ));
m_saturatedSchema->addColumn( ColumnSchema( "MU" , Table::RANDOM , Table::DEFAULT_LINEAR ));
PvtxTable::init(keyword , tableIdx);
}
}

24
opm/parser/eclipse/EclipseState/Tables/PvtoTable.hpp
View File

@@ -22,28 +22,12 @@
#include <opm/parser/eclipse/EclipseState/Tables/PvtxTable.hpp>
namespace Opm {
class DeckKeyword;
class PvtoTable : public PvtxTable {
public:
PvtoTable(Opm::DeckKeywordConstPtr keyword , size_t tableIdx) : PvtxTable("RS")
{
m_underSaturatedSchema = std::make_shared<TableSchema>( );
m_underSaturatedSchema->addColumn( ColumnSchema( "P" , Table::STRICTLY_INCREASING , Table::DEFAULT_NONE ));
m_underSaturatedSchema->addColumn( ColumnSchema( "BO" , Table::RANDOM , Table::DEFAULT_LINEAR ));
m_underSaturatedSchema->addColumn( ColumnSchema( "MU" , Table::RANDOM , Table::DEFAULT_LINEAR ));
m_saturatedSchema = std::make_shared<TableSchema>( );
m_saturatedSchema->addColumn( ColumnSchema( "RS" , Table::STRICTLY_INCREASING , Table::DEFAULT_NONE ));
m_saturatedSchema->addColumn( ColumnSchema( "P" , Table::RANDOM , Table::DEFAULT_NONE ));
m_saturatedSchema->addColumn( ColumnSchema( "BO" , Table::RANDOM , Table::DEFAULT_LINEAR ));
m_saturatedSchema->addColumn( ColumnSchema( "MU" , Table::RANDOM , Table::DEFAULT_LINEAR ));
PvtxTable::init(keyword , tableIdx);
}
PvtoTable(std::shared_ptr< const DeckKeyword > keyword, size_t tableIdx);
};
}

5
opm/parser/eclipse/EclipseState/Tables/PvtxTable.cpp
View File

@@ -17,7 +17,12 @@
along with OPM. If not, see <http://www.gnu.org/licenses/>.
*/
#include <opm/parser/eclipse/Deck/DeckItem.hpp>
#include <opm/parser/eclipse/Deck/DeckKeyword.hpp>
#include <opm/parser/eclipse/Deck/DeckRecord.hpp>
#include <opm/parser/eclipse/EclipseState/Tables/PvtxTable.hpp>
#include <opm/parser/eclipse/EclipseState/Tables/SimpleTable.hpp>
#include <opm/parser/eclipse/EclipseState/Tables/TableSchema.hpp>
namespace Opm {

14
opm/parser/eclipse/EclipseState/Tables/PvtxTable.hpp
View File

@@ -20,11 +20,8 @@
#define OPM_PARSER_PVTX_TABLE_HPP
#include <vector>
#include <opm/parser/eclipse/Deck/DeckKeyword.hpp>
#include <opm/parser/eclipse/EclipseState/Tables/SimpleTable.hpp>
#include <opm/parser/eclipse/EclipseState/Tables/TableColumn.hpp>
#include <opm/parser/eclipse/EclipseState/Tables/TableSchema.hpp>
#include <opm/parser/eclipse/EclipseState/Tables/ColumnSchema.hpp>
/*
@@ -105,16 +102,21 @@ The first row actually corresponds to saturated values.
namespace Opm {
class DeckKeyword;
class SimpleTable;
class TableSchema;
class PvtxTable
{
public:
static size_t numTables(Opm::DeckKeywordConstPtr keyword);
static std::vector<std::pair<size_t , size_t> > recordRanges(Opm::DeckKeywordConstPtr keyword);
static size_t numTables(std::shared_ptr< const DeckKeyword > keyword);
static std::vector<std::pair<size_t , size_t> > recordRanges(std::shared_ptr< const DeckKeyword > keyword);
PvtxTable(const std::string& columnName);
const SimpleTable& getUnderSaturatedTable(size_t tableNumber) const;
void init(Opm::DeckKeywordConstPtr keyword , size_t tableIdx);
void init(std::shared_ptr< const DeckKeyword > keyword , size_t tableIdx);
size_t size() const;
double evaluate(const std::string& column, double outerArg, double innerArg) const;
double getArgValue(size_t index) const;

5
opm/parser/eclipse/EclipseState/Tables/RocktabTable.hpp
View File

@@ -23,9 +23,12 @@
#include <opm/parser/eclipse/EclipseState/Tables/TableEnums.hpp>
namespace Opm {
class DeckItem;
class RocktabTable : public SimpleTable {
public:
RocktabTable(Opm::DeckItemConstPtr item,
RocktabTable(std::shared_ptr< const DeckItem > item,
bool isDirectional,
bool hasStressOption)
{

5
opm/parser/eclipse/EclipseState/Tables/RsvdTable.hpp
View File

@@ -23,9 +23,12 @@
#include <opm/parser/eclipse/EclipseState/Tables/TableEnums.hpp>
namespace Opm {
class DeckItem;
class RsvdTable : public SimpleTable {
public:
RsvdTable(Opm::DeckItemConstPtr item)
RsvdTable(std::shared_ptr< const DeckItem > item)
{
m_schema = std::make_shared<TableSchema>( );
m_schema->addColumn( ColumnSchema( "DEPTH" , Table::STRICTLY_INCREASING , Table::DEFAULT_NONE ));

4
opm/parser/eclipse/EclipseState/Tables/RtempvdTable.hpp
View File

@@ -24,9 +24,11 @@
namespace Opm {
class DeckItem;
class RtempvdTable : public SimpleTable {
public:
RtempvdTable(Opm::DeckItemConstPtr item)
RtempvdTable(std::shared_ptr< const DeckItem > item)
{
m_schema = std::make_shared<TableSchema>();
m_schema->addColumn( ColumnSchema( "Depth" , Table::STRICTLY_INCREASING , Table::DEFAULT_NONE) );

Some files were not shown because too many files have changed in this diff Show More