AbstractGridRepresentation.h

/*-----------------------------------------------------------------------
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements.  See the NOTICE file
distributed with this work for additional information
regarding copyright ownership.  The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"; you may not use this file except in compliance
with the License.  You may obtain a copy of the License at

  http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied.  See the License for the
specific language governing permissions and limitations
under the License.
-----------------------------------------------------------------------*/
#pragma once

#include "resqml2/GridConnectionSetRepresentation.h"
#include "resqml2_0_1/BlockedWellboreRepresentation.h"

namespace RESQML2_0_1_NS
{
    class AbstractStratigraphicOrganizationInterpretation;
    class UnstructuredGridRepresentation;
}

namespace RESQML2_NS
{
    class DLL_IMPORT_OR_EXPORT AbstractGridRepresentation : public AbstractRepresentation
    {
    private:

        gsoap_resqml2_0_1::resqml2__Regrid* createRegrid(const unsigned int & indexRegridStart, unsigned int * childCellCountPerInterval, unsigned int * parentCellCountPerInterval,  const unsigned int & intervalCount, double * childCellWeights,
            const std::string & dimension, bool forceConstantCellCountPerInterval = false);

        /*
        * @param    dimension                   It must be either 'i', 'j' ou 'k' (upper or lower case) for an ijk parent grid. 'k' for a strict column layer parent grid.
        * @param    childVsParentCellCount      If true return the child cell count per interval. If false return the parent cell count per interval.
        */
        gsoap_resqml2_0_1::resqml2__AbstractIntegerArray* getCellCountPerInterval2_0_1(const char & dimension, const bool & childVsParentCellCount) const;

        gsoap_resqml2_0_1::resqml2__AbstractParentWindow* getParentWindow2_0_1() const;

    protected:

        AbstractGridRepresentation(gsoap_resqml2_0_1::eml20__DataObjectReference* partialObject, bool withTruncatedPillars) :AbstractRepresentation(partialObject), withTruncatedPillars(withTruncatedPillars)  {}
        
        AbstractGridRepresentation(RESQML2_NS::AbstractFeatureInterpretation* interp, RESQML2_NS::AbstractLocal3dCrs * crs, bool withTruncatedPillars) : AbstractRepresentation(interp, crs), withTruncatedPillars(withTruncatedPillars){}

        AbstractGridRepresentation(gsoap_resqml2_0_1::resqml2__AbstractGridRepresentation* fromGsoap, bool withTruncatedPillars) : AbstractRepresentation(fromGsoap), withTruncatedPillars(withTruncatedPillars) {}

    public:

        virtual ~AbstractGridRepresentation() {}

        virtual ULONG64 getCellCount() const = 0;

        //************************************************************
        //****************** GRID CONNECTION SET *********************
        //************************************************************

        std::vector<RESQML2_NS::GridConnectionSetRepresentation*> getGridConnectionSetRepresentationSet() const {return gridConnectionSetRepresentationSet;}

        unsigned int getGridConnectionSetRepresentationCount() const {return static_cast<unsigned int>(gridConnectionSetRepresentationSet.size());}

        RESQML2_NS::GridConnectionSetRepresentation* getGridConnectionSetRepresentation(const unsigned int & index) const;


        //************************************************************
        //******************** GRID PARENTAGE ************************
        //************************************************************

        AbstractGridRepresentation* getParentGrid() const;

        gsoap_resqml2_0_1::eml20__DataObjectReference* getParentGridDor() const;

        std::string getParentGridUuid() const;

        unsigned int getChildGridCount() const {return static_cast<unsigned int>(childGridSet.size());}

        AbstractGridRepresentation* getChildGrid(const unsigned int & index) const {return childGridSet[index];}

        void setParentWindow(ULONG64 * cellIndices, const ULONG64 & cellIndexCount, RESQML2_0_1_NS::UnstructuredGridRepresentation* parentGrid);

        void setParentWindow(unsigned int * columnIndices, const unsigned int & columnIndexCount,
            const unsigned int & kLayerIndexRegridStart,
            unsigned int * childCellCountPerInterval, unsigned int * parentCellCountPerInterval,  const unsigned int & intervalCount,
            class AbstractColumnLayerGridRepresentation* parentGrid, double * childCellWeights = nullptr);

        void setParentWindow(
            const unsigned int & iCellIndexRegridStart, unsigned int * childCellCountPerIInterval, unsigned int * parentCellCountPerIInterval,  const unsigned int & iIntervalCount,
            const unsigned int & jCellIndexRegridStart, unsigned int * childCellCountPerJInterval, unsigned int * parentCellCountPerJInterval,  const unsigned int & jIntervalCount,
            const unsigned int & kCellIndexRegridStart, unsigned int * childCellCountPerKInterval, unsigned int * parentCellCountPerKInterval,  const unsigned int & kIntervalCount,
            RESQML2_0_1_NS::AbstractIjkGridRepresentation* parentGrid, double * iChildCellWeights = nullptr, double * jChildCellWeights = nullptr, double * kChildCellWeights = nullptr);

        void setParentWindow(
            const unsigned int & iCellIndexRegridStart, unsigned int constantChildCellCountPerIInterval, unsigned int constantParentCellCountPerIInterval, const unsigned int & iIntervalCount,
            const unsigned int & jCellIndexRegridStart, unsigned int constantChildCellCountPerJInterval, unsigned int constantParentCellCountPerJInterval, const unsigned int & jIntervalCount,
            const unsigned int & kCellIndexRegridStart, unsigned int constantChildCellCountPerKInterval, unsigned int constantParentCellCountPerKInterval, const unsigned int & kIntervalCount,
            RESQML2_0_1_NS::AbstractIjkGridRepresentation* parentGrid, double * iChildCellWeights = nullptr, double * jChildCellWeights = nullptr, double * kChildCellWeights = nullptr);

