//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
Rim3dOverlayInfoConfig::HistogramData Rim3dOverlayInfoConfig::histogramData()
{
auto eclipseView = dynamic_cast<RimEclipseView*>(m_viewDef.p());
auto geoMechView = dynamic_cast<RimGeoMechView*>(m_viewDef.p());
if (eclipseView) return histogramData(eclipseView);
if (geoMechView) return histogramData(geoMechView);
return HistogramData();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim3dOverlayInfoConfig::updateGeoMech3DInfo(RimGeoMechView * geoMechView)
{
HistogramData histData;
if (m_showResultInfo() || m_showHistogram())
{
histData = histogramData(geoMechView);
}
// Compose text
QString infoText;
if (m_showCaseInfo())
{
infoText = caseInfoText(geoMechView);
}
if (m_showResultInfo())
{
infoText += resultInfoText(histData, geoMechView);
}
if (!infoText.isEmpty())
{
geoMechView->viewer()->setInfoText(infoText);
}
// Populate histogram
if (m_showHistogram())
{
RimGeoMechCase* geoMechCase = geoMechView->geoMechCase();
RigGeoMechCaseData* caseData = geoMechCase ? geoMechCase->geoMechData() : nullptr;
bool isResultsInfoRelevant = caseData && geoMechView->hasUserRequestedAnimation() && geoMechView->cellResultResultDefinition()->hasResult();
if (isResultsInfoRelevant)
{
geoMechView->viewer()->showHistogram(true);
geoMechView->viewer()->setHistogram(histData.min, histData.max, *histData.histogram);
geoMechView->viewer()->setHistogramPercentiles(histData.p10, histData.p90, histData.mean);
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim3dOverlayInfoConfig::updateEclipse3DInfo(RimEclipseView * eclipseView)
{
HistogramData histData;
if (m_showHistogram() || m_showResultInfo())
{
histData = histogramData();
}
QString infoText;
if (m_showCaseInfo())
{
infoText = caseInfoText();
}
if (m_showResultInfo())
{
infoText += resultInfoText(histData);
}
if (!infoText.isEmpty())
{
eclipseView->viewer()->setInfoText(infoText);
}
if (m_showHistogram())
{
bool isResultsInfoRelevant = eclipseView->hasUserRequestedAnimation() && eclipseView->cellResult()->hasResult();
if (isResultsInfoRelevant && histData.histogram)
{
eclipseView->viewer()->showHistogram(true);
eclipseView->viewer()->setHistogram(histData.min, histData.max, *histData.histogram);
eclipseView->viewer()->setHistogramPercentiles(histData.p10, histData.p90, histData.mean);
}
}
}
TripMetricsReference::TripMetricsReference( const std::vector< TripMetrics >& input,
long binsForHistograms,
const TripMetricsReference& reference ):
m_histograms(),
m_binsForHistograms( binsForHistograms ),
m_meanValues(),
m_stdValues(),
m_pca( 0 )
{
// Create the vectors to feed the histograms
if ( input.size() == 0 ) {
throw std::runtime_error( "TripMetricsReference::TripMetricsReference : 0 size input given." );
}
const size_t numberOfHistograms = input.front().values().size();
std::vector< std::vector<double> > allValues( numberOfHistograms, std::vector<double>() );
// Loop over the trip metrics and fill in the valarrays, minimum and maximum values
for ( size_t iMetric = 0; iMetric < input.size(); ++iMetric ) {
const std::vector<double>& metricValues = input[iMetric].values();
for ( size_t iValue = 0; iValue < numberOfHistograms; ++iValue ) {
if ( std::isnan(metricValues[iValue])) continue;
double currentValue = metricValues[iValue];
allValues[iValue].push_back( currentValue );
}
}
// For each vector create the corresponding histogram
for ( size_t iValue = 0; iValue < numberOfHistograms; ++iValue ) {
std::vector<double>& valuesForMetric = allValues[iValue];
double lowEdge = reference.m_histograms[iValue]->lowEdge();
double highEdge = reference.m_histograms[iValue]->highEdge();
double binSize = ( (highEdge/1.01) - lowEdge ) / binsForHistograms;
// Create the histogram
m_histograms.push_back( new Histogram( valuesForMetric,
binsForHistograms,
lowEdge,
highEdge ) );
}
// Get rid of empty values and normalise
allValues.clear();
allValues.reserve( input.size() );
for ( std::vector< TripMetrics >::const_iterator iSample = input.begin(); iSample != input.end(); ++iSample )
allValues.push_back( iSample->values() );
const long nBinaryVariables = TripMetrics::numberOfBinaryMetrics();
const long numberOfFeatures = numberOfHistograms - nBinaryVariables;
std::vector< std::vector< double > > cleanData;
cleanData.reserve( allValues.size() );
m_meanValues = reference.m_meanValues;
m_stdValues = reference.m_stdValues;
for ( size_t iSample = 0; iSample < allValues.size(); ++iSample ) {
bool nanFound = false;
const std::vector<double>& metricValues = allValues[iSample];
for ( size_t iMetric = 0; iMetric < metricValues.size(); ++iMetric ) {
if ( std::isnan( metricValues[iMetric]) ) {
nanFound = true;
break;
}
}
if ( nanFound ) continue;
std::vector<double> sampleValues = std::vector<double>( metricValues.begin() + nBinaryVariables, metricValues.end() );
// Normalise using previously calculated mean and std values.
for ( size_t iFeature = 0; iFeature < numberOfFeatures; ++iFeature ) sampleValues[iFeature] = (sampleValues[iFeature] - m_meanValues[iFeature] ) / m_stdValues[iFeature];
cleanData.push_back( sampleValues );
}
// Transform the clean data using the reference pca obejcts and create the corresponding histograms
m_pca = new PCA( *(reference.m_pca ) );
for ( std::vector< std::vector< double > >::iterator iData = cleanData.begin(); iData != cleanData.end(); ++iData )
*iData = m_pca->transform( *iData );
const size_t nPrincipalComponents = cleanData.front().size();
const size_t numberOfSamples = cleanData.size();
m_histogramsPCA.reserve( nPrincipalComponents );
for ( size_t iComponent = 0; iComponent < nPrincipalComponents; ++iComponent ) {
std::vector< double > histogramData( numberOfSamples, 0.0 );
for ( size_t iSample = 0; iSample < numberOfSamples; ++iSample ) {
histogramData[iSample] = cleanData[iSample][iComponent];
}
// Create the histogram
m_histogramsPCA.push_back( new Histogram( histogramData,
m_binsForHistograms,
reference.m_histogramsPCA[iComponent]->lowEdge(),
reference.m_histogramsPCA[iComponent]->highEdge() ) );
}
}
void
TripMetricsReference::performPCA( const std::vector< std::vector<double> >& input )
{
const long nBinaryVariables = TripMetrics::numberOfBinaryMetrics();
// Get rid of empty values.
std::vector< std::vector< double > > cleanData;
cleanData.reserve( input.size() );
for ( size_t iSample = 0; iSample < input.size(); ++iSample ) {
bool nanFound = false;
const std::vector<double>& metricValues = input[iSample];
for ( size_t iMetric = nBinaryVariables; iMetric < metricValues.size(); ++iMetric ) {
if ( std::isnan( metricValues[iMetric]) ) {
nanFound = true;
break;
}
}
if ( nanFound ) continue;
cleanData.push_back( std::vector<double>( metricValues.begin() + nBinaryVariables, metricValues.end() ) );
}
// Get rid of the extreme values
const double percentageToKeep = 99.8;
std::vector<std::vector<double> > cleanDataNoExtremes = tripExtremesFromColumns( cleanData, percentageToKeep );
// Then normalize the values. Store the mean and std to be used when scoring
const size_t numberOfFeatures = cleanDataNoExtremes.front().size();
const size_t numberOfSamples = cleanDataNoExtremes.size();
m_meanValues = std::vector< double >( numberOfFeatures, 0.0 );
m_stdValues = std::vector< double >( numberOfFeatures, 0.0 );
for ( size_t iFeature = 0; iFeature < numberOfFeatures; ++iFeature ) {
// calculate mean and standard deviation
double sx = 0;
double sxx = 0;
for ( size_t iSample = 0; iSample < cleanDataNoExtremes.size(); ++iSample ) {
const double x = cleanDataNoExtremes[iSample][iFeature];
sx += x;
sxx += x*x;
}
const double mx = sx / numberOfSamples;
const double stdx = std::sqrt( (sxx / numberOfSamples) - mx*mx );
m_meanValues[iFeature] = mx;
m_stdValues[iFeature] = stdx;
// normalise values
for ( size_t iSample = 0; iSample < cleanDataNoExtremes.size(); ++iSample ) {
const double x = cleanData[iSample][iFeature];
const double xnew = (x - mx) / stdx;
cleanDataNoExtremes[iSample][iFeature] = xnew;
}
}
if ( m_pca ) delete m_pca;
m_pca = new PCA;
// Find the principal components using the clean sample without the extremes
m_pca->fit( cleanDataNoExtremes );
// Transform the clean data to identify the histogram edges
for ( std::vector< std::vector< double > >::iterator iData = cleanDataNoExtremes.begin(); iData != cleanDataNoExtremes.end(); ++iData )
*iData = m_pca->transform( *iData );
const size_t nPrincipalComponents = cleanDataNoExtremes.front().size();
std::vector<double> minValues = cleanDataNoExtremes.front();
std::vector<double> maxValues = minValues;
for ( size_t iComponent = 0; iComponent < nPrincipalComponents; ++iComponent ) {
for (size_t i = 0; i < cleanDataNoExtremes.size(); ++i ) {
const double value = cleanDataNoExtremes[i][iComponent];
if ( value < minValues[iComponent] ) minValues[iComponent] = value;
if ( value > maxValues[iComponent] ) maxValues[iComponent] = value;
}
}
// Normalise the full reference data
// Normalise and tranform the full reference data
for ( std::vector< std::vector< double > >::iterator iData = cleanData.begin(); iData != cleanData.end(); ++iData ) {
std::vector<double>& sampleData = *iData;
// Normalise
for ( size_t iFeature = 0; iFeature < numberOfFeatures; ++iFeature )
sampleData[iFeature] = (sampleData[iFeature] - m_meanValues[iFeature] ) / m_stdValues[iFeature];
// Transform
sampleData = m_pca->transform( sampleData );
}
// Create the histograms with the principal component values
m_histogramsPCA.reserve( nPrincipalComponents );
for ( size_t iComponent = 0; iComponent < nPrincipalComponents; ++iComponent ) {
std::vector< double > histogramData( numberOfSamples, 0.0 );
double minValue = minValues[iComponent];
double maxValue = maxValues[iComponent];
for ( size_t iSample = 0; iSample < cleanData.size(); ++iSample ) {
const double value = cleanData[iSample][iComponent];
histogramData[iSample] = value;
}
// Determine the edges, the bins and create the corresponding histogram.
double binSize = ( maxValue - minValue ) / m_binsForHistograms;
maxValue += 0.01 * binSize;
// Create the histogram
m_histogramsPCA.push_back( new Histogram( histogramData,
m_binsForHistograms,
minValue,
maxValue ) );
}
}
