ea38a25af4
this is just the result of ``` find -iname "*.[ch]pp" | xargs sed -i "s/ *$//" find opm/parser/share/keywords -type f | xargs sed -i "s/ *$//" ``` so if it causes conflicts with other patches, the others should get priority. The rationale behind this patch is that some people tell their editor to remove white space which leads to larger than necessary patches...
230 lines
9.3 KiB
C++
230 lines
9.3 KiB
C++
/*
|
|
Copyright 2013 Statoil ASA.
|
|
|
|
This file is part of the Open Porous Media project (OPM).
|
|
|
|
OPM is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
OPM is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with OPM. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <opm/parser/eclipse/Deck/DeckIntItem.hpp>
|
|
|
|
#include <opm/parser/eclipse/EclipseState/Schedule/TimeMap.hpp>
|
|
#include <opm/parser/eclipse/Deck/DeckDoubleItem.hpp>
|
|
|
|
namespace Opm {
|
|
TimeMap::TimeMap(boost::posix_time::ptime startDate) {
|
|
if (startDate.is_not_a_date_time())
|
|
throw std::invalid_argument("Input argument not properly initialized.");
|
|
|
|
m_timeList.push_back( boost::posix_time::ptime(startDate) );
|
|
}
|
|
|
|
TimeMap::TimeMap(Opm::DeckConstPtr deck) {
|
|
// The default start date is not specified in the Eclipse
|
|
// reference manual. We hence just assume it is same as for
|
|
// the START keyword for Eclipse R100, i.e., January 1st,
|
|
// 1983...
|
|
boost::posix_time::ptime startTime(boost::gregorian::date(1983, 1, 1));
|
|
|
|
// use the 'START' keyword to find out the start date (if the
|
|
// keyword was specified)
|
|
if (deck->hasKeyword("START")) {
|
|
Opm::DeckKeywordConstPtr keyword = deck->getKeyword("START");
|
|
startTime = timeFromEclipse(keyword->getRecord(/*index=*/0));
|
|
}
|
|
|
|
m_timeList.push_back( startTime );
|
|
|
|
// find all "TSTEP" and "DATES" keywords in the deck and deal
|
|
// with them one after another
|
|
size_t numKeywords = deck->size();
|
|
for (size_t keywordIdx = 0; keywordIdx < numKeywords; ++keywordIdx) {
|
|
Opm::DeckKeywordConstPtr keyword = deck->getKeyword(keywordIdx);
|
|
|
|
// We're only interested in "TSTEP" and "DATES" keywords,
|
|
// so we ignore everything else here...
|
|
if (keyword->name() != "TSTEP" &&
|
|
keyword->name() != "DATES")
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (keyword->name() == "TSTEP")
|
|
addFromTSTEPKeyword(keyword);
|
|
else if (keyword->name() == "DATES")
|
|
addFromDATESKeyword(keyword);
|
|
}
|
|
}
|
|
|
|
size_t TimeMap::numTimesteps() const {
|
|
return m_timeList.size() - 1;
|
|
}
|
|
|
|
|
|
boost::posix_time::ptime TimeMap::getStartTime(size_t tStepIdx) const {
|
|
return m_timeList[tStepIdx];
|
|
}
|
|
|
|
|
|
double TimeMap::getTotalTime() const
|
|
{
|
|
if (m_timeList.size() < 2)
|
|
return 0.0;
|
|
boost::posix_time::time_duration deltaT = m_timeList.back() - m_timeList.front();
|
|
return static_cast<double>(deltaT.total_milliseconds())/1000.0;
|
|
}
|
|
|
|
void TimeMap::addTime(boost::posix_time::ptime newTime) {
|
|
boost::posix_time::ptime lastTime = m_timeList.back();
|
|
if (newTime > lastTime)
|
|
m_timeList.push_back( newTime );
|
|
else
|
|
throw std::invalid_argument("Times added must be in strictly increasing order.");
|
|
}
|
|
|
|
|
|
void TimeMap::addTStep(boost::posix_time::time_duration step) {
|
|
if (step.total_seconds() > 0) {
|
|
boost::posix_time::ptime newTime = m_timeList.back() + step;
|
|
m_timeList.push_back( newTime );
|
|
} else
|
|
throw std::invalid_argument("Can only add positive steps");
|
|
}
|
|
|
|
|
|
size_t TimeMap::size() const {
|
|
return m_timeList.size();
|
|
}
|
|
|
|
const std::map<std::string , boost::gregorian::greg_month>& TimeMap::eclipseMonthNames() {
|
|
static std::map<std::string , boost::gregorian::greg_month> monthNames;
|
|
|
|
if (monthNames.size() == 0) {
|
|
monthNames.insert( std::make_pair( "JAN" , boost::gregorian::Jan ));
|
|
monthNames.insert( std::make_pair( "FEB" , boost::gregorian::Feb ));
|
|
monthNames.insert( std::make_pair( "MAR" , boost::gregorian::Mar ));
|
|
monthNames.insert( std::make_pair( "APR" , boost::gregorian::Apr ));
|
|
monthNames.insert( std::make_pair( "MAI" , boost::gregorian::May ));
|
|
monthNames.insert( std::make_pair( "MAY" , boost::gregorian::May ));
|
|
monthNames.insert( std::make_pair( "JUN" , boost::gregorian::Jun ));
|
|
monthNames.insert( std::make_pair( "JUL" , boost::gregorian::Jul ));
|
|
monthNames.insert( std::make_pair( "JLY" , boost::gregorian::Jul ));
|
|
monthNames.insert( std::make_pair( "AUG" , boost::gregorian::Aug ));
|
|
monthNames.insert( std::make_pair( "SEP" , boost::gregorian::Sep ));
|
|
monthNames.insert( std::make_pair( "OCT" , boost::gregorian::Oct ));
|
|
monthNames.insert( std::make_pair( "OKT" , boost::gregorian::Oct ));
|
|
monthNames.insert( std::make_pair( "NOV" , boost::gregorian::Nov ));
|
|
monthNames.insert( std::make_pair( "DEC" , boost::gregorian::Dec ));
|
|
monthNames.insert( std::make_pair( "DES" , boost::gregorian::Dec ));
|
|
}
|
|
|
|
return monthNames;
|
|
}
|
|
|
|
boost::posix_time::ptime TimeMap::timeFromEclipse(int day,
|
|
const std::string& eclipseMonthName,
|
|
int year,
|
|
const std::string& eclipseTimeString) {
|
|
boost::gregorian::greg_month month = eclipseMonthNames().at( eclipseMonthName );
|
|
boost::gregorian::date date( year , month , day );
|
|
boost::posix_time::time_duration dayTime = dayTimeFromEclipse(eclipseTimeString);
|
|
return boost::posix_time::ptime(date, dayTime);
|
|
}
|
|
|
|
boost::posix_time::time_duration TimeMap::dayTimeFromEclipse(const std::string& eclipseTimeString) {
|
|
return boost::posix_time::duration_from_string(eclipseTimeString);
|
|
}
|
|
|
|
boost::posix_time::ptime TimeMap::timeFromEclipse(DeckRecordConstPtr dateRecord) {
|
|
static const std::string errorMsg("The datarecord must consist of the for values "
|
|
"\"DAY(int), MONTH(string), YEAR(int), TIME(string)\".\n");
|
|
if (dateRecord->size() != 4) {
|
|
throw std::invalid_argument( errorMsg);
|
|
}
|
|
|
|
DeckItemConstPtr dayItem = dateRecord->getItem( 0 );
|
|
DeckItemConstPtr monthItem = dateRecord->getItem( 1 );
|
|
DeckItemConstPtr yearItem = dateRecord->getItem( 2 );
|
|
DeckItemConstPtr timeItem = dateRecord->getItem( 3 );
|
|
|
|
try {
|
|
int day = dayItem->getInt(0);
|
|
const std::string& month = monthItem->getString(0);
|
|
int year = yearItem->getInt(0);
|
|
std::string eclipseTimeString = timeItem->getString(0);
|
|
|
|
return TimeMap::timeFromEclipse(day, month, year, eclipseTimeString);
|
|
} catch (...) {
|
|
throw std::invalid_argument( errorMsg );
|
|
}
|
|
}
|
|
|
|
void TimeMap::addFromDATESKeyword( DeckKeywordConstPtr DATESKeyword ) {
|
|
if (DATESKeyword->name() != "DATES")
|
|
throw std::invalid_argument("Method requires DATES keyword input.");
|
|
|
|
for (size_t recordIndex = 0; recordIndex < DATESKeyword->size(); recordIndex++) {
|
|
DeckRecordConstPtr record = DATESKeyword->getRecord( recordIndex );
|
|
boost::posix_time::ptime nextTime = TimeMap::timeFromEclipse( record );
|
|
addTime( nextTime );
|
|
}
|
|
}
|
|
|
|
void TimeMap::addFromTSTEPKeyword( DeckKeywordConstPtr TSTEPKeyword ) {
|
|
if (TSTEPKeyword->name() != "TSTEP")
|
|
throw std::invalid_argument("Method requires TSTEP keyword input.");
|
|
{
|
|
DeckRecordConstPtr record = TSTEPKeyword->getRecord( 0 );
|
|
DeckItemConstPtr item = record->getItem( 0 );
|
|
|
|
for (size_t itemIndex = 0; itemIndex < item->size(); itemIndex++) {
|
|
double days = item->getRawDouble( itemIndex );
|
|
long int wholeSeconds = static_cast<long int>(days * 24*60*60);
|
|
long int milliSeconds = static_cast<long int>((days * 24*60*60 - wholeSeconds)*1000);
|
|
boost::posix_time::time_duration step =
|
|
boost::posix_time::seconds(wholeSeconds) +
|
|
boost::posix_time::milliseconds(milliSeconds);
|
|
addTStep( step );
|
|
}
|
|
}
|
|
}
|
|
|
|
double TimeMap::getTimeStepLength(size_t tStepIdx) const
|
|
{
|
|
assert(tStepIdx < numTimesteps());
|
|
const boost::posix_time::ptime &t1
|
|
= m_timeList[tStepIdx];
|
|
const boost::posix_time::ptime &t2
|
|
= m_timeList[tStepIdx + 1];
|
|
const boost::posix_time::time_duration &deltaT
|
|
= t2 - t1;
|
|
return static_cast<double>(deltaT.total_milliseconds())/1000.0;
|
|
}
|
|
|
|
double TimeMap::getTimePassedUntil(size_t tLevelIdx) const
|
|
{
|
|
assert(tLevelIdx < m_timeList.size());
|
|
const boost::posix_time::ptime &t1
|
|
= m_timeList.front();
|
|
const boost::posix_time::ptime &t2
|
|
= m_timeList[tLevelIdx];
|
|
const boost::posix_time::time_duration &deltaT
|
|
= t2 - t1;
|
|
return static_cast<double>(deltaT.total_milliseconds())/1000.0;
|
|
}
|
|
|
|
}
|
|
|
|
|