コード例 #1
0
ファイル: RigGridBase.cpp プロジェクト: magnesj/ResInsight
//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
bool RigGridBase::isCellValid(size_t i, size_t j, size_t k) const
{
    if (i >= cellCountI() || j >= cellCountJ() || k >= cellCountK())
    {
        return false;
    }

    size_t idx = cellIndexFromIJK(i, j, k);
    const RigCell& c = cell(idx);
    return !c.isInvalid();
}
コード例 #2
0
ファイル: RigGridBase.cpp プロジェクト: magnesj/ResInsight
//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
bool RigGridBase::ijkFromCellIndex(size_t cellIndex, size_t* i, size_t* j, size_t* k) const
{
    CVF_TIGHT_ASSERT(cellIndex < cellCount());

    size_t index = cellIndex;

    if (cellCountI() <= 0 || cellCountJ() <= 0)
    {
        return false;
    }

    *k      = index/(cellCountI()*cellCountJ());
    index   -= (*k)*(cellCountI()*cellCountJ());
    *j      = index/cellCountI();
    index   -= (*j)*cellCountI();
    *i      = index;


    return true;
}
コード例 #3
0
ファイル: cvfStructGrid.cpp プロジェクト: vkip/ResInsight
//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void StructGridInterface::characteristicCellSizes(double* iSize, double* jSize, double* kSize)
{
    CVF_ASSERT(iSize && jSize && kSize);

    if (m_characteristicCellSizeI == cvf::UNDEFINED_DOUBLE
        || m_characteristicCellSizeJ == cvf::UNDEFINED_DOUBLE
        || m_characteristicCellSizeK == cvf::UNDEFINED_DOUBLE)
    {

        ubyte faceConnPosI[4];
        cellFaceVertexIndices(StructGridInterface::POS_I, faceConnPosI);

        ubyte faceConnNegI[4];
        cellFaceVertexIndices(StructGridInterface::NEG_I, faceConnNegI);
        
        ubyte faceConnPosJ[4];
        cellFaceVertexIndices(StructGridInterface::POS_J, faceConnPosJ);

        ubyte faceConnNegJ[4];
        cellFaceVertexIndices(StructGridInterface::NEG_J, faceConnNegJ);

        ubyte faceConnPosK[4];
        cellFaceVertexIndices(StructGridInterface::POS_K, faceConnPosK);

        ubyte faceConnNegK[4];
        cellFaceVertexIndices(StructGridInterface::NEG_K, faceConnNegK);

        double iSize = 0.0;
        double jSize = 0.0;
        double kSize = 0.0;

        cvf::Vec3d cornerVerts[8];
        size_t cellCount = 0;

        size_t k;
        for (k = 0; k < cellCountK(); k++)
        {
            size_t j;
            for (j = 0; j < cellCountJ(); j++)
            {
                size_t i;
                for (i = 0; i < cellCountI(); i += 10)  // NB! Evaluate every n-th cell
                {
                    if (isCellValid(i, j, k))
                    {
                        size_t cellIndex = cellIndexFromIJK(i, j, k);
                        cellCornerVertices(cellIndex, cornerVerts);

                        iSize += (cornerVerts[faceConnPosI[0]] - cornerVerts[faceConnNegI[0]]).lengthSquared();
                        iSize += (cornerVerts[faceConnPosI[1]] - cornerVerts[faceConnNegI[3]]).lengthSquared();
                        iSize += (cornerVerts[faceConnPosI[2]] - cornerVerts[faceConnNegI[2]]).lengthSquared();
                        iSize += (cornerVerts[faceConnPosI[3]] - cornerVerts[faceConnNegI[1]]).lengthSquared();

                        jSize += (cornerVerts[faceConnPosJ[0]] - cornerVerts[faceConnNegJ[0]]).lengthSquared();
                        jSize += (cornerVerts[faceConnPosJ[1]] - cornerVerts[faceConnNegJ[3]]).lengthSquared();
                        jSize += (cornerVerts[faceConnPosJ[2]] - cornerVerts[faceConnNegJ[2]]).lengthSquared();
                        jSize += (cornerVerts[faceConnPosJ[3]] - cornerVerts[faceConnNegJ[1]]).lengthSquared();

                        kSize += (cornerVerts[faceConnPosK[0]] - cornerVerts[faceConnNegK[0]]).lengthSquared();
                        kSize += (cornerVerts[faceConnPosK[1]] - cornerVerts[faceConnNegK[3]]).lengthSquared();
                        kSize += (cornerVerts[faceConnPosK[2]] - cornerVerts[faceConnNegK[2]]).lengthSquared();
                        kSize += (cornerVerts[faceConnPosK[3]] - cornerVerts[faceConnNegK[1]]).lengthSquared();

                        cellCount++;
                    }
                }
            }
        }

        double divisor = cellCount * 4.0;

        if (divisor > 0.0)
        {
            m_characteristicCellSizeI = cvf::Math::sqrt(iSize / divisor);
            m_characteristicCellSizeJ = cvf::Math::sqrt(jSize / divisor);
            m_characteristicCellSizeK = cvf::Math::sqrt(kSize / divisor);
        }
    }

    *iSize = m_characteristicCellSizeI;
    *jSize = m_characteristicCellSizeJ;
    *kSize = m_characteristicCellSizeK;
}