SM_Network.h

#ifndef SM_Network_H
#define SM_Network_H
 
//define a real field
#include"SM_Field.h"
 
//define the std::array object
#include <array>
 
//super class header
#include "SM_Object.h"
 
//constant header
#include "SM_Constants.h"
 
 
class SM_Network : public SM_Object {
    
    //attributes
private :
 
    //network part
    int mIndex;
    int mIndicesNumber;
    int mRootIndex;
    tString mIndexPrefix;
    //file version for reading file portability
    tInteger mFileVersion;
    //number of particles of the network
    tInteger mParticlesNumber;
    
    //number of halo particles needed by the network
    tInteger mHaloParticlesNumber;
    
    //coordinates of all points of size nParticlesNumber+mHaloParticlesNumber
    SM_RealField mX;
 
    //list of the neighbors particles indices in increasing ordered for each particle of size nNeighboringParticles
    //mNeighboringParticlesList[q] in {0,nParticlesNumber+nHaloParticlesNumber[
    std::valarray<tIndex> mNeighboringParticlesList;
    
    //mNeighboringParticlesNumberOffset[p] offset within  mNeighboringParticlesList to get the first neighboring particle of the p particle of size mParticlesNumber+1
    std::valarray<tIndex> mNeighboringParticlesNumberOffset;
 
    
    //connection data of size nNeighboringParticles
    std::valarray<tReal> mConnectionValues;
   
    //periodicity of the network
    std::array<tBoolean,SM_Constants::DIM> mPeriodicity;
    
    //bounding box of the network
    std::array<tReal,SM_Constants::DIM> mBoundingBoxMinPoint;
    std::array<tReal,SM_Constants::DIM> mBoundingBoxSize;
 
 
protected:
 
   
 
    // CONSTRUCTORS 
    SM_Network(void) {
        mIndex=-1;
        mRootIndex=0;
        mIndicesNumber=1;
        mIndexPrefix="";
        
        //points of netowrk
        mX.setElementsNumber(1);
        
        //first neighbor index
        mNeighboringParticlesNumberOffset={0,0};
        
       
        //bounding box
        for(auto& Pk:mBoundingBoxMinPoint)Pk=0;
        for(auto& Pk:mBoundingBoxSize) Pk=0;
 
        mParticlesNumber=0;
        mHaloParticlesNumber=0;
 
        //no periodicity
        mPeriodicity={false,false,false};
        for(auto& Ik:mPeriodicity) Ik=0;
        //file version
        mFileVersion=1;
        
    }
    // DESTRUCTORS 
    virtual ~SM_Network(void) {
    }
    
public : 
 
    //Instance building
    //=================
    
   
 
 
    //MEMORY
    
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+getContentsMemorySize();
    }
 
    virtual tMemSize getContentsMemorySize() const {
        tMemSize mem=SM_Object::getContentsMemorySize();
        mem+=mX.getContentsMemorySize();
        mem+=mNeighboringParticlesNumberOffset.size()*sizeof(tIndex);
        mem+=mNeighboringParticlesList.size()*sizeof(tIndex);
        mem+=mBoundingBoxMinPoint.size()*sizeof(tReal);
        mem+=mBoundingBoxSize.size()*sizeof(tReal);
        mem+=mConnectionValues.size()*sizeof(tReal);
        mem+=mPeriodicity.size()*sizeof(tBoolean);
        return mem;
    }
    
    //SET & GET methods
 
    virtual void copy(const SM_Network& network) {
        mX.copy(network.getParticlesCoordinates());
        mNeighboringParticlesNumberOffset=network.getNeighboringParticlesNumberOffset();
        mNeighboringParticlesList=network.getNeighboringParticlesList();
        mConnectionValues=network.getConnectionValues();
    }
 
    //virtual CORE_UniquePointer<SM_Network> newInstance() const=0;
    
