From f392f4457de205abbbc985d69bb87960dd91be99 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jacob=20St=C3=B8ren?= Date: Mon, 26 Aug 2013 14:03:01 +0200 Subject: [PATCH] MswRollUp: Splitted normal well and MSW handling. Got the Normal path to work fairly well. Some strangeties at the end of the pipes though This is an intermediate commit and does not compile p4#: 22214 --- .../FileInterface/RifReaderEclipseOutput.cpp | 628 ++++++++++-------- .../FileInterface/RifReaderEclipseOutput.h | 7 +- .../RivWellPipesPartMgr.cpp | 77 ++- .../ModelVisualization/RivWellPipesPartMgr.h | 4 +- .../ProjectDataModel/RimReservoirView.cpp | 10 +- ApplicationCode/ProjectDataModel/RimWell.cpp | 4 +- .../ProjectDataModel/RimWellCollection.cpp | 30 +- .../ReservoirDataModel/RigCaseData.cpp | 10 +- .../ReservoirDataModel/RigCaseData.h | 4 +- .../RigReservoirBuilderMock.cpp | 22 +- .../RigSingleWellResultsData.cpp | 28 +- .../RigSingleWellResultsData.h | 53 +- 12 files changed, 485 insertions(+), 392 deletions(-) diff --git a/ApplicationCode/FileInterface/RifReaderEclipseOutput.cpp b/ApplicationCode/FileInterface/RifReaderEclipseOutput.cpp index 2c660a74bc..bde773deb4 100644 --- a/ApplicationCode/FileInterface/RifReaderEclipseOutput.cpp +++ b/ApplicationCode/FileInterface/RifReaderEclipseOutput.cpp @@ -725,6 +725,54 @@ struct SegmentData const well_conn_collection_type* m_connections; }; +struct SegmentTreeNode +{ + SegmentTreeNode() : outletSegment(NULL), mainChildSegment(NULL) {} + std::vector connections; + + SegmentTreeNode* outletSegment; + SegmentTreeNode* mainChildSegment; + std::vector additionalChildSegments; +}; + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +RigWellResultPoint RifReaderEclipseOutput::createWellResultPoint(const RigGridBase* grid, const well_conn_type* ert_connection, int ertBranchId, int ertSegmentId) +{ + CVF_ASSERT(ert_connection); + CVF_ASSERT(grid); + + RigWellResultPoint resultPoint; + int cellI = well_conn_get_i( ert_connection ); + int cellJ = well_conn_get_j( ert_connection ); + int cellK = well_conn_get_k( ert_connection ); + bool isCellOpen = well_conn_open( ert_connection ); + + // If a well is defined in fracture region, the K-value is from (cellCountK - 1) -> cellCountK*2 - 1 + // Adjust K so index is always in valid grid region + if (cellK >= static_cast(grid->cellCountK())) + { + cellK -= static_cast(grid->cellCountK()); + } + + // The K value might also be -1. It is not yet known why, or what it is supposed to mean, + // but for now we will interpret as 0. + // TODO: Ask Joakim Haave regarding this. + if (cellK < 0) cellK = 0; + + resultPoint.m_gridIndex = grid->gridIndex(); + resultPoint.m_gridCellIndex = grid->cellIndexFromIJK(cellI, cellJ, cellK); + + resultPoint.m_isOpen = isCellOpen; + + resultPoint.m_ertBranchId = ertBranchId; + resultPoint.m_ertSegmentId = ertSegmentId; + + return resultPoint; +} + + void getSegmentDataByBranchId(const std::list& segments, std::vector& branchSegments, int branchId) { std::list::const_iterator it; @@ -814,317 +862,365 @@ void RifReaderEclipseOutput::readWellCells(const ecl_grid_type* mainEclGrid) wellResFrame.m_isOpen = well_state_is_open( ert_well_state ); + if (well_state_is_MSW(ert_well_state)) + { + // Loop over all the grids in the model. If we have connections in one, we will discard + // the main grid connections as the well connections are duplicated in the main grid and LGR grids - // Loop over all the grids in the model. If we have connections in one, we will discard - // the main grid connections as the well connections are duplicated in the main grid and LGR grids + bool hasWellConnectionsInLGR = false; - bool hasWellConnectionsInLGR = false; #if 0 - // To be discussed with Statoil - for (size_t gridNr = 1; gridNr < grids.size(); ++gridNr) - { - RigGridBase* lgrGrid = m_eclipseCase->grid(gridNr); - if (well_state_has_grid_connections(ert_well_state, lgrGrid->gridName().data())) + // To be discussed with Statoil + for (size_t gridNr = 1; gridNr < grids.size(); ++gridNr) { - hasWellConnectionsInLGR = true; - break; + RigGridBase* lgrGrid = m_eclipseCase->grid(gridNr); + if (well_state_has_grid_connections(ert_well_state, lgrGrid->gridName().data())) + { + hasWellConnectionsInLGR = true; + break; + } } - } #endif - size_t gridNr = hasWellConnectionsInLGR ? 1 : 0; - for (; gridNr < grids.size(); ++gridNr) - { - - // Wellhead. If several grids have a wellhead definition for this well, we use the last one. (Possibly the innermost LGR) - const well_conn_type* ert_wellhead = well_state_iget_wellhead(ert_well_state, static_cast(gridNr)); - if (ert_wellhead) + size_t gridNr = hasWellConnectionsInLGR ? 1 : 0; + for (; gridNr < grids.size(); ++gridNr) { - int cellI = well_conn_get_i( ert_wellhead ); - int cellJ = well_conn_get_j( ert_wellhead ); - int cellK = CVF_MAX(0, well_conn_get_k(ert_wellhead)); // Why this ? - // If a well is defined in fracture region, the K-value is from (cellCountK - 1) -> cellCountK*2 - 1 - // Adjust K so index is always in valid grid region - if (cellK >= static_cast(grids[gridNr]->cellCountK())) + // Wellhead. If several grids have a wellhead definition for this well, we use the last one. (Possibly the innermost LGR) + const well_conn_type* ert_wellhead = well_state_iget_wellhead(ert_well_state, static_cast(gridNr)); + if (ert_wellhead) { - cellK -= static_cast(grids[gridNr]->cellCountK()); + wellResFrame.m_wellHead = createWellResultPoint(grids[gridNr], ert_wellhead, -1, -1 ); } - - wellResFrame.m_wellHead.m_gridCellIndex = grids[gridNr]->cellIndexFromIJK(cellI, cellJ, cellK); - wellResFrame.m_wellHead.m_gridIndex = gridNr; - } - else - { - CVF_ASSERT(0); - } - - - std::string gridName; - if (gridNr == 0) - { - gridName = ECL_GRID_GLOBAL_GRID; - } - else - { - RigGridBase* rigGrid = m_eclipseCase->grid(gridNr); - gridName = rigGrid->gridName(); - } - - - - std::list segmentList; - std::vector outletBranchSegmentList; // Keep a list of branch outlet segments to avoid traversal twice - std::vector ertBranchIDs; - - int branchCount = 0; - if (well_state_is_MSW(ert_well_state)) - { - wellResults->setMultiSegmentWell(true); - - well_branch_collection_type* branches = well_state_get_branches(ert_well_state); - - branchCount = well_branch_collection_get_size(branches); - for (int branchIdx = 0; branchIdx < well_branch_collection_get_size(branches); branchIdx++) + else { - const well_segment_type* segment = well_branch_collection_iget_start_segment(branches, branchIdx); - int branchId = well_segment_get_branch_id(segment); - - ertBranchIDs.push_back(branchId); - - while (segment && branchId == well_segment_get_branch_id(segment)) - { - SegmentData segmentData(NULL); - segmentData.m_branchId = branchId; - segmentData.m_segmentId = well_segment_get_id(segment); - segmentData.m_gridIndex = gridNr; - - if (well_segment_has_grid_connections(segment, gridName.data())) - { - const well_conn_collection_type* connections = well_segment_get_connections(segment, gridName.data()); - segmentData.m_connections = connections; - } - - // Insert in front, as the segments are accessed starting from grid cell closes to well head - segmentList.push_front(segmentData); - - if (well_segment_get_outlet_id(segment) == -1) - { - break; - } - - segment = well_segment_get_outlet(segment); - } - - outletBranchSegmentList.push_back(segment); + // CVF_ASSERT(0); // This is just a test assert to see if this condition exists in some file. + // All the grids does not necessarily have a well head definition. (I think, JJS) } - } - else - { - branchCount = 1; - ertBranchIDs.push_back(0); - - const well_conn_collection_type* connections = well_state_get_grid_connections(ert_well_state, gridName.data()); - SegmentData segmentData(connections); - segmentData.m_gridIndex = gridNr; - segmentList.push_front(segmentData); - } - - size_t currentGridBranchStartIndex = wellResFrame.m_wellResultBranches.size(); - wellResFrame.m_wellResultBranches.resize(currentGridBranchStartIndex + branchCount); - // Import all well result cells for all connections - for (int branchIdx = 0; branchIdx < branchCount; branchIdx++) - { - RigWellResultBranch& wellResultBranch = wellResFrame.m_wellResultBranches[currentGridBranchStartIndex + branchIdx]; - wellResultBranch.m_branchIndex = branchIdx; - - int ertBranchId = ertBranchIDs[branchIdx]; - wellResultBranch.m_ertBranchId = ertBranchId; - - std::vector branchSegments; - getSegmentDataByBranchId(segmentList, branchSegments, ertBranchId); - - for (size_t segmentIdx = 0; segmentIdx < branchSegments.size(); segmentIdx++) + std::string gridName; + if (gridNr == 0) { - SegmentData& connData = branchSegments[segmentIdx]; + gridName = ECL_GRID_GLOBAL_GRID; + } + else + { + RigGridBase* rigGrid = m_eclipseCase->grid(gridNr); + gridName = rigGrid->gridName(); + } - if (!connData.m_connections) + + + std::list segmentList; + std::vector outletBranchSegmentList; // Keep a list of branch outlet segments to avoid traversal twice + std::vector ertBranchIDs; + + int branchCount = 0; + if (well_state_is_MSW(ert_well_state)) + { + wellResults->setMultiSegmentWell(true); + + well_branch_collection_type* branches = well_state_get_branches(ert_well_state); + + branchCount = well_branch_collection_get_size(branches); + for (int branchIdx = 0; branchIdx < well_branch_collection_get_size(branches); branchIdx++) { - size_t existingCellCount = wellResultBranch.m_wellCells.size(); - wellResultBranch.m_wellCells.resize(existingCellCount + 1); - - RigWellResultCell& data = wellResultBranch.m_wellCells[existingCellCount]; + const well_segment_type* segment = well_branch_collection_iget_start_segment(branches, branchIdx); + int branchId = well_segment_get_branch_id(segment); - data.m_ertBranchId = connData.m_branchId; - data.m_ertSegmentId = connData.m_segmentId; - } - else - { - int connectionCount = well_conn_collection_get_size(connData.m_connections); + ertBranchIDs.push_back(branchId); - size_t existingCellCount = wellResultBranch.m_wellCells.size(); - wellResultBranch.m_wellCells.resize(existingCellCount + connectionCount); - - for (int connIdx = 0; connIdx < connectionCount; connIdx++) + while (segment && branchId == well_segment_get_branch_id(segment)) { - well_conn_type* ert_connection = well_conn_collection_iget(connData.m_connections, connIdx); - CVF_ASSERT(ert_connection); + SegmentData segmentData(NULL); + segmentData.m_branchId = branchId; + segmentData.m_segmentId = well_segment_get_id(segment); + segmentData.m_gridIndex = gridNr; - RigWellResultCell& data = wellResultBranch.m_wellCells[existingCellCount + connIdx]; - int cellI = well_conn_get_i( ert_connection ); - int cellJ = well_conn_get_j( ert_connection ); - int cellK = well_conn_get_k( ert_connection ); - bool isCellOpen = well_conn_open( ert_connection ); - - // If a well is defined in fracture region, the K-value is from (cellCountK - 1) -> cellCountK*2 - 1 - // Adjust K so index is always in valid grid region - if (cellK >= static_cast(grids[gridNr]->cellCountK())) + if (well_segment_has_grid_connections(segment, gridName.data())) { - cellK -= static_cast(grids[gridNr]->cellCountK()); + const well_conn_collection_type* connections = well_segment_get_connections(segment, gridName.data()); + segmentData.m_connections = connections; } - data.m_gridIndex = gridNr; - data.m_gridCellIndex = grids[gridNr]->cellIndexFromIJK(cellI, cellJ, cellK); + // Insert in front, as the segments are accessed starting from grid cell closes to well head + segmentList.push_front(segmentData); - data.m_isOpen = isCellOpen; + if (well_segment_get_outlet_id(segment) == -1) + { + break; + } + + segment = well_segment_get_outlet(segment); + } + + outletBranchSegmentList.push_back(segment); + } + + } + else + { + branchCount = 1; + ertBranchIDs.push_back(0); + + const well_conn_collection_type* connections = well_state_get_grid_connections(ert_well_state, gridName.data()); + SegmentData segmentData(connections); + segmentData.m_gridIndex = gridNr; + segmentList.push_front(segmentData); + } + + size_t currentGridBranchStartIndex = wellResFrame.m_wellResultBranches.size(); + wellResFrame.m_wellResultBranches.resize(currentGridBranchStartIndex + branchCount); + + + // Import all well result cells for all connections + for (int branchIdx = 0; branchIdx < branchCount; branchIdx++) + { + RigWellResultBranch& wellResultBranch = wellResFrame.m_wellResultBranches[currentGridBranchStartIndex + branchIdx]; + wellResultBranch.m_branchIndex = branchIdx; + + int ertBranchId = ertBranchIDs[branchIdx]; + wellResultBranch.m_ertBranchId = ertBranchId; + + std::vector branchSegments; + getSegmentDataByBranchId(segmentList, branchSegments, ertBranchId); + + for (size_t segmentIdx = 0; segmentIdx < branchSegments.size(); segmentIdx++) + { + SegmentData& connData = branchSegments[segmentIdx]; + + if (!connData.m_connections) + { + size_t existingCellCount = wellResultBranch.m_branchResultPoints.size(); + wellResultBranch.m_branchResultPoints.resize(existingCellCount + 1); + + RigWellResultPoint& data = wellResultBranch.m_branchResultPoints[existingCellCount]; data.m_ertBranchId = connData.m_branchId; data.m_ertSegmentId = connData.m_segmentId; } + else + { + int connectionCount = well_conn_collection_get_size(connData.m_connections); + + size_t existingCellCount = wellResultBranch.m_branchResultPoints.size(); + wellResultBranch.m_branchResultPoints.resize(existingCellCount + connectionCount); + + for (int connIdx = 0; connIdx < connectionCount; connIdx++) + { + well_conn_type* ert_connection = well_conn_collection_iget(connData.m_connections, connIdx); + wellResultBranch.m_branchResultPoints[existingCellCount + connIdx] = + createWellResultPoint(grids[gridNr], ert_connection, connData.m_branchId, connData.m_segmentId); + } + } + } + } + + + if (well_state_is_MSW(ert_well_state)) + { + + // Assign outlet well cells to leaf branch well heads + + for (int branchIdx = 0; branchIdx < branchCount; branchIdx++) + { + RigWellResultBranch& wellResultLeafBranch = wellResFrame.m_wellResultBranches[currentGridBranchStartIndex + branchIdx]; + + const well_segment_type* outletBranchSegment = outletBranchSegmentList[branchIdx]; + CVF_ASSERT(outletBranchSegment); + + int outletErtBranchId = well_segment_get_branch_id(outletBranchSegment); + + size_t outletErtBranchIndex = cvf::UNDEFINED_SIZE_T; + for (size_t i = 0; i < ertBranchIDs.size(); i++) + { + if (ertBranchIDs[i] == outletErtBranchId) + { + outletErtBranchIndex = i; + } + } + + RigWellResultBranch& outletResultBranch = wellResFrame.m_wellResultBranches[currentGridBranchStartIndex + outletErtBranchIndex]; + + int outletErtSegmentId = well_segment_get_branch_id(outletBranchSegment); + size_t lastCellIndexForSegmentIdInOutletBranch = cvf::UNDEFINED_SIZE_T; + for (size_t outletCellIdx = 0; outletCellIdx < outletResultBranch.m_branchResultPoints.size(); outletCellIdx++) + { + if (outletResultBranch.m_branchResultPoints[outletCellIdx].m_ertSegmentId == outletErtSegmentId) + { + lastCellIndexForSegmentIdInOutletBranch = outletCellIdx; + } + } + + if (lastCellIndexForSegmentIdInOutletBranch == cvf::UNDEFINED_SIZE_T) + { + // Did not find the cell in the outlet branch based on branch id and segment id from outlet cell in leaf branch + CVF_ASSERT(0); + } + else + { + RigWellResultPoint& outletCell = outletResultBranch.m_branchResultPoints[lastCellIndexForSegmentIdInOutletBranch]; + + wellResultLeafBranch.m_outletBranchIndex_OBSOLETE = currentGridBranchStartIndex + outletErtBranchIndex; + wellResultLeafBranch.m_outletBranchHeadCellIndex_OBSOLETE = lastCellIndexForSegmentIdInOutletBranch; + } + } + + + // Update outlet well cells with no grid cell connections + + for (int branchIdx = 0; branchIdx < branchCount; branchIdx++) + { + RigWellResultBranch& wellResultLeafBranch = wellResFrame.m_wellResultBranches[currentGridBranchStartIndex + branchIdx]; + + const RigWellResultPoint* leafBranchHead = wellResFrame.findResultCellFromOutletSpecification(wellResultLeafBranch.m_outletBranchIndex_OBSOLETE, wellResultLeafBranch.m_outletBranchHeadCellIndex_OBSOLETE); + if (!leafBranchHead || leafBranchHead->isCell()) + { + continue; + } + + RigWellResultBranch& outletResultBranch = wellResFrame.m_wellResultBranches[wellResultLeafBranch.m_outletBranchIndex_OBSOLETE]; + + size_t firstCellIndexWithGridConnectionInLeafBranch = cvf::UNDEFINED_SIZE_T; + for (size_t j = 0; j < wellResultLeafBranch.m_branchResultPoints.size(); j++) + { + if (wellResultLeafBranch.m_branchResultPoints[j].isCell()) + { + firstCellIndexWithGridConnectionInLeafBranch = j; + break; + } + } + + if (firstCellIndexWithGridConnectionInLeafBranch != cvf::UNDEFINED_SIZE_T) + { + const RigCell& firstCellWithGridConnectionInLeafBranch = m_eclipseCase->cellFromWellResultCell(wellResultLeafBranch.m_branchResultPoints[firstCellIndexWithGridConnectionInLeafBranch]); + cvf::Vec3d firstGridConnectionCenterInLeafBranch = firstCellWithGridConnectionInLeafBranch.center(); + + size_t cellIndexInOutletBranch = wellResultLeafBranch.m_outletBranchHeadCellIndex_OBSOLETE; + CVF_ASSERT(cellIndexInOutletBranch != cvf::UNDEFINED_SIZE_T); + + RigWellResultPoint& currCell = outletResultBranch.m_branchResultPoints[cellIndexInOutletBranch]; + + while (cellIndexInOutletBranch != cvf::UNDEFINED_SIZE_T && !currCell.isCell()) + { + size_t branchConnectionCount = currCell.m_branchConnectionCount; + if (branchConnectionCount == 0) + { + currCell.m_bottomPosition = firstGridConnectionCenterInLeafBranch; + } + else + { + cvf::Vec3d currentWeightedCoord = currCell.m_bottomPosition * branchConnectionCount / static_cast(branchConnectionCount + 1); + cvf::Vec3d additionalWeightedCoord = firstGridConnectionCenterInLeafBranch / static_cast(branchConnectionCount + 1); + + currCell.m_bottomPosition = currentWeightedCoord + additionalWeightedCoord; + } + + currCell.m_branchConnectionCount++; + + if (cellIndexInOutletBranch == 0) + { + cellIndexInOutletBranch = cvf::UNDEFINED_SIZE_T; + + // Find the branch the outlet is connected to, and continue update of + // segments until a segment with a grid connection is found + const RigWellResultPoint* leafBranchHead = wellResFrame.findResultCellFromOutletSpecification(outletResultBranch.m_outletBranchIndex_OBSOLETE, outletResultBranch.m_outletBranchHeadCellIndex_OBSOLETE); + + if (leafBranchHead && + !leafBranchHead->isCell() && + leafBranchHead->m_ertBranchId != outletResultBranch.m_ertBranchId) + { + outletResultBranch = wellResFrame.m_wellResultBranches[outletResultBranch.m_outletBranchIndex_OBSOLETE]; + cellIndexInOutletBranch = outletResultBranch.m_outletBranchHeadCellIndex_OBSOLETE; + } + } + else + { + cellIndexInOutletBranch--; + } + + if(cellIndexInOutletBranch >= 0 && cellIndexInOutletBranch < outletResultBranch.m_branchResultPoints.size()) + { + currCell = outletResultBranch.m_branchResultPoints[cellIndexInOutletBranch]; + } + } + } } } } + } + else + { + // Loop over all the grids in the model. If we have connections in one, we will discard + // the main grid connections as the well connections are duplicated in the main grid and LGR grids - - if (well_state_is_MSW(ert_well_state)) + bool hasWellConnectionsInLGR = false; +#if 0 + // To be discussed with Statoil + for (size_t gridIdx = 1; gridIdx < grids.size(); ++gridIdx) { - - // Assign outlet well cells to leaf branch well heads - - for (int branchIdx = 0; branchIdx < branchCount; branchIdx++) + RigGridBase* lgrGrid = m_eclipseCase->grid(gridIdx); + if (well_state_has_grid_connections(ert_well_state, lgrGrid->gridName().data())) { - RigWellResultBranch& wellResultLeafBranch = wellResFrame.m_wellResultBranches[currentGridBranchStartIndex + branchIdx]; + hasWellConnectionsInLGR = true; + break; + } + } +#endif + size_t gridNr = hasWellConnectionsInLGR ? 1 : 0; + for (; gridNr < grids.size(); ++gridNr) + { - const well_segment_type* outletBranchSegment = outletBranchSegmentList[branchIdx]; - CVF_ASSERT(outletBranchSegment); - - int outletErtBranchId = well_segment_get_branch_id(outletBranchSegment); - - size_t outletErtBranchIndex = cvf::UNDEFINED_SIZE_T; - for (size_t i = 0; i < ertBranchIDs.size(); i++) - { - if (ertBranchIDs[i] == outletErtBranchId) - { - outletErtBranchIndex = i; - } - } - - RigWellResultBranch& outletResultBranch = wellResFrame.m_wellResultBranches[currentGridBranchStartIndex + outletErtBranchIndex]; - - int outletErtSegmentId = well_segment_get_branch_id(outletBranchSegment); - size_t lastCellIndexForSegmentIdInOutletBranch = cvf::UNDEFINED_SIZE_T; - for (size_t outletCellIdx = 0; outletCellIdx < outletResultBranch.m_wellCells.size(); outletCellIdx++) - { - if (outletResultBranch.m_wellCells[outletCellIdx].m_ertSegmentId == outletErtSegmentId) - { - lastCellIndexForSegmentIdInOutletBranch = outletCellIdx; - } - } - - if (lastCellIndexForSegmentIdInOutletBranch == cvf::UNDEFINED_SIZE_T) - { - // Did not find the cell in the outlet branch based on branch id and segment id from outlet cell in leaf branch - CVF_ASSERT(0); - } - else - { - RigWellResultCell& outletCell = outletResultBranch.m_wellCells[lastCellIndexForSegmentIdInOutletBranch]; - - wellResultLeafBranch.m_outletBranchIndex = currentGridBranchStartIndex + outletErtBranchIndex; - wellResultLeafBranch.m_outletBranchHeadCellIndex = lastCellIndexForSegmentIdInOutletBranch; - } + // Wellhead. If several grids have a wellhead definition for this well, we use the last one. (Possibly the innermost LGR) + const well_conn_type* ert_wellhead = well_state_iget_wellhead(ert_well_state, static_cast(gridNr)); + if (ert_wellhead) + { + wellResFrame.m_wellHead = createWellResultPoint(grids[gridNr], ert_wellhead, -1, -1 ); + std::cout << "Wellhead YES at timeIdx: " << timeIdx << " wellIdx: " << wellIdx << " Grid: " << gridNr << std::endl; + } + else + { + std::cout << "Wellhead NO at timeIdx: " << timeIdx << " wellIdx: " << wellIdx << " Grid: " << gridNr << std::endl; + //CVF_ASSERT(0); // This is just a test assert to see if this condition exists in some file. + // All the grids does not necessarily have a well head definition. (I think, JJS) } - // Update outlet well cells with no grid cell connections - - for (int branchIdx = 0; branchIdx < branchCount; branchIdx++) + std::string gridName; + if (gridNr == 0) { - RigWellResultBranch& wellResultLeafBranch = wellResFrame.m_wellResultBranches[currentGridBranchStartIndex + branchIdx]; - - const RigWellResultCell* leafBranchHead = wellResFrame.findResultCellFromOutletSpecification(wellResultLeafBranch.m_outletBranchIndex, wellResultLeafBranch.m_outletBranchHeadCellIndex); - if (!leafBranchHead || leafBranchHead->hasGridConnections()) - { - continue; - } - - RigWellResultBranch& outletResultBranch = wellResFrame.m_wellResultBranches[wellResultLeafBranch.m_outletBranchIndex]; + gridName = ECL_GRID_GLOBAL_GRID; + } + else + { + RigGridBase* rigGrid = m_eclipseCase->grid(gridNr); + gridName = rigGrid->gridName(); + } - size_t firstCellIndexWithGridConnectionInLeafBranch = cvf::UNDEFINED_SIZE_T; - for (size_t j = 0; j < wellResultLeafBranch.m_wellCells.size(); j++) + const well_conn_collection_type* connections = well_state_get_grid_connections(ert_well_state, gridName.data()); + + // Import all well result cells for all connections + if (connections) + { + int connectionCount = well_conn_collection_get_size(connections); + if (connectionCount) { - if (wellResultLeafBranch.m_wellCells[j].hasGridConnections()) + wellResFrame.m_wellResultBranches.push_back(RigWellResultBranch()); + RigWellResultBranch& wellResultBranch = wellResFrame.m_wellResultBranches.back(); + + wellResultBranch.m_branchIndex = 0; + wellResultBranch.m_ertBranchId = -1; + + size_t existingCellCount = wellResultBranch.m_branchResultPoints.size(); + wellResultBranch.m_branchResultPoints.resize(existingCellCount + connectionCount); + + for (int connIdx = 0; connIdx < connectionCount; connIdx++) { - firstCellIndexWithGridConnectionInLeafBranch = j; - break; - } - } - - if (firstCellIndexWithGridConnectionInLeafBranch != cvf::UNDEFINED_SIZE_T) - { - const RigCell& firstCellWithGridConnectionInLeafBranch = m_eclipseCase->cellFromWellResultCell(wellResultLeafBranch.m_wellCells[firstCellIndexWithGridConnectionInLeafBranch]); - cvf::Vec3d firstGridConnectionCenterInLeafBranch = firstCellWithGridConnectionInLeafBranch.center(); - - size_t cellIndexInOutletBranch = wellResultLeafBranch.m_outletBranchHeadCellIndex; - CVF_ASSERT(cellIndexInOutletBranch != cvf::UNDEFINED_SIZE_T); - - RigWellResultCell& currCell = outletResultBranch.m_wellCells[cellIndexInOutletBranch]; - - while (cellIndexInOutletBranch != cvf::UNDEFINED_SIZE_T && !currCell.hasGridConnections()) - { - size_t branchConnectionCount = currCell.m_branchConnectionCount; - if (branchConnectionCount == 0) - { - currCell.m_averageCenter = firstGridConnectionCenterInLeafBranch; - } - else - { - cvf::Vec3d currentWeightedCoord = currCell.m_averageCenter * branchConnectionCount / static_cast(branchConnectionCount + 1); - cvf::Vec3d additionalWeightedCoord = firstGridConnectionCenterInLeafBranch / static_cast(branchConnectionCount + 1); - - currCell.m_averageCenter = currentWeightedCoord + additionalWeightedCoord; - } - - currCell.m_branchConnectionCount++; - - if (cellIndexInOutletBranch == 0) - { - cellIndexInOutletBranch = cvf::UNDEFINED_SIZE_T; - - // Find the branch the outlet is connected to, and continue update of - // segments until a segment with a grid connection is found - const RigWellResultCell* leafBranchHead = wellResFrame.findResultCellFromOutletSpecification(outletResultBranch.m_outletBranchIndex, outletResultBranch.m_outletBranchHeadCellIndex); - - if (leafBranchHead && - !leafBranchHead->hasGridConnections() && - leafBranchHead->m_ertBranchId != outletResultBranch.m_ertBranchId) - { - outletResultBranch = wellResFrame.m_wellResultBranches[outletResultBranch.m_outletBranchIndex]; - cellIndexInOutletBranch = outletResultBranch.m_outletBranchHeadCellIndex; - } - } - else - { - cellIndexInOutletBranch--; - } - - if(cellIndexInOutletBranch >= 0 && cellIndexInOutletBranch < outletResultBranch.m_wellCells.size()) - { - currCell = outletResultBranch.m_wellCells[cellIndexInOutletBranch]; - } + well_conn_type* ert_connection = well_conn_collection_iget(connections, connIdx); + wellResultBranch.m_branchResultPoints[existingCellCount + connIdx] = + createWellResultPoint(grids[gridNr], ert_connection, -1, -1); } } } diff --git a/ApplicationCode/FileInterface/RifReaderEclipseOutput.h b/ApplicationCode/FileInterface/RifReaderEclipseOutput.h index fe33a025ae..316353f727 100644 --- a/ApplicationCode/FileInterface/RifReaderEclipseOutput.h +++ b/ApplicationCode/FileInterface/RifReaderEclipseOutput.h @@ -22,6 +22,8 @@ #include #include +#include "RigSingleWellResultsData.h" + class RifEclipseOutputFileTools; class RifEclipseRestartDataAccess; class RigGridBase; @@ -30,7 +32,7 @@ class RigActiveCellInfo; typedef struct ecl_grid_struct ecl_grid_type; typedef struct ecl_file_struct ecl_file_type; - +typedef struct well_conn_struct well_conn_type; //================================================================================================== // @@ -57,7 +59,10 @@ private: bool readActiveCellInfo(); void buildMetaData(); void readWellCells(const ecl_grid_type* mainEclGrid); + static RigWellResultPoint createWellResultPoint(const RigGridBase* grid, const well_conn_type* ert_connection, int ertBranchId, int ertSegmentId); + + void openInitFile(); bool openDynamicAccess(); diff --git a/ApplicationCode/ModelVisualization/RivWellPipesPartMgr.cpp b/ApplicationCode/ModelVisualization/RivWellPipesPartMgr.cpp index 00702a2091..dc7125f363 100644 --- a/ApplicationCode/ModelVisualization/RivWellPipesPartMgr.cpp +++ b/ApplicationCode/ModelVisualization/RivWellPipesPartMgr.cpp @@ -97,7 +97,7 @@ void RivWellPipesPartMgr::buildWellPipeParts() std::vector< size_t > pipeBranchIds; std::vector< std::vector > pipeBranchesCLCoords; - std::vector< std::vector > pipeBranchesCellIds; + std::vector< std::vector > pipeBranchesCellIds; calculateWellPipeCenterline(pipeBranchesCLCoords, pipeBranchesCellIds); @@ -163,10 +163,10 @@ void RivWellPipesPartMgr::buildWellPipeParts() //-------------------------------------------------------------------------------------------------- -/// +/// Based on the points and cells, calculate a pipe centerline //-------------------------------------------------------------------------------------------------- void RivWellPipesPartMgr::calculateWellPipeCenterline( std::vector< std::vector >& pipeBranchesCLCoords, - std::vector< std::vector >& pipeBranchesCellIds) const + std::vector< std::vector >& pipeBranchesCellIds) const { CVF_ASSERT(m_rimWell.notNull()); CVF_ASSERT(m_rimReservoirView.notNull()); @@ -193,7 +193,7 @@ void RivWellPipesPartMgr::calculateWellPipeCenterline( std::vector< std::vector // Match this position with well head position in RivWellHeadPartMgr::buildWellHeadParts() const RigCell& whCell = rigReservoir->cellFromWellResultCell(staticWellFrame.m_wellHead); cvf::Vec3d whStartPos = whCell.faceCenter(cvf::StructGridInterface::NEG_K); - const RigWellResultCell* whResCell = &(staticWellFrame.m_wellHead); + const RigWellResultPoint* whResCell = &(staticWellFrame.m_wellHead); // Loop over all the well branches const std::vector& resBranches = staticWellFrame.m_wellResultBranches; @@ -202,7 +202,7 @@ void RivWellPipesPartMgr::calculateWellPipeCenterline( std::vector< std::vector { for (size_t i = 0 ; i < resBranches.size(); ++i) { - if (resBranches[i].m_wellCells.size() != 0) + if (resBranches[i].m_branchResultPoints.size() != 0) { hasResultCells = true; } @@ -218,15 +218,15 @@ void RivWellPipesPartMgr::calculateWellPipeCenterline( std::vector< std::vector whIntermediate.z() = (whStartPos.z() + whCell.center().z()) / 2.0; - const RigWellResultCell* prevResCell = NULL; + const RigWellResultPoint* prevResCell = NULL; // Use well head if branch head is not specified - if (!wellResults->isMultiSegmentWell()) + if (false && !wellResults->isMultiSegmentWell()) { // Create a new branch from wellhead pipeBranchesCLCoords.push_back(std::vector()); - pipeBranchesCellIds.push_back(std::vector ()); + pipeBranchesCellIds.push_back(std::vector ()); prevResCell = whResCell; @@ -237,9 +237,11 @@ void RivWellPipesPartMgr::calculateWellPipeCenterline( std::vector< std::vector pipeBranchesCellIds.back().push_back(*prevResCell); } + CVF_ASSERT(wellResults->isMultiSegmentWell() || resBranches.size() <= 1); + for (size_t brIdx = 0; brIdx < resBranches.size(); brIdx++) { - if (resBranches[brIdx].m_wellCells.size() == 0) + if (resBranches[brIdx].m_branchResultPoints.size() == 0) continue; // Skip empty branches. Do not know why they exist, but they make problems. prevResCell = NULL; @@ -247,10 +249,10 @@ void RivWellPipesPartMgr::calculateWellPipeCenterline( std::vector< std::vector // Find the start the MSW well-branch centerline. Normal wells are started "once" at wellhead in the code above - if (wellResults->isMultiSegmentWell()) - { + // if (wellResults->isMultiSegmentWell()) + // { pipeBranchesCLCoords.push_back(std::vector()); - pipeBranchesCellIds.push_back(std::vector ()); + pipeBranchesCellIds.push_back(std::vector ()); if (brIdx == 0) { @@ -264,9 +266,12 @@ void RivWellPipesPartMgr::calculateWellPipeCenterline( std::vector< std::vector pipeBranchesCLCoords.back().push_back(whIntermediate); pipeBranchesCellIds.back().push_back(*prevResCell); } + +#if 0 // Branch is supposed to contain its start point except the else { - const RigWellResultCell* leafBranchHead = staticWellFrame.findResultCellFromOutletSpecification(resBranches[brIdx].m_outletBranchIndex, resBranches[brIdx].m_outletBranchHeadCellIndex); + + const RigWellResultPoint* leafBranchHead = staticWellFrame.findResultCellFromOutletSpecification(resBranches[brIdx].m_outletBranchIndex_OBSOLETE, resBranches[brIdx].m_outletBranchHeadCellIndex_OBSOLETE); if (leafBranchHead && leafBranchHead->hasGridConnections()) { // Create a new branch and use branch head as previous result cell @@ -281,13 +286,13 @@ void RivWellPipesPartMgr::calculateWellPipeCenterline( std::vector< std::vector } else if (leafBranchHead) { - cvf::Vec3d interpolatedCoord = leafBranchHead->m_averageCenter; + cvf::Vec3d interpolatedCoord = leafBranchHead->m_bottomPosition; CVF_ASSERT(interpolatedCoord != cvf::Vec3d::UNDEFINED); if (interpolatedCoord != cvf::Vec3d::UNDEFINED) { pipeBranchesCLCoords.back().push_back(interpolatedCoord); - pipeBranchesCellIds.back().push_back(RigWellResultCell()); + pipeBranchesCellIds.back().push_back(RigWellResultPoint()); } } else @@ -295,34 +300,36 @@ void RivWellPipesPartMgr::calculateWellPipeCenterline( std::vector< std::vector // No branch head found: Possibly main branch CVF_ASSERT(false); } + } - } +#endif + // } // Loop over all the resultCells in the branch - const std::vector& resBranchCells = resBranches[brIdx].m_wellCells; + const std::vector& resBranchCells = resBranches[brIdx].m_branchResultPoints; for (int cIdx = 0; cIdx < static_cast(resBranchCells.size()); cIdx++) // Need int because cIdx can temporarily end on -1 { std::vector& branchCLCoords = pipeBranchesCLCoords.back(); - std::vector& branchCellIds = pipeBranchesCellIds.back(); + std::vector& branchCellIds = pipeBranchesCellIds.back(); - const RigWellResultCell& resCell = resBranchCells[cIdx]; + const RigWellResultPoint& resPoint = resBranchCells[cIdx]; - if (!resCell.hasConnections()) + if (!resPoint.isValid()) { continue; } - if (resCell.hasBranchConnections()) + if (!resPoint.isCell()) { // Use the interpolated value of branch head - cvf::Vec3d interpolatedCoord = resCell.m_averageCenter; + cvf::Vec3d interpolatedCoord = resPoint.m_bottomPosition; CVF_ASSERT(interpolatedCoord != cvf::Vec3d::UNDEFINED); if (interpolatedCoord != cvf::Vec3d::UNDEFINED) { pipeBranchesCLCoords.back().push_back(interpolatedCoord); - pipeBranchesCellIds.back().push_back(RigWellResultCell()); + pipeBranchesCellIds.back().push_back(RigWellResultPoint()); } // Set previous result cell to NULL @@ -331,23 +338,25 @@ void RivWellPipesPartMgr::calculateWellPipeCenterline( std::vector< std::vector continue; } - const RigCell& cell = rigReservoir->cellFromWellResultCell(resCell); + const RigCell& cell = rigReservoir->cellFromWellResultCell(resPoint); // Check if this and the previous cells has shared faces cvf::StructGridInterface::FaceType sharedFace; - if (prevResCell && rigReservoir->findSharedSourceFace(sharedFace, resCell, *prevResCell)) + if (prevResCell && rigReservoir->findSharedSourceFace(sharedFace, resPoint, *prevResCell)) { branchCLCoords.push_back(cell.faceCenter(sharedFace)); - branchCellIds.push_back(resCell); + branchCellIds.push_back(resPoint); } else { + // This and the previous cell does not share a face. cvf::Vec3d previousCoord; + // If we have a previous cell, we need to go out of it, before entering this. + if (prevResCell) { - // This and the previous cell does not share a face. We need to go out of the previous cell, before entering this. const RigCell& prevCell = rigReservoir->cellFromWellResultCell(*prevResCell); previousCoord = prevCell.center(); } @@ -362,7 +371,7 @@ void RivWellPipesPartMgr::calculateWellPipeCenterline( std::vector< std::vector if ( wellResults->isMultiSegmentWell() || !isAutoDetectBranches || (prevResCell == whResCell) - || (centerThisCell-previousCoord).lengthSquared() <= (centerThisCell - whStartPos).lengthSquared() + || (centerThisCell - previousCoord).lengthSquared() <= (centerThisCell - whStartPos).lengthSquared() ) { // Not starting a "display" branch @@ -391,7 +400,7 @@ void RivWellPipesPartMgr::calculateWellPipeCenterline( std::vector< std::vector } branchCLCoords.push_back(intoThisCell); - branchCellIds.push_back(resCell); + branchCellIds.push_back(resPoint); } else { @@ -405,7 +414,7 @@ void RivWellPipesPartMgr::calculateWellPipeCenterline( std::vector< std::vector // Create new display branch pipeBranchesCLCoords.push_back(std::vector()); - pipeBranchesCellIds.push_back(std::vector ()); + pipeBranchesCellIds.push_back(std::vector ()); // Start the new branch by entering the first cell (the wellhead) and intermediate prevResCell = whResCell; @@ -422,7 +431,7 @@ void RivWellPipesPartMgr::calculateWellPipeCenterline( std::vector< std::vector } } - prevResCell = &resCell; + prevResCell = &resPoint; } if ( wellResults->isMultiSegmentWell()) @@ -509,14 +518,14 @@ void RivWellPipesPartMgr::updatePipeResultColor(size_t frameIndex) wellCellStates.clear(); wellCellStates.resize(brIt->m_cellIds.size(), closed); - const std::vector & cellIds = brIt->m_cellIds; + const std::vector & cellIds = brIt->m_cellIds; for (size_t wcIdx = 0; wcIdx < cellIds.size(); ++wcIdx) { // we need a faster lookup, I guess - const RigWellResultCell* wResCell = NULL; + const RigWellResultPoint* wResCell = NULL; - if (cellIds[wcIdx].hasGridConnections()) + if (cellIds[wcIdx].isCell()) { wResCell = wResFrame.findResultCell(cellIds[wcIdx].m_gridIndex, cellIds[wcIdx].m_gridCellIndex); } diff --git a/ApplicationCode/ModelVisualization/RivWellPipesPartMgr.h b/ApplicationCode/ModelVisualization/RivWellPipesPartMgr.h index 0bb8dec675..574d8d3c15 100644 --- a/ApplicationCode/ModelVisualization/RivWellPipesPartMgr.h +++ b/ApplicationCode/ModelVisualization/RivWellPipesPartMgr.h @@ -67,11 +67,11 @@ private: //void calculateWellPipeCenterline(std::vector& coords) const; void calculateWellPipeCenterline(std::vector< std::vector >& pipeBranchesCLCoords, - std::vector< std::vector >& pipeBranchesCellIds ) const; + std::vector< std::vector >& pipeBranchesCellIds ) const; struct RivPipeBranchData { - std::vector m_cellIds; + std::vector m_cellIds; //std::vector< std::vector > m_cellStatusPrFrame; cvf::ref m_pipeGeomGenerator; diff --git a/ApplicationCode/ProjectDataModel/RimReservoirView.cpp b/ApplicationCode/ProjectDataModel/RimReservoirView.cpp index 2e1d37c6e0..4280a690c4 100644 --- a/ApplicationCode/ProjectDataModel/RimReservoirView.cpp +++ b/ApplicationCode/ProjectDataModel/RimReservoirView.cpp @@ -1037,14 +1037,14 @@ void RimReservoirView::appendCellResultInfo(size_t gridIndex, size_t cellIndex, } const RigWellResultFrame& wellResultFrame = singleWellResultData->wellResultFrame(m_currentTimeStep); - const RigWellResultCell* wellResultCell = wellResultFrame.findResultCell(gridIndex, cellIndex); + const RigWellResultPoint* wellResultCell = wellResultFrame.findResultCell(gridIndex, cellIndex); if (wellResultCell) { resultInfoText->append(QString("(0-based) Branch Id : %1 Segment Id %2\n").arg(wellResultCell->m_ertBranchId).arg(wellResultCell->m_ertSegmentId)); - if (wellResultCell->hasBranchConnections()) + if (wellResultCell->m_branchConnectionCount) { resultInfoText->append(QString("Branch Connection Count : %1\n").arg(wellResultCell->m_branchConnectionCount)); - resultInfoText->append(QString("Center coord : %1 %2 %3\n").arg(wellResultCell->m_averageCenter.x()).arg(wellResultCell->m_averageCenter.y()).arg(wellResultCell->m_averageCenter.z())); + resultInfoText->append(QString("Center coord : %1 %2 %3\n").arg(wellResultCell->m_bottomPosition.x()).arg(wellResultCell->m_bottomPosition.y()).arg(wellResultCell->m_bottomPosition.z())); } } } @@ -1399,12 +1399,12 @@ void RimReservoirView::calculateVisibleWellCellsIncFence(cvf::UByteArray* visibl const std::vector& wellResSegments = wellResFrames[wfIdx].m_wellResultBranches; for (size_t wsIdx = 0; wsIdx < wellResSegments.size(); ++wsIdx) { - const std::vector& wsResCells = wellResSegments[wsIdx].m_wellCells; + const std::vector& wsResCells = wellResSegments[wsIdx].m_branchResultPoints; for (size_t cIdx = 0; cIdx < wsResCells.size(); ++ cIdx) { if (wsResCells[cIdx].m_gridIndex == grid->gridIndex()) { - if (!wsResCells[cIdx].hasGridConnections()) + if (!wsResCells[cIdx].isCell()) { continue; } diff --git a/ApplicationCode/ProjectDataModel/RimWell.cpp b/ApplicationCode/ProjectDataModel/RimWell.cpp index ccbeaef416..daff321161 100644 --- a/ApplicationCode/ProjectDataModel/RimWell.cpp +++ b/ApplicationCode/ProjectDataModel/RimWell.cpp @@ -193,10 +193,10 @@ bool RimWell::calculateWellPipeVisibility(size_t frameIndex) const std::vector& wellResSegments = wrsf.m_wellResultBranches; for (size_t wsIdx = 0; wsIdx < wellResSegments.size(); ++wsIdx) { - const std::vector& wsResCells = wellResSegments[wsIdx].m_wellCells; + const std::vector& wsResCells = wellResSegments[wsIdx].m_branchResultPoints; for (size_t cIdx = 0; cIdx < wsResCells.size(); ++ cIdx) { - if (wsResCells[cIdx].hasGridConnections()) + if (wsResCells[cIdx].isCell()) { gridIndex = wsResCells[cIdx].m_gridIndex; gridCellIndex = wsResCells[cIdx].m_gridCellIndex; diff --git a/ApplicationCode/ProjectDataModel/RimWellCollection.cpp b/ApplicationCode/ProjectDataModel/RimWellCollection.cpp index 9f4dea4e10..7aff321f31 100644 --- a/ApplicationCode/ProjectDataModel/RimWellCollection.cpp +++ b/ApplicationCode/ProjectDataModel/RimWellCollection.cpp @@ -66,16 +66,6 @@ namespace caf } } -namespace caf -{ - template<> - void RimWellCollection::WellHeadPositionEnum::setUp() - { - addItem(RimWellCollection::WELLHEAD_POS_ACTIVE_CELLS_BB, "WELLHEAD_POS_ACTIVE_CELLS_BB", "Top of active cells BB"); - addItem(RimWellCollection::WELLHEAD_POS_TOP_COLUMN, "WELLHEAD_POS_TOP_COLUMN", "Top of active cells IJ-column"); - setDefault(RimWellCollection::WELLHEAD_POS_TOP_COLUMN); - } -} CAF_PDM_SOURCE_INIT(RimWellCollection, "Wells"); @@ -86,13 +76,12 @@ RimWellCollection::RimWellCollection() { CAF_PDM_InitObject("Wells", ":/WellCollection.png", "", ""); - CAF_PDM_InitField(&isActive, "Active", true, "Active", "", "", ""); - isActive.setUiHidden(true); + CAF_PDM_InitField(&active, "Active", true, "Active", "", "", ""); + active.setUiHidden(true); CAF_PDM_InitField(&showWellHead, "ShowWellHead", true, "Show well heads", "", "", ""); CAF_PDM_InitField(&showWellLabel, "ShowWellLabel", true, "Show well labels", "", "", ""); CAF_PDM_InitField(&wellHeadScaleFactor, "WellHeadScale", 1.0, "Well head scale", "", "", ""); - CAF_PDM_InitField(&wellHeadPosition, "WellHeadPosition", WellHeadPositionEnum(WELLHEAD_POS_TOP_COLUMN), "Well head position", "", "", ""); CAF_PDM_InitField(&wellPipeVisibility, "GlobalWellPipeVisibility", WellVisibilityEnum(PIPES_OPEN_IN_VISIBLE_CELLS), "Global well pipe visibility", "", "", ""); @@ -141,7 +130,6 @@ RimWell* RimWellCollection::findWell(QString name) //-------------------------------------------------------------------------------------------------- bool RimWellCollection::hasVisibleWellCells() { - if (!this->isActive()) return false; if (this->wellCellsToRangeFilterMode() == RANGE_ADD_NONE) return false; if (this->wells().size() == 0 ) return false; @@ -156,7 +144,7 @@ bool RimWellCollection::hasVisibleWellCells() const RigWellResultFrame& wellResultFrame = well->wellResults()->m_wellCellsTimeSteps[tIdx]; for (size_t wsIdx = 0; !hasCells && wsIdx < wellResultFrame.m_wellResultBranches.size(); ++wsIdx) { - if (wellResultFrame.m_wellResultBranches[wsIdx].m_wellCells.size() > 0 ) hasCells = true; + if (wellResultFrame.m_wellResultBranches[wsIdx].m_branchResultPoints.size() > 0 ) hasCells = true; } } } @@ -176,7 +164,7 @@ bool RimWellCollection::hasVisibleWellCells() //-------------------------------------------------------------------------------------------------- bool RimWellCollection::hasVisibleWellPipes() { - if (!this->isActive()) return false; + if (!this->active()) return false; if (this->wellPipeVisibility() == PIPES_FORCE_ALL_OFF) return false; if (this->wells().size() == 0 ) return false; if (this->wellPipeVisibility() == PIPES_FORCE_ALL_ON) return true; @@ -190,13 +178,12 @@ bool RimWellCollection::hasVisibleWellPipes() //-------------------------------------------------------------------------------------------------- void RimWellCollection::fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue) { - if (&showWellLabel == changedField || &isActive == changedField) + if (&showWellLabel == changedField || &active == changedField) { - this->updateUiIconFromState(isActive); + this->updateUiIconFromState(active); if (m_reservoirView) { - m_reservoirView->scheduleGeometryRegen(RivReservoirViewPartMgr::VISIBLE_WELL_CELLS); m_reservoirView->createDisplayModelAndRedraw(); } } @@ -242,8 +229,7 @@ void RimWellCollection::fieldChangedByUi(const caf::PdmFieldHandle* changedField || &pipeRadiusScaleFactor == changedField || &wellHeadScaleFactor == changedField || &showWellHead == changedField - || &isAutoDetectingBranches == changedField - || &wellHeadPosition == changedField) + || &isAutoDetectingBranches == changedField) { if (m_reservoirView) { @@ -290,7 +276,7 @@ void RimWellCollection::defineUiOrdering(QString uiConfigName, caf::PdmUiOrderin //-------------------------------------------------------------------------------------------------- caf::PdmFieldHandle* RimWellCollection::objectToggleField() { - return &isActive; + return &active; } diff --git a/ApplicationCode/ReservoirDataModel/RigCaseData.cpp b/ApplicationCode/ReservoirDataModel/RigCaseData.cpp index 4f6eebc983..1f5d7951ee 100644 --- a/ApplicationCode/ReservoirDataModel/RigCaseData.cpp +++ b/ApplicationCode/ReservoirDataModel/RigCaseData.cpp @@ -173,10 +173,10 @@ void RigCaseData::computeWellCellsPrGrid() { RigWellResultBranch& wellSegment = wellCells.m_wellResultBranches[sIdx]; size_t cdIdx; - for (cdIdx = 0; cdIdx < wellSegment.m_wellCells.size(); ++cdIdx) + for (cdIdx = 0; cdIdx < wellSegment.m_branchResultPoints.size(); ++cdIdx) { - gridIndex = wellSegment.m_wellCells[cdIdx].m_gridIndex; - gridCellIndex = wellSegment.m_wellCells[cdIdx].m_gridCellIndex; + gridIndex = wellSegment.m_branchResultPoints[cdIdx].m_gridIndex; + gridCellIndex = wellSegment.m_branchResultPoints[cdIdx].m_gridCellIndex; if(gridIndex < m_wellCellsInGrid.size() && gridCellIndex < m_wellCellsInGrid[gridIndex]->size()) { @@ -227,7 +227,7 @@ cvf::UIntArray* RigCaseData::gridCellToWellIndex(size_t gridIndex) //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- -RigCell& RigCaseData::cellFromWellResultCell(const RigWellResultCell& wellResultCell) +RigCell& RigCaseData::cellFromWellResultCell(const RigWellResultPoint& wellResultCell) { size_t gridIndex = wellResultCell.m_gridIndex; size_t gridCellIndex = wellResultCell.m_gridCellIndex; @@ -241,7 +241,7 @@ RigCell& RigCaseData::cellFromWellResultCell(const RigWellResultCell& wellResult //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- -bool RigCaseData::findSharedSourceFace(cvf::StructGridInterface::FaceType& sharedSourceFace,const RigWellResultCell& sourceWellCellResult, const RigWellResultCell& otherWellCellResult) const +bool RigCaseData::findSharedSourceFace(cvf::StructGridInterface::FaceType& sharedSourceFace,const RigWellResultPoint& sourceWellCellResult, const RigWellResultPoint& otherWellCellResult) const { size_t gridIndex = sourceWellCellResult.m_gridIndex; size_t gridCellIndex = sourceWellCellResult.m_gridCellIndex; diff --git a/ApplicationCode/ReservoirDataModel/RigCaseData.h b/ApplicationCode/ReservoirDataModel/RigCaseData.h index a4d100e3d7..2ab3432815 100644 --- a/ApplicationCode/ReservoirDataModel/RigCaseData.h +++ b/ApplicationCode/ReservoirDataModel/RigCaseData.h @@ -65,8 +65,8 @@ public: cvf::UByteArray* wellCellsInGrid(size_t gridIndex); cvf::UIntArray* gridCellToWellIndex(size_t gridIndex); - RigCell& cellFromWellResultCell(const RigWellResultCell& wellResultCell); - bool findSharedSourceFace(cvf::StructGridInterface::FaceType& sharedSourceFace, const RigWellResultCell& sourceWellCellResult, const RigWellResultCell& otherWellCellResult) const; + RigCell& cellFromWellResultCell(const RigWellResultPoint& wellResultCell); + bool findSharedSourceFace(cvf::StructGridInterface::FaceType& sharedSourceFace, const RigWellResultPoint& sourceWellCellResult, const RigWellResultPoint& otherWellCellResult) const; void computeActiveCellBoundingBoxes(); diff --git a/ApplicationCode/ReservoirDataModel/RigReservoirBuilderMock.cpp b/ApplicationCode/ReservoirDataModel/RigReservoirBuilderMock.cpp index 8f27fc9a20..1ebacb6c1a 100644 --- a/ApplicationCode/ReservoirDataModel/RigReservoirBuilderMock.cpp +++ b/ApplicationCode/ReservoirDataModel/RigReservoirBuilderMock.cpp @@ -407,7 +407,7 @@ void RigReservoirBuilderMock::addWellData(RigCaseData* eclipseCase, RigGridBase* { if (connIdx == (size_t)(connectionCount/4)) continue; - RigWellResultCell data; + RigWellResultPoint data; data.m_gridIndex = 0; if (connIdx < dim.y()-2) @@ -425,28 +425,28 @@ void RigReservoirBuilderMock::addWellData(RigCaseData* eclipseCase, RigGridBase* data.m_isOpen = false; } - if (wellSegment.m_wellCells.size() == 0 || wellSegment.m_wellCells.back().m_gridCellIndex != data.m_gridCellIndex) + if (wellSegment.m_branchResultPoints.size() == 0 || wellSegment.m_branchResultPoints.back().m_gridCellIndex != data.m_gridCellIndex) { - wellSegment.m_wellCells.push_back(data); + wellSegment.m_branchResultPoints.push_back(data); if (connIdx == connectionCount / 2 ) { - RigWellResultCell deadEndData = data; + RigWellResultPoint deadEndData = data; deadEndData.m_gridCellIndex = data.m_gridCellIndex + 1; deadEndData.m_isOpen = true; - RigWellResultCell deadEndData1 = data; + RigWellResultPoint deadEndData1 = data; deadEndData1.m_gridCellIndex = data.m_gridCellIndex + 2; deadEndData.m_isOpen = false; - wellSegment.m_wellCells.push_back(deadEndData); - wellSegment.m_wellCells.push_back(deadEndData1); + wellSegment.m_branchResultPoints.push_back(deadEndData); + wellSegment.m_branchResultPoints.push_back(deadEndData1); deadEndData.m_isOpen = true; - wellSegment.m_wellCells.push_back(deadEndData); + wellSegment.m_branchResultPoints.push_back(deadEndData); data.m_isOpen = true; - wellSegment.m_wellCells.push_back(data); + wellSegment.m_branchResultPoints.push_back(data); } } @@ -454,9 +454,9 @@ void RigReservoirBuilderMock::addWellData(RigCaseData* eclipseCase, RigGridBase* { data.m_gridCellIndex = grid->cellIndexFromIJK(1 , 1 + connIdx , 2 + connIdx); - if (wellSegment.m_wellCells.size() == 0 || wellSegment.m_wellCells.back().m_gridCellIndex != data.m_gridCellIndex) + if (wellSegment.m_branchResultPoints.size() == 0 || wellSegment.m_branchResultPoints.back().m_gridCellIndex != data.m_gridCellIndex) { - wellSegment.m_wellCells.push_back(data); + wellSegment.m_branchResultPoints.push_back(data); } } } diff --git a/ApplicationCode/ReservoirDataModel/RigSingleWellResultsData.cpp b/ApplicationCode/ReservoirDataModel/RigSingleWellResultsData.cpp index 609e2766ed..da183cfa90 100644 --- a/ApplicationCode/ReservoirDataModel/RigSingleWellResultsData.cpp +++ b/ApplicationCode/ReservoirDataModel/RigSingleWellResultsData.cpp @@ -112,16 +112,16 @@ void RigSingleWellResultsData::computeStaticWellCellPath() { if (m_wellCellsTimeSteps.size() == 0) return; - std::map < size_t, std::list< RigWellResultCell > > staticWellBranches; + std::map < size_t, std::list< RigWellResultPoint > > staticWellBranches; // Add ResultCell data from the first timestep to the final result. for (size_t bIdx = 0; bIdx < m_wellCellsTimeSteps[0].m_wellResultBranches.size(); ++bIdx) { size_t branchNumber = m_wellCellsTimeSteps[0].m_wellResultBranches[bIdx].m_branchIndex; - std::vector& frameCells = m_wellCellsTimeSteps[0].m_wellResultBranches[bIdx].m_wellCells; + std::vector& frameCells = m_wellCellsTimeSteps[0].m_wellResultBranches[bIdx].m_branchResultPoints; - std::list< RigWellResultCell >& branch = staticWellBranches[branchNumber]; + std::list< RigWellResultPoint >& branch = staticWellBranches[branchNumber]; for(size_t cIdx = 0; cIdx < frameCells.size(); ++cIdx) { @@ -138,12 +138,12 @@ void RigSingleWellResultsData::computeStaticWellCellPath() for (size_t bIdx = 0; bIdx < m_wellCellsTimeSteps[tIdx].m_wellResultBranches.size(); ++bIdx) { size_t branchNumber = m_wellCellsTimeSteps[tIdx].m_wellResultBranches[bIdx].m_branchIndex; - std::vector& resBranch = m_wellCellsTimeSteps[tIdx].m_wellResultBranches[bIdx].m_wellCells; + std::vector& resBranch = m_wellCellsTimeSteps[tIdx].m_wellResultBranches[bIdx].m_branchResultPoints; - std::list< RigWellResultCell >& stBranch = staticWellBranches[branchNumber]; - std::list< RigWellResultCell >::iterator it; - std::list< RigWellResultCell >::iterator sStartIt; - std::list< RigWellResultCell >::iterator sEndIt; + std::list< RigWellResultPoint >& stBranch = staticWellBranches[branchNumber]; + std::list< RigWellResultPoint >::iterator it; + std::list< RigWellResultPoint >::iterator sStartIt; + std::list< RigWellResultPoint >::iterator sEndIt; size_t rStartIdx; size_t rEndIdx; @@ -245,7 +245,7 @@ void RigSingleWellResultsData::computeStaticWellCellPath() // Populate the static well info - std::map < size_t, std::list< RigWellResultCell > >::iterator bIt; + std::map < size_t, std::list< RigWellResultPoint > >::iterator bIt; m_staticWellCells.m_wellResultBranches.clear(); m_staticWellCells.m_wellHead = m_wellCellsTimeSteps[0].m_wellHead; @@ -262,15 +262,15 @@ void RigSingleWellResultsData::computeStaticWellCellPath() rigBranch.m_branchIndex = bIt->first; // Clear well cells, and insert the collection of well cells for the static situation - rigBranch.m_wellCells.clear(); + rigBranch.m_branchResultPoints.clear(); - std::list< RigWellResultCell >& branch = bIt->second; - std::list< RigWellResultCell >::iterator cIt; + std::list< RigWellResultPoint >& branch = bIt->second; + std::list< RigWellResultPoint >::iterator cIt; for (cIt = branch.begin(); cIt != branch.end(); ++cIt) { - RigWellResultCell rwc = *cIt; + RigWellResultPoint rwc = *cIt; rwc.m_isOpen = false; // Reset the dynamic property - rigBranch.m_wellCells.push_back(*cIt); + rigBranch.m_branchResultPoints.push_back(*cIt); } m_staticWellCells.m_wellResultBranches.push_back(rigBranch); diff --git a/ApplicationCode/ReservoirDataModel/RigSingleWellResultsData.h b/ApplicationCode/ReservoirDataModel/RigSingleWellResultsData.h index 3954c0d11b..108448ab32 100644 --- a/ApplicationCode/ReservoirDataModel/RigSingleWellResultsData.h +++ b/ApplicationCode/ReservoirDataModel/RigSingleWellResultsData.h @@ -27,31 +27,31 @@ #include #include "cvfVector3.h" -struct RigWellResultCell +struct RigWellResultPoint { - RigWellResultCell() : + RigWellResultPoint() : m_gridIndex(cvf::UNDEFINED_SIZE_T), m_gridCellIndex(cvf::UNDEFINED_SIZE_T), m_isOpen(false), m_ertBranchId(-1), m_ertSegmentId(-1), - m_averageCenter(cvf::Vec3d::UNDEFINED), + m_bottomPosition(cvf::Vec3d::UNDEFINED), m_branchConnectionCount(0) { } - bool hasBranchConnections() const + bool isPointValid() const { - return m_branchConnectionCount != 0; + return m_bottomPosition != cvf::Vec3d::UNDEFINED; } - bool hasGridConnections() const + bool isCell() const { return m_gridCellIndex != cvf::UNDEFINED_SIZE_T; } - bool hasConnections() const + bool isValid() const { - return hasGridConnections() || hasBranchConnections(); + return isCell() || isPointValid(); } @@ -63,33 +63,30 @@ struct RigWellResultCell int m_ertBranchId; int m_ertSegmentId; - cvf::Vec3d m_averageCenter; + cvf::Vec3d m_bottomPosition; size_t m_branchConnectionCount; }; + struct RigWellResultBranch { RigWellResultBranch() : m_branchIndex(cvf::UNDEFINED_SIZE_T), m_ertBranchId(-1), - m_outletBranchIndex(cvf::UNDEFINED_SIZE_T), - m_outletBranchHeadCellIndex(cvf::UNDEFINED_SIZE_T) + m_outletBranchIndex_OBSOLETE(cvf::UNDEFINED_SIZE_T), + m_outletBranchHeadCellIndex_OBSOLETE(cvf::UNDEFINED_SIZE_T) {} size_t m_branchIndex; int m_ertBranchId; - std::vector m_wellCells; - + std::vector m_branchResultPoints; + // Grid cell from last connection in outlet segment. For MSW wells, this is either well head or a well result cell in another branch // For standard wells, this is always well head. - RigWellResultCell m_branchHead; - - // Grid cell from last connection in outlet segment. For MSW wells, this is either well head or a well result cell in another branch - // For standard wells, this is always well head. - size_t m_outletBranchIndex; - size_t m_outletBranchHeadCellIndex; + size_t m_outletBranchIndex_OBSOLETE; + size_t m_outletBranchHeadCellIndex_OBSOLETE; }; @@ -104,7 +101,7 @@ public: m_productionType(UNDEFINED_PRODUCTION_TYPE) { } - const RigWellResultCell* findResultCell(size_t gridIndex, size_t gridCellIndex) const + const RigWellResultPoint* findResultCell(size_t gridIndex, size_t gridCellIndex) const { CVF_ASSERT(gridIndex != cvf::UNDEFINED_SIZE_T && gridCellIndex != cvf::UNDEFINED_SIZE_T); @@ -115,12 +112,12 @@ public: for (size_t wb = 0; wb < m_wellResultBranches.size(); ++wb) { - for (size_t wc = 0; wc < m_wellResultBranches[wb].m_wellCells.size(); ++wc) + for (size_t wc = 0; wc < m_wellResultBranches[wb].m_branchResultPoints.size(); ++wc) { - if ( m_wellResultBranches[wb].m_wellCells[wc].m_gridCellIndex == gridCellIndex - && m_wellResultBranches[wb].m_wellCells[wc].m_gridIndex == gridIndex ) + if ( m_wellResultBranches[wb].m_branchResultPoints[wc].m_gridCellIndex == gridCellIndex + && m_wellResultBranches[wb].m_branchResultPoints[wc].m_gridIndex == gridIndex ) { - return &(m_wellResultBranches[wb].m_wellCells[wc]); + return &(m_wellResultBranches[wb].m_branchResultPoints[wc]); } } } @@ -128,14 +125,14 @@ public: return NULL; } - const RigWellResultCell* findResultCellFromOutletSpecification(size_t branchIndex, size_t wellResultCellIndex) const + const RigWellResultPoint* findResultCellFromOutletSpecification(size_t branchIndex, size_t wellResultCellIndex) const { if (branchIndex != cvf::UNDEFINED_SIZE_T && branchIndex < m_wellResultBranches.size()) { const RigWellResultBranch& resBranch = m_wellResultBranches[branchIndex]; - if (wellResultCellIndex != cvf::UNDEFINED_SIZE_T && wellResultCellIndex < resBranch.m_wellCells.size()) + if (wellResultCellIndex != cvf::UNDEFINED_SIZE_T && wellResultCellIndex < resBranch.m_branchResultPoints.size()) { - return (&resBranch.m_wellCells[wellResultCellIndex]); + return (&resBranch.m_branchResultPoints[wellResultCellIndex]); } } @@ -145,7 +142,7 @@ public: WellProductionType m_productionType; bool m_isOpen; - RigWellResultCell m_wellHead; + RigWellResultPoint m_wellHead; QDateTime m_timestamp; std::vector m_wellResultBranches;