SM_Network.h

Go to the documentation of this file.

#ifndef SM_Network_H
#define SM_Network_H
 
//define a real field
#include"SM_Field.h"
 
//define the std::array object
#include <array>
 
#include "SM_Object.h"
 
class SM_Network : public SM_Object {
    
    //attributes
private :
    
    
  
    
    
    
    //strength
    tReal mLambda;
    
  
    //coordinates of points
    SM_RealField mPoints;
 
    //neighbors number
    std::valarray<tUInt> mNeighborsNumber;
    
    //list of the neighbors indices
    std::valarray<tIndex> mNeighborsIndices;
    
    //list of js;
    std::valarray<tReal> mJs;
    
    //association
  
    
   
public:
    // CONSTRUCTORS 
    SM_Network(void) {
 
        mPoints.setElementsNumber(1);
        
        mLambda=1;
        mNeighborsNumber={0};
    }
    
    // DESTRUCTORS 
    virtual ~SM_Network(void) {
    }
    
public : 
 
    //Instance building
    //=================
    
    inline static CORE_UniquePointer<SM_Network> New() {
        return CORE_UniquePointer<SM_Network>(new SM_Network(),SM_Network::Delete());
    }
 
 
    //MEMORY
    
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+getContentsMemorySize();
    }
 
    virtual tMemSize getContentsMemorySize() const {
        tMemSize mem=SM_Object::getContentsMemorySize();
        mem+=mPoints.getContentsMemorySize();
        mem+=mNeighborsNumber.size()*sizeof(tUInt);
        mem+=mNeighborsIndices.size()*sizeof(tIndex);
        mem+=mJs.size()*sizeof(tReal);
        return mem;
    }
    
    //SET & GET methods
 
    void copy(const SM_Network& network) {
        //strength
        mLambda=network.getLambda();
        mPoints.copy(network.getParticlesCoordinates());
        mNeighborsNumber=network.getNeighborsNumber();
        mNeighborsIndices=network.getNeighborsIndices();
        mJs=network.getHeissenbergCoefficients();
   
    
    }
   
    inline tDimension getDimension() const {
        return mPoints.getDimension();
    }
   
    inline void setParticlesNumber(const tInteger& nParticles)  {
        mPoints.setElementsNumber(nParticles);
    }
    inline tInteger getParticlesNumber() const {
        return mPoints.getElementsNumber();
    }
    inline tIndex computeAloneParticlesNumber() const {
        tIndex nAloneParticles=0;
        std::for_each(std::begin(mNeighborsNumber),std::end(mNeighborsNumber),
                      [&nAloneParticles](const auto& i){nAloneParticles+=(i==0);});
        return nAloneParticles;
    }
    
    inline void setParticlesCoordinates(std::initializer_list<tReal>&& coords) {
        mPoints=coords;
    }
    inline void setParticlesCoordinates(const std::initializer_list<tReal>& coords) {
        mPoints=coords;
    }
    inline void setParticlesCoordinates(const SM_RealField& coords) {
        mPoints=coords;
    }
    
    inline const SM_RealField& getParticlesCoordinates() const {
        return mPoints;
    }
 
    inline SM_RealField& getParticlesCoordinates() {
        return mPoints;
    }
    
    inline void setLambda( const tReal& L)  {
        mLambda=L;
    }
    inline const tReal& getLambda() const {
        return mLambda;
    }
    
    inline void setNeighbors(std::valarray<tUInt>&& neighborsNumber,
                             std::valarray<tIndex>&& neighborsIndices,
                             std::valarray<tReal>&& Js) {
        mNeighborsNumber=neighborsNumber;
        mNeighborsIndices=neighborsIndices;
        mJs=Js;
    }
    inline void setNeighbors(const std::valarray<tUInt>& neighborsNumber,
                             const std::vector<tIndex>& neighborsIndices,
                             const std::vector<tReal>& Js) {
        //copy neighbors
        mNeighborsNumber=neighborsNumber;
 
       
        //copy vector neighborsIndices into array mNeighborsIndices
        auto Ni=neighborsIndices.cbegin();
        mNeighborsIndices.resize(neighborsIndices.size());
        std::for_each(std::begin(mNeighborsIndices),std::end(mNeighborsIndices),[&Ni](tIndex& e){e=(*Ni);Ni++;} );
 
        //copy vector Js into array mJs
        auto Ji=Js.cbegin();
        mJs.resize(Js.size());
        std::for_each(std::begin(mJs),std::end(mJs),[&Ji](tReal& e){e=(*Ji);Ji++;} );
          
    }
 
    
    
    inline tIndex getConnectionsNumber() const {
        return mNeighborsIndices.size();
    }
    inline const std::valarray<tUInt>& getNeighborsNumber() const {
        return mNeighborsNumber;
    }
    inline std::valarray<tUInt>& getNeighborsNumber()  {
        return mNeighborsNumber;
    }
   
    
    /* ! \brief get the neighbors indices
     * @return the neighborsIndices as indices of neighbors  for each particle of size mParticlesNumber x sum on i of  neighborsNumber[i]
     */
    inline const std::valarray<tIndex>& getNeighborsIndices() const {
        return mNeighborsIndices;
    }
     
    /* ! \brief get the neighbors indices
     * @return the neighborsIndices as indices of neighbors  for each particle of size mParticlesNumber x sum on i of  neighborsNumber[i]
     */
    inline std::valarray<tIndex>& getNeighborsIndices()  {
        return mNeighborsIndices;
    }
 
   
 
 
    inline const std::valarray<tReal>& getHeissenbergCoefficients() const {
        return mJs;
    }
 
    inline std::valarray<tReal>& getHeissenbergCoefficients()  {
        return mJs;
    }
 
 
    void create3DGrid(const tIndex& Nx,const tIndex Ny,const tIndex Nz,
                      const tReal & Hx,const tReal& Hy,const tReal &Hz,
                      const tReal& J,const tBoolean& hasSelfInteraction);
    
public:
  
    virtual tString toString() const override;
};
 
 
#endif