Loading...
Searching...
No Matches
Events.hpp
/*
Copyright 2015 Statoil ASA.
This file is part of the Open Porous Media project (OPM).
OPM is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OPM is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OPM. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef SCHEDULE_EVENTS_HPP
#define SCHEDULE_EVENTS_HPP
#include <cstdint>
#include <string>
#include <unordered_map>
namespace Opm
{
namespace ScheduleEvents {
// These values are used as bitmask - 2^n structure is essential.
enum Events {
/*
The NEW_WELL event is triggered by the WELSPECS
keyword. For wells the event is triggered the first
time the well is mentioned in the WELSPECS keyword, for
the Schedule object the NEW_WELL event is triggered
every time a WELSPECS keyword is encountered.
*/
NEW_WELL = (1 << 0),
/*
WHen the well data is updated with the WELSPECS keyword
this event is triggered. Only applies to individual
wells, and not the global Schedule object.
*/
WELL_WELSPECS_UPDATE = (1 << 1),
//WELL_POLYMER_UPDATE = (1 << 2),
/*
The NEW_GROUP event is triggered by the WELSPECS and
GRUPTREE keywords.
*/
NEW_GROUP = (1 << 3),
/*
The PRODUCTION_UPDATE event is triggered by the
WCONPROD, WCONHIST, WELTARG, WEFAC keywords. The event will be
triggered if *any* of the elements in one of keywords
is changed. Quite simlar for INJECTION_UPDATE and
POLYMER_UPDATE.
*/
PRODUCTION_UPDATE = (1 << 4),
INJECTION_UPDATE = (1 << 5),
//POLYMER_UPDATES = (1 << 6),
/*
This event is triggered if the well status is changed
between {OPEN,SHUT,STOP,AUTO}. There are many keywords
which can trigger a well status change.
*/
WELL_STATUS_CHANGE = (1 << 7),
/*
COMPDAT and WELOPEN
*/
COMPLETION_CHANGE = (1 << 8),
/*
The well group topolyg has changed.
*/
GROUP_CHANGE = (1 << 9),
/*
Geology modifier.
*/
GEO_MODIFIER = (1 << 10),
/*
TUNING has changed
*/
TUNING_CHANGE = (1 << 11),
/* The VFP tables have changed */
VFPINJ_UPDATE = (1 << 12),
VFPPROD_UPDATE = (1 << 13),
/*
GROUP production or injection targets has changed
*/
GROUP_PRODUCTION_UPDATE = (1 << 14),
GROUP_INJECTION_UPDATE = (1 << 15),
/*
* New explicit well productivity/injectivity assignment.
*/
WELL_PRODUCTIVITY_INDEX = (1 << 16),
/*
* Well/group efficiency factor has changed
*/
WELLGROUP_EFFICIENCY_UPDATE = (1 << 17),
/*
* Injection type changed
*/
INJECTION_TYPE_CHANGED = (1 << 18),
/*
* Well switched between injector and producer
*/
WELL_SWITCHED_INJECTOR_PRODUCER = (1 << 19),
/*
* The well has been affected in an ACTIONX keyword.
*/
ACTIONX_WELL_EVENT = (1 << 20),
/*
* Some SCHEDULE keywords can set a well to be OPEN to open a previously STOPped or SHUT well.
* The well is SHUT/STOP due to various causes (SCHEDULE, economical, physical, etc.)
* For now, the WELOPEN, WCONPROD and WCONINJE keywords are considered with this event
*/
REQUEST_OPEN_WELL = (1 << 21),
};
}
/*
This class implements a simple system for recording when various
events happen in the Schedule file. The purpose of the class is
that downstream code can query this system whether a certain a
event has taken place, and then perform potentially expensive
calculations conditionally:
auto events = schedule->getEvents();
if (events.hasEvent(SchedulEvents::NEW_WELL , reportStep))
// Perform expensive calculation which must be performed
// when a new well is introduced.
...
*/
class Events {
public:
static Events serializationTestObject();
void addEvent(ScheduleEvents::Events event);
bool hasEvent(uint64_t eventMask) const;
void clearEvent(uint64_t eventMask);
void reset();
bool operator==(const Events& data) const;
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(m_events);
}
private:
uint64_t m_events = 0;
};
class WellGroupEvents {
public:
static WellGroupEvents serializationTestObject();
void addWell(const std::string& wname);
void addGroup(const std::string& gname);
void addEvent(const std::string& wgname, ScheduleEvents::Events event);
bool hasEvent(const std::string& wgname, uint64_t eventMask) const;
bool has(const std::string& wgname) const;
void clearEvent(const std::string& wgname, uint64_t eventMask);
void reset();
const Events& at(const std::string& wgname) const;
bool operator==(const WellGroupEvents& data) const;
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(m_wellgroup_events);
}
private:
std::unordered_map<std::string, Events> m_wellgroup_events;
};
}
#endif
Opm::Events
Definition Events.hpp:154
Opm::Serializer
Class for (de-)serializing.
Definition Serializer.hpp:91
Opm::WellGroupEvents
Definition Events.hpp:176
Opm
This class implements a small container which holds the transmissibility mulitpliers for all the face...
Definition Exceptions.hpp:30