SM_NetworkGridBuilder.h

#ifndef SM_NetworkGridBuidler_H
#define SM_NetworkGridBuilder_H
 
//super class header
#include "SM_NetworkBuilder.h"
 
//network header
#include "SM_Network.h"
 
//crystal structure header
#include "SM_CrystalStructure.h"
 
//utility functions header
#include "functions_array.h"
 
class SM_NetworkGridBuilder : public SM_NetworkBuilder {
    
 
private :
 
    //  class name
    typedef  SM_NetworkGridBuilder SelfClass;
    typedef  SM_NetworkBuilder SuperClass;
 
    
    //attributes
   //indices move direction per hyperlan in {0,1}
    static std::array<tUCInt,SM_Constants::HDIM> HYPERPLAN_MOVES_NUMBER;
    //indices move diercetion in space in {0,1}
    static std::array<tUCInt,SM_Constants::DIM> SPACE_MOVES_NUMBER;
   
    //indictaes if static arrays are initialized
    static tBoolean INIT_STATIC_ARRAYS;
 
public:
    static tUCInt N_HYPERPLAN_MOVES;
    static tUCInt N_SPACE_MOVES;
 
    
    
protected:
 
    // CONSTRUCTORS 
    SM_NetworkGridBuilder(void) {
 
          
        //initialize only once staic arrays
        if (!INIT_STATIC_ARRAYS) {
            N_HYPERPLAN_MOVES=1;
            N_SPACE_MOVES=1;
            for(auto& Mk:SPACE_MOVES_NUMBER) {
                Mk=2;
                N_SPACE_MOVES*=Mk;
            }
            for(auto& Mk:HYPERPLAN_MOVES_NUMBER) {
                Mk=2;
                N_HYPERPLAN_MOVES*=Mk;
            }
            INIT_STATIC_ARRAYS=true;
        }
        
    }
    
    // DESTRUCTORS 
    virtual ~SM_NetworkGridBuilder(void) {
    }
    
public : 
 
    //Instance building
    //=================
    
   
 
 
    //MEMORY
    //=====
    
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+getContentsMemorySize();
    }
 
    virtual tMemSize getContentsMemorySize() const {
        tMemSize mem=SuperClass::getContentsMemorySize();
       
        return mem;
    }
 
    //buidler grid methods
    //=================
 
 
    //IO methods
    //==========
 
protected:
   
 
 
 
    //Grid Block methods
    //====================
