SM_CrystalStructuresBuilder.h

#ifndef SM_CrystalStructuresBuilder_H
#define SM_CrystalStructuresBuilder_H
 
//super class header
#include "SM_Object.h"
 
 
//crystal structure header
#include "SM_CrystalStructure.h"
 
class SM_CrystalStructuresBuilder : public SM_Object {
    
private:
 
    
    
protected:
    // CONSTRUCTORS 
    SM_CrystalStructuresBuilder(void) {
      
    }
    
    
    // DESTRUCTORS 
    virtual ~SM_CrystalStructuresBuilder(void) {
    }
    
public : 
 
    //Instance building
    //=================
    
   
 
    //MEMORY
    
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+getContentsMemorySize();
    }
 
    virtual tMemSize getContentsMemorySize() const {
        tMemSize mem=SM_Object::getContentsMemorySize();
        return mem;
    }
    
    //SET & GET methods
 
   
public:
    
    inline static void RegisterParticle(const tIndex& indexParticle,
                                        const std::array<tReal,SM_Constants::DIM>& P,
                                        const std::map<tIndex,tIndex>& neighboringParticlesOrderedList,
                                        tIndex& nParticles,
                                        tIndex*& iParticles,
                                        tReal*& iX,
                                        tIndex*& iNeighborsNumberPerParticle,
                                        tIndex&  nNeighboringParticles,
                                        tIndex*& iNeighboringParticlesList) {
        
        //register the index of particle
        nParticles++;//number of particles in block
        (*iParticles)=indexParticle;//grid index of particle + number of cells
        iParticles++;
 
        //register the coordinate
        for(const auto Pk:P) {
            (*iX)=Pk;
            iX++;
        }
 
        // if (incW==1) {
        //     (*iWs)=w;
        //     iWs++;
        // }
      
        //number of neighbors of the point
        (*iNeighborsNumberPerParticle)=neighboringParticlesOrderedList.size();
        //total number of neighboring points
        nNeighboringParticles+=(*iNeighborsNumberPerParticle);
        iNeighborsNumberPerParticle++;
        //set the neighboring particles list of P
        for(const auto&  indexCell:neighboringParticlesOrderedList) {
            (*iNeighboringParticlesList)=indexCell.second;
            iNeighboringParticlesList++;
        }
    }
    
    
     
    virtual void getNetworkSliceMaxSizeOffset(const SM_CrystalStructure& cStructure,
                                              const std::array<tInteger,SM_Constants::DIM>& Ns,
                                              const std::array<tBoolean,SM_Constants::DIM>& periodicity,
                                              std::valarray<tIndex>& sliceParticlesNumberOffset) const=0;
  
   
    virtual void  buildNetworkSliceSet(const tInteger& slicesNumber,
                                       const tInteger& sliceIndex,
                                       const std::array<tReal,SM_Constants::DIM>& X0,
                                       const std::array<tInteger,SM_Constants::DIM>& Ns,
                                       const std::array<tReal,SM_Constants::DIM>& Hs,
                                       const std::array<tBoolean,SM_Constants::DIM>& periodicity,
                                       const std::valarray<tMask>& mask,
                                       tIndex& nParticles,
                                       tIndex *particles,
                                       tReal *X,
                                       tIndex *neighborsNumberPerParticle,
                                       tIndex& nNeighboringParticles,
                                       tIndex *neighboringParticlesList) const=0;
 
   
    
        
    virtual tIndex getNetworkGridMaxSize(const SM_CrystalStructure& cStructure,
                                         const std::array<tInteger,SM_Constants::DIM>& Ns,
                                         const std::array<tBoolean,SM_Constants::DIM>& isPeriodic,
                                         const std::array<tInteger,SM_Constants::DIM>& gridSize,
                                         const std::array<tInteger,SM_Constants::DIM>& gridIndex) const=0;
    
        
    virtual void  buildNetworkGridSet(const std::array<tInteger,SM_Constants::DIM>& gridsNumber,
                                      const std::array<tInteger,SM_Constants::DIM>& gridIndex,
                                      const std::array<tReal,SM_Constants::DIM>& X0,
                                      const std::array<tInteger,SM_Constants::DIM>& Ns,
                                      const std::array<tReal,SM_Constants::DIM>& Hs,
                                      const std::array<tBoolean,SM_Constants::DIM>& periodicity,
                                      const std::valarray<tMask>& mask,
                                      tIndex& nParticles,
                                      tIndex *particles,
                                      tReal *X,
                                      tIndex *neighborsNumberPerParticle,
                                      tIndex& nNeighboringParticles,
                                      tIndex *neighboringParticlesList) const=0;
 
  
};
 
#endif