mirror of
https://github.com/OPM/ResInsight.git
synced 2025-01-24 15:26:48 -06:00
86a53980a4
Added PDM objects for a list of well paths (RimWellPathCollection) and for individual well paths (RimWellPath). RimWellPathCollection uses RivWellPathCollectionPartMgr to generate visualization parts for each well path in the collection. RimWellPath handles geometry defined in RigWellPath, and RivWellPathPartMgr is used to generate visualization parts. The well path visualization parts are generated by reusing RivPipeGeometryGenerator (also used for well pipes). Added features: - Select Open Well Paths in File menu to open one or more well path files, file format supported is Statoil JSON format. - Each well path has a label showing the name, and the PDM window will show additional info (Id, Source System, UTM Zone, Update Date and User, Survey Type, File Path). - Possible to turn on / off visibility, set thickness, set color for individual well paths. - List of well paths including specified parameters/settings will be stored in project file. - Possible to clip all well paths at a specified distance to the reservoir as this is the relevant area to see, and if showing whole well path it may be problematic for auto zoom etc. p4#: 21652
188 lines
7.4 KiB
C++
188 lines
7.4 KiB
C++
/////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Copyright (C) 2011-2012 Statoil ASA, Ceetron AS
|
|
//
|
|
// ResInsight is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
// FITNESS FOR A PARTICULAR PURPOSE.
|
|
//
|
|
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
|
|
// for more details.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include "RigWellPath.h"
|
|
#include <map>
|
|
|
|
#include <QDebug>
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
// void RigWellPath::computeStaticWellCellPath()
|
|
// {
|
|
// if (m_wellCellsTimeSteps.size() == 0) return;
|
|
//
|
|
// std::map < size_t, std::list< RigWellResultCell > > 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_branchNumber;
|
|
// std::vector<RigWellResultCell>& frameCells = m_wellCellsTimeSteps[0].m_wellResultBranches[bIdx].m_wellCells;
|
|
//
|
|
// std::list< RigWellResultCell >& branch = staticWellBranches[branchNumber];
|
|
//
|
|
// for(size_t cIdx = 0; cIdx < frameCells.size(); ++cIdx)
|
|
// {
|
|
// branch.push_back(frameCells[cIdx]);
|
|
// }
|
|
// }
|
|
//
|
|
//
|
|
//
|
|
// for (size_t tIdx = 1; tIdx < m_wellCellsTimeSteps.size(); ++tIdx)
|
|
// {
|
|
// // Merge well branches separately
|
|
//
|
|
// for (size_t bIdx = 0; bIdx < m_wellCellsTimeSteps[tIdx].m_wellResultBranches.size(); ++bIdx)
|
|
// {
|
|
// size_t branchNumber = m_wellCellsTimeSteps[tIdx].m_wellResultBranches[bIdx].m_branchNumber;
|
|
// std::vector<RigWellResultCell>& resBranch = m_wellCellsTimeSteps[tIdx].m_wellResultBranches[bIdx].m_wellCells;
|
|
//
|
|
// std::list< RigWellResultCell >& stBranch = staticWellBranches[branchNumber];
|
|
// std::list< RigWellResultCell >::iterator it;
|
|
// std::list< RigWellResultCell >::iterator sStartIt;
|
|
// std::list< RigWellResultCell >::iterator sEndIt;
|
|
// size_t rStartIdx;
|
|
// size_t rEndIdx;
|
|
//
|
|
//
|
|
// size_t sGridIdx;
|
|
// size_t sCellIdx;
|
|
// size_t rGridIdx;
|
|
// size_t rCellIdx;
|
|
//
|
|
// // First detect if we have cells on the start of the result frame, that is not in the static frame
|
|
// {
|
|
// sEndIt = stBranch.begin();
|
|
// bool found = false;
|
|
// if (stBranch.size())
|
|
// {
|
|
// sGridIdx = sEndIt->m_gridIndex;
|
|
// sCellIdx = sEndIt->m_gridCellIndex;
|
|
//
|
|
// for (rEndIdx = 0; !found && rEndIdx < resBranch.size(); ++rEndIdx)
|
|
// {
|
|
// rGridIdx = resBranch[rEndIdx].m_gridIndex;
|
|
// rCellIdx = resBranch[rEndIdx].m_gridCellIndex;
|
|
//
|
|
// if (sGridIdx == rGridIdx && sCellIdx == rCellIdx) { found = true; break; }
|
|
// }
|
|
// }
|
|
//
|
|
// if (found)
|
|
// {
|
|
// if (rEndIdx > 0)
|
|
// {
|
|
// // Found cells in start, merge them in
|
|
// for (size_t cIdx = 0; cIdx < rEndIdx; ++cIdx)
|
|
// {
|
|
// stBranch.insert(sEndIt, resBranch[cIdx]);
|
|
// }
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// // The result probably starts later in the well
|
|
// rEndIdx = 0;
|
|
// }
|
|
//
|
|
// sStartIt = sEndIt;
|
|
// rStartIdx = rEndIdx;
|
|
// }
|
|
//
|
|
// // Now find all result cells in ranges between pairs in the static path
|
|
// // If the result has items that "compete" with those in the static path,
|
|
// // those items are inserted after the ones in the static path. This
|
|
// // is not neccesarily correct. They could be in front, and also merged in
|
|
// // strange ways. A geometric test could make this more robust, but we will
|
|
// // not solve before we see that it actually ends up as a problem
|
|
//
|
|
// if (sEndIt != stBranch.end()) ++sEndIt;
|
|
// for ( ; sEndIt != stBranch.end() ; ++sEndIt)
|
|
// {
|
|
// sGridIdx = sEndIt->m_gridIndex;
|
|
// sCellIdx = sEndIt->m_gridCellIndex;
|
|
//
|
|
// bool found = false;
|
|
// for (rEndIdx += 1; !found && rEndIdx < resBranch.size(); ++rEndIdx)
|
|
// {
|
|
// rGridIdx = resBranch[rEndIdx].m_gridIndex;
|
|
// rCellIdx = resBranch[rEndIdx].m_gridCellIndex;
|
|
//
|
|
// if (sGridIdx == rGridIdx && sCellIdx == rCellIdx) { found = true; break; }
|
|
// }
|
|
//
|
|
// if (found)
|
|
// {
|
|
// if (rEndIdx - rStartIdx > 1)
|
|
// {
|
|
// // Found cell range in result that we do not have in the static result, merge them in
|
|
// for (size_t cIdx = rStartIdx + 1; cIdx < rEndIdx; ++cIdx)
|
|
// {
|
|
// stBranch.insert(sEndIt, resBranch[cIdx]);
|
|
// }
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// // The static path probably has some extra cells
|
|
// rEndIdx = rStartIdx;
|
|
// }
|
|
//
|
|
// sStartIt = sEndIt;
|
|
// rStartIdx = rEndIdx;
|
|
// }
|
|
//
|
|
// // Then add cells from the end of the resultpath not present in the static path
|
|
// for (size_t cIdx = rEndIdx + 1; cIdx < resBranch.size(); ++cIdx)
|
|
// {
|
|
// stBranch.push_back(resBranch[cIdx]);
|
|
// }
|
|
// }
|
|
// }
|
|
//
|
|
// // Populate the static well info
|
|
//
|
|
// std::map < size_t, std::list< RigWellResultCell > >::iterator bIt;
|
|
//
|
|
// m_staticWellCells.m_wellResultBranches.clear();
|
|
// m_staticWellCells.m_wellHead = m_wellCellsTimeSteps[0].m_wellHead;
|
|
//
|
|
// for (bIt = staticWellBranches.begin(); bIt != staticWellBranches.end(); ++bIt)
|
|
// {
|
|
// RigWellResultBranch rigBranch;
|
|
// rigBranch.m_branchNumber = bIt->first;
|
|
//
|
|
// std::list< RigWellResultCell >& branch = bIt->second;
|
|
// std::list< RigWellResultCell >::iterator cIt;
|
|
//
|
|
// for (cIt = branch.begin(); cIt != branch.end(); ++cIt)
|
|
// {
|
|
// RigWellResultCell rwc = *cIt;
|
|
// rwc.m_isOpen = false; // Reset the dynamic property
|
|
// rigBranch.m_wellCells.push_back(*cIt);
|
|
// }
|
|
//
|
|
// m_staticWellCells.m_wellResultBranches.push_back(rigBranch);
|
|
// }
|
|
// }
|
|
|