mirror of
https://github.com/OPM/ResInsight.git
synced 2025-01-09 23:53:04 -06:00
759 lines
27 KiB
C++
759 lines
27 KiB
C++
/////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Copyright (C) 2011- Statoil ASA
|
|
// Copyright (C) 2013- Ceetron Solutions AS
|
|
// Copyright (C) 2011-2012 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 "RigMainGrid.h"
|
|
|
|
#include "RiaDefines.h"
|
|
#include "RiaLogging.h"
|
|
#include "RigActiveCellInfo.h"
|
|
#include "RigHexIntersectionTools.h"
|
|
|
|
#include "cvfAssert.h"
|
|
#include "cvfBoundingBoxTree.h"
|
|
|
|
RigMainGrid::RigMainGrid()
|
|
: RigGridBase(this)
|
|
{
|
|
m_displayModelOffset = cvf::Vec3d::ZERO;
|
|
|
|
m_gridIndex = 0;
|
|
m_gridId = 0;
|
|
m_gridIdToIndexMapping.push_back(0);
|
|
|
|
m_flipXAxis = false;
|
|
m_flipYAxis = false;
|
|
}
|
|
|
|
RigMainGrid::~RigMainGrid() {}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::vector<cvf::Vec3d>& RigMainGrid::nodes()
|
|
{
|
|
return m_nodes;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
const std::vector<cvf::Vec3d>& RigMainGrid::nodes() const
|
|
{
|
|
return m_nodes;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::vector<RigCell>& RigMainGrid::globalCellArray()
|
|
{
|
|
return m_cells;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
const std::vector<RigCell>& RigMainGrid::globalCellArray() const
|
|
{
|
|
return m_cells;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RigGridBase* RigMainGrid::gridAndGridLocalIdxFromGlobalCellIdx(size_t globalCellIdx, size_t* gridLocalCellIdx)
|
|
{
|
|
CVF_ASSERT(globalCellIdx < m_cells.size());
|
|
|
|
RigCell& cell = m_cells[globalCellIdx];
|
|
RigGridBase* hostGrid = cell.hostGrid();
|
|
CVF_ASSERT(hostGrid);
|
|
|
|
*gridLocalCellIdx = cell.gridLocalCellIndex();
|
|
return hostGrid;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
const RigGridBase* RigMainGrid::gridAndGridLocalIdxFromGlobalCellIdx(size_t globalCellIdx, size_t* gridLocalCellIdx) const
|
|
{
|
|
CVF_ASSERT(globalCellIdx < m_cells.size());
|
|
|
|
const RigCell& cell = m_cells[globalCellIdx];
|
|
const RigGridBase* hostGrid = cell.hostGrid();
|
|
CVF_ASSERT(hostGrid);
|
|
|
|
*gridLocalCellIdx = cell.gridLocalCellIndex();
|
|
return hostGrid;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
const RigCell& RigMainGrid::cellByGridAndGridLocalCellIdx(size_t gridIdx, size_t gridLocalCellIdx) const
|
|
{
|
|
return gridByIndex(gridIdx)->cell(gridLocalCellIdx);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
size_t RigMainGrid::reservoirCellIndexByGridAndGridLocalCellIndex(size_t gridIdx, size_t gridLocalCellIdx) const
|
|
{
|
|
return gridByIndex(gridIdx)->reservoirCellIndex(gridLocalCellIdx);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
size_t RigMainGrid::findReservoirCellIndexFromPoint(const cvf::Vec3d& point) const
|
|
{
|
|
size_t cellContainingPoint = cvf::UNDEFINED_SIZE_T;
|
|
|
|
cvf::BoundingBox pointBBox;
|
|
pointBBox.add(point);
|
|
|
|
std::vector<size_t> cellIndices;
|
|
m_mainGrid->findIntersectingCells(pointBBox, &cellIndices);
|
|
|
|
cvf::Vec3d hexCorners[8];
|
|
for (size_t cellIndex : cellIndices)
|
|
{
|
|
m_mainGrid->cellCornerVertices(cellIndex, hexCorners);
|
|
|
|
if (RigHexIntersectionTools::isPointInCell(point, hexCorners))
|
|
{
|
|
cellContainingPoint = cellIndex;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return cellContainingPoint;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::vector<size_t> RigMainGrid::findAllReservoirCellIndicesMatching2dPoint(const cvf::Vec2d& point2d) const
|
|
{
|
|
cvf::BoundingBox gridBoundingVox = boundingBox();
|
|
cvf::Vec3d highestPoint(point2d, gridBoundingVox.max().z());
|
|
cvf::Vec3d lowestPoint(point2d, gridBoundingVox.min().z());
|
|
|
|
cvf::BoundingBox rayBBox;
|
|
rayBBox.add(highestPoint);
|
|
rayBBox.add(lowestPoint);
|
|
|
|
std::vector<size_t> cellIndices;
|
|
m_mainGrid->findIntersectingCells(rayBBox, &cellIndices);
|
|
|
|
cvf::Vec3d hexCorners[8];
|
|
for (size_t cellIndex : cellIndices)
|
|
{
|
|
m_mainGrid->cellCornerVertices(cellIndex, hexCorners);
|
|
|
|
if (RigHexIntersectionTools::lineIntersectsHexCell(highestPoint, lowestPoint, hexCorners))
|
|
{
|
|
cellIndices.push_back(cellIndex);
|
|
}
|
|
}
|
|
|
|
return cellIndices;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RigMainGrid::addLocalGrid(RigLocalGrid* localGrid)
|
|
{
|
|
CVF_ASSERT(localGrid && localGrid->gridId() != cvf::UNDEFINED_INT); // The grid ID must be set.
|
|
CVF_ASSERT(localGrid->gridId() >= 0); // We cant handle negative ID's if they exist.
|
|
|
|
m_localGrids.push_back(localGrid);
|
|
localGrid->setGridIndex(m_localGrids.size()); // Maingrid itself has grid index 0
|
|
|
|
if (m_gridIdToIndexMapping.size() <= static_cast<size_t>(localGrid->gridId()))
|
|
{
|
|
m_gridIdToIndexMapping.resize(localGrid->gridId() + 1, cvf::UNDEFINED_SIZE_T);
|
|
}
|
|
|
|
m_gridIdToIndexMapping[localGrid->gridId()] = localGrid->gridIndex();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
size_t RigMainGrid::gridCountOnFile() const
|
|
{
|
|
size_t gridCount = 1;
|
|
|
|
for (const auto& grid : m_localGrids)
|
|
{
|
|
if (!grid->isTempGrid())
|
|
{
|
|
gridCount++;
|
|
}
|
|
}
|
|
|
|
return gridCount;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
size_t RigMainGrid::gridCount() const
|
|
{
|
|
return m_localGrids.size() + 1;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RigMainGrid::initAllSubGridsParentGridPointer()
|
|
{
|
|
if (m_localGrids.size() && m_localGrids[0]->parentGrid() == nullptr)
|
|
{
|
|
initSubGridParentPointer();
|
|
size_t i;
|
|
for (i = 0; i < m_localGrids.size(); ++i)
|
|
{
|
|
m_localGrids[i]->initSubGridParentPointer();
|
|
}
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RigMainGrid::initAllSubCellsMainGridCellIndex()
|
|
{
|
|
initSubCellsMainGridCellIndex();
|
|
size_t i;
|
|
for (i = 0; i < m_localGrids.size(); ++i)
|
|
{
|
|
m_localGrids[i]->initSubCellsMainGridCellIndex();
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
cvf::Vec3d RigMainGrid::displayModelOffset() const
|
|
{
|
|
return m_displayModelOffset;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RigMainGrid::setDisplayModelOffset(cvf::Vec3d offset)
|
|
{
|
|
m_displayModelOffset = offset;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
/// Initialize pointers from grid to parent grid
|
|
/// Compute cell ranges for active and valid cells
|
|
/// Compute bounding box in world coordinates based on node coordinates
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RigMainGrid::computeCachedData()
|
|
{
|
|
initAllSubGridsParentGridPointer();
|
|
initAllSubCellsMainGridCellIndex();
|
|
|
|
m_cellSearchTree = nullptr;
|
|
buildCellSearchTree();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
/// Returns the grid with index \a localGridIndex. Main Grid itself has index 0. First LGR starts on 1
|
|
//--------------------------------------------------------------------------------------------------
|
|
RigGridBase* RigMainGrid::gridByIndex(size_t localGridIndex)
|
|
{
|
|
if (localGridIndex == 0) return this;
|
|
CVF_ASSERT(localGridIndex - 1 < m_localGrids.size());
|
|
return m_localGrids[localGridIndex - 1].p();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
/// Returns the grid with index \a localGridIndex. Main Grid itself has index 0. First LGR starts on 1
|
|
//--------------------------------------------------------------------------------------------------
|
|
const RigGridBase* RigMainGrid::gridByIndex(size_t localGridIndex) const
|
|
{
|
|
if (localGridIndex == 0) return this;
|
|
CVF_ASSERT(localGridIndex - 1 < m_localGrids.size());
|
|
return m_localGrids[localGridIndex - 1].p();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RigMainGrid::setFlipAxis(bool flipXAxis, bool flipYAxis)
|
|
{
|
|
bool needFlipX = false;
|
|
bool needFlipY = false;
|
|
|
|
if (m_flipXAxis != flipXAxis)
|
|
{
|
|
needFlipX = true;
|
|
}
|
|
|
|
if (m_flipYAxis != flipYAxis)
|
|
{
|
|
needFlipY = true;
|
|
}
|
|
|
|
if (needFlipX || needFlipY)
|
|
{
|
|
for (size_t i = 0; i < m_nodes.size(); i++)
|
|
{
|
|
if (needFlipX)
|
|
{
|
|
m_nodes[i].x() *= -1.0;
|
|
}
|
|
|
|
if (needFlipY)
|
|
{
|
|
m_nodes[i].y() *= -1.0;
|
|
}
|
|
}
|
|
|
|
m_flipXAxis = flipXAxis;
|
|
m_flipYAxis = flipYAxis;
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RigGridBase* RigMainGrid::gridById(int localGridId)
|
|
{
|
|
CVF_ASSERT(localGridId >= 0 && static_cast<size_t>(localGridId) < m_gridIdToIndexMapping.size());
|
|
return this->gridByIndex(m_gridIdToIndexMapping[localGridId]);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
size_t RigMainGrid::totalTemporaryGridCellCount() const
|
|
{
|
|
size_t cellCount = 0;
|
|
|
|
for (const auto& grid : m_localGrids)
|
|
{
|
|
if (grid->isTempGrid())
|
|
{
|
|
cellCount += grid->cellCount();
|
|
}
|
|
}
|
|
|
|
return cellCount;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RigNNCData* RigMainGrid::nncData()
|
|
{
|
|
if (m_nncData.isNull())
|
|
{
|
|
m_nncData = new RigNNCData;
|
|
}
|
|
|
|
return m_nncData.p();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RigMainGrid::setFaults(const cvf::Collection<RigFault>& faults)
|
|
{
|
|
m_faults = faults;
|
|
|
|
#pragma omp parallel for
|
|
for (int i = 0; i < static_cast<int>(m_faults.size()); i++)
|
|
{
|
|
m_faults[i]->computeFaultFacesFromCellRanges(this->mainGrid());
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
const cvf::Collection<RigFault>& RigMainGrid::faults()
|
|
{
|
|
return m_faults;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
bool RigMainGrid::hasFaultWithName(const QString& name) const
|
|
{
|
|
for (auto fault : m_faults)
|
|
{
|
|
if (fault->name() == name)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RigMainGrid::calculateFaults(const RigActiveCellInfo* activeCellInfo, bool forceCalculation)
|
|
{
|
|
if (!forceCalculation && hasFaultWithName(RiaDefines::undefinedGridFaultName()) &&
|
|
hasFaultWithName(RiaDefines::undefinedGridFaultWithInactiveName()))
|
|
{
|
|
// RiaLogging::debug(QString("Calculate faults already run for grid."));
|
|
|
|
return;
|
|
}
|
|
|
|
m_faults.clear();
|
|
|
|
m_faultsPrCellAcc = new RigFaultsPrCellAccumulator(m_cells.size());
|
|
|
|
// Spread fault idx'es on the cells from the faults
|
|
for (size_t fIdx = 0; fIdx < m_faults.size(); ++fIdx)
|
|
{
|
|
m_faults[fIdx]->accumulateFaultsPrCell(m_faultsPrCellAcc.p(), static_cast<int>(fIdx));
|
|
}
|
|
|
|
// Find the geometrical faults that is in addition: Has no user defined (eclipse) fault assigned.
|
|
// Separate the grid faults that has an inactive cell as member
|
|
|
|
RigFault* unNamedFault = new RigFault;
|
|
unNamedFault->setName(RiaDefines::undefinedGridFaultName());
|
|
int unNamedFaultIdx = static_cast<int>(m_faults.size());
|
|
m_faults.push_back(unNamedFault);
|
|
|
|
RigFault* unNamedFaultWithInactive = new RigFault;
|
|
unNamedFaultWithInactive->setName(RiaDefines::undefinedGridFaultWithInactiveName());
|
|
int unNamedFaultWithInactiveIdx = static_cast<int>(m_faults.size());
|
|
m_faults.push_back(unNamedFaultWithInactive);
|
|
|
|
const std::vector<cvf::Vec3d>& vxs = m_mainGrid->nodes();
|
|
|
|
for (int gcIdx = 0; gcIdx < static_cast<int>(m_cells.size()); ++gcIdx)
|
|
{
|
|
if (m_cells[gcIdx].isInvalid())
|
|
{
|
|
continue;
|
|
}
|
|
|
|
size_t neighborReservoirCellIdx;
|
|
size_t neighborGridCellIdx;
|
|
size_t i = 0;
|
|
size_t j = 0;
|
|
size_t k = 0;
|
|
|
|
RigGridBase* hostGrid = nullptr;
|
|
bool firstNO_FAULTFaceForCell = true;
|
|
bool isCellActive = true;
|
|
|
|
char upperLimitForFaceType = cvf::StructGridInterface::FaceType::POS_K;
|
|
|
|
// Compare only I and J faces
|
|
for (char faceIdx = 0; faceIdx < upperLimitForFaceType; ++faceIdx)
|
|
{
|
|
cvf::StructGridInterface::FaceType face = cvf::StructGridInterface::FaceType(faceIdx);
|
|
|
|
// For faces that has no used defined Fault assigned:
|
|
|
|
if (m_faultsPrCellAcc->faultIdx(gcIdx, face) == RigFaultsPrCellAccumulator::NO_FAULT)
|
|
{
|
|
// Find neighbor cell
|
|
if (firstNO_FAULTFaceForCell) // To avoid doing this for every face, and only when detecting a NO_FAULT
|
|
{
|
|
size_t gridLocalCellIndex;
|
|
hostGrid = this->gridAndGridLocalIdxFromGlobalCellIdx(gcIdx, &gridLocalCellIndex);
|
|
|
|
hostGrid->ijkFromCellIndex(gridLocalCellIndex, &i, &j, &k);
|
|
isCellActive = activeCellInfo->isActive(gcIdx);
|
|
|
|
firstNO_FAULTFaceForCell = false;
|
|
}
|
|
|
|
if (!hostGrid->cellIJKNeighbor(i, j, k, face, &neighborGridCellIdx))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
neighborReservoirCellIdx = hostGrid->reservoirCellIndex(neighborGridCellIdx);
|
|
if (m_cells[neighborReservoirCellIdx].isInvalid())
|
|
{
|
|
continue;
|
|
}
|
|
|
|
bool isNeighborCellActive = activeCellInfo->isActive(neighborReservoirCellIdx);
|
|
|
|
double tolerance = 1e-6;
|
|
|
|
std::array<size_t, 4> faceIdxs;
|
|
m_cells[gcIdx].faceIndices(face, &faceIdxs);
|
|
std::array<size_t, 4> nbFaceIdxs;
|
|
m_cells[neighborReservoirCellIdx].faceIndices(StructGridInterface::oppositeFace(face), &nbFaceIdxs);
|
|
|
|
bool sharedFaceVertices = true;
|
|
if (sharedFaceVertices && vxs[faceIdxs[0]].pointDistance(vxs[nbFaceIdxs[0]]) > tolerance)
|
|
sharedFaceVertices = false;
|
|
if (sharedFaceVertices && vxs[faceIdxs[1]].pointDistance(vxs[nbFaceIdxs[3]]) > tolerance)
|
|
sharedFaceVertices = false;
|
|
if (sharedFaceVertices && vxs[faceIdxs[2]].pointDistance(vxs[nbFaceIdxs[2]]) > tolerance)
|
|
sharedFaceVertices = false;
|
|
if (sharedFaceVertices && vxs[faceIdxs[3]].pointDistance(vxs[nbFaceIdxs[1]]) > tolerance)
|
|
sharedFaceVertices = false;
|
|
|
|
if (sharedFaceVertices)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// To avoid doing this calculation for the opposite face
|
|
int faultIdx = unNamedFaultIdx;
|
|
if (!(isCellActive && isNeighborCellActive)) faultIdx = unNamedFaultWithInactiveIdx;
|
|
|
|
m_faultsPrCellAcc->setFaultIdx(gcIdx, face, faultIdx);
|
|
m_faultsPrCellAcc->setFaultIdx(neighborReservoirCellIdx, StructGridInterface::oppositeFace(face), faultIdx);
|
|
|
|
// Add as fault face only if the grid index is less than the neighbors
|
|
|
|
if (static_cast<size_t>(gcIdx) < neighborReservoirCellIdx)
|
|
{
|
|
RigFault::FaultFace ff(gcIdx, cvf::StructGridInterface::FaceType(faceIdx), neighborReservoirCellIdx);
|
|
if (isCellActive && isNeighborCellActive)
|
|
{
|
|
unNamedFault->faultFaces().push_back(ff);
|
|
}
|
|
else
|
|
{
|
|
unNamedFaultWithInactive->faultFaces().push_back(ff);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CVF_FAIL_MSG(
|
|
"Found fault with global neighbor index less than the native index. "); // Should never occur. because we
|
|
// flag the opposite face in the
|
|
// faultsPrCellAcc
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
distributeNNCsToFaults();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RigMainGrid::distributeNNCsToFaults()
|
|
{
|
|
const std::vector<RigConnection>& nncs = this->nncData()->connections();
|
|
for (size_t nncIdx = 0; nncIdx < nncs.size(); ++nncIdx)
|
|
{
|
|
// Find the fault for each side of the nnc
|
|
const RigConnection& conn = nncs[nncIdx];
|
|
int fIdx1 = RigFaultsPrCellAccumulator::NO_FAULT;
|
|
int fIdx2 = RigFaultsPrCellAccumulator::NO_FAULT;
|
|
|
|
if (conn.m_c1Face != StructGridInterface::NO_FACE)
|
|
{
|
|
fIdx1 = m_faultsPrCellAcc->faultIdx(conn.m_c1GlobIdx, conn.m_c1Face);
|
|
fIdx2 = m_faultsPrCellAcc->faultIdx(conn.m_c2GlobIdx, StructGridInterface::oppositeFace(conn.m_c1Face));
|
|
}
|
|
|
|
if (fIdx1 < 0 && fIdx2 < 0)
|
|
{
|
|
cvf::String lgrString("Same Grid");
|
|
if (m_cells[conn.m_c1GlobIdx].hostGrid() != m_cells[conn.m_c2GlobIdx].hostGrid())
|
|
{
|
|
lgrString = "Different Grid";
|
|
}
|
|
|
|
// cvf::Trace::show("NNC: No Fault for NNC C1: " + cvf::String((int)conn.m_c1GlobIdx) + " C2: " +
|
|
// cvf::String((int)conn.m_c2GlobIdx) + " Grid: " + lgrString);
|
|
}
|
|
|
|
if (fIdx1 >= 0)
|
|
{
|
|
// Add the connection to both, if they are different.
|
|
m_faults[fIdx1]->connectionIndices().push_back(nncIdx);
|
|
}
|
|
|
|
if (fIdx2 != fIdx1)
|
|
{
|
|
if (fIdx2 >= 0)
|
|
{
|
|
m_faults[fIdx2]->connectionIndices().push_back(nncIdx);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
/// The cell is normally inverted due to Depth becoming -Z at import,
|
|
/// but if (only) one of the flipX/Y is done, the cell is back to normal
|
|
//--------------------------------------------------------------------------------------------------
|
|
bool RigMainGrid::isFaceNormalsOutwards() const
|
|
{
|
|
for (int gcIdx = 0; gcIdx < static_cast<int>(m_cells.size()); ++gcIdx)
|
|
{
|
|
if (!m_cells[gcIdx].isInvalid())
|
|
{
|
|
cvf::Vec3d cellCenter = m_cells[gcIdx].center();
|
|
cvf::Vec3d faceCenter = m_cells[gcIdx].faceCenter(StructGridInterface::POS_I);
|
|
cvf::Vec3d faceNormal = m_cells[gcIdx].faceNormalWithAreaLenght(StructGridInterface::POS_I);
|
|
|
|
double typicalIJCellSize = characteristicIJCellSize();
|
|
double dummy, dummy2, typicalKSize;
|
|
characteristicCellSizes(&dummy, &dummy2, &typicalKSize);
|
|
|
|
if ((faceCenter - cellCenter).length() > 0.2 * typicalIJCellSize &&
|
|
(faceNormal.length() > (0.2 * typicalIJCellSize * 0.2 * typicalKSize)))
|
|
{
|
|
// Cell is assumed ok to use, so calculate whether the normals are outwards or inwards
|
|
|
|
if ((faceCenter - cellCenter) * faceNormal >= 0)
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
const RigFault* RigMainGrid::findFaultFromCellIndexAndCellFace(size_t reservoirCellIndex,
|
|
cvf::StructGridInterface::FaceType face) const
|
|
{
|
|
CVF_TIGHT_ASSERT(m_faultsPrCellAcc.notNull());
|
|
|
|
if (face == cvf::StructGridInterface::NO_FACE) return nullptr;
|
|
|
|
int faultIdx = m_faultsPrCellAcc->faultIdx(reservoirCellIndex, face);
|
|
if (faultIdx != RigFaultsPrCellAccumulator::NO_FAULT)
|
|
{
|
|
return m_faults.at(faultIdx);
|
|
}
|
|
|
|
#if 0
|
|
for (size_t i = 0; i < m_faults.size(); i++)
|
|
{
|
|
const RigFault* rigFault = m_faults.at(i);
|
|
const std::vector<RigFault::FaultFace>& faultFaces = rigFault->faultFaces();
|
|
|
|
for (size_t fIdx = 0; fIdx < faultFaces.size(); fIdx++)
|
|
{
|
|
if (faultFaces[fIdx].m_nativeReservoirCellIndex == cellIndex)
|
|
{
|
|
if (face == faultFaces[fIdx].m_nativeFace )
|
|
{
|
|
return rigFault;
|
|
}
|
|
}
|
|
|
|
if (faultFaces[fIdx].m_oppositeReservoirCellIndex == cellIndex)
|
|
{
|
|
if (face == cvf::StructGridInterface::oppositeFace(faultFaces[fIdx].m_nativeFace))
|
|
{
|
|
return rigFault;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
return nullptr;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RigMainGrid::findIntersectingCells(const cvf::BoundingBox& inputBB, std::vector<size_t>* cellIndices) const
|
|
{
|
|
CVF_ASSERT(m_cellSearchTree.notNull());
|
|
|
|
m_cellSearchTree->findIntersections(inputBB, cellIndices);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RigMainGrid::buildCellSearchTree()
|
|
{
|
|
if (m_cellSearchTree.isNull())
|
|
{
|
|
// build tree
|
|
|
|
size_t cellCount = m_cells.size();
|
|
|
|
std::vector<cvf::BoundingBox> cellBoundingBoxes;
|
|
cellBoundingBoxes.resize(cellCount);
|
|
|
|
for (size_t cIdx = 0; cIdx < cellCount; ++cIdx)
|
|
{
|
|
if (m_cells[cIdx].isInvalid()) continue;
|
|
|
|
const std::array<size_t, 8>& cellIndices = m_cells[cIdx].cornerIndices();
|
|
|
|
cvf::BoundingBox& cellBB = cellBoundingBoxes[cIdx];
|
|
cellBB.add(m_nodes[cellIndices[0]]);
|
|
cellBB.add(m_nodes[cellIndices[1]]);
|
|
cellBB.add(m_nodes[cellIndices[2]]);
|
|
cellBB.add(m_nodes[cellIndices[3]]);
|
|
cellBB.add(m_nodes[cellIndices[4]]);
|
|
cellBB.add(m_nodes[cellIndices[5]]);
|
|
cellBB.add(m_nodes[cellIndices[6]]);
|
|
cellBB.add(m_nodes[cellIndices[7]]);
|
|
}
|
|
|
|
m_cellSearchTree = new cvf::BoundingBoxTree;
|
|
m_cellSearchTree->buildTreeFromBoundingBoxes(cellBoundingBoxes, nullptr);
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
cvf::BoundingBox RigMainGrid::boundingBox() const
|
|
{
|
|
if (m_boundingBox.isValid()) return m_boundingBox;
|
|
|
|
for (const auto& node : m_nodes)
|
|
{
|
|
m_boundingBox.add(node);
|
|
}
|
|
|
|
return m_boundingBox;
|
|
}
|