VTK.hpp

/*---------------------------------------------------------------------------*\
 *
 *  bitpit
 *
 *  Copyright (C) 2015-2021 OPTIMAD engineering Srl
 *
 *  -------------------------------------------------------------------------
 *  License
 *  This file is part of bitpit.
 *
 *  bitpit is free software: you can redistribute it and/or modify it
 *  under the terms of the GNU Lesser General Public License v3 (LGPL)
 *  as published by the Free Software Foundation.
 *
 *  bitpit 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 Lesser General Public
 *  License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public License
 *  along with bitpit. If not, see <http://www.gnu.org/licenses/>.
 *
\*---------------------------------------------------------------------------*/
 
 
#ifndef __BITPIT_VTK_HPP__
#define __BITPIT_VTK_HPP__
 
#include <cstdint>
#include <typeinfo>
#include <type_traits>
#include <vector>
#include <array>
#include <typeindex>
#include <unordered_map>
 
#include "bitpit_common.hpp"
#include "GenericIO.hpp"
 
namespace bitpit{
 
class VTK;
class VTKField;

enum class VTKWriteMode {
    DEFAULT = 0,
    NO_INCREMENT =1,
    NO_SERIES =2
};

enum class VTKFieldType {
    UNDEFINED = -1,
    SCALAR    = 0,
    VECTOR    = 1,
    TENSOR    = 2,
};

enum class VTKDataType {
    UNDEFINED,
    Int8     ,
    Int16    ,
    Int32    ,
    Int64    ,
    UInt8    ,
    UInt16   ,
    UInt32   ,
    UInt64   ,
    Float32  ,
    Float64      
};

enum class VTKFormat {
    UNDEFINED,
    ASCII,
    APPENDED
};

enum class VTKLocation {
    UNDEFINED,
    CELL,
    POINT
};

enum class VTKElementType {
    UNDEFINED            = -1,
    VERTEX               = 1,
    LINE                 = 3,
    TRIANGLE             = 5,
    POLYGON              = 7,
    PIXEL                = 8,
    QUAD                 = 9,
    TETRA                = 10,
    VOXEL                = 11,
    HEXAHEDRON           = 12,
    WEDGE                = 13,
    PYRAMID              = 14,
    QUADRATIC_EDGE       = 21,
    QUADRATIC_TRIANGLE   = 22,
    QUADRATIC_QUAD       = 23,
    QUADRATIC_TETRA      = 24,
    QUADRATIC_HEXAHEDRON = 25,
    POLYHEDRON           = 42
};

enum class VTKUnstructuredField {
    POINTS       = 0,
    OFFSETS      = 1,
    TYPES        = 2,
    CONNECTIVITY = 3,
    FACE_STREAMS = 4,
    FACE_OFFSETS = 5
};

enum class VTKRectilinearField {
    X_COORDS    = 0,
    Y_COORDS    = 1,
    Z_COORDS    = 2 
};
 
class VTKTypes{
 
    private:
        static std::unordered_map<std::type_index, VTKDataType> m_types;  
 
    public:
        static uint8_t          sizeOfType( VTKDataType type );
 
        template<typename T>
        static VTKDataType      registerType();
 
        template<typename T>
        static VTKDataType      registerType(VTKDataType VTKType);
 
        static VTKDataType      whichType( const std::type_info & ) ;
 
        template<typename T, int nesting=0, typename std::enable_if<std::is_pod<T>::value && !utils::is_iterable<T>::value>::type* = nullptr>
        static VTKDataType      whichType();
 
        template<typename T, int nesting=0, typename std::enable_if<utils::is_iterable<T>::value>::type* = nullptr>
        static VTKDataType      whichType();
 
};
 
class VTKBaseContainer{
    private:
 
    public:
        VTKBaseContainer( ) ;
        virtual ~VTKBaseContainer( ) = default;
 
        virtual VTKBaseContainer *  clone() const = 0 ;
 
        virtual void                flushData( std::fstream &, VTKFormat) =0 ;
        virtual void                absorbData( std::fstream &, VTKFormat, uint64_t, uint8_t) =0 ;
};
 
template<class T>
class VTKVectorContainer : public VTKBaseContainer{
    private:
        std::vector<T>*         m_ptr ;                     
 
    public:
        VTKVectorContainer( std::vector<T> &) ;
 
        VTKVectorContainer*     clone() const override ;
 
        void                    flushData( std::fstream &, VTKFormat) override ;
        void                    absorbData( std::fstream &, VTKFormat, uint64_t, uint8_t) override ;
        void                    resize( std::true_type, uint64_t , uint8_t) ;
        void                    resize( std::false_type, uint64_t , uint8_t) ;
};
 
class VTKBaseStreamer{ 
 
    private:
 
