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

Remove old well implementation

Browse Source
This commit is contained in:
Joakim Hove 2019-05-04 12:00:32 +02:00
parent 1d31de03c7
commit 94b160258e
48 changed files with 1988 additions and 4093 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists_files.cmake
View File

@ -101,7 +101,6 @@ if(ENABLE_ECL_INPUT)
src/opm/parser/eclipse/EclipseState/Schedule/TimeMap.cpp
src/opm/parser/eclipse/EclipseState/Schedule/Tuning.cpp
src/opm/parser/eclipse/EclipseState/Schedule/Well/Connection.cpp
src/opm/parser/eclipse/EclipseState/Schedule/Well/Well.cpp
src/opm/parser/eclipse/EclipseState/Schedule/Well/Well2.cpp
src/opm/parser/eclipse/EclipseState/Schedule/Well/WellConnections.cpp
src/opm/parser/eclipse/EclipseState/Schedule/Well/WList.cpp
@ -505,7 +504,6 @@ if(ENABLE_ECL_INPUT)
opm/parser/eclipse/EclipseState/Schedule/VFPInjTable.hpp
opm/parser/eclipse/EclipseState/Schedule/VFPProdTable.hpp
opm/parser/eclipse/EclipseState/Schedule/Well/Connection.hpp
opm/parser/eclipse/EclipseState/Schedule/Well/Well.hpp
opm/parser/eclipse/EclipseState/Schedule/Well/WellInjectionProperties.hpp
opm/parser/eclipse/EclipseState/Schedule/Well/Well2.hpp
opm/parser/eclipse/EclipseState/Schedule/Well/WList.hpp

6
opm/output/eclipse/AggregateMSWData.hpp
View File