public:
 
    inline const int& getIndex() const {
        return mIndex;
    }
    inline const int& getRootIndex() const {
        return mRootIndex;
    }
    inline const int& getIndicesNumber() const {
        return mIndicesNumber;
    }
    inline const tString& getIndexPrefix() const {
        return mIndexPrefix;
    }
    
    inline void setIndex(const int& index,const int& rootIndex,const int& indicesNumber) {
        setIndex(index,rootIndex,indicesNumber,"_c");
    }
    inline void setIndex(const int& index,const int& rootIndex,const int& indicesNumber,const tString& prefix) {
        mIndex=index;
        mRootIndex=rootIndex;
        mIndicesNumber=indicesNumber;
        int nDigits=(int) (log(indicesNumber)+1.);
        mIndexPrefix=prefix+functions_numeric::toString(index,nDigits)+"p"+functions_numeric::toString(indicesNumber,nDigits);
    }
    
  
 
    //periodicity
    //============
    
    inline void setPeriodicity(const std::initializer_list<tBoolean>&& period) {
        tBoolean *iPeriod=mPeriodicity.data();
        const tBoolean *ePeriod=iPeriod;ePeriod+=SM_Constants::DIM;
        auto iter=period.begin();
        while ((iPeriod!=ePeriod) && (iter!=period.end()))  {
            (*iPeriod)=(*iter);
            iter++;
            iPeriod++;
        }
        while (iPeriod!=ePeriod)  {
            (*iPeriod)=false;
            iPeriod++;
        }   
    }
    
    inline void setPeriodicity(const std::array<tBoolean,SM_Constants::DIM>& period) {
        mPeriodicity=period;
    }
    
    inline void setPeriodicity(const std::vector<tBoolean>& period) {
        tBoolean *iPeriod=mPeriodicity.data();
        const tBoolean *ePeriod=iPeriod;ePeriod+=SM_Constants::DIM;
        auto iter=period.begin();
        while ((iPeriod!=ePeriod) && (iter!=period.end()))  {
            (*iPeriod)=(*iter);
            iter++;
            iPeriod++;
        }
        while (iPeriod!=ePeriod)  {
            (*iPeriod)=false;
            iPeriod++;
        }   
    }
   
    inline  const std::array<tBoolean,SM_Constants::DIM>& getPeriodicity() const {
        return mPeriodicity;
    }
   
   
    //particles coodinates
    //====================
    inline void setParticlesNumber(const tInteger& nParticles)  {
        setSize(nParticles,0);
    }
    inline void setSize(const tInteger& nParticles,
                        const tInteger& nHaloParticles)  {
        mParticlesNumber=nParticles;
        mHaloParticlesNumber=nHaloParticles;
        
        //number of particles
        mX.setElementsNumber(nParticles+nHaloParticles);
        
        //index of neighbors
        mNeighboringParticlesNumberOffset.resize(nParticles+1);
 
        //set the index of neighbors to 0
        memset(&mNeighboringParticlesNumberOffset[0],0,sizeof(tIndex)*mNeighboringParticlesNumberOffset.size());
 
        //particles weights
        // if (!mIsParticlesSpatialWeightUniform) {
        //     mParticlesSpatialWeight.resize(nParticles);
            
        // }
        
    }
    inline const tInteger& getParticlesNumber() const {
        return mParticlesNumber;
    }
    inline const tInteger& getHaloParticlesNumber() const {
        return mHaloParticlesNumber;
    }
 
    
    inline void setParticlesCoordinates(std::initializer_list<tReal>&& coords) {
        mX=coords;
    }
    inline void setParticlesCoordinates(const std::initializer_list<tReal>& coords) {
        mX=coords;
    }
    inline void setParticlesCoordinates(const SM_RealField& coords) {
        mX=coords;
    }
    
    inline const SM_RealField& getParticlesCoordinates() const {
        return mX;
    }
 
    inline SM_RealField& getParticlesCoordinates() {
        return mX;
    }
 
    //neighboring particles
    //=====================
 
    inline const std::valarray<tIndex>& getNeighboringParticlesList() const {
        return mNeighboringParticlesList;
    }
     
    inline std::valarray<tIndex>& getNeighboringParticlesList()  {
        return mNeighboringParticlesList;
    }
 
    inline tIndex getNeighboringParticlesNumber() const {
        return mNeighboringParticlesList.size();
    }
  
      
    inline tIndex getConnectionsNumber() const {
        return  mNeighboringParticlesList.size();
    }
 
    inline const std::valarray<tIndex>& getNeighboringParticlesNumberOffset() const {
        return mNeighboringParticlesNumberOffset;
    }
    inline std::valarray<tIndex>& getNeighboringParticlesNumberOffset()  {
        return mNeighboringParticlesNumberOffset;
    }
 
    inline const tIndex* getNeighboringParticlesList(const tIndex& i) const {
        ASSERT_IN(i<mNeighboringParticlesNumberOffset.size()-1);
        return  &mNeighboringParticlesList[mNeighboringParticlesNumberOffset[i]];
    }
    inline tIndex  getNeighboringParticlesNumber(const tIndex& i) const {
        ASSERT_IN(i<mNeighboringParticlesNumberOffset.size()-1);
        return  mNeighboringParticlesNumberOffset[i+1]- mNeighboringParticlesNumberOffset[i];
    }
    inline void setNeighboringParticlesList(std::valarray<tUCInt>&& neighborsNumber,
                                            std::valarray<tIndex>&& neighborsList) {
        //mNeighboringParticlesNumberOffset[p]=0;
        //mNeighboringParticlesNumberOffset[p+1]=mNeighboringParticlesNumberOffset[p]+mNeighborsNumber[p]
        //mFirsNeighborIndices.size()=nParticles+1
        //mFirstNeighbordArrayIndex[i] : is the index of the first neighbor particle  within the list mNeighborsParticlesIndices for the particle i
        //mFirstNeighbordArrayIndex[L]: is the number of neighbors
      
        mNeighboringParticlesNumberOffset.resize(neighborsNumber.size()+1);
        tIndex *iIndex=&mNeighboringParticlesNumberOffset[0];
        tIndex *iNextIndex=iIndex;iNextIndex++;
        const tIndex *eIndex=iIndex;eIndex+=mNeighboringParticlesNumberOffset.size();
        (*iIndex)=0;
        for(const auto& n:neighborsNumber) {
            (*iNextIndex)=(*iIndex)+n;
            iIndex=iNextIndex;
            iNextIndex++;
        }
        
        mNeighboringParticlesList=neighborsList;
    }
 
    inline void setNeighboringParticlesList(const std::valarray<tUCInt>& neighborsNumber,
                                            const std::vector<tIndex>& neighborsList) {
        //set neighbors indices
        //mFirstNeighborIndices[p]=0;
        //mFirstNeighborIndices[p+1]=mFirstNeighborIndices[p]+mNeighborsNumber[p]
        //mFirsNeighborIndices.size()=nParticles+1
        mNeighboringParticlesNumberOffset.resize(neighborsNumber.size()+1);
 
        //itertaor on index of the first neighbor of current particule 
        tIndex *iIndex=&mNeighboringParticlesNumberOffset[0];
        //iterator on index of the first neighbor of next particle
        tIndex *iNextIndex=iIndex;iNextIndex++;
        //end iterator on first neighbor arrays of size mParticlesNumber+1
        const tIndex *eIndex=iIndex;eIndex+=mNeighboringParticlesNumberOffset.size();
        (*iIndex)=0;
        for(const auto& n:neighborsNumber) {//loop on number of neighbors per particles
            (*iNextIndex)=(*iIndex)+n;
            //next perticle iterator
            iIndex=iNextIndex;
            iNextIndex++;
        }
 
       
        //copy vector neighborsIndices into array mNeighboringParticlesList
        auto Ni=neighborsList.cbegin();
        mNeighboringParticlesList.resize(neighborsList.size());
        std::for_each(std::begin(mNeighboringParticlesList),std::end(mNeighboringParticlesList),[&Ni](tIndex& e){e=(*Ni);Ni++;} );
 
    }
 
    inline tIndex computeAloneParticlesNumber() const {
        tIndex nAloneParticles=0;
        //mNeighboringParticlesNumberOffset[p]=0;
        //neighorsNumber=mNeighboringParticlesNumberOffset[p+1]-mNeighboringParticlesNumberOffset[p]
        //mFirsNeighborIndices.size()=nParticles+1
        //begin iterator on mNeighboringParticlesNumberOffset
        const tIndex *iIndex=&mNeighboringParticlesNumberOffset[0];
        const tIndex *iNextIndex=iIndex;iNextIndex++;
        //end iterator on mNeighboringParticlesNumberOffset
        const tIndex *eIndex=iIndex;eIndex+=mNeighboringParticlesNumberOffset.size();
        while (iNextIndex!=eIndex) {
            //increment of 1 if the number of neighbors = 0
            nAloneParticles+=((*iNextIndex)==(*iIndex));
            //next particles
            iIndex=iNextIndex;
            iNextIndex++;
           
        }
        return nAloneParticles;
    }
 
 
    //connection values
    //=================
 
    inline tBoolean hasConnectionValues() const {
        return (mConnectionValues.size()>1);
    }
    
    inline tIndex getConnectionValuesNumber() const {
        return mConnectionValues.size();
    }
 
    inline const std::valarray<tReal>& getConnectionValues() const {
        return mConnectionValues;
    }
 
    inline std::valarray<tReal>& getConnectionValues()  {
        return mConnectionValues;
    }