    public:
        virtual ~VTKBaseStreamer() = default;
 
        virtual void            flushData( std::fstream &, const std::string &, VTKFormat)  ;
        virtual void            absorbData( std::fstream &, const std::string &, VTKFormat, uint64_t, uint8_t, VTKDataType)  ;
 
        template<typename T>
        void                    flushValue(std::fstream &, VTKFormat, const T &value) const;
        template<typename T>
        void                    flushValue(std::fstream &, VTKFormat, const T *values, int nValues) const;
 
};
 
class VTKNativeStreamer : public VTKBaseStreamer {
 
    private:
        std::unordered_map<std::string,std::unique_ptr<VTKBaseContainer> >         m_field ; 
 
    public:
        VTKNativeStreamer();
        VTKNativeStreamer( const VTKNativeStreamer & );
        VTKNativeStreamer( VTKNativeStreamer && ) = default;
 
        VTKNativeStreamer & operator=(const VTKNativeStreamer &other);
        VTKNativeStreamer & operator=(VTKNativeStreamer &&other) = default;
 
        template<class T>
        void                    addData( const std::string &, std::vector<T> & ) ;
        void                    removeData( const std::string & ) ;
        bool                    hasData( const std::string & ) const ;
        void                    flushData( std::fstream &, const std::string &, VTKFormat) override ;
        void                    absorbData( std::fstream &, const std::string &, VTKFormat, uint64_t, uint8_t, VTKDataType) override ;
};
 
class VTKField{
 
    //members
    protected:
        std::string             m_name;                     
        VTKFieldType            m_fieldType;                
        VTKDataType             m_dataType;                 
        VTKLocation             m_location;                 
        VTKFormat               m_codification ;            
        uint64_t                m_offset;                   
        std::fstream::pos_type  m_position;                 
        VTKBaseStreamer*        m_streamer;                 
        bool                    m_enabled;                  
                                
 
        //methods
    public:
        static unsigned getComponentCount(VTKFieldType fieldType);
 
        virtual ~VTKField() = default;
 
        VTKField();
        VTKField( const std::string & );
 
        const std::string &     getName() const;
        VTKDataType             getDataType() const;
        VTKFieldType            getFieldType() const;
        unsigned                getComponentCount() const;
        VTKLocation             getLocation() const;
        VTKFormat               getCodification() const;
        uint64_t                getOffset() const;
        std::fstream::pos_type  getPosition() const; 
        const VTKBaseStreamer & getStreamer() const;
        bool                    isEnabled() const ;
        bool                    hasAllMetaData() const ;
 
        void                    setName( const std::string & ) ;
        void                    setDataType( VTKDataType ) ;
        void                    setFieldType( VTKFieldType ) ;
        void                    setLocation( VTKLocation ) ;
        void                    setCodification( VTKFormat ) ;
        void                    setOffset( uint64_t ) ;
        void                    setPosition( std::fstream::pos_type ) ;
        void                    setStreamer( VTKBaseStreamer& ) ;
        void                    enable() ;
        void                    disable() ;
 
        void                    read( std::fstream&, uint64_t, uint8_t ) const ;
        void                    write( std::fstream& ) const ;
};
 
class VTK{
 
    protected:
        FileHandler             m_fh ;                      
        uint64_t                m_points ;                  
        uint64_t                m_cells  ;                  
        uint16_t                m_procs  ;                  
        uint16_t                m_rank   ;                  
 
        std::string             m_headerType ;              
 
        std::vector<VTKField>   m_geometry ;                
        VTKFormat               m_geomCodex ;               
 
        std::vector<VTKField>   m_data ;                    
        VTKFormat               m_dataCodex ;               
 
        VTKNativeStreamer       m_nativeStreamer;           
 
    public:
        VTK( );
        VTK( const std::string &, const std::string & );
        virtual ~VTK( ) = default;
 
        void                    setHeaderType( const std::string & );
        const std::string &     getHeaderType(  ) const;
 
        std::string             getName(  ) const;
        std::string             getDirectory(  ) const;
        int                     getCounter(  ) const;
 
        void                    setNames( const std::string & , const std::string & ) ;
        void                    setName( const std::string & ) ;
        void                    setDirectory( const std::string & ) ;
        void                    setCounter( int c_=0 ) ;
        void                    incrementCounter( ) ;
        int                     unsetCounter( ) ;
        void                    setParallel( uint16_t , uint16_t ) ;
 
        void                    setCodex( VTKFormat );
        void                    setGeomCodex( VTKFormat );
        void                    setDataCodex( VTKFormat );
 
        void                    setGeomData( VTKField &&field ) ;
 
        VTKField&               addData( VTKField &&field ) ;
 
        VTKField&               addData( const std::string &, VTKBaseStreamer* = nullptr ) ;
 