@ -55,13 +55,13 @@ namespace Opm { namespace RestartIO { namespace Helpers {
std::vector<double> sofr;
std::vector<double> swfr;
std::vector<double> sgfr;
};
};
class AggregateMSWData
{
public:
explicit AggregateMSWData(const std::vector<int>& inteHead);
void captureDeclaredMSWData(const Opm::Schedule& sched,
const std::size_t rptStep,
const Opm::UnitSystem& units,

1
opm/output/eclipse/RestartIO.hpp
View File

@ -26,7 +26,6 @@
#include <opm/parser/eclipse/Units/UnitSystem.hpp>
#include <opm/parser/eclipse/EclipseState/Runspec.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/Well.hpp>
#include <opm/output/data/Cells.hpp>
#include <opm/output/data/Solution.hpp>

83
opm/output/eclipse/libECLRestart.hpp
View File

@ -36,7 +36,7 @@
#include <stdbool.h>
#include <time.h>
#include <sys/types.h>
#include <sys/types.h>
#include <sys/stat.h>
//#ifndef ERT_VECTOR_H
@ -49,7 +49,6 @@
//jal - comment on the following include to avoid duplication
#include <opm/parser/eclipse/Units/UnitSystem.hpp>
#include <opm/parser/eclipse/EclipseState/Runspec.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/Well.hpp>
#include <opm/output/data/Cells.hpp>
#include <opm/output/data/Solution.hpp>
@ -132,8 +131,8 @@ typedef enum {
ECL_PVT_M_UNITS = 4
} ert_ecl_unit_enum;
typedef enum { ECL_OTHER_FILE = 0 ,
ECL_RESTART_FILE = 1 ,
ECL_UNIFIED_RESTART_FILE = 2 ,
@ -188,11 +187,11 @@ typedef enum {
typedef enum {CTYPE_VOID_POINTER = 1,
CTYPE_INT_VALUE = 2,
CTYPE_DOUBLE_VALUE = 3,
CTYPE_FLOAT_VALUE = 4 ,
CTYPE_CHAR_VALUE = 5 ,
CTYPE_BOOL_VALUE = 6 ,
CTYPE_INT_VALUE = 2,
CTYPE_DOUBLE_VALUE = 3,
CTYPE_FLOAT_VALUE = 4 ,
CTYPE_CHAR_VALUE = 5 ,
CTYPE_BOOL_VALUE = 6 ,
CTYPE_SIZE_T_VALUE = 7 ,
CTYPE_INVALID = 100} node_ctype;
@ -341,10 +340,10 @@ typedef struct int_vector_struct int_vector_type;
//typedef int (int_ftype) (int);
typedef void * ( copyc_ftype ) (const void *);
typedef void ( free_ftype ) (void *);
struct ecl_rst_file_struct;
struct ecl_rst_file_struct;
typedef struct ecl_rst_file_struct ecl_rst_file_type;
struct ecl_file_view_struct;
struct ecl_file_view_struct;
typedef struct ecl_file_view_struct ecl_file_view_type;
struct ecl_type_struct {
@ -353,7 +352,7 @@ struct ecl_type_struct {
//orig
const ::Opm::RestartIO::ecl_type_enum type;
const size_t element_size;
};
};
typedef struct ecl_type_struct ecl_data_type;
@ -361,11 +360,11 @@ struct ecl_rst_file_struct {
fortio_type * fortio;
bool unified;
bool fmt_file;
};
};
//struct ecl_kw_struct;
//
//
struct ecl_kw_struct {
UTIL_TYPE_ID_DECLARATION;
int size;
@ -383,7 +382,7 @@ struct inv_map_struct;
typedef struct inv_map_struct inv_map_type;
struct size_t_vector_struct;
typedef struct size_t_vector_struct size_t_vector_type;
typedef size_t (size_t_ftype) (size_t);
typedef size_t (size_t_ftype) (size_t);
struct perm_vector_struct;
typedef struct perm_vector_struct perm_vector_type;
struct stringlist_struct;
@ -397,7 +396,7 @@ typedef struct stringlist_struct stringlist_type;
char * ecl_type_alloc_name(const ::Opm::RestartIO::ecl_data_type);
void ecl_rsthead_free( ::Opm::RestartIO::ecl_rsthead_type * rsthead );
::Opm::RestartIO::ecl_rsthead_type * ecl_rsthead_alloc_from_kw( int report_step , const ::Opm::RestartIO::ecl_kw_type * intehead_kw ,
::Opm::RestartIO::ecl_rsthead_type * ecl_rsthead_alloc_from_kw( int report_step , const ::Opm::RestartIO::ecl_kw_type * intehead_kw ,
const ::Opm::RestartIO::ecl_kw_type * doubhead_kw , const ::Opm::RestartIO::ecl_kw_type * logihead_kw );
Opm::RestartIO::ecl_rsthead_type * ecl_rsthead_alloc( const Opm::RestartIO::ecl_file_view_type * rst_file , int report_step);
Opm::RestartIO::ecl_rsthead_type * ecl_rsthead_alloc_empty(void);
@ -411,7 +410,7 @@ void ecl_util_set_date_values(time_t t , int * mday , int * month , int * year);
void util_set_date_values_utc(time_t t , int * mday , int * month , int * year);
void util_time_utc( time_t * t , struct tm * ts );
::Opm::RestartIO::ecl_data_type ecl_kw_get_data_type(const ::Opm::RestartIO::ecl_kw_type *);
int ecl_type_get_sizeof_iotype(const ::Opm::RestartIO::ecl_data_type ecl_type);
int ecl_type_get_sizeof_iotype(const ::Opm::RestartIO::ecl_data_type ecl_type);
void ecl_rsthead_fprintf( const ::Opm::RestartIO::ecl_rsthead_type * header , FILE * stream);
void ecl_rsthead_fprintf_struct( const ::Opm::RestartIO::ecl_rsthead_type * header , FILE * stream);
bool ecl_rsthead_equal( const ::Opm::RestartIO::ecl_rsthead_type * header1 , const Opm::RestartIO::ecl_rsthead_type * header2);
@ -448,7 +447,7 @@ void size_t_vector_iset(::Opm::RestartIO::size_t_vector_type * , int , si
void size_t_vector_permute(::Opm::RestartIO::size_t_vector_type * vector , const ::Opm::RestartIO::perm_vector_type * perm);
void size_t_vector_set_read_only( ::Opm::RestartIO::size_t_vector_type * vector , bool read_only);
int vector_append_owned_ref( ::Opm::RestartIO::vector_type * , const void * , ::Opm::RestartIO::free_ftype * del);
::Opm::RestartIO::size_t_vector_type * size_t_vector_alloc( int init_size , size_t );
::Opm::RestartIO::size_t_vector_type * size_t_vector_alloc( int init_size , size_t );
int util_stat(const char * filename , ::Opm::RestartIO::stat_type * stat_info);
/*
The two loose functions RestartIO::save() and RestartIO::load() can
@ -473,7 +472,7 @@ int util_stat(const char * filename , ::Opm::RestartIO::stat_type * sta
*/
const char * ecl_kw_get_header8(const ::Opm::RestartIO::ecl_kw_type *);
const char * ecl_kw_get_header(const ::Opm::RestartIO::ecl_kw_type * ecl_kw );
::Opm::RestartIO::ecl_rst_file_type * ecl_rst_file_open_read( const char * filename );
::Opm::RestartIO::ecl_rst_file_type * ecl_rst_file_open_write( const char * filename );
::Opm::RestartIO::ecl_rst_file_type * ecl_rst_file_open_append( const char * filename );
@ -566,9 +565,9 @@ const char * ecl_file_kw_get_header( const ::Opm::RestartIO::ecl_file_kw_type *
bool ecl_kw_fskip_data__( ::Opm::RestartIO::ecl_data_type, int, fortio_type *);
::Opm::RestartIO::ecl_data_type ecl_file_kw_get_data_type(const ::Opm::RestartIO::ecl_file_kw_type * file_kw);
::Opm::RestartIO::ecl_file_kw_type * ecl_file_view_iget_file_kw( const ::Opm::RestartIO::ecl_file_view_type * ecl_file_view , int global_index);
::Opm::RestartIO::ecl_file_view_type * ecl_file_get_restart_view( ::Opm::RestartIO::ecl_file_type * ecl_file ,
::Opm::RestartIO::ecl_file_view_type * ecl_file_get_restart_view( ::Opm::RestartIO::ecl_file_type * ecl_file ,
int input_index, int report_step , time_t sim_time, double sim_days);
::Opm::RestartIO::ecl_file_view_type * ecl_file_view_add_restart_view(::Opm::RestartIO::ecl_file_view_type * file_view ,
::Opm::RestartIO::ecl_file_view_type * ecl_file_view_add_restart_view(::Opm::RestartIO::ecl_file_view_type * file_view ,
int seqnum_index, int report_step , time_t sim_time, double sim_days);
::Opm::RestartIO::ecl_file_view_type * ecl_file_get_global_view( ::Opm::RestartIO::ecl_file_type * ecl_file );
::Opm::RestartIO::ecl_file_view_type * ecl_file_view_alloc( fortio_type * fortio , int * flags , ::Opm::RestartIO::inv_map_type * inv_map , bool owner );
@ -576,7 +575,7 @@ void ecl_file_view_add_kw( ::Opm::RestartIO::ecl_file_view_type * ecl_file_
void ecl_file_view_free( ::Opm::RestartIO::ecl_file_view_type * ecl_file_view );
void ecl_file_select_global( ::Opm::RestartIO::ecl_file_type * ecl_file );
void vector_free(::Opm::RestartIO::vector_type * );
void vector_clear(::Opm::RestartIO::vector_type * vector);
void vector_clear(::Opm::RestartIO::vector_type * vector);
void hash_free(::Opm::RestartIO::hash_type *);
void hash_sll_free(::Opm::RestartIO::hash_sll_type *);
void stringlist_free(::Opm::RestartIO::stringlist_type *);
@ -709,10 +708,10 @@ template<> struct ecl_type< char* >
template<> struct ecl_type< const char* >
{ static const ::Opm::RestartIO::ecl_type_enum type { ::Opm::RestartIO::ECL_CHAR_TYPE }; };
template <typename T>
class EclKW_ref {
public:
explicit EclKW_ref( ::Opm::RestartIO::ecl_kw_type * kw ) : m_kw( kw ) {
@ -917,23 +916,23 @@ struct deleter
F( arg );
}
};
template <typename T , void (*F)(T*)>
using ert_unique_ptr = std::unique_ptr<T, deleter<T,F> >;
template <typename T>
template <typename T>
T * ecl_kw_get_type_ptr (const ::Opm::RestartIO::ecl_kw_type * ecl_kw, ::Opm::RestartIO::ecl_type_enum ECL_TYPE)
{
{
/* implementation */
if (::Opm::RestartIO::ecl_kw_get_type(ecl_kw) != ECL_TYPE) \
util_abort("%s: Keyword: %s is wrong type - aborting \n",__func__ , ::Opm::RestartIO::ecl_kw_get_header8(ecl_kw)); \
return (T *) ecl_kw->data;
return (T *) ecl_kw->data;
}
template <typename T>
template <typename T>
T ecl_kw_iget_type (const ::Opm::RestartIO::ecl_kw_type * ecl_kw, ::Opm::RestartIO::ecl_type_enum ECL_TYPE, int i)
{
{
/* implementation */
T value; \
if (::Opm::RestartIO::ecl_kw_get_type(ecl_kw) != ECL_TYPE) \
@ -943,8 +942,8 @@ T ecl_kw_iget_type (const ::Opm::RestartIO::ecl_kw_type * ecl_kw, ::Opm::Restart
}
template <typename T>
void ecl_kw_scalar_set_type( ::Opm::RestartIO::ecl_kw_type * ecl_kw , ::Opm::RestartIO::ecl_type_enum ECL_TYPE , T value){
template <typename T>
void ecl_kw_scalar_set_type( ::Opm::RestartIO::ecl_kw_type * ecl_kw , ::Opm::RestartIO::ecl_type_enum ECL_TYPE , T value){
/* implementation */
if (::Opm::RestartIO::ecl_kw_get_type(ecl_kw) == ECL_TYPE) { \
T * data = static_cast<T *>(::Opm::RestartIO::ecl_kw_get_data_ref(ecl_kw)); \
@ -954,7 +953,7 @@ void ecl_kw_scalar_set_type( ::Opm::RestartIO::ecl_kw_type * ecl_kw , ::Opm::Res
} else util_abort("%s: wrong type\n",__func__); \
}
template <typename T>
template <typename T>
void ecl_kw_iset_type(::Opm::RestartIO::ecl_kw_type * ecl_kw, ::Opm::RestartIO::ecl_type_enum ECL_TYPE, int i, T value) { \
if (::Opm::RestartIO::ecl_kw_get_type(ecl_kw) != ECL_TYPE) \
util_abort("%s: Keyword: %s is wrong type - aborting \n",__func__ , ::Opm::RestartIO::ecl_kw_get_header8(ecl_kw)); \
@ -962,14 +961,14 @@ void ecl_kw_iset_type(::Opm::RestartIO::ecl_kw_type * ecl_kw, ::Opm::RestartIO::
} \
//#undef ECL_INT
#undef ECL_FLOAT
//#undef ECL_INT
#undef ECL_FLOAT
#undef ECL_DOUBLE
#undef ECL_BOOL
#undef ECL_BOOL
#undef ECL_CHAR
//#undef ECL_MESS
//#undef ECL_MESS
#undef ECL_STRING
#ifdef __cplusplus
//#undef ECL_INT
#define ECL_INT_2 ::Opm::RestartIO::ecl_data_type{::Opm::RestartIO::ECL_INT_TYPE, sizeof(int)}
@ -1003,7 +1002,7 @@ void ecl_kw_iset_type(::Opm::RestartIO::ecl_kw_type * ecl_kw, ::Opm::RestartIO::
#define util_abort(fmt , ...) ::Opm::RestartIO::util_abort__(__FILE__ , __func__ , __LINE__ , fmt , ##__VA_ARGS__)
#endif // _MSC_VER
}
// #ifndef ERT_ECL_ENDIAN_FLIP_H
@ -1017,11 +1016,11 @@ extern "C" {
This header file checks if the ECLIPSE endianness and the hardware
endianness are equal, and defines the macro ECL_ENDIAN_FLIP
accordingly.
All the ecl_xxx functions will use the ECL_ENDIAN_FLIP macro to
determine whether the endian flip should be performed. When opening
a fortio instance explicitly you can use the ECL_ENDIAN_FLIP macro
to get the endianness correct (for ECLIPSE usage that is).
to get the endianness correct (for ECLIPSE usage that is).
*/
#define ECLIPSE_BYTE_ORDER __BIG_ENDIAN // Alternatively: __LITTLE_ENDIAN

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

@ -90,17 +90,17 @@ class DynamicState {
}
std::vector<std::pair<std::size_t, T>> unique() {
std::vector<std::pair<std::size_t, T>> unique() const {
if (this->m_data.empty())
return {};
auto& current_value = this->m_data[0];
const auto * current_value = std::addressof(this->m_data[0]);
std::size_t current_index = 0;
std::vector<std::pair<std::size_t, T>> result{{current_index, current_value}};
std::vector<std::pair<std::size_t, T>> result{{current_index, *current_value}};
while (true) {
if (this->m_data[current_index] != current_value) {
current_value = this->m_data[current_index];
result.emplace_back(current_index, current_value);
if (this->m_data[current_index] != *current_value) {
current_value = std::addressof(this->m_data[current_index]);
result.emplace_back(current_index, *current_value);
}
current_index++;

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

@ -39,7 +39,6 @@
#include <opm/parser/eclipse/EclipseState/Schedule/RFTConfig.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/VFPInjTable.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/VFPProdTable.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/Well.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/Well2.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/WellTestConfig.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Action/Actions.hpp>
@ -115,6 +114,7 @@ namespace Opm
size_t numWells() const;
size_t numWells(size_t timestep) const;
bool hasWell(const std::string& wellName) const;
bool hasWell(const std::string& wellName, std::size_t timeStep) const;
std::vector<std::string> wellNames(const std::string& pattern, size_t timeStep, const std::vector<std::string>& matching_wells = {}) const;
std::vector<std::string> wellNames(const std::string& pattern) const;
@ -123,12 +123,11 @@ namespace Opm
void updateWell(std::shared_ptr<Well2> well, size_t reportStep);
const Well2& getWell2(const std::string& wellName, size_t timeStep) const;
std::vector< const Well2* > getChildWells2(const std::string& group_name, size_t timeStep, GroupWellQueryMode query_mode) const;
const Well* getWell(const std::string& wellName) const;
std::vector< const Well* > getOpenWells(size_t timeStep) const;
std::vector< const Well* > getWells() const;
std::vector< const Well* > getWells(size_t timeStep) const;
std::vector< const Well* > getChildWells(const std::string& group_name, size_t timeStep, GroupWellQueryMode query_mode) const;
const Well2& getWell2atEnd(const std::string& well_name) const;
std::vector<Well2> getWells2(size_t timeStep) const;
std::vector<Well2> getWells2atEnd() const;
std::vector<Well2> getChildWells2(const std::string& group_name, size_t timeStep, GroupWellQueryMode query_mode) const;
const OilVaporizationProperties& getOilVaporizationProperties(size_t timestep) const;
const WellTestConfig& wtestConfig(size_t timestep) const;
@ -169,7 +168,6 @@ namespace Opm
void applyAction(size_t reportStep, const ActionX& action, const std::vector<std::string>& matching_wells);
private:
TimeMap m_timeMap;
OrderedMap< std::string, Well > m_wells;
OrderedMap< std::string, Group > m_groups;
OrderedMap< std::string, DynamicState<std::shared_ptr<Well2>>> wells_static;
DynamicState< GroupTree > m_rootGroupTree;
@ -189,7 +187,6 @@ namespace Opm
Actions m_actions;
std::vector< Well* > getWells(const std::string& wellNamePattern, const std::vector<std::string>& matching_wells = {});
std::vector< Group* > getGroups(const std::string& groupNamePattern);
std::map<std::string,Events> well_events;

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

@ -1,239 +0,0 @@
/*
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 WELL_HPP_
#define WELL_HPP_
#include <memory>
#include <string>
#include <vector>
#include <opm/parser/eclipse/EclipseState/Runspec.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/DynamicState.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/WellConnections.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/WellEconProductionLimits.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/WellInjectionProperties.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/WellPolymerProperties.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/WellTracerProperties.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/WellProductionProperties.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/MSW/WellSegments.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
namespace Opm {
template< typename > class DynamicState;
class COnnection;
class WellConnections;
class Segment;
class WellSegments;
class TimeMap;
class EclipseGrid;
class Well {
public:
Well(const std::string& name, const size_t& seqIndex, int headI,
int headJ, double refDepth, double drainageRadius, Phase preferredPhase,
WellProducer::ControlModeEnum whist_ctl,
const TimeMap& timeMap, size_t creationTimeStep,
WellCompletion::CompletionOrderEnum completionOrdering = WellCompletion::TRACK,
bool allowCrossFlow = true, bool automaticShutIn = true);
const std::string& name() const;
const size_t& seqIndex() const;
std::size_t getTotNoConn() const;
bool hasBeenDefined(size_t timeStep) const;
const std::string getGroupName(size_t timeStep) const;
void setGroupName(size_t timeStep , const std::string& groupName);
WellCommon::StatusEnum getStatus(size_t timeStep) const;
bool setStatus(size_t timeStep, WellCommon::StatusEnum Status);
int getHeadI() const;
int getHeadJ() const;
int getHeadI( size_t timestep ) const;
int getHeadJ( size_t timestep ) const;
void setHeadI( size_t timestep, int I );
void setHeadJ( size_t timestep, int J );
double getRefDepth() const;
double getRefDepth( size_t timestep ) const;
void setRefDepth( size_t timestep, double );
double getDrainageRadius( size_t timestep ) const;
void setDrainageRadius( size_t timestep, double );
Phase getPreferredPhase() const;
bool isAvailableForGroupControl(size_t timeStep) const;
void setAvailableForGroupControl(size_t timeStep, bool isAvailableForGroupControl);
double getGuideRate(size_t timeStep) const;
void setGuideRate(size_t timeStep, double guideRate);
GuideRate::GuideRatePhaseEnum getGuideRatePhase(size_t timeStep) const;
void setGuideRatePhase(size_t timeStep, GuideRate::GuideRatePhaseEnum phase);
double getGuideRateScalingFactor(size_t timeStep) const;
void setGuideRateScalingFactor(size_t timeStep, double scalingFactor);
void setEfficiencyFactor (size_t timestep, double efficiencyFactor);
double getEfficiencyFactor (size_t timestep) const;
void switchToInjector( size_t timeStep);
void switchToProducer( size_t timeStep);
bool setProducer(size_t timeStep, bool producer);
bool isProducer(size_t timeStep) const;
bool isInjector(size_t timeStep) const;
void addWELSPECS(const DeckRecord& deckRecord);
/*
The getCompletions() function will return a map:
{
1 : [Connection, Connection],
2 : [Connection, Connection, Connecton],
-3 : [Connection]
-7 : [Connection]
}
The integer ID's correspond to the COMPLETION id given by the COMPLUMP
keyword. All positive id values come from COMPLUMP, whereas the
negative values are arbitrary negative id values for connections which
have not been lumped together in a completion. In the case of negative
id values the list of connections always has exactly one element.
*/
std::map<int, std::vector<Connection>> getCompletions(size_t time_step) const;
const WellConnections& getConnections(size_t timeStep) const;
const WellConnections& getConnections() const;
WellConnections getActiveConnections(size_t timeStep, const EclipseGrid& grid) const;
WellConnections * newWellConnections(size_t time_step);
void updateWellConnections(size_t time_step, WellConnections * new_set );
/* The rate of a given phase under the following assumptions:
* * Returns zero if production is requested for an injector (and vice
* versa)
* * If this is an injector and something else than the
* requested phase is injected, returns 0, i.e.
* water_injector.injection_rate( gas ) == 0
* * Mixed injection is not supported and always returns 0.
*/
double production_rate( Phase phase, size_t timestep ) const;
double injection_rate( Phase phase, size_t timestep ) const;
bool operator==(const Well&) const;
bool operator!=(const Well&) const;
bool setProductionProperties(size_t timeStep , const WellProductionProperties& properties);
WellProductionProperties getProductionPropertiesCopy(size_t timeStep) const;
const WellProductionProperties& getProductionProperties(size_t timeStep) const;
bool setInjectionProperties(size_t timeStep , const WellInjectionProperties& properties);
WellInjectionProperties getInjectionPropertiesCopy(size_t timeStep) const;
const WellInjectionProperties& getInjectionProperties(size_t timeStep) const;
bool setPolymerProperties(size_t timeStep , const WellPolymerProperties& properties);
WellPolymerProperties getPolymerPropertiesCopy(size_t timeStep) const;
const WellPolymerProperties& getPolymerProperties(size_t timeStep) const;
bool setTracerProperties(size_t timeStep , const WellTracerProperties& properties);
const WellTracerProperties& getTracerProperties(size_t timeStep) const;
bool setSolventFraction(size_t timeStep , const double fraction);
const double& getSolventFraction(size_t timeStep) const;
bool setEconProductionLimits(const size_t timeStep, const WellEconProductionLimits& productionlimits);
const WellEconProductionLimits& getEconProductionLimits(const size_t timeStep) const;
int findWellFirstOpen(int startTimeStep) const;
/*
Will return the report step when the well is created with
WELSPECS, actually opening the well might be later.
*/
size_t firstTimeStep( ) const;
static bool wellNameInWellNamePattern(const std::string& wellName, const std::string& wellNamePattern);
WellCompletion::CompletionOrderEnum getWellConnectionOrdering() const;
bool getAllowCrossFlow() const;
bool getAutomaticShutIn() const;
bool canOpen(size_t time_step) const;
// for multi-segment wells
bool isMultiSegment(size_t time_step) const;
const WellSegments& getWellSegments(size_t time_step) const;
void addWellSegments(size_t time_step, WellSegments new_segmentset);
void handleCOMPLUMP(const DeckRecord& record, size_t time_step);
void handleCOMPDAT(size_t time_step, const DeckRecord& record, const EclipseGrid& grid, const Eclipse3DProperties& eclipseProperties);
void handleCOMPSEGS(const DeckKeyword& keyword, const EclipseGrid& grid, size_t time_step);
void handleWELOPEN(const DeckRecord& record, size_t time_step, WellCompletion::StateEnum status);
void handleWPIMULT(const DeckRecord& record, size_t time_step);
void handleWELSEGS(const DeckKeyword& keyword, size_t time_step);
/*
Will remove all completions which are attached to inactive cells. Will
scan through all timesteps.
*/
void filterConnections(const EclipseGrid& grid);
private:
size_t m_creationTimeStep;
std::string m_name;
std::size_t m_seqIndex;
DynamicState< WellCommon::StatusEnum > m_status;
DynamicState< int > m_isAvailableForGroupControl;
DynamicState< double > m_guideRate;
DynamicState< GuideRate::GuideRatePhaseEnum > m_guideRatePhase;
DynamicState< double > m_guideRateScalingFactor;
DynamicState< double > m_efficiencyFactors;
DynamicState< int > m_isProducer;
DynamicState< std::shared_ptr<WellConnections> > m_completions;
DynamicState< WellProductionProperties > m_productionProperties;
DynamicState< WellInjectionProperties > m_injectionProperties;
DynamicState< WellPolymerProperties > m_polymerProperties;
DynamicState< WellEconProductionLimits > m_econproductionlimits;
DynamicState< double > m_solventFraction;
DynamicState< WellTracerProperties > m_tracerProperties;
DynamicState< std::string > m_groupName;
DynamicState< int > m_headI;
DynamicState< int > m_headJ;
DynamicState< double > m_refDepth;
DynamicState< double > m_drainageRadius;
Phase m_preferredPhase;
WellCompletion::CompletionOrderEnum m_comporder;
bool m_allowCrossFlow;
bool m_automaticShutIn;
// WELSEGS DATA - for mutli-segment wells
// flag indicating if the well is a multi-segment well
DynamicState< WellSegments > m_segmentset;
size_t timesteps;
};
}
#endif /* WELL_HPP_ */

18
opm/parser/eclipse/EclipseState/Schedule/Well/Well2.hpp
View File

@ -67,10 +67,12 @@ public:
GuideRate::GuideRatePhaseEnum getGuideRatePhase() const;
double getGuideRateScalingFactor() const;
bool hasBeenDefined(size_t timeStep) const;
std::size_t firstTimeStep() const;
bool predictionMode() const;
bool canOpen() const;
bool isProducer() const;
bool isInjector() const;
size_t seqIndex() const;
bool getAutomaticShutIn() const;
bool getAllowCrossFlow() const;
@ -92,6 +94,18 @@ public:
WellCommon::StatusEnum getStatus() const;
const std::string& groupName() const;
Phase getPreferredPhase() const;
/* The rate of a given phase under the following assumptions:
* * Returns zero if production is requested for an injector (and vice
* versa)
* * If this is an injector and something else than the
* requested phase is injected, returns 0, i.e.
* water_injector.injection_rate( gas ) == 0
* * Mixed injection is not supported and always returns 0.
*/
double production_rate( Phase phase) const;
double injection_rate( Phase phase) const;
static bool wellNameInWellNamePattern(const std::string& wellName, const std::string& wellNamePattern);
/*
The getCompletions() function will return a map:
@ -126,8 +140,6 @@ public:
bool updateEconLimits(std::shared_ptr<WellEconProductionLimits> econ_limits);
bool updateProduction(std::shared_ptr<WellProductionProperties> production);
bool updateInjection(std::shared_ptr<WellInjectionProperties> injection);
void switchToProducer();
void switchToInjector();
bool handleWELSEGS(const DeckKeyword& keyword);
bool handleCOMPSEGS(const DeckKeyword& keyword, const EclipseGrid& grid);
@ -136,6 +148,8 @@ public:
bool handleWPIMULT(const DeckRecord& record);
void filterConnections(const EclipseGrid& grid);
void switchToInjector();
void switchToProducer();
private:
std::string wname;
std::string group_name;

217
src/opm/output/eclipse/AggregateConnectionData.cpp
View File

@ -27,7 +27,6 @@
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/Well.hpp>
#include <opm/parser/eclipse/Units/UnitSystem.hpp>
@ -55,66 +54,65 @@ namespace {
std::map <std::size_t, const Opm::Connection*> mapSeqIndexToConnection(const Opm::WellConnections& conns)
{
// make seqIndex to Connection map
std::map <std::size_t, const Opm::Connection*> seqIndConnMap;
for (const auto & conn : conns) {
std::size_t sI = conn.getSeqIndex();
seqIndConnMap.insert(std::make_pair(sI, &conn));
}
return seqIndConnMap;
// make seqIndex to Connection map
std::map <std::size_t, const Opm::Connection*> seqIndConnMap;
for (const auto & conn : conns) {
std::size_t sI = conn.getSeqIndex();
seqIndConnMap.insert(std::make_pair(sI, &conn));
}
return seqIndConnMap;
}
std::map <std::size_t, const Opm::Connection*> mapCompSegSeqIndexToConnection(const Opm::WellConnections& conns)
{
// make CompSegSeqIndex to Connection map
std::map <std::size_t, const Opm::Connection*> cs_seqIndConnMap;
for (const auto & conn : conns) {
std::size_t sI = conn.getCompSegSeqIndex();
cs_seqIndConnMap.insert(std::make_pair(sI, &conn));
}
return cs_seqIndConnMap;
// make CompSegSeqIndex to Connection map
std::map <std::size_t, const Opm::Connection*> cs_seqIndConnMap;
for (const auto & conn : conns) {
std::size_t sI = conn.getCompSegSeqIndex();
cs_seqIndConnMap.insert(std::make_pair(sI, &conn));
}
return cs_seqIndConnMap;
}
template <class ConnOp>
void connectionLoop(const std::vector<const Opm::Well*>& wells,
const Opm::EclipseGrid& grid,
const std::size_t sim_step,
ConnOp&& connOp)
void connectionLoop(const std::vector<Opm::Well2>& wells,
const Opm::EclipseGrid& grid,
const std::size_t sim_step,
ConnOp&& connOp)
{
for (auto nWell = wells.size(), wellID = 0*nWell;
wellID < nWell; ++wellID)
{
const auto* well = wells[wellID];
if (well == nullptr) { continue; }
const auto& conns = well->getActiveConnections(sim_step, grid);
const int niSI = static_cast<int>(well->getTotNoConn());
std::map <std::size_t, const Opm::Connection*> sIToConn;
//Branch according to MSW well or not and
//sort active connections according to appropriate seqIndex
if (well->isMultiSegment(sim_step)) {
//sort connections according to input sequence in COMPSEGS
sIToConn = mapCompSegSeqIndexToConnection(conns);
} else
{
//sort connections according to input sequence in COMPDAT
sIToConn = mapSeqIndexToConnection(conns);
}
std::vector<const Opm::Connection*> connSI;
for (int iSI = 0; iSI < niSI; iSI++) {
const auto searchSI = sIToConn.find(static_cast<std::size_t>(iSI));
if (searchSI != sIToConn.end()) {
connSI.push_back(searchSI->second);
}
}
for (auto nConn = connSI.size(), connID = 0*nConn;
connID < nConn; ++connID)
{
connOp(*well, wellID, *(connSI[connID]), connID);
const auto& well = wells[wellID];
const auto& conn0 = well.getConnections();
const auto& conns = Opm::WellConnections( conn0, grid );
const int niSI = static_cast<int>(conn0.size());
std::map <std::size_t, const Opm::Connection*> sIToConn;
//Branch according to MSW well or not and
//sort active connections according to appropriate seqIndex
if (well.isMultiSegment()) {
//sort connections according to input sequence in COMPSEGS
sIToConn = mapCompSegSeqIndexToConnection(conns);
} else {
//sort connections according to input sequence in COMPDAT
sIToConn = mapSeqIndexToConnection(conns);
}
std::vector<const Opm::Connection*> connSI;
for (int iSI = 0; iSI < niSI; iSI++) {
const auto searchSI = sIToConn.find(static_cast<std::size_t>(iSI));
if (searchSI != sIToConn.end()) {
connSI.push_back(searchSI->second);
}
}
for (auto nConn = connSI.size(), connID = 0*nConn;
connID < nConn; ++connID)
{
connOp(well, wellID, *(connSI[connID]), connID);
}
}
}
}
namespace IConn {
@ -130,8 +128,8 @@ namespace {
return WM {
WM::NumRows { numWells(inteHead) },
WM::NumCols { maxNumConn(inteHead) },
WM::WindowSize{ entriesPerConn(inteHead) }
WM::NumCols { maxNumConn(inteHead) },
WM::WindowSize{ entriesPerConn(inteHead) }
};
}
@ -158,8 +156,8 @@ namespace {
// Don't support differing sat-func tables for
// draining and imbibition curves at connections.
iConn[Ix::Imbibition] = iConn[Ix::Drainage];
//complnum is(1 too large): 1 - based while icon is 0 - based?
//complnum is(1 too large): 1 - based while icon is 0 - based?
iConn[Ix::ComplNum] = std::abs(conn.complnum());
//iConn[Ix::ComplNum] = iConn[Ix::SeqIndex];
@ -182,8 +180,8 @@ namespace {
return WM {
WM::NumRows { numWells(inteHead) },
WM::NumCols { maxNumConn(inteHead) },
WM::WindowSize{ entriesPerConn(inteHead) }
WM::NumCols { maxNumConn(inteHead) },
WM::WindowSize{ entriesPerConn(inteHead) }
};
}
@ -196,18 +194,18 @@ namespace {
using Ix = ::Opm::RestartIO::Helpers::VectorItems::SConn::index;
auto scprop = [&units](const M u, const double x) -> float
{
return static_cast<float>(units.from_si(u, x));
};
{
return static_cast<float>(units.from_si(u, x));
};
sConn[Ix::ConnTrans] =
scprop(M::transmissibility, conn.CF());
sConn[Ix::ConnTrans] =
scprop(M::transmissibility, conn.CF());
sConn[Ix::Depth] = scprop(M::length, conn.depth());
sConn[Ix::Diameter] = scprop(M::length, 2*conn.rw());
sConn[Ix::EffectiveKH] =
scprop(M::effective_Kh, conn.Kh());
sConn[Ix::EffectiveKH] =
scprop(M::effective_Kh, conn.Kh());
sConn[Ix::item12] = sConn[Ix::ConnTrans];
@ -232,8 +230,8 @@ namespace {
return WM {
WM::NumRows { numWells(inteHead) },
WM::NumCols { maxNumConn(inteHead) },
WM::WindowSize{ entriesPerConn(inteHead) }
WM::NumCols { maxNumConn(inteHead) },
WM::WindowSize{ entriesPerConn(inteHead) }
};
}
@ -303,57 +301,60 @@ captureDeclaredConnData(const Schedule& sched,
const data::WellRates& xw,
const std::size_t sim_step)
{
const auto& wells = sched.getWells(sim_step);
const auto& wells = sched.getWells2(sim_step);
//
// construct a composite vector of connection objects holding
// rates for all open connectons
//
std::map<std::string, std::vector<const Opm::data::Connection*> > allWellConnections;
for (const auto wl : wells) {
const auto& conns = wl->getActiveConnections(sim_step, grid);
std::vector<const Opm::data::Connection*> initConn (conns.size(), nullptr);
allWellConnections.insert(std::make_pair(wl->name(), initConn));
const auto it = allWellConnections.find(wl->name());
const auto xr = xw.find(wl->name());
size_t rCInd = 0;
if ((it != allWellConnections.end()) && (xr != xw.end())) {
for (auto nConn = conns.size(), connID = 0*nConn; connID < nConn; connID++) {
//
// WellRates connections are only defined for OPEN connections
if ((conns[connID].state() == Opm::WellCompletion::StateEnum::OPEN) &&
(rCInd < xr->second.connections.size())) {
it->second[connID] = &(xr->second.connections[rCInd]);
rCInd+= 1;
}
else if ((conns[connID].state() == Opm::WellCompletion::StateEnum::OPEN) && (rCInd >= xr->second.connections.size())) {
throw std::invalid_argument {
"Inconsistent number of open connections I in vector<Opm::data::Connection*> (" +
std::to_string(xr->second.connections.size()) + ") in Well " + wl->name()
};
}
}
}
}
connectionLoop(wells, grid, sim_step, [&units, &allWellConnections, this]
(const Well& well, const std::size_t wellID,
const Connection& conn, const std::size_t connID) -> void
{
auto ic = this->iConn_(wellID, connID);
auto sc = this->sConn_(wellID, connID);
for (const auto& wl : wells) {
const auto& conn0 = wl.getConnections();
const auto conns = WellConnections(conn0, grid);
std::vector<const Opm::data::Connection*> initConn (conns.size(), nullptr);
IConn::staticContrib(conn, connID, ic);
SConn::staticContrib(conn, units, sc);
allWellConnections.insert(std::make_pair(wl.name(), initConn));
const auto it = allWellConnections.find(wl.name());
const auto xr = xw.find(wl.name());
size_t rCInd = 0;
if ((it != allWellConnections.end()) && (xr != xw.end())) {
for (auto nConn = conns.size(), connID = 0*nConn; connID < nConn; connID++) {
//
// WellRates connections are only defined for OPEN connections
if ((conns[connID].state() == Opm::WellCompletion::StateEnum::OPEN) &&
(rCInd < xr->second.connections.size())) {
it->second[connID] = &(xr->second.connections[rCInd]);
rCInd+= 1;
}
else if ((conns[connID].state() == Opm::WellCompletion::StateEnum::OPEN) && (rCInd >= xr->second.connections.size())) {
throw std::invalid_argument {
"Inconsistent number of open connections I in vector<Opm::data::Connection*> (" +
std::to_string(xr->second.connections.size()) + ") in Well " + wl.name()
};
auto xi = allWellConnections.find(well.name());
if ((xi != allWellConnections.end()) &&
(connID < xi->second.size()))
//(connID < xi->second.connections.size()))
{
auto xc = this->xConn_(wellID, connID);
//XConn::dynamicContrib(xi->second.connections[connID],
if (xi->second[connID]) XConn::dynamicContrib(*(xi->second[connID]), units, xc);
}
}
}
});
}
connectionLoop(wells, grid, sim_step, [&units, &allWellConnections, this]
(const Well2& well, const std::size_t wellID,
const Connection& conn, const std::size_t connID) -> void
{
auto ic = this->iConn_(wellID, connID);
auto sc = this->sConn_(wellID, connID);
IConn::staticContrib(conn, connID, ic);
SConn::staticContrib(conn, units, sc);
auto xi = allWellConnections.find(well.name());
if ((xi != allWellConnections.end()) &&
(connID < xi->second.size()))
//(connID < xi->second.connections.size()))
{
auto xc = this->xConn_(wellID, connID);
//XConn::dynamicContrib(xi->second.connections[connID],
if (xi->second[connID]) XConn::dynamicContrib(*(xi->second[connID]), units, xc);
}
});
}

123
src/opm/output/eclipse/AggregateGroupData.cpp
View File

@ -26,7 +26,6 @@
#include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/GroupTree.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/Well.hpp>
#include <algorithm>
#include <cstddef>
@ -98,7 +97,7 @@ namespace {
for (const auto* group : groups) {
int ind = (group->name() == "FIELD")
? ngmaxz(inteHead)-1 : group->seqIndex()-1;
const std::pair<size_t, const Opm::Group*> groupPair = std::make_pair(static_cast<size_t>(ind), group);
const std::pair<size_t, const Opm::Group*> groupPair = std::make_pair(static_cast<size_t>(ind), group);
indexGroupMap.insert(groupPair);
}
return indexGroupMap;
@ -112,7 +111,7 @@ namespace {
for (const auto* group : groups) {
int ind = (group->name() == "FIELD")
? ngmaxz(inteHead)-1 : group->seqIndex()-1;
std::pair<const std::string, size_t> groupPair = std::make_pair(group->name(), ind);
std::pair<const std::string, size_t> groupPair = std::make_pair(group->name(), ind);
groupIndexMap.insert(groupPair);
}
return groupIndexMap;
@ -174,72 +173,72 @@ namespace {
IGrpArray& iGrp,
const std::vector<int>& inteHead)
{
// find the number of wells or child groups belonging to a group and store in
// location nwgmax +1 in the iGrp array
// find the number of wells or child groups belonging to a group and store in
// location nwgmax +1 in the iGrp array
const auto childGroups = sched.getChildGroups(group.name(), simStep);
const auto childWells = sched.getChildWells(group.name(), simStep, Opm::GroupWellQueryMode::Immediate);
const auto groupMapNameIndex = currentGroupMapNameIndex(sched, simStep, inteHead);
const auto mapIndexGroup = currentGroupMapIndexGroup(sched, simStep, inteHead);
if ((childGroups.size() != 0) && (childWells.size()!=0))
throw std::invalid_argument("group has both wells and child groups" + group.name());
const auto childGroups = sched.getChildGroups(group.name(), simStep);
const auto childWells = sched.getChildWells2(group.name(), simStep, Opm::GroupWellQueryMode::Immediate);
const auto groupMapNameIndex = currentGroupMapNameIndex(sched, simStep, inteHead);
const auto mapIndexGroup = currentGroupMapIndexGroup(sched, simStep, inteHead);
if ((childGroups.size() != 0) && (childWells.size()!=0))
throw std::invalid_argument("group has both wells and child groups" + group.name());
int igrpCount = 0;
if (childWells.size() != 0) {
//group has child wells
//store the well number (sequence index) in iGrp according to the sequence they are defined
for ( auto it = childWells.begin() ; it != childWells.end(); it++) {
iGrp[igrpCount] = (*it)->seqIndex()+1;
igrpCount+=1;
}
}
else if (childGroups.size() != 0) {
//group has child groups
//The field group always has seqIndex = 0 because it is always defined first
//Hence the all groups except the Field group uses the seqIndex assigned
//iGrp contains the child groups in ascending group sequence index
std::vector<size_t> childGroupIndex;
Opm::RestartIO::Helpers::groupMaps groupMap;
groupMap.currentGrpTreeNameSeqIndMap(sched, simStep, groupMapNameIndex,mapIndexGroup);
const auto indGroupMap = groupMap.indexGroupMap();
const auto gNameIndMap = groupMap.groupNameIndexMap();
for (auto* grp : childGroups) {
auto groupName = grp->name();
auto searchGTName = gNameIndMap.find(groupName);
if (searchGTName != gNameIndMap.end()) {
childGroupIndex.push_back(searchGTName->second);
}
else {
throw std::invalid_argument( "Invalid group name" );
}
}
std::sort(childGroupIndex.begin(), childGroupIndex.end());
for (auto groupTreeIndex : childGroupIndex) {
auto searchGTIterator = indGroupMap.find(groupTreeIndex);
if (searchGTIterator != indGroupMap.end()) {
auto gname = (searchGTIterator->second)->name();
auto gSeqNoItr = groupMapNameIndex.find(gname);
if (gSeqNoItr != groupMapNameIndex.end()) {
iGrp[igrpCount] = (gSeqNoItr->second) + 1;
igrpCount+=1;
}
else {
std::cout << "AggregateGroupData, ChildGroups - Group name: groupMapNameIndex: " << gSeqNoItr->first << std::endl;
throw std::invalid_argument( "Invalid group name" );
}
}
else {
std::cout << "AggregateGroupData, ChildGroups - GroupTreeIndex: " << groupTreeIndex << std::endl;
throw std::invalid_argument( "Invalid GroupTree index" );
}
}
}
if (childWells.size() != 0) {
//group has child wells
//store the well number (sequence index) in iGrp according to the sequence they are defined
for ( const auto& well : childWells) {
iGrp[igrpCount] = well.seqIndex()+1;
igrpCount+=1;
}
}
else if (childGroups.size() != 0) {
//group has child groups
//The field group always has seqIndex = 0 because it is always defined first
//Hence the all groups except the Field group uses the seqIndex assigned
//iGrp contains the child groups in ascending group sequence index
std::vector<size_t> childGroupIndex;
Opm::RestartIO::Helpers::groupMaps groupMap;
groupMap.currentGrpTreeNameSeqIndMap(sched, simStep, groupMapNameIndex,mapIndexGroup);
const auto indGroupMap = groupMap.indexGroupMap();
const auto gNameIndMap = groupMap.groupNameIndexMap();
for (auto* grp : childGroups) {
auto groupName = grp->name();
auto searchGTName = gNameIndMap.find(groupName);
if (searchGTName != gNameIndMap.end()) {
childGroupIndex.push_back(searchGTName->second);
}
else {
throw std::invalid_argument( "Invalid group name" );
}
}
std::sort(childGroupIndex.begin(), childGroupIndex.end());
for (auto groupTreeIndex : childGroupIndex) {
auto searchGTIterator = indGroupMap.find(groupTreeIndex);
if (searchGTIterator != indGroupMap.end()) {
auto gname = (searchGTIterator->second)->name();
auto gSeqNoItr = groupMapNameIndex.find(gname);
if (gSeqNoItr != groupMapNameIndex.end()) {
iGrp[igrpCount] = (gSeqNoItr->second) + 1;
igrpCount+=1;
}
else {
std::cout << "AggregateGroupData, ChildGroups - Group name: groupMapNameIndex: " << gSeqNoItr->first << std::endl;
throw std::invalid_argument( "Invalid group name" );
}
}
else {
std::cout << "AggregateGroupData, ChildGroups - GroupTreeIndex: " << groupTreeIndex << std::endl;
throw std::invalid_argument( "Invalid GroupTree index" );
}
}
}
//assign the number of child wells or child groups to
// location nwgmax
iGrp[nwgmax] = (childGroups.size() == 0)
? childWells.size() : childGroups.size();
// find the group type (well group (type 0) or node group (type 1) and store the type in
// find the group type (well group (type 0) or node group (type 1) and store the type in
// location nwgmax + 26
const auto grpType = groupType(sched, group, simStep);
iGrp[nwgmax+26] = grpType;
@ -248,7 +247,7 @@ namespace {
//location nwgmax + 27
const auto grpLevel = currentGroupLevel(sched, group, simStep);
iGrp[nwgmax+27] = grpLevel;
// set values for group probably connected to GCONPROD settings
//
if (group.name() != "FIELD")

1001
src/opm/output/eclipse/AggregateMSWData.cpp
View File

File diff suppressed because it is too large Load Diff

241
src/opm/output/eclipse/AggregateWellData.cpp
View File

@ -29,7 +29,6 @@
#include <opm/parser/eclipse/EclipseState/Schedule/SummaryState.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/Well.hpp>
#include <opm/parser/eclipse/Units/UnitSystem.hpp>
#include <opm/parser/eclipse/Units/Units.hpp>
@ -73,17 +72,15 @@ namespace {
}
template <typename WellOp>
void wellLoop(const std::vector<const Opm::Well*>& wells,
WellOp&& wellOp)
void wellLoop(const std::vector<Opm::Well2>& wells,
WellOp&& wellOp)
{
for (auto nWell = wells.size(), wellID = 0*nWell;
wellID < nWell; ++wellID)
{
const auto* well = wells[wellID];
const auto& well = wells[wellID];
if (well == nullptr) { continue; }
wellOp(*well, wellID);
wellOp(well, wellID);
}
}
@ -112,7 +109,7 @@ namespace {
for (const auto* group : groups) {
int ind = (group->name() == "FIELD")
? inteHead[VI::intehead::NGMAXZ]-1 : group->seqIndex()-1;
std::pair<const std::string, size_t> groupPair = std::make_pair(group->name(), ind);
std::pair<const std::string, size_t> groupPair = std::make_pair(group->name(), ind);
groupIndexMap.insert(groupPair);
}
return groupIndexMap;
@ -133,20 +130,20 @@ namespace {
return ind;
}
int wellType(const Opm::Well& well,
int wellType(const Opm::Well2& well,
const std::size_t sim_step)
{
using WTypeVal = ::Opm::RestartIO::Helpers::
VectorItems::IWell::Value::WellType;
if (well.isProducer(sim_step)) {
if (well.isProducer()) {
return WTypeVal::Producer;
}
using IType = ::Opm::WellInjector::TypeEnum;
const auto itype = well
.getInjectionProperties(sim_step).injectorType;
.getInjectionProperties().injectorType;
switch (itype) {
case IType::OIL: return WTypeVal::OilInj;
@ -156,25 +153,25 @@ namespace {
}
}
int wellVFPTab(const Opm::Well& well,
int wellVFPTab(const Opm::Well2& well,
const std::size_t sim_step)
{
if (well.isInjector(sim_step)) {
return well.getInjectionProperties(sim_step).VFPTableNumber;
if (well.isInjector()) {
return well.getInjectionProperties().VFPTableNumber;
}
return well.getProductionProperties(sim_step).VFPTableNumber;
return well.getProductionProperties().VFPTableNumber;
}
int ctrlMode(const Opm::Well& well,
int ctrlMode(const Opm::Well2& well,
const std::size_t sim_step)
{
using WMCtrlVal = ::Opm::RestartIO::Helpers::
VectorItems::IWell::Value::WellCtrlMode;
if (well.isInjector(sim_step)) {
if (well.isInjector()) {
const auto& prop = well
.getInjectionProperties(sim_step);
.getInjectionProperties();
const auto wmctl = prop.controlMode;
const auto wtype = prop.injectorType;
@ -200,7 +197,7 @@ namespace {
default:
{
const auto stat = well.getStatus(sim_step);
const auto stat = well.getStatus();
using WStat = ::Opm::WellCommon::StatusEnum;
@ -211,9 +208,9 @@ namespace {
return WMCtrlVal::WMCtlUnk;
}
}
else if (well.isProducer(sim_step)) {
else if (well.isProducer()) {
const auto& prop = well
.getProductionProperties(sim_step);
.getProductionProperties();
using CMode = ::Opm::WellProducer::ControlModeEnum;
@ -230,7 +227,7 @@ namespace {
default:
{
const auto stat = well.getStatus(sim_step);
const auto stat = well.getStatus();
using WStat = ::Opm::WellCommon::StatusEnum;
@ -245,7 +242,7 @@ namespace {
return WMCtrlVal::WMCtlUnk;
}
int compOrder(const Opm::Well& well)
int compOrder(const Opm::Well2& well)
{
using WCO = ::Opm::WellCompletion::CompletionOrderEnum;
using COVal = ::Opm::RestartIO::Helpers::
@ -261,26 +258,26 @@ namespace {
}
template <class IWellArray>
void staticContrib(const Opm::Well& well,
void staticContrib(const Opm::Well2& well,
const std::size_t msWellID,
const std::map <const std::string, size_t>& GroupMapNameInd,
/*const std::vector<std::string>& groupNames,*/
/*const std::vector<std::string>& groupNames,*/
const int /* maxGroups */,
const std::size_t sim_step,
IWellArray& iWell)
{
using Ix = ::Opm::RestartIO::Helpers::VectorItems::IWell::index;
iWell[Ix::IHead] = well.getHeadI(sim_step) + 1;
iWell[Ix::JHead] = well.getHeadJ(sim_step) + 1;
iWell[Ix::IHead] = well.getHeadI() + 1;
iWell[Ix::JHead] = well.getHeadJ() + 1;
// Connections
{
const auto& conn = well.getConnections(sim_step);
const auto& conn = well.getConnections();
iWell[Ix::NConn] = static_cast<int>(conn.size());
if (well.isMultiSegment(sim_step)) {
if (well.isMultiSegment()) {
// Set top and bottom connections to zero for multi
// segment wells
iWell[Ix::FirstK] = 0;
@ -296,8 +293,7 @@ namespace {
}
iWell[Ix::Group] =
groupIndex(trim(well.getGroupName(sim_step)),
GroupMapNameInd);
groupIndex(trim(well.groupName()), GroupMapNameInd);
iWell[Ix::WType] = wellType (well, sim_step);
iWell[Ix::VFPTab] = wellVFPTab(well, sim_step);
@ -317,11 +313,11 @@ namespace {
iWell[Ix::ActWCtrl] = ctrlMode(well, sim_step);
const auto isPred =
(well.isProducer(sim_step) &&
well.getProductionProperties(sim_step).predictionMode)
(well.isProducer() &&
well.getProductionProperties().predictionMode)
||
(well.isInjector(sim_step) &&
well.getInjectionProperties(sim_step).predictionMode);
(well.isInjector() &&
well.getInjectionProperties().predictionMode);
if (isPred) {
// Well in prediction mode (WCONPROD, WCONINJE). Assign
@ -339,44 +335,44 @@ namespace {
// Multi-segmented well information
iWell[Ix::MsWID] = 0; // MS Well ID (0 or 1..#MS wells)
iWell[Ix::NWseg] = 0; // Number of well segments
if (well.isMultiSegment(sim_step)) {
if (well.isMultiSegment()) {
iWell[Ix::MsWID] = static_cast<int>(msWellID);
iWell[Ix::NWseg] =
well.getWellSegments(sim_step).size();
well.getSegments().size();
}
iWell[Ix::CompOrd] = compOrder(well);
}
template <class IWellArray>
void dynamicContribShut(IWellArray& iWell)
{
using Ix = ::Opm::RestartIO::Helpers::VectorItems::IWell::index;
iWell[Ix::item9 ] = -1000;
iWell[Ix::item11] = -1000;
}
template <class IWellArray>
void dynamicContribOpen(const Opm::data::Well& xw,
IWellArray& iWell)
{
using Ix = ::Opm::RestartIO::Helpers::VectorItems::IWell::index;
const auto any_flowing_conn =
std::any_of(std::begin(xw.connections),
std::end (xw.connections),
[](const Opm::data::Connection& c)
template <class IWellArray>
void dynamicContribShut(IWellArray& iWell)
{
return c.rates.any();
});
using Ix = ::Opm::RestartIO::Helpers::VectorItems::IWell::index;
iWell[Ix::item9] = any_flowing_conn
? iWell[Ix::ActWCtrl] : -1;
iWell[Ix::item9 ] = -1000;
iWell[Ix::item11] = -1000;
}
iWell[Ix::item11] = 1;
}
} // IWell
template <class IWellArray>
void dynamicContribOpen(const Opm::data::Well& xw,
IWellArray& iWell)
{
using Ix = ::Opm::RestartIO::Helpers::VectorItems::IWell::index;
const auto any_flowing_conn =
std::any_of(std::begin(xw.connections),
std::end (xw.connections),
[](const Opm::data::Connection& c)
{
return c.rates.any();
});
iWell[Ix::item9] = any_flowing_conn
? iWell[Ix::ActWCtrl] : -1;
iWell[Ix::item11] = 1;
}
} // IWell
namespace SWell {
std::size_t entriesPerWell(const std::vector<int>& inteHead)
@ -387,19 +383,17 @@ namespace {
return inteHead[VI::intehead::NSWELZ];
}
float datumDepth(const Opm::Well& well,
const std::size_t sim_step)
float datumDepth(const Opm::Well2& well)
{
if (well.isMultiSegment(sim_step)) {
if (well.isMultiSegment()) {
// Datum depth for multi-segment wells is
// depth of top-most segment.
return well.getWellSegments(sim_step)
.depthTopSegment();
return well.getSegments().depthTopSegment();
}
// Not a multi-segment well--i.e., this is a regular
// well. Use well's reference depth.
return well.getRefDepth(sim_step);
return well.getRefDepth();
}
Opm::RestartIO::Helpers::WindowedArray<float>
@ -463,7 +457,7 @@ namespace {
}
template <class SWellArray>
void staticContrib(const Opm::Well& well,
void staticContrib(const Opm::Well2& well,
const Opm::UnitSystem& units,
const std::size_t sim_step,
const ::Opm::SummaryState& smry,
@ -479,8 +473,8 @@ namespace {
assignDefaultSWell(sWell);
if (well.isProducer(sim_step)) {
const auto& pp = well.getProductionProperties(sim_step);
if (well.isProducer()) {
const auto& pp = well.getProductionProperties();
const auto& predMode = pp.predictionMode;
if ((pp.OilRate != 0.0) || (!predMode)) {
@ -531,8 +525,8 @@ namespace {
: swprop(M::pressure, 1.0*::Opm::unit::atm);
sWell[Ix::HistBHPTarget] = sWell[Ix::BHPTarget];
}
else if (well.isInjector(sim_step)) {
const auto& ip = well.getInjectionProperties(sim_step);
else if (well.isInjector()) {
const auto& ip = well.getInjectionProperties();
using IP = ::Opm::WellInjector::ControlModeEnum;
using IT = ::Opm::WellInjector::TypeEnum;
@ -569,8 +563,7 @@ namespace {
sWell[Ix::HistBHPTarget] = sWell[Ix::BHPTarget];
}
sWell[Ix::DatumDepth] =
swprop(M::length, datumDepth(well, sim_step));
sWell[Ix::DatumDepth] = swprop(M::length, datumDepth(well));
}
} // SWell
@ -595,7 +588,7 @@ namespace {
}
template <class XWellArray>
void staticContrib(const ::Opm::Well& well,
void staticContrib(const ::Opm::Well2& well,
const Opm::UnitSystem& units,
const std::size_t sim_step,
XWellArray& xWell)
@ -603,9 +596,9 @@ namespace {
using M = ::Opm::UnitSystem::measure;
using Ix = ::Opm::RestartIO::Helpers::VectorItems::XWell::index;
const auto bhpTarget = well.isInjector(sim_step)
? well.getInjectionProperties (sim_step).BHPLimit
: well.getProductionProperties(sim_step).BHPLimit;
const auto bhpTarget = well.isInjector()
? well.getInjectionProperties ().BHPLimit
: well.getProductionProperties().BHPLimit;
xWell[Ix::BHPTarget] = units.from_si(M::pressure, bhpTarget);
}
@ -728,19 +721,19 @@ namespace {
}
template <class XWellArray>
void dynamicContrib(const ::Opm::Well& well,
void dynamicContrib(const ::Opm::Well2& well,
const ::Opm::SummaryState& smry,
const std::size_t sim_step,
XWellArray& xWell)
{
if (well.isProducer(sim_step)) {
if (well.isProducer()) {
assignProducer(well.name(), smry, xWell);
}
else if (well.isInjector(sim_step)) {
else if (well.isInjector()) {
using IType = ::Opm::WellInjector::TypeEnum;
const auto itype = well
.getInjectionProperties(sim_step).injectorType;
.getInjectionProperties().injectorType;
switch (itype) {
case IType::OIL:
@ -789,7 +782,7 @@ namespace {
}
template <class ZWellArray>
void staticContrib(const Opm::Well& well, ZWellArray& zWell)
void staticContrib(const Opm::Well2& well, ZWellArray& zWell)
{
using Ix = ::Opm::RestartIO::Helpers::VectorItems::ZWell::index;
@ -816,54 +809,54 @@ Opm::RestartIO::Helpers::AggregateWellData::
captureDeclaredWellData(const Schedule& sched,
const UnitSystem& units,
const std::size_t sim_step,
const ::Opm::SummaryState& smry,
const std::vector<int>& inteHead)
const ::Opm::SummaryState& smry,
const std::vector<int>& inteHead)
{
const auto& wells = sched.getWells(sim_step);
const auto& wells = sched.getWells2(sim_step);
// Static contributions to IWEL array.
{
//const auto grpNames = groupNames(sched.getGroups());
const auto groupMapNameIndex = IWell::currentGroupMapNameIndex(sched, sim_step, inteHead);
const auto groupMapNameIndex = IWell::currentGroupMapNameIndex(sched, sim_step, inteHead);
auto msWellID = std::size_t{0};
wellLoop(wells, [&groupMapNameIndex, &msWellID, sim_step, this]
(const Well& well, const std::size_t wellID) -> void
{
msWellID += well.isMultiSegment(sim_step); // 1-based index.
auto iw = this->iWell_[wellID];
(const Well2& well, const std::size_t wellID) -> void
{
msWellID += well.isMultiSegment(); // 1-based index.
auto iw = this->iWell_[wellID];
IWell::staticContrib(well, msWellID, groupMapNameIndex,
this->nWGMax_, sim_step, iw);
});
IWell::staticContrib(well, msWellID, groupMapNameIndex,
this->nWGMax_, sim_step, iw);
});
}
// Static contributions to SWEL array.
wellLoop(wells, [&units, sim_step, &smry, this]
(const Well& well, const std::size_t wellID) -> void
{
auto sw = this->sWell_[wellID];
(const Well2& well, const std::size_t wellID) -> void
{
auto sw = this->sWell_[wellID];
SWell::staticContrib(well, units, sim_step, smry, sw);
});
SWell::staticContrib(well, units, sim_step, smry, sw);
});
// Static contributions to XWEL array.
wellLoop(wells, [&units, sim_step, this]
(const Well& well, const std::size_t wellID) -> void
{
auto xw = this->xWell_[wellID];
(const Well2& well, const std::size_t wellID) -> void
{
auto xw = this->xWell_[wellID];
XWell::staticContrib(well, units, sim_step, xw);
});
XWell::staticContrib(well, units, sim_step, xw);
});
// Static contributions to ZWEL array.
wellLoop(wells,
[this](const Well& well, const std::size_t wellID) -> void
{
auto zw = this->zWell_[wellID];
[this](const Well2& well, const std::size_t wellID) -> void
{
auto zw = this->zWell_[wellID];
ZWell::staticContrib(well, zw);
});
ZWell::staticContrib(well, zw);
});
}
// ---------------------------------------------------------------------
@ -875,26 +868,26 @@ captureDynamicWellData(const Schedule& sched,
const Opm::data::WellRates& xw,
const ::Opm::SummaryState& smry)
{
const auto& wells = sched.getWells(sim_step);
const auto& wells = sched.getWells2(sim_step);
// Dynamic contributions to IWEL array.
wellLoop(wells, [this, &xw]
(const Well& well, const std::size_t wellID) -> void
{
auto iWell = this->iWell_[wellID];
(const Well2& well, const std::size_t wellID) -> void
{
auto iWell = this->iWell_[wellID];
auto i = xw.find(well.name());
if ((i == std::end(xw)) || !i->second.flowing()) {
IWell::dynamicContribShut(iWell);
}
else {
IWell::dynamicContribOpen(i->second, iWell);
}
});
auto i = xw.find(well.name());
if ((i == std::end(xw)) || !i->second.flowing()) {
IWell::dynamicContribShut(iWell);
}
else {
IWell::dynamicContribOpen(i->second, iWell);
}
});
// Dynamic contributions to XWEL array.
wellLoop(wells, [this, sim_step, &smry]
(const Well& well, const std::size_t wellID) -> void
(const Well2& well, const std::size_t wellID) -> void
{
auto xw = this->xWell_[wellID];

10
src/opm/output/eclipse/CreateInteHead.cpp
View File

@ -45,8 +45,8 @@ namespace {
{
auto ncwmax = 0;
for (const auto* well : sched.getWells(lookup_step)) {
const auto ncw = well->getConnections().size();
for (const auto& well : sched.getWells2(lookup_step)) {
const auto ncw = well.getConnections().size();
ncwmax = std::max(ncwmax, static_cast<int>(ncw));
}
@ -188,13 +188,13 @@ namespace {
{
const auto& wsd = rspec.wellSegmentDimensions();
const auto& sched_wells = sched.getWells(lookup_step);
const auto& sched_wells = sched.getWells2(lookup_step);
const auto nsegwl =
std::count_if(std::begin(sched_wells), std::end(sched_wells),
[lookup_step](const Opm::Well* wellPtr)
[lookup_step](const Opm::Well2& well)
{
return wellPtr->isMultiSegment(lookup_step);
return well.isMultiSegment();
});
const auto nswlmx = wsd.maxSegmentedWells();

5
src/opm/output/eclipse/EclipseIO.cpp
View File

@ -34,7 +34,6 @@
#include <opm/parser/eclipse/EclipseState/Runspec.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/Well.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/WellConnections.hpp>
#include <opm/parser/eclipse/Utility/Functional.hpp>
@ -239,14 +238,14 @@ void RFT::writeTimeStep( const Schedule& schedule,
if (!(rft_config.rft(well_name, report_step) || rft_config.plt(well_name, report_step)))
continue;
auto* well = schedule.getWell(well_name);
rft rft_node(ecl_rft_node_alloc_new( well_name.c_str(), "RFT", current_time, days ));
const auto& wellData = wellDatas.at(well_name);
if (wellData.connections.empty())
continue;
for( const auto& connection : well->getConnections( report_step ) ) {
const auto& well = schedule.getWell2(well_name, report_step);
for( const auto& connection : well.getConnections() ) {
const size_t i = size_t( connection.getI() );
const size_t j = size_t( connection.getJ() );

41
src/opm/output/eclipse/LoadRestart.cpp
View File

@ -54,7 +54,6 @@
#include <utility>
#include <vector>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/Well.hpp>
namespace VI = ::Opm::RestartIO::Helpers::VectorItems;
class RestartFileView
@ -671,17 +670,17 @@ namespace {
const ::Opm::RestartIO::ecl_kw_type* opm_iwel,
const int sim_step,
const std::vector<Opm::data::Rates::opt>& phases,
const std::vector<const Opm::Well*>& sched_wells)
const std::vector<Opm::Well2>& sched_wells)
{
const auto expected_xwel_size =
std::accumulate(sched_wells.begin(), sched_wells.end(),
std::size_t(0),
[&phases, sim_step](const std::size_t acc, const Opm::Well* w)
[&phases, sim_step](const std::size_t acc, const Opm::Well2& w)
-> std::size_t
{
return acc
+ 2 + phases.size()
+ (w->getConnections(sim_step).size()
+ (w.getConnections().size()
* (phases.size() + Opm::data::Connection::restart_size));
});
@ -720,7 +719,7 @@ namespace {
using rt = Opm::data::Rates::opt;
const auto& sched_wells = schedule.getWells(rst_view.simStep());
const auto& sched_wells = schedule.getWells2(rst_view.simStep());
std::vector<rt> phases;
{
const auto& phase = es.runspec().phases();
@ -738,8 +737,8 @@ namespace {
const auto* opm_xwel_data = Load::ecl_kw_get_type_ptr<double>(opm_xwel, Load::ECL_DOUBLE_TYPE);
const auto* opm_iwel_data = Load::ecl_kw_get_type_ptr<int>(opm_iwel, Load::ECL_INT_TYPE);
for (const auto* sched_well : sched_wells) {
auto& well = wells[ sched_well->name() ];
for (const auto& sched_well : sched_wells) {
auto& well = wells[ sched_well.name() ];
well.bhp = *opm_xwel_data++;
well.temperature = *opm_xwel_data++;
@ -749,7 +748,7 @@ namespace {
well.rates.set(phase, *opm_xwel_data++);
}
for (const auto& sc : sched_well->getConnections(rst_view.simStep())) {
for (const auto& sc : sched_well.getConnections()) {
const auto i = sc.getI(), j = sc.getJ(), k = sc.getK();
if (!grid.cellActive(i, j, k) || sc.state() == Opm::WellCompletion::SHUT) {
@ -835,7 +834,7 @@ namespace {
if (gas) { xc.rates.set(Opm::data::Rates::opt::gas, 0.0); }
}
void restoreConnResults(const Opm::Well& well,
void restoreConnResults(const Opm::Well2& well,
const std::size_t wellID,
const std::size_t sim_step,
const Opm::EclipseGrid& grid,
@ -868,7 +867,8 @@ namespace {
return;
}
const auto conns = well.getActiveConnections(sim_step, grid);
const auto& conn0 = well.getConnections();
const auto conns = Opm::WellConnections(conn0, grid);
const auto ijk_to_res = ijk_to_resID(wellID, nConn, wellData);
auto linConnID = std::size_t{0};
@ -956,7 +956,7 @@ namespace {
}
Opm::data::Well
restore_well(const Opm::Well& well,
restore_well(const Opm::Well2& well,
const std::size_t wellID,
const std::size_t sim_step,
const Opm::EclipseGrid& grid,
@ -1010,14 +1010,14 @@ namespace {
grid, usys, phases, wellData, xw);
// 4) Restore segment quantities if applicable.
if (well.isMultiSegment(sim_step) &&
if (well.isMultiSegment() &&
segData.hasDefinedValues())
{
const auto iwel = wellData.iwel(wellID);
const auto mswID = iwel[VI::IWell::index::MsWID]; // One-based
const auto numSeg = iwel[VI::IWell::index::NWseg];
const auto& segSet = well.getWellSegments(sim_step);
const auto& segSet = well.getSegments();
if ((mswID > 0) && (numSeg > 0) &&
(segSet.size() == numSeg))
@ -1053,14 +1053,13 @@ namespace {
const auto& phases = es.runspec().phases();
const auto sim_step = rst_view.simStep();
const auto& wells = schedule.getWells(sim_step);
for (auto nWells = wells.size(), wellID = 0*nWells;
wellID < nWells; ++wellID)
const auto& wells = schedule.getWells2(sim_step);
for (auto nWells = wells.size(), wellID = 0*nWells; wellID < nWells; ++wellID)
{
const auto* well = wells[wellID];
const auto& well = wells[wellID];
soln[well->name()] =
restore_well(*well, wellID, sim_step, grid,
soln[well.name()] =
restore_well(well, wellID, sim_step, grid,
units, phases, wellData, segData);
}
@ -1152,12 +1151,12 @@ namespace {
// Well cumulatives
{
const auto wellData = WellVectors { rst_view, intehead };
const auto& wells = schedule.getWells(sim_step);
const auto& wells = schedule.getWells2(sim_step);
for (auto nWells = wells.size(), wellID = 0*nWells;
wellID < nWells; ++wellID)
{
assign_well_cumulatives(wells[wellID]->name(),
assign_well_cumulatives(wells[wellID].name(),
wellID, wellData, smry);
}
}

11
src/opm/output/eclipse/RegionCache.cpp
View File

@ -15,12 +15,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/EclipseState.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/Connection.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/WellConnections.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/Well.hpp>
#include <opm/parser/eclipse/EclipseState/Eclipse3DProperties.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/GridProperty.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
@ -33,16 +33,16 @@ namespace out {
RegionCache::RegionCache(const Eclipse3DProperties& properties, const EclipseGrid& grid, const Schedule& schedule) {
const auto& fipnum = properties.getIntGridProperty("FIPNUM");
const auto& wells = schedule.getWells();
const auto& wells = schedule.getWells2atEnd();
for (const auto& well : wells) {
const auto& connections = well->getConnections( );
const auto& connections = well.getConnections( );
for (const auto& c : connections) {
size_t global_index = grid.getGlobalIndex( c.getI() , c.getJ() , c.getK());
if (grid.cellActive( global_index )) {
size_t active_index = grid.activeIndex( global_index );
int region_id =fipnum.iget( global_index );
auto& well_index_list = this->connection_map[ region_id ];
well_index_list.push_back( { well->name() , active_index } );
well_index_list.push_back( { well.name() , active_index } );
}
}
}
@ -59,3 +59,4 @@ RegionCache::RegionCache(const Eclipse3DProperties& properties, const EclipseGri
}
}

34
src/opm/output/eclipse/RestartIO.cpp
View File

@ -51,7 +51,6 @@
#include <ert/ecl/EclFilename.hpp>
#include <ert/ecl/fortio.h>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/Well.hpp>
namespace Opm { namespace RestartIO {
namespace {
@ -98,11 +97,11 @@ namespace {
}
std::vector<double>
serialize_OPM_XWEL(const data::Wells& wells,
int sim_step,
const std::vector<const Well*>& sched_wells,
const Phases& phase_spec,
const EclipseGrid& grid)
serialize_OPM_XWEL(const data::Wells& wells,
int sim_step,
const std::vector<Opm::Well2>& sched_wells,
const Phases& phase_spec,
const EclipseGrid& grid)
{
using rt = data::Rates::opt;
@ -112,13 +111,12 @@ namespace {
if (phase_spec.active(Phase::GAS)) phases.push_back(rt::gas);
std::vector< double > xwel;
for (const auto* sched_well : sched_wells) {
if (wells.count(sched_well->name()) == 0 ||
sched_well->getStatus(sim_step) == Opm::WellCommon::SHUT)
for (const auto& sched_well : sched_wells) {
if (wells.count(sched_well.name()) == 0 ||
sched_well.getStatus() == Opm::WellCommon::SHUT)
{
const auto elems = (sched_well->getConnections( sim_step ).size()
* (phases.size() + data::Connection::restart_size))
const auto elems = (sched_well.getConnections().size()
* (phases.size() + data::Connection::restart_size))
+ 2 /* bhp, temperature */
+ phases.size();
@ -127,7 +125,7 @@ namespace {
continue;
}
const auto& well = wells.at( sched_well->name() );
const auto& well = wells.at( sched_well.name() );
xwel.push_back( well.bhp );
xwel.push_back( well.temperature );
@ -135,7 +133,7 @@ namespace {
for (auto phase : phases)
xwel.push_back(well.rates.get(phase));
for (const auto& sc : sched_well->getConnections(sim_step)) {
for (const auto& sc : sched_well.getConnections()) {
const auto i = sc.getI(), j = sc.getJ(), k = sc.getK();
const auto rs_size = phases.size() + data::Connection::restart_size;
@ -373,7 +371,7 @@ namespace {
// Extended set of OPM well vectors
if (!ecl_compatible_rst)
{
const auto sched_wells = schedule.getWells(sim_step);
const auto sched_wells = schedule.getWells2(sim_step);
const auto sched_well_names = schedule.wellNames(sim_step);
const auto opm_xwel =
@ -557,14 +555,14 @@ void save(const std::string& filename,
// Write well and MSW data only when applicable (i.e., when present)
{
const auto& wells = schedule.getWells(sim_step);
const auto& wells = schedule.getWells2(sim_step);
if (! wells.empty()) {
const auto haveMSW =
std::any_of(std::begin(wells), std::end(wells),
[sim_step](const Well* well)
[sim_step](const Well2& well)
{
return well->isMultiSegment(sim_step);
return well.isMultiSegment();
});
if (haveMSW) {

137
src/opm/output/eclipse/Summary.cpp
View File

@ -40,7 +40,6 @@
#include <opm/parser/eclipse/EclipseState/Schedule/UDQ/UDQContext.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Group.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/Well.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/WellProductionProperties.hpp>
#include <opm/parser/eclipse/EclipseState/SummaryConfig/SummaryConfig.hpp>
#include <opm/parser/eclipse/Units/UnitSystem.hpp>
@ -122,17 +121,15 @@ namespace {
ret.push_back(SRD{"SPR" , well, segNumber});
};
const auto last_timestep = sched.getTimeMap().last();
for (const auto* well : sched.getWells()) {
if (! well->isMultiSegment(last_timestep)) {
for (const auto& well : sched.getWells2atEnd()) {
if (! well.isMultiSegment()) {
// Don't allocate MS summary vectors for non-MS wells.
continue;
}
const auto& wname = well->name();
const auto& wname = well.name();
const auto nSeg =
well->getWellSegments(last_timestep).size();
well.getSegments().size();
for (auto segID = 0*nSeg; segID < nSeg; ++segID) {
makeVectors(wname, segID + 1); // One-based
@ -289,7 +286,7 @@ struct quantity {
* is the index of the block in question. wells is simulation data.
*/
struct fn_args {
const std::vector< const Well* >& schedule_wells;
const std::vector<Well2>& schedule_wells;
double duration;
const int sim_step;
int num;
@ -357,14 +354,14 @@ template< rt phase, bool injection = true, bool polymer = false >
inline quantity rate( const fn_args& args ) {
double sum = 0.0;
for( const auto* sched_well : args.schedule_wells ) {
const auto& name = sched_well->name();
for( const auto& sched_well : args.schedule_wells ) {
const auto& name = sched_well.name();
if( args.wells.count( name ) == 0 ) continue;
double eff_fac = efac( args.eff_factors, name );
double concentration = polymer
? sched_well->getPolymerProperties( args.sim_step ).m_polymerConcentration
? sched_well.getPolymerProperties().m_polymerConcentration
: 1;
const auto v = args.wells.at(name).rates.get(phase, 0.0) * eff_fac * concentration;
@ -383,9 +380,9 @@ template< bool injection >
inline quantity flowing( const fn_args& args ) {
const auto& wells = args.wells;
const auto ts = args.sim_step;
auto pred = [&wells,ts]( const Well* w ) {
const auto& name = w->name();
return w->isInjector( ts ) == injection
auto pred = [&wells,ts]( const Well2& w ) {
const auto& name = w.name();
return w.isInjector( ) == injection
&& wells.count( name ) > 0
&& wells.at( name ).flowing();
};
@ -407,7 +404,7 @@ inline quantity crate( const fn_args& args ) {
if( args.schedule_wells.empty() ) return zero;
const auto& well = args.schedule_wells.front();
const auto& name = well->name();
const auto& name = well.name();
if( args.wells.count( name ) == 0 ) return zero;
const auto& well_data = args.wells.at( name );
@ -421,7 +418,7 @@ inline quantity crate( const fn_args& args ) {
double eff_fac = efac( args.eff_factors, name );
double concentration = polymer
? well->getPolymerProperties( args.sim_step ).m_polymerConcentration
? well.getPolymerProperties().m_polymerConcentration
: 1;
auto v = completion->rates.get( phase, 0.0 ) * eff_fac * concentration;
@ -443,7 +440,7 @@ inline quantity srate( const fn_args& args ) {
if( args.schedule_wells.empty() ) return zero;
const auto& well = args.schedule_wells.front();
const auto& name = well->name();
const auto& name = well.name();
if( args.wells.count( name ) == 0 ) return zero;
const auto& well_data = args.wells.at( name );
@ -454,7 +451,7 @@ inline quantity srate( const fn_args& args ) {
double eff_fac = efac( args.eff_factors, name );
double concentration = polymer
? well->getPolymerProperties( args.sim_step ).m_polymerConcentration
? well.getPolymerProperties().m_polymerConcentration
: 1;
auto v = segment->second.rates.get( phase, 0.0 ) * eff_fac * concentration;
@ -474,11 +471,11 @@ inline quantity trans_factors ( const fn_args& args ) {
const size_t global_index = args.num - 1;
const auto& well = args.schedule_wells.front();
const auto& name = well->name();
const auto& name = well.name();
if( args.wells.count( name ) == 0 ) return zero;
const auto& grid = args.grid;
const auto& connections = well->getConnections(args.sim_step);
const auto& connections = well.getConnections();
const auto& connection = std::find_if(
connections.begin(),
@ -503,7 +500,7 @@ inline quantity spr ( const fn_args& args ) {
if( args.schedule_wells.empty() ) return zero;
const auto& well = args.schedule_wells.front();
const auto& name = well->name();
const auto& name = well.name();
if( args.wells.count( name ) == 0 ) return zero;
const auto& well_data = args.wells.at( name );
@ -522,7 +519,7 @@ inline quantity bhp( const fn_args& args ) {
const quantity zero = { 0, measure::pressure };
if( args.schedule_wells.empty() ) return zero;
const auto p = args.wells.find( args.schedule_wells.front()->name() );
const auto p = args.wells.find( args.schedule_wells.front().name() );
if( p == args.wells.end() ) return zero;
return { p->second.bhp, measure::pressure };
@ -532,7 +529,7 @@ inline quantity thp( const fn_args& args ) {
const quantity zero = { 0, measure::pressure };
if( args.schedule_wells.empty() ) return zero;
const auto p = args.wells.find( args.schedule_wells.front()->name() );
const auto p = args.wells.find( args.schedule_wells.front().name() );
if( p == args.wells.end() ) return zero;
return { p->second.thp, measure::pressure };
@ -541,13 +538,13 @@ inline quantity thp( const fn_args& args ) {
inline quantity bhp_history( const fn_args& args ) {
if( args.schedule_wells.empty() ) return { 0.0, measure::pressure };
const Well* sched_well = args.schedule_wells.front();
const Well2& sched_well = args.schedule_wells.front();
double bhp_hist;
if ( sched_well->isProducer( args.sim_step ) )
bhp_hist = sched_well->getProductionProperties( args.sim_step ).BHPH;
if ( sched_well.isProducer( ) )
bhp_hist = sched_well.getProductionProperties().BHPH;
else
bhp_hist = sched_well->getInjectionProperties( args.sim_step ).BHPH;
bhp_hist = sched_well.getInjectionProperties().BHPH;
return { bhp_hist, measure::pressure };
}
@ -555,13 +552,13 @@ inline quantity bhp_history( const fn_args& args ) {
inline quantity thp_history( const fn_args& args ) {
if( args.schedule_wells.empty() ) return { 0.0, measure::pressure };
const Well* sched_well = args.schedule_wells.front();
const Well2& sched_well = args.schedule_wells.front();
double thp_hist;
if ( sched_well->isProducer( args.sim_step ) )
thp_hist = sched_well->getProductionProperties( args.sim_step ).THPH;
if ( sched_well.isProducer() )
thp_hist = sched_well.getProductionProperties().THPH;
else
thp_hist = sched_well->getInjectionProperties( args.sim_step ).THPH;
thp_hist = sched_well.getInjectionProperties().THPH;
return { thp_hist, measure::pressure };
}
@ -576,10 +573,10 @@ inline quantity production_history( const fn_args& args ) {
*/
double sum = 0.0;
for( const Well* sched_well : args.schedule_wells ){
for( const auto& sched_well : args.schedule_wells ){
double eff_fac = efac( args.eff_factors, sched_well->name() );
sum += sched_well->production_rate( phase, args.sim_step ) * eff_fac;
double eff_fac = efac( args.eff_factors, sched_well.name() );
sum += sched_well.production_rate( phase ) * eff_fac;
}
@ -590,10 +587,9 @@ template< Phase phase >
inline quantity injection_history( const fn_args& args ) {
double sum = 0.0;
for( const Well* sched_well : args.schedule_wells ){
double eff_fac = efac( args.eff_factors, sched_well->name() );
sum += sched_well->injection_rate( phase, args.sim_step ) * eff_fac;
for( const auto& sched_well : args.schedule_wells ){
double eff_fac = efac( args.eff_factors, sched_well.name() );
sum += sched_well.injection_rate( phase ) * eff_fac;
}
@ -603,9 +599,9 @@ inline quantity injection_history( const fn_args& args ) {
inline quantity res_vol_production_target( const fn_args& args ) {
double sum = 0.0;
for( const Well* sched_well : args.schedule_wells )
if (sched_well->getProductionProperties(args.sim_step).predictionMode)
sum += sched_well->getProductionProperties( args.sim_step ).ResVRate;
for( const Well2& sched_well : args.schedule_wells )
if (sched_well.getProductionProperties().predictionMode)
sum += sched_well.getProductionProperties().ResVRate;
return { sum, measure::rate };
}
@ -661,15 +657,15 @@ template < rt phase, bool outputProducer = true, bool outputInjector = true>
inline quantity potential_rate( const fn_args& args ) {
double sum = 0.0;
for( const auto* sched_well : args.schedule_wells ) {
const auto& name = sched_well->name();
for( const auto& sched_well : args.schedule_wells ) {
const auto& name = sched_well.name();
if( args.wells.count( name ) == 0 ) continue;
if (sched_well->isInjector(args.sim_step) && outputInjector) {
if (sched_well.isInjector() && outputInjector) {
const auto v = args.wells.at(name).rates.get(phase, 0.0);
sum += v;
}
else if (sched_well->isProducer(args.sim_step) && outputProducer) {
else if (sched_well.isProducer() && outputProducer) {
const auto v = args.wells.at(name).rates.get(phase, 0.0);
sum += v;
}
@ -1079,10 +1075,10 @@ static const std::unordered_map< std::string, UnitSystem::measure> block_units =
{"BOVIS" , UnitSystem::measure::viscosity},
};
inline std::vector< const Well* > find_wells( const Schedule& schedule,
const ecl::smspec_node* node,
const int sim_step,
const out::RegionCache& regionCache ) {
inline std::vector<Well2> find_wells( const Schedule& schedule,
const ecl::smspec_node* node,
const int sim_step,
const out::RegionCache& regionCache ) {
const auto* name = smspec_node_get_wgname( node );
const auto type = smspec_node_get_var_type( node );
@ -1091,34 +1087,38 @@ inline std::vector< const Well* > find_wells( const Schedule& schedule,
(type == ECL_SMSPEC_COMPLETION_VAR) ||
(type == ECL_SMSPEC_SEGMENT_VAR))
{
const auto* well = schedule.getWell( name );
if( !well ) return {};
return { well };
if (schedule.hasWell(name, sim_step)) {
const auto& well = schedule.getWell2( name, sim_step );
return { well };
} else
return {};
}
if( type == ECL_SMSPEC_GROUP_VAR ) {
if( !schedule.hasGroup( name ) ) return {};
return schedule.getChildWells( name, sim_step, GroupWellQueryMode::Recursive);
return schedule.getChildWells2( name, sim_step, GroupWellQueryMode::Recursive);
}
if( type == ECL_SMSPEC_FIELD_VAR )
return schedule.getWells();
return schedule.getWells2(sim_step);
if( type == ECL_SMSPEC_REGION_VAR ) {
std::vector< const Well* > wells;
std::vector<Well2> wells;
const auto region = smspec_node_get_num( node );
for ( const auto& connection : regionCache.connections( region ) ){
const auto& w_name = connection.first;
const auto& well = schedule.getWell( w_name );
if (schedule.hasWell(w_name, sim_step)) {
const auto& well = schedule.getWell2( w_name, sim_step );
const auto& it = std::find_if( wells.begin(), wells.end(),
[&] ( const Well* elem )
{ return *elem == *well; });
if ( it == wells.end() )
wells.push_back( schedule.getWell( w_name ) );
const auto& it = std::find_if( wells.begin(), wells.end(),
[&] ( const Well2& elem )
{ return elem.name() == well.name(); });
if ( it == wells.end() )
wells.push_back( schedule.getWell2( w_name, sim_step ));
}
}
return wells;
@ -1312,7 +1312,7 @@ Summary::Summary( const EclipseState& st,
/* get unit strings by calling each function with dummy input */
const auto handle = funs_pair->second;
const std::vector< const Well* > dummy_wells;
const std::vector< Well2 > dummy_wells;
const fn_args no_args { dummy_wells, // Wells from Schedule object
0, // Duration of time step
@ -1419,7 +1419,7 @@ Summary::Summary( const EclipseState& st,
std::vector< std::pair< std::string, double > >
well_efficiency_factors( const ecl::smspec_node* node,
const Schedule& schedule,
const std::vector< const Well* >& schedule_wells,
const std::vector<Well2>& schedule_wells,
const int sim_step ) {
std::vector< std::pair< std::string, double > > efac;
@ -1435,13 +1435,12 @@ well_efficiency_factors( const ecl::smspec_node* node,
const bool is_rate = !node->is_total();
const auto &groupTree = schedule.getGroupTree(sim_step);
for( const auto* well : schedule_wells ) {
double eff_factor = well->getEfficiencyFactor(sim_step);
if ( !well->hasBeenDefined( sim_step ) )
for( const auto& well : schedule_wells ) {
if (!well.hasBeenDefined(sim_step))
continue;
const auto* group_node = &schedule.getGroup(well->getGroupName(sim_step));
double eff_factor = well.getEfficiencyFactor();
const auto* group_node = &schedule.getGroup(well.groupName());
while(true){
if(( is_group
@ -1455,7 +1454,7 @@ well_efficiency_factors( const ecl::smspec_node* node,
break;
group_node = &schedule.getGroup( parent );
}
efac.emplace_back( well->name(), eff_factor );
efac.emplace_back( well.name(), eff_factor );
}
return efac;

82
src/opm/output/eclipse/libECLRestart.cpp
View File

@ -27,11 +27,11 @@
#include <time.h>
#include <ctime>
#include <cstring>
#include <stdlib.h>
#include <stdlib.h>
#include <iostream>
#include <stdio.h>
#include <sys/stat.h>
#include <fstream>
#include <fstream>
#include <fcntl.h>
#include <cstdint>
#include <cstdlib>
@ -78,7 +78,7 @@
//# else
//# error No known program_invocation_name in runtime library
//# endif
//#endif
//#endif
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
#include <opm/parser/eclipse/EclipseState/EclipseState.hpp>
@ -230,12 +230,12 @@ static const char * string_type = "int";
/*
Macros for endian flipping. The macros create a new endian-flipped
value, and should be used as:
value, and should be used as:
flipped_value = FLIP32( value )
The macros are not exported and only available through the function
util_endian_flip_vector().
util_endian_flip_vector().
*/
@ -267,7 +267,7 @@ struct int_vector_struct {
bool data_owner; /* Is the vector owner of the the actual storage data?
If this is false the vector can not be resized. */
bool read_only;
};
};
struct size_t_vector_struct {
@ -325,15 +325,15 @@ struct node_data_struct {
::Opm::RestartIO::node_ctype ctype;
void *data;
int buffer_size; /* This is to facilitate deep copies of buffers. */
/*
For the copy constructor and delete
operator the logic is very simple:
if they are present they are used.
*/
::Opm::RestartIO::copyc_ftype *copyc; /* Copy constructor - can be NULL. */
::Opm::RestartIO::free_ftype *del; /* Destructor - can be NULL. */
::Opm::RestartIO::free_ftype *del; /* Destructor - can be NULL. */
};
@ -437,12 +437,12 @@ void util_abort__(const char * file , const char * function , int line , const c
fprintf(stderr, "Version info : %s\n" , (__abort_program_message == NULL) ? "<Not set>" : __abort_program_message);
fprintf(stderr, "\nError message: ");
fprintf(stderr , "Abort called from: %s (%s:%d) \n",function , file , line);
{
{
va_list ap;
va_start(ap , fmt);
vfprintf(stderr , fmt , ap);
va_end(ap);
}
}
fprintf(stderr,"-----------------------------------------------------------------\n");
signal(SIGABRT , SIG_DFL);
@ -1421,7 +1421,7 @@ bool ecl_type_is_double(const ::Opm::RestartIO::ecl_data_type ecl_type) {
return (ecl_type.type == ECL_DOUBLE_TYPE);
}
bool ecl_type_is_bool(const ::Opm::RestartIO::ecl_data_type ecl_type) {
return (ecl_type.type == ECL_BOOL_TYPE);
}
@ -1441,7 +1441,7 @@ static uint16_t util_endian_convert16( uint16_t u ) {
static uint32_t util_endian_convert32( uint32_t u ) {
const uint32_t m8 = (uint32_t) 0x00FF00FFUL;
const uint32_t m16 = (uint32_t) 0x0000FFFFUL;
u = (( u >> 8U ) & m8) | ((u & m8) << 8U);
u = (( u >> 16U ) & m16) | ((u & m16) << 16U);
return u;
@ -1453,7 +1453,7 @@ static uint64_t util_endian_convert64( uint64_t u ) {
const uint64_t m16 = (uint64_t) 0x0000FFFF0000FFFFULL;
const uint64_t m32 = (uint64_t) 0x00000000FFFFFFFFULL;
u = (( u >> 8U ) & m8) | ((u & m8) << 8U);
u = (( u >> 16U ) & m16) | ((u & m16) << 16U);
u = (( u >> 32U ) & m32) | ((u & m32) << 32U);
@ -1465,7 +1465,7 @@ static uint64_t util_endian_convert32_64( uint64_t u ) {
const uint64_t m8 = (uint64_t) 0x00FF00FF00FF00FFULL;
const uint64_t m16 = (uint64_t) 0x0000FFFF0000FFFFULL;
u = (( u >> 8U ) & m8) | ((u & m8) << 8U);
u = (( u >> 16U ) & m16) | ((u & m16) << 16U);
return u;
@ -1478,7 +1478,7 @@ void util_endian_flip_vector(void *data, int element_size , int elements) {
switch (element_size) {
case(1):
break;
case(2):
case(2):
{
uint16_t *tmp16 = (uint16_t *) data;
@ -1509,10 +1509,10 @@ void util_endian_flip_vector(void *data, int element_size , int elements) {
break;
#else
uint32_t *tmp32 = (uint32_t *) data;
for (i = 0; i <elements; i++)
tmp32[i] = util_endian_convert32(tmp32[i]);
break;
#endif
}
@ -1805,16 +1805,16 @@ bool hash_node_key_eq(const ::Opm::RestartIO::hash_node_type * node , uint32_t g
return eq;
}
::Opm::RestartIO::hash_node_type * hash_node_get_next(const ::Opm::RestartIO::hash_node_type * node) {
return node->next_node;
::Opm::RestartIO::hash_node_type * hash_node_get_next(const ::Opm::RestartIO::hash_node_type * node) {
return node->next_node;
}
::Opm::RestartIO::hash_node_type * hash_sll_get(const ::Opm::RestartIO::hash_sll_type *hash_sll, uint32_t global_index , const char *key) {
::Opm::RestartIO::hash_node_type * node = hash_sll->head;
while ((node != NULL) && (!::Opm::RestartIO::hash_node_key_eq(node , global_index , key)))
while ((node != NULL) && (!::Opm::RestartIO::hash_node_key_eq(node , global_index , key)))
node = ::Opm::RestartIO::hash_node_get_next(node);
return node;
}
@ -1907,7 +1907,7 @@ static void * __hash_get_node(const ::Opm::RestartIO::hash_type *hash_in , const
/*****************************************************************/
/* The three functions below here are the only functions accessing the
data field of the hash_node.
data field of the hash_node.
*/
::Opm::RestartIO::node_data_type * hash_node_get_data(const ::Opm::RestartIO::hash_node_type * node) {
@ -2185,7 +2185,7 @@ void node_data_free_container(::Opm::RestartIO::node_data_type * node_data) {
void node_data_free(::Opm::RestartIO::node_data_type * node_data) {
if (node_data->del != NULL)
node_data->del( (void *) node_data->data );
::Opm::RestartIO::node_data_free_container( node_data );
}
@ -2498,7 +2498,7 @@ stringlist_type * stringlist_alloc_new() {
return ecl_file_view;
}
/**
/**
If the node has a copy constructor, the data is copied immediately
- so the node contains a copy from object creation time.
*/
@ -2514,7 +2514,7 @@ static ::Opm::RestartIO::node_data_type * node_data_alloc__(const void * data ,
node->data = node->copyc( data );
else
node->data = (void *) data;
return node;
}
@ -2525,7 +2525,7 @@ static ::Opm::RestartIO::node_data_type * node_data_alloc__(const void * data ,
//jal - declare function before definition due to mutual calls for two functions
static int vector_append_node(::Opm::RestartIO::vector_type * vector , ::Opm::RestartIO::node_data_type * node);
/**
If the index is beyond the length of the vector the hole in the
vector will be filled with NULL nodes.
@ -2651,7 +2651,7 @@ static time_t timegm(struct tm * a_tm)
}
time_t utc = std::mktime(a_tm) - offset * 3600;
return utc;
}
}
static bool util_make_datetime_utc__(int sec, int min, int hour , int mday , int month , int year, bool force_set, time_t * t) {
bool valid = false;
@ -2734,11 +2734,11 @@ static time_t rsthead_date( int day , int month , int year) {
time_t ecl_rsthead_date( const ::Opm::RestartIO::ecl_kw_type * intehead_kw ) {
/*return ::Opm::RestartIO::rsthead_date( ::Opm::RestartIO::ecl_kw_iget_int( intehead_kw , INTEHEAD_DAY_INDEX) ,
::Opm::RestartIO::ecl_kw_iget_int( intehead_kw , INTEHEAD_MONTH_INDEX) ,
::Opm::RestartIO::ecl_kw_iget_int( intehead_kw , INTEHEAD_YEAR_INDEX) );
::Opm::RestartIO::ecl_kw_iget_int( intehead_kw , INTEHEAD_YEAR_INDEX) );
*/
return ::Opm::RestartIO::rsthead_date( ::Opm::RestartIO::ecl_kw_iget_type<int>( intehead_kw , ECL_INT_TYPE, INTEHEAD_DAY_INDEX) ,
::Opm::RestartIO::ecl_kw_iget_type<int>( intehead_kw , ECL_INT_TYPE, INTEHEAD_MONTH_INDEX) ,
::Opm::RestartIO::ecl_kw_iget_type<int>( intehead_kw , ECL_INT_TYPE, INTEHEAD_YEAR_INDEX) );
::Opm::RestartIO::ecl_kw_iget_type<int>( intehead_kw , ECL_INT_TYPE, INTEHEAD_YEAR_INDEX) );
}
@ -3296,14 +3296,14 @@ bool hash_sll_empty(const ::Opm::RestartIO::hash_sll_type * hash_sll) {
}
const char * hash_node_get_key(const ::Opm::RestartIO::hash_node_type * node) {
return node->key;
const char * hash_node_get_key(const ::Opm::RestartIO::hash_node_type * node) {
return node->key;
}
::Opm::RestartIO::hash_node_type * hash_sll_get_head(const ::Opm::RestartIO::hash_sll_type *hash_sll) { return hash_sll->head; }
uint32_t hash_node_get_table_index(const ::Opm::RestartIO::hash_node_type * node) {
return node->table_index;
uint32_t hash_node_get_table_index(const ::Opm::RestartIO::hash_node_type * node) {
return node->table_index;
}
/**
@ -3377,7 +3377,7 @@ void hash_node_set_next(::Opm::RestartIO::hash_node_type *node , const ::Opm::Re
void hash_sll_del_node(::Opm::RestartIO::hash_sll_type *hash_sll , ::Opm::RestartIO::hash_node_type *del_node) {
if (del_node == NULL)
if (del_node == NULL)
util_abort("%s: tried to delete NULL node - aborting \n",__func__);
{
@ -3390,8 +3390,8 @@ void hash_sll_del_node(::Opm::RestartIO::hash_sll_type *hash_sll , ::Opm::Restar
}
if (node == del_node) {
if (p_node == NULL)
/*
if (p_node == NULL)
/*
We are attempting to delete the first element in the list.
*/
hash_sll->head = ::Opm::RestartIO::hash_node_get_next(del_node);
@ -3399,7 +3399,7 @@ void hash_sll_del_node(::Opm::RestartIO::hash_sll_type *hash_sll , ::Opm::Restar
::Opm::RestartIO::hash_node_set_next(p_node , ::Opm::RestartIO::hash_node_get_next(del_node));
::Opm::RestartIO::hash_node_free(del_node);
hash_sll->length--;
} else
} else
util_abort("%s: tried to delete node not in list - aborting \n",__func__);
}
@ -3582,7 +3582,7 @@ hash_node_type * hash_node_alloc_new(const char *key, ::Opm::RestartIO::node_dat
node->key = util_alloc_string_copy( key );
node->data = data;
node->next_node = NULL;
node->global_index = hashf(node->key , strlen(node->key));
::Opm::RestartIO::hash_node_set_table_index(node , table_size);
return node;

1
src/opm/parser/eclipse/EclipseState/IOConfig/IOConfig.cpp
View File

@ -31,7 +31,6 @@
#include <opm/parser/eclipse/Deck/Section.hpp>
#include <opm/parser/eclipse/EclipseState/IOConfig/IOConfig.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/DynamicState.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/Well.hpp>
#include <ert/ecl/EclFilename.hpp>

1
src/opm/parser/eclipse/EclipseState/IOConfig/RestartConfig.cpp
View File

@ -38,7 +38,6 @@
#include <opm/parser/eclipse/EclipseState/IOConfig/RestartConfig.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/DynamicState.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/Well.hpp>

6
src/opm/parser/eclipse/EclipseState/Schedule/ArrayDimChecker.cpp
View File

@ -29,7 +29,6 @@
#include <opm/parser/eclipse/EclipseState/Schedule/Group.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/GroupTree.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/Well.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/WellConnections.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/ArrayDimChecker.hpp>
@ -61,8 +60,9 @@ namespace {
Opm::ErrorGuard& guard)
{
auto nconn = std::size_t{0};
for (const auto* well : sched.getWells()) {
nconn = std::max(nconn, well->getConnections().size());
for (const auto& well_name : sched.wellNames()) {
const auto& well = sched.getWell2atEnd(well_name);
nconn = std::max(nconn, well.getConnections().size());
}
if (nconn > static_cast<decltype(nconn)>(wdims.maxConnPerWell()))

1
src/opm/parser/eclipse/EclipseState/Schedule/Group.cpp
View File

@ -21,7 +21,6 @@
#include <opm/parser/eclipse/EclipseState/Schedule/DynamicState.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Group.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/Well.hpp>
#define INVALID_GROUP_RATE -999e100
#define INVALID_EFFICIENCY_FACTOR 0.0

770
src/opm/parser/eclipse/EclipseState/Schedule/Schedule.cpp
View File

File diff suppressed because it is too large Load Diff

1
src/opm/parser/eclipse/EclipseState/Schedule/Well/Connection.cpp
View File

@ -31,7 +31,6 @@
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/Connection.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/Well.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
#include <opm/parser/eclipse/EclipseState/Util/Value.hpp>

643
src/opm/parser/eclipse/EclipseState/Schedule/Well/Well.cpp
View File

@ -1,643 +0,0 @@
/*
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 <iostream>
#include <opm/common/OpmLog/OpmLog.hpp>
#include <opm/parser/eclipse/Deck/DeckRecord.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/DynamicState.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/MSW/WellSegments.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/MSW/updatingConnectionsWithSegments.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/TimeMap.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/Connection.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/WellConnections.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/Well.hpp>
namespace Opm {
Well::Well(const std::string& name_, const size_t& seqIndex_, int headI,
int headJ, double refDepth , double drainageRadius, Phase preferredPhase,
WellProducer::ControlModeEnum whist_ctl,
const TimeMap& timeMap, size_t creationTimeStep,
WellCompletion::CompletionOrderEnum completionOrdering,
bool allowCrossFlow, bool automaticShutIn)
: m_creationTimeStep( creationTimeStep ),
m_name( name_ ),
m_seqIndex( seqIndex_),
m_status( timeMap, WellCommon::SHUT ),
m_isAvailableForGroupControl( timeMap, true ),
m_guideRate( timeMap, -1.0 ),
m_guideRatePhase( timeMap, GuideRate::UNDEFINED ),
m_guideRateScalingFactor( timeMap, 1.0 ),
m_efficiencyFactors (timeMap, 1.0 ),
m_isProducer( timeMap, true ) ,
m_completions( timeMap, std::make_shared<WellConnections>(headI, headJ) ),
m_productionProperties( timeMap, WellProductionProperties() ),
m_injectionProperties( timeMap, WellInjectionProperties() ),
m_polymerProperties( timeMap, WellPolymerProperties() ),
m_econproductionlimits( timeMap, WellEconProductionLimits() ),
m_solventFraction( timeMap, 0.0 ),
m_tracerProperties( timeMap, WellTracerProperties() ),
m_groupName( timeMap, "" ),
m_headI( timeMap, headI ),
m_headJ( timeMap, headJ ),
m_refDepth( timeMap, refDepth ),
m_drainageRadius (timeMap, drainageRadius),
m_preferredPhase(preferredPhase),
m_comporder(completionOrdering),
m_allowCrossFlow(allowCrossFlow),
m_automaticShutIn(automaticShutIn),
m_segmentset( timeMap, WellSegments{} ),
timesteps( timeMap.numTimesteps() )
{
WellProductionProperties p;
p.whistctl_cmode = whist_ctl;
this->m_productionProperties = DynamicState<WellProductionProperties>(timeMap, p);
}
const std::string& Well::name() const {
return m_name;
}
const size_t& Well::seqIndex() const {
return m_seqIndex;
}
void Well::switchToProducer( size_t timeStep) {
WellInjectionProperties p = getInjectionPropertiesCopy(timeStep);
p.BHPLimit = 0;
p.dropInjectionControl( Opm::WellInjector::BHP );
setInjectionProperties( timeStep , p );
}
void Well::switchToInjector( size_t timeStep) {
WellProductionProperties p = getProductionPropertiesCopy(timeStep);
p.BHPLimit = 0;
p.dropProductionControl( Opm::WellProducer::BHP );
setProductionProperties( timeStep , p );
}
bool Well::operator==(const Well& other) const {
return this->m_creationTimeStep == other.m_creationTimeStep
&& this->m_name == other.m_name
&& this->m_preferredPhase == other.m_preferredPhase
&& this->timesteps == other.timesteps;
}
bool Well::operator!=(const Well& other) const {
return !(*this == other);
}
double Well::production_rate( Phase phase, size_t timestep ) const {
if( !this->isProducer( timestep ) ) return 0.0;
const auto& p = this->getProductionProperties( timestep );
switch( phase ) {
case Phase::WATER: return p.WaterRate;
case Phase::OIL: return p.OilRate;
case Phase::GAS: return p.GasRate;
case Phase::SOLVENT:
throw std::invalid_argument( "Production of 'SOLVENT' requested." );
case Phase::POLYMER:
throw std::invalid_argument( "Production of 'POLYMER' requested." );
case Phase::ENERGY:
throw std::invalid_argument( "Production of 'ENERGY' requested." );
case Phase::POLYMW:
throw std::invalid_argument( "Production of 'POLYMW' requested.");
}
throw std::logic_error( "Unreachable state. Invalid Phase value. "
"This is likely a programming error." );
}
double Well::injection_rate( Phase phase, size_t timestep ) const {
if( !this->isInjector( timestep ) ) return 0.0;
const auto& i = this->getInjectionProperties( timestep );
const auto type = i.injectorType;
if( phase == Phase::WATER && type != WellInjector::WATER ) return 0.0;
if( phase == Phase::OIL && type != WellInjector::OIL ) return 0.0;
if( phase == Phase::GAS && type != WellInjector::GAS ) return 0.0;
return i.surfaceInjectionRate;
}
bool Well::setProductionProperties(size_t timeStep , const WellProductionProperties& newProperties) {
if (isInjector(timeStep))
switchToProducer( timeStep );
this->setProducer(timeStep, true);
return m_productionProperties.update(timeStep, newProperties);
}
WellProductionProperties Well::getProductionPropertiesCopy(size_t timeStep) const {
return m_productionProperties.get(timeStep);
}
const WellProductionProperties& Well::getProductionProperties(size_t timeStep) const {
return m_productionProperties.at(timeStep);
}
bool Well::setInjectionProperties(size_t timeStep , const WellInjectionProperties& newProperties) {
if (isProducer(timeStep))
switchToInjector( timeStep );
this->setProducer(timeStep, false);
return m_injectionProperties.update(timeStep, newProperties);
}
WellInjectionProperties Well::getInjectionPropertiesCopy(size_t timeStep) const {
return m_injectionProperties.get(timeStep);
}
const WellInjectionProperties& Well::getInjectionProperties(size_t timeStep) const {
return m_injectionProperties.at(timeStep);
}
bool Well::setPolymerProperties(size_t timeStep , const WellPolymerProperties& newProperties) {
bool update = m_polymerProperties.update(timeStep, newProperties);
this->setProducer(timeStep, false);
return update;
}
WellPolymerProperties Well::getPolymerPropertiesCopy(size_t timeStep) const {
return m_polymerProperties.get(timeStep);
}
const WellPolymerProperties& Well::getPolymerProperties(size_t timeStep) const {
return m_polymerProperties.at(timeStep);
}
bool Well::setSolventFraction(size_t timeStep , const double fraction) {
m_isProducer.update(timeStep , false);
return m_solventFraction.update(timeStep, fraction);
}
bool Well::setTracerProperties(size_t timeStep , const WellTracerProperties& newProperties) {
if (isProducer(timeStep))
throw std::invalid_argument("WTRACER keyword can only be applied to injectors");
return m_tracerProperties.update(timeStep, newProperties);
}
bool Well::setEconProductionLimits(const size_t timeStep, const WellEconProductionLimits& productionlimits) {
// not sure if this keyword turning a well to be producer.
// not sure what will happen if we use this keyword to a injector.
return m_econproductionlimits.update(timeStep, productionlimits);
}
const WellEconProductionLimits& Well::getEconProductionLimits(const size_t timeStep) const {
return m_econproductionlimits.at(timeStep);
}
const double& Well::getSolventFraction(size_t timeStep) const {
return m_solventFraction.at(timeStep);
}
const WellTracerProperties& Well::getTracerProperties(size_t timeStep) const {
return m_tracerProperties.at(timeStep);
}
bool Well::hasBeenDefined(size_t timeStep) const {
if (timeStep < m_creationTimeStep)
return false;
else
return true;
}
WellCommon::StatusEnum Well::getStatus(size_t timeStep) const {
return m_status.get( timeStep );
}
bool Well::setStatus(size_t timeStep, WellCommon::StatusEnum status) {
if ((WellCommon::StatusEnum::OPEN == status) && getConnections(timeStep).allConnectionsShut()) {
OpmLog::note("When handling keyword for well " + name() + ": Cannot open a well where all completions are shut" );
return false;
} else
return m_status.update( timeStep , status );
}
bool Well::setProducer(size_t timeStep, bool producer) {
return this->m_isProducer.update(timeStep, producer);
}
bool Well::isProducer(size_t timeStep) const {
return bool( m_isProducer.get(timeStep) );
}
bool Well::isInjector(size_t timeStep) const {
return !bool( isProducer(timeStep) );
}
bool Well::isAvailableForGroupControl(size_t timeStep) const {
return m_isAvailableForGroupControl.get(timeStep);
}
void Well::setAvailableForGroupControl(size_t timeStep, bool isAvailableForGroupControl_) {
m_isAvailableForGroupControl.update(timeStep, isAvailableForGroupControl_);
}
double Well::getGuideRate(size_t timeStep) const {
return m_guideRate.get(timeStep);
}
void Well::setGuideRate(size_t timeStep, double guideRate) {
m_guideRate.update(timeStep, guideRate);
}
GuideRate::GuideRatePhaseEnum Well::getGuideRatePhase(size_t timeStep) const {
return m_guideRatePhase.get(timeStep);
}
void Well::setGuideRatePhase(size_t timeStep, GuideRate::GuideRatePhaseEnum phase) {
m_guideRatePhase.update(timeStep, phase);
}
double Well::getGuideRateScalingFactor(size_t timeStep) const {
return m_guideRateScalingFactor.get(timeStep);
}
void Well::setGuideRateScalingFactor(size_t timeStep, double scalingFactor) {
m_guideRateScalingFactor.update(timeStep, scalingFactor);
}
double Well::getEfficiencyFactor (size_t timeStep) const {
return m_efficiencyFactors.get(timeStep);
}
void Well::setEfficiencyFactor(size_t timeStep, double scalingFactor) {
m_efficiencyFactors.update(timeStep, scalingFactor);
}
/*****************************************************************/
// WELSPECS
int Well::getHeadI() const {
return m_headI.back();
}
int Well::getHeadJ() const {
return m_headJ.back();
}
int Well::getHeadI( size_t timestep ) const {
return this->m_headI.get( timestep );
}
int Well::getHeadJ( size_t timestep ) const {
return this->m_headJ.get( timestep );
}
void Well::setHeadI( size_t timestep, int I ) {
this->m_headI.update( timestep, I );
}
void Well::setHeadJ( size_t timestep, int J ) {
this->m_headJ.update( timestep, J );
}
double Well::getRefDepth() const {
return this->getRefDepth( this->timesteps );
}
double Well::getRefDepth( size_t timestep ) const {
auto depth = this->m_refDepth.get( timestep );
if( depth >= 0.0 ) return depth;
// ref depth was defaulted and we get the depth of the first completion
const auto& completions = this->getConnections( timestep );
if( completions.size() == 0 ) {
throw std::invalid_argument( "No completions defined for well: "
+ name()
+ ". Can not infer reference depth" );
}
return completions.get( 0 ).depth();
}
void Well::setRefDepth( size_t timestep, double depth ) {
this->m_refDepth.update( timestep, depth );
}
void Well::setDrainageRadius( size_t timestep, double radius ) {
this->m_drainageRadius.update( timestep, radius );
}
double Well::getDrainageRadius(size_t timestep) const {
return m_drainageRadius.get( timestep );
}
Phase Well::getPreferredPhase() const {
return m_preferredPhase;
}
const WellConnections& Well::getConnections(size_t timeStep) const {
return *m_completions.get( timeStep );
}
std::map<int, std::vector<Connection>> Well::getCompletions(size_t time_step) const {
std::map<int, std::vector<Connection>> completions;
const auto& connections = this->getConnections(time_step);
for (const auto& conn : connections) {
auto pair = completions.find( conn.complnum() );
if (pair == completions.end())
completions[conn.complnum()] = {};
pair = completions.find(conn.complnum());
pair->second.push_back(conn);
}
return completions;
}
WellConnections Well::getActiveConnections(size_t timeStep, const EclipseGrid& grid) const {
return WellConnections(this->getConnections(timeStep), grid);
}
const WellConnections& Well::getConnections() const {
return *m_completions.back();
}
std::size_t Well::getTotNoConn() const {
std::size_t time_step = this->timesteps;
const auto& connections = this->getConnections(time_step);
return connections.inputSize();
}
const std::string Well::getGroupName(size_t time_step) const {
return m_groupName.get(time_step);
}
void Well::setGroupName(size_t time_step, const std::string& groupName ) {
m_groupName.update(time_step , groupName);
}
size_t Well::firstTimeStep( ) const {
return m_creationTimeStep;
}
WellCompletion::CompletionOrderEnum Well::getWellConnectionOrdering() const {
return m_comporder;
}
bool Well::wellNameInWellNamePattern(const std::string& wellName, const std::string& wellNamePattern) {
bool wellNameInPattern = false;
if (util_fnmatch( wellNamePattern.c_str() , wellName.c_str()) == 0) {
wellNameInPattern = true;
}
return wellNameInPattern;
}
bool Well::getAllowCrossFlow() const {
return m_allowCrossFlow;
}
bool Well::getAutomaticShutIn() const {
return m_automaticShutIn;
}
bool Well::canOpen(size_t currentStep) const {
if( getAllowCrossFlow() ) return true;
if( isInjector( currentStep ) )
return getInjectionProperties( currentStep ).surfaceInjectionRate != 0;
const auto& prod = getProductionProperties( currentStep );
return (prod.WaterRate + prod.OilRate + prod.GasRate) != 0;
}
const WellSegments& Well::getWellSegments(size_t time_step) const {
return m_segmentset.get(time_step);
}
bool Well::isMultiSegment(size_t time_step) const {
return (getWellSegments(time_step).size() > 0);
}
void Well::addWellSegments(size_t time_step, WellSegments new_segmentset ) {
// to see if it is the first time entering WELSEGS input to this well.
// if the well is not multi-segment well, it will be the first time
// not sure if a well can switch between mutli-segment well and other
// type of well
// Here, we assume not
const bool first_time = !isMultiSegment(time_step);
if( !first_time ) {
// checking the consistency of the input WELSEGS information
throw std::logic_error("re-entering WELSEGS for a well is not supported yet!!.");
}
// overwrite the BHP reference depth with the one from WELSEGS keyword
const double ref_depth = new_segmentset.depthTopSegment();
m_refDepth.update( time_step, ref_depth );
new_segmentset.process(first_time);
m_segmentset.update(time_step, new_segmentset);
}
WellConnections * Well::newWellConnections(size_t time_step) {
return new WellConnections( this->m_headI[time_step], this->m_headJ[time_step]);
}
void Well::updateWellConnections(size_t time_step, WellConnections * new_set ){
if( getWellConnectionOrdering() == WellCompletion::TRACK) {
const auto headI = this->m_headI[ time_step ];
const auto headJ = this->m_headJ[ time_step ];
new_set->orderConnections( headI, headJ );
}
//This breaks test at line 824 in ScheduleTests
/*if (new_set->allConnectionsShut())
this->setStatus(time_step, WellCommon::SHUT );
*/
m_completions.update( time_step, std::shared_ptr<WellConnections>( new_set ));
}
void Well::filterConnections(const EclipseGrid& grid) {
/*
The m_completions member variable is DynamicState<WellConnections>
instance, hence this for loop is over all timesteps.
*/
for (auto& completions : m_completions)
completions->filter(grid);
}
namespace {
bool defaulted(const DeckRecord& rec, const std::string& s) {
const auto& item = rec.getItem( s );
if (item.defaultApplied(0))
return true;
if (item.get<int>(0) == 0)
return true;
return false;
}
int limit(const DeckRecord& rec, const std::string&s , int shift) {
const auto& item = rec.getItem( s );
return shift + item.get<int>(0);
}
bool match_le(int value, const DeckRecord& rec, const std::string& s, int shift = 0) {
if (defaulted(rec,s))
return true;
return (value <= limit(rec,s,shift));
}
bool match_ge(int value, const DeckRecord& rec, const std::string& s, int shift = 0) {
if (defaulted(rec,s))
return true;
return (value >= limit(rec,s,shift));
}
bool match_eq(int value, const DeckRecord& rec, const std::string& s, int shift = 0) {
if (defaulted(rec,s))
return true;
return (limit(rec,s,shift) == value);
}}
void Well::handleCOMPLUMP(const DeckRecord& record, size_t time_step) {
auto match = [=]( const Connection& c ) -> bool {
if (!match_eq(c.getI(), record, "I" , -1)) return false;
if (!match_eq(c.getJ(), record, "J" , -1)) return false;
if (!match_ge(c.getK(), record, "K1", -1)) return false;
if (!match_le(c.getK(), record, "K2", -1)) return false;
return true;
};
WellConnections * new_connections = this->newWellConnections(time_step);
const int complnum = record.getItem("N").get<int>(0);
if (complnum <= 0)
throw std::invalid_argument("Completion number must be >= 1. COMPLNUM=" + std::to_string(complnum) + "is invalid");
for (auto c : this->getConnections(time_step)) {
if (match(c))
c.setComplnum( complnum );
new_connections->add(c);
}
this->updateWellConnections(time_step, new_connections);
}
void Well::handleWELOPEN(const DeckRecord& record, size_t time_step, WellCompletion::StateEnum status) {
auto match = [=]( const Connection &c) -> bool {
if (!match_eq(c.getI(), record, "I" , -1)) return false;
if (!match_eq(c.getJ(), record, "J" , -1)) return false;
if (!match_eq(c.getK(), record, "K", -1)) return false;
if (!match_ge(c.complnum(), record, "C1")) return false;
if (!match_le(c.complnum(), record, "C2")) return false;
return true;
};
WellConnections * new_connections = this->newWellConnections(time_step);
for (auto c : this->getConnections(time_step)) {
if (match(c))
c.setState( status );
new_connections->add(c);
}
this->updateWellConnections(time_step, new_connections);
}
void Well::handleCOMPDAT(size_t time_step, const DeckRecord& record, const EclipseGrid& grid, const Eclipse3DProperties& eclipseProperties) {
WellConnections * connections = new WellConnections(this->getConnections(time_step));
connections->loadCOMPDAT(record, grid, eclipseProperties);
this->updateWellConnections(time_step, connections);
}
void Well::handleCOMPSEGS(const DeckKeyword& keyword, const EclipseGrid& grid, size_t time_step) {
const auto& segment_set = this->getWellSegments(time_step);
const auto& completion_set = this->getConnections( time_step );
WellConnections * new_connection_set = newConnectionsWithSegments(keyword, completion_set, segment_set, grid);
this->updateWellConnections(time_step, new_connection_set);
}
void Well::handleWPIMULT(const DeckRecord& record, size_t time_step) {
auto match = [=]( const Connection &c) -> bool {
if (!match_ge(c.complnum(), record, "FIRST")) return false;
if (!match_le(c.complnum(), record, "LAST")) return false;
if (!match_eq(c.getI() , record, "I", -1)) return false;
if (!match_eq(c.getJ() , record, "J", -1)) return false;
if (!match_eq(c.getK() , record, "K", -1)) return false;
return true;
};
WellConnections * new_connections = this->newWellConnections(time_step);
double wellPi = record.getItem("WELLPI").get< double >(0);
for (auto c : this->getConnections(time_step)) {
if (match(c))
c.scaleWellPi( wellPi );
new_connections->add(c);
}
this->updateWellConnections(time_step, new_connections);
}
void Well::handleWELSEGS(const DeckKeyword& keyword, size_t time_step) {
WellSegments newSegmentset;
newSegmentset.loadWELSEGS(keyword);
// update multi-segment related information for the well
this->addWellSegments(time_step, newSegmentset);
}
}

61
src/opm/parser/eclipse/EclipseState/Schedule/Well/Well2.cpp
View File

@ -104,9 +104,9 @@ Well2::Well2(const std::string& wname,
production(std::make_shared<WellProductionProperties>()),
injection(std::make_shared<WellInjectionProperties>())
{
WellProductionProperties * p = new WellProductionProperties(*this->production);
auto p = std::make_shared<WellProductionProperties>();
p->whistctl_cmode = whistctl_cmode;
this->production.reset( p );
this->updateProduction(p);
}
bool Well2::updateEfficiencyFactor(double efficiency_factor) {
@ -148,7 +148,6 @@ bool Well2::updateEconLimits(std::shared_ptr<WellEconProductionLimits> econ_limi
return false;
}
void Well2::switchToProducer() {
auto p = std::make_shared<WellInjectionProperties>(this->getInjectionProperties());
@ -355,6 +354,11 @@ bool Well2::isProducer() const {
return this->producer;
}
bool Well2::isInjector() const {
return !this->producer;
}
bool Well2::isAvailableForGroupControl() const {
return this->guide_rate.available;
}
@ -584,6 +588,13 @@ std::size_t Well2::firstTimeStep() const {
return this->init_step;
}
bool Well2::hasBeenDefined(size_t timeStep) const {
if (timeStep < this->init_step)
return false;
else
return true;
}
bool Well2::canOpen() const {
@ -619,6 +630,50 @@ WellCompletion::CompletionOrderEnum Well2::getWellConnectionOrdering() const {
return this->ordering;
}
double Well2::production_rate( Phase phase) const {
if( !this->isProducer() ) return 0.0;
const auto& p = this->getProductionProperties();
switch( phase ) {
case Phase::WATER: return p.WaterRate;
case Phase::OIL: return p.OilRate;
case Phase::GAS: return p.GasRate;
case Phase::SOLVENT:
throw std::invalid_argument( "Production of 'SOLVENT' requested." );
case Phase::POLYMER:
throw std::invalid_argument( "Production of 'POLYMER' requested." );
case Phase::ENERGY:
throw std::invalid_argument( "Production of 'ENERGY' requested." );
case Phase::POLYMW:
throw std::invalid_argument( "Production of 'POLYMW' requested.");
}
throw std::logic_error( "Unreachable state. Invalid Phase value. "
"This is likely a programming error." );
}
double Well2::injection_rate( Phase phase) const {
if( !this->isInjector() ) return 0.0;
const auto& i = this->getInjectionProperties();
const auto type = i.injectorType;
if( phase == Phase::WATER && type != WellInjector::WATER ) return 0.0;
if( phase == Phase::OIL && type != WellInjector::OIL ) return 0.0;
if( phase == Phase::GAS && type != WellInjector::GAS ) return 0.0;
return i.surfaceInjectionRate;
}
bool Well2::wellNameInWellNamePattern(const std::string& wellName, const std::string& wellNamePattern) {
bool wellNameInPattern = false;
if (util_fnmatch( wellNamePattern.c_str() , wellName.c_str()) == 0) {
wellNameInPattern = true;
}
return wellNameInPattern;
}
}

37
src/opm/parser/eclipse/EclipseState/SummaryConfig/SummaryConfig.cpp
View File

@ -39,7 +39,6 @@
#include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/TimeMap.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/Connection.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/Well.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/WellConnections.hpp>
#include <opm/parser/eclipse/EclipseState/SummaryConfig/SummaryConfig.hpp>
@ -294,8 +293,6 @@ inline void keywordMISC( SummaryConfig::keyword_list& list,
const GridDims& dims) {
const auto& keywordstring = keyword.name();
const auto last_timestep = schedule.getTimeMap().last();
for( const auto& record : keyword ) {
const auto& wellitem = record.getItem( 0 );
@ -308,13 +305,13 @@ inline void keywordMISC( SummaryConfig::keyword_list& list,
handleMissingWell( parseContext, errors, keyword.name(), wellitem.getTrimmedString( 0 ) );
for(const auto& name : well_names) {
const auto* well = schedule.getWell(name);
const auto& well = schedule.getWell2atEnd(name);
/*
* we don't want to add completions that don't exist, so we iterate
* over a well's completions regardless of the desired block is
* defaulted or not
*/
for( const auto& connection : well->getConnections( last_timestep ) ) {
for( const auto& connection : well.getConnections() ) {
/* block coordinates defaulted */
auto cijk = getijk( connection );
@ -354,34 +351,20 @@ inline void keywordMISC( SummaryConfig::keyword_list& list,
});
}
bool isMultiSegmentWell(const std::size_t last_timestep,
const Well* well)
{
for (auto step = 0*last_timestep;
step <= last_timestep; ++step)
{
if (well->isMultiSegment(step)) {
return true;
}
}
return false;
}
int maxNumWellSegments(const std::size_t last_timestep,
const Well* well)
const Well2& well)
{
auto numSeg = 0;
for (auto step = 0*last_timestep;
step <= last_timestep; ++step)
{
if (! well->isMultiSegment(step)) {
if (! well.isMultiSegment())
continue;
}
const auto nseg =
well->getWellSegments(last_timestep).size();
well.getSegments().size();
if (nseg > numSeg) {
numSeg = nseg;
@ -394,7 +377,7 @@ inline void keywordMISC( SummaryConfig::keyword_list& list,
void makeSegmentNodes(const std::size_t last_timestep,
const int segID,
const DeckKeyword& keyword,
const Well* well,
const Well2& well,
SummaryConfig::keyword_list& list)
{
// Modifies 'list' in place.
@ -404,11 +387,11 @@ inline void keywordMISC( SummaryConfig::keyword_list& list,
list.push_back(SummaryConfig::keyword_type( keyword.name(), well, segNumber ));
};
if (! isMultiSegmentWell(last_timestep, well))
if (!well.isMultiSegment())
// Not an MSW. Don't create summary vectors for segments.
return;
const auto& wname = well->name();
const auto& wname = well.name();
if (segID < 1) {
// Segment number defaulted. Allocate a summary
// vector for each segment.
@ -443,7 +426,7 @@ inline void keywordMISC( SummaryConfig::keyword_list& list,
const auto segID = -1;
for (const auto& well : schedule.getWells())
for (const auto& well : schedule.getWells2atEnd())
makeSegmentNodes(last_timestep, segID, keyword,
well, list);
}
@ -487,7 +470,7 @@ inline void keywordMISC( SummaryConfig::keyword_list& list,
? -1 : record.getItem(1).get<int>(0);
for (const auto& well_name : well_names)
makeSegmentNodes(last_timestep, segID, keyword, schedule.getWell(well_name), list);
makeSegmentNodes(last_timestep, segID, keyword, schedule.getWell2atEnd(well_name), list);
}
}

65
tests/msim/test_msim_ACTIONX.cpp
View File

@ -130,14 +130,16 @@ BOOST_AUTO_TEST_CASE(UDQ_SORTA_EXAMPLE) {
sim.run(td.schedule, io);
{
const auto& w1 = td.schedule.getWell("P1");
const auto& w4 = td.schedule.getWell("P4");
std::size_t last_step = td.schedule.size() - 1;
BOOST_CHECK_EQUAL(w1->getStatus(1), WellCommon::StatusEnum::OPEN );
BOOST_CHECK_EQUAL(w4->getStatus(1), WellCommon::StatusEnum::OPEN );
BOOST_CHECK_EQUAL(w1->getStatus(last_step), WellCommon::StatusEnum::OPEN );
BOOST_CHECK_EQUAL(w4->getStatus(last_step), WellCommon::StatusEnum::SHUT );
const auto& w1 = td.schedule.getWell2("P1", 1);
const auto& w4 = td.schedule.getWell2("P4", 1);
BOOST_CHECK_EQUAL(w1.getStatus(), WellCommon::StatusEnum::OPEN );
BOOST_CHECK_EQUAL(w4.getStatus(), WellCommon::StatusEnum::OPEN );
}
{
const auto& w1 = td.schedule.getWell2atEnd("P1");
const auto& w4 = td.schedule.getWell2atEnd("P4");
BOOST_CHECK_EQUAL(w1.getStatus(), WellCommon::StatusEnum::OPEN );
BOOST_CHECK_EQUAL(w4.getStatus(), WellCommon::StatusEnum::SHUT );
}
test_work_area_free(work_area);
@ -165,36 +167,37 @@ BOOST_AUTO_TEST_CASE(WELL_CLOSE_EXAMPLE) {
sim.well_rate("P4", data::Rates::opt::wat, prod_wpr_P4);
{
const auto& w1 = td.schedule.getWell("P1");
const auto& w2 = td.schedule.getWell("P2");
const auto& w3 = td.schedule.getWell("P3");
const auto& w4 = td.schedule.getWell("P4");
const auto& w1 = td.schedule.getWell2("P1", 15);
const auto& w2 = td.schedule.getWell2("P2", 15);
const auto& w3 = td.schedule.getWell2("P3", 15);
const auto& w4 = td.schedule.getWell2("P4", 15);
BOOST_CHECK_EQUAL(w1->getStatus(15), WellCommon::StatusEnum::OPEN );
BOOST_CHECK_EQUAL(w2->getStatus(15), WellCommon::StatusEnum::OPEN );
BOOST_CHECK_EQUAL(w3->getStatus(15), WellCommon::StatusEnum::OPEN );
BOOST_CHECK_EQUAL(w4->getStatus(15), WellCommon::StatusEnum::OPEN );
BOOST_CHECK_EQUAL(w1.getStatus(), WellCommon::StatusEnum::OPEN );
BOOST_CHECK_EQUAL(w2.getStatus(), WellCommon::StatusEnum::OPEN );
BOOST_CHECK_EQUAL(w3.getStatus(), WellCommon::StatusEnum::OPEN );
BOOST_CHECK_EQUAL(w4.getStatus(), WellCommon::StatusEnum::OPEN );
}
sim.run(td.schedule, io);
{
const auto& w1 = td.schedule.getWell("P1");
const auto& w2 = td.schedule.getWell("P2");
const auto& w3 = td.schedule.getWell("P3");
const auto& w4 = td.schedule.getWell("P4");
BOOST_CHECK_EQUAL(w1->getStatus(15), WellCommon::StatusEnum::OPEN );
BOOST_CHECK_EQUAL(w3->getStatus(15), WellCommon::StatusEnum::OPEN );
BOOST_CHECK_EQUAL(w2->getStatus(5), WellCommon::StatusEnum::OPEN );
BOOST_CHECK_EQUAL(w2->getStatus(6), WellCommon::StatusEnum::SHUT );
BOOST_CHECK_EQUAL(w4->getStatus(10), WellCommon::StatusEnum::OPEN );
BOOST_CHECK_EQUAL(w4->getStatus(11), WellCommon::StatusEnum::SHUT );
const auto& w1 = td.schedule.getWell2("P1", 15);
const auto& w3 = td.schedule.getWell2("P3", 15);
BOOST_CHECK_EQUAL(w1.getStatus(), WellCommon::StatusEnum::OPEN );
BOOST_CHECK_EQUAL(w3.getStatus(), WellCommon::StatusEnum::OPEN );
}
{
const auto& w2_5 = td.schedule.getWell2("P2", 5);
const auto& w2_6 = td.schedule.getWell2("P2", 6);
BOOST_CHECK_EQUAL(w2_5.getStatus(), WellCommon::StatusEnum::OPEN );
BOOST_CHECK_EQUAL(w2_6.getStatus(), WellCommon::StatusEnum::SHUT );
}
{
const auto& w4_10 = td.schedule.getWell2("P4", 10);
const auto& w4_11 = td.schedule.getWell2("P4", 11);
BOOST_CHECK_EQUAL(w4_10.getStatus(), WellCommon::StatusEnum::OPEN );
BOOST_CHECK_EQUAL(w4_11.getStatus(), WellCommon::StatusEnum::SHUT );
}
test_work_area_free(work_area);
}

8
tests/parser/ConnectionTests.cpp
View File

@ -203,8 +203,8 @@ BOOST_AUTO_TEST_CASE(loadCOMPDATTESTSPE1) {
Opm::Schedule sched(deck, state);
const auto& units = deck.getActiveUnitSystem();
const auto& prod = sched.getWell("PROD");
const auto& connections = prod->getConnections(0);
const auto& prod = sched.getWell2("PROD", 0);
const auto& connections = prod.getConnections();
const auto& conn0 = connections[0];
/* Expected values come from Eclipse simulation. */
BOOST_CHECK_CLOSE(conn0.CF(), units.to_si(Opm::UnitSystem::measure::transmissibility, 10.609), 2e-2);
@ -316,8 +316,8 @@ BOOST_AUTO_TEST_CASE(loadCOMPDATTESTSPE9) {
{"PRODU26" ,3 , 0.176, 118.6}};
for (const auto& ec : expected) {
const auto& well = sched.getWell(ec.well);
const auto& connections = well->getConnections(0);
const auto& well = sched.getWell2(ec.well, 0);
const auto& connections = well.getConnections();
const auto& conn = connections[ec.ci - 1];
BOOST_CHECK_CLOSE( conn.CF(), units.to_si(Opm::UnitSystem::measure::transmissibility, ec.CF), 2e-1);

2
tests/parser/DynamicStateTests.cpp
View File

@ -26,8 +26,6 @@
#include <boost/test/unit_test.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/Well.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/TimeMap.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/DynamicState.hpp>

2
tests/parser/DynamicVectorTests.cpp
View File

@ -23,8 +23,6 @@
#include <boost/test/unit_test.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/Well.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/TimeMap.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/DynamicState.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/DynamicVector.hpp>

25
tests/parser/GroupTests.cpp
View File

@ -31,7 +31,6 @@
#include <opm/parser/eclipse/EclipseState/Util/Value.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/Well.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Group.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/TimeMap.hpp>
@ -156,8 +155,8 @@ BOOST_AUTO_TEST_CASE(GroupAddWell) {
auto timeMap = createXDaysTimeMap( 10 );
Opm::Group group("G1" , 1, timeMap , 0);
auto well1 = std::make_shared< Well >("WELL1", 1, 0, 0, 0.0, 0.0, Opm::Phase::OIL, Opm::WellProducer::CMODE_UNDEFINED, timeMap, 0);
auto well2 = std::make_shared< Well >("WELL2", 2, 0, 0, 0.0, 0.0, Opm::Phase::OIL, Opm::WellProducer::CMODE_UNDEFINED, timeMap, 0);
auto well1 = std::make_shared< Well2 >("WELL1", "G1", 0, 1, 0, 0, 0.0, Opm::Phase::OIL, WellProducer::CMODE_UNDEFINED, WellCompletion::DEPTH);
auto well2 = std::make_shared< Well2 >("WELL2", "G1", 0, 2, 0, 0, 0.0, Opm::Phase::OIL, WellProducer::CMODE_UNDEFINED, WellCompletion::DEPTH);
BOOST_CHECK_EQUAL(0U , group.numWells(2));
group.addWell( 3 , well1->name() );
@ -193,8 +192,8 @@ BOOST_AUTO_TEST_CASE(GroupAddAndDelWell) {
auto timeMap = createXDaysTimeMap( 10 );
Opm::Group group("G1" , 1, timeMap , 0);
auto well1 = std::make_shared< Well >("WELL1", 1, 0, 0, 0.0, 0.0, Opm::Phase::OIL, Opm::WellProducer::CMODE_UNDEFINED, timeMap, 0);
auto well2 = std::make_shared< Well >("WELL2", 2, 0, 0, 0.0, 0.0, Opm::Phase::OIL, Opm::WellProducer::CMODE_UNDEFINED, timeMap, 0);
auto well1 = std::make_shared< Well2 >("WELL1", "G1", 0, 1, 0, 0, 0.0, Opm::Phase::OIL, WellProducer::CMODE_UNDEFINED, WellCompletion::DEPTH);
auto well2 = std::make_shared< Well2 >("WELL2", "G1", 0, 2, 0, 0, 0.0, Opm::Phase::OIL, WellProducer::CMODE_UNDEFINED, WellCompletion::DEPTH);
BOOST_CHECK_EQUAL(0U , group.numWells(2));
group.addWell( 3 , well1->name() );
@ -226,8 +225,8 @@ BOOST_AUTO_TEST_CASE(GroupAddAndDelWell) {
BOOST_AUTO_TEST_CASE(getWells) {
auto timeMap = createXDaysTimeMap( 10 );
Opm::Group group("G1" , 1, timeMap , 0);
auto well1 = std::make_shared< Well >("WELL1", 1, 0, 0, 0.0, 0.0, Opm::Phase::OIL, Opm::WellProducer::CMODE_UNDEFINED, timeMap, 0);
auto well2 = std::make_shared< Well >("WELL2", 2, 0, 0, 0.0, 0.0, Opm::Phase::OIL, Opm::WellProducer::CMODE_UNDEFINED, timeMap, 0);
auto well1 = std::make_shared< Well2 >("WELL1", "G1", 0, 1, 0, 0, 0.0, Opm::Phase::OIL, WellProducer::CMODE_UNDEFINED, WellCompletion::DEPTH);
auto well2 = std::make_shared< Well2 >("WELL2", "G1", 0, 2, 0, 0, 0.0, Opm::Phase::OIL, WellProducer::CMODE_UNDEFINED, WellCompletion::DEPTH);
group.addWell( 2 , well1->name() );
group.addWell( 3 , well1->name() );
@ -333,14 +332,14 @@ BOOST_AUTO_TEST_CASE(createDeckWithWGRUPCONandWCONPROD) {
Eclipse3DProperties eclipseProperties ( deck , table, grid);
Runspec runspec (deck );
Opm::Schedule schedule(deck, grid, eclipseProperties, runspec);
const auto* currentWell = schedule.getWell("B-37T2");
const Opm::WellProductionProperties& wellProductionProperties = currentWell->getProductionProperties(0);
const auto& currentWell = schedule.getWell2("B-37T2", 0);
const Opm::WellProductionProperties& wellProductionProperties = currentWell.getProductionProperties();
BOOST_CHECK_EQUAL(wellProductionProperties.controlMode, Opm::WellProducer::ControlModeEnum::GRUP);
BOOST_CHECK_EQUAL(currentWell->isAvailableForGroupControl(0), true);
BOOST_CHECK_EQUAL(currentWell->getGuideRate(0), 30);
BOOST_CHECK_EQUAL(currentWell->getGuideRatePhase(0), Opm::GuideRate::OIL);
BOOST_CHECK_EQUAL(currentWell->getGuideRateScalingFactor(0), 1.0);
BOOST_CHECK_EQUAL(currentWell.isAvailableForGroupControl(), true);
BOOST_CHECK_EQUAL(currentWell.getGuideRate(), 30);
BOOST_CHECK_EQUAL(currentWell.getGuideRatePhase(), Opm::GuideRate::OIL);
BOOST_CHECK_EQUAL(currentWell.getGuideRateScalingFactor(), 1.0);
}

878
tests/parser/ScheduleTests.cpp
View File

File diff suppressed because it is too large Load Diff

1
tests/parser/WTEST.cpp
View File

@ -31,7 +31,6 @@
#include <opm/parser/eclipse/EclipseState/Schedule/Well/WellTestState.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/WellTestConfig.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/WellConnections.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/Well.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/TimeMap.hpp>
#include <opm/parser/eclipse/Parser/ParseContext.hpp>
#include <opm/parser/eclipse/Parser/Parser.hpp>

10
tests/parser/WellSolventTests.cpp
View File

@ -24,7 +24,6 @@
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/Well.hpp>
#include <opm/parser/eclipse/Deck/Deck.hpp>
#include <opm/parser/eclipse/Deck/DeckItem.hpp>
#include <opm/parser/eclipse/Deck/DeckKeyword.hpp>
@ -206,11 +205,10 @@ BOOST_AUTO_TEST_CASE(TestDynamicWSOLVENT) {
const auto& record = keyword.getRecord(0);
const std::string& well_name = record.getItem("WELL").getTrimmedString(0);
BOOST_CHECK_EQUAL(well_name, "W_1");
const auto* well = schedule.getWell(well_name);
BOOST_CHECK_EQUAL(well->getSolventFraction(0),0); //default 0
BOOST_CHECK_EQUAL(well->getSolventFraction(1),1);
BOOST_CHECK_EQUAL(well->getSolventFraction(2),1);
BOOST_CHECK_EQUAL(well->getSolventFraction(3),0);
BOOST_CHECK_EQUAL(schedule.getWell2("W_1", 0).getSolventFraction(),0); //default 0
BOOST_CHECK_EQUAL(schedule.getWell2("W_1", 1).getSolventFraction(),1);
BOOST_CHECK_EQUAL(schedule.getWell2("W_1", 2).getSolventFraction(),1);
BOOST_CHECK_EQUAL(schedule.getWell2("W_1", 3).getSolventFraction(),0);
}
BOOST_AUTO_TEST_CASE(TestOilInjector) {

549
tests/parser/WellTests.cpp
View File

@ -36,7 +36,6 @@
#include <opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/Connection.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/WellConnections.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/Well.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/WellProductionProperties.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/TimeMap.hpp>
#include <opm/parser/eclipse/Parser/ParseContext.hpp>
@ -44,143 +43,16 @@
using namespace Opm;
static Opm::TimeMap createXDaysTimeMap(size_t numDays) {
const std::time_t startDate = Opm::TimeMap::mkdate(2010, 1, 1);
Opm::TimeMap timeMap{ startDate };
for (size_t i = 0; i < numDays; i++)
timeMap.addTStep((i+1) * 24 * 60 * 60);
return timeMap;
}
namespace Opm {
inline std::ostream& operator<<( std::ostream& stream, const Connection& c ) {
return stream << "(" << c.getI() << "," << c.getJ() << "," << c.getK() << ")";
}
inline std::ostream& operator<<( std::ostream& stream, const Well& well ) {
inline std::ostream& operator<<( std::ostream& stream, const Well2& well ) {
return stream << "(" << well.name() << ")";
}
}
BOOST_AUTO_TEST_CASE(CreateWell_CorrectNameAndDefaultValues) {
auto timeMap = createXDaysTimeMap(10);
Opm::Well well("WELL1" , 1, 0, 0, 0.0, 0.0, Opm::Phase::OIL, Opm::WellProducer::CMODE_UNDEFINED, timeMap , 0);
BOOST_CHECK_EQUAL( "WELL1" , well.name() );
BOOST_CHECK_EQUAL(0.0 , well.getProductionPropertiesCopy(5).OilRate);
}
BOOST_AUTO_TEST_CASE(CreateWell_GetProductionPropertiesShouldReturnSameObject) {
auto timeMap = createXDaysTimeMap(10);
Opm::Well well("WELL1" , 1, 0, 0, 0.0, 0.0, Opm::Phase::OIL, Opm::WellProducer::CMODE_UNDEFINED, timeMap , 0);
BOOST_CHECK_EQUAL(&(well.getProductionProperties(5)), &(well.getProductionProperties(5)));
BOOST_CHECK_EQUAL(&(well.getProductionProperties(8)), &(well.getProductionProperties(8)));
BOOST_CHECK_EQUAL(well.getProductionProperties(5), well.getProductionProperties(8));
}
BOOST_AUTO_TEST_CASE(CreateWell_GetInjectionPropertiesShouldReturnSameObject) {
auto timeMap = createXDaysTimeMap(10);
Opm::Well well("WELL1" , 1, 0, 0, 0.0, 0.0, Opm::Phase::WATER, Opm::WellProducer::CMODE_UNDEFINED, timeMap , 0);
BOOST_CHECK_EQUAL(&(well.getInjectionProperties(5)), &(well.getInjectionProperties(5)));
BOOST_CHECK_EQUAL(&(well.getInjectionProperties(8)), &(well.getInjectionProperties(8)));
BOOST_CHECK_EQUAL(well.getInjectionProperties(5), well.getInjectionProperties(8));
}
BOOST_AUTO_TEST_CASE(CreateWellCreateTimeStepOK) {
auto timeMap = createXDaysTimeMap(10);
Opm::Well well("WELL1" , 1, 0, 0, 0.0, 0.0, Opm::Phase::OIL, Opm::WellProducer::CMODE_UNDEFINED, timeMap , 5);
BOOST_CHECK_EQUAL( false , well.hasBeenDefined(0) );
BOOST_CHECK_EQUAL( false , well.hasBeenDefined(4) );
BOOST_CHECK_EQUAL( true , well.hasBeenDefined(5) );
BOOST_CHECK_EQUAL( true , well.hasBeenDefined(7) );
}
BOOST_AUTO_TEST_CASE(setWellProductionProperties_PropertiesSetCorrect) {
auto timeMap = createXDaysTimeMap(10);
Opm::Well well("WELL1" , 1, 0, 0, 0.0, 0.0, Opm::Phase::OIL, Opm::WellProducer::CMODE_UNDEFINED, timeMap , 0);
BOOST_CHECK_EQUAL(0.0 , well.getProductionPropertiesCopy( 5 ).OilRate);
Opm::WellProductionProperties props;
props.OilRate = 99;
props.GasRate = 98;
props.WaterRate = 97;
props.LiquidRate = 96;
props.ResVRate = 95;
well.setProductionProperties( 5 , props);
BOOST_CHECK_EQUAL(99 , well.getProductionPropertiesCopy( 5 ).OilRate);
BOOST_CHECK_EQUAL(98 , well.getProductionPropertiesCopy( 5 ).GasRate);
BOOST_CHECK_EQUAL(97 , well.getProductionPropertiesCopy( 5 ).WaterRate);
BOOST_CHECK_EQUAL(96 , well.getProductionPropertiesCopy( 5 ).LiquidRate);
BOOST_CHECK_EQUAL(95 , well.getProductionPropertiesCopy( 5 ).ResVRate);
BOOST_CHECK_EQUAL(99 , well.getProductionPropertiesCopy( 8 ).OilRate);
BOOST_CHECK_EQUAL(98 , well.getProductionPropertiesCopy( 8 ).GasRate);
BOOST_CHECK_EQUAL(97 , well.getProductionPropertiesCopy( 8 ).WaterRate);
BOOST_CHECK_EQUAL(96 , well.getProductionPropertiesCopy( 8 ).LiquidRate);
BOOST_CHECK_EQUAL(95 , well.getProductionPropertiesCopy( 8 ).ResVRate);
BOOST_CHECK_EQUAL(99, well.production_rate( Opm::Phase::OIL, 5 ) );
BOOST_CHECK_EQUAL(99, well.production_rate( Opm::Phase::OIL, 8 ) );
BOOST_CHECK_EQUAL(98, well.production_rate( Opm::Phase::GAS, 5 ) );
BOOST_CHECK_EQUAL(98, well.production_rate( Opm::Phase::GAS, 8 ) );
BOOST_CHECK_EQUAL(0.0, well.injection_rate( Opm::Phase::GAS, 8 ) );
BOOST_CHECK_THROW( well.production_rate( Opm::Phase::SOLVENT, 5 ), std::invalid_argument );
}
BOOST_AUTO_TEST_CASE(setOilRate_RateSetCorrect) {
auto timeMap = createXDaysTimeMap(10);
Opm::Well well("WELL1" , 1, 0, 0, 0.0, 0.0, Opm::Phase::OIL, Opm::WellProducer::CMODE_UNDEFINED, timeMap , 0);
BOOST_CHECK_EQUAL(0.0 , well.getProductionPropertiesCopy(5).OilRate);
Opm::WellProductionProperties props;
props.OilRate = 99;
well.setProductionProperties( 5 , props);
BOOST_CHECK_EQUAL(99 , well.getProductionPropertiesCopy(5).OilRate);
BOOST_CHECK_EQUAL(99 , well.getProductionPropertiesCopy(8).OilRate);
}
BOOST_AUTO_TEST_CASE(seLiquidRate_RateSetCorrect) {
auto timeMap = createXDaysTimeMap(10);
Opm::Well well("WELL1" , 1, 0, 0, 0.0, 0.0, Opm::Phase::OIL, Opm::WellProducer::CMODE_UNDEFINED, timeMap , 0);
BOOST_CHECK_EQUAL(0.0 , well.getProductionPropertiesCopy(5).LiquidRate);
Opm::WellProductionProperties props;
props.LiquidRate = 99;
well.setProductionProperties( 5 , props);
BOOST_CHECK_EQUAL(99 , well.getProductionPropertiesCopy(5).LiquidRate);
BOOST_CHECK_EQUAL(99 , well.getProductionPropertiesCopy(8).LiquidRate);
}
BOOST_AUTO_TEST_CASE(setPredictionModeProduction_ModeSetCorrect) {
auto timeMap = createXDaysTimeMap(10);
Opm::Well well("WELL1" , 1, 0, 0, 0.0, 0.0, Opm::Phase::OIL, Opm::WellProducer::CMODE_UNDEFINED, timeMap , 0);
BOOST_CHECK_EQUAL( true, well.getProductionPropertiesCopy(5).predictionMode);
Opm::WellProductionProperties props;
props.predictionMode = false;
well.setProductionProperties( 5 , props);
BOOST_CHECK( !well.getProductionPropertiesCopy(5).predictionMode );
BOOST_CHECK( !well.getProductionPropertiesCopy(8).predictionMode );
}
BOOST_AUTO_TEST_CASE(setpredictionModeInjection_ModeSetCorrect) {
auto timeMap = createXDaysTimeMap(10);
Opm::Well well("WELL1" , 1, 0, 0, 0.0, 0.0, Opm::Phase::WATER, Opm::WellProducer::CMODE_UNDEFINED, timeMap , 0);
BOOST_CHECK_EQUAL( true, well.getInjectionPropertiesCopy(5).predictionMode);
Opm::WellInjectionProperties props;
props.predictionMode = false;
well.setInjectionProperties( 5 , props);
BOOST_CHECK_EQUAL(false , well.getInjectionPropertiesCopy(5).predictionMode);
BOOST_CHECK_EQUAL(false , well.getInjectionPropertiesCopy(8).predictionMode);
}
BOOST_AUTO_TEST_CASE(WellCOMPDATtestTRACK) {
Opm::Parser parser;
@ -213,10 +85,9 @@ BOOST_AUTO_TEST_CASE(WellCOMPDATtestTRACK) {
Eclipse3DProperties eclipseProperties ( deck , table, grid);
Opm::Runspec runspec (deck);
Opm::Schedule schedule(deck, grid , eclipseProperties, runspec);
auto* op_1 = schedule.getWell("OP_1");
const auto& op_1 = schedule.getWell2("OP_1", 2);
size_t timestep = 2;
const auto& completions = op_1->getConnections( timestep );
const auto& completions = op_1.getConnections();
BOOST_CHECK_EQUAL(9U, completions.size());
//Verify TRACK completion ordering
@ -254,10 +125,9 @@ BOOST_AUTO_TEST_CASE(WellCOMPDATtestDefaultTRACK) {
Eclipse3DProperties eclipseProperties ( deck , table, grid);
Opm::Runspec runspec (deck);
Opm::Schedule schedule(deck, grid , eclipseProperties, runspec);
auto* op_1 = schedule.getWell("OP_1");
const auto& op_1 = schedule.getWell2("OP_1", 2);
size_t timestep = 2;
const auto& completions = op_1->getConnections( timestep );
const auto& completions = op_1.getConnections();
BOOST_CHECK_EQUAL(9U, completions.size());
//Verify TRACK completion ordering
@ -298,10 +168,9 @@ BOOST_AUTO_TEST_CASE(WellCOMPDATtestINPUT) {
Eclipse3DProperties eclipseProperties ( deck , table, grid);
Opm::Runspec runspec (deck);
Opm::Schedule schedule(deck, grid , eclipseProperties, runspec, Opm::ParseContext(), errors);
auto* op_1 = schedule.getWell("OP_1");
const auto& op_1 = schedule.getWell2("OP_1", 2);
size_t timestep = 2;
const auto& completions = op_1->getConnections( timestep );
const auto& completions = op_1.getConnections();
BOOST_CHECK_EQUAL(9U, completions.size());
//Verify INPUT completion ordering
@ -317,148 +186,75 @@ BOOST_AUTO_TEST_CASE(WellCOMPDATtestINPUT) {
}
BOOST_AUTO_TEST_CASE(NewWellZeroCompletions) {
auto timeMap = createXDaysTimeMap(10);
Opm::Well well("WELL1" , 1, 0, 0, 0.0, 0.0, Opm::Phase::OIL, Opm::WellProducer::CMODE_UNDEFINED, timeMap , 0);
BOOST_CHECK_EQUAL( 0U , well.getConnections( 0 ).size() );
}
BOOST_AUTO_TEST_CASE(setGasRate_RateSetCorrect) {
auto timeMap = createXDaysTimeMap(10);
Opm::Well well("WELL1" , 1, 0, 0, 0.0, 0.0, Opm::Phase::GAS, Opm::WellProducer::CMODE_UNDEFINED, timeMap , 0);
BOOST_CHECK_EQUAL(0.0 , well.getProductionPropertiesCopy(5).GasRate);
Opm::WellProductionProperties properties;
properties.GasRate = 108;
well.setProductionProperties(5, properties);
BOOST_CHECK_EQUAL(108 , well.getProductionPropertiesCopy(5).GasRate);
BOOST_CHECK_EQUAL(108 , well.getProductionPropertiesCopy(8).GasRate);
}
BOOST_AUTO_TEST_CASE(setWaterRate_RateSetCorrect) {
auto timeMap = createXDaysTimeMap(10);
Opm::Well well("WELL1" , 1, 0, 0, 0.0, 0.0, Opm::Phase::WATER, Opm::WellProducer::CMODE_UNDEFINED, timeMap , 0);
BOOST_CHECK_EQUAL(0.0 , well.getProductionPropertiesCopy(5).WaterRate);
Opm::WellProductionProperties properties;
properties.WaterRate = 108;
well.setProductionProperties(5, properties);
BOOST_CHECK_EQUAL(108 , well.getProductionPropertiesCopy(5).WaterRate);
BOOST_CHECK_EQUAL(108 , well.getProductionPropertiesCopy(8).WaterRate);
}
BOOST_AUTO_TEST_CASE(setSurfaceInjectionRate_RateSetCorrect) {
auto timeMap = createXDaysTimeMap(10);
Opm::Well well("WELL1" , 1, 0, 0, 0.0, 0.0, Opm::Phase::WATER, Opm::WellProducer::CMODE_UNDEFINED, timeMap , 0);
BOOST_CHECK_EQUAL(0.0 , well.getInjectionPropertiesCopy(5).surfaceInjectionRate);
Opm::WellInjectionProperties props(well.getInjectionPropertiesCopy(5));
props.surfaceInjectionRate = 108;
well.setInjectionProperties(5, props);
BOOST_CHECK_EQUAL(108 , well.getInjectionPropertiesCopy(5).surfaceInjectionRate);
BOOST_CHECK_EQUAL(108 , well.getInjectionPropertiesCopy(8).surfaceInjectionRate);
BOOST_CHECK_EQUAL( 108, well.injection_rate(Opm::Phase::WATER, 5) );
BOOST_CHECK_EQUAL( 108, well.injection_rate(Opm::Phase::WATER, 8) );
BOOST_CHECK_EQUAL( 0.0, well.injection_rate(Opm::Phase::GAS, 5) );
BOOST_CHECK_EQUAL( 0.0, well.injection_rate(Opm::Phase::GAS, 8) );
}
BOOST_AUTO_TEST_CASE(setReservoirInjectionRate_RateSetCorrect) {
auto timeMap = createXDaysTimeMap(10);
Opm::Well well("WELL1" , 1, 0, 0, 0.0, 0.0, Opm::Phase::WATER, Opm::WellProducer::CMODE_UNDEFINED, timeMap , 0);
BOOST_CHECK_EQUAL(0.0 , well.getInjectionPropertiesCopy(5).reservoirInjectionRate);
Opm::WellInjectionProperties properties(well.getInjectionPropertiesCopy(5));
properties.reservoirInjectionRate = 108;
well.setInjectionProperties(5, properties);
BOOST_CHECK_EQUAL(108 , well.getInjectionPropertiesCopy(5).reservoirInjectionRate);
BOOST_CHECK_EQUAL(108 , well.getInjectionPropertiesCopy(8).reservoirInjectionRate);
Opm::Well2 well("WELL1", "GROUP", 0, 1, 0, 0, 0.0, Opm::Phase::OIL, Opm::WellProducer::CMODE_UNDEFINED, WellCompletion::DEPTH);
BOOST_CHECK_EQUAL( 0U , well.getConnections( ).size() );
}
BOOST_AUTO_TEST_CASE(isProducerCorrectlySet) {
// HACK: This test checks correctly setting of isProducer/isInjector. This property depends on which of
// WellProductionProperties/WellInjectionProperties is set last, independent of actual values.
auto timeMap = createXDaysTimeMap(10);
Opm::Well well("WELL1" , 1, 0, 0, 0.0, 0.0, Opm::Phase::OIL, Opm::WellProducer::CMODE_UNDEFINED, timeMap ,0);
Opm::Well2 well("WELL1" , "GROUP", 0, 1, 0, 0, 0.0, Opm::Phase::OIL, Opm::WellProducer::CMODE_UNDEFINED, WellCompletion::DEPTH);
/* 1: Well is created as producer */
BOOST_CHECK_EQUAL( false , well.isInjector(0));
BOOST_CHECK_EQUAL( true , well.isProducer(0));
BOOST_CHECK_EQUAL( false , well.isInjector());
BOOST_CHECK_EQUAL( true , well.isProducer());
/* Set a surface injection rate => Well becomes an Injector */
Opm::WellInjectionProperties injectionProps1(well.getInjectionPropertiesCopy(3));
injectionProps1.surfaceInjectionRate = 100;
well.setInjectionProperties(3, injectionProps1);
BOOST_CHECK_EQUAL( true , well.isInjector(3));
BOOST_CHECK_EQUAL( false , well.isProducer(3));
BOOST_CHECK_EQUAL( 100 , well.getInjectionPropertiesCopy(3).surfaceInjectionRate);
auto injectionProps1 = std::make_shared<Opm::WellInjectionProperties>(well.getInjectionProperties());
injectionProps1->surfaceInjectionRate = 100;
well.updateInjection(injectionProps1);
BOOST_CHECK_EQUAL( true , well.isInjector());
BOOST_CHECK_EQUAL( false , well.isProducer());
BOOST_CHECK_EQUAL( 100 , well.getInjectionProperties().surfaceInjectionRate);
/* Set a reservoir injection rate => Well becomes an Injector */
Opm::WellInjectionProperties injectionProps2(well.getInjectionPropertiesCopy(4));
injectionProps2.reservoirInjectionRate = 200;
well.setInjectionProperties(4, injectionProps2);
BOOST_CHECK_EQUAL( true , well.isInjector(4));
BOOST_CHECK_EQUAL( false , well.isProducer(4));
BOOST_CHECK_EQUAL( 200 , well.getInjectionPropertiesCopy(4).reservoirInjectionRate);
{
Opm::Well2 well("WELL1" , "GROUP", 0, 1, 0, 0, 0.0, Opm::Phase::OIL, Opm::WellProducer::CMODE_UNDEFINED, WellCompletion::DEPTH);
/* Set a reservoir injection rate => Well becomes an Injector */
auto injectionProps2 = std::make_shared<Opm::WellInjectionProperties>(well.getInjectionProperties());
injectionProps2->reservoirInjectionRate = 200;
well.updateInjection(injectionProps2);
BOOST_CHECK_EQUAL( true , well.isInjector());
BOOST_CHECK_EQUAL( false , well.isProducer());
BOOST_CHECK_EQUAL( 200 , well.getInjectionProperties().reservoirInjectionRate);
}
/* Set rates => Well becomes a producer; injection rate should be set to 0. */
Opm::WellInjectionProperties injectionProps3;
well.setInjectionProperties(4, injectionProps3);
Opm::WellProductionProperties properties(well.getProductionPropertiesCopy(4));
properties.OilRate = 100;
properties.GasRate = 200;
properties.WaterRate = 300;
well.setProductionProperties(4, properties);
BOOST_CHECK_EQUAL( false , well.isInjector(4));
BOOST_CHECK_EQUAL( true , well.isProducer(4));
BOOST_CHECK_EQUAL( 0 , well.getInjectionPropertiesCopy(4).surfaceInjectionRate);
BOOST_CHECK_EQUAL( 0 , well.getInjectionPropertiesCopy(4).reservoirInjectionRate);
BOOST_CHECK_EQUAL( 100 , well.getProductionPropertiesCopy(4).OilRate);
BOOST_CHECK_EQUAL( 200 , well.getProductionPropertiesCopy(4).GasRate);
BOOST_CHECK_EQUAL( 300 , well.getProductionPropertiesCopy(4).WaterRate);
{
Opm::Well2 well("WELL1" , "GROUP", 0, 1, 0, 0, 0.0, Opm::Phase::OIL, Opm::WellProducer::CMODE_UNDEFINED, WellCompletion::DEPTH);
/* Set injection rate => Well becomes injector - all produced rates -> 0 */
Opm::WellProductionProperties prodProps2;
well.setProductionProperties(6, prodProps2);
Opm::WellInjectionProperties injectionProps4(well.getInjectionPropertiesCopy(6));
injectionProps4.reservoirInjectionRate = 50;
well.setInjectionProperties(6, injectionProps4);
BOOST_CHECK_EQUAL( true , well.isInjector(6));
BOOST_CHECK_EQUAL( false , well.isProducer(6));
BOOST_CHECK_EQUAL( 50 , well.getInjectionPropertiesCopy(6).reservoirInjectionRate);
BOOST_CHECK_EQUAL( 0 , well.getProductionPropertiesCopy(6).OilRate);
BOOST_CHECK_EQUAL( 0 , well.getProductionPropertiesCopy(6).GasRate);
BOOST_CHECK_EQUAL( 0 , well.getProductionPropertiesCopy(6).WaterRate);
/* Set rates => Well becomes a producer; injection rate should be set to 0. */
auto injectionProps3 = std::make_shared<Opm::WellInjectionProperties>(well.getInjectionProperties());
well.updateInjection(injectionProps3);
auto properties = std::make_shared<Opm::WellProductionProperties>( well.getProductionProperties() );
properties->OilRate = 100;
properties->GasRate = 200;
properties->WaterRate = 300;
well.updateProduction(properties);
BOOST_CHECK_EQUAL( false , well.isInjector());
BOOST_CHECK_EQUAL( true , well.isProducer());
BOOST_CHECK_EQUAL( 0 , well.getInjectionProperties().surfaceInjectionRate);
BOOST_CHECK_EQUAL( 0 , well.getInjectionProperties().reservoirInjectionRate);
BOOST_CHECK_EQUAL( 100 , well.getProductionProperties().OilRate);
BOOST_CHECK_EQUAL( 200 , well.getProductionProperties().GasRate);
BOOST_CHECK_EQUAL( 300 , well.getProductionProperties().WaterRate);
}
}
BOOST_AUTO_TEST_CASE(GroupnameCorretlySet) {
auto timeMap = createXDaysTimeMap(10);
Opm::Well well("WELL1" , 1, 0, 0, 0.0, 0.0, Opm::Phase::WATER, Opm::WellProducer::CMODE_UNDEFINED, timeMap ,0);
Opm::Well2 well("WELL1" , "G1", 0, 1, 0, 0, 0.0, Opm::Phase::OIL, Opm::WellProducer::CMODE_UNDEFINED, WellCompletion::DEPTH);
BOOST_CHECK_EQUAL("" , well.getGroupName(2));
well.setGroupName(3 , "GROUP2");
BOOST_CHECK_EQUAL("GROUP2" , well.getGroupName(3));
BOOST_CHECK_EQUAL("GROUP2" , well.getGroupName(6));
well.setGroupName(7 , "NEWGROUP");
BOOST_CHECK_EQUAL("NEWGROUP" , well.getGroupName(7));
BOOST_CHECK_EQUAL("G1" , well.groupName());
well.updateGroup( "GROUP2");
BOOST_CHECK_EQUAL("GROUP2" , well.groupName());
}
BOOST_AUTO_TEST_CASE(addWELSPECS_setData_dataSet) {
auto timeMap = createXDaysTimeMap(10);
Opm::Well well("WELL1", 1, 23, 42, 2334.32, 0.0, Opm::Phase::WATER, Opm::WellProducer::CMODE_UNDEFINED, timeMap, 3);
Opm::Well2 well("WELL1", "GROUP", 0, 1, 23, 42, 2334.32, Opm::Phase::WATER, WellProducer::CMODE_UNDEFINED, WellCompletion::DEPTH);
BOOST_CHECK(!well.hasBeenDefined(2));
BOOST_CHECK(well.hasBeenDefined(3));
BOOST_CHECK_EQUAL(23, well.getHeadI());
BOOST_CHECK_EQUAL(42, well.getHeadJ());
BOOST_CHECK_EQUAL(2334.32, well.getRefDepth());
@ -467,36 +263,34 @@ BOOST_AUTO_TEST_CASE(addWELSPECS_setData_dataSet) {
BOOST_AUTO_TEST_CASE(XHPLimitDefault) {
auto timeMap = createXDaysTimeMap(10);
Opm::Well well("WELL1", 1, 1, 2, 2334.32, 0.0, Opm::Phase::WATER, Opm::WellProducer::CMODE_UNDEFINED, timeMap, 0);
Opm::Well2 well("WELL1", "GROUP", 0, 1, 23, 42, 2334.32, Opm::Phase::WATER, WellProducer::CMODE_UNDEFINED, WellCompletion::DEPTH);
Opm::WellProductionProperties productionProps(well.getProductionPropertiesCopy(1));
productionProps.BHPLimit = 100;
productionProps.addProductionControl(Opm::WellProducer::BHP);
well.setProductionProperties(1, productionProps);
BOOST_CHECK_EQUAL( 100 , well.getProductionPropertiesCopy(5).BHPLimit);
BOOST_CHECK( well.getProductionPropertiesCopy(5).hasProductionControl( Opm::WellProducer::BHP ));
auto productionProps = std::make_shared<Opm::WellProductionProperties>(well.getProductionProperties());
productionProps->BHPLimit = 100;
productionProps->addProductionControl(Opm::WellProducer::BHP);
well.updateProduction(productionProps);
BOOST_CHECK_EQUAL( 100 , well.getProductionProperties().BHPLimit);
BOOST_CHECK_EQUAL( true, well.getProductionProperties().hasProductionControl( Opm::WellProducer::BHP ));
Opm::WellInjectionProperties injProps(well.getInjectionPropertiesCopy(1));
injProps.THPLimit = 200;
well.setInjectionProperties(1, injProps);
BOOST_CHECK_EQUAL( 200 , well.getInjectionPropertiesCopy(5).THPLimit);
BOOST_CHECK( !well.getInjectionPropertiesCopy(5).hasInjectionControl( Opm::WellInjector::THP ));
auto injProps = std::make_shared<Opm::WellInjectionProperties>(well.getInjectionProperties());
injProps->THPLimit = 200;
well.updateInjection(injProps);
BOOST_CHECK_EQUAL( 200 , well.getInjectionProperties().THPLimit);
BOOST_CHECK( !well.getInjectionProperties().hasInjectionControl( Opm::WellInjector::THP ));
}
BOOST_AUTO_TEST_CASE(InjectorType) {
auto timeMap = createXDaysTimeMap(10);
Opm::Well well("WELL1", 1, 1, 2, 2334.32, 0.0, Opm::Phase::WATER, Opm::WellProducer::CMODE_UNDEFINED, timeMap, 0);
Opm::Well2 well("WELL1", "GROUP", 0, 1, 23, 42, 2334.32, Opm::Phase::WATER, WellProducer::CMODE_UNDEFINED, WellCompletion::DEPTH);
Opm::WellInjectionProperties injectionProps(well.getInjectionPropertiesCopy(1));
injectionProps.injectorType = Opm::WellInjector::WATER;
well.setInjectionProperties(1, injectionProps);
auto injectionProps = std::make_shared<Opm::WellInjectionProperties>(well.getInjectionProperties());
injectionProps->injectorType = Opm::WellInjector::WATER;
well.updateInjection(injectionProps);
// TODO: Should we test for something other than water here, as long as
// the default value for InjectorType is WellInjector::WATER?
BOOST_CHECK_EQUAL( Opm::WellInjector::WATER , well.getInjectionPropertiesCopy(5).injectorType);
BOOST_CHECK_EQUAL( Opm::WellInjector::WATER , well.getInjectionProperties().injectorType);
}
@ -505,158 +299,113 @@ BOOST_AUTO_TEST_CASE(InjectorType) {
BOOST_AUTO_TEST_CASE(WellHaveProductionControlLimit) {
auto timeMap = createXDaysTimeMap(20);
Opm::Well well("WELL1", 1, 1, 2, 2334.32, 0.0, Opm::Phase::OIL, Opm::WellProducer::CMODE_UNDEFINED, timeMap, 0);
Opm::Well2 well("WELL1", "GROUP", 0, 1, 23, 42, 2334.32, Opm::Phase::WATER, WellProducer::CMODE_UNDEFINED, WellCompletion::DEPTH);
BOOST_CHECK( !well.getProductionPropertiesCopy(1).hasProductionControl( Opm::WellProducer::ORAT ));
BOOST_CHECK( !well.getProductionPropertiesCopy(1).hasProductionControl( Opm::WellProducer::RESV ));
BOOST_CHECK( !well.getProductionProperties().hasProductionControl( Opm::WellProducer::ORAT ));
BOOST_CHECK( !well.getProductionProperties().hasProductionControl( Opm::WellProducer::RESV ));
Opm::WellProductionProperties properties(well.getProductionPropertiesCopy(1));
properties.OilRate = 100;
properties.addProductionControl(Opm::WellProducer::ORAT);
well.setProductionProperties(2, properties);
BOOST_CHECK( well.getProductionPropertiesCopy(2).hasProductionControl( Opm::WellProducer::ORAT ));
BOOST_CHECK( !well.getProductionPropertiesCopy(2).hasProductionControl( Opm::WellProducer::RESV ));
auto properties1 = std::make_shared<Opm::WellProductionProperties>(well.getProductionProperties());
properties1->OilRate = 100;
properties1->addProductionControl(Opm::WellProducer::ORAT);
well.updateProduction(properties1);
BOOST_CHECK( well.getProductionProperties().hasProductionControl( Opm::WellProducer::ORAT ));
BOOST_CHECK( !well.getProductionProperties().hasProductionControl( Opm::WellProducer::RESV ));
Opm::WellProductionProperties properties2(well.getProductionPropertiesCopy(2));
properties2.ResVRate = 100;
properties2.addProductionControl(Opm::WellProducer::RESV);
well.setProductionProperties(2, properties2);
BOOST_CHECK( well.getProductionPropertiesCopy(2).hasProductionControl( Opm::WellProducer::RESV ));
auto properties2 = std::make_shared<Opm::WellProductionProperties>(well.getProductionProperties());
properties2->ResVRate = 100;
properties2->addProductionControl(Opm::WellProducer::RESV);
well.updateProduction(properties2);
BOOST_CHECK( well.getProductionProperties().hasProductionControl( Opm::WellProducer::RESV ));
Opm::WellProductionProperties properties3(well.getProductionPropertiesCopy(2));
properties3.OilRate = 100;
properties3.WaterRate = 100;
properties3.GasRate = 100;
properties3.LiquidRate = 100;
properties3.ResVRate = 100;
properties3.BHPLimit = 100;
properties3.THPLimit = 100;
properties3.addProductionControl(Opm::WellProducer::ORAT);
properties3.addProductionControl(Opm::WellProducer::LRAT);
properties3.addProductionControl(Opm::WellProducer::BHP);
well.setProductionProperties(10, properties3);
auto properties3 = std::make_shared<Opm::WellProductionProperties>(well.getProductionProperties());
properties3->OilRate = 100;
properties3->WaterRate = 100;
properties3->GasRate = 100;
properties3->LiquidRate = 100;
properties3->ResVRate = 100;
properties3->BHPLimit = 100;
properties3->THPLimit = 100;
properties3->addProductionControl(Opm::WellProducer::ORAT);
properties3->addProductionControl(Opm::WellProducer::LRAT);
properties3->addProductionControl(Opm::WellProducer::BHP);
well.updateProduction(properties3);
BOOST_CHECK( well.getProductionPropertiesCopy(10).hasProductionControl( Opm::WellProducer::ORAT ));
BOOST_CHECK( well.getProductionPropertiesCopy(10).hasProductionControl( Opm::WellProducer::LRAT ));
BOOST_CHECK( well.getProductionPropertiesCopy(10).hasProductionControl( Opm::WellProducer::BHP ));
BOOST_CHECK( well.getProductionProperties().hasProductionControl( Opm::WellProducer::ORAT ));
BOOST_CHECK( well.getProductionProperties().hasProductionControl( Opm::WellProducer::LRAT ));
BOOST_CHECK( well.getProductionProperties().hasProductionControl( Opm::WellProducer::BHP ));
Opm::WellProductionProperties properties4(well.getProductionPropertiesCopy(10));
properties4.dropProductionControl( Opm::WellProducer::LRAT );
well.setProductionProperties(10, properties4);
auto properties4 = std::make_shared<Opm::WellProductionProperties>(well.getProductionProperties());
properties4->dropProductionControl( Opm::WellProducer::LRAT );
well.updateProduction(properties4);
BOOST_CHECK( well.getProductionPropertiesCopy(11).hasProductionControl( Opm::WellProducer::ORAT ));
BOOST_CHECK( !well.getProductionPropertiesCopy(11).hasProductionControl( Opm::WellProducer::LRAT ));
BOOST_CHECK( well.getProductionPropertiesCopy(11).hasProductionControl( Opm::WellProducer::BHP ));
BOOST_CHECK( well.getProductionProperties().hasProductionControl( Opm::WellProducer::ORAT ));
BOOST_CHECK(!well.getProductionProperties().hasProductionControl( Opm::WellProducer::LRAT ));
BOOST_CHECK( well.getProductionProperties().hasProductionControl( Opm::WellProducer::BHP ));
}
BOOST_AUTO_TEST_CASE(WellHaveInjectionControlLimit) {
Opm::Well2 well("WELL1", "GROUP", 0, 1, 23, 42, 2334.32, Opm::Phase::WATER, WellProducer::CMODE_UNDEFINED, WellCompletion::DEPTH);
auto timeMap = createXDaysTimeMap(20);
Opm::Well well("WELL1", 1, 1, 2, 2334.32, 0.0, Opm::Phase::WATER, Opm::WellProducer::CMODE_UNDEFINED, timeMap, 0);
BOOST_CHECK( !well.getInjectionProperties().hasInjectionControl( Opm::WellInjector::RATE ));
BOOST_CHECK( !well.getInjectionProperties().hasInjectionControl( Opm::WellInjector::RESV ));
BOOST_CHECK( !well.getInjectionPropertiesCopy(1).hasInjectionControl( Opm::WellInjector::RATE ));
BOOST_CHECK( !well.getInjectionPropertiesCopy(1).hasInjectionControl( Opm::WellInjector::RESV ));
auto injProps1 = std::make_shared<Opm::WellInjectionProperties>(well.getInjectionProperties());
injProps1->surfaceInjectionRate = 100;
injProps1->addInjectionControl(Opm::WellInjector::RATE);
well.updateInjection(injProps1);
BOOST_CHECK( well.getInjectionProperties().hasInjectionControl( Opm::WellInjector::RATE ));
BOOST_CHECK( !well.getInjectionProperties().hasInjectionControl( Opm::WellInjector::RESV ));
Opm::WellInjectionProperties injProps1(well.getInjectionPropertiesCopy(2));
injProps1.surfaceInjectionRate = 100;
injProps1.addInjectionControl(Opm::WellInjector::RATE);
well.setInjectionProperties(2, injProps1);
BOOST_CHECK( well.getInjectionPropertiesCopy(2).hasInjectionControl( Opm::WellInjector::RATE ));
BOOST_CHECK( !well.getInjectionPropertiesCopy(2).hasInjectionControl( Opm::WellInjector::RESV ));
auto injProps2 = std::make_shared<Opm::WellInjectionProperties>(well.getInjectionProperties());
injProps2->reservoirInjectionRate = 100;
injProps2->addInjectionControl(Opm::WellInjector::RESV);
well.updateInjection(injProps2);
BOOST_CHECK( well.getInjectionProperties().hasInjectionControl( Opm::WellInjector::RESV ));
Opm::WellInjectionProperties injProps2(well.getInjectionPropertiesCopy(2));
injProps2.reservoirInjectionRate = 100;
injProps2.addInjectionControl(Opm::WellInjector::RESV);
well.setInjectionProperties(2, injProps2);
BOOST_CHECK( well.getInjectionPropertiesCopy(2).hasInjectionControl( Opm::WellInjector::RESV ));
auto injProps3 = std::make_shared<Opm::WellInjectionProperties>(well.getInjectionProperties());
injProps3->BHPLimit = 100;
injProps3->addInjectionControl(Opm::WellInjector::BHP);
injProps3->THPLimit = 100;
injProps3->addInjectionControl(Opm::WellInjector::THP);
well.updateInjection(injProps3);
Opm::WellInjectionProperties injProps3(well.getInjectionPropertiesCopy(10));
injProps3.BHPLimit = 100;
injProps3.addInjectionControl(Opm::WellInjector::BHP);
injProps3.THPLimit = 100;
injProps3.addInjectionControl(Opm::WellInjector::THP);
well.setInjectionProperties(10, injProps3);
BOOST_CHECK( well.getInjectionProperties().hasInjectionControl( Opm::WellInjector::RATE ));
BOOST_CHECK( well.getInjectionProperties().hasInjectionControl( Opm::WellInjector::RESV ));
BOOST_CHECK( well.getInjectionProperties().hasInjectionControl( Opm::WellInjector::THP ));
BOOST_CHECK( well.getInjectionProperties().hasInjectionControl( Opm::WellInjector::BHP ));
BOOST_CHECK( well.getInjectionPropertiesCopy(10).hasInjectionControl( Opm::WellInjector::RATE ));
BOOST_CHECK( well.getInjectionPropertiesCopy(10).hasInjectionControl( Opm::WellInjector::RESV ));
BOOST_CHECK( well.getInjectionPropertiesCopy(10).hasInjectionControl( Opm::WellInjector::THP ));
BOOST_CHECK( well.getInjectionPropertiesCopy(10).hasInjectionControl( Opm::WellInjector::BHP ));
Opm::WellInjectionProperties injProps4(well.getInjectionPropertiesCopy(11));
injProps4.dropInjectionControl( Opm::WellInjector::RESV );
well.setInjectionProperties(11, injProps4);
BOOST_CHECK( well.getInjectionPropertiesCopy(11).hasInjectionControl( Opm::WellInjector::RATE ));
BOOST_CHECK( !well.getInjectionPropertiesCopy(11).hasInjectionControl( Opm::WellInjector::RESV ));
BOOST_CHECK( well.getInjectionPropertiesCopy(11).hasInjectionControl( Opm::WellInjector::THP ));
BOOST_CHECK( well.getInjectionPropertiesCopy(11).hasInjectionControl( Opm::WellInjector::BHP ));
auto injProps4 = std::make_shared<Opm::WellInjectionProperties>(well.getInjectionProperties());
injProps4->dropInjectionControl( Opm::WellInjector::RESV );
well.updateInjection(injProps4);
BOOST_CHECK( well.getInjectionProperties().hasInjectionControl( Opm::WellInjector::RATE ));
BOOST_CHECK( !well.getInjectionProperties().hasInjectionControl( Opm::WellInjector::RESV ));
BOOST_CHECK( well.getInjectionProperties().hasInjectionControl( Opm::WellInjector::THP ));
BOOST_CHECK( well.getInjectionProperties().hasInjectionControl( Opm::WellInjector::BHP ));
}
/*********************************************************************/
BOOST_AUTO_TEST_CASE(WellSetAvailableForGroupControl_ControlSet) {
auto timeMap = createXDaysTimeMap(20);
Opm::Well well("WELL1", 1, 1, 2, 2334.32, 0.0, Opm::Phase::WATER, Opm::WellProducer::CMODE_UNDEFINED, timeMap, 0);
BOOST_CHECK(well.isAvailableForGroupControl(10));
well.setAvailableForGroupControl(12, false);
BOOST_CHECK(!well.isAvailableForGroupControl(13));
well.setAvailableForGroupControl(15, true);
BOOST_CHECK(well.isAvailableForGroupControl(15));
}
BOOST_AUTO_TEST_CASE(WellSetGuideRate_GuideRateSet) {
auto timeMap = createXDaysTimeMap(20);
Opm::Well well("WELL1", 1, 1, 2, 2334.32, 0.0, Opm::Phase::WATER, Opm::WellProducer::CMODE_UNDEFINED, timeMap, 0);
BOOST_CHECK_LT(well.getGuideRate(0), 0);
well.setGuideRate(1, 32.2);
BOOST_CHECK_LT(well.getGuideRate(0), 0);
BOOST_CHECK_EQUAL(32.2, well.getGuideRate(1));
}
BOOST_AUTO_TEST_CASE(WellGuideRatePhase_GuideRatePhaseSet) {
auto timeMap = createXDaysTimeMap(20);
Opm::Well well("WELL1", 1, 1, 2, 2334.32, 0.0, Opm::Phase::WATER, Opm::WellProducer::CMODE_UNDEFINED, timeMap, 0);
BOOST_CHECK_EQUAL(Opm::GuideRate::UNDEFINED, well.getGuideRatePhase(0));
well.setGuideRatePhase(3, Opm::GuideRate::RAT);
BOOST_CHECK_EQUAL(Opm::GuideRate::UNDEFINED, well.getGuideRatePhase(2));
BOOST_CHECK_EQUAL(Opm::GuideRate::RAT, well.getGuideRatePhase(3));
Opm::Well2 well("WELL1" , "GROUP", 0, 1, 0, 0, 0.0, Opm::Phase::OIL, Opm::WellProducer::CMODE_UNDEFINED, WellCompletion::DEPTH);
BOOST_CHECK_EQUAL(Opm::GuideRate::UNDEFINED, well.getGuideRatePhase());
BOOST_CHECK(well.updateWellGuideRate(true, 100, Opm::GuideRate::RAT, 66.0));
BOOST_CHECK_EQUAL(Opm::GuideRate::RAT, well.getGuideRatePhase());
BOOST_CHECK_EQUAL(100, well.getGuideRate());
BOOST_CHECK_EQUAL(66.0, well.getGuideRateScalingFactor());
}
BOOST_AUTO_TEST_CASE(WellEfficiencyFactorSet) {
auto timeMap = createXDaysTimeMap(20);
Opm::Well well("WELL1", 1, 1, 2, 2334.32, 0.0, Opm::Phase::WATER, Opm::WellProducer::CMODE_UNDEFINED, timeMap, 0);
BOOST_CHECK_EQUAL(1.0, well.getEfficiencyFactor(0));
well.setEfficiencyFactor(3, 0.9);
BOOST_CHECK_EQUAL(1.0, well.getEfficiencyFactor(0));
BOOST_CHECK_EQUAL(0.9, well.getEfficiencyFactor(3));
Opm::Well2 well("WELL1" , "GROUP", 0, 1, 0, 0, 0.0, Opm::Phase::OIL, Opm::WellProducer::CMODE_UNDEFINED, WellCompletion::DEPTH);
BOOST_CHECK_EQUAL(1.0, well.getEfficiencyFactor());
BOOST_CHECK( well.updateEfficiencyFactor(0.9));
BOOST_CHECK_EQUAL(0.9, well.getEfficiencyFactor());
}
BOOST_AUTO_TEST_CASE(WellSetScalingFactor_ScalingFactorSetSet) {
auto timeMap = createXDaysTimeMap(20);
Opm::Well well("WELL1", 1, 1, 2, 2334.32, 0.0, Opm::Phase::WATER, Opm::WellProducer::CMODE_UNDEFINED, timeMap, 0);
BOOST_CHECK_EQUAL(1.0, well.getGuideRateScalingFactor(0));
well.setGuideRateScalingFactor(4, 0.6);
BOOST_CHECK_EQUAL(1.0, well.getGuideRateScalingFactor(3));
BOOST_CHECK_EQUAL(0.6, well.getGuideRateScalingFactor(4));
}
BOOST_AUTO_TEST_CASE(testWellNameInWellNamePattern) {
const std::string& wellnamePattern1 = "OP_*";
const std::string& wellname1 = "OP_1";
BOOST_CHECK_EQUAL(Opm::Well::wellNameInWellNamePattern(wellname1, wellnamePattern1), true);
const std::string& wellnamePattern2 = "NONE";
BOOST_CHECK_EQUAL(Opm::Well::wellNameInWellNamePattern(wellname1, wellnamePattern2), false);
}
namespace {
namespace WCONHIST {

14
tests/parser/WellTracerTests.cpp
View File

@ -24,7 +24,6 @@
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/Well.hpp>
#include <opm/parser/eclipse/Deck/Deck.hpp>
#include <opm/parser/eclipse/Deck/DeckItem.hpp>
#include <opm/parser/eclipse/Deck/DeckKeyword.hpp>
@ -153,13 +152,12 @@ BOOST_AUTO_TEST_CASE(TestDynamicWTRACER) {
const auto& record = keyword.getRecord(0);
const std::string& well_name = record.getItem("WELL").getTrimmedString(0);
BOOST_CHECK_EQUAL(well_name, "W_1");
const auto* well = schedule.getWell(well_name);
BOOST_CHECK_EQUAL(well->getTracerProperties(0).getConcentration("I1"),0); //default 0
BOOST_CHECK_EQUAL(well->getTracerProperties(0).getConcentration("I2"),0); //default 0
BOOST_CHECK_EQUAL(well->getTracerProperties(1).getConcentration("I1"),1);
BOOST_CHECK_EQUAL(well->getTracerProperties(2).getConcentration("I1"),1);
BOOST_CHECK_EQUAL(well->getTracerProperties(4).getConcentration("I1"),0);
BOOST_CHECK_EQUAL(well->getTracerProperties(4).getConcentration("I2"),1);
BOOST_CHECK_EQUAL(schedule.getWell2("W_1", 0).getTracerProperties().getConcentration("I1"),0); //default 0
BOOST_CHECK_EQUAL(schedule.getWell2("W_1", 0).getTracerProperties().getConcentration("I2"),0); //default 0
BOOST_CHECK_EQUAL(schedule.getWell2("W_1", 1).getTracerProperties().getConcentration("I1"),1);
BOOST_CHECK_EQUAL(schedule.getWell2("W_1", 2).getTracerProperties().getConcentration("I1"),1);
BOOST_CHECK_EQUAL(schedule.getWell2("W_1", 4).getTracerProperties().getConcentration("I1"),0);
BOOST_CHECK_EQUAL(schedule.getWell2("W_1", 4).getTracerProperties().getConcentration("I2"),1);
}

92
tests/parser/integration/ParseKEYWORD.cpp
View File

@ -575,36 +575,34 @@ BOOST_AUTO_TEST_CASE( MULTISEGMENT_ABS ) {
// checking the relation between segments and completions
// and also the depth of completions
{
BOOST_CHECK(sched.hasWell("PROD01"));
const auto* well = sched.getWell("PROD01");
const auto& connections = well->getConnections(0);
BOOST_CHECK_EQUAL(7U, connections.size());
BOOST_CHECK(sched.hasWell("PROD01"));
const auto& well = sched.getWell2("PROD01", 0);
const auto& connections = well.getConnections();
BOOST_CHECK_EQUAL(7U, connections.size());
const Connection& connection5 = connections.get(4);
const int seg_number_connection5 = connection5.segment();
const double connection5_depth = connection5.depth();
BOOST_CHECK_EQUAL(seg_number_connection5, 6);
BOOST_CHECK_CLOSE(connection5_depth, 2538.83, 0.001);
const Connection& connection5 = connections.get(4);
const int seg_number_connection5 = connection5.segment();
const double connection5_depth = connection5.depth();
BOOST_CHECK_EQUAL(seg_number_connection5, 6);
BOOST_CHECK_CLOSE(connection5_depth, 2538.83, 0.001);
const Connection& connection6 = connections.get(5);
const int seg_number_connection6 = connection6.segment();
const double connection6_depth = connection6.depth();
BOOST_CHECK_EQUAL(seg_number_connection6, 6);
BOOST_CHECK_CLOSE(connection6_depth, 2537.83, 0.001);
const Connection& connection6 = connections.get(5);
const int seg_number_connection6 = connection6.segment();
const double connection6_depth = connection6.depth();
BOOST_CHECK_EQUAL(seg_number_connection6, 6);
BOOST_CHECK_CLOSE(connection6_depth, 2537.83, 0.001);
const Connection& connection1 = connections.get(0);
const int seg_number_connection1 = connection1.segment();
const double connection1_depth = connection1.depth();
BOOST_CHECK_EQUAL(seg_number_connection1, 1);
BOOST_CHECK_EQUAL(connection1_depth, 2512.5);
const Connection& connection1 = connections.get(0);
const int seg_number_connection1 = connection1.segment();
const double connection1_depth = connection1.depth();
BOOST_CHECK_EQUAL(seg_number_connection1, 1);
BOOST_CHECK_EQUAL(connection1_depth, 2512.5);
const Connection& connection3 = connections.get(2);
const int seg_number_connection3 = connection3.segment();
const double connection3_depth = connection3.depth();
BOOST_CHECK_EQUAL(seg_number_connection3, 3);
BOOST_CHECK_EQUAL(connection3_depth, 2562.5);
}
const Connection& connection3 = connections.get(2);
const int seg_number_connection3 = connection3.segment();
const double connection3_depth = connection3.depth();
BOOST_CHECK_EQUAL(seg_number_connection3, 3);
BOOST_CHECK_EQUAL(connection3_depth, 2562.5);
}
BOOST_AUTO_TEST_CASE( PLYADS ) {
@ -1364,21 +1362,24 @@ BOOST_AUTO_TEST_CASE( WCONPROD ) {
BOOST_CHECK(sched.hasWell("PROX5"));
{
auto* well = sched.getWell("PROD2");
BOOST_CHECK_CLOSE(1000/Metric::Time, well->getProductionProperties(0).OilRate, 0.001);
BOOST_CHECK_CLOSE(1500/Metric::Time, well->getProductionProperties(1).OilRate, 0.001);
const auto& well0 = sched.getWell2("PROD2", 0 );
const auto& well1 = sched.getWell2("PROD2", 1 );
BOOST_CHECK_CLOSE(1000/Metric::Time, well0.getProductionProperties().OilRate, 0.001);
BOOST_CHECK_CLOSE(1500/Metric::Time, well1.getProductionProperties().OilRate, 0.001);
}
{
auto* well = sched.getWell("PROD3");
BOOST_CHECK_CLOSE(0/Metric::Time, well->getProductionProperties(0).OilRate, 0.001);
BOOST_CHECK_CLOSE(1500/Metric::Time, well->getProductionProperties(1).OilRate, 0.001);
const auto& well0 = sched.getWell2("PROD3", 0 );
const auto& well1 = sched.getWell2("PROD3", 1 );
BOOST_CHECK_CLOSE(0/Metric::Time, well0.getProductionProperties().OilRate, 0.001);
BOOST_CHECK_CLOSE(1500/Metric::Time, well1.getProductionProperties().OilRate, 0.001);
}
{
auto* well = sched.getWell("PROX5");
BOOST_CHECK_CLOSE(2000/Metric::Time, well->getProductionProperties(0).OilRate, 0.001);
BOOST_CHECK_CLOSE(2000/Metric::Time, well->getProductionProperties(1).OilRate, 0.001);
const auto& well0 = sched.getWell2("PROX5", 0);
const auto& well1 = sched.getWell2("PROX5", 1);
BOOST_CHECK_CLOSE(2000/Metric::Time, well0.getProductionProperties().OilRate, 0.001);
BOOST_CHECK_CLOSE(2000/Metric::Time, well1.getProductionProperties().OilRate, 0.001);
}
}
@ -1401,21 +1402,24 @@ BOOST_AUTO_TEST_CASE( WCONINJE ) {
BOOST_CHECK(sched.hasWell("INJX5"));
{
auto* well = sched.getWell("INJE2");
BOOST_CHECK_CLOSE(1000/Metric::Time, well->getInjectionProperties(0).surfaceInjectionRate, 0.001);
BOOST_CHECK_CLOSE(1500/Metric::Time, well->getInjectionProperties(1).surfaceInjectionRate, 0.001);
const auto& well0 = sched.getWell2("INJE2", 0);
const auto& well1 = sched.getWell2("INJE2", 1);
BOOST_CHECK_CLOSE(1000/Metric::Time, well0.getInjectionProperties().surfaceInjectionRate, 0.001);
BOOST_CHECK_CLOSE(1500/Metric::Time, well1.getInjectionProperties().surfaceInjectionRate, 0.001);
}
{
auto* well = sched.getWell("INJE3");
BOOST_CHECK_CLOSE(0/Metric::Time, well->getInjectionProperties(0).surfaceInjectionRate, 0.001);
BOOST_CHECK_CLOSE(1500/Metric::Time, well->getInjectionProperties(1).surfaceInjectionRate, 0.001);
const auto& well0 = sched.getWell2("INJE3", 0);
const auto& well1 = sched.getWell2("INJE3", 1);
BOOST_CHECK_CLOSE(0000/Metric::Time, well0.getInjectionProperties().surfaceInjectionRate, 0.001);
BOOST_CHECK_CLOSE(1500/Metric::Time, well1.getInjectionProperties().surfaceInjectionRate, 0.001);
}
{
auto* well = sched.getWell("INJX5");
BOOST_CHECK_CLOSE(2000/Metric::Time, well->getInjectionProperties(0).surfaceInjectionRate, 0.001);
BOOST_CHECK_CLOSE(2000/Metric::Time, well->getInjectionProperties(1).surfaceInjectionRate, 0.001);
const auto& well0 = sched.getWell2("INJX5", 0);
const auto& well1 = sched.getWell2("INJX5", 1);
BOOST_CHECK_CLOSE(2000/Metric::Time, well0.getInjectionProperties().surfaceInjectionRate, 0.001);
BOOST_CHECK_CLOSE(2000/Metric::Time, well1.getInjectionProperties().surfaceInjectionRate, 0.001);
}
}

384
tests/parser/integration/ScheduleCreateFromDeck.cpp
View File

@ -32,7 +32,6 @@
#include <opm/parser/eclipse/EclipseState/Schedule/Group.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/GroupTree.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/Well.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/WellConnections.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Events.hpp>
#include <opm/parser/eclipse/Units/Units.hpp>
@ -116,72 +115,12 @@ BOOST_AUTO_TEST_CASE(WellTestRefDepth) {
Schedule sched(deck , grid , eclipseProperties, runspec);
BOOST_CHECK_EQUAL(4, 4);
auto* well1 = sched.getWell("W_1");
auto* well2 = sched.getWell("W_2");
auto* well4 = sched.getWell("W_4");
BOOST_CHECK_EQUAL( well1->getRefDepth() , grid.getCellDepth( 29 , 36 , 0 ));
BOOST_CHECK_EQUAL( well2->getRefDepth() , 100 );
BOOST_CHECK_THROW( well4->getRefDepth() , std::invalid_argument );
}
BOOST_AUTO_TEST_CASE(WellTestOpen) {
Parser parser;
std::string scheduleFile(pathprefix() + "SCHEDULE/SCHEDULE_WELLS2");
auto deck = parser.parseFile(scheduleFile);
EclipseGrid grid(40,60,30);
TableManager table ( deck );
Eclipse3DProperties eclipseProperties ( deck , table, grid);
Runspec runspec (deck);
Schedule sched(deck, grid , eclipseProperties, runspec);
auto well1 = sched.getWell( "W_1" );
auto well2 = sched.getWell( "W_2" );
auto well3 = sched.getWell( "W_3" );
{
auto wells = sched.getOpenWells( 0 );
BOOST_CHECK_EQUAL( 0U , wells.size() );
}
{
auto wells = sched.getOpenWells( 3 );
BOOST_CHECK_EQUAL( 1U , wells.size() );
BOOST_CHECK_EQUAL( well1 , wells[0] );
}
{
auto wells = sched.getOpenWells(6);
BOOST_CHECK_EQUAL( 3U , wells.size() );
BOOST_CHECK_EQUAL( well1 , wells[0] );
BOOST_CHECK_EQUAL( well2 , wells[1] );
BOOST_CHECK_EQUAL( well3 , wells[2] );
}
{
auto wells = sched.getOpenWells(12);
BOOST_CHECK_EQUAL( 3U , wells.size() );
BOOST_CHECK_EQUAL( well2 , wells[1] );
BOOST_CHECK_EQUAL( well3 , wells[2] );
}
{
auto wells = sched.getOpenWells(13);
BOOST_CHECK_EQUAL( 2U , wells.size() );
BOOST_CHECK_EQUAL( well2 , wells[0] );
BOOST_CHECK_EQUAL( well3 , wells[1] );
}
{
auto wells = sched.getOpenWells(14);
BOOST_CHECK_EQUAL( 3U , wells.size() );
BOOST_CHECK_EQUAL( well2 , wells[1] );
BOOST_CHECK_EQUAL( well3 , wells[2] );
}
const auto& well1 = sched.getWell2atEnd("W_1");
const auto& well2 = sched.getWell2atEnd("W_2");
const auto& well4 = sched.getWell2atEnd("W_4");
BOOST_CHECK_EQUAL( well1.getRefDepth() , grid.getCellDepth( 29 , 36 , 0 ));
BOOST_CHECK_EQUAL( well2.getRefDepth() , 100 );
BOOST_CHECK_THROW( well4.getRefDepth() , std::invalid_argument );
}
@ -203,95 +142,78 @@ BOOST_AUTO_TEST_CASE(WellTesting) {
BOOST_CHECK(sched.hasWell("W_2"));
BOOST_CHECK(sched.hasWell("W_3"));
BOOST_CHECK_CLOSE( 777/Metric::Time , sched.getWell2("W_2", 7).getProductionProperties().ResVRate , 0.0001);
BOOST_CHECK_EQUAL( 0 , sched.getWell2("W_2", 8).getProductionProperties().ResVRate);
BOOST_CHECK_EQUAL( WellCommon::SHUT , sched.getWell2("W_2", 3).getStatus());
{
auto* well2 = sched.getWell("W_2");
const auto& rft_config = sched.rftConfig();
BOOST_CHECK_EQUAL( 0 , well2->getProductionPropertiesCopy(2).ResVRate);
BOOST_CHECK_CLOSE( 777/Metric::Time , well2->getProductionPropertiesCopy(7).ResVRate , 0.0001);
BOOST_CHECK_EQUAL( 0 , well2->getProductionPropertiesCopy(8).ResVRate);
BOOST_CHECK_EQUAL( WellCommon::SHUT , well2->getStatus(3));
BOOST_CHECK( !rft_config.rft("W_2", 2));
BOOST_CHECK( rft_config.rft("W_2", 3));
BOOST_CHECK( rft_config.rft("W_2", 4));
BOOST_CHECK( !rft_config.rft("W_2", 5));
{
const WellProductionProperties& prop3 = well2->getProductionProperties(3);
BOOST_CHECK_EQUAL( WellProducer::ORAT , prop3.controlMode);
BOOST_CHECK( prop3.hasProductionControl(WellProducer::ORAT));
BOOST_CHECK( !prop3.hasProductionControl(WellProducer::GRAT));
BOOST_CHECK( !prop3.hasProductionControl(WellProducer::WRAT));
}
// BOOST_CHECK( !well2->getProductionProperties(8).hasProductionControl(WellProducer::GRAT));
BOOST_CHECK( rft_config.rft("W_1", 3));
}
{
const WellProductionProperties& prop3 = sched.getWell2("W_2", 3).getProductionProperties();
BOOST_CHECK_EQUAL( WellProducer::ORAT , prop3.controlMode);
BOOST_CHECK( prop3.hasProductionControl(WellProducer::ORAT));
BOOST_CHECK( !prop3.hasProductionControl(WellProducer::GRAT));
BOOST_CHECK( !prop3.hasProductionControl(WellProducer::WRAT));
}
BOOST_CHECK_EQUAL( WellCommon::AUTO, sched.getWell2("W_3", 3).getStatus());
{
auto* well3 = sched.getWell("W_3");
BOOST_CHECK_EQUAL( WellCommon::AUTO , well3->getStatus(3));
BOOST_CHECK_EQUAL( 0 , well3->getProductionPropertiesCopy(2).LiquidRate);
{
const WellProductionProperties& prop7 = well3->getProductionProperties(7);
BOOST_CHECK_CLOSE( 999/Metric::Time , prop7.LiquidRate , 0.001);
BOOST_CHECK_EQUAL( WellProducer::RESV, prop7.controlMode);
}
BOOST_CHECK_CLOSE( 8000./Metric::Time, well3->getProductionPropertiesCopy(3).LiquidRate, 1.e-12);
BOOST_CHECK_CLOSE( 18000./Metric::Time, well3->getProductionPropertiesCopy(8).LiquidRate, 1.e-12);
const WellProductionProperties& prop7 = sched.getWell2("W_3", 7).getProductionProperties();
BOOST_CHECK_CLOSE( 999/Metric::Time , prop7.LiquidRate , 0.001);
BOOST_CHECK_EQUAL( WellProducer::RESV, prop7.controlMode);
}
BOOST_CHECK_CLOSE( 8000./Metric::Time , sched.getWell2("W_3", 3).getProductionProperties().LiquidRate, 1.e-12);
BOOST_CHECK_CLOSE( 18000./Metric::Time, sched.getWell2("W_3", 8).getProductionProperties().LiquidRate, 1.e-12);
{
auto* well1 = sched.getWell("W_1");
const auto& rft_config = sched.rftConfig();
BOOST_CHECK_EQUAL(sched.getWell2("W_1", 3).getProductionProperties().predictionMode, false);
BOOST_CHECK_CLOSE(sched.getWell2("W_1", 3).getProductionProperties().WaterRate , 4/Metric::Time, 0.001);
BOOST_CHECK_CLOSE(sched.getWell2("W_1", 3).getProductionProperties().GasRate , 12345/Metric::Time, 0.001);
BOOST_CHECK_CLOSE(sched.getWell2("W_1", 3).getProductionProperties().OilRate , 4000/Metric::Time, 0.001);
BOOST_CHECK(rft_config.rft("W_1", 3));
BOOST_CHECK(well1->getProductionPropertiesCopy(0).predictionMode);
BOOST_CHECK_EQUAL(0, well1->getProductionPropertiesCopy(0).OilRate);
BOOST_CHECK_CLOSE(sched.getWell2("W_1", 4).getProductionProperties().OilRate , 4000/Metric::Time, 0.001);
BOOST_CHECK_CLOSE(sched.getWell2("W_1", 4).getProductionProperties().WaterRate , 4/Metric::Time, 0.001);
BOOST_CHECK_CLOSE(sched.getWell2("W_1", 4).getProductionProperties().GasRate , 12345/Metric::Time,0.001);
BOOST_CHECK_EQUAL(0, well1->getProductionPropertiesCopy(1).OilRate);
BOOST_CHECK_EQUAL(0, well1->getProductionPropertiesCopy(2).OilRate);
BOOST_CHECK(!well1->getProductionPropertiesCopy(3).predictionMode);
BOOST_CHECK_CLOSE(4000/Metric::Time , well1->getProductionPropertiesCopy(3).OilRate , 0.001);
BOOST_CHECK_CLOSE(4000/Metric::Time , well1->getProductionPropertiesCopy(4).OilRate , 0.001);
BOOST_CHECK_CLOSE(4000/Metric::Time , well1->getProductionPropertiesCopy(5).OilRate , 0.001);
BOOST_CHECK_CLOSE(4/Metric::Time , well1->getProductionPropertiesCopy(3).WaterRate , 0.001);
BOOST_CHECK_CLOSE(12345/Metric::Time , well1->getProductionPropertiesCopy(3).GasRate , 0.001);
BOOST_CHECK_CLOSE(4/Metric::Time , well1->getProductionPropertiesCopy(4).WaterRate , 0.001);
BOOST_CHECK_CLOSE(12345/Metric::Time , well1->getProductionPropertiesCopy(4).GasRate , 0.001);
BOOST_CHECK_CLOSE(4/Metric::Time , well1->getProductionPropertiesCopy(5).WaterRate , 0.001);
BOOST_CHECK_CLOSE(12345/Metric::Time , well1->getProductionPropertiesCopy(5).GasRate , 0.001);
BOOST_CHECK_CLOSE(sched.getWell2("W_1", 5).getProductionProperties().WaterRate, 4/Metric::Time, 0.001);
BOOST_CHECK_CLOSE(sched.getWell2("W_1", 5).getProductionProperties().GasRate , 12345/Metric::Time, 0.001);
BOOST_CHECK_CLOSE(sched.getWell2("W_1", 5).getProductionProperties().OilRate , 4000/Metric::Time, 0.001);
BOOST_CHECK(!well1->getProductionPropertiesCopy(6).predictionMode);
BOOST_CHECK_CLOSE(14000/Metric::Time , well1->getProductionPropertiesCopy(6).OilRate , 0.001);
BOOST_CHECK_EQUAL(sched.getWell2("W_1", 6).getProductionProperties().predictionMode, false);
BOOST_CHECK_CLOSE(sched.getWell2("W_1", 6).getProductionProperties().OilRate , 14000/Metric::Time, 0.001);
BOOST_CHECK(well1->getProductionPropertiesCopy(7).predictionMode);
BOOST_CHECK_CLOSE(11000/Metric::Time , well1->getProductionPropertiesCopy(7).OilRate , 0.001);
BOOST_CHECK_CLOSE(44/Metric::Time , well1->getProductionPropertiesCopy(7).WaterRate , 0.001);
BOOST_CHECK_CLOSE(188/Metric::Time , well1->getProductionPropertiesCopy(7).GasRate , 0.001);
BOOST_CHECK_EQUAL(sched.getWell2("W_1", 7).getProductionProperties().predictionMode, true);
BOOST_CHECK_CLOSE(sched.getWell2("W_1", 7).getProductionProperties().OilRate , 11000/Metric::Time, 0.001);
BOOST_CHECK_CLOSE(sched.getWell2("W_1", 7).getProductionProperties().WaterRate , 44/Metric::Time, 0.001);
BOOST_CHECK(!well1->getProductionPropertiesCopy(8).predictionMode);
BOOST_CHECK_CLOSE(13000/Metric::Time , well1->getProductionPropertiesCopy(8).OilRate , 0.001);
BOOST_CHECK_CLOSE(123.00 * Metric::Pressure , well1->getInjectionPropertiesCopy(10).BHPLimit, 0.001);
BOOST_CHECK_CLOSE(678.00 * Metric::Pressure , well1->getInjectionPropertiesCopy(10).THPLimit, 0.001);
BOOST_CHECK_EQUAL(sched.getWell2("W_1", 8).getProductionProperties().predictionMode, false);
BOOST_CHECK_CLOSE(sched.getWell2("W_1", 8).getProductionProperties().OilRate , 13000/Metric::Time , 0.001);
BOOST_CHECK_CLOSE(sched.getWell2("W_1", 10).getInjectionProperties().BHPLimit, 123.00 * Metric::Pressure , 0.001);
BOOST_CHECK_CLOSE(sched.getWell2("W_1", 10).getInjectionProperties().THPLimit, 678.00 * Metric::Pressure , 0.001);
{
const WellInjectionProperties& prop11 = well1->getInjectionProperties(11);
const WellInjectionProperties& prop11 = sched.getWell2("W_1", 11).getInjectionProperties();
BOOST_CHECK_CLOSE(5000/Metric::Time , prop11.surfaceInjectionRate, 0.001);
BOOST_CHECK_EQUAL( WellInjector::RATE , prop11.controlMode);
BOOST_CHECK_EQUAL( WellCommon::OPEN , well1->getStatus( 11 ));
}
BOOST_CHECK( well1->isInjector(9));
BOOST_CHECK( sched.getWell2("W_1", 9).isInjector());
{
const WellInjectionProperties& prop9 = well1->getInjectionProperties(9);
const WellInjectionProperties& prop9 = sched.getWell2("W_1", 9).getInjectionProperties();
BOOST_CHECK_CLOSE(20000/Metric::Time , prop9.surfaceInjectionRate , 0.001);
BOOST_CHECK_CLOSE(200000/Metric::Time , prop9.reservoirInjectionRate, 0.001);
BOOST_CHECK_CLOSE(6895 * Metric::Pressure , prop9.BHPLimit, 0.001);
@ -304,14 +226,16 @@ BOOST_AUTO_TEST_CASE(WellTesting) {
}
BOOST_CHECK_EQUAL( WellCommon::OPEN , well1->getStatus( 12 ));
BOOST_CHECK( well1->getInjectionPropertiesCopy(12).hasInjectionControl(WellInjector::RATE ));
BOOST_CHECK( !well1->getInjectionPropertiesCopy(12).hasInjectionControl(WellInjector::RESV));
BOOST_CHECK( well1->getInjectionPropertiesCopy(12).hasInjectionControl(WellInjector::THP ));
BOOST_CHECK( well1->getInjectionPropertiesCopy(12).hasInjectionControl(WellInjector::BHP ));
BOOST_CHECK_EQUAL( WellCommon::SHUT , well1->getStatus( 13 ));
BOOST_CHECK_EQUAL( WellCommon::OPEN , well1->getStatus( 14 ));
BOOST_CHECK_EQUAL( WellCommon::OPEN, sched.getWell2("W_1", 11).getStatus( ));
BOOST_CHECK_EQUAL( WellCommon::OPEN, sched.getWell2("W_1", 12).getStatus( ));
BOOST_CHECK_EQUAL( WellCommon::SHUT, sched.getWell2("W_1", 13).getStatus( ));
BOOST_CHECK_EQUAL( WellCommon::OPEN, sched.getWell2("W_1", 14).getStatus( ));
{
BOOST_CHECK( sched.getWell2("W_1", 12).getInjectionProperties().hasInjectionControl(WellInjector::RATE ));
BOOST_CHECK( !sched.getWell2("W_1", 12).getInjectionProperties().hasInjectionControl(WellInjector::RESV));
BOOST_CHECK( sched.getWell2("W_1", 12).getInjectionProperties().hasInjectionControl(WellInjector::THP ));
BOOST_CHECK( sched.getWell2("W_1", 12).getInjectionProperties().hasInjectionControl(WellInjector::BHP ));
}
}
}
@ -343,18 +267,19 @@ BOOST_AUTO_TEST_CASE(WellTestCOMPDAT) {
BOOST_CHECK(sched.hasWell("W_2"));
BOOST_CHECK(sched.hasWell("W_3"));
{
auto* well1 = sched.getWell("W_1");
BOOST_CHECK_CLOSE(13000/Metric::Time , well1->getProductionPropertiesCopy(8).OilRate , 0.0001);
BOOST_CHECK_EQUAL(0U, well1->getConnections( 0 ).size() );
BOOST_CHECK_CLOSE(13000/Metric::Time , sched.getWell2("W_1", 8).getProductionProperties().OilRate , 0.0001);
{
const auto& connections = sched.getWell2("W_1", 3).getConnections();
BOOST_CHECK_EQUAL(4U, connections.size());
const auto& connections = well1->getConnections(3);
BOOST_CHECK_EQUAL(4U, connections.size());
BOOST_CHECK_EQUAL(WellCompletion::OPEN, connections.get(3).state());
BOOST_CHECK_EQUAL(2.2836805555555556e-12 , connections.get(3).CF());
BOOST_CHECK_EQUAL(4U, well1->getConnections( 7 ).size() );
BOOST_CHECK_EQUAL(WellCompletion::SHUT, well1->getConnections( 7 ).get( 3 ).state() );
BOOST_CHECK_EQUAL(WellCompletion::OPEN, connections.get(3).state());
BOOST_CHECK_EQUAL(2.2836805555555556e-12 , connections.get(3).CF());
}
{
const auto& connections = sched.getWell2("W_1", 7).getConnections();
BOOST_CHECK_EQUAL(4U, connections.size() );
BOOST_CHECK_EQUAL(WellCompletion::SHUT, connections.get( 3 ).state() );
}
}
}
@ -549,41 +474,6 @@ BOOST_AUTO_TEST_CASE( WellTestGroupAndWellRelation ) {
}
BOOST_AUTO_TEST_CASE(WellTestWELSPECSDataLoaded) {
Parser parser;
std::string scheduleFile(pathprefix() + "SCHEDULE/SCHEDULE_WELLS2");
auto deck = parser.parseFile(scheduleFile);
EclipseGrid grid(40,60,30);
TableManager table ( deck );
Eclipse3DProperties eclipseProperties ( deck , table, grid);
Runspec runspec (deck);
Schedule sched(deck, grid , eclipseProperties, runspec);
BOOST_CHECK_EQUAL(4U, sched.numWells());
BOOST_CHECK(sched.hasWell("W_1"));
BOOST_CHECK(sched.hasWell("W_2"));
BOOST_CHECK(sched.hasWell("W_3"));
{
const auto* well1 = sched.getWell("W_1");
BOOST_CHECK(!well1->hasBeenDefined(2));
BOOST_CHECK(well1->hasBeenDefined(3));
BOOST_CHECK_EQUAL(29, well1->getHeadI());
BOOST_CHECK_EQUAL(36, well1->getHeadJ());
const auto* well2 = sched.getWell("W_2");
BOOST_CHECK(!well2->hasBeenDefined(2));
BOOST_CHECK(well2->hasBeenDefined(3));
BOOST_CHECK_EQUAL(19, well2->getHeadI());
BOOST_CHECK_EQUAL(50, well2->getHeadJ());
const auto* well3 = sched.getWell("W_3");
BOOST_CHECK(!well3->hasBeenDefined(2));
BOOST_CHECK(well3->hasBeenDefined(3));
BOOST_CHECK_EQUAL(30, well3->getHeadI());
BOOST_CHECK_EQUAL(17, well3->getHeadJ());
}
}
/*
BOOST_AUTO_TEST_CASE(WellTestWELOPEN_ConfigWithIndexes_Throws) {
Parser parser;
@ -623,23 +513,23 @@ BOOST_AUTO_TEST_CASE(WellTestWGRUPCONWellPropertiesSet) {
Runspec runspec (deck);
Schedule sched(deck, grid , eclipseProperties, runspec);
const auto* well1 = sched.getWell("W_1");
BOOST_CHECK(well1->isAvailableForGroupControl(0));
BOOST_CHECK_EQUAL(-1, well1->getGuideRate(0));
BOOST_CHECK_EQUAL(GuideRate::OIL, well1->getGuideRatePhase(0));
BOOST_CHECK_EQUAL(1.0, well1->getGuideRateScalingFactor(0));
const auto& well1 = sched.getWell2("W_1", 0);
BOOST_CHECK(well1.isAvailableForGroupControl( ));
BOOST_CHECK_EQUAL(-1, well1.getGuideRate( ));
BOOST_CHECK_EQUAL(GuideRate::OIL, well1.getGuideRatePhase( ));
BOOST_CHECK_EQUAL(1.0, well1.getGuideRateScalingFactor( ));
const auto* well2 = sched.getWell("W_2");
BOOST_CHECK(!well2->isAvailableForGroupControl(0));
BOOST_CHECK_EQUAL(-1, well2->getGuideRate(0));
BOOST_CHECK_EQUAL(GuideRate::UNDEFINED, well2->getGuideRatePhase(0));
BOOST_CHECK_EQUAL(1.0, well2->getGuideRateScalingFactor(0));
const auto& well2 = sched.getWell2("W_2", 0);
BOOST_CHECK(!well2.isAvailableForGroupControl( ));
BOOST_CHECK_EQUAL(-1, well2.getGuideRate( ));
BOOST_CHECK_EQUAL(GuideRate::UNDEFINED, well2.getGuideRatePhase( ));
BOOST_CHECK_EQUAL(1.0, well2.getGuideRateScalingFactor( ));
const auto* well3 = sched.getWell("W_3");
BOOST_CHECK(well3->isAvailableForGroupControl(0));
BOOST_CHECK_EQUAL(100, well3->getGuideRate(0));
BOOST_CHECK_EQUAL(GuideRate::RAT, well3->getGuideRatePhase(0));
BOOST_CHECK_EQUAL(0.5, well3->getGuideRateScalingFactor(0));
const auto& well3 = sched.getWell2("W_3", 0);
BOOST_CHECK(well3.isAvailableForGroupControl( ));
BOOST_CHECK_EQUAL(100, well3.getGuideRate( ));
BOOST_CHECK_EQUAL(GuideRate::RAT, well3.getGuideRatePhase( ));
BOOST_CHECK_EQUAL(0.5, well3.getGuideRateScalingFactor( ));
}
@ -670,8 +560,7 @@ COMPDAT \n\
Eclipse3DProperties eclipseProperties ( deck , table, grid);
Runspec runspec (deck);
Schedule sched(deck, grid , eclipseProperties, runspec);
const auto* well = sched.getWell("W1");
const auto& connections = well->getConnections(0);
const auto& connections = sched.getWell2("W1", 0).getConnections();
BOOST_CHECK_EQUAL( 10 , connections.get(0).getI() );
BOOST_CHECK_EQUAL( 20 , connections.get(0).getJ() );
}
@ -705,18 +594,22 @@ BOOST_AUTO_TEST_CASE(WELLS_SHUT) {
Schedule sched(deck, grid , eclipseProperties, runspec);
const auto* well1 = sched.getWell("W1");
const auto* well2 = sched.getWell("W2");
const auto* well3 = sched.getWell("W3");
BOOST_CHECK_EQUAL( WellCommon::StatusEnum::OPEN , well1->getStatus(1));
BOOST_CHECK_EQUAL( WellCommon::StatusEnum::OPEN , well2->getStatus(1));
BOOST_CHECK_EQUAL( WellCommon::StatusEnum::OPEN , well3->getStatus(1));
BOOST_CHECK_EQUAL( WellCommon::StatusEnum::SHUT , well1->getStatus(2));
BOOST_CHECK_EQUAL( WellCommon::StatusEnum::SHUT , well2->getStatus(2));
BOOST_CHECK_EQUAL( WellCommon::StatusEnum::SHUT , well3->getStatus(2));
{
const auto& well1 = sched.getWell2("W1", 1);
const auto& well2 = sched.getWell2("W2", 1);
const auto& well3 = sched.getWell2("W3", 1);
BOOST_CHECK_EQUAL( WellCommon::StatusEnum::OPEN , well1.getStatus());
BOOST_CHECK_EQUAL( WellCommon::StatusEnum::OPEN , well2.getStatus());
BOOST_CHECK_EQUAL( WellCommon::StatusEnum::OPEN , well3.getStatus());
}
{
const auto& well1 = sched.getWell2("W1", 2);
const auto& well2 = sched.getWell2("W2", 2);
const auto& well3 = sched.getWell2("W3", 2);
BOOST_CHECK_EQUAL( WellCommon::StatusEnum::SHUT , well1.getStatus());
BOOST_CHECK_EQUAL( WellCommon::StatusEnum::SHUT , well2.getStatus());
BOOST_CHECK_EQUAL( WellCommon::StatusEnum::SHUT , well3.getStatus());
}
}
@ -735,36 +628,53 @@ BOOST_AUTO_TEST_CASE(WellTestWPOLYMER) {
BOOST_CHECK(sched.hasWell("INJE01"));
BOOST_CHECK(sched.hasWell("PROD01"));
const auto* well1 = sched.getWell("INJE01");
BOOST_CHECK( well1->isInjector(0));
{
const WellPolymerProperties& props_well10 = well1->getPolymerProperties(0);
const auto& well1 = sched.getWell2("INJE01", 0);
BOOST_CHECK( well1.isInjector());
const WellPolymerProperties& props_well10 = well1.getPolymerProperties();
BOOST_CHECK_CLOSE(1.5*Metric::PolymerDensity, props_well10.m_polymerConcentration, 0.0001);
const WellPolymerProperties& props_well11 = well1->getPolymerProperties(1);
}
{
const auto& well1 = sched.getWell2("INJE01", 1);
const WellPolymerProperties& props_well11 = well1.getPolymerProperties();
BOOST_CHECK_CLOSE(1.0*Metric::PolymerDensity, props_well11.m_polymerConcentration, 0.0001);
const WellPolymerProperties& props_well12 = well1->getPolymerProperties(2);
}
{
const auto& well1 = sched.getWell2("INJE01", 2);
const WellPolymerProperties& props_well12 = well1.getPolymerProperties();
BOOST_CHECK_CLOSE(0.1*Metric::PolymerDensity, props_well12.m_polymerConcentration, 0.0001);
}
const auto* well2 = sched.getWell("INJE02");
BOOST_CHECK( well2->isInjector(0));
{
const WellPolymerProperties& props_well20 = well2->getPolymerProperties(0);
const auto& well2 = sched.getWell2("INJE02", 0);
BOOST_CHECK( well2.isInjector());
const WellPolymerProperties& props_well20 = well2.getPolymerProperties();
BOOST_CHECK_CLOSE(2.0*Metric::PolymerDensity, props_well20.m_polymerConcentration, 0.0001);
const WellPolymerProperties& props_well21 = well2->getPolymerProperties(1);
}
{
const auto& well2 = sched.getWell2("INJE02", 1);
const WellPolymerProperties& props_well21 = well2.getPolymerProperties();
BOOST_CHECK_CLOSE(1.5*Metric::PolymerDensity, props_well21.m_polymerConcentration, 0.0001);
const WellPolymerProperties& props_well22 = well2->getPolymerProperties(2);
}
{
const auto& well2 = sched.getWell2("INJE02", 2);
const WellPolymerProperties& props_well22 = well2.getPolymerProperties();
BOOST_CHECK_CLOSE(0.2*Metric::PolymerDensity, props_well22.m_polymerConcentration, 0.0001);
}
const auto* well3 = sched.getWell("INJE03");
BOOST_CHECK( well3->isInjector(0));
{
const WellPolymerProperties& props_well30 = well3->getPolymerProperties(0);
const auto& well3 = sched.getWell2("INJE03", 0);
BOOST_CHECK( well3.isInjector());
const WellPolymerProperties& props_well30 = well3.getPolymerProperties();
BOOST_CHECK_CLOSE(2.5*Metric::PolymerDensity, props_well30.m_polymerConcentration, 0.0001);
const WellPolymerProperties& props_well31 = well3->getPolymerProperties(1);
}
{
const auto& well3 = sched.getWell2("INJE03", 1);
const WellPolymerProperties& props_well31 = well3.getPolymerProperties();
BOOST_CHECK_CLOSE(2.0*Metric::PolymerDensity, props_well31.m_polymerConcentration, 0.0001);
const WellPolymerProperties& props_well32 = well3->getPolymerProperties(2);
}
{
const auto& well3 = sched.getWell2("INJE03", 2);
const WellPolymerProperties& props_well32 = well3.getPolymerProperties();
BOOST_CHECK_CLOSE(0.3*Metric::PolymerDensity, props_well32.m_polymerConcentration, 0.0001);
}
}
@ -785,9 +695,8 @@ BOOST_AUTO_TEST_CASE(WellTestWECON) {
BOOST_CHECK(sched.hasWell("PROD01"));
BOOST_CHECK(sched.hasWell("PROD02"));
const auto* prod1 = sched.getWell("PROD01");
{
const WellEconProductionLimits& econ_limit1 = prod1->getEconProductionLimits(0);
const WellEconProductionLimits& econ_limit1 = sched.getWell2("PROD01", 0).getEconLimits();
BOOST_CHECK(econ_limit1.onMinOilRate());
BOOST_CHECK(econ_limit1.onMaxWaterCut());
BOOST_CHECK(!(econ_limit1.onMinGasRate()));
@ -809,7 +718,7 @@ BOOST_AUTO_TEST_CASE(WellTestWECON) {
BOOST_CHECK(econ_limit1.onAnyRateLimit());
BOOST_CHECK(econ_limit1.onAnyEffectiveLimit());
const WellEconProductionLimits& econ_limit2 = prod1->getEconProductionLimits(1);
const WellEconProductionLimits& econ_limit2 = sched.getWell2("PROD01", 1).getEconLimits();
BOOST_CHECK(!(econ_limit2.onMinOilRate()));
BOOST_CHECK(econ_limit2.onMaxWaterCut());
BOOST_CHECK(econ_limit2.onMinGasRate());
@ -832,9 +741,8 @@ BOOST_AUTO_TEST_CASE(WellTestWECON) {
BOOST_CHECK(econ_limit2.onAnyEffectiveLimit());
}
const auto* prod2 = sched.getWell("PROD02");
{
const WellEconProductionLimits& econ_limit1 = prod2->getEconProductionLimits(0);
const WellEconProductionLimits& econ_limit1 = sched.getWell2("PROD02", 0).getEconLimits();
BOOST_CHECK(!(econ_limit1.onMinOilRate()));
BOOST_CHECK(!(econ_limit1.onMaxWaterCut()));
BOOST_CHECK(!(econ_limit1.onMinGasRate()));
@ -856,7 +764,7 @@ BOOST_AUTO_TEST_CASE(WellTestWECON) {
BOOST_CHECK(!(econ_limit1.onAnyRateLimit()));
BOOST_CHECK(!(econ_limit1.onAnyEffectiveLimit()));
const WellEconProductionLimits& econ_limit2 = prod2->getEconProductionLimits(1);
const WellEconProductionLimits& econ_limit2 = sched.getWell2("PROD02", 1).getEconLimits();
BOOST_CHECK(!(econ_limit2.onMinOilRate()));
BOOST_CHECK(econ_limit2.onMaxWaterCut());
BOOST_CHECK(econ_limit2.onMinGasRate());
@ -925,14 +833,11 @@ BOOST_AUTO_TEST_CASE(TestWellEvents) {
Eclipse3DProperties eclipseProperties ( deck , table, grid);
Runspec runspec(deck);
Schedule sched(deck , grid , eclipseProperties, runspec);
const auto& w1 = sched.getWell( "W_1");
const auto& w2 = sched.getWell( "W_2");
BOOST_CHECK( sched.hasWellEvent( "W_1", ScheduleEvents::NEW_WELL , 0 ));
BOOST_CHECK( sched.hasWellEvent( "W_2", ScheduleEvents::NEW_WELL , 2 ));
BOOST_CHECK( sched.hasWellEvent( "W_1", ScheduleEvents::NEW_WELL , 0 ));
BOOST_CHECK( sched.hasWellEvent( "W_2", ScheduleEvents::NEW_WELL , 2 ));
BOOST_CHECK( !sched.hasWellEvent( "W_2", ScheduleEvents::NEW_WELL , 3 ));
BOOST_CHECK( sched.hasWellEvent( "W_2", ScheduleEvents::WELL_WELSPECS_UPDATE , 3 ));
BOOST_CHECK( sched.hasWellEvent( "W_2", ScheduleEvents::WELL_WELSPECS_UPDATE , 3 ));
BOOST_CHECK( sched.hasWellEvent( "W_1", ScheduleEvents::WELL_STATUS_CHANGE , 0 ));
BOOST_CHECK( sched.hasWellEvent( "W_1", ScheduleEvents::WELL_STATUS_CHANGE , 1 ));
@ -942,7 +847,4 @@ BOOST_AUTO_TEST_CASE(TestWellEvents) {
BOOST_CHECK( sched.hasWellEvent( "W_1", ScheduleEvents::COMPLETION_CHANGE , 0 ));
BOOST_CHECK( sched.hasWellEvent( "W_1", ScheduleEvents::COMPLETION_CHANGE , 5 ));
BOOST_CHECK_EQUAL( w1->firstTimeStep( ) , 0 );
BOOST_CHECK_EQUAL( w2->firstTimeStep( ) , 2 );
}

64
tests/test_AggregateConnectionData.cpp
View File

@ -47,13 +47,13 @@
struct MockIH
{
MockIH(const int numWells,
const int nsegWell = 1, // E100
const int ncwMax = 20,
const int iConnPerConn = 25, // NICONZ
const int sConnPerConn = 40, // NSCONZ
const int xConnPerConn = 58); // NXCONZ
std::vector<int> value;
@ -80,7 +80,7 @@ MockIH::MockIH(const int numWells,
using Ix = ::Opm::RestartIO::Helpers::VectorItems::intehead;
this->nwells = this->value[Ix::NWELLS] = numWells;
this->nsegwl = this->value[Ix::NSEGWL] = nsegWell;
this->ncwmax = this->value[Ix::NCWMAX] = 20;
this->nswlmx = this->value[Ix::NSWLMX] = 1;
@ -144,10 +144,10 @@ GRID =========================================================
BOX
1 10 1 5 1 1 /
TOPS
TOPS
50*7000 /
BOX
BOX
1 10 1 5 1 10 /
DXV
@ -175,15 +175,15 @@ COPY
RPTGRID
-- Report Levels for Grid Section Data
--
/
--
/
EDIT
EQUALS
'PORV' 0.0 7 7 1 1 9 9 /
/
PROPS ==========================================================
-- WATER RELATIVE PERMEABILITY AND CAPILLARY PRESSURE ARE TABULATED AS
@ -292,9 +292,9 @@ PVTO
/
RPTPROPS
RPTPROPS
-- PROPS Reporting Options
--
--
/
REGIONS ===========================================================
@ -332,13 +332,13 @@ RSVD 2 TABLES 3 NODES IN EACH FIELD 12:00 17 AUG 83
RPTRST
-- Restart File Output Control
--
--
'BASIC=2' 'FLOWS' 'POT' 'PRES' /
--RPTSOL
--
--
-- Initialisation Print Output
--
--
--'PRES' 'SOIL' 'SWAT' 'SGAS' 'RS' 'RESTART=1' 'FIP=2' 'EQUIL' 'RSVD' /
SUMMARY ===========================================================
@ -464,7 +464,7 @@ END
return Opm::Parser{}.parseString(input);
}
Opm::data::WellRates wr()
{
using o = ::Opm::data::Rates::opt;
@ -483,11 +483,11 @@ END
for (int i = 0; i < 5; i++) {
xw["PROD"].connections.emplace_back();
auto& c = xw["PROD"].connections.back();
c.rates.set(o::wat, qw*(float(i)+1.))
.set(o::oil, qo*(float(i)+1.))
.set(o::gas, qg*(float(i)+1.));
c.pressure = 215.;
c.pressure = 215.;
}
auto seg = Opm::data::Segment{};
for (std::size_t i = 1; i < 5; i++) {
@ -502,7 +502,7 @@ END
for (int i = 0; i < 5; i++) {
xw["WINJ"].connections.emplace_back();
auto& c = xw["WINJ"].connections.back();
c.rates.set(o::wat, qw*(float(i)+1.))
.set(o::oil, 0.)
.set(o::gas, 0.);
@ -536,7 +536,7 @@ BOOST_AUTO_TEST_SUITE(Aggregate_ConnData)
BOOST_AUTO_TEST_CASE (Constructor)
{
const auto ih = MockIH{ 5 };
const auto amconn = Opm::RestartIO::Helpers::AggregateConnectionData{ ih.value };
BOOST_CHECK_EQUAL(amconn.getIConn().size(), ih.nwells * ih.ncwmax * ih.niconz);
@ -553,7 +553,7 @@ BOOST_AUTO_TEST_CASE (Declared_Connection_Data)
const auto rptStep = std::size_t{1};
const auto ih = MockIH {
static_cast<int>(simCase.sched.getWells(rptStep).size())
static_cast<int>(simCase.sched.getWells2(rptStep).size())
};
BOOST_CHECK_EQUAL(ih.nwells, MockIH::Sz{2});
@ -562,7 +562,7 @@ BOOST_AUTO_TEST_CASE (Declared_Connection_Data)
auto amconn = Opm::RestartIO::Helpers::AggregateConnectionData{ih.value};
amconn.captureDeclaredConnData(simCase.sched,
simCase.grid,
simCase.es.getUnits(),
simCase.es.getUnits(),
wrc,
rptStep
);
@ -620,7 +620,7 @@ BOOST_AUTO_TEST_CASE (Declared_Connection_Data)
BOOST_CHECK_EQUAL(iConn[start + Ix::ComplNum ] , 3); // WINJ-connection 3, Complum number
BOOST_CHECK_EQUAL(iConn[start + Ix::ConnDir ] , 1); // WINJ-connection 3, Connection direction
BOOST_CHECK_EQUAL(iConn[start + Ix::Segment ] , 0); // WINJ-connection 3, Segment ID for direction
start = ih.ncwmax*ih.niconz + 3*ih.niconz;
BOOST_CHECK_EQUAL(iConn[start + Ix::SeqIndex ] , 4); // WINJ-connection 4, sequence number
BOOST_CHECK_EQUAL(iConn[start + Ix::CellI ] , 6); // WINJ-connection 4, Cell I
@ -632,7 +632,7 @@ BOOST_AUTO_TEST_CASE (Declared_Connection_Data)
BOOST_CHECK_EQUAL(iConn[start + Ix::ComplNum ] , 4); // WINJ-connection 4, Complum number
BOOST_CHECK_EQUAL(iConn[start + Ix::ConnDir ] , 1); // WINJ-connection 4, Connection direction
BOOST_CHECK_EQUAL(iConn[start + Ix::Segment ] , 0); // WINJ-connection 4, Segment ID for direction
}
// SCONN (PROD) + (WINJ)
@ -649,7 +649,7 @@ BOOST_AUTO_TEST_CASE (Declared_Connection_Data)
BOOST_CHECK_CLOSE(sconn[i0 + Ix::item12 ], 2.55826545 , 1.0e-5); // PROD - conn 1 : Transmissibility factor
BOOST_CHECK_CLOSE(sconn[i0 + Ix::SegDistEnd ], 130. , 1.0e-5); // PROD - conn 1 : Distance to end of connection in segment
BOOST_CHECK_CLOSE(sconn[i0 + Ix::SegDistStart], 30. , 1.0e-5); // PROD - conn 1 : Distance to start of connection in segment
// Well no 2 - WINJ well
connNo = 3;
i0 = ih.ncwmax*ih.nsconz + (connNo-1)*ih.nsconz;
@ -660,7 +660,7 @@ BOOST_AUTO_TEST_CASE (Declared_Connection_Data)
BOOST_CHECK_CLOSE(sconn[i0 + Ix::item12 ], 2.55826545 , 1.0e-5); // WINJ - conn 3 : Transmissibility factor
BOOST_CHECK_CLOSE(sconn[i0 + Ix::SegDistEnd ], 0. , 1.0e-5); // WINJ - conn 3 : Distance to end of connection in segment
BOOST_CHECK_CLOSE(sconn[i0 + Ix::SegDistStart], 0. , 1.0e-5); // WINJ - conn 3 : Distance to start of connection in segment
connNo = 4;
i0 = ih.ncwmax*ih.nsconz + (connNo-1)*ih.nsconz;
BOOST_CHECK_CLOSE(sconn[i0 + Ix::ConnTrans ], 2.55826545 , 1.0e-5); // WINJ - conn 4 : Transmissibility factor
@ -671,9 +671,9 @@ BOOST_AUTO_TEST_CASE (Declared_Connection_Data)
BOOST_CHECK_CLOSE(sconn[i0 + Ix::SegDistEnd ], 0. , 1.0e-5); // WINJ - conn 4 : Distance to end of connection in segment
BOOST_CHECK_CLOSE(sconn[i0 + Ix::SegDistStart], 0. , 1.0e-5); // WINJ - conn 4 : Distance to start of connection in segment
}
// XCONN (PROD) + (WINJ)
{
using Ix = ::Opm::RestartIO::Helpers::VectorItems::XConn::index;
@ -687,20 +687,20 @@ BOOST_AUTO_TEST_CASE (Declared_Connection_Data)
BOOST_CHECK_CLOSE(xconn[i0 + Ix::OilRate ], -units.from_si(M::liquid_surface_rate,5.*(float(connNo))) , 1.0e-5); // PROD - conn 1 : Surface oil rate
BOOST_CHECK_CLOSE(xconn[i0 + Ix::WaterRate], -units.from_si(M::liquid_surface_rate,4.*(float(connNo))) , 1.0e-5); // PROD - conn 1 : Surface water rate
BOOST_CHECK_CLOSE(xconn[i0 + Ix::GasRate ], -units.from_si(M::gas_surface_rate, 50.*(float(connNo))) , 1.0e-5); // PROD - conn 1 : Surface gas rate
BOOST_CHECK_CLOSE(xconn[i0 + Ix::Pressure ], units.from_si(M::pressure, 215.) , 1.0e-5); // PROD - conn 1 : Connection pressure
BOOST_CHECK_CLOSE(xconn[i0 + Ix::Pressure ], units.from_si(M::pressure, 215.) , 1.0e-5); // PROD - conn 1 : Connection pressure
BOOST_CHECK_CLOSE(xconn[i0 + Ix::ResVRate ], 0. , 1.0e-5); // PROD - conn 1 : Reservoir volume rate
// WINJ well
connNo = 3;
i0 = ih.ncwmax*ih.nxconz + (connNo-1)*ih.nxconz;
BOOST_CHECK_CLOSE(xconn[i0 + Ix::WaterRate], -units.from_si(M::liquid_surface_rate,7.*(float(connNo))) , 1.0e-5); // WINJ - conn 3 : Surface water rate
BOOST_CHECK_CLOSE(xconn[i0 + Ix::Pressure ], units.from_si(M::pressure, 218.) , 1.0e-5); // WINJ - conn 3 : Connection pressure
BOOST_CHECK_CLOSE(xconn[i0 + Ix::Pressure ], units.from_si(M::pressure, 218.) , 1.0e-5); // WINJ - conn 3 : Connection pressure
BOOST_CHECK_CLOSE(xconn[i0 + Ix::ResVRate ], 0. , 1.0e-5); // WINJ - conn 3 : Reservoir volume rate
connNo = 4;
i0 = ih.ncwmax*ih.nxconz + (connNo-1)*ih.nxconz;
BOOST_CHECK_CLOSE(xconn[i0 + Ix::WaterRate], -units.from_si(M::liquid_surface_rate,7.*(float(connNo))) , 1.0e-5); // WINJ - conn 3 : Surface water rate
BOOST_CHECK_CLOSE(xconn[i0 + Ix::Pressure ], units.from_si(M::pressure, 218.) , 1.0e-5); // WINJ - conn 3 : Connection pressure
BOOST_CHECK_CLOSE(xconn[i0 + Ix::Pressure ], units.from_si(M::pressure, 218.) , 1.0e-5); // WINJ - conn 3 : Connection pressure
BOOST_CHECK_CLOSE(xconn[i0 + Ix::ResVRate ], 0. , 1.0e-5); // WINJ - conn 3 : Reservoir volume rate
}

48
tests/test_AggregateGroupData.cpp
View File

@ -45,12 +45,12 @@
struct MockIH
{
MockIH(const int numWells,
const int igrpPerGrp = 101, // no of data elements per group in IGRP array
const int sgrpPerGrp = 112, // number of data elements per group in SGRP array
const int xgrpPerGrp = 180, // number of data elements per group in XGRP array
const int zgrpPerGrp = 5); // number of data elements per group in XGRP array
std::vector<int> value;
@ -75,7 +75,7 @@ MockIH::MockIH(const int numWells,
using Ix = ::Opm::RestartIO::Helpers::VectorItems::intehead;
this->nwells = this->value[Ix::NWELLS] = numWells;
this->ngmaxz = this->value[Ix::NGMAXZ] = 5;
this->nwgmax = this->value[Ix::NWGMAX] = 4;
this->nigrpz = this->value[Ix::NIGRPZ] = igrpPerGrp;
@ -93,7 +93,7 @@ namespace {
RUNSPEC
TITLE
2 PRODUCERS AND INJECTORS, 2 WELL GROUPS AND ONE INTERMEDIATE GROUP LEVEL BELOW THE FIELD LEVEL
2 PRODUCERS AND INJECTORS, 2 WELL GROUPS AND ONE INTERMEDIATE GROUP LEVEL BELOW THE FIELD LEVEL
DIMENS
10 5 10 /
@ -135,10 +135,10 @@ GRID =========================================================
BOX
1 10 1 5 1 1 /
TOPS
TOPS
50*7000 /
BOX
BOX
1 10 1 5 1 10 /
DXV
@ -166,8 +166,8 @@ COPY
RPTGRID
-- Report Levels for Grid Section Data
--
/
--
/
PROPS ==========================================================
@ -283,9 +283,9 @@ PVTO
/
RPTPROPS
RPTPROPS
-- PROPS Reporting Options
--
--
/
REGIONS ===========================================================
@ -323,9 +323,9 @@ RSVD 2 TABLES 3 NODES IN EACH FIELD 12:00 17 AUG 83
RPTRST
-- Restart File Output Control
--
--
'BASIC=2' 'FLOWS' 'POT' 'PRES' /
SUMMARY ===========================================================
@ -444,7 +444,7 @@ END
state.update("GOPR:WGRP2", 43.);
state.update("GGPR:WGRP2", 70237.);
state.update("GWPR:WGRP2", 59.);
state.update("FOPR", 3456.);
state.update("FGPR", 2003456.);
state.update("FWPR", 5678.);
@ -463,7 +463,7 @@ struct SimulationCase
// Order requirement: 'es' must be declared/initialised before 'sched'.
Opm::EclipseState es;
Opm::Schedule sched;
};
};
// =====================================================================
@ -474,7 +474,7 @@ BOOST_AUTO_TEST_SUITE(Aggregate_Group)
BOOST_AUTO_TEST_CASE (Constructor)
{
const auto ih = MockIH{ 5 };
const auto agrpd = Opm::RestartIO::Helpers::AggregateGroupData{ ih.value };
BOOST_CHECK_EQUAL(agrpd.getIGroup().size(), ih.ngmaxz * ih.nigrpz);
@ -492,7 +492,7 @@ BOOST_AUTO_TEST_CASE (Declared_Group_Data)
const auto rptStep = std::size_t{1};
const auto ih = MockIH {
static_cast<int>(simCase.sched.getWells(rptStep).size())
static_cast<int>(simCase.sched.getWells2(rptStep).size())
};
BOOST_CHECK_EQUAL(ih.nwells, MockIH::Sz{4});
@ -520,7 +520,7 @@ BOOST_AUTO_TEST_CASE (Declared_Group_Data)
BOOST_CHECK_EQUAL(iGrp[start + ih.nwgmax + 26] , 1); // Group GRP1 - Group type (well group = 0, node group = 1)
BOOST_CHECK_EQUAL(iGrp[start + ih.nwgmax + 27] , 1); // Group GRP1 - Group level (FIELD level is 0)
BOOST_CHECK_EQUAL(iGrp[start + ih.nwgmax + 28] , 5); // Group GRP1 - index of parent group (= 0 for FIELD)
start = 1*ih.nigrpz;
BOOST_CHECK_EQUAL(iGrp[start + 0] , 1); // Group WGRP1 - Child well number one - equal to well PROD1 (no 1)
BOOST_CHECK_EQUAL(iGrp[start + 1] , 3); // Group WGRP1 - Child well number two - equal to well WINJ1 (no 3)
@ -528,7 +528,7 @@ BOOST_AUTO_TEST_CASE (Declared_Group_Data)
BOOST_CHECK_EQUAL(iGrp[start + ih.nwgmax + 26] , 0); // Group WGRP1 - Group type (well group = 0, node group = 1)
BOOST_CHECK_EQUAL(iGrp[start + ih.nwgmax + 27] , 2); // Group WGRP1 - Group level (FIELD level is 0)
BOOST_CHECK_EQUAL(iGrp[start + ih.nwgmax + 28] , 1); // Group GRP1 - index of parent group (= 0 for FIELD)
start = (ih.ngmaxz-1)*ih.nigrpz;
BOOST_CHECK_EQUAL(iGrp[start + 0] , 1); // Group FIELD - Child group number one - equal to group GRP1
BOOST_CHECK_EQUAL(iGrp[start + 4] , 1); // Group FIELD - No of child groups
@ -536,7 +536,7 @@ BOOST_AUTO_TEST_CASE (Declared_Group_Data)
BOOST_CHECK_EQUAL(iGrp[start + ih.nwgmax + 27] , 0); // Group FIELD - Group level (FIELD level is 0)
}
// XGRP (PROD)
{
auto start = 0*ih.nxgrpz;
@ -545,7 +545,7 @@ BOOST_AUTO_TEST_CASE (Declared_Group_Data)
BOOST_CHECK_EQUAL(xGrp[start + 0] , 235.); // Group GRP1 - GOPR
BOOST_CHECK_EQUAL(xGrp[start + 1] , 239.); // Group GRP1 - GWPR
BOOST_CHECK_EQUAL(xGrp[start + 2] , 100237.); // Group GRP1 - GGPR
start = 1*ih.nxgrpz;
BOOST_CHECK_EQUAL(xGrp[start + 0] , 23.); // Group WGRP1 - GOPR
BOOST_CHECK_EQUAL(xGrp[start + 1] , 29.); // Group WGRP1 - GWPR
@ -556,7 +556,7 @@ BOOST_AUTO_TEST_CASE (Declared_Group_Data)
BOOST_CHECK_EQUAL(xGrp[start + 1] , 59.); // Group WGRP2 - GWPR
BOOST_CHECK_EQUAL(xGrp[start + 2] , 70237.); // Group WGRP2 - GGPR
start = (ih.ngmaxz-1)*ih.nxgrpz;
BOOST_CHECK_EQUAL(xGrp[start + 0] , 3456.); // Group FIELD - FOPR
BOOST_CHECK_EQUAL(xGrp[start + 1] , 5678.); // Group FIELD - FWPR
@ -569,18 +569,18 @@ BOOST_AUTO_TEST_CASE (Declared_Group_Data)
const auto& zGrp = agrpd.getZGroup();
BOOST_CHECK_EQUAL(zGrp[start + 0].c_str() , "GRP1 "); // Group GRP1 - GOPR
start = 1*ih.nzgrpz;
BOOST_CHECK_EQUAL(zGrp[start + 0].c_str() , "WGRP1 "); // Group WGRP1 - GOPR
start = 2*ih.nzgrpz;
BOOST_CHECK_EQUAL(zGrp[start + 0].c_str() , "WGRP2 "); // Group WGRP2 - GOPR
start = (ih.ngmaxz-1)*ih.nzgrpz;
BOOST_CHECK_EQUAL(zGrp[start + 0].c_str() , "FIELD "); // Group FIELD - FOPR
}
}

98
tests/test_AggregateMSWData.cpp
View File

@ -45,20 +45,20 @@
struct MockIH
{
MockIH(const int numWells,
const int nsegWell = 2, // E100
const int isegPerWell = 22, // E100
const int rsegPerWell = 146, // E100
const int ilbsPerWell = 5, // E100
const int ilbrPerWell = 10); // E100
std::vector<int> value;
using Sz = std::vector<int>::size_type;
Sz nwells;
Sz nsegwl;
Sz nswlmx;
Sz nsegmx;
@ -79,7 +79,7 @@ MockIH::MockIH(const int numWells,
using Ix = ::Opm::RestartIO::Helpers::VectorItems::intehead;
this->nwells = this->value[Ix::NWELLS] = numWells;
this->nsegwl = this->value[Ix::NSEGWL] = nsegWell;
this->nswlmx = this->value[Ix::NSWLMX] = 2;
this->nsegmx = this->value[Ix::NSEGMX] = 32;
@ -143,10 +143,10 @@ GRID =========================================================
BOX
1 10 1 5 1 1 /
TOPS
TOPS
50*7000 /
BOX
BOX
1 10 1 5 1 10 /
DXV
@ -174,8 +174,8 @@ COPY
RPTGRID
-- Report Levels for Grid Section Data
--
/
--
/
PROPS ==========================================================
@ -291,9 +291,9 @@ PVTO
/
RPTPROPS
RPTPROPS
-- PROPS Reporting Options
--
--
/
REGIONS ===========================================================
@ -331,13 +331,13 @@ RSVD 2 TABLES 3 NODES IN EACH FIELD 12:00 17 AUG 83
RPTRST
-- Restart File Output Control
--
--
'BASIC=2' 'FLOWS' 'POT' 'PRES' /
--RPTSOL
--
--
-- Initialisation Print Output
--
--
--'PRES' 'SOIL' 'SWAT' 'SGAS' 'RS' 'RESTART=1' 'FIP=2' 'EQUIL' 'RSVD' /
SUMMARY ===========================================================
@ -507,7 +507,7 @@ END
state.update("SOFR:PROD:2", 30.);
state.update("SOFR:PROD:3", 25.);
state.update("SOFR:PROD:4", 20.);
state.update("SGFR:PROD:1", 25.E3);
state.update("SGFR:PROD:2", 20.E3);
state.update("SGFR:PROD:3", 15.E3);
@ -527,9 +527,9 @@ END
state.update("SWFR:WINJ:2", 22.);
state.update("SWFR:WINJ:3", 23.);
state.update("SWFR:WINJ:4", 24.);
state.update("WBHP:WINJ", 234.);
return state;
}
Opm::data::WellRates wr()
@ -550,7 +550,7 @@ END
for (int i = 0; i < 5; i++) {
xw["PROD"].connections.emplace_back();
auto& c = xw["PROD"].connections.back();
c.rates.set(o::wat, qw*(float(i)+1.))
.set(o::oil, qo*(float(i)+1.))
.set(o::gas, qg*(float(i)+1.));
@ -568,7 +568,7 @@ END
for (int i = 0; i < 5; i++) {
xw["WINJ"].connections.emplace_back();
auto& c = xw["WINJ"].connections.back();
c.rates.set(o::wat, qw*(float(i)+1.))
.set(o::oil, 0.)
.set(o::gas, 0.);
@ -601,7 +601,7 @@ BOOST_AUTO_TEST_SUITE(Aggregate_MSW)
BOOST_AUTO_TEST_CASE (Constructor)
{
const auto ih = MockIH{ 5 };
const auto amswd = Opm::RestartIO::Helpers::AggregateMSWData{ ih.value };
BOOST_CHECK_EQUAL(amswd.getISeg().size(), ih.nswlmx * ih.nsegmx * ih.nisegz);
@ -619,7 +619,7 @@ BOOST_AUTO_TEST_CASE (Declared_MSW_Data)
const auto rptStep = std::size_t{1};
const auto ih = MockIH {
static_cast<int>(simCase.sched.getWells(rptStep).size())
static_cast<int>(simCase.sched.getWells2(rptStep).size())
};
BOOST_CHECK_EQUAL(ih.nwells, MockIH::Sz{2});
@ -629,8 +629,8 @@ BOOST_AUTO_TEST_CASE (Declared_MSW_Data)
auto amswd = Opm::RestartIO::Helpers::AggregateMSWData{ih.value};
amswd.captureDeclaredMSWData(simCase.sched,
rptStep,
simCase.es.getUnits(),
ih.value,
simCase.es.getUnits(),
ih.value,
simCase.grid,
smry,
wrc
@ -641,7 +641,7 @@ BOOST_AUTO_TEST_CASE (Declared_MSW_Data)
auto start = 2*ih.nisegz;
const auto& iSeg = amswd.getISeg();
BOOST_CHECK_EQUAL(iSeg[start + 0] , 15); // PROD-segment 3, ordered segment
BOOST_CHECK_EQUAL(iSeg[start + 0] , 15); // PROD-segment 3, ordered segment
BOOST_CHECK_EQUAL(iSeg[start + 1] , 2); // PROD-segment 3, outlet segment
BOOST_CHECK_EQUAL(iSeg[start + 2] , 4); // PROD-segment 3, inflow segment current branch
BOOST_CHECK_EQUAL(iSeg[start + 3] , 1); // PROD-segment 3, branch number
@ -649,11 +649,11 @@ BOOST_AUTO_TEST_CASE (Declared_MSW_Data)
BOOST_CHECK_EQUAL(iSeg[start + 5] , 1); // PROD-segment 3, Sum number of inflow branches from first segment to current segment
BOOST_CHECK_EQUAL(iSeg[start + 6] , 0); // PROD-segment 3, number of connections in segment
BOOST_CHECK_EQUAL(iSeg[start + 7] , 0); // PROD-segment 3, sum of connections with lower segmeent number than current segment
BOOST_CHECK_EQUAL(iSeg[start + 8] , 15); // PROD-segment 3, ordered segment
BOOST_CHECK_EQUAL(iSeg[start + 8] , 15); // PROD-segment 3, ordered segment
start = 13*ih.nisegz;
BOOST_CHECK_EQUAL(iSeg[start + 0] , 4); // PROD-segment 14, ordered segment
BOOST_CHECK_EQUAL(iSeg[start + 0] , 4); // PROD-segment 14, ordered segment
BOOST_CHECK_EQUAL(iSeg[start + 1] , 13); // PROD-segment 14, outlet segment
BOOST_CHECK_EQUAL(iSeg[start + 2] , 15); // PROD-segment 14, inflow segment current branch
BOOST_CHECK_EQUAL(iSeg[start + 3] , 2); // PROD-segment 14, branch number
@ -661,7 +661,7 @@ BOOST_AUTO_TEST_CASE (Declared_MSW_Data)
BOOST_CHECK_EQUAL(iSeg[start + 5] , 0); // PROD-segment 14, Sum number of inflow branches from first segment to current segment
BOOST_CHECK_EQUAL(iSeg[start + 6] , 1); // PROD-segment 14, number of connections in segment
BOOST_CHECK_EQUAL(iSeg[start + 7] , 2); // PROD-segment 14, sum of connections with lower segmeent number than current segment
BOOST_CHECK_EQUAL(iSeg[start + 8] , 4); // PROD-segment 14, ordered segment
BOOST_CHECK_EQUAL(iSeg[start + 8] , 4); // PROD-segment 14, ordered segment
}
@ -670,7 +670,7 @@ BOOST_AUTO_TEST_CASE (Declared_MSW_Data)
auto start = ih.nisegz*ih.nsegmx + 13*ih.nisegz;
const auto& iSeg = amswd.getISeg();
BOOST_CHECK_EQUAL(iSeg[start + 0] , 6); // WINJ-segment 14, ordered segment
BOOST_CHECK_EQUAL(iSeg[start + 0] , 6); // WINJ-segment 14, ordered segment
BOOST_CHECK_EQUAL(iSeg[start + 1] , 13); // WINJ-segment 14, outlet segment
BOOST_CHECK_EQUAL(iSeg[start + 2] , 0); // WINJ-segment 14, inflow segment current branch
BOOST_CHECK_EQUAL(iSeg[start + 3] , 1); // WINJ-segment 14, branch number
@ -678,10 +678,10 @@ BOOST_AUTO_TEST_CASE (Declared_MSW_Data)
BOOST_CHECK_EQUAL(iSeg[start + 5] , 1); // WINJ-segment 14, Sum number of inflow branches from first segment to current segment
BOOST_CHECK_EQUAL(iSeg[start + 6] , 0); // WINJ-segment 14, number of connections in segment
BOOST_CHECK_EQUAL(iSeg[start + 7] , 0); // WINJ-segment 14, sum of connections with lower segmeent number than current segment
BOOST_CHECK_EQUAL(iSeg[start + 8] , 6); // WINJ-segment 14, ordered segment
BOOST_CHECK_EQUAL(iSeg[start + 8] , 6); // WINJ-segment 14, ordered segment
start = ih.nisegz*ih.nsegmx + 16*ih.nisegz;
BOOST_CHECK_EQUAL(iSeg[start + 0] , 3); // WINJ-segment 17, ordered segment
BOOST_CHECK_EQUAL(iSeg[start + 0] , 3); // WINJ-segment 17, ordered segment
BOOST_CHECK_EQUAL(iSeg[start + 1] , 16); // WINJ-segment 17, outlet segment
BOOST_CHECK_EQUAL(iSeg[start + 2] , 18); // WINJ-segment 17, inflow segment current branch
BOOST_CHECK_EQUAL(iSeg[start + 3] , 2); // WINJ-segment 17, branch number
@ -689,10 +689,10 @@ BOOST_AUTO_TEST_CASE (Declared_MSW_Data)
BOOST_CHECK_EQUAL(iSeg[start + 5] , 0); // WINJ-segment 17, Sum number of inflow branches from first segment to current segment
BOOST_CHECK_EQUAL(iSeg[start + 6] , 1); // WINJ-segment 17, number of connections in segment
BOOST_CHECK_EQUAL(iSeg[start + 7] , 3); // WINJ-segment 17, sum of connections with lower segmeent number than current segment
BOOST_CHECK_EQUAL(iSeg[start + 8] , 3); // WINJ-segment 17, ordered segment
BOOST_CHECK_EQUAL(iSeg[start + 8] , 3); // WINJ-segment 17, ordered segment
}
// RSEG (PROD) + (WINJ)
{
// well no 1 - PROD
@ -712,21 +712,21 @@ BOOST_AUTO_TEST_CASE (Declared_MSW_Data)
BOOST_CHECK_CLOSE(rseg[i0 + 5], 0.31 , 1.0e-10);
BOOST_CHECK_CLOSE(rseg[i0 + 6], 10. , 1.0e-10);
BOOST_CHECK_CLOSE(rseg[i0 + 7], 7010. , 1.0e-10);
const double temp_o = smry.get("SOFR:PROD:1");
const double temp_w = smry.get("SWFR:PROD:1")*0.1;
const double temp_g = smry.get("SGFR:PROD:1")*gfactor;
auto t0 = temp_o + temp_w + temp_g;
double t1 = (std::abs(temp_w) > 0) ? temp_w / t0 : 0.;
double t2 = (std::abs(temp_g) > 0) ? temp_g / t0 : 0.;
BOOST_CHECK_CLOSE(rseg[i0 + 8], t0, 1.0e-10);
BOOST_CHECK_CLOSE(rseg[i0 + 9], t1, 1.0e-10);
BOOST_CHECK_CLOSE(rseg[i0 + 10], t2, 1.0e-10);
BOOST_CHECK_CLOSE(rseg[i0 + 11], 235., 1.0e-10);
}
{
// well no 2 - WINJ
const std::string wname = "WINJ";
@ -746,23 +746,23 @@ BOOST_AUTO_TEST_CASE (Declared_MSW_Data)
BOOST_CHECK_CLOSE(rseg[i0 + 5], 0.31 , 1.0e-10);
BOOST_CHECK_CLOSE(rseg[i0 + 6], 10. , 1.0e-10);
BOOST_CHECK_CLOSE(rseg[i0 + 7], 7010. , 1.0e-10);
const double temp_o = 0.;
const double temp_w = -units.from_si(M::liquid_surface_rate,105.)*0.1;
const double temp_g = 0.0*gfactor;
auto t0 = temp_o + temp_w + temp_g;
double t1 = (std::abs(temp_w) > 0) ? temp_w / t0 : 0.;
double t2 = (std::abs(temp_g) > 0) ? temp_g / t0 : 0.;
BOOST_CHECK_CLOSE(rseg[i0 + 8], t0, 1.0e-10);
BOOST_CHECK_CLOSE(rseg[i0 + 9], t1, 1.0e-10);
BOOST_CHECK_CLOSE(rseg[i0 + 10], t2, 1.0e-10);
BOOST_CHECK_CLOSE(rseg[i0 + 11], 234., 1.0e-10);
}
// ILBR
// ILBR
{
auto start = 0*ih.nilbrz;
@ -772,23 +772,23 @@ BOOST_AUTO_TEST_CASE (Declared_MSW_Data)
BOOST_CHECK_EQUAL(iLBr[start + 1] , 12); // PROD-branch 1, No of segments in branch
BOOST_CHECK_EQUAL(iLBr[start + 2] , 1); // PROD-branch 1, first segment
BOOST_CHECK_EQUAL(iLBr[start + 3] , 12); // PROD-branch 1, last segment
BOOST_CHECK_EQUAL(iLBr[start + 4] , 0); // PROD-branch 1, branch no - 1
BOOST_CHECK_EQUAL(iLBr[start + 4] , 0); // PROD-branch 1, branch no - 1
//PROD
start = 1*ih.nilbrz;
BOOST_CHECK_EQUAL(iLBr[start + 0] , 3); // PROD-branch 2, outlet segment
BOOST_CHECK_EQUAL(iLBr[start + 1] , 5); // PROD-branch 2, No of segments in branch
BOOST_CHECK_EQUAL(iLBr[start + 2] , 13); // PROD-branch 2, first segment
BOOST_CHECK_EQUAL(iLBr[start + 3] , 17); // PROD-branch 2, last segment
BOOST_CHECK_EQUAL(iLBr[start + 4] , 1); // PROD-branch 2, branch no - 1
BOOST_CHECK_EQUAL(iLBr[start + 4] , 1); // PROD-branch 2, branch no - 1
start = ih.nilbrz*ih.nlbrmx + 0*ih.nilbrz;
//WINJ
BOOST_CHECK_EQUAL(iLBr[start + 0] , 0); // WINJ-branch 1, outlet segment
BOOST_CHECK_EQUAL(iLBr[start + 1] , 14); // WINJ-branch 1, No of segments in branch
BOOST_CHECK_EQUAL(iLBr[start + 2] , 1); // WINJ-branch 1, first segment
BOOST_CHECK_EQUAL(iLBr[start + 3] , 14); // WINJ-branch 1, last segment
BOOST_CHECK_EQUAL(iLBr[start + 4] , 0); // WINJ-branch 1, branch no - 1
BOOST_CHECK_EQUAL(iLBr[start + 4] , 0); // WINJ-branch 1, branch no - 1
start = ih.nilbrz*ih.nlbrmx + 1*ih.nilbrz;
//WINJ
@ -796,11 +796,11 @@ BOOST_AUTO_TEST_CASE (Declared_MSW_Data)
BOOST_CHECK_EQUAL(iLBr[start + 1] , 5); // WINJ-branch 2, No of segments in branch
BOOST_CHECK_EQUAL(iLBr[start + 2] , 15); // WINJ-branch 2, first segment
BOOST_CHECK_EQUAL(iLBr[start + 3] , 19); // WINJ-branch 2, last segment
BOOST_CHECK_EQUAL(iLBr[start + 4] , 1); // WINJ-branch 2, branch no - 1
BOOST_CHECK_EQUAL(iLBr[start + 4] , 1); // WINJ-branch 2, branch no - 1
}
// ILBS
{
auto start = 0*ih.nlbrmx;
@ -808,7 +808,7 @@ BOOST_AUTO_TEST_CASE (Declared_MSW_Data)
const auto& iLBs = amswd.getILBs();
//PROD
BOOST_CHECK_EQUAL(iLBs[start + 0] , 13); // PROD-branch 2, first segment in branch
start = ih.nlbrmx + 0*ih.nlbrmx;
//WINJ
BOOST_CHECK_EQUAL(iLBs[start + 0] , 15); // WINJ-branch 2, first segment in branch

6
tests/test_AggregateWellData.cpp
View File

@ -380,7 +380,7 @@ BOOST_AUTO_TEST_CASE (Declared_Well_Data)
const auto rptStep = std::size_t{1};
const auto ih = MockIH {
static_cast<int>(simCase.sched.getWells(rptStep).size())
static_cast<int>(simCase.sched.getWells2(rptStep).size())
};
BOOST_CHECK_EQUAL(ih.nwells, MockIH::Sz{2});
@ -531,7 +531,7 @@ BOOST_AUTO_TEST_CASE (Dynamic_Well_Data_Step1)
const auto rptStep = std::size_t{1};
const auto ih = MockIH {
static_cast<int>(simCase.sched.getWells(rptStep).size())
static_cast<int>(simCase.sched.getWells2(rptStep).size())
};
const auto xw = well_rates_1();
@ -638,7 +638,7 @@ BOOST_AUTO_TEST_CASE (Dynamic_Well_Data_Step2)
const auto rptStep = std::size_t{2};
const auto ih = MockIH {
static_cast<int>(simCase.sched.getWells(rptStep).size())
static_cast<int>(simCase.sched.getWells2(rptStep).size())
};
const auto xw = well_rates_2();

1
tests/test_RFT.cpp
View File

@ -30,7 +30,6 @@
#include <opm/parser/eclipse/Deck/Deck.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
#include <opm/parser/eclipse/EclipseState/SummaryConfig/SummaryConfig.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/Well.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
#include <opm/parser/eclipse/EclipseState/IOConfig/IOConfig.hpp>

1
tests/test_Restart.cpp
View File

@ -34,7 +34,6 @@
#include <opm/parser/eclipse/EclipseState/IOConfig/IOConfig.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
#include <opm/parser/eclipse/EclipseState/SummaryConfig/SummaryConfig.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/Well.hpp>
#include <opm/parser/eclipse/Parser/Parser.hpp>
#include <opm/parser/eclipse/Utility/Functional.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/SummaryState.hpp>

1
tests/test_Summary.cpp
View File

@ -299,7 +299,6 @@ void compare(const SummaryState& st, const ecl_sum_type * ecl_sum, int tstep) {
BOOST_AUTO_TEST_SUITE(Summary)
/*
* Tests works by reading the Deck, write the summary output, then immediately
* read it again (with ERT), and compare the read values with the input.

33
tests/test_writenumwells.cpp
View File

@ -29,7 +29,6 @@
#include <opm/parser/eclipse/EclipseState/Schedule/TimeMap.hpp>
#include <opm/parser/eclipse/EclipseState/SummaryConfig/SummaryConfig.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/WellConnections.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/Well.hpp>
#include <opm/parser/eclipse/Parser/ParseContext.hpp>
#include <opm/parser/eclipse/Parser/Parser.hpp>
@ -54,32 +53,39 @@ void verifyWellState(const std::string& rst_filename,
int numwells = well_info_get_num_wells(well_info);
BOOST_CHECK_EQUAL( numwells, schedule.numWells() );
auto wells = schedule.getWells();
auto wells = schedule.getWells2atEnd();
for (int i = 0; i < numwells; ++i) {
//Verify wellnames
const char * wellname = well_info_iget_well_name(well_info, i);
auto* well = wells.at(i);
BOOST_CHECK_EQUAL( wellname, well->name() );
// Verify well-head position data
well_ts_type* well_ts = well_info_get_ts(well_info , wellname);
well_state_type* well_state = well_ts_iget_state(well_ts, 0);
const well_conn_type* well_head = well_state_get_wellhead(well_state, ECL_GRID_GLOBAL_GRID);
BOOST_CHECK_EQUAL(well_conn_get_i(well_head), well->getHeadI());
BOOST_CHECK_EQUAL(well_conn_get_j(well_head), well->getHeadJ());
{
const auto& sched_well = wells.at(i);
BOOST_CHECK_EQUAL( wellname, sched_well.name() );
// Verify well-head position data
const well_conn_type* well_head = well_state_get_wellhead(well_state, ECL_GRID_GLOBAL_GRID);
BOOST_CHECK_EQUAL(well_conn_get_i(well_head), sched_well.getHeadI());
BOOST_CHECK_EQUAL(well_conn_get_j(well_head), sched_well.getHeadJ());
}
for (int j = 0; j < well_ts_get_size(well_ts); ++j) {
const auto& well_at_end = schedule.getWell2atEnd(wellname);
if (!well_at_end.hasBeenDefined(j))
continue;
const auto& well = schedule.getWell2(wellname, j);
well_state = well_ts_iget_state(well_ts, j);
//Verify welltype
int well_type = ERT_UNDOCUMENTED_ZERO;
if( well->isProducer( j ) ) {
if( well.isProducer( ) ) {
well_type = ERT_PRODUCER;
}
else {
switch( well->getInjectionProperties( j ).injectorType ) {
switch( well.getInjectionProperties( ).injectorType ) {
case WellInjector::WATER:
well_type = ERT_WATER_INJECTOR;
break;
@ -99,7 +105,7 @@ void verifyWellState(const std::string& rst_filename,
//Verify wellstatus
int ert_well_status = well_state_is_open(well_state) ? 1 : 0;
int wellstatus = well->getStatus( j ) == WellCommon::OPEN ? 1 : 0;
int wellstatus = well.getStatus( ) == WellCommon::OPEN ? 1 : 0;
BOOST_CHECK_EQUAL(ert_well_status, wellstatus);
@ -107,8 +113,7 @@ void verifyWellState(const std::string& rst_filename,
const well_conn_collection_type * well_connections = well_state_get_global_connections( well_state );
size_t num_wellconnections = well_conn_collection_get_size(well_connections);
int report_nr = well_state_get_report_nr(well_state);
const auto& connections_set = well->getConnections((size_t)report_nr);
const auto& connections_set = well.getConnections();
BOOST_CHECK_EQUAL(num_wellconnections, connections_set.size());