AbstractIjkGridRepresentation.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/AbstractColumnLayerGridRepresentation.h"

#include <stdexcept>
#include <map>

namespace RESQML2_0_1_NS
{
    class DLL_IMPORT_OR_EXPORT AbstractIjkGridRepresentation : public RESQML2_NS::AbstractColumnLayerGridRepresentation
    {
    private :

        void init(soap* soapContext, RESQML2_NS::AbstractLocal3dCrs * crs,
                const std::string & guid, const std::string & title,
                const unsigned int & iCount, const unsigned int & jCount, const unsigned int & kCount,
                bool withTruncatedPillars);

        class BlockInformation
        {
        public:

            unsigned int iInterfaceStart;
            unsigned int iInterfaceEnd;
            unsigned int jInterfaceStart;
            unsigned int jInterfaceEnd;
            unsigned int kInterfaceStart;
            unsigned int kInterfaceEnd;

            std::map<unsigned int, unsigned int> globalToLocalSplitCoordinateLinesIndex;
            
            BlockInformation() {}

            ~BlockInformation() {}
        };

    protected :

        AbstractIjkGridRepresentation(gsoap_resqml2_0_1::_resqml2__IjkGridRepresentation* fromGsoap) : AbstractColumnLayerGridRepresentation(fromGsoap, false), splitInformation(nullptr), blockInformation(nullptr) {}
        AbstractIjkGridRepresentation(gsoap_resqml2_0_1::_resqml2__TruncatedIjkGridRepresentation* fromGsoap) : AbstractColumnLayerGridRepresentation(fromGsoap, true), splitInformation(nullptr), blockInformation(nullptr) {}

        gsoap_resqml2_0_1::_resqml2__IjkGridRepresentation* getSpecializedGsoapProxy() const;
        gsoap_resqml2_0_1::_resqml2__TruncatedIjkGridRepresentation* getSpecializedTruncatedGsoapProxy() const;

        gsoap_resqml2_0_1::resqml2__PointGeometry* getPointGeometry2_0_1(const unsigned int & patchIndex) const;

        std::vector< std::pair< unsigned int, std::vector<unsigned int> > >* splitInformation;

        BlockInformation* blockInformation;

    public:

        enum geometryKind { UNKNOWN = 0, EXPLICIT = 1, PARAMETRIC = 2, LATTICE = 3, NO_GEOMETRY = 4}; // UNKNOWN exists in case of partial transfer

        AbstractIjkGridRepresentation(soap* soapContext, RESQML2_NS::AbstractLocal3dCrs * crs,
            const std::string & guid, const std::string & title,
            const unsigned int & iCount, const unsigned int & jCount, const unsigned int & kCount,
            bool withTruncatedPillars = false);

        AbstractIjkGridRepresentation(RESQML2_NS::AbstractFeatureInterpretation* interp, RESQML2_NS::AbstractLocal3dCrs * crs,
            const std::string & guid, const std::string & title,
            const unsigned int & iCount, const unsigned int & jCount, const unsigned int & kCount,
            bool withTruncatedPillars = false);

        AbstractIjkGridRepresentation(gsoap_resqml2_0_1::eml20__DataObjectReference* partialObject,
            bool withTruncatedPillars = false) :
            AbstractColumnLayerGridRepresentation(nullptr, partialObject, withTruncatedPillars), splitInformation(nullptr), blockInformation(nullptr)
        {
        }

        virtual ~AbstractIjkGridRepresentation() 
        {
            if (blockInformation != nullptr)
                delete blockInformation;
        }

        unsigned int getICellCount() const;

        void setICellCount(const unsigned int & iCount);

        unsigned int getJCellCount() const;

        void setJCellCount(const unsigned int & jCount);

        ULONG64 getCellCount() const {return getICellCount() * getJCellCount() * getKCellCount();}

        unsigned int getColumnCount() const {return getICellCount() * getJCellCount();}

        unsigned int getPillarCount() const {return (getICellCount()+1) * (getJCellCount()+1);}

        unsigned int getFaceCount() const;

        unsigned int getIPillarFromGlobalIndex(const unsigned int & globalIndex) const;