        template<class T>
        VTKField&               addData( const std::string &, VTKFieldType, VTKLocation, VTKBaseStreamer* = nullptr ) ;
 
        template<class T>
        VTKField&               addData( const std::string &, std::vector<T> & ) ;
 
        template<class T>
        VTKField&               addData( const std::string &, VTKFieldType, VTKLocation, std::vector<T> & ) ;
 
        void                    removeData( const std::string & ) ;
        void                    enableData( const std::string & ) ;
        void                    disableData( const std::string & ) ;
 
        bool                    hasData( const std::string & ) const ;
 
        std::vector<VTKField>::const_iterator    getDataBegin( ) const ;
        std::vector<VTKField>::const_iterator    getDataEnd( ) const ;
 
        std::vector<VTKField>::const_iterator    getGeomDataBegin( ) const ;
        std::vector<VTKField>::const_iterator    getGeomDataEnd( ) const ;
 
        std::size_t             getDataCount( ) const ;
        std::size_t             getGeomDataCount( ) const ;
 
        const VTKField *        findData( const std::string & name ) const ;
        const VTKField *        findGeomData( const std::string & name ) const ;
 
        void                    read() ;
        virtual void            readMetaInformation() = 0 ; 
        void                    readData() ;
 
        void                    write( VTKWriteMode writeMode, double time )  ;
        void                    write( VTKWriteMode writeMode=VTKWriteMode::DEFAULT )  ;
        void                    write( const std::string &, VTKWriteMode writeMode, double time )  ;
        void                    write( const std::string &, VTKWriteMode writeMode=VTKWriteMode::NO_INCREMENT )  ;
 
        void                    writeCollection( ) const ;
        void                    writeCollection( const std::string &outputName ) const ;
        virtual void            writeCollection( const std::string &outputName, const std::string &collectionName ) const = 0;
 
        void                    writeTimeSeries( double time ) const;
        void                    writeTimeSeries( const std::string &outputName, double time ) const ;
        void                    writeTimeSeries( const std::string &outputName, const std::string &seriesName, double time ) const ;
 
    protected:
        //For Writing
        virtual void            writeMetaInformation() const = 0 ;
        void                    writeData() ;
 
        void                    writeDataHeader( std::fstream &, bool parallel=false ) const ;
        void                    writeDataArray( std::fstream &, const VTKField &) const ;
        void                    writePDataArray( std::fstream &, const VTKField &) const ;
 
        FileHandler             createCollectionHandler( const std::string &collectionName) const ;
 
        //For Reading
        void                    readDataHeader( std::fstream &) ;
        bool                    readDataArray( std::fstream &, VTKField &) const ;
 
        //General Purpose
        std::vector<std::string> getFieldNames( const std::vector<VTKField> &fields ) const;
 
        VTKField *              getData( std::size_t id );
        const VTKField *        getData( std::size_t id ) const ;
        VTKField *              getGeomData( std::size_t id );
        const VTKField *        getGeomData( std::size_t id ) const ;
 
        VTKField *              _findData( const std::string & name);
        VTKField *              _findGeomData( const std::string & name);
 
        int                     _findFieldIndex( const std::string &name, const std::vector<VTKField> &fields ) const;
 
        bool                    isAppendedActive() const;
        bool                    isASCIIActive() const;
 
        void                    calcAppendedOffsets() ;
        virtual uint64_t        calcFieldSize( const VTKField &) const = 0;
        virtual uint64_t        calcFieldEntries( const VTKField &) const = 0;
        virtual uint8_t         calcFieldComponents( const VTKField &) const = 0;
        void                    checkAllFields();
 
        virtual std::string     getExtension() const = 0 ;
        virtual std::string     getCollectionExtension() const;
 
};
 
class VTKUnstructuredGrid : public VTK {
 
    protected:
        class HomogeneousInfoStreamer :public VTKBaseStreamer{
 
            private:
                VTKElementType          m_type ;                    
                uint64_t                m_nCells ;                  
                const VTKField         *m_connectivity ;            
 
                void                    flushData( std::fstream &, const std::string &, VTKFormat) override ;
 
            public:
                void                    setElementType( VTKElementType) ;
                void                    setCellCount( uint64_t) ;
                void                    setConnectivityField( const VTKField *connectivity) ;
        };
 
        uint64_t                m_nConnectivityEntries ;            
        uint64_t                m_nFaceStreamEntries ;              
        VTKElementType          m_elementType ;                     
        HomogeneousInfoStreamer m_homogeneousInfoStreamer;          
 
    public:
    VTKUnstructuredGrid( VTKElementType elementType = VTKElementType::UNDEFINED );
    VTKUnstructuredGrid( const std::string &, const std::string &, VTKElementType elementType = VTKElementType::UNDEFINED ) ;
 