public:
    static tIndex BuildBlock(const std::array<tInteger,SM_Constants::DIM>& nCs,
                             const tInteger *iBlocksNumber,
                             const tInteger *iBlockIndex,
                             const tReal& margin,
                             const tReal *iX0,
                             const tReal *iHs,
                             tInteger *iI0,
                             tInteger *iI1,
                             tReal *iBlockMinPoint,
                             tReal *iBlockMaxPoint);
    
    inline static tIndex GetCellsNumberInBlock(const std::array<tInteger,SM_Constants::DIM>& nCs,
                                               const tInteger *iBlocksNumber,
                                               const tInteger *iBlockIndex) {
        
        //number of Cells of the block
        tIndex nCells=1;
       
        tInteger I0k,I1k;
        
        //iterator on total number of points per direction 
        for(const auto& Nk:nCs) {//loop on direction k
            //Nk: number of cells in the direction k
            //bounded index of the block
            I0k=(*iBlockIndex);
            I0k*=Nk;
            I0k/=(*iBlocksNumber);
 
            I1k=(*iBlockIndex);
            I1k++;
            I1k*=Nk;
            I1k/=(*iBlocksNumber);
            I1k++;
         
            //max index must not be greater than the number of cells
            I1k=(I1k>Nk)?Nk:I1k ;
 
            //number of cells
            nCells*=I1k-I0k;
           
            //iterator at next coordinate
            iBlockIndex++;
            iBlocksNumber++;
            
        }
        return nCells;
    }
 
    template<tUCInt R>
    inline static tBoolean IsPointInBlock(std::array<tInteger,SM_Constants::DIM>& I,
                                          const tReal *iBlockMinPoint,
                                          const tReal *iBlockMaxPoint,
                                          const tReal* iX0,
                                          const tReal* iHs,
                                          tReal *iP) {
        
        //coodinate of point P=X0+I.Hs
     
        tBoolean isPInBlock=true;
        for(const auto& Ik:I) {//loop on coordinate
            (*iP)=Ik;
            (*iP)+=R*0.5;
            (*iP)*=(*iHs);
            (*iP)+=(*iX0);
            //verify the point is in the block
            isPInBlock=isPInBlock && ((*iP)>=(*iBlockMinPoint)) && ((*iP)<(*iBlockMaxPoint));
            //iterators at next coordinate
            iP++;
            iHs++;
            iX0++;
            iBlockMinPoint++;
            iBlockMaxPoint++;
        }
        return isPInBlock;
                
    }
    static tBoolean GetCenterFacePointInBlock(const tDimension& d,
                                              const std::array<tDimension,SM_Constants::HDIM>& hyperplanBase,
                                              const std::array<tInteger,SM_Constants::DIM>& faceElementIndices,
                                              const std::array<tReal,SM_Constants::DIM>& blockMinPoint,
                                              const std::array<tReal,SM_Constants::DIM>& blockMaxPoint,
                                              std::array<tUCInt,SM_Constants::HDIM>& moveIndices,
                                              const std::array<tReal,SM_Constants::DIM>& X0,
                                              const std::array<tReal,SM_Constants::DIM>& H,
                                              std::array<tReal,SM_Constants::DIM>& P);
    
    //Element coordinates methods
    //============================
    
    template<tBoolean R> 
    inline static void GetPointWithIndices(std::array<tInteger,SM_Constants::DIM>& I,
                                           const tReal* iX0,
                                           const tReal* iHs,
                                           tReal *iP) {
        
        //coodinate of point P=X0+I.Hs
        for(const auto& Ik:I) {//loop on coordinate
            (*iP)=Ik;
            (*iP)+=R*0.5;
            (*iP)*=(*iHs);
            (*iP)+=(*iX0);
            
            //iterators at next coordinate
            iP++;
            iHs++;
            iX0++;
        }
 
      
        
    }
       
    static void GetCenterFacePoint(const tDimension& d,
                                   const std::array<tDimension,SM_Constants::HDIM>& hyperplanBase,
                                   const std::array<tInteger,SM_Constants::DIM>& faceElementIndices,
                                   std::array<tUCInt,SM_Constants::HDIM>& movesIndices,
                                   const std::array<tReal,SM_Constants::DIM>& X0,
                                   const std::array<tReal,SM_Constants::DIM>& H,
                                   std::array<tReal,SM_Constants::DIM>& P);
    
   
 
 
    //Topological grid cell methods
    //================================
    
    static void  GetCellVertices(const std::array<tInteger,SM_Constants::DIM>& cellIndices,
                                 const std::array<tInteger,SM_Constants::DIM>& nPs,
                                 const std::array<tBoolean,SM_Constants::DIM>& isPeriodic,
                                 std::array<tUCInt,SM_Constants::DIM>& moveIndices,//work array
                                 std::array<tInteger,SM_Constants::DIM>& vertexIndices,//work array
                                 std::map<tIndex,tIndex>& vertices);
    static void  GetFaceVertices(const tDimension& d,
                                 const std::array<tDimension,SM_Constants::HDIM>& hyperplanBase,
                                 const std::array<tInteger,SM_Constants::DIM> faceElementIndices,
                                 const std::array<tInteger,SM_Constants::DIM>& nPs,
                                 const std::array<tBoolean,SM_Constants::DIM>& isPeriodic,
                                 std::array<tUCInt,SM_Constants::HDIM>& moveIndices,//work array
                                 std::array<tInteger,SM_Constants::DIM>& vertexIndices,//work array
                                 tIndex& vertexIndex,//work index
                                 std::map<tIndex,tIndex>& vertices);
    
    static tBoolean  IsFaceInDomain(const tDimension& d,
                                    const std::array<tDimension,SM_Constants::HDIM>& hyperplanBase,
                                    const tInteger* iFaceElementIndices,//in base (e_u,e_v,e_d)
                                    const std::array<tInteger,SM_Constants::DIM>& nCs,
                                    const std::array<tBoolean,SM_Constants::DIM>& isPeriodic,
                                    const tBoolean& incMask,const tMask* vMask,
                                    std::array<tInteger,SM_Constants::DIM>& connectedCellIndices);
    
    //Topological connection  methods on grid structure
    //=================================================
    
    static void GetConnectedDomainCellsToVertex(const std::array<tInteger,SM_Constants::DIM>& vertexIndices,
                                                const std::array<tInteger,SM_Constants::DIM>& Ns,
                                                const std::array<tBoolean,SM_Constants::DIM>& isPeriodic,
                                                const tBoolean& incMask,const tMask* vMask,
                                                std::array<tUCInt,SM_Constants::DIM>& moveIndices,//work array
                                                std::array<tInteger,SM_Constants::DIM>& connectedCellIndices,//work array
                                                std::map<tIndex,tIndex>& connectedCells);
     
    static void GetConnectedDomainCellsToFace(const tDimension& d,
                                              const std::array<tDimension,SM_Constants::HDIM>& hyperplanBase,
                                              const tInteger* iFaceElementIndices,//in base (e_u,e_v,e_d)
                                              const std::array<tInteger,SM_Constants::DIM>& nCs,
                                              const std::array<tBoolean,SM_Constants::DIM>& isPeriodic,
                                              const tBoolean& incMask,const tMask* vMask,
                                              std::array<tInteger,SM_Constants::DIM>& connectedCellIndices,//work array
                                              std::map<tIndex,tIndex>& connectedCells);
      
    static void GetConnectedDomainFacesToVertex(const std::array<tInteger,SM_Constants::DIM>& vertexIndices,
                                                const tDimension& d,
                                                const std::array<tDimension,SM_Constants::HDIM>& hyperplanBase,
                                                const std::array<tInteger,SM_Constants::DIM>& facesElementsNumber,
                                                const std::array<tInteger,SM_Constants::DIM>& nCs,
                                                const std::array<tBoolean,SM_Constants::DIM>& isPeriodic,
                                                const tBoolean& incMask,const tMask* vMask,
                                                std::array<tUCInt,SM_Constants::HDIM>& moveIndices,
                                                std::array<tInteger,SM_Constants::DIM>& cellIndices,//work array
                                                tIndex& index,//work index
                                                std::array<tInteger,SM_Constants::DIM>& faceElementIndices,//work array
                                                std::map<tIndex,tIndex>& connectedFaces);
    static void GetConnectedDomainFacesToFace(const tDimension& p,
                                              const std::array<tDimension,SM_Constants::HDIM>& pHyperplanBase,
                                              const tInteger* iFaceElementIndices,//in base (e_u,e_v,e_d)
                                              const tDimension& q,
                                              const std::array<tDimension,SM_Constants::HDIM>& qHyperplanBase,
                                              const std::array<tInteger,SM_Constants::DIM>& qFacesElementsNumber,
                                              const std::array<tInteger,SM_Constants::DIM>& nCs,
                                              const std::array<tBoolean,SM_Constants::DIM>& isPeriodic,
                                              const tBoolean& incMask,const tMask* vMask,
                                              std::array<tInteger,SM_Constants::DIM>& connectedCellIndices,//work array
                                              tIndex& cellIndex,//work index
                                              std::array<tInteger,SM_Constants::DIM>& connectedFaceIndices,//work array
                                              std::map<tIndex,tIndex>& connectedFaces);
    
   
   
    
    //weights methods
    //================
 
    static void BuildVerticesWeight(const std::array<tInteger,SM_Constants::DIM>& nCs,
                                    const std::array<tInteger,SM_Constants::DIM>& nPs,
                                    const std::array<tBoolean,SM_Constants::DIM>& isPeriodic,
                                    const std::valarray<tMask>& mask,
                                    tReal *iVerticesWeight,
                                    tUCInt *iConnectedCellsNumber,
                                    tIndex *iConnectedCells);
    
    static void BuildFacesWeight(const tDimension& d,
                                 const std::array<tDimension,SM_Constants::HDIM>& hyperplanBase,
                                 const std::array<tInteger,SM_Constants::DIM>& nCs,
                                 const std::array<tInteger,SM_Constants::DIM>& nPs,
                                 const std::array<tBoolean,SM_Constants::DIM>& isPeriodic,
                                 const std::valarray<tMask>& mask,
                                 tReal *iFacesWeight,
                                 tUCInt *iConnectedCellsNumber,
                                 tIndex *iConnectedCells);
 
    static void BuildCellsWeight(const std::array<tInteger,SM_Constants::DIM>& nCs,
                                 const std::valarray<tMask>& mask,
                                 tReal *iCellsWeight,
                                 tUCInt *iConnectedCellsNumber,
                                 tIndex *iConnectedCells);
    
    static void BuildCellsParticlesNumber(const std::array<tInteger,SM_Constants::DIM> Ns,
                                          const std::valarray<tReal>& elementsWeight,
                                          const std::valarray<tUCInt>& elementsConnectedCellsNumber,
                                          const std::valarray<tIndex>& elementsConnectedCells,
                                          std::valarray<tReal>& cellsParticlesNumber);
    static void BuildElementsVolume(const std::valarray<tReal>& elementsWeight,
                                    const std::valarray<tUCInt>& elementsConnectedCellsNumber,
                                    const std::valarray<tIndex>& elementsConnectedCells,
                                    const std::valarray<tReal>& cellsParticlesNumber,
                                    std::valarray<tReal>& elementsVolume);
 
public:
   
};
 
#endif