OilfieldToolsNet/ResInsight
4
0
Fork 0
mirror of https://github.com/OPM/ResInsight.git synced 2025-02-25 18:55:39 -06:00
Code Issues Packages Projects Releases Wiki Activity

#1901 Whitespace changes to improve readability

Browse Source
This commit is contained in:
Jacob Støren
2017-09-19 15:22:14 +02:00
parent d1c41fa77d
commit 19354b1a8b
6 changed files with 50 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
ApplicationCode/Commands/CompletionCommands/RicFishbonesTransmissibilityCalculationFeatureImp.cpp
View File

@@ -166,16 +166,20 @@ std::vector<RigCompletionData> RicFishbonesTransmissibilityCalculationFeatureImp
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RicFishbonesTransmissibilityCalculationFeatureImp::findFishboneImportedLateralsWellBoreParts(std::map<size_t, std::vector<WellBorePartForTransCalc> >& wellBorePartsInCells, const RimWellPath* wellPath, const RicExportCompletionDataSettingsUi& settings) void RicFishbonesTransmissibilityCalculationFeatureImp::findFishboneImportedLateralsWellBoreParts(std::map<size_t, std::vector<WellBorePartForTransCalc> >& wellBorePartsInCells,
const RimWellPath* wellPath,
const RicExportCompletionDataSettingsUi& settings)
{ {
RiaEclipseUnitTools::UnitSystem unitSystem = settings.caseToApply->eclipseCaseData()->unitsType(); RiaEclipseUnitTools::UnitSystem unitSystem = settings.caseToApply->eclipseCaseData()->unitsType();
std::vector<size_t> wellPathCells = RicWellPathExportCompletionDataFeature::findIntersectingCells(settings.caseToApply()->eclipseCaseData(), wellPath->wellPathGeometry()->m_wellPathPoints); std::vector<size_t> wellPathCells = RicWellPathExportCompletionDataFeature::findIntersectingCells(settings.caseToApply()->eclipseCaseData(),
wellPath->wellPathGeometry()->m_wellPathPoints);
bool isMainBore = false; bool isMainBore = false;
double diameter = wellPath->fishbonesCollection()->wellPathCollection()->holeDiameter(unitSystem); double diameter = wellPath->fishbonesCollection()->wellPathCollection()->holeDiameter(unitSystem);
for (const RimFishboneWellPath* fishbonesPath : wellPath->fishbonesCollection()->wellPathCollection()->wellPaths()) for (const RimFishboneWellPath* fishbonesPath : wellPath->fishbonesCollection()->wellPathCollection()->wellPaths())
{ {
std::vector<WellPathCellIntersectionInfo> intersectedCells = RigWellPathIntersectionTools::findCellsIntersectedByPath(settings.caseToApply->eclipseCaseData(), fishbonesPath->coordinates()); std::vector<WellPathCellIntersectionInfo> intersectedCells = RigWellPathIntersectionTools::findCellsIntersectedByPath(settings.caseToApply->eclipseCaseData(),
fishbonesPath->coordinates());
for (auto& cell : intersectedCells) for (auto& cell : intersectedCells)
{ {
if (std::find(wellPathCells.begin(), wellPathCells.end(), cell.cellIndex) != wellPathCells.end()) continue; if (std::find(wellPathCells.begin(), wellPathCells.end(), cell.cellIndex) != wellPathCells.end()) continue;

18
ApplicationCode/Commands/CompletionCommands/RicWellPathExportCompletionDataFeature.cpp
View File

@@ -717,7 +717,8 @@ std::vector<RigCompletionData> RicWellPathExportCompletionDataFeature::generateP
if (!interval->isActiveOnDate(settings.caseToApply->timeStepDates()[settings.timeStep])) continue; if (!interval->isActiveOnDate(settings.caseToApply->timeStepDates()[settings.timeStep])) continue;
std::vector<cvf::Vec3d> perforationPoints = wellPath->wellPathGeometry()->clippedPointSubset(interval->startMD(), interval->endMD()); std::vector<cvf::Vec3d> perforationPoints = wellPath->wellPathGeometry()->clippedPointSubset(interval->startMD(), interval->endMD());
std::vector<WellPathCellIntersectionInfo> intersectedCells = RigWellPathIntersectionTools::findCellsIntersectedByPath(settings.caseToApply->eclipseCaseData(), perforationPoints); std::vector<WellPathCellIntersectionInfo> intersectedCells = RigWellPathIntersectionTools::findCellsIntersectedByPath(settings.caseToApply->eclipseCaseData(),
perforationPoints);
for (auto& cell : intersectedCells) for (auto& cell : intersectedCells)
{ {
bool cellIsActive = activeCellInfo->isActive(cell.cellIndex); bool cellIsActive = activeCellInfo->isActive(cell.cellIndex);
@@ -852,13 +853,17 @@ std::vector<WellSegmentLocation> RicWellPathExportCompletionDataFeature::findWel
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RicWellPathExportCompletionDataFeature::calculateLateralIntersections(const RimEclipseCase* caseToApply, WellSegmentLocation* location, int* branchNum, int* segmentNum) void RicWellPathExportCompletionDataFeature::calculateLateralIntersections(const RimEclipseCase* caseToApply,
WellSegmentLocation* location,
int* branchNum,
int* segmentNum)
{ {
for (WellSegmentLateral& lateral : location->laterals) for (WellSegmentLateral& lateral : location->laterals)
{ {
lateral.branchNumber = ++(*branchNum); lateral.branchNumber = ++(*branchNum);
std::vector<cvf::Vec3d> lateralCoords = location->fishbonesSubs->coordsForLateral(location->subIndex, lateral.lateralIndex); std::vector<cvf::Vec3d> lateralCoords = location->fishbonesSubs->coordsForLateral(location->subIndex, lateral.lateralIndex);
std::vector<WellPathCellIntersectionInfo> intersections = RigWellPathIntersectionTools::findCellsIntersectedByPath(caseToApply->eclipseCaseData(), lateralCoords); std::vector<WellPathCellIntersectionInfo> intersections = RigWellPathIntersectionTools::findCellsIntersectedByPath(caseToApply->eclipseCaseData(),
lateralCoords);
auto intersection = intersections.cbegin(); auto intersection = intersections.cbegin();
double length = 0; double length = 0;
@@ -873,7 +878,12 @@ void RicWellPathExportCompletionDataFeature::calculateLateralIntersections(const
length += (intersection->endPoint - startPoint).length(); length += (intersection->endPoint - startPoint).length();
depth += intersection->endPoint.z() - startPoint.z(); depth += intersection->endPoint.z() - startPoint.z();
WellSegmentLateralIntersection lateralIntersection(++(*segmentNum), attachedSegmentNumber, intersection->cellIndex, length, depth); WellSegmentLateralIntersection lateralIntersection( ++(*segmentNum),
attachedSegmentNumber,
intersection->cellIndex,
length,
depth);
lateralIntersection.lengthsInCell = intersection->internalCellLengths; lateralIntersection.lengthsInCell = intersection->internalCellLengths;
lateral.intersections.push_back(lateralIntersection); lateral.intersections.push_back(lateralIntersection);

10
ApplicationCode/ReservoirDataModel/RigHexIntersectionTools.cpp
View File

@@ -46,7 +46,10 @@ int RigHexIntersectionTools::lineHexCellIntersection(const cvf::Vec3d p1,
cvf::Vec3d intersection; cvf::Vec3d intersection;
bool isEntering = false; bool isEntering = false;
cvf::Vec3d faceCenter = cvf::GeometryTools::computeFaceCenter(hexCorners[faceVertexIndices[0]], hexCorners[faceVertexIndices[1]], hexCorners[faceVertexIndices[2]], hexCorners[faceVertexIndices[3]]); cvf::Vec3d faceCenter = cvf::GeometryTools::computeFaceCenter(hexCorners[faceVertexIndices[0]],
hexCorners[faceVertexIndices[1]],
hexCorners[faceVertexIndices[2]],
hexCorners[faceVertexIndices[3]]);
for ( int i = 0; i < 4; ++i ) for ( int i = 0; i < 4; ++i )
{ {
@@ -91,7 +94,10 @@ bool RigHexIntersectionTools::isPointInCell(const cvf::Vec3d point,
{ {
cvf::ubyte faceVertexIndices[4]; cvf::ubyte faceVertexIndices[4];
cvf::StructGridInterface::cellFaceVertexIndices(static_cast<cvf::StructGridInterface::FaceType>(face), faceVertexIndices); cvf::StructGridInterface::cellFaceVertexIndices(static_cast<cvf::StructGridInterface::FaceType>(face), faceVertexIndices);
cvf::Vec3d faceCenter = cvf::GeometryTools::computeFaceCenter(hexCorners[faceVertexIndices[0]], hexCorners[faceVertexIndices[1]], hexCorners[faceVertexIndices[2]], hexCorners[faceVertexIndices[3]]); cvf::Vec3d faceCenter = cvf::GeometryTools::computeFaceCenter(hexCorners[faceVertexIndices[0]],
hexCorners[faceVertexIndices[1]],
hexCorners[faceVertexIndices[2]],
hexCorners[faceVertexIndices[3]]);
for ( int i = 0; i < 4; ++i ) for ( int i = 0; i < 4; ++i )
{ {

8
ApplicationCode/ReservoirDataModel/RigWellLogExtractor.cpp
View File

@@ -40,8 +40,12 @@ RigWellLogExtractor::~RigWellLogExtractor()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RigWellLogExtractor::insertIntersectionsInMap(const std::vector<HexIntersectionInfo> &intersections, cvf::Vec3d p1, double md1, cvf::Vec3d p2, double md2, void RigWellLogExtractor::insertIntersectionsInMap(const std::vector<HexIntersectionInfo> &intersections,
std::map<RigMDCellIdxEnterLeaveKey, HexIntersectionInfo > *uniqueIntersections) cvf::Vec3d p1,
double md1,
cvf::Vec3d p2,
double md2,
std::map<RigMDCellIdxEnterLeaveKey, HexIntersectionInfo > *uniqueIntersections)
{ {
for (size_t intIdx = 0; intIdx < intersections.size(); ++intIdx) for (size_t intIdx = 0; intIdx < intersections.size(); ++intIdx)
{ {

9
ApplicationCode/ReservoirDataModel/RigWellLogExtractor.h
View File

@@ -49,9 +49,12 @@ public:
const RigWellPath* wellPathData() { return m_wellPath.p();} const RigWellPath* wellPathData() { return m_wellPath.p();}
protected: protected:
void insertIntersectionsInMap(const std::vector<HexIntersectionInfo> &intersections, static void insertIntersectionsInMap(const std::vector<HexIntersectionInfo> &intersections,
cvf::Vec3d p1, double md1, cvf::Vec3d p2, double md2, cvf::Vec3d p1,
std::map<RigMDCellIdxEnterLeaveKey, HexIntersectionInfo > *uniqueIntersections); double md1,
cvf::Vec3d p2,
double md2,
std::map<RigMDCellIdxEnterLeaveKey, HexIntersectionInfo > *uniqueIntersections);
void populateReturnArrays(std::map<RigMDCellIdxEnterLeaveKey, HexIntersectionInfo > &uniqueIntersections); void populateReturnArrays(std::map<RigMDCellIdxEnterLeaveKey, HexIntersectionInfo > &uniqueIntersections);
void appendIntersectionToArrays(double measuredDepth, const HexIntersectionInfo& intersection); void appendIntersectionToArrays(double measuredDepth, const HexIntersectionInfo& intersection);

17
ApplicationCode/ReservoirDataModel/RigWellPathIntersectionTools.cpp
View File

@@ -32,17 +32,18 @@
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
std::vector<WellPathCellIntersectionInfo> RigWellPathIntersectionTools::findCellsIntersectedByPath(const RigEclipseCaseData* caseData, const std::vector<cvf::Vec3d>& pathCoords) std::vector<WellPathCellIntersectionInfo> RigWellPathIntersectionTools::findCellsIntersectedByPath(const RigEclipseCaseData* caseData,
const std::vector<cvf::Vec3d>& pathCoords)
{ {
std::vector<WellPathCellIntersectionInfo> intersectionInfo; std::vector<WellPathCellIntersectionInfo> intersectionInfos;
const RigMainGrid* grid = caseData->mainGrid(); const RigMainGrid* grid = caseData->mainGrid();
if (pathCoords.size() < 2) return intersectionInfo; if (pathCoords.size() < 2) return intersectionInfos;
std::vector<HexIntersectionInfo> intersections = getIntersectedCells(grid, pathCoords); std::vector<HexIntersectionInfo> intersections = getIntersectedCells(grid, pathCoords);
removeEnteringIntersections(&intersections); removeEnteringIntersections(&intersections);
if (intersections.empty()) return intersectionInfo; if (intersections.empty()) return intersectionInfos;
cvf::Vec3d startPoint; cvf::Vec3d startPoint;
cvf::Vec3d endPoint; cvf::Vec3d endPoint;
@@ -59,7 +60,7 @@ std::vector<WellPathCellIntersectionInfo> RigWellPathIntersectionTools::findCell
{ {
endPoint = intersection->m_intersectionPoint; endPoint = intersection->m_intersectionPoint;
internalCellLengths = calculateLengthInCell(grid, cellIndex, startPoint, endPoint); internalCellLengths = calculateLengthInCell(grid, cellIndex, startPoint, endPoint);
intersectionInfo.push_back(WellPathCellIntersectionInfo(cellIndex, startPoint, endPoint, internalCellLengths)); intersectionInfos.push_back(WellPathCellIntersectionInfo(cellIndex, startPoint, endPoint, internalCellLengths));
} }
else else
{ {
@@ -76,7 +77,7 @@ std::vector<WellPathCellIntersectionInfo> RigWellPathIntersectionTools::findCell
{ {
endPoint = intersection->m_intersectionPoint; endPoint = intersection->m_intersectionPoint;
internalCellLengths = calculateLengthInCell(grid, cellIndex, startPoint, endPoint); internalCellLengths = calculateLengthInCell(grid, cellIndex, startPoint, endPoint);
intersectionInfo.push_back(WellPathCellIntersectionInfo(cellIndex, startPoint, endPoint, internalCellLengths)); intersectionInfos.push_back(WellPathCellIntersectionInfo(cellIndex, startPoint, endPoint, internalCellLengths));
startPoint = endPoint; startPoint = endPoint;
cellIndex = intersection->m_hexIndex; cellIndex = intersection->m_hexIndex;
@@ -86,9 +87,9 @@ std::vector<WellPathCellIntersectionInfo> RigWellPathIntersectionTools::findCell
//end cell //end cell
endPoint = pathCoords[pathCoords.size() - 1]; endPoint = pathCoords[pathCoords.size() - 1];
internalCellLengths = calculateLengthInCell(grid, cellIndex, startPoint, endPoint); internalCellLengths = calculateLengthInCell(grid, cellIndex, startPoint, endPoint);
intersectionInfo.push_back(WellPathCellIntersectionInfo(cellIndex, startPoint, endPoint, internalCellLengths)); intersectionInfos.push_back(WellPathCellIntersectionInfo(cellIndex, startPoint, endPoint, internalCellLengths));
return intersectionInfo; return intersectionInfos;
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------