Refactor ensemble import dialog

* #9773 Refactor ensemble import dialog.
* #9773 Add support for ensemble import of StimPlan/Reveal summary data.
* #9773 Add method for finding min and max time steps.
* #9773 Add option for resampling to hour intervals.
* #9773 Add option for resampling to minute intervals.
* #9773 Ensemble statistics: determine sub-sampling period dynamically.
* Use RiaWeightedMeanCalculator for curve resampling.
* Add HOUR and MINUTE to date time app enum.
* #9773 Generate better ensembles for StimPlan summaries.
* #9773 Fix parameters.txt lookup for StimPlan summaries
* Refactor: Improve interface of RicImportSummaryCasesFreature::createSummaryCasesFromFiles

Co-authored-by: Magne Sjaastad <magne.sjaastad@ceetronsolutions.com>

ApplicationLibCode/Application/Tools/RiaEnsembleNameTools.cpp

@@ -133,6 +133,106 @@ std::vector<QStringList> RiaEnsembleNameTools::groupFilesByEnsemble( const QStri
     return groupedByIteration;
 }
 
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+std::map<QString, QStringList> RiaEnsembleNameTools::groupFilesByStimPlanEnsemble( const QStringList& fileNames )
+{
+    std::vector<QStringList> componentsForAllFilePaths;
+    for ( const auto& filePath : fileNames )
+    {
+        QStringList components = RiaFilePathTools::splitPathIntoComponents( filePath );
+        componentsForAllFilePaths.push_back( components );
+    }
+
+    auto mapping = findUniqueStimPlanEnsembleNames( fileNames, componentsForAllFilePaths );
+
+    std::set<QString> iterations;
+    for ( const auto& [name, iterFileNamePair] : mapping )
+    {
+        iterations.insert( iterFileNamePair.first );
+    }
+
+    std::map<QString, QStringList> groupedByIteration;
+
+    for ( const QString& groupIteration : iterations )
+    {
+        QStringList fileNamesFromIteration;
+
+        for ( const auto& [name, iterFileNamePair] : mapping )
+        {
+            QString iteration = iterFileNamePair.first;
+            QString fileName  = iterFileNamePair.second;
+
+            if ( groupIteration == iteration )
+            {
+                fileNamesFromIteration << fileName;
+            }
+        }
+        groupedByIteration[groupIteration] = fileNamesFromIteration;
+    }
+
+    return groupedByIteration;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+std::map<QString, std::pair<QString, QString>>
+    RiaEnsembleNameTools::findUniqueStimPlanEnsembleNames( const QStringList& fileNames, const std::vector<QStringList>& fileNameComponents )
+{
+    CAF_ASSERT( fileNames.size() == static_cast<int>( fileNameComponents.size() ) );
+
+    struct StimPlanComponents
+    {
+        QString realization;
+        QString iteration;
+        QString well;
+        QString fracture;
+        QString job;
+        QString fileName;
+    };
+
+    std::vector<StimPlanComponents> comps;
+
+    int i = 0;
+    for ( const auto& fileComponents : fileNameComponents )
+    {
+        int numComponents = fileComponents.size();
+
+        if ( numComponents >= 7 )
+        {
+            StimPlanComponents c;
+            c.fileName    = fileNames[i];
+            c.fracture    = fileComponents[numComponents - 2];
+            c.iteration   = fileComponents[numComponents - 6];
+            c.realization = fileComponents[numComponents - 7];
+
+            QString     wellJobComponent = fileComponents[numComponents - 3];
+            QStringList parts            = wellJobComponent.split( "_" );
+
+            if ( parts.size() == 4 )
+            {
+                c.well = parts[0];
+                c.job  = parts[3];
+            }
+
+            comps.push_back( c );
+        }
+        i++;
+    }
+
+    std::map<QString, std::pair<QString, QString>> mapping;
+    for ( const StimPlanComponents& c : comps )
+    {
+        QString key       = QString( "%1, %2, %3, %4, %5" ).arg( c.iteration, c.realization, c.well, c.fracture, c.job );
+        QString iteration = QString( "%1, %2, %3, %4" ).arg( c.iteration, c.well, c.fracture, c.job );
+        mapping[key]      = std::make_pair( iteration, c.fileName );
+    }
+
+    return mapping;
+}
+
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/Application/Tools/RiaEnsembleNameTools.h

@@ -49,7 +49,11 @@ public:
                                                   const std::map<QString, QStringList>& keyFileComponentsForAllFiles,
                                                   const QString&                        ensembleCaseName );
 
-    static std::vector<QStringList> groupFilesByEnsemble( const QStringList& fileNames, EnsembleGroupingMode groupingMode );
+    static std::vector<QStringList>       groupFilesByEnsemble( const QStringList& fileNames, EnsembleGroupingMode groupingMode );
+    static std::map<QString, QStringList> groupFilesByStimPlanEnsemble( const QStringList& fileNames );
+
+    static std::map<QString, std::pair<QString, QString>>
+        findUniqueStimPlanEnsembleNames( const QStringList& fileNames, const std::vector<QStringList>& fileNameComponents );
 
     static QString uniqueShortNameForEnsembleCase( RimSummaryCase* summaryCase );
     static QString uniqueShortNameForSummaryCase( RimSummaryCase* summaryCase );

