ResInsight/ApplicationCode/ReservoirDataModel/RigSimulationWellCenterLineCalculator.cpp

/////////////////////////////////////////////////////////////////////////////////
//
//  Copyright (C) Statoil ASA
//  Copyright (C) Ceetron Solutions 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 "RigSimulationWellCenterLineCalculator.h"

#include "RigCell.h"
#include "RigEclipseCaseData.h"
#include "RigMainGrid.h"

#include "RimEclipseCase.h"
#include "RimEclipseView.h"
#include "RimSimWellInView.h"
#include "RimSimWellInViewCollection.h"

#include "cvfBoundingBoxTree.h"
#include "cvfGeometryTools.h"
#include "cvfRay.h"

#include <deque>
#include <list>

//--------------------------------------------------------------------------------------------------
/// Based on the points and cells, calculate a pipe centerline
/// The returned CellIds is one less than the number of centerline points,
/// and are describing the lines between the points, starting with the first line
//--------------------------------------------------------------------------------------------------
void RigSimulationWellCenterLineCalculator::calculateWellPipeStaticCenterline(
    RimSimWellInView*                             rimWell,
    std::vector<std::vector<cvf::Vec3d>>&         pipeBranchesCLCoords,
    std::vector<std::vector<RigWellResultPoint>>& pipeBranchesCellIds)
{
    CVF_ASSERT(rimWell);

    const RigSimWellData* simWellData = rimWell->simWellData();

    RimEclipseView* eclipseView;
    rimWell->firstAncestorOrThisOfType(eclipseView);

    CVF_ASSERT(eclipseView);

    RigEclipseCaseData* eclipseCaseData      = eclipseView->eclipseCase()->eclipseCaseData();
    bool                isAutoDetectBranches = eclipseView->wellCollection()->isAutoDetectingBranches();

    bool useAllCellCenters = rimWell->isUsingCellCenterForPipe();
    int  timeStepIndex     = -1;

    calculateWellPipeCenterlineFromWellFrame(eclipseCaseData,
                                             simWellData,
                                             timeStepIndex,
                                             isAutoDetectBranches,
                                             useAllCellCenters,
                                             pipeBranchesCLCoords,
                                             pipeBranchesCellIds);
}

