OilfieldToolsNet/ResInsight
4
0
Fork 0
mirror of https://github.com/OPM/ResInsight.git synced 2025-02-25 18:55:39 -06:00
Code Issues Packages Projects Releases Wiki Activity

#165 Keep original days since simulation start

Browse Source
This commit is contained in:
Bjørnar Grip Fjær
2017-04-26 09:39:17 +02:00
parent 6f07a3698b
commit cf18f5324f
16 changed files with 86 additions and 37 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
ApplicationCode/FileInterface/RifEclipseOutputFileTools.cpp
View File

@@ -115,7 +115,7 @@ void getDayMonthYear(const ecl_kw_type* intehead_kw, int* day, int* month, int*
//--------------------------------------------------------------------------------------------------
/// Get list of time step texts (dates)
//--------------------------------------------------------------------------------------------------
void RifEclipseOutputFileTools::timeSteps(ecl_file_type* ecl_file, std::vector<QDateTime>* timeSteps)
void RifEclipseOutputFileTools::timeSteps(ecl_file_type* ecl_file, std::vector<QDateTime>* timeSteps, std::vector<double>* daysSinceSimulationStart)
{
if (!ecl_file) return;
@@ -127,7 +127,7 @@ void RifEclipseOutputFileTools::timeSteps(ecl_file_type* ecl_file, std::vector<Q
// Get the number of occurrences of the DOUBHEAD keyword
int numDOUBHEAD = ecl_file_get_num_named_kw(ecl_file, DOUBHEAD_KW);
std::vector<double> dayFractions(numINTEHEAD, 0.0); // Init fraction to zero
std::vector<double> dayValues(numINTEHEAD, 0.0); // Init fraction to zero
// Read out fraction of day if number of keywords are identical
if (numINTEHEAD == numDOUBHEAD)
@@ -137,12 +137,7 @@ void RifEclipseOutputFileTools::timeSteps(ecl_file_type* ecl_file, std::vector<Q
ecl_kw_type* kwDOUBHEAD = ecl_file_iget_named_kw(ecl_file, DOUBHEAD_KW, i);
if (kwDOUBHEAD)
{
double dayValue = ecl_kw_iget_double(kwDOUBHEAD, DOUBHEAD_DAYS_INDEX);
double floorDayValue = cvf::Math::floor(dayValue);
double dayDelta = dayValue - floorDayValue;
dayFractions[i] = dayDelta;
dayValues[i] = ecl_kw_iget_double(kwDOUBHEAD, DOUBHEAD_DAYS_INDEX);
}
}
}
@@ -159,7 +154,8 @@ void RifEclipseOutputFileTools::timeSteps(ecl_file_type* ecl_file, std::vector<Q
QDateTime reportDateTime(QDate(year, month, day));
CVF_ASSERT(reportDateTime.isValid());
double dayFraction = dayFractions[i];
double dayValue = dayValues[i];
double dayFraction = dayValue - cvf::Math::floor(dayValue);
int milliseconds = static_cast<int>(dayFraction * 24.0 * 60.0 * 60.0 * 1000.0);
int seconds = milliseconds % 1000;
milliseconds -= seconds * 1000;
@@ -172,6 +168,7 @@ void RifEclipseOutputFileTools::timeSteps(ecl_file_type* ecl_file, std::vector<Q
if (std::find(timeSteps->begin(), timeSteps->end(), reportDateTime) == timeSteps->end())
{
timeSteps->push_back(reportDateTime);
daysSinceSimulationStart->push_back(dayValue);
}
}
}

2
ApplicationCode/FileInterface/RifEclipseOutputFileTools.h
View File

@@ -51,7 +51,7 @@ public:
static bool keywordData(ecl_file_type* ecl_file, const QString& keyword, size_t fileKeywordOccurrence, std::vector<double>* values);
static bool keywordData(ecl_file_type* ecl_file, const QString& keyword, size_t fileKeywordOccurrence, std::vector<int>* values);
static void timeSteps(ecl_file_type* ecl_file, std::vector<QDateTime>* timeSteps);
static void timeSteps(ecl_file_type* ecl_file, std::vector<QDateTime>* timeSteps, std::vector<double>* daysSinceSimulationStart);
static bool findSiblingFilesWithSameBaseName(const QString& fileName, QStringList* fileSet);

2
ApplicationCode/FileInterface/RifEclipseRestartDataAccess.h
View File

@@ -98,7 +98,7 @@ public:
virtual void setTimeSteps(const std::vector<QDateTime>& timeSteps) {};
virtual size_t timeStepCount() = 0;
virtual std::vector<QDateTime> timeSteps() = 0;
virtual void timeSteps(std::vector<QDateTime>* timeSteps, std::vector<double>* daysSinceSimulationStart) = 0;
virtual std::vector<int> reportNumbers() = 0;
virtual void resultNames(QStringList* resultNames, std::vector<size_t>* resultDataItemCounts) = 0;

10
ApplicationCode/FileInterface/RifEclipseRestartFilesetAccess.cpp
View File

@@ -119,7 +119,7 @@ size_t RifEclipseRestartFilesetAccess::timeStepCount()
//--------------------------------------------------------------------------------------------------
/// Get the time steps
//--------------------------------------------------------------------------------------------------
std::vector<QDateTime> RifEclipseRestartFilesetAccess::timeSteps()
void RifEclipseRestartFilesetAccess::timeSteps(std::vector<QDateTime>* timeSteps, std::vector<double>* daysSinceSimulationStart)
{
if (m_timeSteps.size() == 0)
{
@@ -128,24 +128,28 @@ std::vector<QDateTime> RifEclipseRestartFilesetAccess::timeSteps()
for (i = 0; i < numSteps; i++)
{
std::vector<QDateTime> stepTime;
std::vector<double> stepDays;
openTimeStep(i);
RifEclipseOutputFileTools::timeSteps(m_ecl_files[i], &stepTime);
RifEclipseOutputFileTools::timeSteps(m_ecl_files[i], &stepTime, &stepDays);
if (stepTime.size() == 1)
{
m_timeSteps.push_back(stepTime[0]);
m_daysSinceSimulationStart.push_back(stepDays[0]);
}
else
{
m_timeSteps.push_back(QDateTime());
m_daysSinceSimulationStart.push_back(0.0);
}
}
}
return m_timeSteps;
*timeSteps = m_timeSteps;
*daysSinceSimulationStart = m_daysSinceSimulationStart;
}
//--------------------------------------------------------------------------------------------------

3
ApplicationCode/FileInterface/RifEclipseRestartFilesetAccess.h
View File

@@ -43,7 +43,7 @@ public:
void setTimeSteps(const std::vector<QDateTime>& timeSteps);
size_t timeStepCount();
std::vector<QDateTime> timeSteps();
void timeSteps(std::vector<QDateTime>* timeSteps, std::vector<double>* daysSinceSimulationStart) override;
std::vector<int> reportNumbers();
void resultNames(QStringList* resultNames, std::vector<size_t>* resultDataItemCounts);
@@ -58,6 +58,7 @@ private:
private:
QStringList m_fileNames;
std::vector<QDateTime> m_timeSteps;
std::vector<double> m_daysSinceSimulationStart;
std::vector< ecl_file_type* > m_ecl_files;
};

14
ApplicationCode/FileInterface/RifEclipseUnifiedRestartFileAccess.cpp
View File

@@ -85,23 +85,23 @@ size_t RifEclipseUnifiedRestartFileAccess::timeStepCount()
{
return 0;
}
std::vector<QDateTime> timeSteps;
std::vector<double> daysSinceSimulationStart;
return timeSteps().size();
this->timeSteps(&timeSteps, &daysSinceSimulationStart);
return timeSteps.size();
}
//--------------------------------------------------------------------------------------------------
/// Get the time steps
//--------------------------------------------------------------------------------------------------
std::vector<QDateTime> RifEclipseUnifiedRestartFileAccess::timeSteps()
void RifEclipseUnifiedRestartFileAccess::timeSteps(std::vector<QDateTime>* timeSteps, std::vector<double>* daysSinceSimulationStart)
{
std::vector<QDateTime> timeSteps;
if (openFile())
{
RifEclipseOutputFileTools::timeSteps(m_ecl_file, &timeSteps);
RifEclipseOutputFileTools::timeSteps(m_ecl_file, timeSteps, daysSinceSimulationStart);
}
return timeSteps;
}

