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

Merge pull request #4980 from OPM/adjust-clang-format

Browse Source 
Adjust clang-format settings
This commit is contained in:
Magne Sjaastad 2019-11-04 20:29:09 +01:00 committed by GitHub
commit 03d13f668b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
168 changed files with 1091 additions and 921 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
ApplicationCode/.clang-format
View File

@ -8,7 +8,7 @@ AlignConsecutiveDeclarations: true
AlignEscapedNewlinesLeft: true
AlignOperands: true
AlignTrailingComments: false
AllowAllParametersOfDeclarationOnNextLine: true
AllowAllParametersOfDeclarationOnNextLine: false
AllowShortBlocksOnASingleLine: false
AllowShortCaseLabelsOnASingleLine: false
AllowShortIfStatementsOnASingleLine: true
@ -52,7 +52,7 @@ MacroBlockBegin: ''
MacroBlockEnd: ''
MaxEmptyLinesToKeep: 1
NamespaceIndentation: Inner
PenaltyBreakAssignment: 200
PenaltyBreakAssignment: 130
PenaltyBreakBeforeFirstCallParameter: 100000
PenaltyBreakComment: 300
PenaltyBreakFirstLessLess: 120

3
ApplicationCode/Application/RiaApplication.cpp
View File

@ -1196,7 +1196,8 @@ void RiaApplication::applyPreferences()
//--------------------------------------------------------------------------------------------------
QString RiaApplication::commandLineParameterHelp()
{
QString helpText = QString( "\n%1 v. %2\n" ).arg( RI_APPLICATION_NAME ).arg( RiaApplication::getVersionStringApp( false ) );
QString helpText =
QString( "\n%1 v. %2\n" ).arg( RI_APPLICATION_NAME ).arg( RiaApplication::getVersionStringApp( false ) );
helpText += "Copyright Equinor ASA, Ceetron Solution AS, Ceetron AS\n\n";
helpText += m_commandLineHelpText;

4
ApplicationCode/Application/RiaGuiApplication.cpp
View File

@ -1592,8 +1592,8 @@ void RiaGuiApplication::applyGuiPreferences( const RiaPreferences* oldPreference
if ( gridView && gridView->annotationCollection() )
{
RiaFontCache::FontSize oldFontSize = oldPreferences->defaultAnnotationFontSize();
existingObjectsWithCustomFonts = gridView->annotationCollection()
->hasTextAnnotationsWithCustomFontSize( oldFontSize );
existingObjectsWithCustomFonts =
gridView->annotationCollection()->hasTextAnnotationsWithCustomFontSize( oldFontSize );
}
RimEclipseView* eclipseView = dynamic_cast<RimEclipseView*>( rim3dView );
if ( eclipseView )

3
ApplicationCode/Application/RiaMemoryCleanup.cpp
View File

@ -280,7 +280,8 @@ QList<caf::PdmOptionItemInfo> RiaMemoryCleanup::calculateValueOptions( const caf
const RigFemResultAddress& result = m_geomResultAddresses[i];
bool inUse = resultsInUse.count( result );
QString posText = caf::AppEnum<RigFemResultPosEnum>::uiTextFromIndex( result.resultPosType );
QString resultsText = QString( "%1, %2" ).arg( posText ).arg( QString::fromStdString( result.fieldName ) );
QString resultsText =
QString( "%1, %2" ).arg( posText ).arg( QString::fromStdString( result.fieldName ) );
if ( !result.componentName.empty() )
{
resultsText += QString( ", %1" ).arg( QString::fromStdString( result.componentName ) );

7
ApplicationCode/Application/Tools/RiaProjectFileVersionTools.cpp
View File

@ -61,8 +61,11 @@ bool RiaProjectFileVersionTools::isCandidateVersionNewerThanOther( const QString
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiaProjectFileVersionTools::decodeVersionString(
const QString& projectFileVersion, int* majorVersion, int* minorVersion, int* patch, int* developmentId )
void RiaProjectFileVersionTools::decodeVersionString( const QString& projectFileVersion,
int* majorVersion,
int* minorVersion,
int* patch,
int* developmentId )
{
if ( projectFileVersion.isEmpty() ) return;

7
ApplicationCode/Application/Tools/RiaProjectFileVersionTools.h
View File

@ -30,8 +30,11 @@ public:
const QString& otherProjectFileVersion );
// Public to be able to unit test function, not intended to be used
static void decodeVersionString(
const QString& projectFileVersion, int* majorVersion, int* minorVersion, int* patch, int* developmentId );
static void decodeVersionString( const QString& projectFileVersion,
int* majorVersion,
int* minorVersion,
int* patch,
int* developmentId );
private:
static bool isCandidateNewerThanOther( int candidateMajorVersion,

7
ApplicationCode/Application/Tools/RiaRegressionTestRunner.cpp
View File

@ -152,11 +152,8 @@ void RiaRegressionTestRunner::runRegressionTest()
}
}
QString htmlReportFileName = generateHtmlReport( folderList,
baseFolderName,
generatedFolderName,
diffFolderName,
testDir );
QString htmlReportFileName =
generateHtmlReport( folderList, baseFolderName, generatedFolderName, diffFolderName, testDir );
if ( regressionTestConfig.openReportInBrowser() )
{

30
ApplicationCode/Application/Tools/WellPathTools/RiaSCurveCalculator.cpp
View File

@ -28,8 +28,14 @@
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiaSCurveCalculator::RiaSCurveCalculator(
cvf::Vec3d p1, double azi1, double inc1, double rad1, cvf::Vec3d p2, double azi2, double inc2, double rad2 )
RiaSCurveCalculator::RiaSCurveCalculator( cvf::Vec3d p1,
double azi1,
double inc1,
double rad1,
cvf::Vec3d p2,
double azi2,
double inc2,
double rad2 )
: m_isCalculationOK( false )
, m_p1( p1 )
, m_p2( p2 )
@ -145,8 +151,14 @@ RiaSCurveCalculator::RiaSCurveCalculator( cvf::Vec3d p1, cvf::Vec3d q1, cvf::Vec
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiaSCurveCalculator RiaSCurveCalculator::fromTangentsAndLength(
cvf::Vec3d p1, double azi1, double inc1, double lengthToQ1, cvf::Vec3d p2, double azi2, double inc2, double lengthToQ2 )
RiaSCurveCalculator RiaSCurveCalculator::fromTangentsAndLength( cvf::Vec3d p1,
double azi1,
double inc1,
double lengthToQ1,
cvf::Vec3d p2,
double azi2,
double inc2,
double lengthToQ2 )
{
cvf::Vec3d t1( RiaOffshoreSphericalCoords::unitVectorFromAziInc( azi1, inc1 ) );
cvf::Vec3d t2( RiaOffshoreSphericalCoords::unitVectorFromAziInc( azi2, inc2 ) );
@ -209,8 +221,14 @@ bool isZeroCrossing( double newError, double oldError, double maxError )
/// R1(q1, q2), R2(q1, q2)
///
//--------------------------------------------------------------------------------------------------
void RiaSCurveCalculator::initializeByFinding_q1q2(
cvf::Vec3d p1, double azi1, double inc1, double r1, cvf::Vec3d p2, double azi2, double inc2, double r2 )
void RiaSCurveCalculator::initializeByFinding_q1q2( cvf::Vec3d p1,
double azi1,
double inc1,
double r1,
cvf::Vec3d p2,
double azi2,
double inc2,
double r2 )
{
// Algorithm options

13
ApplicationCode/Application/Tools/WellPathTools/RiaSCurveCalculator.h
View File

@ -23,8 +23,7 @@
class RiaSCurveCalculator
{
public:
RiaSCurveCalculator(
cvf::Vec3d p1, double azi1, double inc1, double r1, cvf::Vec3d p2, double azi2, double inc2, double r2 );
RiaSCurveCalculator( cvf::Vec3d p1, double azi1, double inc1, double r1, cvf::Vec3d p2, double azi2, double inc2, double r2 );
RiaSCurveCalculator( cvf::Vec3d p1, cvf::Vec3d q1, cvf::Vec3d p2, cvf::Vec3d q2 );
@ -105,8 +104,14 @@ public:
double lengthToQ2 );
private:
void initializeByFinding_q1q2(
cvf::Vec3d p1, double azi1, double inc1, double r1, cvf::Vec3d p2, double azi2, double inc2, double r2 );
void initializeByFinding_q1q2( cvf::Vec3d p1,
double azi1,
double inc1,
double r1,
cvf::Vec3d p2,
double azi2,
double inc2,
double r2 );
bool m_isCalculationOK;

4
ApplicationCode/CommandFileInterface/Core/RicfFieldCapability.cpp
View File

@ -145,8 +145,8 @@ void RicfFieldReader<bool>::readFieldData( bool& fieldValue,
{
QString formatString(
"Boolean argument \"%1\" for the command \"%2\" does not evaluate to either true or false" );
QString errorMessage = formatString.arg( errorMessageContainer->currentArgument )
.arg( errorMessageContainer->currentCommand );
QString errorMessage =
formatString.arg( errorMessageContainer->currentArgument ).arg( errorMessageContainer->currentCommand );
errorMessageContainer->addError( errorMessage );
}
fieldValue = evaluatesToTrue;

4
ApplicationCode/CommandFileInterface/RicfComputeCaseGroupStatistics.cpp
View File

@ -95,8 +95,8 @@ RicfCommandResponse RicfComputeCaseGroupStatistics::execute()
if ( !foundCase )
{
QString warning = QString( "computeCaseGroupStatistics: Could not find statistics case with ID %1." )
.arg( caseId );
QString warning =
QString( "computeCaseGroupStatistics: Could not find statistics case with ID %1." ).arg( caseId );
RiaLogging::warning( warning );
response.updateStatus( RicfCommandResponse::COMMAND_WARNING, warning );

3
ApplicationCode/CommandFileInterface/RicfExportFlowCharacteristics.cpp
View File

@ -86,7 +86,8 @@ RicfCommandResponse RicfExportFlowCharacteristics::execute()
exportFileName = exportFolder + "/" + fi.fileName();
}
RimFlowPlotCollection* flowPlotColl = RiaApplication::instance()->project()->mainPlotCollection->flowPlotCollection();
RimFlowPlotCollection* flowPlotColl =
RiaApplication::instance()->project()->mainPlotCollection->flowPlotCollection();
if ( flowPlotColl )
{
RimFlowCharacteristicsPlot* plot = flowPlotColl->defaultFlowCharacteristicsPlot();

4
ApplicationCode/CommandFileInterface/RicfExportWellPathCompletions.cpp
View File

@ -176,8 +176,8 @@ RicfCommandResponse RicfExportWellPathCompletions::execute()
}
else
{
QString warning = QString( "exportWellPathCompletions: Could not find well path with name %1" )
.arg( wellPathName );
QString warning =
QString( "exportWellPathCompletions: Could not find well path with name %1" ).arg( wellPathName );
RiaLogging::warning( warning );
response.updateStatus( RicfCommandResponse::COMMAND_WARNING, warning );
}

4
ApplicationCode/Commands/CompletionCommands/RicExportFishbonesLateralsFeature.cpp
View File

@ -76,8 +76,8 @@ void RicExportFishbonesLateralsFeature::onActionTriggered( bool isChecked )
{
for ( size_t lateralIndex : sub.lateralIndices )
{
std::vector<std::pair<cvf::Vec3d, double>> coordsAndMD = fishbone->coordsAndMDForLateral( sub.subIndex,
lateralIndex );
std::vector<std::pair<cvf::Vec3d, double>> coordsAndMD =
fishbone->coordsAndMDForLateral( sub.subIndex, lateralIndex );
std::vector<cvf::Vec3d> lateralCoords;
std::vector<double> lateralMDs;

4
ApplicationCode/Commands/CompletionCommands/RicNewFishbonesSubsFeature.cpp
View File

@ -115,8 +115,8 @@ RimFishbonesCollection* RicNewFishbonesSubsFeature::selectedFishbonesCollection(
{
return wellPaths[0]->fishbonesCollection();
}
RimWellPathCompletions* completions = caf::SelectionManager::instance()
->selectedItemOfType<RimWellPathCompletions>();
RimWellPathCompletions* completions =
caf::SelectionManager::instance()->selectedItemOfType<RimWellPathCompletions>();
if ( completions )
{
return completions->fishbonesCollection();

4
ApplicationCode/Commands/CompletionCommands/RicNewPerforationIntervalFeature.cpp
View File

@ -99,8 +99,8 @@ RimPerforationCollection* RicNewPerforationIntervalFeature::selectedPerforationC
RimWellPath* wellPath = dynamic_cast<RimWellPath*>( objHandle );
if ( wellPath ) return wellPath->perforationIntervalCollection();
RimWellPathCompletions* completions = caf::SelectionManager::instance()
->selectedItemOfType<RimWellPathCompletions>();
RimWellPathCompletions* completions =
caf::SelectionManager::instance()->selectedItemOfType<RimWellPathCompletions>();
if ( completions ) return completions->perforationCollection();
}
return nullptr;

3
ApplicationCode/Commands/CompletionExportCommands/RicExportCompletionDataSettingsUi.cpp
View File

@ -257,7 +257,8 @@ QList<caf::PdmOptionItemInfo>
wellList = candidateWellList;
}
QString wellStringWithPressure = QString( "%1 (%2)" ).arg( it->second[w].first ).arg( it->second[w].second );
QString wellStringWithPressure =
QString( "%1 (%2)" ).arg( it->second[w].first ).arg( it->second[w].second );
QStringList candidateWellPressureList = wellPressureList;
candidateWellPressureList << wellStringWithPressure;
if ( startStringFormat.arg( candidateWellPressureList.join( ", " ) ).length() < maxStringLength )

12
ApplicationCode/Commands/CompletionExportCommands/RicExportCompletionsWellSegmentsFeature.cpp
View File

@ -63,12 +63,12 @@ void RicExportCompletionsWellSegmentsFeature::onActionTriggered( bool isChecked
RimWellPath* wellPath = caf::SelectionManager::instance()->selectedItemAncestorOfType<RimWellPath>();
CVF_ASSERT( wellPath );
RimFishbonesCollection* fishbonesCollection = caf::SelectionManager::instance()
->selectedItemAncestorOfType<RimFishbonesCollection>();
RimWellPathFractureCollection* fractureCollection = caf::SelectionManager::instance()
->selectedItemAncestorOfType<RimWellPathFractureCollection>();
RimPerforationCollection* perforationCollection = caf::SelectionManager::instance()
->selectedItemAncestorOfType<RimPerforationCollection>();
RimFishbonesCollection* fishbonesCollection =
caf::SelectionManager::instance()->selectedItemAncestorOfType<RimFishbonesCollection>();
RimWellPathFractureCollection* fractureCollection =
caf::SelectionManager::instance()->selectedItemAncestorOfType<RimWellPathFractureCollection>();
RimPerforationCollection* perforationCollection =
caf::SelectionManager::instance()->selectedItemAncestorOfType<RimPerforationCollection>();
CVF_ASSERT( fishbonesCollection || fractureCollection || perforationCollection );

14
ApplicationCode/Commands/CompletionExportCommands/RicExportFractureCompletionsImpl.cpp
View File

@ -368,11 +368,8 @@ std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateCompdat
}
}
std::vector<RigCompletionData> allCompletionsForOneFracture = generateCompdatValuesForFracture( matrixToWellTrans,
wellNameForExport,
caseToApply,
fracture,
fracTemplate );
std::vector<RigCompletionData> allCompletionsForOneFracture =
generateCompdatValuesForFracture( matrixToWellTrans, wellNameForExport, caseToApply, fracture, fracTemplate );
if ( fractureDataReportItems )
{
@ -531,7 +528,9 @@ bool RicExportFractureCompletionsImpl::checkForStimPlanConductivity( const RimFr
///
//--------------------------------------------------------------------------------------------------
void RicExportFractureCompletionsImpl::calculateInternalFractureTransmissibilities(
const RigFractureGrid* fractureGrid, double cDarcyInCorrectUnit, RigTransmissibilityCondenser& transCondenser )
const RigFractureGrid* fractureGrid,
double cDarcyInCorrectUnit,
RigTransmissibilityCondenser& transCondenser )
{
for ( size_t i = 0; i < fractureGrid->iCellCount(); i++ )
{
@ -732,7 +731,8 @@ std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateCompdat
///
//--------------------------------------------------------------------------------------------------
void RicExportFractureCompletionsImpl::computeNonDarcyFlowParameters(
const RimFracture* fracture, std::vector<RigCompletionData>& allCompletionsForOneFracture )
const RimFracture* fracture,
std::vector<RigCompletionData>& allCompletionsForOneFracture )
{
double dFactorForFracture = fracture->nonDarcyProperties().dFactor;
double khForFracture = fracture->nonDarcyProperties().conductivity;

18
ApplicationCode/Commands/CompletionExportCommands/RicFishbonesTransmissibilityCalculationFeatureImp.cpp
View File

@ -46,8 +46,11 @@
//==================================================================================================
struct WellBorePartForTransCalc
{
WellBorePartForTransCalc(
cvf::Vec3d lengthsInCell, double wellRadius, double skinFactor, bool isMainBore, const QString& metaData )
WellBorePartForTransCalc( cvf::Vec3d lengthsInCell,
double wellRadius,
double skinFactor,
bool isMainBore,
const QString& metaData )
: lengthsInCell( lengthsInCell )
, wellRadius( wellRadius )
, skinFactor( skinFactor )
@ -79,7 +82,8 @@ struct WellBorePartForTransCalc
//--------------------------------------------------------------------------------------------------
std::vector<RigCompletionData>
RicFishbonesTransmissibilityCalculationFeatureImp::generateFishboneCompdatValuesUsingAdjustedCellVolume(
const RimWellPath* wellPath, const RicExportCompletionDataSettingsUi& settings )
const RimWellPath* wellPath,
const RicExportCompletionDataSettingsUi& settings )
{
std::vector<RigCompletionData> completionData;
@ -211,10 +215,10 @@ void RicFishbonesTransmissibilityCalculationFeatureImp::findFishboneLateralsWell
{
for ( std::shared_ptr<RicMswSubSegmentCellIntersection> intersection : segment->intersections() )
{
double diameter = location->holeDiameter();
QString completionMetaData = ( location->label() + QString( ": Sub: %1 Lateral: %2" )
.arg( location->subIndex() )
.arg( completion->index() ) );
double diameter = location->holeDiameter();
QString completionMetaData =
( location->label() +
QString( ": Sub: %1 Lateral: %2" ).arg( location->subIndex() ).arg( completion->index() ) );
WellBorePartForTransCalc wellBorePart = WellBorePartForTransCalc( intersection->lengthsInCell(),
diameter / 2.0,

8
ApplicationCode/Commands/CompletionExportCommands/RicWellPathExportCompletionDataFeature.cpp
View File

@ -50,7 +50,9 @@ CAF_CMD_SOURCE_INIT( RicWellPathExportCompletionDataFeature, "RicWellPathExportC
///
//--------------------------------------------------------------------------------------------------
void RicWellPathExportCompletionDataFeature::prepareExportSettingsAndExportCompletions(
const QString& dialogTitle, const std::vector<RimWellPath*>& wellPaths, const std::vector<RimSimWellInView*>& simWells )
const QString& dialogTitle,
const std::vector<RimWellPath*>& wellPaths,
const std::vector<RimSimWellInView*>& simWells )
{
RiaApplication* app = RiaApplication::instance();
RimProject* project = app->project();
@ -210,8 +212,8 @@ std::vector<RimWellPath*> RicWellPathExportCompletionDataFeature::selectedWellPa
if ( wellPaths.empty() )
{
RimWellPathCompletions* completions = caf::SelectionManager::instance()
->selectedItemAncestorOfType<RimWellPathCompletions>();
RimWellPathCompletions* completions =
caf::SelectionManager::instance()->selectedItemAncestorOfType<RimWellPathCompletions>();
if ( completions )
{
RimWellPath* wellPath = nullptr;

49
ApplicationCode/Commands/CompletionExportCommands/RicWellPathExportCompletionDataFeatureImpl.cpp
View File

@ -460,8 +460,10 @@ std::vector<RigCompletionData>
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RigCompletionData> RicWellPathExportCompletionDataFeatureImpl::computeDynamicCompletionsForWellPath(
RimWellPath* wellPath, RimEclipseCase* eclipseCase, size_t timeStepIndex )
std::vector<RigCompletionData>
RicWellPathExportCompletionDataFeatureImpl::computeDynamicCompletionsForWellPath( RimWellPath* wellPath,
RimEclipseCase* eclipseCase,
size_t timeStepIndex )
{
std::vector<RigCompletionData> completionsPerEclipseCell;
@ -474,10 +476,10 @@ std::vector<RigCompletionData> RicWellPathExportCompletionDataFeatureImpl::compu
exportSettings.includePerforations = true;
exportSettings.includeFractures = true;
completionsPerEclipseCell = generatePerforationsCompdatValues( wellPath,
wellPath->perforationIntervalCollection()
->perforations(),
exportSettings );
completionsPerEclipseCell =
generatePerforationsCompdatValues( wellPath,
wellPath->perforationIntervalCollection()->perforations(),
exportSettings );
}
return completionsPerEclipseCell;
@ -487,7 +489,8 @@ std::vector<RigCompletionData> RicWellPathExportCompletionDataFeatureImpl::compu
///
//==================================================================================================
RigCompletionData RicWellPathExportCompletionDataFeatureImpl::combineEclipseCellCompletions(
const std::vector<RigCompletionData>& completions, const RicExportCompletionDataSettingsUi& settings )
const std::vector<RigCompletionData>& completions,
const RicExportCompletionDataSettingsUi& settings )
{
CVF_ASSERT( !completions.empty() );
@ -780,7 +783,9 @@ void RicWellPathExportCompletionDataFeatureImpl::exportWelspecsToFile( RimEclips
///
//--------------------------------------------------------------------------------------------------
void RicWellPathExportCompletionDataFeatureImpl::exportWelspeclToFile(
RimEclipseCase* gridCase, QFilePtr exportFile, const std::map<QString, std::vector<RigCompletionData>>& completions )
RimEclipseCase* gridCase,
QFilePtr exportFile,
const std::map<QString, std::vector<RigCompletionData>>& completions )
{
QTextStream stream( exportFile.get() );
@ -958,7 +963,9 @@ void RicWellPathExportCompletionDataFeatureImpl::exportCompdatAndWpimultTables(
///
//--------------------------------------------------------------------------------------------------
void RicWellPathExportCompletionDataFeatureImpl::exportCompdatTableUsingFormatter(
RifTextDataTableFormatter& formatter, const QString& gridName, const std::vector<RigCompletionData>& completionData )
RifTextDataTableFormatter& formatter,
const QString& gridName,
const std::vector<RigCompletionData>& completionData )
{
std::vector<RifTextDataTableColumn> header;
@ -1094,7 +1101,9 @@ void RicWellPathExportCompletionDataFeatureImpl::exportCompdatTableUsingFormatte
///
//--------------------------------------------------------------------------------------------------
void RicWellPathExportCompletionDataFeatureImpl::exportWpimultTableUsingFormatter(
RifTextDataTableFormatter& formatter, const QString& gridName, const std::vector<RigCompletionData>& completionData )
RifTextDataTableFormatter& formatter,
const QString& gridName,
const std::vector<RigCompletionData>& completionData )
{
std::vector<RifTextDataTableColumn> header;
@ -1192,8 +1201,8 @@ std::vector<RigCompletionData> RicWellPathExportCompletionDataFeatureImpl::gener
cell.globCellIndex,
cell.intersectionLengthsInCellCS );
const RimNonDarcyPerforationParameters* nonDarcyParameters = wellPath->perforationIntervalCollection()
->nonDarcyParameters();
const RimNonDarcyPerforationParameters* nonDarcyParameters =
wellPath->perforationIntervalCollection()->nonDarcyParameters();
double transmissibility = 0.0;
double kh = RigCompletionData::defaultValue();
@ -1429,7 +1438,8 @@ TransmissibilityData
const double totalKh = RigTransmissibilityEquations::totalKh( permx, permy, permz, internalCellLengths, latNtg, ntg );
const double effectiveK = RigTransmissibilityEquations::effectiveK( permx, permy, permz, internalCellLengths, latNtg, ntg );
const double effectiveK =
RigTransmissibilityEquations::effectiveK( permx, permy, permz, internalCellLengths, latNtg, ntg );
const double effectiveH = RigTransmissibilityEquations::effectiveH( internalCellLengths, latNtg, ntg );
double darcy = RiaEclipseUnitTools::darcysConstant( wellPath->unitSystem() );
@ -1531,8 +1541,11 @@ double RicWellPathExportCompletionDataFeatureImpl::calculateDFactor( RimEclipseC
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RicWellPathExportCompletionDataFeatureImpl::calculateTransmissibilityAsEclipseDoes(
RimEclipseCase* eclipseCase, double skinFactor, double wellRadius, size_t globalCellIndex, CellDirection direction )
double RicWellPathExportCompletionDataFeatureImpl::calculateTransmissibilityAsEclipseDoes( RimEclipseCase* eclipseCase,
double skinFactor,
double wellRadius,
size_t globalCellIndex,
CellDirection direction )
{
RigEclipseCaseData* eclipseCaseData = eclipseCase->eclipseCaseData();
@ -1651,8 +1664,10 @@ double RicWellPathExportCompletionDataFeatureImpl::calculateTransmissibilityAsEc
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::pair<double, cvf::Vec2i> RicWellPathExportCompletionDataFeatureImpl::wellPathUpperGridIntersectionIJ(
const RimEclipseCase* gridCase, const RimWellPath* wellPath, const QString& gridName )
std::pair<double, cvf::Vec2i>
RicWellPathExportCompletionDataFeatureImpl::wellPathUpperGridIntersectionIJ( const RimEclipseCase* gridCase,
const RimWellPath* wellPath,
const QString& gridName )
{
const RigEclipseCaseData* caseData = gridCase->eclipseCaseData();
const RigMainGrid* mainGrid = caseData->mainGrid();

35
ApplicationCode/Commands/CompletionExportCommands/RicWellPathExportMswCompletionsImpl.cpp
View File

@ -59,8 +59,12 @@
class SubSegmentIntersectionInfo
{
public:
SubSegmentIntersectionInfo(
size_t globCellIndex, double startTVD, double endTVD, double startMD, double endMD, cvf::Vec3d lengthsInCell );
SubSegmentIntersectionInfo( size_t globCellIndex,
double startTVD,
double endTVD,
double startMD,
double endMD,
cvf::Vec3d lengthsInCell );
static std::vector<SubSegmentIntersectionInfo>
spiltIntersectionSegmentsToMaxLength( const RigWellPath* pathGeometry,
const std::vector<WellPathCellIntersectionInfo>& intersections,
@ -79,13 +83,14 @@ public:
///
//--------------------------------------------------------------------------------------------------
void RicWellPathExportMswCompletionsImpl::exportWellSegmentsForAllCompletions(
const RicExportCompletionDataSettingsUi& exportSettings, const std::vector<RimWellPath*>& wellPaths )
const RicExportCompletionDataSettingsUi& exportSettings,
const std::vector<RimWellPath*>& wellPaths )
{
std::shared_ptr<QFile> unifiedExportFile;
if ( exportSettings.fileSplit() == RicExportCompletionDataSettingsUi::UNIFIED_FILE )
{
QString unifiedFileName = QString( "UnifiedCompletions_MSW_%1" )
.arg( exportSettings.caseToApply->caseUserDescription() );
QString unifiedFileName =
QString( "UnifiedCompletions_MSW_%1" ).arg( exportSettings.caseToApply->caseUserDescription() );
unifiedExportFile = RicWellPathExportCompletionsFileTools::openFileForExport( exportSettings.folder,
unifiedFileName );
}
@ -436,7 +441,8 @@ void RicWellPathExportMswCompletionsImpl::generateWelsegsSegments(
///
//--------------------------------------------------------------------------------------------------
void RicWellPathExportMswCompletionsImpl::generateWelsegsCompletionCommentHeader(
RifTextDataTableFormatter& formatter, RigCompletionData::CompletionType completionType )
RifTextDataTableFormatter& formatter,
RigCompletionData::CompletionType completionType )
{
if ( completionType == RigCompletionData::CT_UNDEFINED )
{
@ -921,7 +927,9 @@ RicMswExportInfo RicWellPathExportMswCompletionsImpl::generateFracturesMswExport
///
//--------------------------------------------------------------------------------------------------
RicMswExportInfo RicWellPathExportMswCompletionsImpl::generateFracturesMswExportInfo(
RimEclipseCase* caseToApply, const RimWellPath* wellPath, const std::vector<RimWellPathFracture*>& fractures )
RimEclipseCase* caseToApply,
const RimWellPath* wellPath,
const std::vector<RimWellPathFracture*>& fractures )
{
const RigMainGrid* grid = caseToApply->eclipseCaseData()->mainGrid();
const RigActiveCellInfo* activeCellInfo = caseToApply->eclipseCaseData()->activeCellInfo( RiaDefines::MATRIX_MODEL );
@ -1611,7 +1619,10 @@ void RicWellPathExportMswCompletionsImpl::assignFractureIntersections( const Rim
///
//--------------------------------------------------------------------------------------------------
std::vector<RigCompletionData> RicWellPathExportMswCompletionsImpl::generatePerforationIntersections(
const RimWellPath* wellPath, const RimPerforationInterval* perforationInterval, int timeStep, RimEclipseCase* eclipseCase )
const RimWellPath* wellPath,
const RimPerforationInterval* perforationInterval,
int timeStep,
RimEclipseCase* eclipseCase )
{
std::vector<RigCompletionData> completionData;
const RigActiveCellInfo* activeCellInfo = eclipseCase->eclipseCaseData()->activeCellInfo( RiaDefines::MATRIX_MODEL );
@ -1757,8 +1768,12 @@ void RicWellPathExportMswCompletionsImpl::assignBranchAndSegmentNumbers( const R
}
}
SubSegmentIntersectionInfo::SubSegmentIntersectionInfo(
size_t globCellIndex, double startTVD, double endTVD, double startMD, double endMD, cvf::Vec3d lengthsInCell )
SubSegmentIntersectionInfo::SubSegmentIntersectionInfo( size_t globCellIndex,
double startTVD,
double endTVD,
double startMD,
double endMD,
cvf::Vec3d lengthsInCell )
: globCellIndex( globCellIndex )
, startTVD( startTVD )
, endTVD( endTVD )

7
ApplicationCode/Commands/CrossSectionCommands/RicCopyIntersectionsToAllViewsInCaseFeature.cpp
View File

@ -109,8 +109,8 @@ void RicCopyIntersectionsToAllViewsInCaseFeature::setupActionLook( QAction* acti
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicCopyIntersectionsToAllViewsInCaseFeature::copyIntersectionsToOtherViews(
RimCase& gridCase, std::vector<RimIntersection*> intersections )
void RicCopyIntersectionsToAllViewsInCaseFeature::copyIntersectionsToOtherViews( RimCase& gridCase,
std::vector<RimIntersection*> intersections )
{
for ( RimIntersection* intersection : intersections )
{
@ -142,7 +142,8 @@ void RicCopyIntersectionsToAllViewsInCaseFeature::copyIntersectionsToOtherViews(
///
//--------------------------------------------------------------------------------------------------
void RicCopyIntersectionsToAllViewsInCaseFeature::copyIntersectionBoxesToOtherViews(
RimCase& gridCase, std::vector<RimIntersectionBox*> intersectionBoxes )
RimCase& gridCase,
std::vector<RimIntersectionBox*> intersectionBoxes )
{
for ( RimIntersectionBox* intersectionBox : intersectionBoxes )
{

4
ApplicationCode/Commands/CrossSectionCommands/RicNewWellPathIntersectionFeature.cpp
View File

@ -79,8 +79,8 @@ void RicNewWellPathIntersectionFeature::setupActionLook( QAction* actionToSetup
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RicNewWellPathIntersectionFeatureCmd::RicNewWellPathIntersectionFeatureCmd(
RimIntersectionCollection* intersectionCollection, RimWellPath* wellPath )
RicNewWellPathIntersectionFeatureCmd::RicNewWellPathIntersectionFeatureCmd( RimIntersectionCollection* intersectionCollection,
RimWellPath* wellPath )
: CmdExecuteCommand( nullptr )
, m_intersectionCollection( intersectionCollection )
, m_wellPath( wellPath )

6
ApplicationCode/Commands/ExportCommands/RicAdvancedSnapshotExportFeature.cpp
View File

@ -88,9 +88,9 @@ void RicAdvancedSnapshotExportFeature::onActionTriggered( bool isChecked )
{
QString fallbackFolderName = RiaApplication::instance()->createAbsolutePathFromProjectRelativePath(
"snapshots" );
QString folderName = RiaApplication::instance()
->lastUsedDialogDirectoryWithFallback( "ADVANCED_SNAPSHOT_EXPORT",
fallbackFolderName );
QString folderName =
RiaApplication::instance()->lastUsedDialogDirectoryWithFallback( "ADVANCED_SNAPSHOT_EXPORT",
fallbackFolderName );
dlg.setExportFolder( folderName );
}

6
ApplicationCode/Commands/ExportCommands/RicEclipseCellResultToFileImpl.cpp
View File

@ -79,10 +79,8 @@ bool RicEclipseCellResultToFileImpl::writeBinaryResultToTextFile( const QString&
{
CVF_TIGHT_ASSERT( eclipseCase );
cvf::ref<RigResultAccessor> resultAccessor = RigResultAccessorFactory::createFromResultDefinition( eclipseCase,
0,
timeStep,
resultDefinition );
cvf::ref<RigResultAccessor> resultAccessor =
RigResultAccessorFactory::createFromResultDefinition( eclipseCase, 0, timeStep, resultDefinition );
if ( resultAccessor.isNull() )
{
return false;

3
ApplicationCode/Commands/ExportCommands/RicExportEclipseSectorModelFeature.cpp
View File

@ -70,7 +70,8 @@ void RicExportEclipseSectorModelFeature::openDialogAndExecuteCommand( RimEclipse
cvf::Vec3i min, max;
std::tie( min, max ) = getVisibleCellRange( view, cellVisibility );
RicExportEclipseSectorModelUi* exportSettings = RiaApplication::instance()->project()->dialogData()->exportSectorModelUi();
RicExportEclipseSectorModelUi* exportSettings =
RiaApplication::instance()->project()->dialogData()->exportSectorModelUi();
exportSettings->setCaseData( caseData, min, max );
exportSettings->applyBoundaryDefaults();

6
ApplicationCode/Commands/FlowCommands/RicAddStoredFlowCharacteristicsPlotFeature.cpp
View File

@ -42,7 +42,8 @@ bool RicAddStoredFlowCharacteristicsPlotFeature::isCommandEnabled()
{
if ( RiaApplication::instance()->project() )
{
RimFlowPlotCollection* flowPlotColl = RiaApplication::instance()->project()->mainPlotCollection->flowPlotCollection();
RimFlowPlotCollection* flowPlotColl =
RiaApplication::instance()->project()->mainPlotCollection->flowPlotCollection();
if ( flowPlotColl )
{
RimFlowCharacteristicsPlot* flowCharacteristicsPlot = dynamic_cast<RimFlowCharacteristicsPlot*>(
@ -65,7 +66,8 @@ void RicAddStoredFlowCharacteristicsPlotFeature::onActionTriggered( bool isCheck
{
if ( RiaApplication::instance()->project() )
{
RimFlowPlotCollection* flowPlotColl = RiaApplication::instance()->project()->mainPlotCollection->flowPlotCollection();
RimFlowPlotCollection* flowPlotColl =
RiaApplication::instance()->project()->mainPlotCollection->flowPlotCollection();
if ( flowPlotColl )
{
RimFlowCharacteristicsPlot* sourceObject = dynamic_cast<RimFlowCharacteristicsPlot*>(

6
ApplicationCode/Commands/FlowCommands/RicAddStoredWellAllocationPlotFeature.cpp
View File

@ -42,7 +42,8 @@ bool RicAddStoredWellAllocationPlotFeature::isCommandEnabled()
{
if ( RiaApplication::instance()->project() )
{
RimFlowPlotCollection* flowPlotColl = RiaApplication::instance()->project()->mainPlotCollection->flowPlotCollection();
RimFlowPlotCollection* flowPlotColl =
RiaApplication::instance()->project()->mainPlotCollection->flowPlotCollection();
if ( flowPlotColl )
{
RimWellAllocationPlot* wellAllocationPlot = dynamic_cast<RimWellAllocationPlot*>(
@ -65,7 +66,8 @@ void RicAddStoredWellAllocationPlotFeature::onActionTriggered( bool isChecked )
{
if ( RiaApplication::instance()->project() )
{
RimFlowPlotCollection* flowPlotColl = RiaApplication::instance()->project()->mainPlotCollection->flowPlotCollection();
RimFlowPlotCollection* flowPlotColl =
RiaApplication::instance()->project()->mainPlotCollection->flowPlotCollection();
if ( flowPlotColl )
{
RimWellAllocationPlot* sourceObject = dynamic_cast<RimWellAllocationPlot*>(

8
ApplicationCode/Commands/FlowCommands/RicShowContributingWellsFeature.cpp
View File

@ -89,10 +89,10 @@ void RicShowContributingWellsFeature::onActionTriggered( bool isChecked )
RimEclipseResultCase* eclipseResultCase = nullptr;
well->firstAncestorOrThisOfTypeAsserted( eclipseResultCase );
RimEclipseView* modifiedView = RicShowContributingWellsFeatureImpl::manipulateSelectedView( eclipseResultCase,
well->name(),
eclipseView
->currentTimeStep() );
RimEclipseView* modifiedView =
RicShowContributingWellsFeatureImpl::manipulateSelectedView( eclipseResultCase,
well->name(),
eclipseView->currentTimeStep() );
if ( modifiedView )
{
modifiedView->createDisplayModelAndRedraw();

6
ApplicationCode/Commands/FlowCommands/RicShowContributingWellsFeatureImpl.cpp
View File

@ -178,8 +178,10 @@ void RicShowContributingWellsFeatureImpl::modifyViewToShowContributingWells( Rim
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<QString> RicShowContributingWellsFeatureImpl::findContributingTracerNames(
const RimFlowDiagSolution* flowDiagSolution, const RigSimWellData* simWellData, int timeStep )
std::vector<QString>
RicShowContributingWellsFeatureImpl::findContributingTracerNames( const RimFlowDiagSolution* flowDiagSolution,
const RigSimWellData* simWellData,
int timeStep )
{
std::vector<QString> tracerCellFractionValues;

3
ApplicationCode/Commands/FlowCommands/RicShowWellAllocationPlotFeature.cpp
View File

@ -105,7 +105,8 @@ void RicShowWellAllocationPlotFeature::onActionTriggered( bool isChecked )
if ( RiaApplication::instance()->project() )
{
RimFlowPlotCollection* flowPlotColl = RiaApplication::instance()->project()->mainPlotCollection->flowPlotCollection();
RimFlowPlotCollection* flowPlotColl =
RiaApplication::instance()->project()->mainPlotCollection->flowPlotCollection();
if ( flowPlotColl )
{
flowPlotColl->defaultWellAllocPlot()->setFromSimulationWell( simWell );

4
ApplicationCode/Commands/FractureCommands/RicNewWellPathFractureFeature.cpp
View File

@ -170,8 +170,8 @@ RimWellPathFractureCollection* RicNewWellPathFractureFeature::selectedWellPathFr
{
return wellPaths[0]->fractureCollection();
}
RimWellPathCompletions* completions = caf::SelectionManager::instance()
->selectedItemOfType<RimWellPathCompletions>();
RimWellPathCompletions* completions =
caf::SelectionManager::instance()->selectedItemOfType<RimWellPathCompletions>();
if ( completions )
{
return completions->fractureCollection();

6
ApplicationCode/Commands/GridCrossPlotCommands/RicCreateGridCrossPlotFeature.cpp
View File

@ -50,9 +50,9 @@ bool RicCreateGridCrossPlotFeature::isCommandEnabled()
//--------------------------------------------------------------------------------------------------
void RicCreateGridCrossPlotFeature::onActionTriggered( bool isChecked )
{
RimProject* project = RiaApplication::instance()->project();
RimGridCrossPlotCollection* collection = caf::SelectionManager::instance()
->selectedItemAncestorOfType<RimGridCrossPlotCollection>();
RimProject* project = RiaApplication::instance()->project();
RimGridCrossPlotCollection* collection =
caf::SelectionManager::instance()->selectedItemAncestorOfType<RimGridCrossPlotCollection>();
if ( !collection )
{
collection = project->mainPlotCollection()->gridCrossPlotCollection();

3
ApplicationCode/Commands/HoloLensCommands/RicHoloLensExportToFolderFeature.cpp
View File

@ -56,7 +56,8 @@ void RicHoloLensExportToFolderFeature::onActionTriggered( bool isChecked )
{
RimGridView* activeView = RiaApplication::instance()->activeGridView();
RicHoloLensExportToFolderUi* featureUi = RiaApplication::instance()->project()->dialogData()->holoLensExportToFolderData();
RicHoloLensExportToFolderUi* featureUi =
RiaApplication::instance()->project()->dialogData()->holoLensExportToFolderData();
featureUi->setViewForExport( activeView );
caf::PdmUiPropertyViewDialog propertyDialog( nullptr,

7
ApplicationCode/Commands/HoloLensCommands/VdeCachingHashedIdFactory.cpp
View File

@ -120,8 +120,11 @@ int VdeCachingHashedIdFactory::lastAssignedId() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
int VdeCachingHashedIdFactory::getOrCreateIdForArrOfType(
ArrayRole arrayRole, ElementType elementType, size_t elementSizeInBytes, const void* data, size_t elementCount )
int VdeCachingHashedIdFactory::getOrCreateIdForArrOfType( ArrayRole arrayRole,
ElementType elementType,
size_t elementSizeInBytes,
const void* data,
size_t elementCount )
{
Key key;
key.elementType = elementType;

7
ApplicationCode/Commands/HoloLensCommands/VdeCachingHashedIdFactory.h
View File

@ -64,8 +64,11 @@ private:
};
private:
int getOrCreateIdForArrOfType(
ArrayRole arrayRole, ElementType elementType, size_t elementSizeInBytes, const void* data, size_t elementCount );
int getOrCreateIdForArrOfType( ArrayRole arrayRole,
ElementType elementType,
size_t elementSizeInBytes,
const void* data,
size_t elementCount );
private:
std::map<Key, int> m_keyToIdMap;

25
ApplicationCode/Commands/HoloLensCommands/VdeVizDataExtractor.cpp
View File

@ -116,9 +116,8 @@ void VdeVizDataExtractor::extractViewContents( QString* modelMetaJson
if ( !packetDirectory->lookupPacket( arrayIdsThisMesh.connArrId ) )
{
cvf::Trace::show( " generating connectivities, arrayId=%d", arrayIdsThisMesh.connArrId );
std::unique_ptr<VdeArrayDataPacket> dataPacket = VdeArrayDataPacket::fromUint32Arr( arrayIdsThisMesh.connArrId,
uintArr,
arrElementCount );
std::unique_ptr<VdeArrayDataPacket> dataPacket =
VdeArrayDataPacket::fromUint32Arr( arrayIdsThisMesh.connArrId, uintArr, arrElementCount );
// Debug testing of decoding
// debugComparePackets(*dataPacket, VdeArrayDataPacket::fromRawPacketBuffer(dataPacket->fullPacketRawPtr(),
@ -131,12 +130,12 @@ void VdeVizDataExtractor::extractViewContents( QString* modelMetaJson
if ( mesh->texCoordArr.notNull() && mesh->texImage.notNull() )
{
{
const float* floatArr = reinterpret_cast<const float*>( mesh->texCoordArr->ptr() );
const size_t arrElementCount = 2 * mesh->texCoordArr->size();
arrayIdsThisMesh.texCoordsArrId = m_cachingIdFactory
->getOrCreateIdForFloatArr( VdeCachingHashedIdFactory::TexCoordsArr,
floatArr,
arrElementCount );
const float* floatArr = reinterpret_cast<const float*>( mesh->texCoordArr->ptr() );
const size_t arrElementCount = 2 * mesh->texCoordArr->size();
arrayIdsThisMesh.texCoordsArrId =
m_cachingIdFactory->getOrCreateIdForFloatArr( VdeCachingHashedIdFactory::TexCoordsArr,
floatArr,
arrElementCount );
if ( !packetDirectory->lookupPacket( arrayIdsThisMesh.texCoordsArrId ) )
{
@ -153,10 +152,10 @@ void VdeVizDataExtractor::extractViewContents( QString* modelMetaJson
}
{
cvf::ref<cvf::UByteArray> byteArr = mesh->texImage->toRgb();
arrayIdsThisMesh.texImageArrId = m_cachingIdFactory
->getOrCreateIdForUint8Arr( VdeCachingHashedIdFactory::TexImage,
byteArr->ptr(),
byteArr->size() );
arrayIdsThisMesh.texImageArrId =
m_cachingIdFactory->getOrCreateIdForUint8Arr( VdeCachingHashedIdFactory::TexImage,
byteArr->ptr(),
byteArr->size() );
if ( !packetDirectory->lookupPacket( arrayIdsThisMesh.texImageArrId ) )
{

6
ApplicationCode/Commands/OperationsUsingObjReferences/RicCopyReferencesToClipboardFeature.cpp
View File

@ -72,9 +72,9 @@ void RicCopyReferencesToClipboardFeature::onActionTriggered( bool isChecked )
{
if ( RicCopyReferencesToClipboardFeature::isCopyOfObjectSupported( pdmObject ) )
{
QString itemRef = caf::PdmReferenceHelper::referenceFromRootToObject( caf::SelectionManager::instance()
->pdmRootObject(),
pdmObject );
QString itemRef =
caf::PdmReferenceHelper::referenceFromRootToObject( caf::SelectionManager::instance()->pdmRootObject(),
pdmObject );
referenceList.push_back( itemRef );
}

6
ApplicationCode/Commands/OperationsUsingObjReferences/RicCutReferencesToClipboardFeature.cpp
View File

@ -59,9 +59,9 @@ void RicCutReferencesToClipboardFeature::onActionTriggered( bool isChecked )
{
if ( RicCutReferencesToClipboardFeature::isCuttingOfObjectSupported( pdmObject ) )
{
QString itemRef = caf::PdmReferenceHelper::referenceFromRootToObject( caf::SelectionManager::instance()
->pdmRootObject(),
pdmObject );
QString itemRef =
caf::PdmReferenceHelper::referenceFromRootToObject( caf::SelectionManager::instance()->pdmRootObject(),
pdmObject );
referenceList.push_back( itemRef );
}

3
ApplicationCode/Commands/PlotTemplateCommands/RicSummaryPlotTemplateTools.cpp
View File

@ -89,7 +89,8 @@ void RicSummaryPlotTemplateTools::appendSummaryPlotToPlotCollection(
if ( selectedSummaryCases.empty() && selectedEnsembles.empty() ) return;
RimSummaryPlotCollection* plotColl = RiaApplication::instance()->project()->mainPlotCollection()->summaryPlotCollection();
RimSummaryPlotCollection* plotColl =
RiaApplication::instance()->project()->mainPlotCollection()->summaryPlotCollection();
plotColl->summaryPlots.push_back( summaryPlot );
summaryPlot->resolveReferencesRecursively();

22
ApplicationCode/Commands/RicNewContourMapViewFeature.cpp
View File

@ -54,10 +54,10 @@ bool RicNewContourMapViewFeature::isCommandEnabled()
{
bool selectedView = caf::SelectionManager::instance()->selectedItemOfType<RimGridView>() != nullptr;
bool selectedCase = caf::SelectionManager::instance()->selectedItemOfType<RimCase>() != nullptr;
bool selectedEclipseContourMapCollection = caf::SelectionManager::instance()
->selectedItemOfType<RimEclipseContourMapViewCollection>();
bool selectedGeoMechContourMapCollection = caf::SelectionManager::instance()
->selectedItemOfType<RimGeoMechContourMapViewCollection>();
bool selectedEclipseContourMapCollection =
caf::SelectionManager::instance()->selectedItemOfType<RimEclipseContourMapViewCollection>();
bool selectedGeoMechContourMapCollection =
caf::SelectionManager::instance()->selectedItemOfType<RimGeoMechContourMapViewCollection>();
return selectedView || selectedCase || selectedEclipseContourMapCollection || selectedGeoMechContourMapCollection;
}
@ -67,14 +67,14 @@ bool RicNewContourMapViewFeature::isCommandEnabled()
void RicNewContourMapViewFeature::onActionTriggered( bool isChecked )
{
RimEclipseView* reservoirView = caf::SelectionManager::instance()->selectedItemOfType<RimEclipseView>();
RimEclipseContourMapView* existingEclipseContourMap = caf::SelectionManager::instance()
->selectedItemOfType<RimEclipseContourMapView>();
RimEclipseContourMapView* existingEclipseContourMap =
caf::SelectionManager::instance()->selectedItemOfType<RimEclipseContourMapView>();
RimEclipseCase* eclipseCase = caf::SelectionManager::instance()->selectedItemAncestorOfType<RimEclipseCase>();
RimEclipseContourMapView* eclipseContourMap = nullptr;
RimGeoMechView* geoMechView = caf::SelectionManager::instance()->selectedItemOfType<RimGeoMechView>();
RimGeoMechContourMapView* existingGeoMechContourMap = caf::SelectionManager::instance()
->selectedItemOfType<RimGeoMechContourMapView>();
RimGeoMechContourMapView* existingGeoMechContourMap =
caf::SelectionManager::instance()->selectedItemOfType<RimGeoMechContourMapView>();
RimGeoMechCase* geoMechCase = caf::SelectionManager::instance()->selectedItemAncestorOfType<RimGeoMechCase>();
RimGeoMechContourMapView* geoMechContourMap = nullptr;
@ -166,7 +166,8 @@ void RicNewContourMapViewFeature::setupActionLook( QAction* actionToSetup )
///
//--------------------------------------------------------------------------------------------------
RimEclipseContourMapView* RicNewContourMapViewFeature::createEclipseContourMapFromExistingContourMap(
RimEclipseCase* eclipseCase, RimEclipseContourMapView* existingContourMap )
RimEclipseCase* eclipseCase,
RimEclipseContourMapView* existingContourMap )
{
RimEclipseContourMapView* contourMap = dynamic_cast<RimEclipseContourMapView*>(
existingContourMap->xmlCapability()->copyByXmlSerialization( caf::PdmDefaultObjectFactory::instance() ) );
@ -260,7 +261,8 @@ RimEclipseContourMapView* RicNewContourMapViewFeature::createEclipseContourMap(
///
//--------------------------------------------------------------------------------------------------
RimGeoMechContourMapView* RicNewContourMapViewFeature::createGeoMechContourMapFromExistingContourMap(
RimGeoMechCase* geoMechCase, RimGeoMechContourMapView* existingContourMap )
RimGeoMechCase* geoMechCase,
RimGeoMechContourMapView* existingContourMap )
{
RimGeoMechContourMapView* contourMap = dynamic_cast<RimGeoMechContourMapView*>(
existingContourMap->xmlCapability()->copyByXmlSerialization( caf::PdmDefaultObjectFactory::instance() ) );

4
ApplicationCode/Commands/RicNewGridPlotWindowFeature.cpp
View File

@ -82,8 +82,8 @@ RicfCommandResponse RicNewGridPlotWindowFeature::execute()
//--------------------------------------------------------------------------------------------------
bool RicNewGridPlotWindowFeature::isCommandEnabled()
{
RimGridPlotWindowCollection* gridPlotCollection = caf::SelectionManager::instance()
->selectedItemOfType<RimGridPlotWindowCollection>();
RimGridPlotWindowCollection* gridPlotCollection =
caf::SelectionManager::instance()->selectedItemOfType<RimGridPlotWindowCollection>();
if ( gridPlotCollection )
{
return true;

4
ApplicationCode/Commands/RicSelectOrCreateViewFeatureImpl.cpp
View File

@ -73,8 +73,8 @@ RimEclipseView* RicSelectOrCreateViewFeatureImpl::showViewSelection( RimEclipseR
viewToManipulate = featureUi.selectedView();
}
QString refFromProjectToView = caf::PdmReferenceHelper::referenceFromRootToObject( RiaApplication::instance()->project(),
viewToManipulate );
QString refFromProjectToView =
caf::PdmReferenceHelper::referenceFromRootToObject( RiaApplication::instance()->project(), viewToManipulate );
RiaApplication::instance()->setCacheDataObject( lastUsedViewKey, refFromProjectToView );
return viewToManipulate;

3
ApplicationCode/Commands/SummaryPlotCommands/RicPasteTimeHistoryCurveFeature.cpp
View File

@ -72,7 +72,8 @@ void RicPasteTimeHistoryCurveFeature::onActionTriggered( bool isChecked )
return;
}
std::vector<caf::PdmPointer<RimGridTimeHistoryCurve>> sourceObjects = RicPasteTimeHistoryCurveFeature::timeHistoryCurves();
std::vector<caf::PdmPointer<RimGridTimeHistoryCurve>> sourceObjects =
RicPasteTimeHistoryCurveFeature::timeHistoryCurves();
for ( size_t i = 0; i < sourceObjects.size(); i++ )
{

6
ApplicationCode/Commands/SummaryPlotCommands/RicSummaryCurveCalculator.cpp
View File

@ -155,9 +155,9 @@ void RicSummaryCurveCalculator::defineUiOrdering( QString uiConfigName, caf::Pdm
}
{
caf::PdmUiGroup* group = uiOrdering
.addNewGroupWithKeyword( "Calculated Summaries",
RicSummaryCurveCalculator::calculatedSummariesGroupName() );
caf::PdmUiGroup* group =
uiOrdering.addNewGroupWithKeyword( "Calculated Summaries",
RicSummaryCurveCalculator::calculatedSummariesGroupName() );
group->add( &m_currentCalculation );
group->add( &m_newCalculation );
group->add( &m_deleteCalculation );

3
ApplicationCode/Commands/SummaryPlotCommands/RicSummaryCurveCalculatorEditor.cpp
View File

@ -62,7 +62,8 @@ RicSummaryCurveCalculatorEditor::~RicSummaryCurveCalculatorEditor()
///
//--------------------------------------------------------------------------------------------------
void RicSummaryCurveCalculatorEditor::recursivelyConfigureAndUpdateTopLevelUiOrdering(
const caf::PdmUiOrdering& topLevelUiOrdering, const QString& uiConfigName )
const caf::PdmUiOrdering& topLevelUiOrdering,
const QString& uiConfigName )
{
if ( !m_firstRowLeftLayout || !m_firstRowRightLayout ) return;

3
ApplicationCode/Commands/SummaryPlotCommands/RicSummaryCurveCreatorSplitterUi.cpp
View File

@ -76,7 +76,8 @@ void RicSummaryCurveCreatorSplitterUi::updateFromDefaultSources( const std::vect
///
//--------------------------------------------------------------------------------------------------
void RicSummaryCurveCreatorSplitterUi::recursivelyConfigureAndUpdateTopLevelUiOrdering(
const caf::PdmUiOrdering& topLevelUiOrdering, const QString& uiConfigName )
const caf::PdmUiOrdering& topLevelUiOrdering,
const QString& uiConfigName )
{
const std::vector<caf::PdmUiItem*>& topLevelUiItems = topLevelUiOrdering.uiItems();
if ( m_summaryCurveCreator->isCloseButtonPressed() )

10
ApplicationCode/Commands/SummaryPlotCommands/RicSummaryPlotFeatureImpl.cpp
View File

@ -500,8 +500,8 @@ void RicSummaryPlotFeatureImpl::createSummaryPlotsFromArgumentLine( const QStrin
{
for ( RimSummaryCase* sumCase : summaryCasesToUse )
{
const std::set<RifEclipseSummaryAddress>& allAddrsInCase = sumCase->summaryReader()
->allResultAddresses();
const std::set<RifEclipseSummaryAddress>& allAddrsInCase =
sumCase->summaryReader()->allResultAddresses();
if ( allAddrsInCase.count( addr ) )
{
RimSummaryCurve* newCurve = new RimSummaryCurve();
@ -755,8 +755,10 @@ std::set<RifEclipseSummaryAddress>
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RimSummaryCurve*> RicSummaryPlotFeatureImpl::addCurvesFromAddressFiltersToPlot(
const QStringList& curveFilters, RimSummaryPlot* plot, RimSummaryCase* summaryCase, bool addHistoryCurves )
std::vector<RimSummaryCurve*> RicSummaryPlotFeatureImpl::addCurvesFromAddressFiltersToPlot( const QStringList& curveFilters,
RimSummaryPlot* plot,
RimSummaryCase* summaryCase,
bool addHistoryCurves )
{
std::vector<RimSummaryCurve*> createdCurves;

7
ApplicationCode/Commands/SummaryPlotCommands/RicSummaryPlotFeatureImpl.h
View File

@ -83,8 +83,11 @@ public:
{
}
RigGridCellResultAddress(
size_t gridIndex, size_t i, size_t j, size_t k, const RigEclipseResultAddress& eclipseResultAddress )
RigGridCellResultAddress( size_t gridIndex,
size_t i,
size_t j,
size_t k,
const RigEclipseResultAddress& eclipseResultAddress )
: gridIndex( gridIndex )
, i( i )
, j( j )

13
ApplicationCode/Commands/WellLogCommands/RicNewWellBoreStabilityPlotFeature.cpp
View File

@ -132,8 +132,8 @@ bool RicNewWellBoreStabilityPlotFeature::isCommandEnabled()
void RicNewWellBoreStabilityPlotFeature::onActionTriggered( bool isChecked )
{
RimWellPath* wellPath = caf::SelectionManager::instance()->selectedItemAncestorOfType<RimWellPath>();
RimWellLogPlotCollection* plotCollection = caf::SelectionManager::instance()
->selectedItemOfType<RimWellLogPlotCollection>();
RimWellLogPlotCollection* plotCollection =
caf::SelectionManager::instance()->selectedItemOfType<RimWellLogPlotCollection>();
if ( !wellPath )
{
if ( plotCollection )
@ -293,13 +293,8 @@ void RicNewWellBoreStabilityPlotFeature::createStabilityCurvesTrack( RimWellBore
{
const QString& resultName = resultNames[i];
RigFemResultAddress resAddr( RIG_WELLPATH_DERIVED, resultName.toStdString(), "" );
RimWellLogWbsCurve* curve = RicWellLogTools::addWellLogWbsCurve( stabilityCurvesTrack,
geoMechCase,
nullptr,
wellPath,
-1,
false,
false );
RimWellLogWbsCurve* curve =
RicWellLogTools::addWellLogWbsCurve( stabilityCurvesTrack, geoMechCase, nullptr, wellPath, -1, false, false );
curve->setGeoMechResultAddress( resAddr );
curve->setCurrentTimeStep( timeStep );
curve->setAutoNameComponents( false, true, false, false, false );

10
ApplicationCode/Commands/WellPathCommands/RicCreateWellTargetsPickEventHandler.cpp
View File

@ -108,11 +108,11 @@ bool RicCreateWellTargetsPickEventHandler::handle3dPickEvent( const Ric3dPickEve
intersectionPointInDomain );
double md = wellPathSourceInfo->measuredDepth( firstPickItem.faceIdx(), intersectionPointInDomain );
doSetAzimuthAndInclination = calculateAzimuthAndInclinationAtMd( md,
wellPathSourceInfo->wellPath()
->wellPathGeometry(),
&azimuth,
&inclination );
doSetAzimuthAndInclination =
calculateAzimuthAndInclinationAtMd( md,
wellPathSourceInfo->wellPath()->wellPathGeometry(),
&azimuth,
&inclination );
}
else if ( isGridSourceObject( firstPickItem.sourceInfo() ) )
{

4
ApplicationCode/Commands/WellPathCommands/RicDeleteWellPathAttributeFeature.cpp
View File

@ -71,8 +71,8 @@ void RicDeleteWellPathAttributeFeature::onActionTriggered( bool isChecked )
}
else
{
wellPathAttributeCollection = caf::SelectionManager::instance()
->selectedItemOfType<RimWellPathAttributeCollection>();
wellPathAttributeCollection =
caf::SelectionManager::instance()->selectedItemOfType<RimWellPathAttributeCollection>();
if ( wellPathAttributeCollection )
{
wellPathAttributeCollection->deleteAllAttributes();

10
ApplicationCode/FileInterface/RifEclipseInputFileTools.cpp
View File

@ -789,14 +789,12 @@ std::map<QString, QString> RifEclipseInputFileTools::readProperties( const QStri
fseek( gridFilePointer, fileKeywords[i].filePos, SEEK_SET );
ecl_kw_type* eclipseKeywordData = ecl_kw_fscanf_alloc_current_grdecl__( gridFilePointer,
false,
ecl_type_create_from_type(
ECL_FLOAT_TYPE ) );
ecl_kw_type* eclipseKeywordData =
ecl_kw_fscanf_alloc_current_grdecl__( gridFilePointer, false, ecl_type_create_from_type( ECL_FLOAT_TYPE ) );
if ( eclipseKeywordData )
{
QString newResultName = caseData->results( RiaDefines::MATRIX_MODEL )
->makeResultNameUnique( fileKeywords[i].keyword );
QString newResultName =
caseData->results( RiaDefines::MATRIX_MODEL )->makeResultNameUnique( fileKeywords[i].keyword );
QString errMsg;
if ( readDataFromKeyword( eclipseKeywordData, caseData, newResultName, &errMsg ) )
{

7
ApplicationCode/FileInterface/RifEclipseOutputFileTools.cpp
View File

@ -410,9 +410,10 @@ void RifEclipseOutputFileTools::readGridDimensions( const QString&
// printf("grid:%s has %d a total of %d lgr's \n", grid_filename , stringlist_get_size( lgr_names ));
for ( int lgr_nr = 0; lgr_nr < stringlist_get_size( lgr_names ); lgr_nr++ )
{
ecl_grid_type* lgr_grid = ecl_grid_get_lgr( grid,
stringlist_iget( lgr_names,
lgr_nr ) ); // get the ecl_grid instance of the lgr - by name.
ecl_grid_type* lgr_grid =
ecl_grid_get_lgr( grid,
stringlist_iget( lgr_names,
lgr_nr ) ); // get the ecl_grid instance of the lgr - by name.
int nx, ny, nz, active_size;
ecl_grid_get_dims( lgr_grid, &nx, &ny, &nz, &active_size ); // get some size info from this lgr.

22
ApplicationCode/FileInterface/RifEclipseSummaryAddress.cpp
View File

@ -400,8 +400,11 @@ RifEclipseSummaryAddress RifEclipseSummaryAddress::wellAddress( const std::strin
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RifEclipseSummaryAddress RifEclipseSummaryAddress::wellCompletionAddress(
const std::string& quantityName, const std::string& wellName, int i, int j, int k )
RifEclipseSummaryAddress RifEclipseSummaryAddress::wellCompletionAddress( const std::string& quantityName,
const std::string& wellName,
int i,
int j,
int k )
{
RifEclipseSummaryAddress addr;
addr.m_variableCategory = SUMMARY_WELL_COMPLETION;
@ -431,8 +434,12 @@ RifEclipseSummaryAddress RifEclipseSummaryAddress::wellLgrAddress( const std::st
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RifEclipseSummaryAddress RifEclipseSummaryAddress::wellCompletionLgrAddress(
const std::string& quantityName, const std::string& lgrName, const std::string& wellName, int i, int j, int k )
RifEclipseSummaryAddress RifEclipseSummaryAddress::wellCompletionLgrAddress( const std::string& quantityName,
const std::string& lgrName,
const std::string& wellName,
int i,
int j,
int k )
{
RifEclipseSummaryAddress addr;
addr.m_variableCategory = SUMMARY_WELL_COMPLETION_LGR;
@ -477,8 +484,11 @@ RifEclipseSummaryAddress RifEclipseSummaryAddress::blockAddress( const std::stri
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RifEclipseSummaryAddress RifEclipseSummaryAddress::blockLgrAddress(
const std::string& quantityName, const std::string& lgrName, int i, int j, int k )
RifEclipseSummaryAddress RifEclipseSummaryAddress::blockLgrAddress( const std::string& quantityName,
const std::string& lgrName,
int i,
int j,
int k )
{
RifEclipseSummaryAddress addr;
addr.m_variableCategory = SUMMARY_BLOCK_LGR;

8
ApplicationCode/FileInterface/RifEclipseSummaryAddress.h
View File

@ -136,8 +136,12 @@ public:
wellCompletionAddress( const std::string& quantityName, const std::string& wellName, int i, int j, int k );
static RifEclipseSummaryAddress
wellLgrAddress( const std::string& quantityName, const std::string& lgrName, const std::string& wellName );
static RifEclipseSummaryAddress wellCompletionLgrAddress(
const std::string& quantityName, const std::string& lgrName, const std::string& wellName, int i, int j, int k );
static RifEclipseSummaryAddress wellCompletionLgrAddress( const std::string& quantityName,
const std::string& lgrName,
const std::string& wellName,
int i,
int j,
int k );
static RifEclipseSummaryAddress
wellSegmentAddress( const std::string& quantityName, const std::string& wellName, int segmentNumber );
static RifEclipseSummaryAddress blockAddress( const std::string& quantityName, int i, int j, int k );

7
ApplicationCode/FileInterface/RifEclipseSummaryTools.cpp
View File

@ -159,8 +159,11 @@ void RifEclipseSummaryTools::dumpMetaData( RifSummaryReaderInterface* readerEcli
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RifEclipseSummaryTools::findSummaryHeaderFileInfo(
const QString& inputFile, QString* headerFile, QString* path, QString* base, bool* isFormatted )
void RifEclipseSummaryTools::findSummaryHeaderFileInfo( const QString& inputFile,
QString* headerFile,
QString* path,
QString* base,
bool* isFormatted )
{
char* myPath = nullptr;
char* myBase = nullptr;

7
ApplicationCode/FileInterface/RifEclipseSummaryTools.h
View File

@ -42,6 +42,9 @@ public:
static void dumpMetaData( RifSummaryReaderInterface* readerEclipseSummary );
private:
static void findSummaryHeaderFileInfo(
const QString& inputFile, QString* headerFile, QString* path, QString* base, bool* isFormatted );
static void findSummaryHeaderFileInfo( const QString& inputFile,
QString* headerFile,
QString* path,
QString* base,
bool* isFormatted );
};

6
ApplicationCode/FileInterface/RifEclipseUnifiedRestartFileAccess.cpp
View File

@ -116,9 +116,9 @@ bool RifEclipseUnifiedRestartFileAccess::openFile()
QString resultPath = fi.absolutePath();
if ( caf::Utils::isFolderWritable( resultPath ) )
{
bool success = ecl_file_write_index( m_ecl_file,
RiaStringEncodingTools::toNativeEncoded( indexFileName )
.data() );
bool success =
ecl_file_write_index( m_ecl_file,
RiaStringEncodingTools::toNativeEncoded( indexFileName ).data() );
if ( success )
{

74
ApplicationCode/FileInterface/RifReaderEclipseOutput.cpp
View File

@ -954,14 +954,13 @@ void RifReaderEclipseOutput::buildMetaData( ecl_grid_type* grid )
m_dynamicResultsAccess->resultNames( &resultNames, &resultNamesDataItemCounts );
{
QStringList matrixResultNames = validKeywordsForPorosityModel( resultNames,
resultNamesDataItemCounts,
m_eclipseCase->activeCellInfo(
RiaDefines::MATRIX_MODEL ),
m_eclipseCase->activeCellInfo(
RiaDefines::FRACTURE_MODEL ),
RiaDefines::MATRIX_MODEL,
m_dynamicResultsAccess->timeStepCount() );
QStringList matrixResultNames =
validKeywordsForPorosityModel( resultNames,
resultNamesDataItemCounts,
m_eclipseCase->activeCellInfo( RiaDefines::MATRIX_MODEL ),
m_eclipseCase->activeCellInfo( RiaDefines::FRACTURE_MODEL ),
RiaDefines::MATRIX_MODEL,
m_dynamicResultsAccess->timeStepCount() );
for ( int i = 0; i < matrixResultNames.size(); ++i )
{
@ -972,14 +971,13 @@ void RifReaderEclipseOutput::buildMetaData( ecl_grid_type* grid )
}
{
QStringList fractureResultNames = validKeywordsForPorosityModel( resultNames,
resultNamesDataItemCounts,
m_eclipseCase->activeCellInfo(
RiaDefines::MATRIX_MODEL ),
m_eclipseCase->activeCellInfo(
RiaDefines::FRACTURE_MODEL ),
RiaDefines::FRACTURE_MODEL,
m_dynamicResultsAccess->timeStepCount() );
QStringList fractureResultNames =
validKeywordsForPorosityModel( resultNames,
resultNamesDataItemCounts,
m_eclipseCase->activeCellInfo( RiaDefines::MATRIX_MODEL ),
m_eclipseCase->activeCellInfo( RiaDefines::FRACTURE_MODEL ),
RiaDefines::FRACTURE_MODEL,
m_dynamicResultsAccess->timeStepCount() );
for ( int i = 0; i < fractureResultNames.size(); ++i )
{
@ -1047,14 +1045,13 @@ void RifReaderEclipseOutput::buildMetaData( ecl_grid_type* grid )
}
{
QStringList matrixResultNames = validKeywordsForPorosityModel( resultNames,
resultNamesDataItemCounts,
m_eclipseCase->activeCellInfo(
RiaDefines::MATRIX_MODEL ),
m_eclipseCase->activeCellInfo(
RiaDefines::FRACTURE_MODEL ),
RiaDefines::MATRIX_MODEL,
1 );
QStringList matrixResultNames =
validKeywordsForPorosityModel( resultNames,
resultNamesDataItemCounts,
m_eclipseCase->activeCellInfo( RiaDefines::MATRIX_MODEL ),
m_eclipseCase->activeCellInfo( RiaDefines::FRACTURE_MODEL ),
RiaDefines::MATRIX_MODEL,
1 );
// Add ACTNUM
matrixResultNames += "ACTNUM";
@ -1068,14 +1065,13 @@ void RifReaderEclipseOutput::buildMetaData( ecl_grid_type* grid )
}
{
QStringList fractureResultNames = validKeywordsForPorosityModel( resultNames,
resultNamesDataItemCounts,
m_eclipseCase->activeCellInfo(
RiaDefines::MATRIX_MODEL ),
m_eclipseCase->activeCellInfo(
RiaDefines::FRACTURE_MODEL ),
RiaDefines::FRACTURE_MODEL,
1 );
QStringList fractureResultNames =
validKeywordsForPorosityModel( resultNames,
resultNamesDataItemCounts,
m_eclipseCase->activeCellInfo( RiaDefines::MATRIX_MODEL ),
m_eclipseCase->activeCellInfo( RiaDefines::FRACTURE_MODEL ),
RiaDefines::FRACTURE_MODEL,
1 );
// Add ACTNUM
fractureResultNames += "ACTNUM";
@ -2051,8 +2047,8 @@ void RifReaderEclipseOutput::readWellCells( const ecl_grid_type* mainEclGrid, bo
// Calculate the bottom position of all the unpositioned segments
// Then do the calculation based on the refined contributions
std::map<int, std::vector<SegmentPositionContribution>>::iterator posContribIt = segmentIdToPositionContrib
.begin();
std::map<int, std::vector<SegmentPositionContribution>>::iterator posContribIt =
segmentIdToPositionContrib.begin();
std::map<int, cvf::Vec3d> bottomPositions;
while ( posContribIt != segmentIdToPositionContrib.end() )
{
@ -2088,7 +2084,8 @@ void RifReaderEclipseOutput::readWellCells( const ecl_grid_type* mainEclGrid, bo
static_cast<int>( gridNr ) );
if ( ert_wellhead )
{
RigWellResultPoint wellHeadRp = createWellResultPoint( grids[gridNr], ert_wellhead, -1, -1, wellName );
RigWellResultPoint wellHeadRp =
createWellResultPoint( grids[gridNr], ert_wellhead, -1, -1, wellName );
// HACK: Ert returns open as "this is equally wrong as closed for well heads".
// Well heads are not open jfr mail communication with HHGS and JH Statoil 07.01.2016
wellHeadRp.m_isOpen = false;
@ -2116,11 +2113,8 @@ void RifReaderEclipseOutput::readWellCells( const ecl_grid_type* mainEclGrid, bo
for ( int connIdx = 0; connIdx < connectionCount; connIdx++ )
{
well_conn_type* ert_connection = well_conn_collection_iget( connections, connIdx );
RigWellResultPoint wellRp = createWellResultPoint( grids[gridNr],
ert_connection,
-1,
-1,
wellName );
RigWellResultPoint wellRp =
createWellResultPoint( grids[gridNr], ert_connection, -1, -1, wellName );
if ( !subCellConnCalc.hasSubCellConnection( wellRp ) )
{

5
ApplicationCode/FileInterface/RifReaderEclipseRft.cpp
View File

@ -285,8 +285,9 @@ std::set<QDateTime>
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::set<QDateTime> RifReaderEclipseRft::availableTimeSteps(
const QString& wellName, const std::set<RifEclipseRftAddress::RftWellLogChannelType>& relevantChannels )
std::set<QDateTime>
RifReaderEclipseRft::availableTimeSteps( const QString& wellName,
const std::set<RifEclipseRftAddress::RftWellLogChannelType>& relevantChannels )
{
if ( !m_ecl_rft_file )
{

6
ApplicationCode/FileInterface/RifReaderEnsembleStatisticsRft.cpp
View File

@ -114,7 +114,8 @@ std::set<QDateTime> RifReaderEnsembleStatisticsRft::availableTimeSteps( const QS
///
//--------------------------------------------------------------------------------------------------
std::set<QDateTime> RifReaderEnsembleStatisticsRft::availableTimeSteps(
const QString& wellName, const RifEclipseRftAddress::RftWellLogChannelType& wellLogChannelName )
const QString& wellName,
const RifEclipseRftAddress::RftWellLogChannelType& wellLogChannelName )
{
std::set<QDateTime> allTimeSteps;
for ( auto summaryCase : m_summaryCaseCollection->allSummaryCases() )
@ -132,7 +133,8 @@ std::set<QDateTime> RifReaderEnsembleStatisticsRft::availableTimeSteps(
///
//--------------------------------------------------------------------------------------------------
std::set<QDateTime> RifReaderEnsembleStatisticsRft::availableTimeSteps(
const QString& wellName, const std::set<RifEclipseRftAddress::RftWellLogChannelType>& relevantChannels )
const QString& wellName,
const std::set<RifEclipseRftAddress::RftWellLogChannelType>& relevantChannels )
{
std::set<QDateTime> allTimeSteps;
for ( auto summaryCase : m_summaryCaseCollection->allSummaryCases() )

3
ApplicationCode/FileInterface/RifSummaryCaseRestartSelector.cpp
View File

@ -162,7 +162,8 @@ void RifSummaryCaseRestartSelector::determineFilesToImport( const std::vector<Ri
///
//--------------------------------------------------------------------------------------------------
void RifSummaryCaseRestartSelector::determineFilesToImportByAskingUser(
const std::vector<RifSummaryCaseFileImportInfo>& initialFiles, bool enableApplyToAllField )
const std::vector<RifSummaryCaseFileImportInfo>& initialFiles,
bool enableApplyToAllField )
{
RicSummaryCaseRestartDialogResult lastResult;

160
ApplicationCode/GeoMech/GeoMechDataModel/RigFemPartResultsCollection.cpp
View File

@ -519,8 +519,10 @@ std::map<std::string, std::vector<std::string>>
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigFemScalarResultFrames* RigFemPartResultsCollection::calculateBarConvertedResult(
int partIndex, const RigFemResultAddress& convertedResultAddr, const std::string& fieldNameToConvert )
RigFemScalarResultFrames*
RigFemPartResultsCollection::calculateBarConvertedResult( int partIndex,
const RigFemResultAddress& convertedResultAddr,
const std::string& fieldNameToConvert )
{
caf::ProgressInfo frameCountProgress( this->frameCount() * 2, "" );
frameCountProgress.setProgressDescription(
@ -722,22 +724,16 @@ RigFemScalarResultFrames* RigFemPartResultsCollection::calculateMeanStressSEM( i
"Calculating " + QString::fromStdString( resVarAddr.fieldName + ": " + resVarAddr.componentName ) );
frameCountProgress.setNextProgressIncrement( this->frameCount() );
RigFemScalarResultFrames* sa11 = this->findOrLoadScalarResult( partIndex,
RigFemResultAddress( resVarAddr.resultPosType,
"SE",
"S11" ) );
RigFemScalarResultFrames* sa11 =
this->findOrLoadScalarResult( partIndex, RigFemResultAddress( resVarAddr.resultPosType, "SE", "S11" ) );
frameCountProgress.incrementProgress();
frameCountProgress.setNextProgressIncrement( this->frameCount() );
RigFemScalarResultFrames* sa22 = this->findOrLoadScalarResult( partIndex,
RigFemResultAddress( resVarAddr.resultPosType,
"SE",
"S22" ) );
RigFemScalarResultFrames* sa22 =
this->findOrLoadScalarResult( partIndex, RigFemResultAddress( resVarAddr.resultPosType, "SE", "S22" ) );
frameCountProgress.incrementProgress();
frameCountProgress.setNextProgressIncrement( this->frameCount() );
RigFemScalarResultFrames* sa33 = this->findOrLoadScalarResult( partIndex,
RigFemResultAddress( resVarAddr.resultPosType,
"SE",
"S33" ) );
RigFemScalarResultFrames* sa33 =
this->findOrLoadScalarResult( partIndex, RigFemResultAddress( resVarAddr.resultPosType, "SE", "S33" ) );
RigFemScalarResultFrames* dstDataFrames = m_femPartResults[partIndex]->createScalarResult( resVarAddr );
@ -777,16 +773,12 @@ RigFemScalarResultFrames* RigFemPartResultsCollection::calculateSFI( int partInd
"Calculating " + QString::fromStdString( resVarAddr.fieldName + ": " + resVarAddr.componentName ) );
frameCountProgress.setNextProgressIncrement( this->frameCount() );
RigFemScalarResultFrames* se1Frames = this->findOrLoadScalarResult( partIndex,
RigFemResultAddress( resVarAddr.resultPosType,
"SE",
"S1" ) );
RigFemScalarResultFrames* se1Frames =
this->findOrLoadScalarResult( partIndex, RigFemResultAddress( resVarAddr.resultPosType, "SE", "S1" ) );
frameCountProgress.incrementProgress();
frameCountProgress.setNextProgressIncrement( this->frameCount() );
RigFemScalarResultFrames* se3Frames = this->findOrLoadScalarResult( partIndex,
RigFemResultAddress( resVarAddr.resultPosType,
"SE",
"S3" ) );
RigFemScalarResultFrames* se3Frames =
this->findOrLoadScalarResult( partIndex, RigFemResultAddress( resVarAddr.resultPosType, "SE", "S3" ) );
RigFemScalarResultFrames* dstDataFrames = m_femPartResults[partIndex]->createScalarResult( resVarAddr );
@ -841,16 +833,12 @@ RigFemScalarResultFrames* RigFemPartResultsCollection::calculateDSM( int partInd
"Calculating " + QString::fromStdString( resVarAddr.fieldName + ": " + resVarAddr.componentName ) );
frameCountProgress.setNextProgressIncrement( this->frameCount() );
RigFemScalarResultFrames* se1Frames = this->findOrLoadScalarResult( partIndex,
RigFemResultAddress( resVarAddr.resultPosType,
"SE",
"S1" ) );
RigFemScalarResultFrames* se1Frames =
this->findOrLoadScalarResult( partIndex, RigFemResultAddress( resVarAddr.resultPosType, "SE", "S1" ) );
frameCountProgress.incrementProgress();
frameCountProgress.setNextProgressIncrement( this->frameCount() );
RigFemScalarResultFrames* se3Frames = this->findOrLoadScalarResult( partIndex,
RigFemResultAddress( resVarAddr.resultPosType,
"SE",
"S3" ) );
RigFemScalarResultFrames* se3Frames =
this->findOrLoadScalarResult( partIndex, RigFemResultAddress( resVarAddr.resultPosType, "SE", "S3" ) );
RigFemScalarResultFrames* dstDataFrames = m_femPartResults[partIndex]->createScalarResult( resVarAddr );
@ -892,10 +880,8 @@ RigFemScalarResultFrames* RigFemPartResultsCollection::calculateFOS( int partInd
"Calculating " + QString::fromStdString( resVarAddr.fieldName + ": " + resVarAddr.componentName ) );
frameCountProgress.setNextProgressIncrement( this->frameCount() );
RigFemScalarResultFrames* dsmFrames = this->findOrLoadScalarResult( partIndex,
RigFemResultAddress( resVarAddr.resultPosType,
"SE",
"DSM" ) );
RigFemScalarResultFrames* dsmFrames =
this->findOrLoadScalarResult( partIndex, RigFemResultAddress( resVarAddr.resultPosType, "SE", "DSM" ) );
RigFemScalarResultFrames* dstDataFrames = m_femPartResults[partIndex]->createScalarResult( resVarAddr );
@ -936,22 +922,16 @@ RigFemScalarResultFrames* RigFemPartResultsCollection::calculateMeanStressSTM( i
"Calculating " + QString::fromStdString( resVarAddr.fieldName + ": " + resVarAddr.componentName ) );
frameCountProgress.setNextProgressIncrement( this->frameCount() );
RigFemScalarResultFrames* st11 = this->findOrLoadScalarResult( partIndex,
RigFemResultAddress( resVarAddr.resultPosType,
"ST",
"S11" ) );
RigFemScalarResultFrames* st11 =
this->findOrLoadScalarResult( partIndex, RigFemResultAddress( resVarAddr.resultPosType, "ST", "S11" ) );
frameCountProgress.incrementProgress();
frameCountProgress.setNextProgressIncrement( this->frameCount() );
RigFemScalarResultFrames* st22 = this->findOrLoadScalarResult( partIndex,
RigFemResultAddress( resVarAddr.resultPosType,
"ST",
"S22" ) );
RigFemScalarResultFrames* st22 =
this->findOrLoadScalarResult( partIndex, RigFemResultAddress( resVarAddr.resultPosType, "ST", "S22" ) );
frameCountProgress.incrementProgress();
frameCountProgress.setNextProgressIncrement( this->frameCount() );
RigFemScalarResultFrames* st33 = this->findOrLoadScalarResult( partIndex,
RigFemResultAddress( resVarAddr.resultPosType,
"ST",
"S33" ) );
RigFemScalarResultFrames* st33 =
this->findOrLoadScalarResult( partIndex, RigFemResultAddress( resVarAddr.resultPosType, "ST", "S33" ) );
RigFemScalarResultFrames* dstDataFrames = m_femPartResults[partIndex]->createScalarResult( resVarAddr );
@ -993,29 +973,21 @@ RigFemScalarResultFrames* RigFemPartResultsCollection::calculateDeviatoricStress
"Calculating " + QString::fromStdString( resVarAddr.fieldName + ": " + resVarAddr.componentName ) );
frameCountProgress.setNextProgressIncrement( this->frameCount() );
RigFemScalarResultFrames* st11 = this->findOrLoadScalarResult( partIndex,
RigFemResultAddress( resVarAddr.resultPosType,
"ST",
"S1" ) );
RigFemScalarResultFrames* st11 =
this->findOrLoadScalarResult( partIndex, RigFemResultAddress( resVarAddr.resultPosType, "ST", "S1" ) );
frameCountProgress.incrementProgress();
frameCountProgress.setNextProgressIncrement( this->frameCount() );
RigFemScalarResultFrames* st22 = this->findOrLoadScalarResult( partIndex,
RigFemResultAddress( resVarAddr.resultPosType,
"ST",
"S2" ) );
RigFemScalarResultFrames* st22 =
this->findOrLoadScalarResult( partIndex, RigFemResultAddress( resVarAddr.resultPosType, "ST", "S2" ) );
frameCountProgress.incrementProgress();
frameCountProgress.setNextProgressIncrement( this->frameCount() );
RigFemScalarResultFrames* st33 = this->findOrLoadScalarResult( partIndex,
RigFemResultAddress( resVarAddr.resultPosType,
"ST",
"S3" ) );
RigFemScalarResultFrames* st33 =
this->findOrLoadScalarResult( partIndex, RigFemResultAddress( resVarAddr.resultPosType, "ST", "S3" ) );
frameCountProgress.incrementProgress();
frameCountProgress.setNextProgressIncrement( this->frameCount() );
RigFemScalarResultFrames* stm = this->findOrLoadScalarResult( partIndex,
RigFemResultAddress( resVarAddr.resultPosType,
"ST",
"STM" ) );
RigFemScalarResultFrames* stm =
this->findOrLoadScalarResult( partIndex, RigFemResultAddress( resVarAddr.resultPosType, "ST", "STM" ) );
RigFemScalarResultFrames* dstDataFrames = m_femPartResults[partIndex]->createScalarResult( resVarAddr );
@ -1170,40 +1142,28 @@ RigFemScalarResultFrames*
"Calculating " + QString::fromStdString( resVarAddr.fieldName + ": " + resVarAddr.componentName ) );
frameCountProgress.setNextProgressIncrement( this->frameCount() );
RigFemScalarResultFrames* s11Frames = this->findOrLoadScalarResult( partIndex,
RigFemResultAddress( RIG_ELEMENT_NODAL,
resVarAddr.fieldName,
"S11" ) );
RigFemScalarResultFrames* s11Frames =
this->findOrLoadScalarResult( partIndex, RigFemResultAddress( RIG_ELEMENT_NODAL, resVarAddr.fieldName, "S11" ) );
frameCountProgress.incrementProgress();
frameCountProgress.setNextProgressIncrement( this->frameCount() );
RigFemScalarResultFrames* s22Frames = this->findOrLoadScalarResult( partIndex,
RigFemResultAddress( RIG_ELEMENT_NODAL,
resVarAddr.fieldName,
"S22" ) );
RigFemScalarResultFrames* s22Frames =
this->findOrLoadScalarResult( partIndex, RigFemResultAddress( RIG_ELEMENT_NODAL, resVarAddr.fieldName, "S22" ) );
frameCountProgress.incrementProgress();
frameCountProgress.setNextProgressIncrement( this->frameCount() );
RigFemScalarResultFrames* s33Frames = this->findOrLoadScalarResult( partIndex,
RigFemResultAddress( RIG_ELEMENT_NODAL,
resVarAddr.fieldName,
"S33" ) );
RigFemScalarResultFrames* s33Frames =
this->findOrLoadScalarResult( partIndex, RigFemResultAddress( RIG_ELEMENT_NODAL, resVarAddr.fieldName, "S33" ) );
frameCountProgress.incrementProgress();
frameCountProgress.setNextProgressIncrement( this->frameCount() );
RigFemScalarResultFrames* s12Frames = this->findOrLoadScalarResult( partIndex,
RigFemResultAddress( RIG_ELEMENT_NODAL,
resVarAddr.fieldName,
"S12" ) );
RigFemScalarResultFrames* s12Frames =
this->findOrLoadScalarResult( partIndex, RigFemResultAddress( RIG_ELEMENT_NODAL, resVarAddr.fieldName, "S12" ) );
frameCountProgress.incrementProgress();
frameCountProgress.setNextProgressIncrement( this->frameCount() );
RigFemScalarResultFrames* s23Frames = this->findOrLoadScalarResult( partIndex,
RigFemResultAddress( RIG_ELEMENT_NODAL,
resVarAddr.fieldName,
"S23" ) );
RigFemScalarResultFrames* s23Frames =
this->findOrLoadScalarResult( partIndex, RigFemResultAddress( RIG_ELEMENT_NODAL, resVarAddr.fieldName, "S23" ) );
frameCountProgress.incrementProgress();
frameCountProgress.setNextProgressIncrement( this->frameCount() );
RigFemScalarResultFrames* s13Frames = this->findOrLoadScalarResult( partIndex,
RigFemResultAddress( RIG_ELEMENT_NODAL,
resVarAddr.fieldName,
"S13" ) );
RigFemScalarResultFrames* s13Frames =
this->findOrLoadScalarResult( partIndex, RigFemResultAddress( RIG_ELEMENT_NODAL, resVarAddr.fieldName, "S13" ) );
RigFemScalarResultFrames* SNFrames = m_femPartResults[partIndex]->createScalarResult(
RigFemResultAddress( resVarAddr.resultPosType, resVarAddr.fieldName, "SN" ) );
@ -1707,10 +1667,8 @@ RigFemScalarResultFrames* RigFemPartResultsCollection::calculateCompactionValues
caf::ProgressInfo frameCountProgress( this->frameCount() + 1, "" );
frameCountProgress.setProgressDescription( "Calculating " + QString::fromStdString( resVarAddr.fieldName ) );
RigFemScalarResultFrames* u3Frames = this->findOrLoadScalarResult( partIndex,
RigFemResultAddress( resVarAddr.resultPosType,
"U",
"U3" ) );
RigFemScalarResultFrames* u3Frames =
this->findOrLoadScalarResult( partIndex, RigFemResultAddress( resVarAddr.resultPosType, "U", "U3" ) );
frameCountProgress.incrementProgress();
RigFemScalarResultFrames* compactionFrames = m_femPartResults[partIndex]->createScalarResult( resVarAddr );
@ -1828,11 +1786,9 @@ RigFemScalarResultFrames* RigFemPartResultsCollection::calculateSE( int partInde
RigFemResultAddress( resVarAddr.resultPosType, "S-Bar", resVarAddr.componentName ) );
frameCountProgress.incrementProgress();
frameCountProgress.setNextProgressIncrement( this->frameCount() );
RigFemScalarResultFrames* srcPORDataFrames = this->findOrLoadScalarResult( partIndex,
RigFemResultAddress( RIG_NODAL,
"POR-Bar",
"" ) );
RigFemScalarResultFrames* dstDataFrames = m_femPartResults[partIndex]->createScalarResult( resVarAddr );
RigFemScalarResultFrames* srcPORDataFrames =
this->findOrLoadScalarResult( partIndex, RigFemResultAddress( RIG_NODAL, "POR-Bar", "" ) );
RigFemScalarResultFrames* dstDataFrames = m_femPartResults[partIndex]->createScalarResult( resVarAddr );
frameCountProgress.incrementProgress();
@ -1905,10 +1861,8 @@ RigFemScalarResultFrames* RigFemPartResultsCollection::calculateST_11_22_33( int
frameCountProgress.incrementProgress();
frameCountProgress.setNextProgressIncrement( this->frameCount() );
RigFemScalarResultFrames* srcPORDataFrames = this->findOrLoadScalarResult( partIndex,
RigFemResultAddress( RIG_NODAL,
"POR-Bar",
"" ) );
RigFemScalarResultFrames* srcPORDataFrames =
this->findOrLoadScalarResult( partIndex, RigFemResultAddress( RIG_NODAL, "POR-Bar", "" ) );
RigFemScalarResultFrames* dstDataFrames = m_femPartResults[partIndex]->createScalarResult( resVarAddr );
const RigFemPart* femPart = m_femParts->part( partIndex );
@ -2046,11 +2000,9 @@ RigFemScalarResultFrames* RigFemPartResultsCollection::calculateGamma( int
frameCountProgress.incrementProgress();
frameCountProgress.setNextProgressIncrement( this->frameCount() );
RigFemScalarResultFrames* srcPORDataFrames = this->findOrLoadScalarResult( partIndex,
RigFemResultAddress( RIG_NODAL,
"POR-Bar",
"" ) );
RigFemScalarResultFrames* dstDataFrames = m_femPartResults[partIndex]->createScalarResult( resVarAddr );
RigFemScalarResultFrames* srcPORDataFrames =
this->findOrLoadScalarResult( partIndex, RigFemResultAddress( RIG_NODAL, "POR-Bar", "" ) );
RigFemScalarResultFrames* dstDataFrames = m_femPartResults[partIndex]->createScalarResult( resVarAddr );
frameCountProgress.incrementProgress();

6
ApplicationCode/GrpcInterface/RiaGrpcCommandService.cpp
View File

@ -193,9 +193,9 @@ void RiaGrpcCommandService::assignPdmFieldValue( caf::PdmValueField* pdmValue
{
if ( paramDescriptor->is_repeated() )
{
RepeatedFieldRef<std::string> repeatedField = reflection->GetRepeatedFieldRef<std::string>( params,
paramDescriptor );
std::vector<QString> stringVector;
RepeatedFieldRef<std::string> repeatedField =
reflection->GetRepeatedFieldRef<std::string>( params, paramDescriptor );
std::vector<QString> stringVector;
for ( const std::string& string : repeatedField )
{
stringVector.push_back( QString::fromStdString( string ) );

9
ApplicationCode/ModelVisualization/Riv3dWellLogCurveGeometryGenerator.cpp
View File

@ -357,8 +357,8 @@ void Riv3dWellLogCurveGeometryGenerator::createNewVerticesAlongSegment( const cv
{
caf::Line<double> triangleEdge1 = caf::Line<double>( drawSurfaceVertices[j], drawSurfaceVertices[j + 1] );
caf::Line<double> triangleEdge2 = caf::Line<double>( drawSurfaceVertices[j + 2], drawSurfaceVertices[j + 1] );
cvf::Vec3d triangleNormal = ( triangleEdge1.vector().getNormalized() ^ triangleEdge2.vector().getNormalized() )
.getNormalized();
cvf::Vec3d triangleNormal =
( triangleEdge1.vector().getNormalized() ^ triangleEdge2.vector().getNormalized() ).getNormalized();
cvf::Vec3d currentSubSegment = ptEnd - extraVertices->back();
cvf::Vec3d projectedSegmentVector = currentSubSegment - ( currentSubSegment * triangleNormal ) * triangleNormal;
@ -382,8 +382,9 @@ void Riv3dWellLogCurveGeometryGenerator::createNewVerticesAlongSegment( const cv
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<cvf::Vec3d> Riv3dWellLogCurveGeometryGenerator::projectVerticesOntoTriangles(
const std::vector<cvf::Vec3d>& originalVertices, const std::vector<cvf::Vec3d>& drawSurfaceVertices )
std::vector<cvf::Vec3d>
Riv3dWellLogCurveGeometryGenerator::projectVerticesOntoTriangles( const std::vector<cvf::Vec3d>& originalVertices,
const std::vector<cvf::Vec3d>& drawSurfaceVertices )
{
std::vector<cvf::Vec3d> projectedVertices;
projectedVertices.reserve( originalVertices.size() );

15
ApplicationCode/ModelVisualization/RivCellEdgeGeometryUtils.cpp
View File

@ -57,12 +57,9 @@ void RivCellEdgeGeometryUtils::addCellEdgeResultsToDrawableGeo( size_t
// Create result access objects
cvf::ref<RigResultAccessor> cellCenterDataAccessObject = createCellCenterResultAccessor( cellResultColors,
timeStepIndex,
eclipseCase,
eclipseCase->grid(
gridIndex ) );
cvf::ref<RigResultAccessor> cellEdgeResultAccessor = createCellEdgeResultAccessor( cellResultColors,
cvf::ref<RigResultAccessor> cellCenterDataAccessObject =
createCellCenterResultAccessor( cellResultColors, timeStepIndex, eclipseCase, eclipseCase->grid( gridIndex ) );
cvf::ref<RigResultAccessor> cellEdgeResultAccessor = createCellEdgeResultAccessor( cellResultColors,
cellEdgeResultColors,
timeStepIndex,
eclipseCase,
@ -371,8 +368,10 @@ cvf::ref<RigResultAccessor>
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::ref<RigResultAccessor> RivCellEdgeGeometryUtils::createCellCenterResultAccessor(
RimEclipseCellColors* cellResultColors, size_t timeStepIndex, RigEclipseCaseData* eclipseCase, const RigGridBase* grid )
cvf::ref<RigResultAccessor> RivCellEdgeGeometryUtils::createCellCenterResultAccessor( RimEclipseCellColors* cellResultColors,
size_t timeStepIndex,
RigEclipseCaseData* eclipseCase,
const RigGridBase* grid )
{
cvf::ref<RigResultAccessor> resultAccessor = nullptr;

3
ApplicationCode/ModelVisualization/RivContourMapProjectionPartMgr.cpp
View File

@ -543,7 +543,8 @@ cvf::ref<cvf::DrawableGeo> RivContourMapProjectionPartMgr::createPickPointVisDra
///
//--------------------------------------------------------------------------------------------------
bool RivContourMapProjectionPartMgr::lineOverlapsWithPreviousContourLevel(
const cvf::Vec3d& lineCenter, const RimContourMapProjection::ContourPolygons* previousLevel ) const
const cvf::Vec3d& lineCenter,
const RimContourMapProjection::ContourPolygons* previousLevel ) const
{
const int64_t jump = 50;
CVF_ASSERT( previousLevel );

10
ApplicationCode/ModelVisualization/RivPipeGeometryGenerator.cpp
View File

@ -242,8 +242,9 @@ cvf::ref<cvf::DrawableGeo> RivPipeGeometryGenerator::generateLine( const cvf::Ve
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::ref<cvf::DrawableGeo> RivPipeGeometryGenerator::generateExtrudedCylinder(
double radius, size_t crossSectionNodeCount, const cvf::Vec3dArray* cylinderCenterCoords )
cvf::ref<cvf::DrawableGeo> RivPipeGeometryGenerator::generateExtrudedCylinder( double radius,
size_t crossSectionNodeCount,
const cvf::Vec3dArray* cylinderCenterCoords )
{
CVF_ASSERT( cylinderCenterCoords != nullptr );
@ -396,8 +397,9 @@ cvf::ref<cvf::DrawableGeo> RivPipeGeometryGenerator::generateExtrudedCylinder(
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::ref<cvf::DrawableGeo> RivPipeGeometryGenerator::generateVariableRadiusTube(
size_t crossSectionNodeCount, const cvf::Vec3dArray* cylinderCenterCoords, const std::vector<double>& radii )
cvf::ref<cvf::DrawableGeo> RivPipeGeometryGenerator::generateVariableRadiusTube( size_t crossSectionNodeCount,
const cvf::Vec3dArray* cylinderCenterCoords,
const std::vector<double>& radii )
{
CVF_ASSERT( cylinderCenterCoords != nullptr );

5
ApplicationCode/ModelVisualization/RivPolylineAnnotationPartMgr.cpp
View File

@ -202,8 +202,9 @@ std::vector<std::vector<RivPolylineAnnotationPartMgr::Vec3d>>
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<std::vector<cvf::Vec3d>> RivPolylineAnnotationPartMgr::transformPolylinesPointsToDisplay(
const std::vector<std::vector<Vec3d>>& pointsInDomain, const caf::DisplayCoordTransform* displayXf )
std::vector<std::vector<cvf::Vec3d>>
RivPolylineAnnotationPartMgr::transformPolylinesPointsToDisplay( const std::vector<std::vector<Vec3d>>& pointsInDomain,
const caf::DisplayCoordTransform* displayXf )
{
std::vector<std::vector<Vec3d>> pointsInDisplay;
for ( const auto& pts : pointsInDomain )

11
ApplicationCode/ModelVisualization/RivReservoirViewPartMgr.cpp
View File

@ -715,8 +715,8 @@ void RivReservoirViewPartMgr::computeOverriddenCellVisibility( cvf::UByteArray*
int cellSetCount = gridsWithCellSetVisibility[masterCaseCells.gridIndex[mcIdx]].size();
for ( int csIdx = 0; csIdx < cellSetCount; ++csIdx )
{
( *cellVisibility )[lcIdx] |= gridsWithCellSetVisibility[masterCaseCells.gridIndex[mcIdx]]
[masterCaseCells.cellIndex[mcIdx]];
( *cellVisibility )[lcIdx] |=
gridsWithCellSetVisibility[masterCaseCells.gridIndex[mcIdx]][masterCaseCells.cellIndex[mcIdx]];
}
}
#endif
@ -781,7 +781,8 @@ void RivReservoirViewPartMgr::computeRangeVisibility( RivCellSetEnum
if ( geometryType == RANGE_FILTERED_WELL_CELLS )
{
geometryType = RANGE_FILTERED; // Use the range filtering in the parent grid, not the well cells in the parent grid
geometryType =
RANGE_FILTERED; // Use the range filtering in the parent grid, not the well cells in the parent grid
}
RivReservoirPartMgr* reservoirGridPartMgr = &m_geometries[geometryType];
@ -998,8 +999,8 @@ const cvf::UByteArray*
ensureDynamicGeometryPartsCreated( geometryType, timeStepIndex );
ensureStaticGeometryPartsCreated( geometryType );
RivReservoirPartMgr* pmgr = ( const_cast<RivReservoirViewPartMgr*>( this ) )
->reservoirPartManager( geometryType, timeStepIndex );
RivReservoirPartMgr* pmgr =
( const_cast<RivReservoirViewPartMgr*>( this ) )->reservoirPartManager( geometryType, timeStepIndex );
return pmgr->cellVisibility( gridIndex ).p();
}

7
ApplicationCode/ModelVisualization/RivScalarMapperUtils.cpp
View File

@ -51,11 +51,8 @@ void RivScalarMapperUtils::applyTextureResultsToPart( cvf::Part* p
cvf::DrawableGeo* dg = dynamic_cast<cvf::DrawableGeo*>( part->drawable() );
if ( dg ) dg->setTextureCoordArray( textureCoords );
cvf::ref<cvf::Effect> scalarEffect = RivScalarMapperUtils::createScalarMapperEffect( mapper,
opacityLevel,
faceCulling,
disableLighting,
undefColor );
cvf::ref<cvf::Effect> scalarEffect =
RivScalarMapperUtils::createScalarMapperEffect( mapper, opacityLevel, faceCulling, disableLighting, undefColor );
part->setEffect( scalarEffect.p() );
}

8
ApplicationCode/ModelVisualization/RivSimWellPipesPartMgr.cpp
View File

@ -277,8 +277,8 @@ void RivSimWellPipesPartMgr::buildWellPipeParts( const caf::DisplayCoordTransfor
const RigWellPath* wellPath = wellPaths[brIdx];
RigEclipseWellLogExtractor* extractor = RiaExtractionTools::findOrCreateSimWellExtractor( m_simWellInView,
wellPath );
RigEclipseWellLogExtractor* extractor =
RiaExtractionTools::findOrCreateSimWellExtractor( m_simWellInView, wellPath );
if ( extractor )
{
std::vector<WellPathCellIntersectionInfo> wellPathCellIntersections =
@ -287,8 +287,8 @@ void RivSimWellPipesPartMgr::buildWellPipeParts( const caf::DisplayCoordTransfor
for ( const auto& intersectionInfo : wellPathCellIntersections )
{
size_t globalCellIndex = intersectionInfo.globCellIndex;
const RigWellResultPoint* wResCell = wResFrame.findResultCellWellHeadIncluded( 0,
globalCellIndex );
const RigWellResultPoint* wResCell =
wResFrame.findResultCellWellHeadIncluded( 0, globalCellIndex );
if ( !wResCell || !wResCell->isValid() )
{

7
ApplicationCode/ModelVisualization/RivTernarySaturationOverlayItem.cpp
View File

@ -176,8 +176,11 @@ void RivTernarySaturationOverlayItem::renderGeneric( cvf::OpenGLContext* oglCont
//--------------------------------------------------------------------------------------------------
/// Draw the axis using immediate mode OpenGL
//--------------------------------------------------------------------------------------------------
void RivTernarySaturationOverlayItem::renderAxisImmediateMode(
float upperBoundY, float lowerBoundY, float border, unsigned int totalWidth, cvf::OpenGLContext* oglContext )
void RivTernarySaturationOverlayItem::renderAxisImmediateMode( float upperBoundY,
float lowerBoundY,
float border,
unsigned int totalWidth,
cvf::OpenGLContext* oglContext )
{
#ifdef CVF_OPENGL_ES
CVF_UNUSED( layout );

7
ApplicationCode/ModelVisualization/RivTernarySaturationOverlayItem.h
View File

@ -51,8 +51,11 @@ private:
void renderSoftware( cvf::OpenGLContext* oglContext, const cvf::Vec2i& position, const cvf::Vec2ui& size ) override;
void renderGeneric( cvf::OpenGLContext* oglContext, const cvf::Vec2i& position, const cvf::Vec2ui& size, bool software );
void renderAxisImmediateMode(
float upperY, float lowerBoundY, float border, unsigned int totalWidth, cvf::OpenGLContext* oglContext );
void renderAxisImmediateMode( float upperY,
float lowerBoundY,
float border,
unsigned int totalWidth,
cvf::OpenGLContext* oglContext );
private:
cvf::String m_soilRange;

3
ApplicationCode/ModelVisualization/RivWellConnectionFactorGeometryGenerator.cpp
View File

@ -31,7 +31,8 @@
///
//--------------------------------------------------------------------------------------------------
RivWellConnectionFactorGeometryGenerator::RivWellConnectionFactorGeometryGenerator(
std::vector<CompletionVizData>& completionVizData, float radius )
std::vector<CompletionVizData>& completionVizData,
float radius )
: m_completionVizData( completionVizData )
, m_radius( radius )
, m_trianglesPerConnection( 0 )

22
ApplicationCode/ModelVisualization/RivWellConnectionsPartMgr.cpp
View File

@ -169,10 +169,8 @@ void RivWellConnectionsPartMgr::appendDynamicGeometryPartsToModel( cvf::ModelBas
}
}
std::pair<double, double> injProdFluxPair = flowResults->injectorProducerPairFluxes( injectorName,
producerName,
static_cast<int>(
frameIndex ) );
std::pair<double, double> injProdFluxPair =
flowResults->injectorProducerPairFluxes( injectorName, producerName, static_cast<int>( frameIndex ) );
std::pair<double, double> injProdFluxPairXF = flowResults->injectorProducerPairFluxes( crossFlowInjectorName,
crossFlowProducerName,
static_cast<int>(
@ -210,12 +208,8 @@ void RivWellConnectionsPartMgr::appendDynamicGeometryPartsToModel( cvf::ModelBas
startPoint.z() -= 0.5 * characteristicCellSize;
endPoint.z() -= 0.5 * characteristicCellSize;
}
cvf::ref<cvf::Part> arrowPart = createArrowPart( startPoint,
endPoint,
width,
isProducer,
arrowColor,
enableLighting );
cvf::ref<cvf::Part> arrowPart =
createArrowPart( startPoint, endPoint, width, isProducer, arrowColor, enableLighting );
model->addPart( arrowPart.p() );
}
@ -223,12 +217,8 @@ void RivWellConnectionsPartMgr::appendDynamicGeometryPartsToModel( cvf::ModelBas
{
startPoint.z() -= 0.5 * characteristicCellSize;
endPoint.z() -= 0.5 * characteristicCellSize;
cvf::ref<cvf::Part> arrowPart = createArrowPart( startPoint,
endPoint,
widthXf,
!isProducer,
arrowColor,
enableLighting );
cvf::ref<cvf::Part> arrowPart =
createArrowPart( startPoint, endPoint, widthXf, !isProducer, arrowColor, enableLighting );
model->addPart( arrowPart.p() );
}
}

16
ApplicationCode/ModelVisualization/RivWellFracturePartMgr.cpp
View File

@ -566,10 +566,10 @@ cvf::ref<cvf::Part> RivWellFracturePartMgr::createStimPlanElementColorSurfacePar
QString resultNameFromColors = activeView.fractureColors()->uiResultName();
QString resultUnitFromColors = activeView.fractureColors()->unit();
std::vector<double> prCellResults = stimPlanFracTemplate
->fractureGridResults( resultNameFromColors,
resultUnitFromColors,
stimPlanFracTemplate->activeTimeStepIndex() );
std::vector<double> prCellResults =
stimPlanFracTemplate->fractureGridResults( resultNameFromColors,
resultUnitFromColors,
stimPlanFracTemplate->activeTimeStepIndex() );
textureCoords->reserve( prCellResults.size() * 4 );
@ -1046,10 +1046,10 @@ cvf::ref<cvf::DrawableGeo>
QString resultNameFromColors = activeView.fractureColors()->uiResultName();
QString resultUnitFromColors = activeView.fractureColors()->unit();
std::vector<double> prCellResults = stimPlanFracTemplate
->fractureGridResults( resultNameFromColors,
resultUnitFromColors,
stimPlanFracTemplate->activeTimeStepIndex() );
std::vector<double> prCellResults =
stimPlanFracTemplate->fractureGridResults( resultNameFromColors,
resultUnitFromColors,
stimPlanFracTemplate->activeTimeStepIndex() );
m_visibleFracturePolygons.clear();
for ( size_t cIdx = 0; cIdx < stimPlanCells.size(); ++cIdx )

6
ApplicationCode/ModelVisualization/RivWellFracturePartMgr.h
View File

@ -89,8 +89,10 @@ private:
RimFracture* fracture,
bool disableLighting );
static std::vector<cvf::Vec3f> transformToFractureDisplayCoords(
const std::vector<cvf::Vec3f>& polygon, cvf::Mat4d m, const caf::DisplayCoordTransform& displayCoordTransform );
static std::vector<cvf::Vec3f>
transformToFractureDisplayCoords( const std::vector<cvf::Vec3f>& polygon,
cvf::Mat4d m,
const caf::DisplayCoordTransform& displayCoordTransform );
static cvf::ref<cvf::DrawableGeo> buildDrawableGeoFromTriangles( const std::vector<cvf::uint>& triangleIndices,
const std::vector<cvf::Vec3f>& nodeCoords );

43
ApplicationCode/ProjectDataModel/Completions/RimStimPlanFractureTemplate.cpp
View File

@ -490,11 +490,11 @@ WellFractureIntersectionData
std::vector<double> betaFactorResultValues;
{
auto nameUnit = betaFactorParameterNameAndUnit();
betaFactorResultValues = m_stimPlanFractureDefinitionData
->fractureGridResults( nameUnit.first,
nameUnit.second,
m_activeTimeStepIndex );
auto nameUnit = betaFactorParameterNameAndUnit();
betaFactorResultValues =
m_stimPlanFractureDefinitionData->fractureGridResults( nameUnit.first,
nameUnit.second,
m_activeTimeStepIndex );
}
RiaWeightedMeanCalculator<double> widthCalc;
@ -596,11 +596,11 @@ WellFractureIntersectionData
}
{
auto nameUnit = betaFactorParameterNameAndUnit();
std::vector<double> betaFactorResultValues = m_stimPlanFractureDefinitionData
->fractureGridResults( nameUnit.first,
nameUnit.second,
m_activeTimeStepIndex );
auto nameUnit = betaFactorParameterNameAndUnit();
std::vector<double> betaFactorResultValues =
m_stimPlanFractureDefinitionData->fractureGridResults( nameUnit.first,
nameUnit.second,
m_activeTimeStepIndex );
if ( wellCellIndex < betaFactorResultValues.size() )
{
@ -625,8 +625,8 @@ std::pair<QString, QString> RimStimPlanFractureTemplate::widthParameterNameAndUn
{
if ( m_stimPlanFractureDefinitionData.notNull() )
{
std::vector<std::pair<QString, QString>> propertyNamesUnitsOnFile = m_stimPlanFractureDefinitionData
->getStimPlanPropertyNamesUnits();
std::vector<std::pair<QString, QString>> propertyNamesUnitsOnFile =
m_stimPlanFractureDefinitionData->getStimPlanPropertyNamesUnits();
for ( const auto& nameUnit : propertyNamesUnitsOnFile )
{
@ -652,8 +652,8 @@ std::pair<QString, QString> RimStimPlanFractureTemplate::conductivityParameterNa
{
if ( m_stimPlanFractureDefinitionData.notNull() )
{
std::vector<std::pair<QString, QString>> propertyNamesUnitsOnFile = m_stimPlanFractureDefinitionData
->getStimPlanPropertyNamesUnits();
std::vector<std::pair<QString, QString>> propertyNamesUnitsOnFile =
m_stimPlanFractureDefinitionData->getStimPlanPropertyNamesUnits();
for ( const auto& nameUnit : propertyNamesUnitsOnFile )
{
@ -674,8 +674,8 @@ std::pair<QString, QString> RimStimPlanFractureTemplate::betaFactorParameterName
{
if ( m_stimPlanFractureDefinitionData.notNull() )
{
std::vector<std::pair<QString, QString>> propertyNamesUnitsOnFile = m_stimPlanFractureDefinitionData
->getStimPlanPropertyNamesUnits();
std::vector<std::pair<QString, QString>> propertyNamesUnitsOnFile =
m_stimPlanFractureDefinitionData->getStimPlanPropertyNamesUnits();
for ( const auto& nameUnit : propertyNamesUnitsOnFile )
{
@ -848,8 +848,8 @@ std::vector<std::pair<QString, QString>> RimStimPlanFractureTemplate::uiResultNa
std::vector<std::pair<QString, QString>> tmp;
std::vector<std::pair<QString, QString>> propertyNamesUnitsOnFile = m_stimPlanFractureDefinitionData
->getStimPlanPropertyNamesUnits();
std::vector<std::pair<QString, QString>> propertyNamesUnitsOnFile =
m_stimPlanFractureDefinitionData->getStimPlanPropertyNamesUnits();
for ( const auto& nameUnitPair : propertyNamesUnitsOnFile )
{
if ( nameUnitPair.first.contains( RiaDefines::conductivityResultName(), Qt::CaseInsensitive ) )
@ -924,8 +924,11 @@ bool RimStimPlanFractureTemplate::hasConductivity() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RimStimPlanFractureTemplate::resultValueAtIJ(
const QString& uiResultName, const QString& unitName, size_t timeStepIndex, size_t i, size_t j )
double RimStimPlanFractureTemplate::resultValueAtIJ( const QString& uiResultName,
const QString& unitName,
size_t timeStepIndex,
size_t i,
size_t j )
{
auto values = resultValues( uiResultName, unitName, timeStepIndex );

4
ApplicationCode/ProjectDataModel/Flow/RimWellAllocationPlot.cpp
View File

@ -385,8 +385,8 @@ std::map<QString, const std::vector<double>*>
RigFlowDiagResultAddress resAddr( RIG_FLD_CELL_FRACTION_RESNAME,
RigFlowDiagResultAddress::PHASE_ALL,
tracerName.toStdString() );
const std::vector<double>* tracerCellFractions = m_flowDiagSolution->flowDiagResults()
->resultValues( resAddr, m_timeStep );
const std::vector<double>* tracerCellFractions =
m_flowDiagSolution->flowDiagResults()->resultValues( resAddr, m_timeStep );
if ( tracerCellFractions ) tracerCellFractionValues[tracerName] = tracerCellFractions;
}
}

15
ApplicationCode/ProjectDataModel/Flow/RimWellPltPlot.cpp
View File

@ -473,8 +473,8 @@ public:
m_pipeBranchCLCoords.push_back( intersections[wpExIdx].endPoint );
m_pipeBranchMeasuredDepths.push_back( intersections[wpExIdx].endMD );
const RigWellResultPoint& resPoint = resFrame.m_wellResultBranches[it->second.first]
.m_branchResultPoints[it->second.second];
const RigWellResultPoint& resPoint =
resFrame.m_wellResultBranches[it->second.first].m_branchResultPoints[it->second.second];
m_pipeBranchWellResultPoints.push_back( resPoint );
if ( wpExIdx < intersections.size() - 1 )
@ -570,8 +570,8 @@ void RimWellPltPlot::syncCurvesFromUiSelection()
QString curveUnitText = RimWellPlotTools::flowUnitText( RimWellLogFile::WELL_FLOW_COND_RESERVOIR,
unitSet );
const std::vector<double> accFlow = wfTotalAccumulator
.accumulatedTracerFlowPrPseudoLength( RIG_FLOW_TOTAL_NAME, 0 );
const std::vector<double> accFlow =
wfTotalAccumulator.accumulatedTracerFlowPrPseudoLength( RIG_FLOW_TOTAL_NAME, 0 );
addStackedCurve( curveName + ", " + RIG_FLOW_TOTAL_NAME + " " + curveUnitText,
depthValues,
accFlow,
@ -615,8 +615,8 @@ void RimWellPltPlot::syncCurvesFromUiSelection()
unitSet,
flowPhase );
const std::vector<double>& accFlow = wfPhaseAccumulator
.accumulatedTracerFlowPrPseudoLength( tracerName, 0 );
const std::vector<double>& accFlow =
wfPhaseAccumulator.accumulatedTracerFlowPrPseudoLength( tracerName, 0 );
addStackedCurve( curveName + ", " + tracerName + " " + curveUnitText,
depthValues,
accFlow,
@ -860,7 +860,8 @@ QList<caf::PdmOptionItemInfo> RimWellPltPlot::calculateValueOptions( const caf::
}
else if ( fieldNeedingOptions == &m_selectedTimeSteps )
{
std::set<RifEclipseRftAddress::RftWellLogChannelType> channelTypesToUse = RifEclipseRftAddress::pltPlotChannelTypes();
std::set<RifEclipseRftAddress::RftWellLogChannelType> channelTypesToUse =
RifEclipseRftAddress::pltPlotChannelTypes();
RimWellPlotTools::calculateValueOptionsForTimeSteps( RimWellPlotTools::simWellName( m_wellPathName ),
selectedSourcesExpanded(),

14
ApplicationCode/ProjectDataModel/Flow/RimWellRftPlot.cpp
View File

@ -271,7 +271,8 @@ void RimWellRftPlot::applyInitialSelections()
m_selectedSources = sourcesToSelect;
{
std::set<RifEclipseRftAddress::RftWellLogChannelType> channelTypesToUse = RifEclipseRftAddress::rftPlotChannelTypes();
std::set<RifEclipseRftAddress::RftWellLogChannelType> channelTypesToUse =
RifEclipseRftAddress::rftPlotChannelTypes();
auto relevantTimeSteps = RimWellPlotTools::calculateRelevantTimeStepsFromCases( m_wellPathNameOrSimWellName,
m_selectedSources,
@ -508,10 +509,10 @@ void RimWellRftPlot::updateCurvesInPlot( const std::set<RiaRftPltCurveDefinition
}
else if ( m_showStatisticsCurves && curveDefToAdd.address().sourceType() == RifDataSourceForRftPlt::ENSEMBLE_RFT )
{
RimSummaryCaseCollection* ensemble = curveDefToAdd.address().ensemble();
std::set<RifEclipseRftAddress> rftAddresses = ensemble->rftStatisticsReader()
->eclipseRftAddresses( m_wellPathNameOrSimWellName,
curveDefToAdd.timeStep() );
RimSummaryCaseCollection* ensemble = curveDefToAdd.address().ensemble();
std::set<RifEclipseRftAddress> rftAddresses =
ensemble->rftStatisticsReader()->eclipseRftAddresses( m_wellPathNameOrSimWellName,
curveDefToAdd.timeStep() );
for ( auto rftAddress : rftAddresses )
{
if ( rftAddress.wellLogChannel() != RifEclipseRftAddress::TVD )
@ -799,7 +800,8 @@ QList<caf::PdmOptionItemInfo> RimWellRftPlot::calculateValueOptions( const caf::
}
else if ( fieldNeedingOptions == &m_selectedTimeSteps )
{
std::set<RifEclipseRftAddress::RftWellLogChannelType> channelTypesToUse = RifEclipseRftAddress::rftPlotChannelTypes();
std::set<RifEclipseRftAddress::RftWellLogChannelType> channelTypesToUse =
RifEclipseRftAddress::rftPlotChannelTypes();
RimWellPlotTools::calculateValueOptionsForTimeSteps( m_wellPathNameOrSimWellName,
selectedSourcesExpanded(),

5
ApplicationCode/ProjectDataModel/PlotTemplates/RimPlotTemplateFolderItem.cpp
View File

@ -191,8 +191,9 @@ void RimPlotTemplateFolderItem::defineEditorAttribute( const caf::PdmFieldHandle
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimPlotTemplateFolderItem::appendOptionItemsForPlotTemplatesRecursively(
QList<caf::PdmOptionItemInfo>& options, RimPlotTemplateFolderItem* templateFolderItem, int menuLevel )
void RimPlotTemplateFolderItem::appendOptionItemsForPlotTemplatesRecursively( QList<caf::PdmOptionItemInfo>& options,
RimPlotTemplateFolderItem* templateFolderItem,
int menuLevel )
{
{
auto subFolders = templateFolderItem->subFolders();

4
ApplicationCode/ProjectDataModel/Rim3dOverlayInfoConfig.cpp
View File

@ -566,8 +566,8 @@ QString Rim3dOverlayInfoConfig::caseInfoText( RimEclipseView* eclipseView )
QString weightingParameterString;
if ( contourMap->contourMapProjection()->weightingParameter() != "None" )
{
weightingParameterString += QString( " (Weight: %1)" )
.arg( contourMap->contourMapProjection()->weightingParameter() );
weightingParameterString +=
QString( " (Weight: %1)" ).arg( contourMap->contourMapProjection()->weightingParameter() );
}
infoText += QString( "<p><b>-- Contour Map: %1 --</b><p> "

10
ApplicationCode/ProjectDataModel/RimContourMapProjection.cpp
View File

@ -1160,7 +1160,8 @@ void RimContourMapProjection::generateContourPolygons()
///
//--------------------------------------------------------------------------------------------------
RimContourMapProjection::ContourPolygons RimContourMapProjection::createContourPolygonsFromLineSegments(
caf::ContourLines::ListOfLineSegments& unorderedLineSegments, double contourValue )
caf::ContourLines::ListOfLineSegments& unorderedLineSegments,
double contourValue )
{
const double areaThreshold = 1.5 * ( m_sampleSpacing * m_sampleSpacing ) /
( sampleSpacingFactor() * sampleSpacingFactor() );
@ -1448,11 +1449,8 @@ double RimContourMapProjection::interpolateValue( const cvf::Vec2d& gridPos2d )
x[2] = cvf::Vec3d( cellCenter + cvf::Vec2d( m_sampleSpacing * 0.5, m_sampleSpacing * 0.5 ), 0.0 );
x[3] = cvf::Vec3d( cellCenter + cvf::Vec2d( -m_sampleSpacing * 0.5, m_sampleSpacing * 0.5 ), 0.0 );
cvf::Vec4d baryCentricCoords = cvf::GeometryTools::barycentricCoords( x[0],
x[1],
x[2],
x[3],
cvf::Vec3d( gridPos2d, 0.0 ) );
cvf::Vec4d baryCentricCoords =
cvf::GeometryTools::barycentricCoords( x[0], x[1], x[2], x[3], cvf::Vec3d( gridPos2d, 0.0 ) );
std::array<cvf::Vec2ui, 4> v;
v[0] = cellContainingPoint;

9
ApplicationCode/ProjectDataModel/RimEclipseContourMapProjection.cpp
View File

@ -269,9 +269,8 @@ std::vector<double> RimEclipseContourMapProjection::calculateColumnResult( Resul
resultData->cellScalarResults( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "PORO" ), 0 );
const std::vector<double>& ntgResults =
resultData->cellScalarResults( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "NTG" ), 0 );
const std::vector<double>& dzResults = resultData->cellScalarResults( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE,
"DZ" ),
0 );
const std::vector<double>& dzResults =
resultData->cellScalarResults( RigEclipseResultAddress( RiaDefines::STATIC_NATIVE, "DZ" ), 0 );
CVF_ASSERT( poroResults.size() == ntgResults.size() && ntgResults.size() == dzResults.size() );
@ -434,8 +433,8 @@ double RimEclipseContourMapProjection::calculateRayLengthInCell( size_t
if ( RigHexIntersectionTools::lineHexCellIntersection( highestPoint, lowestPoint, hexCorners.data(), 0, &intersections ) )
{
double lengthInCell = ( intersections.back().m_intersectionPoint - intersections.front().m_intersectionPoint )
.length();
double lengthInCell =
( intersections.back().m_intersectionPoint - intersections.front().m_intersectionPoint ).length();
return lengthInCell;
}
return 0.0;

7
ApplicationCode/ProjectDataModel/RimEclipseGeometrySelectionItem.cpp
View File

@ -67,8 +67,11 @@ void RimEclipseGeometrySelectionItem::setFromSelectionItem( const RiuEclipseSele
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimEclipseGeometrySelectionItem::setFromCaseGridAndIJK(
RimEclipseCase* eclipseCase, size_t gridIndex, size_t i, size_t j, size_t k )
void RimEclipseGeometrySelectionItem::setFromCaseGridAndIJK( RimEclipseCase* eclipseCase,
size_t gridIndex,
size_t i,
size_t j,
size_t k )
{
m_eclipseCase = eclipseCase;
m_gridIndex = gridIndex;

7
ApplicationCode/ProjectDataModel/RimEclipseResultCase.cpp
View File

@ -485,11 +485,8 @@ void RimEclipseResultCase::updateFilePathsFromProjectPath( const QString& newPro
const std::vector<QString>& orgFilesContainingFaults = filesContainingFaults();
for ( auto faultFileName : orgFilesContainingFaults )
{
QString relocatedFaultFile = RimTools::relocateFile( faultFileName,
newProjectPath,
oldProjectPath,
&foundFile,
&searchedPaths );
QString relocatedFaultFile =
RimTools::relocateFile( faultFileName, newProjectPath, oldProjectPath, &foundFile, &searchedPaths );
relocatedFaultFiles.push_back( relocatedFaultFile );
}

16
ApplicationCode/ProjectDataModel/RimEclipseResultDefinition.cpp
View File

@ -1967,10 +1967,10 @@ void RimEclipseResultDefinition::syncInjectorToProducerSelection()
{
for ( const QString& producer : producers )
{
std::pair<double, double> commFluxes = flowSol->flowDiagResults()
->injectorProducerPairFluxes( selectedInjector.toStdString(),
producer.toStdString(),
timeStep );
std::pair<double, double> commFluxes =
flowSol->flowDiagResults()->injectorProducerPairFluxes( selectedInjector.toStdString(),
producer.toStdString(),
timeStep );
if ( std::abs( commFluxes.first ) > epsilon || std::abs( commFluxes.second ) > epsilon )
{
newProducerSelection.insert( producer );
@ -2013,10 +2013,10 @@ void RimEclipseResultDefinition::syncProducerToInjectorSelection()
{
for ( const QString& injector : injectors )
{
std::pair<double, double> commFluxes = flowSol->flowDiagResults()
->injectorProducerPairFluxes( injector.toStdString(),
selectedProducer.toStdString(),
timeStep );
std::pair<double, double> commFluxes =
flowSol->flowDiagResults()->injectorProducerPairFluxes( injector.toStdString(),
selectedProducer.toStdString(),
timeStep );
if ( std::abs( commFluxes.first ) > epsilon || std::abs( commFluxes.second ) > epsilon )
{
newInjectorSelection.insert( injector );

4
ApplicationCode/ProjectDataModel/RimEclipseStatisticsCase.cpp
View File

@ -547,8 +547,8 @@ void RimEclipseStatisticsCase::fieldChangedByUi( const caf::PdmFieldHandle* chan
// Propagate well info to statistics case
if ( sourceResultCase->eclipseCaseData() )
{
const cvf::Collection<RigSimWellData>& sourceCaseSimWellData = sourceResultCase->eclipseCaseData()
->wellResults();
const cvf::Collection<RigSimWellData>& sourceCaseSimWellData =
sourceResultCase->eclipseCaseData()->wellResults();
setWellResultsAndUpdateViews( sourceCaseSimWellData );
}
}

12
ApplicationCode/ProjectDataModel/RimFaultInViewCollection.cpp
View File

@ -285,9 +285,9 @@ void RimFaultInViewCollection::syncronizeFaults()
{
size_t gridLocalCellIndex;
const RigGridBase* hostGrid = mainGrid->gridAndGridLocalIdxFromGlobalCellIdx( nncConnections[connIndex]
.m_c1GlobIdx,
&gridLocalCellIndex );
const RigGridBase* hostGrid =
mainGrid->gridAndGridLocalIdxFromGlobalCellIdx( nncConnections[connIndex].m_c1GlobIdx,
&gridLocalCellIndex );
size_t i, j, k;
if ( hostGrid->ijkFromCellIndex( gridLocalCellIndex, &i, &j, &k ) )
@ -308,9 +308,9 @@ void RimFaultInViewCollection::syncronizeFaults()
{
size_t gridLocalCellIndex;
const RigGridBase* hostGrid = mainGrid->gridAndGridLocalIdxFromGlobalCellIdx( nncConnections[connIndex]
.m_c2GlobIdx,
&gridLocalCellIndex );
const RigGridBase* hostGrid =
mainGrid->gridAndGridLocalIdxFromGlobalCellIdx( nncConnections[connIndex].m_c2GlobIdx,
&gridLocalCellIndex );
size_t i, j, k;
if ( hostGrid->ijkFromCellIndex( gridLocalCellIndex, &i, &j, &k ) )

7
ApplicationCode/ProjectDataModel/RimFormationNames.cpp
View File

@ -171,11 +171,8 @@ void RimFormationNames::readFormationNamesFile( QString* errorMessage )
//--------------------------------------------------------------------------------------------------
void RimFormationNames::updateFilePathsFromProjectPath( const QString& newProjectPath, const QString& oldProjectPath )
{
m_formationNamesFileName = RimTools::relocateFile( m_formationNamesFileName(),
newProjectPath,
oldProjectPath,
nullptr,
nullptr );
m_formationNamesFileName =
RimTools::relocateFile( m_formationNamesFileName(), newProjectPath, oldProjectPath, nullptr, nullptr );
}
//--------------------------------------------------------------------------------------------------

4
ApplicationCode/ProjectDataModel/RimGeoMechContourMapProjection.cpp
View File

@ -474,8 +474,8 @@ double RimGeoMechContourMapProjection::calculateRayLengthInCell( size_t
if ( RigHexIntersectionTools::lineHexCellIntersection( highestPoint, lowestPoint, hexCorners.data(), 0, &intersections ) )
{
double lengthInCell = ( intersections.back().m_intersectionPoint - intersections.front().m_intersectionPoint )
.length();
double lengthInCell =
( intersections.back().m_intersectionPoint - intersections.front().m_intersectionPoint ).length();
return lengthInCell;
}
return 0.0;

8
ApplicationCode/ProjectDataModel/RimGeoMechResultDefinition.cpp
View File

@ -235,8 +235,8 @@ QList<caf::PdmOptionItemInfo>
{
if ( m_geomCase->geoMechData() )
{
size_t kCount = m_geomCase->geoMechData()->femParts()->part( 0 )->getOrCreateStructGrid()->gridPointCountK() -
1;
size_t kCount =
m_geomCase->geoMechData()->femParts()->part( 0 )->getOrCreateStructGrid()->gridPointCountK() - 1;
for ( size_t layerIdx = 0; layerIdx < kCount; ++layerIdx )
{
options.push_back( caf::PdmOptionItemInfo( QString::number( layerIdx + 1 ), (int)layerIdx ) );
@ -405,7 +405,9 @@ std::map<std::string, std::vector<std::string>> RimGeoMechResultDefinition::getR
///
//--------------------------------------------------------------------------------------------------
void RimGeoMechResultDefinition::getUiAndResultVariableStringList(
QStringList* uiNames, QStringList* variableNames, const std::map<std::string, std::vector<std::string>>& fieldCompNames )
QStringList* uiNames,
QStringList* variableNames,
const std::map<std::string, std::vector<std::string>>& fieldCompNames )
{
CVF_ASSERT( uiNames && variableNames );

8
ApplicationCode/ProjectDataModel/RimGridTimeHistoryCurve.cpp
View File

@ -154,8 +154,12 @@ void RimGridTimeHistoryCurve::setFromSelectionItem( const RiuSelectionItem* sele
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimGridTimeHistoryCurve::setFromEclipseCellAndResult(
RimEclipseCase* eclCase, size_t gridIdx, size_t i, size_t j, size_t k, const RigEclipseResultAddress& resAddr )
void RimGridTimeHistoryCurve::setFromEclipseCellAndResult( RimEclipseCase* eclCase,
size_t gridIdx,
size_t i,
size_t j,
size_t k,
const RigEclipseResultAddress& resAddr )
{
delete m_geometrySelectionItem();
delete m_eclipseResultDefinition();

10
ApplicationCode/ProjectDataModel/RimGridTimeHistoryCurve.h
View File

@ -53,9 +53,13 @@ public:
RimGridTimeHistoryCurve();
~RimGridTimeHistoryCurve() override;
void setFromSelectionItem( const RiuSelectionItem* selectionItem );
void setFromEclipseCellAndResult(
RimEclipseCase* eclCase, size_t gridIdx, size_t i, size_t j, size_t k, const RigEclipseResultAddress& resAddr );
void setFromSelectionItem( const RiuSelectionItem* selectionItem );
void setFromEclipseCellAndResult( RimEclipseCase* eclCase,
size_t gridIdx,
size_t i,
size_t j,
size_t k,
const RigEclipseResultAddress& resAddr );
RiaDefines::PlotAxis yAxis() const;
void setYAxis( RiaDefines::PlotAxis plotAxis );

6
ApplicationCode/ProjectDataModel/RimObservedDataCollection.cpp
View File

@ -165,8 +165,10 @@ RimObservedSummaryData*
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimObservedSummaryData* RimObservedDataCollection::createAndAddCvsObservedSummaryDataFromFile(
const QString& fileName, bool useSavedFieldsValuesInDialog, QString* errorText /*= nullptr*/ )
RimObservedSummaryData*
RimObservedDataCollection::createAndAddCvsObservedSummaryDataFromFile( const QString& fileName,
bool useSavedFieldsValuesInDialog,
QString* errorText /*= nullptr*/ )
{
if ( !fileExists( fileName, errorText ) ) return nullptr;

Some files were not shown because too many files have changed in this diff Show More