ResInsight/ApplicationLibCode/ReservoirDataModel/ResultAccessors/RigCombMultResultAccessor.cpp

/////////////////////////////////////////////////////////////////////////////////
//
//  Copyright (C) Statoil ASA
//  Copyright (C) Ceetron Solutions AS
//
//  ResInsight is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
//
//  ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
//  WARRANTY; without even the implied warranty of MERCHANTABILITY or
//  FITNESS FOR A PARTICULAR PURPOSE.
//
//  See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
//  for more details.
//
/////////////////////////////////////////////////////////////////////////////////

#include "RigCombMultResultAccessor.h"

#include "RigGridBase.h"

#include "RigCell.h"
#include "RigMainGrid.h"
#include <cmath>

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigCombMultResultAccessor::RigCombMultResultAccessor( const RigGridBase* grid )
    : m_grid( grid )
{
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigCombMultResultAccessor::setMultResultAccessors( RigResultAccessor* multXPosAccessor,
                                                        RigResultAccessor* multXNegAccessor,
                                                        RigResultAccessor* multYPosAccessor,
                                                        RigResultAccessor* multYNegAccessor,
                                                        RigResultAccessor* multZPosAccessor,
                                                        RigResultAccessor* multZNegAccessor )
{
    m_multXPosAccessor = multXPosAccessor;
    m_multXNegAccessor = multXNegAccessor;
    m_multYPosAccessor = multYPosAccessor;
    m_multYNegAccessor = multYNegAccessor;
    m_multZPosAccessor = multZPosAccessor;
    m_multZNegAccessor = multZNegAccessor;
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RigCombMultResultAccessor::cellScalar( size_t gridLocalCellIndex ) const
{
    CVF_TIGHT_ASSERT( false );

    return HUGE_VAL;
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RigCombMultResultAccessor::cellFaceScalar( size_t gridLocalCellIndex, cvf::StructGridInterface::FaceType faceId ) const
{
    // A non-directional face (e.g. NO_FACE from a plain cell pick) has no neighbor multiplier to combine.
    // Return 1.0, consistent with the "no change in MULT factor" convention used in nativeMultScalar.
    if ( faceId == cvf::StructGridInterface::NO_FACE ) return 1.0;

    size_t i, j, k, neighborGridCellIdx;
    m_grid->ijkFromCellIndex( gridLocalCellIndex, &i, &j, &k );

    double faceScalarThisCell = nativeMultScalar( gridLocalCellIndex, faceId );

    double faceScalarNeighborCell = 1.0;
    if ( m_grid->cellIJKNeighbor( i, j, k, faceId, &neighborGridCellIdx ) )
    {
        faceScalarNeighborCell = nativeMultScalar( neighborGridCellIdx, cvf::StructGridInterface::oppositeFace( faceId ) );
    }

    return faceScalarThisCell * faceScalarNeighborCell;
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RigCombMultResultAccessor::nativeMultScalar( size_t gridLocalCellIndex, cvf::StructGridInterface::FaceType faceId ) const
{
    double faceScalar = 1.0;

    switch ( faceId )
    {
        case cvf::StructGridInterface::POS_I:
        {
            if ( m_multXPosAccessor.notNull() )
            {
                faceScalar = m_multXPosAccessor->cellScalar( gridLocalCellIndex );
            }
            break;
        }
        case cvf::StructGridInterface::NEG_I:
        {
            if ( m_multXNegAccessor.notNull() )
            {
                faceScalar = m_multXNegAccessor->cellScalar( gridLocalCellIndex );
            }
            break;
        }

        case cvf::StructGridInterface::POS_J:
        {
            if ( m_multYPosAccessor.notNull() )
            {
                faceScalar = m_multYPosAccessor->cellScalar( gridLocalCellIndex );
            }
            break;
        }
        case cvf::StructGridInterface::NEG_J:
        {
            if ( m_multYNegAccessor.notNull() )
            {
                faceScalar = m_multYNegAccessor->cellScalar( gridLocalCellIndex );
            }
            break;
        }

        case cvf::StructGridInterface::POS_K:
        {
            if ( m_multZPosAccessor.notNull() )
            {
                faceScalar = m_multZPosAccessor->cellScalar( gridLocalCellIndex );
            }
            break;
        }
        case cvf::StructGridInterface::NEG_K:
        {
            if ( m_multZNegAccessor.notNull() )
            {
                faceScalar = m_multZNegAccessor->cellScalar( gridLocalCellIndex );
            }
            break;
        }
        default:
            break;
    }

    // FaceScalar with value HUGE_VAL means value outside valid IJK-range. Clamp to 1.0 as this means no change in MULT
    // factor.
    if ( faceScalar == HUGE_VAL )
    {
        faceScalar = 1.0;
    }

    return faceScalar;
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RigCombMultResultAccessor::cellScalarGlobIdx( size_t globCellIndex ) const
{
    CVF_TIGHT_ASSERT( false );

    return HUGE_VAL;
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RigCombMultResultAccessor::cellFaceScalarGlobIdx( size_t globCellIndex, cvf::StructGridInterface::FaceType faceId ) const
{
    size_t gridLocalCellIndex = m_grid->mainGrid()->cell( globCellIndex ).gridLocalCellIndex();
    return cellFaceScalar( gridLocalCellIndex, faceId );
}