2
ApplicationCode/FileInterface/RifEclipseUnifiedRestartFileAccess.h
View File

@@ -46,7 +46,7 @@ public:
void close();
size_t timeStepCount();
std::vector<QDateTime> timeSteps();
void timeSteps(std::vector<QDateTime>* timeSteps, std::vector<double>* daysSinceSimulationStart) override;
std::vector<int> reportNumbers();
void resultNames(QStringList* resultNames, std::vector<size_t>* resultDataItemCounts);

19
ApplicationCode/FileInterface/RifReaderEclipseOutput.cpp
View File

@@ -657,7 +657,7 @@ void RifReaderEclipseOutput::buildMetaData()
progInfo.incrementProgress();
// Get time steps
m_timeSteps = m_dynamicResultsAccess->timeSteps();
m_dynamicResultsAccess->timeSteps(&m_timeSteps, &m_daysSinceSimulationStart);
std::vector<int> reportNumbers = m_dynamicResultsAccess->reportNumbers();
QStringList resultNames;
@@ -673,7 +673,7 @@ void RifReaderEclipseOutput::buildMetaData()
for (int i = 0; i < matrixResultNames.size(); ++i)
{
size_t resIndex = matrixModelResults->addEmptyScalarResult(RimDefines::DYNAMIC_NATIVE, matrixResultNames[i], false);
matrixModelResults->setTimeStepDates(resIndex, m_timeSteps, reportNumbers);
matrixModelResults->setTimeStepDates(resIndex, m_timeSteps, m_daysSinceSimulationStart, reportNumbers);
}
}
@@ -686,7 +686,7 @@ void RifReaderEclipseOutput::buildMetaData()
for (int i = 0; i < fractureResultNames.size(); ++i)
{
size_t resIndex = fractureModelResults->addEmptyScalarResult(RimDefines::DYNAMIC_NATIVE, fractureResultNames[i], false);
fractureModelResults->setTimeStepDates(resIndex, m_timeSteps, reportNumbers);
fractureModelResults->setTimeStepDates(resIndex, m_timeSteps, m_daysSinceSimulationStart, reportNumbers);
}
}
@@ -723,12 +723,17 @@ void RifReaderEclipseOutput::buildMetaData()
RifEclipseOutputFileTools::findKeywordsAndItemCount(filesUsedToFindAvailableKeywords, &resultNames, &resultNamesDataItemCounts);
std::vector<QDateTime> staticDate;
std::vector<double> staticDay;
std::vector<int> staticReportNumber;
{
if ( m_timeSteps.size() > 0 )
{
staticDate.push_back(m_timeSteps.front());
}
if (m_daysSinceSimulationStart.size() > 0)
{
staticDay.push_back(m_daysSinceSimulationStart.front());
}
std::vector<int> reportNumbers;
if (m_dynamicResultsAccess.notNull())
@@ -754,7 +759,7 @@ void RifReaderEclipseOutput::buildMetaData()
for (int i = 0; i < matrixResultNames.size(); ++i)
{
size_t resIndex = matrixModelResults->addEmptyScalarResult(RimDefines::STATIC_NATIVE, matrixResultNames[i], false);
matrixModelResults->setTimeStepDates(resIndex, staticDate, staticReportNumber);
matrixModelResults->setTimeStepDates(resIndex, staticDate, staticDay, staticReportNumber);
}
}
@@ -769,7 +774,7 @@ void RifReaderEclipseOutput::buildMetaData()
for (int i = 0; i < fractureResultNames.size(); ++i)
{
size_t resIndex = fractureModelResults->addEmptyScalarResult(RimDefines::STATIC_NATIVE, fractureResultNames[i], false);
fractureModelResults->setTimeStepDates(resIndex, staticDate, staticReportNumber);
fractureModelResults->setTimeStepDates(resIndex, staticDate, staticDay, staticReportNumber);
}
}
}
@@ -1124,7 +1129,9 @@ void RifReaderEclipseOutput::readWellCells(const ecl_grid_type* mainEclGrid, boo
m_dynamicResultsAccess->readWellData(ert_well_info, importCompleteMswData);
std::vector<QDateTime> timeSteps = m_dynamicResultsAccess->timeSteps();
std::vector<double> daysSinceSimulationStart;
std::vector<QDateTime> timeSteps;
m_dynamicResultsAccess->timeSteps(&timeSteps, &daysSinceSimulationStart);
std::vector<int> reportNumbers = m_dynamicResultsAccess->reportNumbers();
bool sameCount = false;

1
ApplicationCode/FileInterface/RifReaderEclipseOutput.h
View File

@@ -93,6 +93,7 @@ private:
RigEclipseCaseData* m_eclipseCase;
std::vector<QDateTime> m_timeSteps;
std::vector<double> m_daysSinceSimulationStart;
ecl_file_type* m_ecl_init_file; // File access to static results
cvf::ref<RifEclipseRestartDataAccess> m_dynamicResultsAccess; // File access to dynamic results

10
ApplicationCode/FileInterface/RifReaderMockModel.cpp
View File

@@ -38,24 +38,28 @@ bool RifReaderMockModel::open(const QString& fileName, RigEclipseCaseData* eclip
std::vector<QDateTime> dates;
std::vector<double> days;
std::vector<int> repNumbers;
for (int i = 0; i < static_cast<int>(m_reservoirBuilder.timeStepCount()); i++)
{
dates.push_back(QDateTime(QDate(2012+i, 6, 1)));
days.push_back(i);
repNumbers.push_back(i);
}
for (size_t i = 0; i < m_reservoirBuilder.resultCount(); i++)
{
size_t resIdx = cellResults->addEmptyScalarResult(RimDefines::DYNAMIC_NATIVE, QString("Dynamic_Result_%1").arg(i), false);
cellResults->setTimeStepDates(resIdx, dates, repNumbers);
cellResults->setTimeStepDates(resIdx, dates, days, repNumbers);
}
if (m_reservoirBuilder.timeStepCount() == 0) return true;
std::vector<QDateTime> staticDates;
staticDates.push_back(dates[0]);
std::vector<double> staticDays;
staticDays.push_back(days[0]);
std::vector<int> staticRepNumbers;
staticRepNumbers.push_back(0);
@@ -68,7 +72,7 @@ bool RifReaderMockModel::open(const QString& fileName, RigEclipseCaseData* eclip
if (i > 1) resIndex = i;
size_t resIdx = cellResults->addEmptyScalarResult(RimDefines::STATIC_NATIVE, QString("Static_Result_%1%2").arg(resIndex).arg(varEnd), false);
cellResults->setTimeStepDates(resIdx, staticDates, staticRepNumbers);
cellResults->setTimeStepDates(resIdx, staticDates, staticDays, staticRepNumbers);
}
@@ -77,7 +81,7 @@ bool RifReaderMockModel::open(const QString& fileName, RigEclipseCaseData* eclip
size_t resIdx; \
QString resultName(Name); \
resIdx = cellResults->addEmptyScalarResult(RimDefines::INPUT_PROPERTY, resultName, false); \
cellResults->setTimeStepDates(resIdx, staticDates, staticRepNumbers); \
cellResults->setTimeStepDates(resIdx, staticDates, staticDays, staticRepNumbers); \
cellResults->cellScalarResults(resIdx).resize(1); \
std::vector<double>& values = cellResults->cellScalarResults(resIdx)[0]; \
this->inputProperty(resultName, &values); \

3
ApplicationCode/ProjectDataModel/RimEclipseStatisticsCaseEvaluator.cpp
View File

@@ -44,12 +44,13 @@ void RimEclipseStatisticsCaseEvaluator::addNamedResult(RigCaseCellResultsData* d
CVF_ASSERT(m_sourceCases.size() > 0);
std::vector<QDateTime> sourceTimeStepDates = m_sourceCases[0]->results(RifReaderInterface::MATRIX_RESULTS)->cellResults()->timeStepDates(0);
std::vector<double> sourceDaysSinceSimulationStart = m_sourceCases[0]->results(RifReaderInterface::MATRIX_RESULTS)->cellResults()->daysSinceSimulationStart(0);
std::vector<int> sourceReportStepNumbers = m_sourceCases[0]->results(RifReaderInterface::MATRIX_RESULTS)->cellResults()->reportStepNumbers(0);
size_t destinationScalarResultIndex = destinationCellResults->addEmptyScalarResult(resultType, resultName, true);
CVF_ASSERT(destinationScalarResultIndex != cvf::UNDEFINED_SIZE_T);
destinationCellResults->setTimeStepDates(destinationScalarResultIndex, sourceTimeStepDates, sourceReportStepNumbers);
destinationCellResults->setTimeStepDates(destinationScalarResultIndex, sourceTimeStepDates, sourceDaysSinceSimulationStart, sourceReportStepNumbers);
std::vector< std::vector<double> >& dataValues = destinationCellResults->cellScalarResults(destinationScalarResultIndex);
dataValues.resize(sourceTimeStepDates.size());

3
ApplicationCode/ProjectDataModel/RimIdenticalGridCaseGroup.cpp
View File

@@ -239,6 +239,7 @@ void RimIdenticalGridCaseGroup::loadMainCaseAndActiveCellInfo()
RifReaderInterface::PorosityModelResultType poroModel = RifReaderInterface::MATRIX_RESULTS;
std::vector<QDateTime> timeStepDates = rigCaseData->results(poroModel)->timeStepDates(0);
std::vector<double> daysSinceSimulationStart = rigCaseData->results(poroModel)->daysSinceSimulationStart(0);
std::vector<int> reportStepNumbers = rigCaseData->results(poroModel)->reportStepNumbers(0);
const std::vector<RigCaseCellResultsData::ResultInfo> resultInfos = rigCaseData->results(poroModel)->infoForEachResultIndex();
@@ -264,7 +265,7 @@ void RimIdenticalGridCaseGroup::loadMainCaseAndActiveCellInfo()
if (mustBeCalculated) cellResultsStorage->cellResults()->setMustBeCalculated(scalarResultIndex);
cellResultsStorage->cellResults()->setTimeStepDates(scalarResultIndex, timeStepDates, reportStepNumbers);
cellResultsStorage->cellResults()->setTimeStepDates(scalarResultIndex, timeStepDates, daysSinceSimulationStart, reportStepNumbers);
std::vector< std::vector<double> >& dataValues = cellResultsStorage->cellResults()->cellScalarResults(scalarResultIndex);
dataValues.resize(timeStepDates.size());

4
ApplicationCode/ProjectDataModel/RimReservoirCellResultsStorage.cpp
View File

@@ -137,6 +137,7 @@ void RimReservoirCellResultsStorage::setupBeforeSave()
cacheEntry->m_resultType = resInfo[rIdx].m_resultType;
cacheEntry->m_resultName = resInfo[rIdx].m_resultName;
cacheEntry->m_timeStepDates = resInfo[rIdx].m_timeStepDates;
cacheEntry->m_daysSinceSimulationStart = resInfo[rIdx].m_daysSinceSimulationStart;
// Take note of the file position for fast lookup later
cacheEntry->m_filePosition = cacheFile.pos();
@@ -1436,7 +1437,7 @@ void RimReservoirCellResultsStorage::setCellResults(RigCaseCellResultsData* cell
RimReservoirCellResultsStorageEntryInfo* resInfo = m_resultCacheMetaData[rIdx];
size_t resultIndex = m_cellResults->addEmptyScalarResult(resInfo->m_resultType(), resInfo->m_resultName(), true);
m_cellResults->setTimeStepDates(resultIndex, resInfo->m_timeStepDates(), std::vector<int>()); // Hack: Using no report step numbers. Not really used except for Flow Diagnostics...
m_cellResults->setTimeStepDates(resultIndex, resInfo->m_timeStepDates(), resInfo->m_daysSinceSimulationStart(), std::vector<int>()); // Hack: Using no report step numbers. Not really used except for Flow Diagnostics...
progress.setProgressDescription(resInfo->m_resultName);
@@ -1556,6 +1557,7 @@ RimReservoirCellResultsStorageEntryInfo::RimReservoirCellResultsStorageEntryInfo
CAF_PDM_InitField(&m_resultType, "ResultType", caf::AppEnum<RimDefines::ResultCatType>(RimDefines::REMOVED), "ResultType", "", "" ,"");
CAF_PDM_InitField(&m_resultName, "ResultName", QString(), "ResultName", "", "" ,"");
CAF_PDM_InitFieldNoDefault(&m_timeStepDates, "TimeSteps", "TimeSteps", "", "" ,"");
CAF_PDM_InitFieldNoDefault(&m_daysSinceSimulationStart, "DaysSinceSimulationStart", "DaysSinceSimulationStart", "", "", "");
CAF_PDM_InitField(&m_filePosition, "FilePositionDataStart", qint64(-1), "FilePositionDataStart", "", "" ,"");
}

1
ApplicationCode/ProjectDataModel/RimReservoirCellResultsStorage.h
View File

@@ -101,6 +101,7 @@ public:
caf::PdmField<caf::AppEnum< RimDefines::ResultCatType> > m_resultType;
caf::PdmField<QString> m_resultName;
caf::PdmField< std::vector <QDateTime> > m_timeStepDates;
caf::PdmField< std::vector <double> > m_daysSinceSimulationStart;
caf::PdmField<qint64> m_filePosition;
};

29
ApplicationCode/ReservoirDataModel/RigCaseCellResultsData.cpp
View File

@@ -420,6 +420,32 @@ std::vector<QDateTime> RigCaseCellResultsData::timeStepDates() const
return timeStepDates(scalarResWithMostTimeSteps);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<double> RigCaseCellResultsData::daysSinceSimulationStart() const
{
size_t scalarResWithMostTimeSteps = cvf::UNDEFINED_SIZE_T;
maxTimeStepCount(&scalarResWithMostTimeSteps);
return daysSinceSimulationStart(scalarResWithMostTimeSteps);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<double> RigCaseCellResultsData::daysSinceSimulationStart(size_t scalarResultIndex) const
{
if (scalarResultIndex < m_resultInfos.size())
{
return m_resultInfos[scalarResultIndex].m_daysSinceSimulationStart;
}
else
{
return std::vector<double>();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -446,11 +472,12 @@ std::vector<int> RigCaseCellResultsData::reportStepNumbers(size_t scalarResultIn
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigCaseCellResultsData::setTimeStepDates(size_t scalarResultIndex, const std::vector<QDateTime>& dates, const std::vector<int>& reportStepNumbers)
void RigCaseCellResultsData::setTimeStepDates(size_t scalarResultIndex, const std::vector<QDateTime>& dates, const std::vector<double>& daysSinceSimulationStart, const std::vector<int>& reportStepNumbers)
{
CVF_ASSERT(scalarResultIndex < m_resultInfos.size() );
m_resultInfos[scalarResultIndex].m_timeStepDates = dates;
m_resultInfos[scalarResultIndex].m_daysSinceSimulationStart = daysSinceSimulationStart;
m_resultInfos[scalarResultIndex].m_timeStepReportNumbers = reportStepNumbers;
std::vector< std::vector<double> >& dataValues = this->cellScalarResults(scalarResultIndex);

5
ApplicationCode/ReservoirDataModel/RigCaseCellResultsData.h
View File

@@ -76,9 +76,11 @@ public:
std::vector<QDateTime> timeStepDates() const;
QDateTime timeStepDate(size_t scalarResultIndex, size_t timeStepIndex) const;
std::vector<QDateTime> timeStepDates(size_t scalarResultIndex) const;
std::vector<double> daysSinceSimulationStart() const;
std::vector<double> daysSinceSimulationStart(size_t scalarResultIndex) const;
int reportStepNumber(size_t scalarResultIndex, size_t timeStepIndex) const;
std::vector<int> reportStepNumbers(size_t scalarResultIndex) const;
void setTimeStepDates(size_t scalarResultIndex, const std::vector<QDateTime>& dates, const std::vector<int>& reportStepNumbers);
void setTimeStepDates(size_t scalarResultIndex, const std::vector<QDateTime>& dates, const std::vector<double>& daysSinceSimulationStart, const std::vector<int>& reportStepNumbers);
// Find or create a slot for the results
@@ -119,6 +121,7 @@ public:
size_t m_gridScalarResultIndex;
std::vector<QDateTime> m_timeStepDates;
std::vector<int> m_timeStepReportNumbers;
std::vector<double> m_daysSinceSimulationStart;
};
const std::vector<ResultInfo>& infoForEachResultIndex() { return m_resultInfos;}