SM_MacroCellsNetwork.h

#ifndef SM_MacroCellsNetwork_H
#define SM_MacroCellsNetwork_H
 
//base classes
#include "SM_Object.h"
 
//field header
#include "SM_Field.h"
 
//network header
#include "SM_Network.h"
 
 
//material header
#include "SM_Material.h"
 
class SM_MacroCellsNetwork : public virtual SM_Object  {
    
 
public:
private :
 
    //type class
    typedef SM_Object SuperClass;
    typedef SM_MacroCellsNetwork SelfClass;
    
    //single attributes
    //-----------------
    
    //margin for building macro cells
    tReal mMargin;
    
 
    //multiple attributes
    //------------------
 
    //number of macro cells
    tInteger mMacroCellsNumber;
    
    //macro cell size in angstrom
    std::array<tReal,SM_Constants::DIM> mMacroCellSize;
 
    
    //macro cell index at particle p of size nParticles
    //mMacroCellsList[p]=index of the macro cell  m to which the particle p belongs to 
    std::valarray<tInteger> mMacroCellsList;
 
    //W[m] : macro cells Weight (of size nMacroCells) i the sum of the volume of the particles in macro cells
    std::valarray<tReal> mMacroCellsVolume;
 
    
    //single associations
    //-------------------
 
    //mass center of the macro cell m  of size nMacroCells x dim
    SM_RealField mC;
 
    //multiple associations
    //---------------------
 
    
   
protected:
    // CONSTRUCTORS 
    SM_MacroCellsNetwork(void) {
        mMargin=0;
    }
    
    // DESTRUCTORS 
    virtual ~SM_MacroCellsNetwork(void) {
    }
   
    
public : 
 
    //Instance building
    //=================
 
   
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+this->getContentsMemorySize();
    }
 
    virtual tMemSize getContentsMemorySize() const {
        tMemSize mem=SuperClass::getContentsMemorySize();
        
        mem+=mMacroCellsList.size()*sizeof(tInteger);
        mem+=mMacroCellSize.size()*sizeof(tReal);
        mem+=mC.getContentsMemorySize();
        mem+=mMacroCellsVolume.size()*sizeof(tReal);
      
        return mem;
    }
public:
 
    virtual CORE_UniquePointer<SM_MacroCellsNetwork> newInstance() const=0;
 
    //Data settting
    //=============
    
    inline void setMacroCellMargin(const tReal& w) {
        mMargin=std::max(w,(tReal)1.e-12);
    }
    inline const tReal& getMacroCellMargin() const {
        return mMargin;
    }
 
    inline void setMacroCellSize(const std::array<tReal,SM_Constants::DIM>& H) {
        mMacroCellSize=H;
    }
    inline void setMacroCellSize(const std::vector<tReal>& H) {
        auto iH=H.cbegin();
        const auto eH=H.cend();
        for(auto& Hk:mMacroCellSize) {
            if (iH!=eH) {
                Hk=(*iH);
                iH++;
            }  else {
                Hk=1;
            }
        }
    }
    inline const std::array<tReal,SM_Constants::DIM>& getMacroCellSize() const {
        return mMacroCellSize;
    }
    //set & get methods
    //==================
    
    inline void setMacroCellsNumber(const tInteger& n)  {
        mMacroCellsNumber=n;
        mC.setElementsNumber(n);
    }
    
    inline const tInteger& getMacroCellsNumber() const {
        return mMacroCellsNumber;
    }
   
 
    inline const SM_RealField& getMacroCellsMassCenter() const {
        return mC;
    }
 
    inline SM_RealField& getMacroCellsMassCenter()  {
        return mC;
    }
 
 
    inline const std::valarray<tInteger>& getMacroCellsList() const {
        return mMacroCellsList;
    }
    inline std::valarray<tInteger>& getMacroCellsList() {
        return mMacroCellsList;
    }
    inline const std::valarray<tReal>& getMacroCellsVolume() const {
        return mMacroCellsVolume;
    }
    inline std::valarray<tReal>& getMacroCellsVolume()  {
        return mMacroCellsVolume;
    }
    inline const tReal&  getMacroCellVolume(const tInteger& m)  const {
        return mMacroCellsVolume[m];
    }
  
     
   
 
public:
   
    inline const tInteger& getMacroCellIndex(const tInteger& p) const {
        return mMacroCellsList[p];
    }
 
    
    //discretize the network
    //======================
public:
  
public:
 
 
    //Macro cells methods
    //======================
    
public:
    virtual void computeMacroCells(const SM_Material& material,
                                   const SM_Network& network) {
        
        
        //get the min & max point of the bounding box of the network
        const std::array<tReal,SM_Constants::DIM>& bbMinPoint=network.getBoundingBoxMinPoint();
        std::array<tReal,SM_Constants::DIM> bbMaxPoint=network.getBoundingBoxSize();
        functions_array::add(bbMaxPoint,bbMinPoint);
        //compute the macro cells in the bounding box
        computeBoundingBoxMacroCells(material,network,bbMinPoint,bbMaxPoint);
    }
 
protected:
    virtual void computeBoundingBoxMacroCells(const SM_Material& material,
                                              const SM_Network& network,
                                              const std::array<tReal,SM_Constants::DIM>& P,
                                              const std::array<tReal,SM_Constants::DIM>& Q);
public:
    virtual void computeMacroCellsMassCenter(const SM_Material& material,
                                             const SM_Network& network);
 
    
   
   
    
   
    
  
 
