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

Use updated version of opm-common as submodule

Browse Source 
* Adjustments to build system for opm-common
* Add opm-common as submodule
* Disable use of unity build for opm-common
This commit is contained in:
Magne Sjaastad
2022-07-07 16:42:06 +02:00
parent d5269abc6e
commit 7a0bfd4917
2184 changed files with 11860 additions and 302420 deletions
Download Patch File Download Diff File Expand all files Collapse all files

59
ApplicationLibCode/FileInterface/RifHdf5SummaryExporter.cpp
View File

@@ -23,8 +23,13 @@
#include "RiaStdStringTools.h"
#include "RifHdf5Exporter.h"
#include "RifOpmCommonSummary.h"
#include "RifSummaryReaderInterface.h"
#ifdef _MSC_VER
// Disable warning from external library to make sure treat warnings as error works
#pragma warning( disable : 4267 )
#endif
#include "opm/common/utility/FileSystem.hpp"
#include "opm/common/utility/TimeService.hpp"
#include "opm/io/eclipse/ESmry.hpp"
@@ -76,7 +81,7 @@ bool RifHdf5SummaryExporter::ensureHdf5FileIsCreated( const std::string& smspecF
const std::string& h5FileName,
size_t& hdfFilesCreatedCount )
{
if ( !Opm::filesystem::exists( smspecFileName ) ) return false;
if ( !std::filesystem::exists( smspecFileName ) ) return false;
{
// Check if we have write permission in the folder
@@ -88,7 +93,7 @@ bool RifHdf5SummaryExporter::ensureHdf5FileIsCreated( const std::string& smspecF
bool exportIsRequired = false;
{
bool h5FileExists = Opm::filesystem::exists( h5FileName );
bool h5FileExists = std::filesystem::exists( h5FileName );
if ( !h5FileExists )
{
exportIsRequired = true;
@@ -107,7 +112,7 @@ bool RifHdf5SummaryExporter::ensureHdf5FileIsCreated( const std::string& smspecF
// Read all data summary data before starting export to HDF. Loading one and one summary vector causes huge
// performance penalty
sourceSummaryData.LoadData();
sourceSummaryData.loadData();
#pragma omp critical( critical_section_HDF5_export )
{
@@ -194,53 +199,47 @@ bool RifHdf5SummaryExporter::writeGeneralSection( RifHdf5Exporter& exporter, Opm
//--------------------------------------------------------------------------------------------------
bool RifHdf5SummaryExporter::writeSummaryVectors( RifHdf5Exporter& exporter, Opm::EclIO::ESmry& sourceSummaryData )
{
using SumNodeVector = std::vector<Opm::EclIO::SummaryNode>;
size_t valueCount = sourceSummaryData.numberOfTimeSteps();
if ( valueCount == 0 ) return false;
const std::string datasetName( "values" );
const SumNodeVector& summaryNodeList = sourceSummaryData.summaryNodeList();
auto summaryVectorsGroup = exporter.createGroup( nullptr, "summary_vectors" );
std::map<std::string, std::vector<size_t>> mapKeywordToSummaryNodeIndex;
for ( size_t i = 0; i < summaryNodeList.size(); i++ )
std::map<std::string, std::vector<RifEclipseSummaryAddress>> mapVectorNameToSummaryAddresses;
auto [addresses, addressToKeywordMap] =
RifOpmCommonSummaryTools::buildAddressesAndKeywordMap( sourceSummaryData.keywordList() );
for ( const auto& adr : addresses )
{
const auto summaryNode = summaryNodeList[i];
const std::string keyword = summaryNode.keyword;
auto vectorName = adr.vectorName();
if ( mapKeywordToSummaryNodeIndex.find( keyword ) == mapKeywordToSummaryNodeIndex.end() )
if ( mapVectorNameToSummaryAddresses.find( vectorName ) == mapVectorNameToSummaryAddresses.end() )
{
mapKeywordToSummaryNodeIndex[keyword] = std::vector<size_t>();
mapVectorNameToSummaryAddresses[vectorName] = {};
}
auto it = mapKeywordToSummaryNodeIndex.find( keyword );
if ( it != mapKeywordToSummaryNodeIndex.end() )
auto it = mapVectorNameToSummaryAddresses.find( vectorName );
if ( it != mapVectorNameToSummaryAddresses.end() )
{
it->second.push_back( i );
it->second.push_back( adr );
}
}
auto summaryVectorsGroup = exporter.createGroup( nullptr, "summary_vectors" );
std::set<std::string> exportErrorKeywords;
for ( const auto& nodesForKeyword : mapKeywordToSummaryNodeIndex )
for ( const auto& [vectorName, addresses] : mapVectorNameToSummaryAddresses )
{
std::string keyword = nodesForKeyword.first;
auto keywordGroup = exporter.createGroup( &summaryVectorsGroup, vectorName );
auto keywordGroup = exporter.createGroup( &summaryVectorsGroup, keyword );
for ( auto nodeIndex : nodesForKeyword.second )
for ( const auto& address : addresses )
{
const auto& summaryNode = summaryNodeList[nodeIndex];
auto smspecKeywordIndex = summaryNode.smspecKeywordIndex;
auto keyword = addressToKeywordMap[address];
auto smspecKeywordIndex = sourceSummaryData.getSmspecIndexForKeyword( keyword );
const QString& smspecKeywordText = QString( "%1" ).arg( smspecKeywordIndex );
try
{
const std::vector<float>& values = sourceSummaryData.get( summaryNode );
const std::vector<float>& values = sourceSummaryData.get( keyword );
auto dataValuesGroup = exporter.createGroup( &keywordGroup, smspecKeywordText.toStdString() );
exporter.writeDataset( dataValuesGroup, datasetName, values );
@@ -278,10 +277,10 @@ bool RifHdf5SummaryExporter::isFirstOlderThanSecond( const std::string& firstFil
{
// Use Opm namespace to make sure the code compiles on older compilers
if ( !Opm::filesystem::exists( firstFileName ) || !Opm::filesystem::exists( secondFileName ) ) return false;
if ( !std::filesystem::exists( firstFileName ) || !std::filesystem::exists( secondFileName ) ) return false;
auto timeA = Opm::filesystem::last_write_time( firstFileName );
auto timeB = Opm::filesystem::last_write_time( secondFileName );
auto timeA = std::filesystem::last_write_time( firstFileName );
auto timeB = std::filesystem::last_write_time( secondFileName );
return ( timeA < timeB );
}

128
ApplicationLibCode/FileInterface/RifOpmCommonSummary.cpp
View File

@@ -21,6 +21,10 @@
#include "RiaLogging.h"
#include "RiaStdStringTools.h"
#ifdef _MSC_VER
// Disable warning from external library to make sure treat warnings as error works
#pragma warning( disable : 4267 )
#endif
#include "opm/io/eclipse/ESmry.hpp"
#include "opm/io/eclipse/ExtESmry.hpp"
@@ -209,7 +213,7 @@ void RifOpmCommonEclipseSummary::buildMetaData()
m_timeSteps.push_back( timeAsTimeT );
}
auto [addresses, addressMap] = RifOpmCommonSummaryTools::buildMetaDataKeyword( keywords );
auto [addresses, addressMap] = RifOpmCommonSummaryTools::buildAddressesAndKeywordMap( keywords );
m_allResultAddresses = addresses;
m_summaryAddressToKeywordMap = addressMap;
@@ -276,129 +280,53 @@ QString RifOpmCommonEclipseSummary::enhancedSummaryFilename( const QString& head
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RifEclipseSummaryAddress RifOpmCommonSummaryTools::createAddressFromSummaryNode( const Opm::EclIO::SummaryNode& summaryNode,
const Opm::EclIO::ESmry* summaryFile )
std::tuple<std::set<RifEclipseSummaryAddress>, std::map<RifEclipseSummaryAddress, size_t>, std::map<RifEclipseSummaryAddress, std::string>>
RifOpmCommonSummaryTools::buildAddressesSmspecAndKeywordMap( const Opm::EclIO::ESmry* summaryFile )
{
int i = -1;
int j = -1;
int k = -1;
switch ( summaryNode.category )
{
case Opm::EclIO::SummaryNode::Category::Aquifer:
return RifEclipseSummaryAddress::aquiferAddress( summaryNode.keyword, summaryNode.number );
break;
case Opm::EclIO::SummaryNode::Category::Well:
return RifEclipseSummaryAddress::wellAddress( summaryNode.keyword, summaryNode.wgname );
break;
case Opm::EclIO::SummaryNode::Category::Group:
return RifEclipseSummaryAddress::groupAddress( summaryNode.keyword, summaryNode.wgname );
break;
case Opm::EclIO::SummaryNode::Category::Field:
return RifEclipseSummaryAddress::fieldAddress( summaryNode.keyword );
break;
case Opm::EclIO::SummaryNode::Category::Region:
{
if ( summaryNode.isRegionToRegion() )
{
auto [r1, r2] = summaryNode.regionToRegionNumbers();
return RifEclipseSummaryAddress::regionToRegionAddress( summaryNode.keyword, r1, r2 );
}
return RifEclipseSummaryAddress::regionAddress( summaryNode.keyword, summaryNode.number );
}
break;
case Opm::EclIO::SummaryNode::Category::Block:
summaryFile->ijk_from_global_index( summaryNode.number, i, j, k );
return RifEclipseSummaryAddress::blockAddress( summaryNode.keyword, i, j, k );
break;
case Opm::EclIO::SummaryNode::Category::Connection:
summaryFile->ijk_from_global_index( summaryNode.number, i, j, k );
return RifEclipseSummaryAddress::wellCompletionAddress( summaryNode.keyword, summaryNode.wgname, i, j, k );
break;
case Opm::EclIO::SummaryNode::Category::Segment:
return RifEclipseSummaryAddress::wellSegmentAddress( summaryNode.keyword, summaryNode.wgname, summaryNode.number );
break;
case Opm::EclIO::SummaryNode::Category::Miscellaneous:
return RifEclipseSummaryAddress::miscAddress( summaryNode.keyword );
break;
default:
break;
case Opm::EclIO::SummaryNode::Category::Node:
// The vector "GPR" is defined as Node
// The behavior in libecl is to use the category Group
// https://github.com/OPM/ResInsight/issues/7838
return RifEclipseSummaryAddress::groupAddress( summaryNode.keyword, summaryNode.wgname );
break;
case Opm::EclIO::SummaryNode::Category::Network:
return RifEclipseSummaryAddress::networkAddress( summaryNode.keyword );
break;
case Opm::EclIO::SummaryNode::Category::Well_Lgr:
return RifEclipseSummaryAddress::wellLgrAddress( summaryNode.keyword, summaryNode.lgrname, summaryNode.wgname );
break;
case Opm::EclIO::SummaryNode::Category::Block_Lgr:
return RifEclipseSummaryAddress::blockLgrAddress( summaryNode.keyword,
summaryNode.lgrname,
summaryNode.lgri,
summaryNode.lgrj,
summaryNode.lgrk );
break;
case Opm::EclIO::SummaryNode::Category::Connection_Lgr:
return RifEclipseSummaryAddress::wellCompletionLgrAddress( summaryNode.keyword,
summaryNode.lgrname,
summaryNode.wgname,
summaryNode.lgri,
summaryNode.lgrj,
summaryNode.lgrk );
break;
}
return RifEclipseSummaryAddress();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::pair<std::set<RifEclipseSummaryAddress>, std::map<RifEclipseSummaryAddress, size_t>>
RifOpmCommonSummaryTools::buildMetaData( const Opm::EclIO::ESmry* summaryFile )
{
std::set<RifEclipseSummaryAddress> addresses;
std::map<RifEclipseSummaryAddress, size_t> addressToNodeIndexMap;
std::set<RifEclipseSummaryAddress> addresses;
std::map<RifEclipseSummaryAddress, size_t> addressToSmspecIndexMap;
std::map<RifEclipseSummaryAddress, std::string> addressToKeywordMap;
if ( summaryFile )
{
auto nodes = summaryFile->summaryNodeList();
for ( size_t i = 0; i < nodes.size(); i++ )
auto keywords = summaryFile->keywordList();
for ( const auto& keyword : keywords )
{
auto summaryNode = nodes[i];
auto eclAdr = createAddressFromSummaryNode( summaryNode, summaryFile );
auto eclAdr = RifEclipseSummaryAddress::fromEclipseTextAddress( keyword );
if ( !eclAdr.isValid() )
{
// If a category is not found, use the MISC category
eclAdr = RifEclipseSummaryAddress::miscAddress( keyword );
}
if ( eclAdr.isValid() )
{
addresses.insert( eclAdr );
addressToNodeIndexMap[eclAdr] = i;
size_t smspecIndex = summaryFile->getSmspecIndexForKeyword( keyword );
addressToSmspecIndexMap[eclAdr] = smspecIndex;
addressToKeywordMap[eclAdr] = keyword;
}
}
}
return { addresses, addressToNodeIndexMap };
return { addresses, addressToSmspecIndexMap, addressToKeywordMap };
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::pair<std::set<RifEclipseSummaryAddress>, std::map<RifEclipseSummaryAddress, std::string>>
RifOpmCommonSummaryTools::buildMetaDataKeyword( const std::vector<std::string>& keywords )
RifOpmCommonSummaryTools::buildAddressesAndKeywordMap( const std::vector<std::string>& keywords )
{
std::set<RifEclipseSummaryAddress> addresses;
std::map<RifEclipseSummaryAddress, std::string> addressToNodeIndexMap;
std::map<RifEclipseSummaryAddress, std::string> addressToKeywordMap;
std::vector<std::string> invalidKeywords;
#pragma omp parallel
{
std::set<RifEclipseSummaryAddress> threadAddresses;
std::map<RifEclipseSummaryAddress, std::string> threadAddressToNodeIndexMap;
std::map<RifEclipseSummaryAddress, std::string> threadAddressToKeywordMap;
std::vector<std::string> threadInvalidKeywords;
#pragma omp for
@@ -418,14 +346,14 @@ std::pair<std::set<RifEclipseSummaryAddress>, std::map<RifEclipseSummaryAddress,
if ( eclAdr.isValid() )
{
threadAddresses.insert( eclAdr );
threadAddressToNodeIndexMap[eclAdr] = keyword;
threadAddressToKeywordMap[eclAdr] = keyword;
}
}
#pragma omp critical
{
addresses.insert( threadAddresses.begin(), threadAddresses.end() );
addressToNodeIndexMap.insert( threadAddressToNodeIndexMap.begin(), threadAddressToNodeIndexMap.end() );
addressToKeywordMap.insert( threadAddressToKeywordMap.begin(), threadAddressToKeywordMap.end() );
invalidKeywords.insert( invalidKeywords.end(), threadInvalidKeywords.begin(), threadInvalidKeywords.end() );
}
@@ -439,5 +367,5 @@ std::pair<std::set<RifEclipseSummaryAddress>, std::map<RifEclipseSummaryAddress,
*/
}
return { addresses, addressToNodeIndexMap };
return { addresses, addressToKeywordMap };
}

13
ApplicationLibCode/FileInterface/RifOpmCommonSummary.h
View File

@@ -30,6 +30,7 @@
#include <memory>
#include <set>
#include <string>
#include <tuple>
#include <vector>
namespace Opm
@@ -38,7 +39,6 @@ namespace EclIO
{
class ESmry;
class ExtESmry;
struct SummaryNode;
} // namespace EclIO
} // namespace Opm
@@ -47,14 +47,13 @@ class RiaThreadSafeLogger;
class RifOpmCommonSummaryTools
{
public:
static RifEclipseSummaryAddress createAddressFromSummaryNode( const Opm::EclIO::SummaryNode& summaryNode,
const Opm::EclIO::ESmry* summaryFile );
static std::pair<std::set<RifEclipseSummaryAddress>, std::map<RifEclipseSummaryAddress, size_t>>
buildMetaData( const Opm::EclIO::ESmry* summaryFile );
static std::tuple<std::set<RifEclipseSummaryAddress>,
std::map<RifEclipseSummaryAddress, size_t>,
std::map<RifEclipseSummaryAddress, std::string>>
buildAddressesSmspecAndKeywordMap( const Opm::EclIO::ESmry* summaryFile );
static std::pair<std::set<RifEclipseSummaryAddress>, std::map<RifEclipseSummaryAddress, std::string>>
buildMetaDataKeyword( const std::vector<std::string>& keywords );
buildAddressesAndKeywordMap( const std::vector<std::string>& keywords );
};
//==================================================================================================

40
ApplicationLibCode/FileInterface/RifOpmHdf5Summary.cpp
View File

@@ -24,6 +24,10 @@
#include "RifHdf5SummaryReader.h"
#include "RifOpmCommonSummary.h"
#ifdef _MSC_VER
// Disable warning from external library to make sure treat warnings as error works
#pragma warning( disable : 4267 )
#endif
#include "opm/io/eclipse/ESmry.hpp"
#include <QFileInfo>
@@ -95,18 +99,18 @@ bool RifOpmHdf5Summary::values( const RifEclipseSummaryAddress& resultAddress, s
{
if ( m_eSmry && m_hdf5Reader )
{
auto it = m_adrToSummaryNodeIndex.find( resultAddress );
if ( it != m_adrToSummaryNodeIndex.end() )
auto it = m_adrToSmspecIndices.find( resultAddress );
if ( it != m_adrToSmspecIndices.end() )
{
size_t index = it->second;
auto node = m_eSmry->summaryNodeList()[index];
int smspecIndex = static_cast<int>( node.smspecKeywordIndex );
const auto& vectorName = resultAddress.vectorName();
size_t smspecIndex = it->second;
*values = m_hdf5Reader->values( vectorName, smspecIndex );
if ( smspecIndex != std::numeric_limits<size_t>::max() )
{
*values = m_hdf5Reader->values( vectorName, static_cast<int>( smspecIndex ) );
return true;
return true;
}
}
}
@@ -120,13 +124,12 @@ std::string RifOpmHdf5Summary::unitName( const RifEclipseSummaryAddress& resultA
{
if ( m_eSmry )
{
auto it = m_adrToSummaryNodeIndex.find( resultAddress );
if ( it != m_adrToSummaryNodeIndex.end() )
auto it = m_summaryAddressToKeywordMap.find( resultAddress );
if ( it != m_summaryAddressToKeywordMap.end() )
{
auto index = it->second;
auto node = m_eSmry->summaryNodeList()[index];
auto keyword = it->second;
auto stringFromFileReader = m_eSmry->get_unit( keyword );
auto stringFromFileReader = m_eSmry->get_unit( node );
return RiaStdStringTools::trimString( stringFromFileReader );
}
}
@@ -167,10 +170,13 @@ void RifOpmHdf5Summary::buildMetaData()
}
}
auto [addresses, addressMap] = RifOpmCommonSummaryTools::buildMetaData( m_eSmry.get() );
m_allResultAddresses = addresses;
m_adrToSummaryNodeIndex = addressMap;
{
auto [addresses, smspecIndices, addressToKeywordMap] =
RifOpmCommonSummaryTools::buildAddressesSmspecAndKeywordMap( m_eSmry.get() );
m_allResultAddresses = addresses;
m_adrToSmspecIndices = smspecIndices;
m_summaryAddressToKeywordMap = addressToKeywordMap;
}
}
}

7
ApplicationLibCode/FileInterface/RifOpmHdf5Summary.h
View File

@@ -66,9 +66,10 @@ private:
bool openESmryFile( const QString& headerFileName, bool includeRestartFiles, RiaThreadSafeLogger* threadSafeLogger );
private:
std::unique_ptr<Opm::EclIO::ESmry> m_eSmry;
std::map<RifEclipseSummaryAddress, size_t> m_adrToSummaryNodeIndex;
std::vector<time_t> m_timeSteps;
std::unique_ptr<Opm::EclIO::ESmry> m_eSmry;
std::map<RifEclipseSummaryAddress, std::string> m_summaryAddressToKeywordMap;
std::map<RifEclipseSummaryAddress, size_t> m_adrToSmspecIndices;
std::vector<time_t> m_timeSteps;
std::unique_ptr<RifHdf5SummaryReader> m_hdf5Reader;
};

9
ApplicationLibCode/FileInterface/RifProjectSummaryDataWriter.cpp
View File

@@ -20,12 +20,17 @@
#include "RifSummaryReaderInterface.h"
#include "cafAssert.h"
#ifdef _MSC_VER
// Disable warning from external library to make sure treat warnings as error works
#pragma warning( disable : 4267 )
#endif
#include "opm/common/utility/TimeService.hpp"
#include "opm/io/eclipse/EclOutput.hpp"
#include "opm/io/eclipse/ExtESmry.hpp"
#include "cafAssert.h"
#include <numeric>
//--------------------------------------------------------------------------------------------------