simulation.h

Go to the documentation of this file.

#pragma once
 
#include <random>
#include <thrust/reduce.h>
#include <thrust/execution_policy.h>
 
#include "model/ising/ising.h"
 
namespace HB
{
//__global__ void setupKernel(curandState *state, size_t seed, size_t n);
  
class MetropolisSimulation
{
 public:
  MetropolisSimulation(const Grid<short int> &grid, const float beta, const size_t steps) : mBeta(beta), mSteps(steps)
  {
    mGrid = std::make_shared<Grid<short int>>(grid);
  }
  
  template<class M>
  void operator()(const M& model) const
  {
    simulate(model);
  }
 private:
  float mBeta{1.0f};
  size_t mSteps{1000};
  std::shared_ptr<Grid<short int>> mGrid{};
  std::vector<float> mEnergies{};
  std::vector<float> mMagnetization{};
  
/*************************************************************************************************************/
  template<class M>
  void simulate(const M &model);
 
/********************************************************************/
  template <class M>
  float metropolisSweep(const M &model);
};
  
class MetropolisSimulationQt
{
 public:
  MetropolisSimulationQt(const Grid<short int> &grid, const float beta) : mBeta(beta)
  {
    mGrid = std::make_shared<Grid<short int>>(grid);
  }
  
  void operator()(const Ising &model) const
  {
    simulate(model);
  }
 private:
  float mBeta{1.0f};
  size_t mSteps{1000};
  std::shared_ptr<Grid<short int>> mGrid{};
  
/*************************************************************************************************************/
  void simulate(const Ising &model);
 
/********************************************************************/
  float metropolisSweep(const Ising &model);
};
  
class SimulatedAnnealing
{
 public:
  SimulatedAnnealing(const Grid<short int> &grid, const float beta, const size_t steps, const float3 temperatureSteps) : mBeta(beta), mSteps(steps), mTemperatureSteps(temperatureSteps)
  {
    mGrid = std::make_shared<Grid<short int>>(grid);
  }
  
  template<class M>
  void operator()(const M& model) const
  {
    simulate(model);
  }
 private:
  float mBeta{1.0f};
  size_t mSteps{1000};
  float3 mTemperatureSteps{1.0f,0.0f,0.1f};
  std::shared_ptr<Grid<short int>> mGrid{};
  std::vector<float> mEnergies{};
  std::vector<float> mMagnetization{};
  
/*************************************************************************************************************************/
  template<class M>
  void simulate(const M &model);
};
 
 
/***********************************************************************************/
template <typename T> T mean(const std::vector<T> &o);
 
/***********************************************************************************/
template <typename T> T covFunc(const size_t t, const std::vector<T> &o);
 
/***********************************************************************************/
template <typename T> T intAuto(const std::vector<T> &o);
 
/***********************************************************************************/
template <typename T> T error(const std::vector<T> &o);
  
/***********************************************************************************/
template <typename T> T blockingError(const std::vector<T> &o, const size_t block_number);
 
/***********************************************************************************/
template <typename T> T bootstrapError(const std::vector<T> &o, const size_t sample_size, const size_t sample_number, const T tau);
 
/***********************************************************************************/
template <typename T> T errorProp(const std::vector<T> &o, const T tau);
 
/**************************************************************************/
template <typename T> T errorPropEnergy(const std::vector<T> &energies, const T beta, const T tau, const size_t V);
 
/***************************************************************************************/
template <typename T> T errorPropMagnetization(const std::vector<T> &magn, const T beta, const T tau, const size_t V);
  
/***************************************************************************************/
template <typename T> size_t d2i(const T d);
 
/***************************************************************************************/
template <typename T> void removeCorr(const std::vector<T> &o);
 
/****************************************************************************/
template <typename T> T specificHeat(const std::vector<T> &energies, const T beta, const size_t V);
 
/****************************************************************************/
template <typename T> T magnSusz(const std::vector<T> &magn, const T beta, const size_t V);
 
using Models = std::vector<std::unique_ptr<HB::Model>>;
 
void simulate(const Models &models);
}