grid.h

Go to the documentation of this file.

#pragma once
 
#include <vector>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <hdf5.h>
#include <random>
 
#include <cuda_runtime.h>
#include <thrust/host_vector.h>
#include <thrust/device_vector.h>
 
namespace HB
{
  typedef struct {
    size_t up;
    size_t right;
    size_t back;
    size_t down;
    size_t left;
    size_t front;
  }NB;
 
  typedef struct {
    float phi; 
    float theta; 
  }Spin;
  
  template<class T>
  class Grid
  {
   public:
    Grid() = default;
 
    /*****************************************************************/
    Grid(const short int spatialDimensions, const dim3 gridSize) : mDim(dim), mGridSize(gridSize)
    {
      mGridData.resize(gridSize.x*gridSize.y*gridSize.z);
    };
 
    /*******************************************************************/
    void calcNeighbourTable();
 
    /*****************************************************************/
    void setGridSize(const dim3 gridSize)
    {
      mGridSize = gridSize;
 
      mGridData.resize(gridSize.x*gridSize.y*gridSize.z);
    }
    
    dim3 getGridSize() const
    {
      return mGridSize;
    }
 
    thrust::host_vector<T> getGridData() const
    {
      return mGridData;
    }
    
    void setGridData(const thrust::host_vector<T> &gridData)
    {
      mGridData = gridData;
    }
 
    thrust::host_vector<NB> getNeighbourTable() const
    {
      return mNeighbourTable;
    }
    
    void setNeighbourTable(const thrust::host_vector<NB> &neighbourTable)
    {
      mNeighbourTable = neighbourTable;
    }
 
    T getSpin(const dim3 index) const
    {
      size_t idx = index.x*mGridSize.x +
               index.y*mGridSize.x*mGridSize.y +
                   index.z;
      return mGridData[idx];
    }
 
    void setSpin(const dim3 index, const T spin)
    {
      size_t idx = index.x*mGridSize.x +
               index.y*mGridSize.x*mGridSize.y +
                   index.z;
      mGridData[idx] = spin;
    }
    
    NB getNeighbours(const dim3 index) const
    {
      size_t idx = index.x*mGridSize.x +
               index.y*mGridSize.x*mGridSize.y +
                   index.z;
      return mNeighbourTable[idx];
    }
    
    short int getDim() const {return mDim;}
 
    void setDim(const short int dim) {mDim = dim;}
 
    /*****************************************************************/
    void hotStart();
    
    /*****************************************************************/
    void coldStart();
 
    /************************************************************************************************/
    herr_t saveGrid(const std::string path);
    
    /************************************************************************************************/
    /*void upload(Grid<T> &deviceGrid)
    {
      deviceGrid.setGridData(mGridData);
      deviceGrid.setNeighbourTable(mNeighbourTable);
      }*/
    
    /************************************************************************************************/
    /*void download(Grid<T> &deviceGrid)
    {
      mGridData = deviceGrid.getGridData();
      }*/
    
   private:
    dim3 mGridSize; 
    short int mDim; 
    thrust::host_vector<T> mGridData; 
    thrust::host_vector<NB> mNeighbourTable; 
  };
}