protected:
  
 
    
    static tInteger ComputeMacroCells(const SM_Material& material,
                                      const SM_Network& network,
                                      const std::array<tReal,SM_Constants::DIM>& P,//min point of the domain
                                      const std::array<tReal,SM_Constants::DIM>& Q,//max point of the domain
                                      const std::array<tReal,SM_Constants::DIM>& macroCellSize,
                                      const tReal& margin,
                                      const tReal& epsVW,
                                      std::valarray<tReal> & MCsVolume,//volume of the macro cells
                                      std::valarray<tInteger>& macroCellsList);//local indices of macro cell per particle
 
    static void EliminateEmptyMacroCells(const tReal& epsVM,
                                         std::valarray<tReal>& gMCVolume,
                                         std::valarray<tReal>& lMCVolume,
                                         std::valarray<tInteger>& gMCLocalIndices);
 
    static void BuildParticlesListOrderedPerMacroCells(const SM_Network& network,
                                                       const tInteger& nMacroCells,
                                                       const std::valarray<tInteger>& macroCellsPList,
                                                       std::valarray<tInteger>& particlesMCList,
                                                       std::valarray<tInteger>& particlesMCListOffset);
    
    inline static void ConvertIndices(const std::valarray<tInteger>& indicesConverter,
                                      std::valarray<tInteger>& indicesList) {
        for(auto& i:indicesList) {
            i=indicesConverter[i];
        }
    }
    inline static void ConvertIndices(const std::valarray<tInteger>& indicesConverter,
                                      const tInteger& n,tInteger* iIndicesList) {
        const tInteger *eIndicesList=iIndicesList;
        eIndicesList+=n;
        while (iIndicesList!=eIndicesList) {
            (*iIndicesList)=indicesConverter[(*iIndicesList)];
            iIndicesList++;
        }
    }
    static void ComputeMacroCellX(const tInteger& nParticles,
                                  const tReal* iX,
                                  const tInteger* iMacroCellsList,
                                  SM_RealField&  C,
                                  std::valarray<tInteger>& nMCParticles);
    
    inline static void MeanX(const tInteger& n,
                             const tInteger* iNs,
                             tReal *iX) {   
        //make the barycenter of center of mass
       
        //end iterator on mass center of not empty macro cells 
        const tReal *eX=iX;
        eX+=n*SM_Constants::DIM;
 
        //end iterator on last coordinate of the mass center of not empty macro cells 
        const tReal *eX_d=iX;
        
        tReal f;//inverse of (*iNs)
        while (iX!=eX) {//loop on particles
            eX_d+=SM_Constants::DIM;
 
            //f=1/Ns
            f=1;
            f/=(*iNs);
            //X[i]/=Ns
            while (iX!=eX_d) {//mean value of the coordinates of the n particles
                (*iX)*=f;
                //iterator at next coordinate of the particle
                iX++;
            }
            //iterators at next particles
            iNs++;
        } 
        
        
    }
    
 
    
 
 
    
  
    // String representation
    // =======================
public:
 
      
    virtual tString toString() const override {
        std::stringstream ret;
        ret<<SuperClass::toString()<<"\n";
        ret<<"\t macro cell size:"<<functions_array::toString(mMacroCellSize)<<"\n";
        ret<<"\t number of macro cells: "<<mC.getElementsNumber()<<"\n";
        ret<<"\t margin of macro cells: "<<mMargin<<"\n";
        ret<<"\t mass centers: C:\n";
        tInteger s=mC.getElementsNumber()/10;
        s=(s==0)?1:s;
        for(tInteger i=0;i<mC.getElementsNumber();i+=s) {
            ret<<"\t ["<<i<<"]="<<functions_array::toString(SM_Constants::DIM,mC(i))<<"\n";
        }
        //ret<<"\t macroCellsList :"<<functions_array::toString(mMacroCellsList)<<"\n";
        //ret<<"\t particlesList :"<<functions_array::toString(mParticlesMCList)<<"\n";
        //ret<<"\t particlesListOffset :"<<functions_array::toString(mParticlesMCListOffset)<<"\n";
        return ret.str();
    }
 
private:
    // void ComputeMacroCellsVBlock(const SM_Material& material,
    //                              const std::array<tReal,SM_Constants::DIM>& P,//min point of the domain
    //                              const std::array<tReal,SM_Constants::DIM>& Q,//max point of the domain
    //                              const SM_Network& network,
    //                              const tReal& eps,
    //                              const std::array<tReal,SM_Constants::DIM>& Hmc,//size of the macro cells
    //                              SM_RealField& C,//centers of the macro cell
    //                              std::valarray<tInteger>& mcParticlesListOffset,
    //                              std::valarray<tInteger>& mcParticlesList,
    //                              std::valarray<tInteger>& macroCellsList);
    // void ComputeMacroCellsVAMPIRE(const SM_Material& material,
    //                               const std::array<tReal,SM_Constants::DIM>& P,//min point of the domain
    //                               const std::array<tReal,SM_Constants::DIM>& Q,//max point of the domain
    //                               const SM_Network& network,
    //                               const tReal& eps,
    //                               const std::array<tReal,SM_Constants::DIM>& Hmc,//size of the macro cells
    //                               SM_RealField& C,//centers of the macro cell
    //                               std::valarray<tInteger>& mcParticlesListOffset,
    //                               std::valarray<tInteger>& mcParticlesList,
    //                               std::valarray<tInteger>& macroCellsList);
    
    
};
 
 
#endif