        unsigned int getJPillarFromGlobalIndex(const unsigned int & globalIndex) const;

        unsigned int getGlobalIndexPillarFromIjIndex(const unsigned int & iPillar, const unsigned int & jPillar) const;

        unsigned int getIColumnFromGlobalIndex(const unsigned int & globalIndex) const;

        unsigned int getJColumnFromGlobalIndex(const unsigned int & globalIndex) const;

        unsigned int getGlobalIndexColumnFromIjIndex(const unsigned int & iColumn, const unsigned int & jColumn) const;

        unsigned int getGlobalIndexCellFromIjkIndex(const unsigned int & iCell, const unsigned int & jCell, const unsigned int & kCell) const;

        bool isRightHanded() const;

        void getPillarsOfSplitCoordinateLines(unsigned int * pillarIndices, bool reverseIAxis = false, bool reverseJAxis = false) const;

        void getColumnsOfSplitCoordinateLines(unsigned int * columnIndices, bool reverseIAxis = false, bool reverseJAxis = false) const;
        void getColumnCountOfSplitCoordinateLines(unsigned int * columnIndexCountPerSplitCoordinateLine) const;

        unsigned long getSplitCoordinateLineCount() const;

        unsigned long getBlockSplitCoordinateLineCount() const;

        ULONG64 getSplitNodeCount() const;
        
        void getPillarGeometryIsDefined(bool * pillarGeometryIsDefined, bool reverseIAxis = false, bool reverseJAxis = false) const;

        bool hasEnabledCellInformation() const;

        void getEnabledCells(bool * enabledCells, bool reverseIAxis = false, bool reverseJAxis= false, bool reverseKAxis= false) const;

        void setEnabledCells(unsigned char* enabledCells);

        void loadSplitInformation();

        void loadBlockInformation(const unsigned int & iInterfaceStart, const unsigned int & iInterfaceEnd, const unsigned int & jInterfaceStart, const unsigned int & jInterfaceEnd, const unsigned int & kInterfaceStart, const unsigned int & kInterfaceEnd);

        void unloadSplitInformation();

        bool isColumnEdgeSplitted(const unsigned int & iColumn, const unsigned int & jColumn, const unsigned int & edge) const;

        ULONG64 getXyzPointIndexFromCellCorner(const unsigned int & iCell, const unsigned int & jCell, const unsigned int & kCell, const unsigned int & corner) const;

        void getXyzPointOfBlockFromCellCorner(const unsigned int & iCell, const unsigned int & jCell, const unsigned int & kCell, const unsigned int & corner,
            const double* xyzPoints, double & x, double & y, double & z) const;

        ULONG64 getXyzPointCountOfKInterfaceOfPatch(const unsigned int & patchIndex) const;

        ULONG64 getXyzPointCountOfBlock() const;

        void getXyzPointsOfKInterfaceOfPatch(const unsigned int & kInterface, const unsigned int & patchIndex, double * xyzPoints);

        virtual void getXyzPointsOfKInterfaceSequenceOfPatch(const unsigned int & kInterfaceStart, const unsigned int & kInterfaceEnd, const unsigned int & patchIndex, double * xyzPoints) { throw std::logic_error("Partial object"); }

        virtual void getXyzPointsOfBlockOfPatch(const unsigned int & patchIndex, double * xyzPoints) { throw std::logic_error("Partial object"); };

        gsoap_resqml2_0_1::resqml2__KDirection getKDirection() const;

        virtual geometryKind getGeometryKind() const { return UNKNOWN; }
        virtual std::string getHdfProxyUuid() const { throw std::logic_error("Partial object"); }
        virtual ULONG64 getXyzPointCountOfPatch(const unsigned int & patchIndex) const { throw std::logic_error("Partial object"); }
        virtual void getXyzPointsOfPatch(const unsigned int & patchIndex, double * xyzPoints) const { throw std::logic_error("Partial object"); }

        static const char* XML_TAG;
        static const char* XML_TAG_TRUNCATED;
        virtual std::string getXmlTag() const;

        unsigned int getPatchCount() const {return 1;}
    };
}