Established new PDM structure with RimProject owning RimOilFields owning RimAnalysisModels.

Moved wellPathCollection into new class RimOilFields.
Moved cases (previously called reservoirs) and caseGroups from RimProject into new class RimAnalysisGroups.
Added support for old project files, move cases and caseGroups from RimProject to RimAnalysisModels. (Do not handle WellPaths for old project files in a similar way, since almost no users have used this functionality yet.)
p4#: 21846
This commit is contained in:
Vidar Lundberg committed 2013-06-06 15:07:31 +02:00
1 parent 691f24e7a7
commit 6340c4a4a8
9 files changed
+382 -382

No files matched your search

+134 -165
View File
@@ -20,9 +20,11 @@
#include "RimProject.h"
#include "cafAppEnum.h"
#include "RimOilField.h"
#include "RimAnalysisModels.h"
#include "RimReservoirView.h"
#include "RimScriptCollection.h"
#include "RimIdenticalGridCaseGroup.h"
@@ -53,6 +55,9 @@ CAF_PDM_SOURCE_INIT(RimProject, "ResInsightProject");
//--------------------------------------------------------------------------------------------------
RimProject::RimProject(void)
{
CAF_PDM_InitFieldNoDefault(&oilFields, "OilFields", "Oil Fields", "", "", "");
oilFields.setUiHidden(true);
CAF_PDM_InitFieldNoDefault(&m_projectFileVersionString, "ProjectFileVersionString", "", "", "", "");
m_projectFileVersionString.setUiHidden(true);
@@ -62,8 +67,12 @@ RimProject::RimProject(void)
CAF_PDM_InitField(&nextValidCaseGroupId, "NextValidCaseGroupId", 0, "Next Valid Case Group ID", "", "" ,"");
nextValidCaseGroupId.setUiHidden(true);
CAF_PDM_InitFieldNoDefault(&reservoirs, "Reservoirs", "", "", "", "");
CAF_PDM_InitFieldNoDefault(&caseGroups, "CaseGroups", "", "", "", "");
CAF_PDM_InitFieldNoDefault(&casesObsolete, "Reservoirs", "", "", "", "");
casesObsolete.setUiHidden(true);
casesObsolete.setIOWritable(false); // read but not write, they will be moved into RimAnalysisGroups
CAF_PDM_InitFieldNoDefault(&caseGroupsObsolete, "CaseGroups", "", "", "", "");
caseGroupsObsolete.setUiHidden(true);
caseGroupsObsolete.setIOWritable(false); // read but not write, they will be moved into RimAnalysisGroups
CAF_PDM_InitFieldNoDefault(&scriptCollection, "ScriptCollection", "Scripts", ":/Default.png", "", "");
CAF_PDM_InitFieldNoDefault(&treeViewState, "TreeViewState", "", "", "", "");
@@ -75,10 +84,6 @@ RimProject::RimProject(void)
scriptCollection = new RimScriptCollection();
scriptCollection->directory.setUiHidden(true);
CAF_PDM_InitFieldNoDefault(&wellPathCollection, "WellPathCollection", "Well Paths", ":/WellCollection.png", "", "");
m_gridCollection = new RigGridManager;
initScriptDirectories();
}
@@ -90,9 +95,7 @@ RimProject::~RimProject(void)
close();
if (scriptCollection()) delete scriptCollection();
if (wellPathCollection()) delete wellPathCollection();
reservoirs.deleteAllChildObjects();
}
//--------------------------------------------------------------------------------------------------
@@ -100,11 +103,17 @@ RimProject::~RimProject(void)
//--------------------------------------------------------------------------------------------------
void RimProject::close()
{
m_gridCollection->clear();
size_t numOilFields = oilFields().size();
for (size_t oilFieldsIdx = 0; oilFieldsIdx < numOilFields; oilFieldsIdx++)
{
RimOilField* oilField = oilFields[oilFieldsIdx];
if (oilField == NULL) continue;
reservoirs.deleteAllChildObjects();
caseGroups.deleteAllChildObjects();
if (wellPathCollection != NULL) delete wellPathCollection;
oilField->close();
}
oilFields.deleteAllChildObjects();
casesObsolete.deleteAllChildObjects();
caseGroupsObsolete.deleteAllChildObjects();
fileName = "";
@@ -157,12 +166,14 @@ void RimProject::initScriptDirectories()
}
// Find largest used groupId read from file and make sure all groups have a valid groupId
RimAnalysisModels* analysisModels = activeOilField() ? activeOilField()->analysisModels() : NULL;
if (analysisModels)
{
int largestGroupId = -1;
for (size_t i = 0; i < caseGroups.size(); i++)
for (size_t i = 0; i < analysisModels->caseGroups().size(); i++)
{
RimIdenticalGridCaseGroup* cg = caseGroups()[i];
RimIdenticalGridCaseGroup* cg = analysisModels->caseGroups()[i];
if (cg->groupId > largestGroupId)
{
@@ -176,9 +187,9 @@ void RimProject::initScriptDirectories()
}
// Assign group Id to groups with an invalid Id
for (size_t i = 0; i < caseGroups.size(); i++)
for (size_t i = 0; i < analysisModels->caseGroups().size(); i++)
{
RimIdenticalGridCaseGroup* cg = caseGroups()[i];
RimIdenticalGridCaseGroup* cg = analysisModels->caseGroups()[i];
if (cg->groupId < 0)
{
@@ -186,7 +197,6 @@ void RimProject::initScriptDirectories()
}
}
}
}
@@ -197,7 +207,62 @@ void RimProject::initAfterRead()
{
initScriptDirectories();
if (wellPathCollection) wellPathCollection->setProject(this);
// Create an empty oil field in case the project did not contain one
if (oilFields.size() < 1)
{
oilFields.push_back(new RimOilField);
}
// Handle old project files with obsolete structure.
// Move caseGroupsObsolete and casesObsolete to oilFields()[idx]->analysisModels()
RimAnalysisModels* analysisModels = activeOilField() ? activeOilField()->analysisModels() : NULL;
bool movedOneRimIdenticalGridCaseGroup = false;
for (size_t cgIdx = 0; cgIdx < caseGroupsObsolete.size(); ++cgIdx)
{
RimIdenticalGridCaseGroup* sourceCaseGroup = caseGroupsObsolete[cgIdx];
if (analysisModels)
{
analysisModels->caseGroups.push_back(sourceCaseGroup);
printf("Moved m_project->caseGroupsObsolete[%i] to first oil fields analysis models\n", cgIdx);
movedOneRimIdenticalGridCaseGroup = true; // moved at least one so assume the others will be moved too...
}
}
if (movedOneRimIdenticalGridCaseGroup)
{
caseGroupsObsolete.clear();
}
bool movedOneRimCase = false;
for (size_t cIdx = 0; cIdx < casesObsolete().size(); ++cIdx)
{
RimCase* sourceCase = casesObsolete[cIdx];
if (analysisModels)
{
analysisModels->cases.push_back(sourceCase);
printf("Moved m_project->casesObsolete[%i] to first oil fields analysis models\n", cIdx);
movedOneRimCase = true; // moved at least one so assume the others will be moved too...
}
}
if (movedOneRimCase)
{
casesObsolete.clear();
}
if (casesObsolete().size() > 0 || caseGroupsObsolete.size() > 0)
{
printf("RimProject::initAfterRead: Was not able to move all cases (%i left) or caseGroups (%i left) from Project to analysisModels",
casesObsolete().size(), caseGroupsObsolete.size());
}
// Set project pointer to each well path
for (size_t oilFieldIdx = 0; oilFieldIdx < oilFields().size(); oilFieldIdx++)
{
RimOilField* oilField = oilFields[oilFieldIdx];
if (oilField == NULL || oilField->wellPathCollection == NULL) continue;
oilField->wellPathCollection->setProject(this);
}
}
@@ -243,135 +308,6 @@ QString RimProject::projectFileVersionString() const
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimIdenticalGridCaseGroup* RimProject::createIdenticalCaseGroupFromMainCase(RimCase* mainCase)
{
CVF_ASSERT(mainCase);
RigCaseData* rigEclipseCase = mainCase->reservoirData();
RigMainGrid* equalGrid = registerCaseInGridCollection(rigEclipseCase);
CVF_ASSERT(equalGrid);
RimIdenticalGridCaseGroup* group = new RimIdenticalGridCaseGroup;
assignIdToCaseGroup(group);
RimCase* createdCase = group->createAndAppendStatisticsCase();
assignCaseIdToCase(createdCase);
group->addCase(mainCase);
caseGroups().push_back(group);
return group;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimProject::moveEclipseCaseIntoCaseGroup(RimCase* rimReservoir)
{
CVF_ASSERT(rimReservoir);
RigCaseData* rigEclipseCase = rimReservoir->reservoirData();
RigMainGrid* equalGrid = registerCaseInGridCollection(rigEclipseCase);
CVF_ASSERT(equalGrid);
// Insert in identical grid group
bool foundGroup = false;
for (size_t i = 0; i < caseGroups.size(); i++)
{
RimIdenticalGridCaseGroup* cg = caseGroups()[i];
if (cg->mainGrid() == equalGrid)
{
cg->addCase(rimReservoir);
foundGroup = true;
}
}
if (!foundGroup)
{
RimIdenticalGridCaseGroup* group = new RimIdenticalGridCaseGroup;
assignIdToCaseGroup(group);
group->addCase(rimReservoir);
caseGroups().push_back(group);
}
// Remove reservoir from main container
reservoirs().removeChildObject(rimReservoir);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimProject::removeCaseFromAllGroups(RimCase* reservoir)
{
m_gridCollection->removeCase(reservoir->reservoirData());
for (size_t i = 0; i < caseGroups.size(); i++)
{
RimIdenticalGridCaseGroup* cg = caseGroups()[i];
cg->removeCase(reservoir);
}
reservoirs().removeChildObject(reservoir);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigMainGrid* RimProject::registerCaseInGridCollection(RigCaseData* rigEclipseCase)
{
CVF_ASSERT(rigEclipseCase);
RigMainGrid* equalGrid = m_gridCollection->findEqualGrid(rigEclipseCase->mainGrid());
if (equalGrid)
{
// Replace the grid with an already registered grid
rigEclipseCase->setMainGrid(equalGrid);
}
else
{
// This is the first insertion of this grid, compute cached data
rigEclipseCase->mainGrid()->computeCachedData();
std::vector<RigGridBase*> grids;
rigEclipseCase->allGrids(&grids);
size_t i;
for (i = 0; i < grids.size(); i++)
{
grids[i]->computeFaults();
}
equalGrid = rigEclipseCase->mainGrid();
}
m_gridCollection->addCase(rigEclipseCase);
return equalGrid;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimProject::insertCaseInCaseGroup(RimIdenticalGridCaseGroup* caseGroup, RimCase* rimReservoir)
{
CVF_ASSERT(rimReservoir);
RigCaseData* rigEclipseCase = rimReservoir->reservoirData();
registerCaseInGridCollection(rigEclipseCase);
caseGroup->addCase(rimReservoir);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -388,7 +324,7 @@ void RimProject::setProjectFileNameAndUpdateDependencies(const QString& fileName
QFileInfo fileInfoOld(oldProjectFileName);
QString oldProjectPath = fileInfoOld.path();
// Loop over all reservoirs and update file path
// Loop over all cases and update file path
std::vector<RimCase*> cases;
allCases(cases);
@@ -429,23 +365,31 @@ void RimProject::assignIdToCaseGroup(RimIdenticalGridCaseGroup* caseGroup)
//--------------------------------------------------------------------------------------------------
void RimProject::allCases(std::vector<RimCase*>& cases)
{
for (size_t i = 0; i < reservoirs.size(); i++)
for (size_t oilFieldIdx = 0; oilFieldIdx < oilFields().size(); oilFieldIdx++)
{
cases.push_back(reservoirs[i]);
}
RimOilField* oilField = oilFields[oilFieldIdx];
RimAnalysisModels* analysisModels = oilField ? oilField->analysisModels() : NULL;
if (analysisModels == NULL) continue;
for (size_t i = 0; i < caseGroups.size(); i++)
{
RimIdenticalGridCaseGroup* cg = caseGroups()[i];
for (size_t i = 0; i < cg->statisticsCaseCollection()->reservoirs.size(); i++)
for (size_t caseIdx = 0; caseIdx < analysisModels->cases.size(); caseIdx++)
{
cases.push_back(cg->statisticsCaseCollection()->reservoirs[i]);
cases.push_back(analysisModels->cases[caseIdx]);
}
for (size_t i = 0; i < cg->caseCollection()->reservoirs.size(); i++)
for (size_t cgIdx = 0; cgIdx < analysisModels->caseGroups.size(); cgIdx++)
{
cases.push_back(cg->caseCollection()->reservoirs[i]);
// Load the Main case of each IdenticalGridCaseGroup
RimIdenticalGridCaseGroup* cg = analysisModels->caseGroups[cgIdx];
if (cg == NULL) continue;
for (size_t caseIdx = 0; caseIdx < cg->statisticsCaseCollection()->reservoirs.size(); caseIdx++)
{
cases.push_back(cg->statisticsCaseCollection()->reservoirs[caseIdx]);
}
for (size_t caseIdx = 0; caseIdx < cg->caseCollection()->reservoirs.size(); caseIdx++)
{
cases.push_back(cg->caseCollection()->reservoirs[caseIdx]);
}
}
}
}
@@ -456,9 +400,13 @@ void RimProject::allCases(std::vector<RimCase*>& cases)
//--------------------------------------------------------------------------------------------------
void RimProject::createDisplayModelAndRedrawAllViews()
{
for (size_t caseIdx = 0; caseIdx < reservoirs.size(); caseIdx++)
std::vector<RimCase*> cases;
allCases(cases);
for (size_t caseIdx = 0; caseIdx < cases.size(); caseIdx++)
{
RimCase* rimCase = reservoirs[caseIdx];
RimCase* rimCase = cases[caseIdx];
if (rimCase == NULL) continue;
for (size_t viewIdx = 0; viewIdx < rimCase->reservoirViews.size(); viewIdx++)
{
RimReservoirView* reservoirView = rimCase->reservoirViews[viewIdx];
@@ -467,6 +415,27 @@ void RimProject::createDisplayModelAndRedrawAllViews()
}
}
//--------------------------------------------------------------------------------------------------
/// Currently there will be only one oil field in Resinsight, so return hardcoded first oil field
/// from the RimOilField collection.
//--------------------------------------------------------------------------------------------------
RimOilField* RimProject::activeOilField()
{
if (oilFields.size() > 1)
{
printf("ERROR: RimProject::activeOilField returns hardcoded first oil field, while oilFields actually contain more than one oil field! Must handle several oil fields in this method!\n");
}
if (oilFields.size() > 0)
{
return oilFields[0];
}
else
{
return NULL;
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------