//--------------------------------------------------------------------------------------------------
/// Based on the points and cells, calculate a pipe centerline
/// The returned CellIds is one less than the number of centerline points,
/// and are describing the lines between the points, starting with the first line
//--------------------------------------------------------------------------------------------------
void RigSimulationWellCenterLineCalculator::calculateWellPipeCenterlineFromWellFrame(const RigEclipseCaseData* eclipseCaseData, 
                                                                                     const RigSimWellData* wellResults,
                                                                                     int timeStepIndex,
                                                                                     bool isAutoDetectBranches,
                                                                                     bool useAllCellCenters,
                                                                                     std::vector<std::vector<cvf::Vec3d>> &pipeBranchesCLCoords, 
                                                                                     std::vector<std::vector<RigWellResultPoint>> &pipeBranchesCellIds)
{
    // Initialize the return arrays
    pipeBranchesCLCoords.clear();
    pipeBranchesCellIds.clear();

    if ( !wellResults) return;
    if ( timeStepIndex >= 0 && !wellResults->hasAnyValidCells(timeStepIndex) ) return;

    const RigWellResultFrame* wellFramePtr = nullptr;
    
    if (timeStepIndex < 0) 
    {
        wellFramePtr = &wellResults->staticWellCells();
    }
    else
    {
        wellFramePtr = &(wellResults->wellResultFrame(timeStepIndex));
    }

    bool isMultiSegmentWell = wellResults->isMultiSegmentWell();

    #if 0 // Fancy branch splitting, but with artifacts. Needs a bit more work to be better overall than the one we have.
    RigWellResultFrame splittedWellFrame;
    if (!isMultiSegmentWell && isAutoDetectBranches)
    {
        splittedWellFrame = splitIntoBranches(*wellFramePtr, eclipseCaseData);
        wellFramePtr = &splittedWellFrame;
        isMultiSegmentWell = true;
    }
    #endif

    const RigWellResultFrame& wellFrame = *wellFramePtr;
    const std::vector<RigWellResultBranch>& resBranches = wellFrame.m_wellResultBranches;

    // Well head
    // Match this position with well head position in RivWellHeadPartMgr::buildWellHeadParts()

    const RigCell& whCell = eclipseCaseData->cellFromWellResultCell(wellFrame.wellHeadOrStartCell());
    cvf::Vec3d whStartPos = whCell.faceCenter(cvf::StructGridInterface::NEG_K);

    RigWellResultPoint wellHead = wellFrame.wellHeadOrStartCell();
    const RigWellResultPoint* whResCell = &wellHead;
   
    // Add extra coordinate between cell face and cell center 
    // to make sure the well pipe terminated in a segment parallel to z-axis

    cvf::Vec3d whIntermediate = whStartPos;
    whIntermediate.z() = (whStartPos.z() + whCell.center().z()) / 2.0;

    const RigWellResultPoint* prevWellResPoint = nullptr;

    // CVF_ASSERT(isMultiSegmentWell ||  resBranches.size() <= 1); // TODO : Consider to set isMultiSegmentWell = true;

    // The centerline is calculated by adding a point when the pipe enters a cell, 
    // and one when the line leaves the cell.
    // For the sake of the loop:
    // The currentResultPoint (Cell) and the one we index by the loop variable is the one we calculate the entry point to.
    // The previous cell is the one we leave, and calculate the "out-point" from 

    for (size_t brIdx = 0; brIdx < resBranches.size(); brIdx++)
    {

        // Skip empty branches. Do not know why they exist, but they make problems.

        const RigWellResultBranch&  branch = resBranches[brIdx];
        if ( !hasAnyValidDataCells(branch) ) continue;

        prevWellResPoint = nullptr;

        // Find the start the MSW well-branch centerline. Normal wells are started "once" at wellhead in the code above 

        pipeBranchesCLCoords.push_back(std::vector<cvf::Vec3d>());
        pipeBranchesCellIds.push_back(std::vector <RigWellResultPoint>());

        if (brIdx == 0)
        {
            // The first branch contains segment number 1, and this is the only segment connected to well head
            // See Eclipse documentation for the keyword WELSEGS
            prevWellResPoint = whResCell;

            pipeBranchesCLCoords.back().push_back(whStartPos);
            pipeBranchesCellIds.back().push_back(*prevWellResPoint);

            pipeBranchesCLCoords.back().push_back(whIntermediate);
            pipeBranchesCellIds.back().push_back(*prevWellResPoint);
        }

        // Loop over all the resultPoints in the branch

        const std::vector<RigWellResultPoint>& resBranchCells = resBranches[brIdx].m_branchResultPoints;

        for (int cIdx = 0; cIdx < static_cast<int>(resBranchCells.size()); cIdx++) // Need int because cIdx can temporarily end on cvf::UNDEFINED_SIZE_T
        {
            std::vector<cvf::Vec3d>&        branchCLCoords = pipeBranchesCLCoords.back();
            std::vector<RigWellResultPoint>& branchCellIds  = pipeBranchesCellIds.back();

            const RigWellResultPoint& currentWellResPoint = resBranchCells[cIdx];

            // Ignore invalid cells

            if (!currentWellResPoint.isValid())
            {
                //CVF_ASSERT(false); // Some segments does not get anything yet.
                continue;
            }

            // Add cl contribution for a geometrical resultPoint by adding exit point from previous cell, 
            // and then the result point position 

            if (!currentWellResPoint.isCell())
            {
                // Use the interpolated value of branch head
                CVF_ASSERT(currentWellResPoint.isPointValid());

                cvf::Vec3d currentPoint = currentWellResPoint.m_bottomPosition;

                // If we have a real previous cell, we need to go out of it, before adding the current point
                // That is: add a CL-point describing where it leaves the previous cell.

                if (prevWellResPoint && prevWellResPoint->isCell())
                {
                    // Create ray between the previous and this position

                    const RigCell& prevCell = eclipseCaseData->cellFromWellResultCell(*prevWellResPoint);
                    cvf::Vec3d centerPreviousCell = prevCell.center();

                    cvf::Ray rayToThisCell;
                    rayToThisCell.setOrigin(centerPreviousCell);
                    rayToThisCell.setDirection((currentPoint - centerPreviousCell).getNormalized());

                    cvf::Vec3d outOfPrevCell(centerPreviousCell);

                    prevCell.firstIntersectionPoint(rayToThisCell, &outOfPrevCell);
                    if ((currentPoint - outOfPrevCell).lengthSquared() > 1e-3)
                    {
                        branchCLCoords.push_back(outOfPrevCell);
                        branchCellIds.push_back(RigWellResultPoint());
                    }

                }

                branchCLCoords.push_back(currentPoint);
                branchCellIds.push_back(currentWellResPoint);

                prevWellResPoint = &currentWellResPoint;

                continue;
            }

            //
            // Handle currentWellResPoint as a real cell result points.
            //

            const RigCell& cell = eclipseCaseData->cellFromWellResultCell(currentWellResPoint);

            // Check if this and the previous cells has shared faces

            cvf::StructGridInterface::FaceType sharedFace;
            if (prevWellResPoint && prevWellResPoint->isCell() && eclipseCaseData->findSharedSourceFace(sharedFace, currentWellResPoint, *prevWellResPoint))
            {
                // If they share faces, the shared face center is used as point
                // describing the entry of this cell. (And exit of the previous cell)

                branchCLCoords.push_back(cell.faceCenter(sharedFace));
                branchCellIds.push_back(currentWellResPoint);
            }
            else
            {
                // This and the previous cell does not share a face.
                // Then we need to calculate the exit of the previous cell, and the entry point into this cell

                cvf::Vec3d centerPreviousCell(cvf::Vec3d::ZERO);
                cvf::Vec3d centerThisCell = cell.center();
                bool distanceToWellHeadIsLonger = true;

                // If we have a previous well result point, use its center as measure point and ray intersection start 
                // when considering things. 

                if (prevWellResPoint && prevWellResPoint->isValid())
                {
                    if (prevWellResPoint->isCell())
                    {
                        const RigCell& prevCell = eclipseCaseData->cellFromWellResultCell(*prevWellResPoint);
                        centerPreviousCell = prevCell.center();
                    }
                    else
                    {
                        centerPreviousCell = prevWellResPoint->m_bottomPosition;
                    }

                    distanceToWellHeadIsLonger = (centerThisCell - centerPreviousCell).lengthSquared() <= (centerThisCell - whStartPos).lengthSquared();
                }


                // First make sure this cell is not starting a new "display" branch for none MSW's

                if (    isMultiSegmentWell
                    || !isAutoDetectBranches
                    || (prevWellResPoint == whResCell)
                    || distanceToWellHeadIsLonger)
                {
                    // Not starting a "display" branch for normal wells
                    // Calculate the exit of the previous cell, and the entry point into this cell

                    cvf::Vec3d intoThisCell(centerThisCell); // Use cell center as default for "into" point.

                    if (prevWellResPoint && prevWellResPoint->isValid())
                    {
                        // We have a defined previous point
                        // Create ray between the previous and this cell 

                        cvf::Ray rayToThisCell;
                        rayToThisCell.setOrigin(centerPreviousCell);
                        rayToThisCell.setDirection((centerThisCell - centerPreviousCell).getNormalized());

                        // Intersect with the current cell to find a better entry point than the cell center

                        int intersectionCount = cell.firstIntersectionPoint(rayToThisCell, &intoThisCell);
                        bool isPreviousResPointInsideCurrentCell = (intersectionCount % 2); // Must intersect uneven times to be inside. (1 % 2 = 1)

                        // If we have a real previous cell, we need to go out of it, before entering this.
                        // That is: add a CL-point describing where it leaves the previous cell.

                        if ( prevWellResPoint->isCell())
                        {
                            cvf::Vec3d outOfPrevCell(centerPreviousCell);

                            const RigCell& prevCell = eclipseCaseData->cellFromWellResultCell(*prevWellResPoint);
                            prevCell.firstIntersectionPoint(rayToThisCell, &outOfPrevCell);
                            if ((intoThisCell - outOfPrevCell).lengthSquared() > 1e-3)
                            {
                                branchCLCoords.push_back(outOfPrevCell);
                                branchCellIds.push_back(RigWellResultPoint());
                            }
                        }
                        else if (isPreviousResPointInsideCurrentCell)
                        {
                            // Since the previous point actually is inside this cell, 
                            /// use that as the entry point into this cell
                            intoThisCell = centerPreviousCell;
                        }

                    }

                    branchCLCoords.push_back(intoThisCell);
                    branchCellIds.push_back(currentWellResPoint);
                }
                else
                {
                    // Need to start a "display branch" for a Normal Well.

                    CVF_ASSERT(!isMultiSegmentWell);

                    // This cell is further from the previous cell than from the well head, 
                    // thus we interpret it as a new branch.

                    // First finish the current branch in the previous cell
                    //branchCLCoords.push_back(branchCLCoords.back() + 1.5*(centerPreviousCell - branchCLCoords.back())  );
                    finishPipeCenterLine(pipeBranchesCLCoords, centerPreviousCell);

                    // Create new display branch
                    pipeBranchesCLCoords.push_back(std::vector<cvf::Vec3d>());
                    pipeBranchesCellIds.push_back(std::vector <RigWellResultPoint>());

                    // Start the new branch by entering the first cell (the wellhead) and intermediate
                    prevWellResPoint = whResCell;
                    pipeBranchesCLCoords.back().push_back(whStartPos);
                    pipeBranchesCellIds.back().push_back(*prevWellResPoint);

                    // Include intermediate
                    pipeBranchesCLCoords.back().push_back(whIntermediate);
                    pipeBranchesCellIds.back().push_back(*prevWellResPoint);

                    // Well now we need to step one back to take this cell again, but in the new branch.
                    cIdx--;
                    continue;
                }
            }

            prevWellResPoint = &currentWellResPoint;
        }

        // For the last cell, add the point 0.5 past the center of that cell
        // Remember that prevWellResPoint actually is the last one in this branch.

        if (prevWellResPoint && prevWellResPoint->isCell())
        {
            const RigCell& prevCell =  eclipseCaseData->cellFromWellResultCell(*prevWellResPoint);
            cvf::Vec3d centerLastCell = prevCell.center();
            finishPipeCenterLine(pipeBranchesCLCoords, centerLastCell);
        }
        else if (prevWellResPoint && prevWellResPoint->isPointValid())
        {
            // Continue the line with the same point, just to keep the last Cell ID
            pipeBranchesCLCoords.back().push_back(prevWellResPoint->m_bottomPosition);
        }
        else
        {
            // Remove the ID that is superfluous since we will not add an ending point
            pipeBranchesCellIds.back().pop_back();
        }
    }

    if (useAllCellCenters) addCellCenterPoints(eclipseCaseData, pipeBranchesCLCoords, pipeBranchesCellIds);

    CVF_ASSERT(pipeBranchesCellIds.size() == pipeBranchesCLCoords.size());
    for (size_t i = 0 ; i < pipeBranchesCellIds.size() ; ++i)
    {
        CVF_ASSERT(pipeBranchesCellIds[i].size() == pipeBranchesCLCoords[i].size()-1);
    }
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void RigSimulationWellCenterLineCalculator::addCellCenterPoints(const RigEclipseCaseData* eclipseCaseData, 
                                                                std::vector<std::vector<cvf::Vec3d>> &pipeBranchesCLCoords, 
                                                                std::vector<std::vector<RigWellResultPoint>> &pipeBranchesCellIds)
{
    for ( size_t brIdx = 0; brIdx < pipeBranchesCellIds.size(); brIdx++ )
    {
        const std::vector<RigWellResultPoint>& branchResPoints = pipeBranchesCellIds[brIdx];
        const std::vector<cvf::Vec3d>& branchClPoints = pipeBranchesCLCoords[brIdx];
        
        std::vector<RigWellResultPoint> branchResPointsWithCellCenters;
        std::vector<cvf::Vec3d> branchClPointsWithCellCenters;

        for ( size_t cIdx = 0; cIdx < branchResPoints.size(); cIdx++ )
        {
            branchResPointsWithCellCenters.push_back(branchResPoints[cIdx]);
            branchClPointsWithCellCenters.push_back(branchClPoints[cIdx]);

            if ( branchResPoints[cIdx].isCell() )
            {
                const RigCell& cell = eclipseCaseData->cellFromWellResultCell(branchResPoints[cIdx]);
                cvf::Vec3d center = cell.center();
                branchClPointsWithCellCenters.push_back(center);
                branchResPointsWithCellCenters.push_back(branchResPoints[cIdx]);          
            }
        }
        
        branchClPointsWithCellCenters.push_back(branchClPoints[branchResPoints.size()]);

        pipeBranchesCellIds[brIdx]  = branchResPointsWithCellCenters;
        pipeBranchesCLCoords[brIdx] = branchClPointsWithCellCenters;
    }
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
bool RigSimulationWellCenterLineCalculator::hasAnyValidDataCells(const RigWellResultBranch& branch)
{
    bool hasValidData = false;
    for ( size_t cIdx = 0; cIdx < branch.m_branchResultPoints.size(); ++cIdx )
    {
        if ( branch.m_branchResultPoints[cIdx].isValid() )
        {
            hasValidData = true;
            break;
        }
    }

    return hasValidData;
}

//--------------------------------------------------------------------------------------------------
/// All branches are completed using the point 0.5 past the center of 
/// last cell.
//--------------------------------------------------------------------------------------------------
void RigSimulationWellCenterLineCalculator::finishPipeCenterLine(std::vector< std::vector<cvf::Vec3d> > &pipeBranchesCLCoords, const cvf::Vec3d& lastCellCenter)
{
    CVF_ASSERT(pipeBranchesCLCoords.size());
    CVF_ASSERT(pipeBranchesCLCoords.back().size());

    cvf::Vec3d entryPointLastCell = pipeBranchesCLCoords.back().back();

    pipeBranchesCLCoords.back().push_back(entryPointLastCell + 1.5*(lastCellCenter - entryPointLastCell)  );
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
class BranchSplitter
{
public:
    BranchSplitter(const RigWellResultFrame& awellResultFrame, 
                   const RigEclipseCaseData* eclipseCaseData)
                   :m_eclipseCaseData(eclipseCaseData), m_orgWellResultFrame(awellResultFrame)
    {
        CVF_ASSERT(m_orgWellResultFrame.m_wellResultBranches.size() <= 1);
        m_branchedWell = m_orgWellResultFrame;
        
        buildCellSearchTree();

        buildCellsToNeighborsMap();

        buildUnusedCellsSet();
  
        buildBranchLinesOfContinousNeighbourCells();
  
        
        class DistToEndPoint
        {
        public:
            DistToEndPoint(double adist, std::list< std::pair<bool, std::deque<size_t> > >::iterator aBranchLineIt, bool aToFrontOfBranchLine2)
                : dist(adist), branchLineIt(aBranchLineIt), toFrontOfBranchLine(aToFrontOfBranchLine2)
            {}

            double dist;

            std::list< std::pair<bool, std::deque<size_t> > >::iterator branchLineIt;
            bool toFrontOfBranchLine; 

            bool operator<(const DistToEndPoint& other ) const { return dist < other.dist; } 
        };

        auto cmp = [] (std::list< std::pair<bool, std::deque<size_t> > >::iterator a, 
                       std::list< std::pair<bool, std::deque<size_t> > >::iterator b) 
                       { 
                           return &(*a) < &(*b);
                       };

        std::set< std::list< std::pair<bool, std::deque<size_t> > >::iterator, decltype(cmp) > unusedBranchLineIterators(cmp);

        std::map<int, std::multiset<DistToEndPoint> > resBranchIdxToBranchLineEndPointsDists;

        /// Creating useful lambda functions

        auto buildResBranchToBranchLineEndsDistMap = 
        [&unusedBranchLineIterators, &resBranchIdxToBranchLineEndPointsDists, this](cvf::Vec3d& fromPoint, int resultBranchIndex)
        {
            for ( auto it :unusedBranchLineIterators )
            {
                {
                    double dist = calculateFrontToPointDistance(it->second, fromPoint);
                    resBranchIdxToBranchLineEndPointsDists[resultBranchIndex].insert(DistToEndPoint(dist, it, true));
                }

                {
                    double dist = calculateEndToPointDistance(it->second, fromPoint);
                    resBranchIdxToBranchLineEndPointsDists[resultBranchIndex].insert(DistToEndPoint(dist, it, false));
                }
            }
        };

        auto removeBranchLineFromDistanceMap = 
            [&resBranchIdxToBranchLineEndPointsDists](std::list< std::pair<bool, std::deque<size_t> > >::iterator branchLineToMergeIt)
        {
            for ( auto& brIdx_DistToEndPointSet : resBranchIdxToBranchLineEndPointsDists )
            {
                std::vector<std::multiset<DistToEndPoint>::iterator> iteratorsToErase;
                for ( auto it = brIdx_DistToEndPointSet.second.begin(); it != brIdx_DistToEndPointSet.second.end(); ++it )
                {
                    if ( it->branchLineIt == branchLineToMergeIt )
                    {
                        iteratorsToErase.push_back(it);
                    }
                }

                for (auto itToErase : iteratorsToErase)  brIdx_DistToEndPointSet.second.erase(itToErase);
            }
        };

        // Make the result container ready

        m_branchedWell.m_wellResultBranches.clear();
        m_branchedWell.m_wellResultBranches.push_back(RigWellResultBranch());

        // Build set of unused branch lines

        for (auto brLIt = m_branchLines.begin(); brLIt != m_branchLines.end(); ++brLIt)
        {
            if (brLIt->first) unusedBranchLineIterators.insert(brLIt);
        }

        // Calculate wellhead to branch line ends distances
        {
            const RigCell& whCell = m_eclipseCaseData->cellFromWellResultCell(m_orgWellResultFrame.wellHeadOrStartCell());
            cvf::Vec3d whStartPos = whCell.faceCenter(cvf::StructGridInterface::NEG_K);

            buildResBranchToBranchLineEndsDistMap(whStartPos, -1);
        }

        // Add the branchLine closest to wellhead into the result
        {
            auto closestEndPointIt =  resBranchIdxToBranchLineEndPointsDists[-1].begin();
            addBranchLineToLastWellResultBranch(closestEndPointIt->branchLineIt, closestEndPointIt->toFrontOfBranchLine);
            unusedBranchLineIterators.erase(closestEndPointIt->branchLineIt);
            removeBranchLineFromDistanceMap(closestEndPointIt->branchLineIt);
        }

        // Add the branchLines that starts directly from another branchLine
        {
            for ( auto brLIt = m_branchLines.begin(); brLIt != m_branchLines.end(); ++brLIt )
            {
                if ( !brLIt->first )
                {
                    m_branchedWell.m_wellResultBranches.push_back(RigWellResultBranch());
                    addBranchLineToLastWellResultBranch(brLIt, true);
                }
            }
        }

        while ( !unusedBranchLineIterators.empty() ) 
        {
            //    Calculate distance from end of all currently added result branches to all branch lines

            for (size_t resultBranchIndex = 0; resultBranchIndex < m_branchedWell.m_wellResultBranches.size(); ++resultBranchIndex)
            {
                if (! resBranchIdxToBranchLineEndPointsDists.count((int)resultBranchIndex) 
                    && m_branchedWell.m_wellResultBranches[resultBranchIndex].m_branchResultPoints.size()
                    && m_branchedWell.m_wellResultBranches[resultBranchIndex].m_branchResultPoints.back().isCell())
                {
                    const RigCell& whCell = eclipseCaseData->cellFromWellResultCell(m_branchedWell.m_wellResultBranches[resultBranchIndex].m_branchResultPoints.back());
                    cvf::Vec3d branchEndPoint = whCell.center();

                    buildResBranchToBranchLineEndsDistMap(branchEndPoint, (int)resultBranchIndex);
                }
            }

            // Find the result branch to grow, by finding the one with the closest distance to a branchLine

            int minDistanceBrIdx = -1;
            DistToEndPoint closestEndPoint(HUGE_VAL,m_branchLines.end(), true);

            for (auto& brIdx_DistToEndPointSet : resBranchIdxToBranchLineEndPointsDists)
            {
                if (brIdx_DistToEndPointSet.second.begin()->dist < closestEndPoint.dist)
                {
                    minDistanceBrIdx =  brIdx_DistToEndPointSet.first;
                    closestEndPoint = *( brIdx_DistToEndPointSet.second.begin());
                }
            }

            // Grow the result branch with the branchLine

            auto closestEndPointIt =  resBranchIdxToBranchLineEndPointsDists[minDistanceBrIdx].begin();
            auto branchLineToAddIt = closestEndPointIt->branchLineIt;
            addBranchLineToWellResultBranch(minDistanceBrIdx, branchLineToAddIt, closestEndPointIt->toFrontOfBranchLine);

            // Remove the branchLine from the control datastructures

            unusedBranchLineIterators.erase(branchLineToAddIt);
            resBranchIdxToBranchLineEndPointsDists.erase(minDistanceBrIdx);
            removeBranchLineFromDistanceMap(branchLineToAddIt);
        } 
    }

    //--------------------------------------------------------------------------------------------------
    /// 
    //--------------------------------------------------------------------------------------------------
    RigWellResultFrame splittedWellResultFrame()
    {
        return m_branchedWell;
    }

private:

    //--------------------------------------------------------------------------------------------------
    /// 
    //--------------------------------------------------------------------------------------------------
    void addBranchLineToLastWellResultBranch(std::list< std::pair<bool, std::deque<size_t> > >::iterator branchLineIt, bool startAtFront)
    {
        addBranchLineToWellResultBranch( static_cast<int>(m_branchedWell.m_wellResultBranches.size()) - 1, branchLineIt, startAtFront);
    }

    //--------------------------------------------------------------------------------------------------
    /// branchIdx == -1 creates a new branch
    //--------------------------------------------------------------------------------------------------
    void addBranchLineToWellResultBranch(int branchIdx, std::list< std::pair<bool, std::deque<size_t> > >::iterator branchLineIt, bool startAtFront)
    {
        if (branchIdx < 0)
        {
            m_branchedWell.m_wellResultBranches.push_back(RigWellResultBranch());
            branchIdx = static_cast<int>( m_branchedWell.m_wellResultBranches.size()) - 1;
            RigWellResultPoint wellHeadAsPoint;
            const RigCell& whCell = m_eclipseCaseData->cellFromWellResultCell(m_orgWellResultFrame.wellHeadOrStartCell());
            cvf::Vec3d whStartPos = whCell.faceCenter(cvf::StructGridInterface::NEG_K);

            wellHeadAsPoint.m_bottomPosition = whStartPos;
            m_branchedWell.m_wellResultBranches[branchIdx].m_branchResultPoints.push_back(wellHeadAsPoint);
        }

        RigWellResultBranch& currentBranch = m_branchedWell.m_wellResultBranches[branchIdx];  
        std::deque<size_t> wellCellIndices = branchLineIt->second;
        if (!startAtFront) std::reverse(wellCellIndices.begin(), wellCellIndices.end());

        const std::vector<RigWellResultPoint>& orgWellResultPoints = m_orgWellResultFrame.m_wellResultBranches[0].m_branchResultPoints;

        #if 1
        if ( wellCellIndices.size() )
        {
            if ( !branchLineIt->first ) // Is real branch, with first cell as cell *before* entry point on main branch
            {
                RigWellResultPoint branchStartAsResultPoint;
                const RigCell& branchStartCell = m_eclipseCaseData->cellFromWellResultCell(orgWellResultPoints[wellCellIndices.front()]);
                cvf::Vec3d branchStartPos = branchStartCell.center();

                if ( wellCellIndices.size() > 1 )
                {
                    // Use the shared face between the cell before, and the branching cell as start point for the branch, to make the pipe "whole"

                    cvf::StructGridInterface::FaceType sharedFace = cvf::StructGridInterface::NO_FACE;
                    m_eclipseCaseData->findSharedSourceFace(sharedFace, orgWellResultPoints[wellCellIndices[0]], orgWellResultPoints[wellCellIndices[1]]);
                    if ( sharedFace != cvf::StructGridInterface::NO_FACE )
                    {
                        branchStartPos = branchStartCell.faceCenter(sharedFace);
                    }
                }

                branchStartAsResultPoint.m_bottomPosition = branchStartPos;
                m_branchedWell.m_wellResultBranches[branchIdx].m_branchResultPoints.push_back(branchStartAsResultPoint);
            }
            else
            {
                currentBranch.m_branchResultPoints.push_back(orgWellResultPoints[wellCellIndices.front()]);
            }

            for ( size_t i = 1; i < wellCellIndices.size(); ++i )
            {
                size_t wcIdx = wellCellIndices[i];
                currentBranch.m_branchResultPoints.push_back(orgWellResultPoints[wcIdx]);
            }
        }
        #else
        for (size_t wcIdx : wellCellIndices)
        {
            currentBranch.m_branchResultPoints.push_back(orgWellResultPoints[wcIdx]);
        }
        #endif
    }

    //--------------------------------------------------------------------------------------------------
    /// 
    //--------------------------------------------------------------------------------------------------
    void buildCellSearchTree()
    {
        const std::vector<RigWellResultPoint>& orgWellResultPoints = m_orgWellResultFrame.m_wellResultBranches[0].m_branchResultPoints;
        size_t cellCount = orgWellResultPoints.size();

        m_cellBoundingBoxes.resize(cellCount);

        const std::vector<cvf::Vec3d>& nodes = m_eclipseCaseData->mainGrid()->nodes();

        for ( size_t cIdx = 0; cIdx < cellCount; ++cIdx )
        {
            if ( !orgWellResultPoints[cIdx].isCell() ) continue;
            const RigCell& wellCell = m_eclipseCaseData->cellFromWellResultCell(orgWellResultPoints[cIdx]);

            if ( wellCell.isInvalid() ) continue;

            const std::array<size_t, 8>& cellIndices = wellCell.cornerIndices();

            cvf::BoundingBox& cellBB = m_cellBoundingBoxes[cIdx];
            cellBB.add(nodes[cellIndices[0]]);
            cellBB.add(nodes[cellIndices[1]]);
            cellBB.add(nodes[cellIndices[2]]);
            cellBB.add(nodes[cellIndices[3]]);
            cellBB.add(nodes[cellIndices[4]]);
            cellBB.add(nodes[cellIndices[5]]);
            cellBB.add(nodes[cellIndices[6]]);
            cellBB.add(nodes[cellIndices[7]]);
        }

        m_cellSearchTree.buildTreeFromBoundingBoxes(m_cellBoundingBoxes, nullptr);
    }

    //--------------------------------------------------------------------------------------------------
    /// 
    //--------------------------------------------------------------------------------------------------
    void buildCellsToNeighborsMap()
    {
        const std::vector<RigWellResultPoint>& orgWellResultPoints = m_orgWellResultFrame.m_wellResultBranches[0].m_branchResultPoints;
        size_t cellCount = orgWellResultPoints.size();
        const std::vector<cvf::Vec3d>& nodes = m_eclipseCaseData->mainGrid()->nodes();
        double cellSizeI, cellSizeJ, cellSizeK; 
        m_eclipseCaseData->mainGrid()->characteristicCellSizes(&cellSizeI, &cellSizeJ, &cellSizeK);
        double stdArea = cellSizeK*(cellSizeI+cellSizeJ)*0.5;

        for ( size_t cIdx = 0; cIdx < cellCount; ++ cIdx )
        {
            std::vector<size_t> closeCells;
            m_cellSearchTree.findIntersections(m_cellBoundingBoxes[cIdx], &closeCells);

            const RigCell& c1 = m_eclipseCaseData->cellFromWellResultCell(orgWellResultPoints[cIdx]);
            
            m_cellsWithNeighbors[cIdx]; // Add an empty set for this cell, in case we have no neighbors

            for ( size_t idxToCloseCell : closeCells )
            {
                if ( idxToCloseCell != cIdx && m_cellsWithNeighbors[cIdx].count(idxToCloseCell) == 0 )
                {
                    const RigCell& c2 = m_eclipseCaseData->cellFromWellResultCell(orgWellResultPoints[idxToCloseCell]);
                    std::vector<size_t> poygonIndices; 
                    std::vector<cvf::Vec3d> intersections;

                    auto contactFace = RigNNCData::calculateCellFaceOverlap(c1, c2, *(m_eclipseCaseData->mainGrid()), &poygonIndices, &intersections);

                    if ( contactFace != cvf::StructGridInterface::NO_FACE )
                    {
                        std::vector<cvf::Vec3d> realPolygon;

                        for ( size_t pIdx = 0; pIdx < poygonIndices.size(); ++pIdx )
                        {
                            if ( poygonIndices[pIdx] < nodes.size() )
                                realPolygon.push_back(nodes[poygonIndices[pIdx]]);
                            else
                                realPolygon.push_back(intersections[poygonIndices[pIdx] - nodes.size()]);
                        }

                        // Polygon area vector

                        cvf::Vec3d area = cvf::GeometryTools::polygonAreaNormal3D(realPolygon);

                        if (area.length() < 1e-3 * stdArea) continue;

                        m_cellsWithNeighbors[cIdx].insert(idxToCloseCell);
                        m_cellsWithNeighbors[idxToCloseCell].insert(cIdx);
                    }
                }
            }
        }
    }

    //--------------------------------------------------------------------------------------------------
    /// 
    //--------------------------------------------------------------------------------------------------
    void buildUnusedCellsSet()
    {
        const std::vector<RigWellResultPoint>& orgWellResultPoints = m_orgWellResultFrame.m_wellResultBranches[0].m_branchResultPoints;
        size_t cellCount = orgWellResultPoints.size();

        for ( size_t i = 0; i < cellCount; ++i )
        {
            if ( orgWellResultPoints[i].isCell() ) m_unusedWellCellIndices.insert(i);
        }
    }

    //--------------------------------------------------------------------------------------------------
    /// 
    //--------------------------------------------------------------------------------------------------
    void buildBranchLinesOfContinousNeighbourCells()
    {
        for ( auto& cellWithNeighborsPair : m_cellsWithNeighbors )
        {
            auto it = m_unusedWellCellIndices.find(cellWithNeighborsPair.first);
            if ( it !=  m_unusedWellCellIndices.end() )
            {
                m_unusedWellCellIndices.erase(it);

                // Create a new branchline containing the cell itself.
                m_branchLines.push_back(std::make_pair(true, std::deque<size_t>()));
                auto currentBranchLineIt = std::prev(m_branchLines.end());
                auto& branchList = currentBranchLineIt->second;

                branchList.push_back(cellWithNeighborsPair.first);

                unsigned endToGrow = 0; // 0 end, 1 front, > 1 new branch

                size_t neighbour = findBestNeighbor(cellWithNeighborsPair.first, cellWithNeighborsPair.second);
                while (neighbour != cvf::UNDEFINED_SIZE_T)
                {
                    m_unusedWellCellIndices.erase(neighbour);
                    if ( endToGrow == 0 )
                    {
                        branchList.push_back(neighbour);
                        growBranchListEnd(currentBranchLineIt);
                        endToGrow++;
                    }
                    else if ( endToGrow == 1 )
                    {
                        branchList.push_front(neighbour);
                        growBranchListFront(currentBranchLineIt);
                        endToGrow++;

                    }
                    else // if ( endToGrow > 1 )
                    {
                        m_branchLines.push_back(std::make_pair(false, std::deque<size_t>{ branchList.front(), cellWithNeighborsPair.first, neighbour } ));
                        auto newBranchLineIt = std::prev(m_branchLines.end());
                        growBranchListEnd(newBranchLineIt);
                        if (newBranchLineIt->second.size() == 3)
                        {
                            // No real contribution from the branch.
                            // Put the cell into main stem
                            // Todo
                        }
                    }

                    neighbour = findBestNeighbor(cellWithNeighborsPair.first, cellWithNeighborsPair.second);
                }

            }
        }
    }

    //--------------------------------------------------------------------------------------------------
    /// 
    //--------------------------------------------------------------------------------------------------
    size_t findBestNeighbor(size_t cell, std::set<size_t> neighbors)
    {
        size_t posKNeighbor = cvf::UNDEFINED_SIZE_T;
        size_t firstUnused = cvf::UNDEFINED_SIZE_T;
        const std::vector<RigWellResultPoint>& orgWellResultPoints = m_orgWellResultFrame.m_wellResultBranches[0].m_branchResultPoints;

        for ( size_t neighbor : neighbors)
        {
            if ( m_unusedWellCellIndices.count(neighbor) )
            {

                cvf::StructGridInterface::FaceType sharedFace;
                m_eclipseCaseData->findSharedSourceFace(sharedFace, orgWellResultPoints[cell], orgWellResultPoints[neighbor]);
                if ( sharedFace == cvf::StructGridInterface::NEG_K ) return neighbor;
                if ( sharedFace == cvf::StructGridInterface::POS_K ) posKNeighbor = neighbor;
                else if (firstUnused == cvf::UNDEFINED_SIZE_T)
                {
                    firstUnused = neighbor;
                }
            }
        }

        if (posKNeighbor != cvf::UNDEFINED_SIZE_T)
        {
            return posKNeighbor;
        }
        else 
        {
            return firstUnused;
        }
    }

    //--------------------------------------------------------------------------------------------------
    /// 
    //--------------------------------------------------------------------------------------------------
    void growBranchListEnd( std::list< std::pair<bool, std::deque<size_t> > >::iterator  branchListIt)
    {
        std::deque<size_t>& branchList = branchListIt->second;

        CVF_ASSERT(branchList.size());

        size_t startCell = branchList.back();
        size_t prevCell = cvf::UNDEFINED_SIZE_T;
        size_t startCellPosInStem = branchList.size()-1;

        if (branchList.size() > 1) prevCell = branchList[branchList.size()-2];
        
        const auto& neighbors = m_cellsWithNeighbors[startCell];

        size_t nb = findBestNeighbor(startCell, neighbors);
        if (nb != cvf::UNDEFINED_SIZE_T)
        {
            branchList.push_back(nb);
            m_unusedWellCellIndices.erase(nb);
            growBranchListEnd(branchListIt);
        }

        startAndGrowSeparateBranchesFromRestOfNeighbors(startCell, prevCell, neighbors, branchList, startCellPosInStem, true);
    }

    //--------------------------------------------------------------------------------------------------
    /// 
    //--------------------------------------------------------------------------------------------------
    void startAndGrowSeparateBranchesFromRestOfNeighbors(size_t startCell, size_t prevCell, const std::set<size_t>& neighbors, std::deque<size_t> mainStem, size_t branchPosInMainStem, bool stemEndIsGrowing)
    {
        size_t nb = findBestNeighbor(startCell, neighbors);
        while ( nb != cvf::UNDEFINED_SIZE_T )
        {
            if ( prevCell == cvf::UNDEFINED_SIZE_T )
            {
                m_branchLines.push_back(std::make_pair(false, std::deque<size_t>{startCell, nb}));
            }
            else
            {
                m_branchLines.push_back(std::make_pair(false, std::deque<size_t>{prevCell, startCell, nb}));
            }

            m_unusedWellCellIndices.erase(nb);

            auto lastBranchIt = std::prev(m_branchLines.end());
            size_t separateBranchStartSize = lastBranchIt->second.size();
            growBranchListEnd(lastBranchIt);

            if (lastBranchIt->second.size() == separateBranchStartSize)
            {
                // No use in this branch.
                // put cell into main stem instead
                if (stemEndIsGrowing)
                    mainStem.insert(mainStem.begin() + branchPosInMainStem, nb);
                else
                    mainStem.insert(mainStem.end() - branchPosInMainStem, nb);
                m_branchLines.erase(lastBranchIt);
            }

            nb = findBestNeighbor(startCell, neighbors);
        }
    }

    //--------------------------------------------------------------------------------------------------
    /// 
    //--------------------------------------------------------------------------------------------------
    void growBranchListFront( std::list< std::pair<bool, std::deque<size_t> > >::iterator  branchListIt)
    {
        std::deque<size_t>& branchList = branchListIt->second;

        CVF_ASSERT(branchList.size());

        size_t startCell = branchList.front();
        size_t prevCell = cvf::UNDEFINED_SIZE_T;
        size_t startCellPosInStem = branchList.size()-1;

        if (branchList.size() > 1) prevCell = branchList[1];

        const auto& neighbors = m_cellsWithNeighbors[startCell];

        size_t nb = findBestNeighbor(startCell, neighbors);
        if (nb != cvf::UNDEFINED_SIZE_T)
        {
            branchList.push_front(nb);
            m_unusedWellCellIndices.erase(nb);
            growBranchListFront(branchListIt);
        }

        startAndGrowSeparateBranchesFromRestOfNeighbors(startCell, prevCell, neighbors, branchList, startCellPosInStem, false);
    }

    //--------------------------------------------------------------------------------------------------
    /// 
    //--------------------------------------------------------------------------------------------------
    double calculateFrontToPointDistance(const std::deque<size_t>& second, const cvf::Vec3d& point)
    {
        // Todo, more fancy virtual curvature based distance using an estimated direction from the branch-end

        return calculateWellCellToPointDistance(second.front(), point);
    }

    //--------------------------------------------------------------------------------------------------
    /// 
    //--------------------------------------------------------------------------------------------------
    double calculateEndToPointDistance(const std::deque<size_t>& second, const cvf::Vec3d& point)
    {
        // Todo, more fancy virtual curvature based distance using an estimated direction from the branch-end

        return calculateWellCellToPointDistance(second.back(), point);
    }

    //--------------------------------------------------------------------------------------------------
    /// 
    //--------------------------------------------------------------------------------------------------
    double calculateWellCellToPointDistance(size_t wellCellIdx, const cvf::Vec3d& point)
    {
        const std::vector<RigWellResultPoint>& orgWellResultPoints = m_orgWellResultFrame.m_wellResultBranches[0].m_branchResultPoints;

        const RigCell& c = m_eclipseCaseData->cellFromWellResultCell(orgWellResultPoints[wellCellIdx]);

        cvf::Vec3d cellCenter = c.center();

        return (point-cellCenter).length();
    }

private:
    // The bool tells if this can be expanded in the front,
    // Set to false when the branchLine starts from a branching cell (cell with more than two neighbors)
    std::list< std::pair<bool, std::deque<size_t> > > m_branchLines;

    std::vector<cvf::BoundingBox> m_cellBoundingBoxes;
    cvf::BoundingBoxTree m_cellSearchTree;

    std::map<size_t, std::set<size_t> > m_cellsWithNeighbors;
    std::set<size_t> m_unusedWellCellIndices;

    RigWellResultFrame m_branchedWell;

    const RigEclipseCaseData* m_eclipseCaseData;
    const RigWellResultFrame& m_orgWellResultFrame;
};

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
RigWellResultFrame RigSimulationWellCenterLineCalculator::splitIntoBranches(const RigWellResultFrame& wellResultFrame, 
                                                                            const RigEclipseCaseData* eclipseCaseData)
{
    BranchSplitter splitter(wellResultFrame, eclipseCaseData);

    return splitter.splittedWellResultFrame();
}