        void setParentWindow(
            const unsigned int & iCellIndexRegridStart, unsigned int iChildCellCount, unsigned int iParentCellCount,
            const unsigned int & jCellIndexRegridStart, unsigned int jChildCellCount, unsigned int jParentCellCount,
            const unsigned int & kCellIndexRegridStart, unsigned int kChildCellCount, unsigned int kParentCellCount,
            RESQML2_0_1_NS::AbstractIjkGridRepresentation* parentGrid, double * iChildCellWeights = nullptr, double * jChildCellWeights = nullptr, double * kChildCellWeights = nullptr);

        void setForcedNonRegridedParentCell(ULONG64 * cellIndices, const ULONG64 & cellIndexCount);

        void setCellOverlap(const ULONG64 & parentChildCellPairCount, ULONG64 * parentChildCellPair,
            const gsoap_resqml2_0_1::eml20__VolumeUom & volumeUom = gsoap_resqml2_0_1::eml20__VolumeUom__m3, double * overlapVolumes = nullptr);

        LONG64 getParentCellIndexCount() const;

        void getParentCellIndices(ULONG64 * parentCellIndices) const;

        LONG64 getParentColumnIndexCount() const;

        void getParentColumnIndices(ULONG64 * parentColumnIndices) const;

        ULONG64 getRegridStartIndexOnParentGrid(const char & dimension) const;

        ULONG64 getRegridIntervalCount(const char & dimension) const;

        bool isRegridCellCountPerIntervalConstant(const char & dimension, const bool & childVsParentCellCount) const;

        /*
        * Get the constant cell count per interval
        * Only run this method for an ijk parent grid or a strict column layer parent grid.
        * @param    dimension                   It must be either 'i', 'j' ou 'k' (upper or lower case) for an ijk parent grid. 'k' for a strict column layer parent grid.
        * @param    childVsParentCellCount      If true return the child cell count per interval. If false return the parent cell count per interval.
        */
        ULONG64 getRegridConstantCellCountPerInterval(const char & dimension, const bool & childVsParentCellCount) const;

        void getRegridCellCountPerInterval(const char & dimension, ULONG64 * childCellCountPerInterval, const bool & childVsParentCellCount) const;

        bool hasRegridChildCellWeights(const char & dimension) const;

        void getRegridChildCellWeights(const char & dimension, ULONG64 * childCellWeights) const;

        bool hasForcedNonRegridedParentCell() const;

        //************************************************************
        //**************** LINK WITH STRATIGRAPHY ********************
        //************************************************************

        void setCellAssociationWithStratigraphicOrganizationInterpretation(ULONG64 * stratiUnitIndices, const ULONG64 & nullValue, RESQML2_0_1_NS::AbstractStratigraphicOrganizationInterpretation* stratiOrgInterp);

        RESQML2_0_1_NS::AbstractStratigraphicOrganizationInterpretation* getStratigraphicOrganizationInterpretation() const;

        virtual gsoap_resqml2_0_1::eml20__DataObjectReference* getStratigraphicOrganizationInterpretationDor() const;

        std::string getStratigraphicOrganizationInterpretationUuid() const;

        std::string getStratigraphicOrganizationInterpretationTitle() const;
        
        bool hasCellStratigraphicUnitIndices() const;

        ULONG64 getCellStratigraphicUnitIndices(ULONG64 * stratiUnitIndices);

        //************************************************************
        //********************** TRUNCATION **************************
        //************************************************************

        bool isTruncated() const;

        ULONG64 getTruncatedFaceCount() const;

        void getNodeIndicesOfTruncatedFaces(ULONG64 * nodeIndices) const;

        void getCumulativeNodeCountPerTruncatedFace(ULONG64 * nodeCountPerFace) const;

        void getNodeCountPerTruncatedFace(ULONG64 * nodeCountPerFace) const;

        ULONG64 getTruncatedCellCount() const;

        void getTruncatedCellIndices(ULONG64* cellIndices) const;

        void getTruncatedFaceIndicesOfTruncatedCells(ULONG64 * faceIndices) const;

        void getCumulativeTruncatedFaceCountPerTruncatedCell(ULONG64 * cumulativeFaceCountPerCell) const;

        void getTruncatedFaceCountPerTruncatedCell(ULONG64 * faceCountPerCell) const;

        void getNonTruncatedFaceIndicesOfTruncatedCells(ULONG64 * faceIndices) const;

        void getCumulativeNonTruncatedFaceCountPerTruncatedCell(ULONG64 * cumulativeFaceCountPerCell) const;

        void getNonTruncatedFaceCountPerTruncatedCell(ULONG64 * faceCountPerCell) const;

        void getTruncatedFaceIsRightHanded(unsigned char* cellFaceIsRightHanded) const;

        static const char* XML_TAG;

    protected:

        virtual std::vector<epc::Relationship> getAllEpcRelationships() const;
        void importRelationshipSetFromEpc(COMMON_NS::EpcDocument* epcDoc);

        bool withTruncatedPillars;

        std::vector<AbstractGridRepresentation*> childGridSet;

        std::vector<RESQML2_NS::GridConnectionSetRepresentation*> gridConnectionSetRepresentationSet;
        std::vector<RESQML2_0_1_NS::BlockedWellboreRepresentation*> blockedWellboreRepresentationSet;

        friend void GridConnectionSetRepresentation::pushBackSupportingGridRepresentation(AbstractGridRepresentation * supportingGridRep);
        friend void RESQML2_0_1_NS::BlockedWellboreRepresentation::pushBackSupportingGridRepresentation(RESQML2_NS::AbstractGridRepresentation * supportingGridRep);

    };
}