ApplicationLibCode/Application/Tools/RiaQDateTimeTools.cpp

@@ -21,6 +21,7 @@
 #include <QDateTime>
 #include <QLocale>
 #include <QString>
+#include <QTime>
 
 #include "cafPdmUiItem.h"
 
@@ -32,6 +33,8 @@
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
+const DateTimeSpan RiaQDateTimeTools::TIMESPAN_MINUTE   = DateTimeSpan( 0, 0, 0, 0, 1 );
+const DateTimeSpan RiaQDateTimeTools::TIMESPAN_HOUR     = DateTimeSpan( 0, 0, 0, 1 );
 const DateTimeSpan RiaQDateTimeTools::TIMESPAN_DAY      = DateTimeSpan( 0, 0, 1 );
 const DateTimeSpan RiaQDateTimeTools::TIMESPAN_WEEK     = DateTimeSpan( 0, 0, 7 );
 const DateTimeSpan RiaQDateTimeTools::TIMESPAN_MONTH    = DateTimeSpan( 0, 1, 0 );
@@ -48,6 +51,22 @@ Qt::TimeSpec RiaQDateTimeTools::currentTimeSpec()
     return Qt::UTC;
 }
 
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+quint64 RiaQDateTimeTools::secondsInMinute()
+{
+    return 60;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+quint64 RiaQDateTimeTools::secondsInHour()
+{
+    return 60 * 60;
+}
+
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
@@ -142,7 +161,12 @@ QDateTime RiaQDateTimeTools::addYears( const QDateTime& dt, double years )
 //--------------------------------------------------------------------------------------------------
 QDateTime RiaQDateTimeTools::addSpan( const QDateTime& dt, DateTimeSpan span )
 {
-    return createUtcDateTime( dt ).addYears( span.years() ).addMonths( span.months() ).addDays( span.days() );
+    return createUtcDateTime( dt )
+        .addYears( span.years() )
+        .addMonths( span.months() )
+        .addDays( span.days() )
+        .addSecs( span.hours() * RiaQDateTimeTools::secondsInHour() )
+        .addSecs( span.minutes() * RiaQDateTimeTools::secondsInMinute() );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -150,7 +174,12 @@ QDateTime RiaQDateTimeTools::addSpan( const QDateTime& dt, DateTimeSpan span )
 //--------------------------------------------------------------------------------------------------
 QDateTime RiaQDateTimeTools::subtractSpan( const QDateTime& dt, DateTimeSpan span )
 {
-    return createUtcDateTime( dt ).addYears( -span.years() ).addMonths( -span.months() ).addDays( -span.days() );
+    return createUtcDateTime( dt )
+        .addYears( -span.years() )
+        .addMonths( -span.months() )
+        .addDays( -span.days() )
+        .addSecs( -span.hours() * RiaQDateTimeTools::secondsInHour() )
+        .addSecs( -span.minutes() * RiaQDateTimeTools::secondsInMinute() );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -250,6 +279,10 @@ const DateTimeSpan RiaQDateTimeTools::timeSpan( RiaDefines::DateTimePeriod perio
 {
     switch ( period )
     {
+        case RiaDefines::DateTimePeriod::MINUTE:
+            return TIMESPAN_MINUTE;
+        case RiaDefines::DateTimePeriod::HOUR:
+            return TIMESPAN_HOUR;
         case RiaDefines::DateTimePeriod::DAY:
             return TIMESPAN_DAY;
         case RiaDefines::DateTimePeriod::WEEK:
@@ -274,13 +307,19 @@ const DateTimeSpan RiaQDateTimeTools::timeSpan( RiaDefines::DateTimePeriod perio
 //--------------------------------------------------------------------------------------------------
 QDateTime RiaQDateTimeTools::truncateTime( const QDateTime& dt, RiaDefines::DateTimePeriod period )
 {
-    int y   = dt.date().year();
-    int m   = dt.date().month();
-    int d   = dt.date().day();
-    int dow = dt.date().dayOfWeek();
+    int y      = dt.date().year();
+    int m      = dt.date().month();
+    int d      = dt.date().day();
+    int dow    = dt.date().dayOfWeek();
+    int h      = dt.time().hour();
+    int minute = dt.time().minute();
 
     switch ( period )
     {
+        case RiaDefines::DateTimePeriod::MINUTE:
+            return createUtcDateTime( QDate( y, m, d ), QTime( h, minute, 0 ) );
+        case RiaDefines::DateTimePeriod::HOUR:
+            return createUtcDateTime( QDate( y, m, d ), QTime( h, 0, 0 ) );
         case RiaDefines::DateTimePeriod::DAY:
             return createUtcDateTime( QDate( y, m, d ) );
         case RiaDefines::DateTimePeriod::WEEK:

ApplicationLibCode/Application/Tools/RiaQDateTimeTools.h

@@ -99,6 +99,8 @@ public:
         getTimeStepsWithinSelectedRange( const std::vector<QDateTime>& timeSteps, const QDateTime& fromTimeStep, const QDateTime& toTimeStep );
 
 private:
+    static const DateTimeSpan TIMESPAN_MINUTE;
+    static const DateTimeSpan TIMESPAN_HOUR;
     static const DateTimeSpan TIMESPAN_DAY;
     static const DateTimeSpan TIMESPAN_WEEK;
     static const DateTimeSpan TIMESPAN_MONTH;
@@ -109,6 +111,8 @@ private:
 
     static quint64 secondsInDay();
     static quint64 secondsInYear();
+    static quint64 secondsInHour();
+    static quint64 secondsInMinute();
 };
 
 //==================================================================================================
@@ -121,23 +125,31 @@ public:
         : m_years( 0 )
         , m_months( 0 )
         , m_days( 0 )
+        , m_hours( 0 )
+        , m_minutes( 0 )
     {
     }
-    DateTimeSpan( int years, int months, int days )
+    DateTimeSpan( int years, int months, int days, int hours = 0, int minutes = 0 )
         : m_years( years )
         , m_months( months )
         , m_days( days )
+        , m_hours( hours )
+        , m_minutes( minutes )
     {
     }
 
     int years() const { return m_years; }
     int months() const { return m_months; }
     int days() const { return m_days; }
+    int hours() const { return m_hours; }
+    int minutes() const { return m_minutes; }
 
-    bool isEmpty() { return m_years == 0 && m_months == 0 && m_days; }
+    bool isEmpty() { return m_years == 0 && m_months == 0 && m_days == 0 && m_hours == 0 && m_minutes == 0; }
 
 private:
     int m_years;
     int m_months;
     int m_days;
+    int m_hours;
+    int m_minutes;
 };

ApplicationLibCode/Application/Tools/RiaTimeHistoryCurveResampler.cpp

@@ -21,6 +21,7 @@
 
 #include "RiaQDateTimeTools.h"
 #include "RiaTimeHistoryCurveResampler.h"
+#include "RiaWeightedMeanCalculator.h"
 
 #include <limits>
 
@@ -125,8 +126,6 @@ std::vector<time_t> RiaTimeHistoryCurveResampler::timeStepsFromTimeRange( RiaDef
 //--------------------------------------------------------------------------------------------------
 void RiaTimeHistoryCurveResampler::computeWeightedMeanValues( RiaDefines::DateTimePeriod period )
 {
-    size_t      origDataSize  = m_originalValues.second.size();
-    size_t      oi            = 0;
     const auto& origTimeSteps = m_originalValues.second;
     const auto& origValues    = m_originalValues.first;
 
@@ -138,15 +137,19 @@ void RiaTimeHistoryCurveResampler::computeWeightedMeanValues( RiaDefines::DateTi
     computeResampledTimeSteps( period );
 
     m_values.reserve( m_timeSteps.size() );
+
+    size_t origDataSize = origValues.size();
+    size_t oi           = 0;
     for ( size_t i = 0; i < m_timeSteps.size(); i++ )
     {
-        double wMean = 0.0;
         time_t periodStart =
             i > 0 ? m_timeSteps[i - 1]
                   : RiaQDateTimeTools::subtractPeriod( RiaQDateTimeTools::fromTime_t( m_timeSteps[0] ), period ).toSecsSinceEpoch();
         time_t periodEnd    = m_timeSteps[i];
         time_t periodLength = periodEnd - periodStart;
 
+        RiaWeightedMeanCalculator<double> calc;
+
         while ( true )
         {
             time_t origTimeStep = 0;
@@ -169,7 +172,7 @@ void RiaTimeHistoryCurveResampler::computeWeightedMeanValues( RiaDefines::DateTi
             {
                 if ( origTimeStep == m_timeSteps[i] )
                 {
-                    wMean += origValue;
+                    calc.addValueAndWeight( origValue, periodLength );
                     oi++;
                     break;
                 }
@@ -179,7 +182,7 @@ void RiaTimeHistoryCurveResampler::computeWeightedMeanValues( RiaDefines::DateTi
             time_t startTime = oi > 0 ? std::max( origTimeSteps[oi - 1], periodStart ) : periodStart;
             time_t endTime   = std::min( origTimeStep, periodEnd );
 
-            wMean += origValue * ( endTime - startTime ) / periodLength;
+            calc.addValueAndWeight( origValue, endTime - startTime );
 
             if ( origTimeStep > m_timeSteps[i] ) break;
             if ( origTimeStep == m_timeSteps[i] )
@@ -190,7 +193,7 @@ void RiaTimeHistoryCurveResampler::computeWeightedMeanValues( RiaDefines::DateTi
             oi++;
         }
 
-        m_values.push_back( wMean );
+        m_values.push_back( calc.weightedMean() );
     }
 }