ScalarField.h

Go to the documentation of this file.

/*-------------------------------------------------------------------
Copyright 2011 Ravishankar Sundararaman

This file is part of JDFTx.

JDFTx is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

JDFTx is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with JDFTx.  If not, see <http://www.gnu.org/licenses/>.
-------------------------------------------------------------------*/

#ifndef JDFTX_CORE_SCALARFIELD_H
#define JDFTX_CORE_SCALARFIELD_H



#include <memory>
#include <core/scalar.h>
#include <core/Util.h>
#include <core/ManagedMemory.h>

class GridInfo; //Grid description and memory manager
struct ScalarFieldData; //Real space data storage container for real scalar fields
struct ScalarFieldTildeData; //Reciprocal space data storage container for real scalar fields
struct complexScalarFieldData; //Real space data storage container for complex scalar fields
struct complexScalarFieldTildeData; //Reciprocal space data storage container for complex scalar fields

//DO NOT work with above data types directly, instead use the following smart pointer types:
typedef std::shared_ptr<ScalarFieldData> ScalarField; 
typedef std::shared_ptr<ScalarFieldTildeData> ScalarFieldTilde; 
typedef std::shared_ptr<complexScalarFieldData> complexScalarField; 
typedef std::shared_ptr<complexScalarFieldTildeData> complexScalarFieldTilde; 

//Define shorthands for fetching gpu data in gpu mode and cpu data in cpu mode:
#ifdef GPU_ENABLED
        #define DECLARE_DATA_PREF_ACCESS \
                DataType* dataPref(bool shouldAbsorbScale=true) { return dataGpu(shouldAbsorbScale); } \
                const DataType* dataPref(bool shouldAbsorbScale=true) const { return dataGpu(shouldAbsorbScale); }
#else
        #define DECLARE_DATA_PREF_ACCESS \
                DataType* dataPref(bool shouldAbsorbScale=true) { return data(shouldAbsorbScale); } \
                const DataType* dataPref(bool shouldAbsorbScale=true) const { return data(shouldAbsorbScale); }
#endif

struct FieldData : private ManagedMemory
{
        int nElem; 
        double scale; 
        const GridInfo& gInfo; 

        void absorbScale() const; 
        inline void zero() { ManagedMemory::zero(); } 

        typedef void DataType; 
        
        void* data(bool shouldAbsorbScale=true); 
        const void* data(bool shouldAbsorbScale=true) const; 
        #ifdef GPU_ENABLED
        void* dataGpu(bool shouldAbsorbScale=true); 
        const void* dataGpu(bool shouldAbsorbScale=true) const; 
        #endif

        DECLARE_DATA_PREF_ACCESS
        
        inline bool isOnGpu() const { return ManagedMemory::isOnGpu(); } 

        FieldData(const GridInfo& gInfo, string category, int nElem, int nDoublesPerElem=1, bool onGpu=false);
        void copyData(const FieldData& other); 

        //Inter-process communication (expose corresponding ManagedMemory functions):
        inline void send(int dest, int tag=0) const { absorbScale(); ManagedMemory::send(dest,tag); } 
        inline void recv(int src, int tag=0) { absorbScale(); ManagedMemory::recv(src,tag); } 
        inline void bcast(int root=0) { absorbScale(); ManagedMemory::bcast(root); } 
        inline void allReduce(MPIUtil::ReduceOp op, bool safeMode=false) { absorbScale(); ManagedMemory::allReduce(op, safeMode, isReal); } 

protected:
        struct PrivateTag {}; 
private:
        bool isReal; 
};

//Shorthand for defining the data() and dataGpu() functions in derived classes of FieldData
#ifdef GPU_ENABLED
        #define DECLARE_DATA_ACCESS \
                DataType* data(bool shouldAbsorbScale=true) { return (DataType*)FieldData::data(shouldAbsorbScale); } \
                const DataType* data(bool shouldAbsorbScale=true) const { return (const DataType*)FieldData::data(shouldAbsorbScale); } \
                DataType* dataGpu(bool shouldAbsorbScale=true) { return (DataType*)FieldData::dataGpu(shouldAbsorbScale); } \
                const DataType* dataGpu(bool shouldAbsorbScale=true) const { return (const DataType*)FieldData::dataGpu(shouldAbsorbScale); }
#else
        #define DECLARE_DATA_ACCESS \
                DataType* data(bool shouldAbsorbScale=true) { return (DataType*)FieldData::data(shouldAbsorbScale); } \
                const DataType* data(bool shouldAbsorbScale=true) const { return (const DataType*)FieldData::data(shouldAbsorbScale); }
#endif

struct ScalarFieldData : public FieldData
{       typedef double DataType; 
        DECLARE_DATA_ACCESS
        DECLARE_DATA_PREF_ACCESS
        ScalarField clone() const; 
        static ScalarField alloc(const GridInfo& gInfo, bool onGpu=false); 
        ScalarFieldData(const GridInfo& gInfo, bool onGpu, PrivateTag); 
};


struct ScalarFieldTildeData : public FieldData
{       typedef complex DataType; 
        DECLARE_DATA_ACCESS
        DECLARE_DATA_PREF_ACCESS
        ScalarFieldTilde clone() const; 
        static ScalarFieldTilde alloc(const GridInfo& gInfo, bool onGpu=false); 
        double getGzero() const; 
        void setGzero(double Gzero); 
        ScalarFieldTildeData(const GridInfo& gInfo, bool onGpu, PrivateTag); 
};


struct complexScalarFieldData : public FieldData
{       typedef complex DataType; 
        DECLARE_DATA_ACCESS
        DECLARE_DATA_PREF_ACCESS
        complexScalarField clone() const; 
        static complexScalarField alloc(const GridInfo& gInfo, bool onGpu=false); 
        complexScalarFieldData(const GridInfo& gInfo, bool onGpu, PrivateTag); 
};

struct complexScalarFieldTildeData : public FieldData
{       typedef complex DataType; 
        DECLARE_DATA_ACCESS
        DECLARE_DATA_PREF_ACCESS
        complexScalarFieldTilde clone() const; 
        static complexScalarFieldTilde alloc(const GridInfo& gInfo, bool onGpu=false); 
        complexScalarFieldTildeData(const GridInfo& gInfo, bool onGpu, PrivateTag); 
};



struct RealKernel
{       const GridInfo& gInfo;
        int nElem; 
        double* data; 
        #ifdef GPU_ENABLED
        double* dataGpu; 
        #endif
        double* dataPref; 

        RealKernel(const GridInfo&); 
        ~RealKernel();
        void set(); 
};

#undef DECLARE_DATA_PREF_ACCESS
#undef DECLARE_DATA_ACCESS

#endif //JDFTX_CORE_SCALARFIELD_H