AbstractGridRepresentation.h

/*-----------------------------------------------------------------------
Copyright F2I-CONSULTING, (2014-2016) 

philippe.verney@f2i-consulting.com

This software is a computer program whose purpose is to access to data formatted using Energistics standards.

This software is governed by the CeCILL-B license under French law and
abiding by the rules of distribution of free software.  You can  use, 
modify and/ or redistribute the software under the terms of the CeCILL-B
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info". 

As a counterpart to the access to the source code and  rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty  and the software's author,  the holder of the
economic rights,  and the successive licensors  have only  limited
liability. 

In this respect, the user's attention is drawn to the risks associated
with loading,  using,  modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean  that it is complicated to manipulate,  and  that  also
therefore means  that it is reserved for developers  and  experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or 
data to be ensured and,  more generally, to use and operate it in the 
same conditions as regards security. 

The fact that you are presently reading this means that you have had
knowledge of the CeCILL-B license and that you accept its terms.
-----------------------------------------------------------------------*/
#pragma once

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

namespace resqml2_0_1
{
    class AbstractStratigraphicOrganizationInterpretation;
    class UnstructuredGridRepresentation;
}

namespace resqml2
{
    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(common::EpcDocument * epcDoc, gsoap_resqml2_0_1::eml__DataObjectReference* partialObject, bool withTruncatedPillars) :AbstractRepresentation(epcDoc, partialObject), withTruncatedPillars(withTruncatedPillars)  {}
        
        AbstractGridRepresentation(resqml2::AbstractFeatureInterpretation* interp, resqml2::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::GridConnectionSetRepresentation*> getGridConnectionSetRepresentationSet() const {return gridConnectionSetRepresentationSet;}

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

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


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

        AbstractGridRepresentation* getParentGrid() const;

        std::string getParentGridUuid() const;

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

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

        void setParentWindow(ULONG64 * cellIndices, const ULONG64 & cellIndexCount, resqml2_0_1::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::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::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::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::eml__VolumeUom & volumeUom = gsoap_resqml2_0_1::eml__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::AbstractStratigraphicOrganizationInterpretation* stratiOrgInterp);

        resqml2_0_1::AbstractStratigraphicOrganizationInterpretation* getStratigraphicOrganizationInterpretation() const;

        virtual std::string getStratigraphicOrganizationInterpretationUuid() 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::EpcDocument* epcDoc);

        bool withTruncatedPillars;

        std::vector<AbstractGridRepresentation*> childGridSet;

        std::vector<resqml2::GridConnectionSetRepresentation*> gridConnectionSetRepresentationSet;
        std::vector<resqml2_0_1::BlockedWellboreRepresentation*> blockedWellboreRepresentationSet;

        friend void GridConnectionSetRepresentation::pushBackSupportingGridRepresentation(AbstractGridRepresentation * supportingGridRep);
        friend void resqml2_0_1::BlockedWellboreRepresentation::pushBackSupportingGridRepresentation(resqml2::AbstractGridRepresentation * supportingGridRep);

    };
}