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

clang-format : Set PenaltyBreakAssignment to 130

Browse Source
This commit is contained in:
Magne Sjaastad
2019-11-04 15:08:09 +01:00
parent 7c8cf60dba
commit 57cab2457e
105 changed files with 596 additions and 711 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
ApplicationCode/ReservoirDataModel/Completions/RigEclipseToStimPlanCalculator.cpp
View File

@@ -79,8 +79,8 @@ void RigEclipseToStimPlanCalculator::computeValues()
reservoirCellIndicesOpenForFlow,
m_fracture );
const std::vector<size_t>& fractureCellContributingEclipseCells = eclToFractureTransCalc
.globalIndiciesToContributingEclipseCells();
const std::vector<size_t>& fractureCellContributingEclipseCells =
eclToFractureTransCalc.globalIndiciesToContributingEclipseCells();
if ( !fractureCellContributingEclipseCells.empty() )
{
@@ -99,8 +99,8 @@ void RigEclipseToStimPlanCalculator::appendDataToTransmissibilityCondenser( bool
{
for ( const auto& eclToFractureTransCalc : m_singleFractureCellCalculators )
{
const std::vector<size_t>& fractureCellContributingEclipseCells = eclToFractureTransCalc.second
.globalIndiciesToContributingEclipseCells();
const std::vector<size_t>& fractureCellContributingEclipseCells =
eclToFractureTransCalc.second.globalIndiciesToContributingEclipseCells();
const std::vector<double>& fractureCellContributingEclipseCellTransmissibilities =
eclToFractureTransCalc.second.contributingEclipseCellTransmissibilities();

45
ApplicationCode/ReservoirDataModel/Completions/RigEclipseToStimPlanCellTransmissibilityCalculator.cpp
View File

@@ -304,27 +304,30 @@ void RigEclipseToStimPlanCellTransmissibilityCalculator::calculateStimPlanCellsM
NTG = dataAccessObjectNTG->cellScalarGlobIdx( reservoirCellIndex );
}
double transmissibility_X = RigFractureTransmissibilityEquations::matrixToFractureTrans( permY,
NTG,
Ay,
dx,
m_fractureSkinFactor,
fractureAreaWeightedlength,
m_cDarcy );
double transmissibility_Y = RigFractureTransmissibilityEquations::matrixToFractureTrans( permX,
NTG,
Ax,
dy,
m_fractureSkinFactor,
fractureAreaWeightedlength,
m_cDarcy );
double transmissibility_Z = RigFractureTransmissibilityEquations::matrixToFractureTrans( permZ,
1.0,
Az,
dz,
m_fractureSkinFactor,
fractureAreaWeightedlength,
m_cDarcy );
double transmissibility_X =
RigFractureTransmissibilityEquations::matrixToFractureTrans( permY,
NTG,
Ay,
dx,
m_fractureSkinFactor,
fractureAreaWeightedlength,
m_cDarcy );
double transmissibility_Y =
RigFractureTransmissibilityEquations::matrixToFractureTrans( permX,
NTG,
Ax,
dy,
m_fractureSkinFactor,
fractureAreaWeightedlength,
m_cDarcy );
double transmissibility_Z =
RigFractureTransmissibilityEquations::matrixToFractureTrans( permZ,
1.0,
Az,
dz,
m_fractureSkinFactor,
fractureAreaWeightedlength,
m_cDarcy );
transmissibility = sqrt( transmissibility_X * transmissibility_X + transmissibility_Y * transmissibility_Y +
transmissibility_Z * transmissibility_Z );

6
ApplicationCode/ReservoirDataModel/Completions/RigTransmissibilityCondenser.cpp
View File

@@ -226,10 +226,8 @@ std::map<size_t, double> RigTransmissibilityCondenser::calculateFicticiousFractu
// Sum(T'_mf)
double scaledMatrixToFractureTrans = matrixToAllFracturesTrans[globalMatrixCellIdx];
// T'mw
double scaledMatrixToWellTrans = condensedTransmissibility( externalCell,
{true,
RigTransmissibilityCondenser::CellAddress::WELL,
1} );
double scaledMatrixToWellTrans =
condensedTransmissibility( externalCell, {true, RigTransmissibilityCondenser::CellAddress::WELL, 1} );
// T'_fjw
fictitiousFractureToWellTrans[globalMatrixCellIdx] =
RigFractureTransmissibilityEquations::effectiveInternalFractureToWellTransPDDHC( scaledMatrixToFractureTrans,

7
ApplicationCode/ReservoirDataModel/RigCaseCellResultCalculator.cpp
View File

@@ -139,11 +139,8 @@ bool RigCaseCellResultCalculator::computeDifference( RigEclipseCaseData*
cvf::ref<RigResultAccessor> sourceResultAccessor =
RigResultAccessorFactory::createFromResultAddress( sourceCase, gridIdx, porosityModel, fIdx, nativeAddress );
cvf::ref<RigResultModifier> resultModifier = RigResultModifierFactory::createResultModifier( sourceCase,
gridIdx,
porosityModel,
fIdx,
address );
cvf::ref<RigResultModifier> resultModifier =
RigResultModifierFactory::createResultModifier( sourceCase, gridIdx, porosityModel, fIdx, address );
size_t baseFrameIdx = fIdx;
if ( address.isTimeLapse() )

9
ApplicationCode/ReservoirDataModel/RigCaseCellResultsData.cpp
View File

@@ -3029,11 +3029,12 @@ void RigCaseCellResultsData::copyResultsMetaDataFromMainCase( RigEclipseCaseData
RiaDefines::PorosityModelType poroModel,
std::vector<RimEclipseCase*> destinationCases )
{
std::vector<RigEclipseResultAddress> resAddresses = mainCaseResultsData->results( poroModel )->existingResults();
std::vector<RigEclipseTimeStepInfo> timeStepInfos = mainCaseResultsData->results( poroModel )
->timeStepInfos( resAddresses[0] );
std::vector<RigEclipseResultAddress> resAddresses = mainCaseResultsData->results( poroModel )->existingResults();
std::vector<RigEclipseTimeStepInfo> timeStepInfos =
mainCaseResultsData->results( poroModel )->timeStepInfos( resAddresses[0] );
const std::vector<RigEclipseResultInfo> resultInfos = mainCaseResultsData->results( poroModel )->infoForEachResultIndex();
const std::vector<RigEclipseResultInfo> resultInfos =
mainCaseResultsData->results( poroModel )->infoForEachResultIndex();
for ( size_t i = 0; i < destinationCases.size(); i++ )
{

72
ApplicationCode/ReservoirDataModel/RigCaseToCaseRangeFilterMapper.cpp
View File

@@ -217,47 +217,47 @@ void RigCaseToCaseRangeFilterMapper::convertRangeFilterEndPoints( const RigRange
if ( femIsDestination )
{
rangeFilterMatches[cornerIdx]
.cellMatchType = findBestFemCellFromEclCell( eclGrid,
srcRangeCube[cornerIdx][0],
srcRangeCube[cornerIdx][1],
srcRangeCube[cornerIdx][2],
femPart,
&( rangeFilterMatches[cornerIdx].ijk[0] ),
&( rangeFilterMatches[cornerIdx].ijk[1] ),
&( rangeFilterMatches[cornerIdx].ijk[2] ) );
rangeFilterMatches[cornerIdx].cellMatchType =
findBestFemCellFromEclCell( eclGrid,
srcRangeCube[cornerIdx][0],
srcRangeCube[cornerIdx][1],
srcRangeCube[cornerIdx][2],
femPart,
&( rangeFilterMatches[cornerIdx].ijk[0] ),
&( rangeFilterMatches[cornerIdx].ijk[1] ),
&( rangeFilterMatches[cornerIdx].ijk[2] ) );
rangeFilterMatches[diagIdx]
.cellMatchType = findBestFemCellFromEclCell( eclGrid,
srcRangeCube[diagIdx][0],
srcRangeCube[diagIdx][1],
srcRangeCube[diagIdx][2],
femPart,
&( rangeFilterMatches[diagIdx].ijk[0] ),
&( rangeFilterMatches[diagIdx].ijk[1] ),
&( rangeFilterMatches[diagIdx].ijk[2] ) );
rangeFilterMatches[diagIdx].cellMatchType =
findBestFemCellFromEclCell( eclGrid,
srcRangeCube[diagIdx][0],
srcRangeCube[diagIdx][1],
srcRangeCube[diagIdx][2],
femPart,
&( rangeFilterMatches[diagIdx].ijk[0] ),
&( rangeFilterMatches[diagIdx].ijk[1] ),
&( rangeFilterMatches[diagIdx].ijk[2] ) );
}
else
{
rangeFilterMatches[cornerIdx]
.cellMatchType = findBestEclCellFromFemCell( femPart,
srcRangeCube[cornerIdx][0],
srcRangeCube[cornerIdx][1],
srcRangeCube[cornerIdx][2],
eclGrid,
&( rangeFilterMatches[cornerIdx].ijk[0] ),
&( rangeFilterMatches[cornerIdx].ijk[1] ),
&( rangeFilterMatches[cornerIdx].ijk[2] ) );
rangeFilterMatches[cornerIdx].cellMatchType =
findBestEclCellFromFemCell( femPart,
srcRangeCube[cornerIdx][0],
srcRangeCube[cornerIdx][1],
srcRangeCube[cornerIdx][2],
eclGrid,
&( rangeFilterMatches[cornerIdx].ijk[0] ),
&( rangeFilterMatches[cornerIdx].ijk[1] ),
&( rangeFilterMatches[cornerIdx].ijk[2] ) );
rangeFilterMatches[diagIdx]
.cellMatchType = findBestEclCellFromFemCell( femPart,
srcRangeCube[diagIdx][0],
srcRangeCube[diagIdx][1],
srcRangeCube[diagIdx][2],
eclGrid,
&( rangeFilterMatches[diagIdx].ijk[0] ),
&( rangeFilterMatches[diagIdx].ijk[1] ),
&( rangeFilterMatches[diagIdx].ijk[2] ) );
rangeFilterMatches[diagIdx].cellMatchType =
findBestEclCellFromFemCell( femPart,
srcRangeCube[diagIdx][0],
srcRangeCube[diagIdx][1],
srcRangeCube[diagIdx][2],
eclGrid,
&( rangeFilterMatches[diagIdx].ijk[0] ),
&( rangeFilterMatches[diagIdx].ijk[1] ),
&( rangeFilterMatches[diagIdx].ijk[2] ) );
}
if ( rangeFilterMatches[cornerIdx].cellMatchType == EXACT &&

12
ApplicationCode/ReservoirDataModel/RigFlowDiagResults.cpp
View File

@@ -232,20 +232,16 @@ std::vector<double>* RigFlowDiagResults::calculateDerivedResult( const RigFlowDi
std::vector<double>* RigFlowDiagResults::calculateAverageTOFResult( const RigFlowDiagResultAddress& resVarAddr,
size_t timeStepIndex )
{
std::vector<const std::vector<double>*> injectorTOFs = findResultsForSelectedTracers( resVarAddr,
timeStepIndex,
RIG_FLD_TOF_RESNAME,
RimFlowDiagSolution::INJECTOR );
std::vector<const std::vector<double>*> injectorTOFs =
findResultsForSelectedTracers( resVarAddr, timeStepIndex, RIG_FLD_TOF_RESNAME, RimFlowDiagSolution::INJECTOR );
std::vector<const std::vector<double>*> injectorFractions =
findResultsForSelectedTracers( resVarAddr,
timeStepIndex,
RIG_FLD_CELL_FRACTION_RESNAME,
RimFlowDiagSolution::INJECTOR );
std::vector<const std::vector<double>*> producerTOFs = findResultsForSelectedTracers( resVarAddr,
timeStepIndex,
RIG_FLD_TOF_RESNAME,
RimFlowDiagSolution::PRODUCER );
std::vector<const std::vector<double>*> producerTOFs =
findResultsForSelectedTracers( resVarAddr, timeStepIndex, RIG_FLD_TOF_RESNAME, RimFlowDiagSolution::PRODUCER );
std::vector<const std::vector<double>*> producerFractions =
findResultsForSelectedTracers( resVarAddr,
timeStepIndex,

40
ApplicationCode/ReservoirDataModel/RigFlowDiagSolverInterface.cpp
View File

@@ -733,10 +733,10 @@ std::vector<RigFlowDiagSolverInterface::RelPermCurve>
{
scaling.enable = static_cast<unsigned char>( 0 );
}
std::vector<Opm::FlowDiagnostics::Graph> graphArr = m_opmFlowDiagStaticData->m_eclSaturationFunc
->getSatFuncCurve( satFuncRequests,
static_cast<int>( activeCellIndex ),
scaling );
std::vector<Opm::FlowDiagnostics::Graph> graphArr =
m_opmFlowDiagStaticData->m_eclSaturationFunc->getSatFuncCurve( satFuncRequests,
static_cast<int>( activeCellIndex ),
scaling );
for ( size_t i = 0; i < graphArr.size(); i++ )
{
const RelPermCurve::Ident curveIdent = curveIdentNameArr[i].first;
@@ -786,10 +786,10 @@ std::vector<RigFlowDiagSolverInterface::PvtCurve>
{
// Bo
{
std::vector<Opm::ECLPVT::PVTGraph> graphArr = m_opmFlowDiagStaticData->m_eclPvtCurveCollection
->getPvtCurve( Opm::ECLPVT::RawCurve::FVF,
Opm::ECLPhaseIndex::Liquid,
static_cast<int>( activeCellIndex ) );
std::vector<Opm::ECLPVT::PVTGraph> graphArr =
m_opmFlowDiagStaticData->m_eclPvtCurveCollection->getPvtCurve( Opm::ECLPVT::RawCurve::FVF,
Opm::ECLPhaseIndex::Liquid,
static_cast<int>( activeCellIndex ) );
for ( Opm::ECLPVT::PVTGraph srcGraph : graphArr )
{
if ( srcGraph.press.size() > 0 )
@@ -802,10 +802,10 @@ std::vector<RigFlowDiagSolverInterface::PvtCurve>
// Bg
{
std::vector<Opm::ECLPVT::PVTGraph> graphArr = m_opmFlowDiagStaticData->m_eclPvtCurveCollection
->getPvtCurve( Opm::ECLPVT::RawCurve::FVF,
Opm::ECLPhaseIndex::Vapour,
static_cast<int>( activeCellIndex ) );
std::vector<Opm::ECLPVT::PVTGraph> graphArr =
m_opmFlowDiagStaticData->m_eclPvtCurveCollection->getPvtCurve( Opm::ECLPVT::RawCurve::FVF,
Opm::ECLPhaseIndex::Vapour,
static_cast<int>( activeCellIndex ) );
for ( Opm::ECLPVT::PVTGraph srcGraph : graphArr )
{
if ( srcGraph.press.size() > 0 )
@@ -821,10 +821,10 @@ std::vector<RigFlowDiagSolverInterface::PvtCurve>
{
// Visc_o / mu_o
{
std::vector<Opm::ECLPVT::PVTGraph> graphArr = m_opmFlowDiagStaticData->m_eclPvtCurveCollection
->getPvtCurve( Opm::ECLPVT::RawCurve::Viscosity,
Opm::ECLPhaseIndex::Liquid,
static_cast<int>( activeCellIndex ) );
std::vector<Opm::ECLPVT::PVTGraph> graphArr =
m_opmFlowDiagStaticData->m_eclPvtCurveCollection->getPvtCurve( Opm::ECLPVT::RawCurve::Viscosity,
Opm::ECLPhaseIndex::Liquid,
static_cast<int>( activeCellIndex ) );
for ( Opm::ECLPVT::PVTGraph srcGraph : graphArr )
{
if ( srcGraph.press.size() > 0 )
@@ -837,10 +837,10 @@ std::vector<RigFlowDiagSolverInterface::PvtCurve>
// Visc_g / mu_g
{
std::vector<Opm::ECLPVT::PVTGraph> graphArr = m_opmFlowDiagStaticData->m_eclPvtCurveCollection
->getPvtCurve( Opm::ECLPVT::RawCurve::Viscosity,
Opm::ECLPhaseIndex::Vapour,
static_cast<int>( activeCellIndex ) );
std::vector<Opm::ECLPVT::PVTGraph> graphArr =
m_opmFlowDiagStaticData->m_eclPvtCurveCollection->getPvtCurve( Opm::ECLPVT::RawCurve::Viscosity,
Opm::ECLPhaseIndex::Vapour,
static_cast<int>( activeCellIndex ) );
for ( Opm::ECLPVT::PVTGraph srcGraph : graphArr )
{
if ( srcGraph.press.size() > 0 )

4
ApplicationCode/ReservoirDataModel/RigGridScalarDataAccess.cpp
View File

@@ -162,8 +162,8 @@ cvf::ref<cvf::StructGridScalarDataAccess>
return NULL;
}
std::vector<std::vector<double>>& scalarSetResults = eclipseCase->results( porosityModel )
->cellScalarResults( scalarSetIndex );
std::vector<std::vector<double>>& scalarSetResults =
eclipseCase->results( porosityModel )->cellScalarResults( scalarSetIndex );
// A generated result with a generated results for a subset of time steps, will end up with a result container with
// less entries than time steps See RiaSetGridProperty command in RiaPropertyDataCommands

15
ApplicationCode/ReservoirDataModel/RigNNCData.cpp
View File

@@ -159,13 +159,14 @@ cvf::StructGridInterface::FaceType RigNNCData::calculateCellFaceOverlap( const R
c1.faceIndices( ( cvf::StructGridInterface::FaceType )( fIdx ), &face1 );
c2.faceIndices( cvf::StructGridInterface::oppositeFace( ( cvf::StructGridInterface::FaceType )( fIdx ) ), &face2 );
bool foundOverlap = cvf::GeometryTools::calculateOverlapPolygonOfTwoQuads( &polygon,
&intersections,
(cvf::EdgeIntersectStorage<size_t>*)nullptr,
cvf::wrapArrayConst( &mainGrid.nodes() ),
face1.data(),
face2.data(),
1e-6 );
bool foundOverlap =
cvf::GeometryTools::calculateOverlapPolygonOfTwoQuads( &polygon,
&intersections,
(cvf::EdgeIntersectStorage<size_t>*)nullptr,
cvf::wrapArrayConst( &mainGrid.nodes() ),
face1.data(),
face2.data(),
1e-6 );
if ( foundOverlap )
{

4
ApplicationCode/ReservoirDataModel/RigNumberOfFloodedPoreVolumesCalculator.cpp
View File

@@ -141,8 +141,8 @@ RigNumberOfFloodedPoreVolumesCalculator::RigNumberOfFloodedPoreVolumesCalculator
flowrateKatAllTimeSteps.push_back( flowrateK );
size_t nativeTimeStepIndex = caseToApply->uiToNativeTimeStepIndex( timeStep );
const std::vector<double>* connectionFlowrate = nncData->dynamicConnectionScalarResultByName( nncConnectionProperty,
nativeTimeStepIndex );
const std::vector<double>* connectionFlowrate =
nncData->dynamicConnectionScalarResultByName( nncConnectionProperty, nativeTimeStepIndex );
flowrateNNCatAllTimeSteps.push_back( connectionFlowrate );
// sum all tracers at current timestep

93
ApplicationCode/ReservoirDataModel/RigResultAccessorFactory.cpp
View File

@@ -101,11 +101,8 @@ cvf::ref<RigResultAccessor> RigResultAccessorFactory::createFromResultAddress( c
adjustedTimeStepIndex = 0;
}
cvf::ref<RigResultAccessor> derivedCandidate = createCombinedResultAccessor( eclipseCase,
gridIndex,
porosityModel,
adjustedTimeStepIndex,
resVarAddr );
cvf::ref<RigResultAccessor> derivedCandidate =
createCombinedResultAccessor( eclipseCase, gridIndex, porosityModel, adjustedTimeStepIndex, resVarAddr );
if ( derivedCandidate.notNull() ) return derivedCandidate;
@@ -136,23 +133,26 @@ cvf::ref<RigResultAccessor>
cvf::ref<RigCombTransResultAccessor> cellFaceAccessObject = new RigCombTransResultAccessor( grid );
nativeAddr.m_resultName = "TRANX";
cvf::ref<RigResultAccessor> xTransAccessor = RigResultAccessorFactory::createNativeFromResultAddress( eclipseCase,
gridIndex,
porosityModel,
timeStepIndex,
nativeAddr );
nativeAddr.m_resultName = "TRANY";
cvf::ref<RigResultAccessor> yTransAccessor = RigResultAccessorFactory::createNativeFromResultAddress( eclipseCase,
gridIndex,
porosityModel,
timeStepIndex,
nativeAddr );
nativeAddr.m_resultName = "TRANZ";
cvf::ref<RigResultAccessor> zTransAccessor = RigResultAccessorFactory::createNativeFromResultAddress( eclipseCase,
gridIndex,
porosityModel,
timeStepIndex,
nativeAddr );
cvf::ref<RigResultAccessor> xTransAccessor =
RigResultAccessorFactory::createNativeFromResultAddress( eclipseCase,
gridIndex,
porosityModel,
timeStepIndex,
nativeAddr );
nativeAddr.m_resultName = "TRANY";
cvf::ref<RigResultAccessor> yTransAccessor =
RigResultAccessorFactory::createNativeFromResultAddress( eclipseCase,
gridIndex,
porosityModel,
timeStepIndex,
nativeAddr );
nativeAddr.m_resultName = "TRANZ";
cvf::ref<RigResultAccessor> zTransAccessor =
RigResultAccessorFactory::createNativeFromResultAddress( eclipseCase,
gridIndex,
porosityModel,
timeStepIndex,
nativeAddr );
cellFaceAccessObject->setTransResultAccessors( xTransAccessor.p(), yTransAccessor.p(), zTransAccessor.p() );
@@ -216,24 +216,27 @@ cvf::ref<RigResultAccessor>
cvf::ref<RigCombTransResultAccessor> cellFaceAccessObject = new RigCombTransResultAccessor( grid );
nativeAddr.m_resultName = RiaDefines::riTranXResultName();
cvf::ref<RigResultAccessor> xTransAccessor = RigResultAccessorFactory::createNativeFromResultAddress( eclipseCase,
gridIndex,
porosityModel,
timeStepIndex,
nativeAddr );
nativeAddr.m_resultName = RiaDefines::riTranYResultName();
cvf::ref<RigResultAccessor> yTransAccessor = RigResultAccessorFactory::createNativeFromResultAddress( eclipseCase,
gridIndex,
porosityModel,
timeStepIndex,
nativeAddr );
nativeAddr.m_resultName = RiaDefines::riTranZResultName();
cvf::ref<RigResultAccessor> zTransAccessor = RigResultAccessorFactory::createNativeFromResultAddress( eclipseCase,
gridIndex,
porosityModel,
timeStepIndex,
nativeAddr );
nativeAddr.m_resultName = RiaDefines::riTranXResultName();
cvf::ref<RigResultAccessor> xTransAccessor =
RigResultAccessorFactory::createNativeFromResultAddress( eclipseCase,
gridIndex,
porosityModel,
timeStepIndex,
nativeAddr );
nativeAddr.m_resultName = RiaDefines::riTranYResultName();
cvf::ref<RigResultAccessor> yTransAccessor =
RigResultAccessorFactory::createNativeFromResultAddress( eclipseCase,
gridIndex,
porosityModel,
timeStepIndex,
nativeAddr );
nativeAddr.m_resultName = RiaDefines::riTranZResultName();
cvf::ref<RigResultAccessor> zTransAccessor =
RigResultAccessorFactory::createNativeFromResultAddress( eclipseCase,
gridIndex,
porosityModel,
timeStepIndex,
nativeAddr );
cellFaceAccessObject->setTransResultAccessors( xTransAccessor.p(), yTransAccessor.p(), zTransAccessor.p() );
@@ -463,8 +466,8 @@ cvf::ref<RigResultAccessor>
return nullptr;
}
const std::vector<std::vector<double>>& scalarSetResults = eclipseCase->results( porosityModel )
->cellScalarResults( resultAddress );
const std::vector<std::vector<double>>& scalarSetResults =
eclipseCase->results( porosityModel )->cellScalarResults( resultAddress );
if ( timeStepIndex >= scalarSetResults.size() )
{
@@ -485,10 +488,8 @@ cvf::ref<RigResultAccessor>
bool useGlobalActiveIndex = eclipseCase->results( porosityModel )->isUsingGlobalActiveIndex( resultAddress );
if ( useGlobalActiveIndex )
{
cvf::ref<RigResultAccessor> object = new RigActiveCellsResultAccessor( grid,
resultValues,
eclipseCase->activeCellInfo(
porosityModel ) );
cvf::ref<RigResultAccessor> object =
new RigActiveCellsResultAccessor( grid, resultValues, eclipseCase->activeCellInfo( porosityModel ) );
return object;
}
else

5
ApplicationCode/ReservoirDataModel/RigResultModifierFactory.cpp
View File

@@ -68,9 +68,8 @@ cvf::ref<RigResultModifier> RigResultModifierFactory::createResultModifier( RigE
bool useGlobalActiveIndex = eclipseCase->results( porosityModel )->isUsingGlobalActiveIndex( resVarAddr );
if ( useGlobalActiveIndex )
{
cvf::ref<RigResultModifier> object = new RigActiveCellsResultModifier( grid,
eclipseCase->activeCellInfo( porosityModel ),
resultValues );
cvf::ref<RigResultModifier> object =
new RigActiveCellsResultModifier( grid, eclipseCase->activeCellInfo( porosityModel ), resultValues );
return object;
}
else

3
ApplicationCode/ReservoirDataModel/RigSimWellData.cpp
View File

@@ -158,7 +158,8 @@ void RigSimWellData::computeStaticWellCellPath() const
for ( size_t bIdx = 0; bIdx < m_wellCellsTimeSteps[0].m_wellResultBranches.size(); ++bIdx )
{
int branchErtId = m_wellCellsTimeSteps[0].m_wellResultBranches[bIdx].m_ertBranchId;
const std::vector<RigWellResultPoint>& frameCells = m_wellCellsTimeSteps[0].m_wellResultBranches[bIdx].m_branchResultPoints;
const std::vector<RigWellResultPoint>& frameCells =
m_wellCellsTimeSteps[0].m_wellResultBranches[bIdx].m_branchResultPoints;
std::list<RigWellResultPoint>& branch = staticWellBranches[branchErtId];

28
ApplicationCode/ReservoirDataModel/RigSimulationWellCenterLineCalculator.cpp
View File

@@ -685,8 +685,8 @@ private:
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;
const std::vector<RigWellResultPoint>& orgWellResultPoints =
m_orgWellResultFrame.m_wellResultBranches[0].m_branchResultPoints;
#if 1
if ( wellCellIndices.size() )
@@ -739,8 +739,8 @@ private:
//--------------------------------------------------------------------------------------------------
void buildCellSearchTree()
{
const std::vector<RigWellResultPoint>& orgWellResultPoints = m_orgWellResultFrame.m_wellResultBranches[0]
.m_branchResultPoints;
const std::vector<RigWellResultPoint>& orgWellResultPoints =
m_orgWellResultFrame.m_wellResultBranches[0].m_branchResultPoints;
size_t cellCount = orgWellResultPoints.size();
m_cellBoundingBoxes.resize( cellCount );
@@ -775,8 +775,8 @@ private:
//--------------------------------------------------------------------------------------------------
void buildCellsToNeighborsMap()
{
const std::vector<RigWellResultPoint>& orgWellResultPoints = m_orgWellResultFrame.m_wellResultBranches[0]
.m_branchResultPoints;
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;
@@ -837,8 +837,8 @@ private:
//--------------------------------------------------------------------------------------------------
void buildUnusedCellsSet()
{
const std::vector<RigWellResultPoint>& orgWellResultPoints = m_orgWellResultFrame.m_wellResultBranches[0]
.m_branchResultPoints;
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 )
@@ -911,10 +911,10 @@ private:
//--------------------------------------------------------------------------------------------------
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;
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 )
{
@@ -1073,8 +1073,8 @@ private:
//--------------------------------------------------------------------------------------------------
double calculateWellCellToPointDistance( size_t wellCellIdx, const cvf::Vec3d& point )
{
const std::vector<RigWellResultPoint>& orgWellResultPoints = m_orgWellResultFrame.m_wellResultBranches[0]
.m_branchResultPoints;
const std::vector<RigWellResultPoint>& orgWellResultPoints =
m_orgWellResultFrame.m_wellResultBranches[0].m_branchResultPoints;
const RigCell& c = m_eclipseCaseData->cellFromWellResultCell( orgWellResultPoints[wellCellIdx] );

8
ApplicationCode/ReservoirDataModel/RigWellPathGeometryTools.cpp
View File

@@ -57,8 +57,8 @@ std::vector<cvf::Vec3d> RigWellPathGeometryTools::calculateLineSegmentNormals( c
cvf::Vec3d normal( 0, 0, 0 );
if ( cvf::Math::abs( tangent * projectionPlaneNormal ) < 0.7071 )
{
cvf::Vec3d projectedTangent = ( tangent - ( tangent * projectionPlaneNormal ) * projectionPlaneNormal )
.getNormalized();
cvf::Vec3d projectedTangent =
( tangent - ( tangent * projectionPlaneNormal ) * projectionPlaneNormal ).getNormalized();
normal = ( projectedTangent ^ projectionPlaneNormal ).getNormalized();
normal = normal.getTransformedVector( cvf::Mat3d::fromRotation( tangent, planeAngle ) );
}
@@ -217,8 +217,8 @@ std::vector<cvf::Vec3d> RigWellPathGeometryTools::interpolateUndefinedNormals( c
if ( lastNormalNonInterpolated.length() > 0.0 && nextNormal.length() > 0.0 )
{
// Both last and next are acceptable, interpolate!
currentNormal = ( distanceToNext * lastNormalNonInterpolated + distanceFromLast * nextNormal )
.getNormalized();
currentNormal =
( distanceToNext * lastNormalNonInterpolated + distanceFromLast * nextNormal ).getNormalized();
}
else if ( lastNormalNonInterpolated.length() > 0.0 )
{