public:
 
    inline tReal& getConnectionValue(const tIndex& i,const tIndex& j,tBoolean& isFound) {
        ASSERT_IN(i<mNeighboringParticlesNumberOffset.size()-1);
        ASSERT_IN(j<mNeighboringParticlesNumberOffset.size()-1);
        tIndex index=mNeighboringParticlesNumberOffset[i];
        index+=functions_numeric::quickSearch(j,mNeighboringParticlesNumberOffset[i+1]-index,
                                              &mNeighboringParticlesList[index],
                                              isFound);
        return mConnectionValues[index];
        
    }
    inline const tReal& getConnectionValue(const tIndex& i,const tIndex& j,tBoolean& isFound) const {
        ASSERT_IN(i<mNeighboringParticlesNumberOffset.size()-1);
        ASSERT_IN(j<mNeighboringParticlesNumberOffset.size()-1);
        tIndex index=mNeighboringParticlesNumberOffset[i];
        index+=functions_numeric::quickSearch(j,mNeighboringParticlesNumberOffset[i+1]-index,
                                              &mNeighboringParticlesList[index],
                                              isFound);
        return mConnectionValues[index];
        
    }
    
    inline const tReal* getConnectionValues(const tIndex& i) const {
        ASSERT_IN(i<mNeighboringParticlesNumberOffset.size()-1);
        return &mConnectionValues[mNeighboringParticlesNumberOffset[i]*(mConnectionValues.size()>1)];
        
    } 
    inline  tReal* getConnectionValues(const tIndex& i)  {
        ASSERT_IN(i<mNeighboringParticlesNumberOffset.size()-1);
        return &mConnectionValues[mNeighboringParticlesNumberOffset[i]*(mConnectionValues.size()>1)];
        
    }
 
    
    //bounding box of the particles
    //==============================
 
    inline const std::array<tReal,SM_Constants::DIM>& getBoundingBoxMinPoint() const {
        return mBoundingBoxMinPoint;
    }
    inline const std::array<tReal,SM_Constants::DIM>& getBoundingBoxSize() const {
        return mBoundingBoxSize;
    }
 
   
    virtual void computeBoundingBox(std::array<tReal,SM_Constants::DIM>& bbMinPoint,
                                    std::array<tReal,SM_Constants::DIM>& bbSize) const =0;
    
 
    //update state methods
    //=====================
    virtual void updateState() {
        computeBoundingBox(mBoundingBoxMinPoint,mBoundingBoxSize);
    }
 
    virtual void updateConnectionValues(const tReal& noiseRate,
                                        SM_StochasticFunctionsInterface& randomF,
                                        const tReal& J,
                                        const std::function<void(const tReal&,const tReal& ,const tReal&,tReal& )>& F)=0;
    
    protected:
    void updateConnectionValuesSlice(const tIndex& startIndex,
                                     const tIndex& endIndex,
                                     const tReal& noiseRate,
                                     SM_StochasticFunctionsInterface& randomF,
                                     const tReal& J,
                                     const std::function<void(const tReal&,const tReal& ,const tReal&,tReal& )>& F);
    
public:
 
    //IO methods
    //===========
    tBoolean saveToFile(const tString& fileName) const;
    
    tBoolean loadFromFile(const tString& fileName);
 
protected:
 
    virtual void saveStatesToFile(std::ofstream& file) const;
 
    virtual void loadStatesFromFile(std::ifstream& file,
                                    tInteger& version,
                                    tDimension& d);
 
    
    
private:
    void saveParticlesToFile(std::ofstream& file) const;
    tBoolean loadParticleDataFromFile(std::ifstream& file,
                                  const tDimension& d); 
    tBoolean loadParticlesFromFile(std::ifstream& file,
                                   const tDimension& d,
                                   const tIndex& nParticles,
                                   const tIndex& nHaloParticles,
                                   const tIndex& nNeighboringParticles);
    
public:
    
    virtual tString toString() const override;
};
 
#endif