SM_NetworkBuilder.h

#ifndef SM_NetworkBuilder_H
#define SM_NetworkBuilder_H
 
//define the std::array object
#include <array>
 
//super class header
#include "SM_Object.h"
 
 
//network header
#include "SM_Network.h"
 
//crystal structure header
#include "SM_CrystalStructure.h"
 
class SM_NetworkBuilder : public SM_Object {
    
    //attributes
private :
 
 
   
protected:
    
    // CONSTRUCTORS 
    SM_NetworkBuilder(void) {
        
     
    }
    
    // DESTRUCTORS 
    virtual ~SM_NetworkBuilder(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:
    
      
    virtual void buildNetwork(const SM_CrystalStructure& cStructure,
                              const std::array<tBoolean,SM_Constants::DIM>& isPeriodic,
                              const std::array<tReal,SM_Constants::DIM>& X0,
                              const std::array<tInteger,SM_Constants::DIM>& Ns,
                              const std::valarray<tMask>& mask,
                              SM_Network& network)=0;
     
  
    virtual tBoolean  buildDomainNetwork(const SM_CrystalStructure& cStructure,
                                         const std::array<tBoolean,SM_Constants::DIM>& isPeriodic,
                                         const tString& domainExpression,
                                         SM_Network& network)=0;
    
   
    inline void buildPaverNetwork(const SM_CrystalStructure& cStructure,
                                  const std::array<tBoolean,SM_Constants::DIM>& isPeriodic,
                                  const std::array<tInteger,SM_Constants::DIM>& Ns,
                                  SM_Network& network)  {
        buildPaverNetwork(cStructure,isPeriodic,
                          {0.,0.,0.},Ns,
                          network);
    }
      
    inline void buildPaverNetwork(const SM_CrystalStructure& cStructure,
                                  const std::array<tReal,SM_Constants::DIM>& X0,
                                  const std::array<tInteger,SM_Constants::DIM>& Ns,
                                  SM_Network& network)  {
        buildPaverNetwork(cStructure,{false,false,false},
                          X0,Ns,
                          network);
    }
      
    inline void buildPaverNetwork(const SM_CrystalStructure& cStructure,
                                  const std::array<tInteger,SM_Constants::DIM>& Ns,
                                  SM_Network& network)  {
        buildPaverNetwork(cStructure,
                          {false,false,false},
                          {0,0,0},Ns,
                          network);
    }
    
    inline void buildPaverNetwork(const SM_CrystalStructure& cStructure,
                                  const std::array<tBoolean,SM_Constants::DIM>& isPeriodic,
                                  const std::array<tReal,SM_Constants::DIM>& X0,
                                  const std::array<tInteger,SM_Constants::DIM>& Ns,
                                  SM_Network& network){
        
        
        std::valarray<tMask> mask(1);
        mask[0]=1;
        buildNetwork(cStructure,isPeriodic,X0,Ns,mask,network);
        
    }
    
    
 
 
  
};
 
#endif