mirror of
https://github.com/OPM/ResInsight.git
synced 2025-02-12 00:16:10 -06:00
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);
|
||
|
|
// }
|
||
|
|
// }
|
||
|
|
|