SM_CrystalStructure.h

#ifndef SM_CrystalStructure_H
#define SM_CrystalStructure_H
 
//super class header
#include "SM_Object.h"
 
//constant header
#include "SM_Constants.h"
 
//array utilities functions
#include "functions_array.h"
 
 
class SM_CrystalStructure : public SM_Object {
    
    //attributes
private :
 
    //name of the structure
    tString mName;
    //max number of neighboring particles per particles 
    tUCInt mCoordinationNumber;
    //number of atoms per unit cell
    tUCInt mAtomsNumber;
 
    //atom volume weight : the normalized volume with respect of the unit cell volume
    tReal mAtomVolumeWeight;
    
    //volume of unit cell in Angstrom
    tReal mUnitVolume;
 
    //size of unit cell in angstrom
    std::array<tReal,SM_Constants::DIM> mUnitCellSize;
 
 
protected:
    // CONSTRUCTORS 
    SM_CrystalStructure(void) {
        mCoordinationNumber=0;
        mAtomsNumber=1;
        mAtomVolumeWeight=1;
        
        mUnitVolume=1;
        for(auto& Sk:mUnitCellSize) Sk=1;
 
        mName="";
 
    }
    
    // DESTRUCTORS 
    virtual ~SM_CrystalStructure(void) {
    }
    
public : 
 
    //Instance building
    //=================
    
   
 
 
    //MEMORY
    
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+getContentsMemorySize();
    }
 
    virtual tMemSize getContentsMemorySize() const {
        tMemSize mem=SM_Object::getContentsMemorySize();
        mem+= mUnitCellSize.size()*sizeof(tReal);
      
        return mem;
    }
    
 
    //constructors
    //============
 
    virtual CORE_UniquePointer<SM_CrystalStructure> newInstance() const=0;
 
    
    //SET & GET methods
    //==================
    
    virtual void copy(const SM_CrystalStructure& s) {
        mAtomsNumber=s.getAtomsNumber();
        mCoordinationNumber=s.getCoordinationNumber();
        setUnitCellSize(s.getUnitCellSize());
    
    }
    inline const tString& getName() const {
        return mName;
    }
protected:
    inline void setName(const tString& name) {
        mName=name;
    }
    
protected:
 
    inline void setCoordinationNumber(const tUCInt& n) {
        mCoordinationNumber=n;
    }
    inline void setAtomsNumber(const tUCInt& n) {
        mAtomsNumber=n;
    }
 
public:
    inline const tUCInt&  getCoordinationNumber() const {
        return mCoordinationNumber;
    }
    inline const tUCInt& getAtomsNumber() const {
        return mAtomsNumber;
    }
   
    
   
    //unit cell size
    //==============
 
    inline void  setUnitCellSize(const tReal& a) {
        mUnitVolume=1;
        for(auto& Sk:mUnitCellSize) {
            Sk=a;
            mUnitVolume*=Sk;
        }
    }
    inline void  setUnitCellSize(const std::array<tReal,SM_Constants::DIM>& as) {
        mUnitCellSize=as;
        
        mUnitVolume=1;
        for(const auto& Sk:mUnitCellSize) mUnitVolume*=Sk;
    }
    inline void  setUnitCellSize(const std::vector<tReal>& as)  {
        //d=min(DIM,as.size)
        tUCInt d=SM_Constants::DIM;
        d=(d>as.size())?as.size():d;
        //last value of as
        tReal a=1;
        for(tUCInt i=0;i<d;i++) {
            a=as[i];
            mUnitCellSize[i]=a;
        }
        for(tUCInt i=d;i<SM_Constants::DIM;i++) {
            mUnitCellSize[i]=a;
        }
        setUnitCellSize(mUnitCellSize);
        
    }
    inline void  setUnitCellSize(std::initializer_list<tReal>&& as)  {
        //d=min(DIM,as.size)
        tUCInt d=SM_Constants::DIM;
        d=(d>as.size())?as.size():d;
        
        //last value of as
        tReal *iHs=mUnitCellSize.data();
        tReal a=1;
        for(const auto& v:as) {
            a=v;
            (*iHs)=v;
            iHs++;
        }
        
        for(tUCInt i=d;i<SM_Constants::DIM;i++) {
            (*iHs)=a;
            iHs++;
        }
        setUnitCellSize(mUnitCellSize);
        
    }
    inline const std::array<tReal,SM_Constants::DIM>& getUnitCellSize() const {
        return mUnitCellSize;
    }
    
    inline const tReal& getUnitVolume() const {
        return mUnitVolume;
    }
 
  
  
 
 
    inline tReal getAtomVolume() const {
        return mAtomVolumeWeight*mUnitVolume;
    }
    inline const tReal& getAtomVolumeWeight() const {
        return mAtomVolumeWeight;
    }
    inline void setAtomVolumeWeight(const tReal& weight)  {
        mAtomVolumeWeight=weight;
    }
 
    
public:
 
  
 
 
    //IO methods
    //===========
  
    virtual tString toString() const override {
        std::stringstream ret;
        ret<<SM_Object::toString()<<"\n";
        ret<<"Name : "<<getName()<<"\n";
        ret<<"Unit Cell Size (A):"<<functions_array::toString(mUnitCellSize)<<"\n";
        ret<<"Unit Cell Volume (A^3):"<<mUnitVolume<<"\n";
        ret<<"Coordination number:"<<((int)mCoordinationNumber)<<"\n";
        ret<<"Atoms number:"<<((int)mAtomsNumber)<<"\n";
        ret<<"Atom volume weight:"<<mAtomVolumeWeight<<"\n";
        ret<<"Atom volume (A^3):"<<getAtomVolume()<<"\n";
        return ret.str();
    }
};
 
#endif