    protected:
        uint64_t                readConnectivityEntries( ) ;
        uint64_t                readFaceStreamEntries( ) ;
 
        void                    setElementType( VTKElementType ) ;
 
        std::string             getExtension() const override;
 
    public:
        using                   VTK::setGeomData;
 
        void                    readMetaInformation() override ;
        void                    writeMetaInformation() const override ;
 
        void                    writeCollection( const std::string &outputName, const std::string &collectionName ) const override ;
 
        void                    setDimensions( uint64_t , uint64_t , uint64_t nconn = 0 , uint64_t nfacestream = 0 ) ;
 
        template<class T>
        void                    setGeomData( VTKUnstructuredField, std::vector<T> & ) ;
        void                    setGeomData( VTKUnstructuredField, VTKBaseStreamer* = nullptr ) ;
 
        template<class T>
        void setGeomData( VTKUnstructuredField, VTKBaseStreamer* = nullptr );
 
        uint64_t                calcConnectivityEntries( ) const ;
        uint64_t                calcFieldSize( const VTKField &) const override ;
        uint64_t                calcFieldEntries( const VTKField &) const override ;
        uint8_t                 calcFieldComponents( const VTKField &) const override ;
 
    private:
        int                     getFieldGeomId( VTKUnstructuredField field ) const ;
 
};
 
class VTKRectilinearGrid : public VTK{
 
    typedef std::array<std::array<int,2>,2> extension2D_t ; 
    typedef std::array<std::array<int,2>,3> extension3D_t ; 
 
    protected:
        int                     m_dimensions ;              
        extension3D_t           m_localIndex ;              
        extension3D_t           m_globalIndex ;             
        std::vector<extension3D_t>      m_procIndex ;       
 
    public:
        VTKRectilinearGrid();
        VTKRectilinearGrid( const std::string & , const std::string &  );
        VTKRectilinearGrid( const std::string & , const std::string & , VTKFormat, int, int, int, int, int, int );
        VTKRectilinearGrid( const std::string & , const std::string & , VTKFormat, int, int, int );
        VTKRectilinearGrid( const std::string & , const std::string & , VTKFormat, int, int, int, int );
        VTKRectilinearGrid( const std::string & , const std::string & , VTKFormat, int, int );
 
    protected:
        std::string             getExtension() const override;
 
    public:
        using                   VTK::setGeomData;
 
        void                    readMetaInformation() override ;
        void                    writeMetaInformation() const override ;
 
        void                    writeCollection( const std::string &outputName, const std::string &collectionName ) const override ;
 
        void                    setDimensions( int, int, int, int, int, int ) ;
        void                    setDimensions( int, int, int ) ;
        void                    setDimensions( int, int, int, int ) ;
        void                    setDimensions( int, int ) ;
 
        void                    setGlobalDimensions( int, int, int ) ;
        void                    setGlobalDimensions( int, int ) ;
 
        template<class T>
        void                    setGeomData( VTKRectilinearField, std::vector<T> & ) ;
        void                    setGeomData( VTKRectilinearField, VTKBaseStreamer* = nullptr ) ;
 
        template<class T>
        void                    setGeomData( VTKRectilinearField, VTKBaseStreamer* = nullptr ) ;
 
        void                    setGlobalIndex( const std::vector<extension3D_t> & ) ;
        void                    setGlobalIndex( const std::vector<extension2D_t> & ) ;
 
        uint64_t                calcFieldSize( const VTKField &) const override ;
        uint64_t                calcFieldEntries( const VTKField &) const override ;
        uint8_t                 calcFieldComponents( const VTKField &) const override ;
};

namespace vtk{
    uint8_t                     getElementNodeCount( VTKElementType ) ;
 
    std::string                 convertDataArrayToString( const VTKField & ) ;
    std::string                 convertPDataArrayToString( const VTKField & ) ;
 
    bool                        convertStringToDataArray( const std::string &, VTKField &) ;
 
    std::string                 convertEnumToString( VTKLocation ) ;
    std::string                 convertEnumToString( VTKFormat ) ;
    std::string                 convertEnumToString( VTKDataType ) ;
 
    bool                        convertStringToEnum( const std::string &, VTKLocation & ) ;
    bool                        convertStringToEnum( const std::string &, VTKFormat & ) ;
    bool                        convertStringToEnum( const std::string &, VTKDataType &) ;
 
    template<class T>
    void                        allocate( std::vector<T> &, int) ;
 
    template<class T>
    void                        allocate( T &, int) ;
}
 
}
 
#include"VTK.tpp"
#include"VTKTypes.tpp"
#include"VTKStreamer.tpp"
#include"VTKUtils.tpp"
 
 
#endif