6 files changed, 578 insertions, 0 deletions
diff --git a/examples/src/models/potts/CMakeLists.txt b/examples/src/models/potts/CMakeLists.txt
new file mode 100644
index 0000000..53133b9
--- /dev/null
+++ b/examples/src/models/potts/CMakeLists.txt
@@ -0,0 +1,39 @@
+
+add_executable(wolff_3potts             wolff_potts.cpp)
+add_executable(wolff_4potts             wolff_potts.cpp)
+add_executable(wolff_7potts             wolff_potts.cpp)
+add_executable(wolff_3clock             wolff_clock.cpp)
+add_executable(wolff_5clock             wolff_clock.cpp)
+
+set_target_properties(wolff_3potts          PROPERTIES COMPILE_FLAGS "-DPOTTSQ=3")
+set_target_properties(wolff_4potts          PROPERTIES COMPILE_FLAGS "-DPOTTSQ=4")
+set_target_properties(wolff_7potts          PROPERTIES COMPILE_FLAGS "-DPOTTSQ=7")
+set_target_properties(wolff_3clock          PROPERTIES COMPILE_FLAGS "-DPOTTSQ=3")
+set_target_properties(wolff_5clock          PROPERTIES COMPILE_FLAGS "-DPOTTSQ=5")
+
+find_library(GL NAMES GL)
+find_library(GLU NAMES GLU)
+find_library(GLUT NAMES glut)
+
+if (${GLUT} MATCHES "GLUT-NOTFOUND")
+  target_link_libraries(wolff_3potts wolff wolff_examples)
+  target_link_libraries(wolff_4potts wolff wolff_examples)
+  target_link_libraries(wolff_7potts wolff wolff_examples)
+  target_link_libraries(wolff_3clock wolff wolff_examples)
+  target_link_libraries(wolff_5clock wolff wolff_examples)
+else()
+  target_compile_definitions(wolff_3potts PUBLIC HAVE_GLUT)
+  target_compile_definitions(wolff_4potts PUBLIC HAVE_GLUT)
+  target_compile_definitions(wolff_7potts PUBLIC HAVE_GLUT)
+  target_compile_definitions(wolff_3clock PUBLIC HAVE_GLUT)
+  target_compile_definitions(wolff_5clock PUBLIC HAVE_GLUT)
+
+  target_link_libraries(wolff_3potts             wolff wolff_examples glut GL GLU)
+  target_link_libraries(wolff_4potts             wolff wolff_examples glut GL GLU)
+  target_link_libraries(wolff_7potts             wolff wolff_examples glut GL GLU)
+  target_link_libraries(wolff_3clock             wolff wolff_examples glut GL GLU)
+  target_link_libraries(wolff_5clock             wolff wolff_examples glut GL GLU)
+endif()
+
+install(TARGETS wolff_3potts wolff_4potts wolff_7potts wolff_3clock wolff_5clock DESTINATION ${CMAKE_INSTALL_BINDIR})
+
diff --git a/examples/src/models/potts/dihedral.hpp b/examples/src/models/potts/dihedral.hpp
new file mode 100644
index 0000000..cbc5687
--- /dev/null
+++ b/examples/src/models/potts/dihedral.hpp
@@ -0,0 +1,48 @@
+
+#pragma once
+
+#include <wolff/types.h>
+#include "potts.hpp"
+
+template <q_t q>
+class dihedral_t {
+  public:
+    bool is_reflection;
+    q_t x;
+
+    dihedral_t() : is_reflection(false), x(0) {}
+    dihedral_t(bool x, q_t y) : is_reflection(x), x(y) {}
+
+    potts_t<q> act(const potts_t<q>& s) const {
+      if (this->is_reflection) {
+        return potts_t<q>(((q + this->x) - s.x) % q);
+      } else {
+        return potts_t<q>((this->x + s.x) % q);
+      }
+    }
+
+    dihedral_t<q> act(dihedral_t<q> r) const {
+      if (this->is_reflection) {
+        return dihedral_t<q>(!(r.is_reflection), ((q + this->x) - r.x) % q); 
+      } else {
+        return dihedral_t<q>(r.is_reflection, (this->x + r.x) % q);
+      }
+    }
+
+    potts_t<q> act_inverse(potts_t<q> s) const {
+      if (this->is_reflection) {
+        return this->act(s);
+      } else {
+        return potts_t<q>(((s.x + q) - this->x) % q);
+      }
+    }
+
+    dihedral_t<q> act_inverse(dihedral_t<q> r) const {
+      if (this->is_reflection) {
+        return this->act(r);
+      } else {
+        return dihedral_t<q>(r.is_reflection, ((r.x + q) - this->x) % q);
+      }
+    }
+};
+
diff --git a/examples/src/models/potts/potts.hpp b/examples/src/models/potts/potts.hpp
new file mode 100644
index 0000000..f4765e2
--- /dev/null
+++ b/examples/src/models/potts/potts.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cmath>
+#include <stdio.h>
+
+#include <wolff/types.h>
+#include "../On/vector.hpp"
+
+template <q_t q>
+class potts_t {
+  public:
+    q_t x;
+
+    typedef vector_t<q, int> M_t;
+    typedef vector_t<q, double> F_t;
+
+    potts_t() : x(0) {}
+    potts_t(q_t x) : x(x) {}
+
+    inline vector_t<q, int> operator*(v_t a) const {
+      vector_t<q, int> result;
+      result.fill(0);
+      result[x] = (int)a;
+
+      return result;
+    }
+
+    inline vector_t<q, double> operator*(double a) const {
+      vector_t<q, double> result;
+      result.fill(0.0);
+      result[x] = a;
+
+      return result;
+    }
+
+    inline vector_t<q, int> operator-(const potts_t<q> &s) const {
+      vector_t<q, int> result;
+      result.fill(0);
+
+      result[x]++;
+      result[s.x]--;
+
+      return result;
+    }
+};
+
+// we could inherit norm_squared from vector.h, but convention dictates that
+// potts norms be changed by a constant factor
+template <q_t q>
+double norm_squared(vector_t<q, double> s) {
+  double total = 0;
+  for (double& x : s) {
+    total += pow(x, 2);
+  }
+
+  return total * (double)q / ((double)q - 1.0);
+}
+
+// we could inherit write_magnetization from vector.h, but since M.x must sum
+// to nv we don't need to write the last element
+template <q_t q>
+void write_magnetization(vector_t<q, int> M, FILE *outfile) {
+  for (int& x : M) {
+    fwrite(&x, sizeof(int), q - 1, outfile);
+  }
+}
+
+// knock yourself out
+const potts_t<POTTSQ> states[256] = {{0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {11}, {12}, {13}, {14}, {15}, {16}, {17}, {18}, {19}, {20}, {21}, {22}, {23}, {24}, {25}, {26}, {27}, {28}, {29}, {30}, {31}, {32}, {33}, {34}, {35}, {36}, {37}, {38}, {39}, {40}, {41}, {42}, {43}, {44}, {45}, {46}, {47}, {48}, {49}, {50}, {51}, {52}, {53}, {54}, {55}, {56}, {57}, {58}, {59}, {60}, {61}, {62}, {63}, {64}, {65}, {66}, {67}, {68}, {69}, {70}, {71}, {72}, {73}, {74}, {75}, {76}, {77}, {78}, {79}, {80}, {81}, {82}, {83}, {84}, {85}, {86}, {87}, {88}, {89}, {90}, {91}, {92}, {93}, {94}, {95}, {96}, {97}, {98}, {99}, {100}, {101}, {102}, {103}, {104}, {105}, {106}, {107}, {108}, {109}, {110}, {111}, {112}, {113}, {114}, {115}, {116}, {117}, {118}, {119}, {120}, {121}, {122}, {123}, {124}, {125}, {126}, {127}, {128}, {129}, {130}, {131}, {132}, {133}, {134}, {135}, {136}, {137}, {138}, {139}, {140}, {141}, {142}, {143}, {144}, {145}, {146}, {147}, {148}, {149}, {150}, {151}, {152}, {153}, {154}, {155}, {156}, {157}, {158}, {159}, {160}, {161}, {162}, {163}, {164}, {165}, {166}, {167}, {168}, {169}, {170}, {171}, {172}, {173}, {174}, {175}, {176}, {177}, {178}, {179}, {180}, {181}, {182}, {183}, {184}, {185}, {186}, {187}, {188}, {189}, {190}, {191}, {192}, {193}, {194}, {195}, {196}, {197}, {198}, {199}, {200}, {201}, {202}, {203}, {204}, {205}, {206}, {207}, {208}, {209}, {210}, {211}, {212}, {213}, {214}, {215}, {216}, {217}, {218}, {219}, {220}, {221}, {222}, {223}, {224}, {225}, {226}, {227}, {228}, {229}, {230}, {231}, {232}, {233}, {234}, {235}, {236}, {237}, {238}, {239}, {240}, {241}, {242}, {243}, {244}, {245}, {246}, {247}, {248}, {249}, {250}, {251}, {252}, {253}, {254}, {255}};
+template <q_t q>
+q_t state_to_ind(potts_t<q> state) { return (q_t)state.x; }
+
diff --git a/examples/src/models/potts/symmetric.hpp b/examples/src/models/potts/symmetric.hpp
new file mode 100644
index 0000000..8636f15
--- /dev/null
+++ b/examples/src/models/potts/symmetric.hpp
@@ -0,0 +1,51 @@
+
+#pragma once
+
+#include <stdlib.h>
+#include <array>
+#include <wolff/types.h>
+#include "potts.hpp"
+
+template <q_t q>
+class symmetric_t : public std::array<q_t, q> {
+  public:
+
+    symmetric_t() {
+      for (q_t i = 0; i < q; i++) {
+        (*this)[i] = i;
+      }
+    }
+
+    potts_t<q> act(const potts_t<q> &s) const {
+      return potts_t<q>((*this)[s.x]);
+    }
+
+    symmetric_t<q> act(const symmetric_t<q>& r) const {
+      symmetric_t<q> r_rot;
+      for (q_t i = 0; i < q; i++) {
+        r_rot[i] = (*this)[r[i]];
+      }
+
+      return r_rot;
+    }
+
+    potts_t<q> act_inverse(const potts_t<q>& s) const {
+      for (q_t i = 0; i < q; i++) {
+        if ((*this)[i] == s.x) {
+          return potts_t<q>(i);
+        }
+      }
+
+      exit(EXIT_FAILURE);
+    }
+
+    symmetric_t<q> act_inverse(const symmetric_t<q>& r) const {
+      symmetric_t<q> r_rot;
+      for (q_t i = 0; i < q; i++) {
+        r_rot[(*this)[i]] = r[i];
+      }
+
+      return r_rot;
+    }
+};
+
diff --git a/examples/src/models/potts/wolff_clock.cpp b/examples/src/models/potts/wolff_clock.cpp
new file mode 100644
index 0000000..020415d
--- /dev/null
+++ b/examples/src/models/potts/wolff_clock.cpp
@@ -0,0 +1,155 @@
+
+#include <getopt.h>
+
+#ifdef HAVE_GLUT
+#include <GL/glut.h>
+#endif
+
+// include your group and spin space
+#include "dihedral.hpp"
+#include "potts.hpp"
+#include <colors.h>
+
+// hack to speed things up considerably
+#define N_STATES POTTSQ
+#include <wolff/finite_states.hpp>
+
+#include <randutils/randutils.hpp>
+
+// include wolff.hpp
+#include <wolff.hpp>
+
+typedef state_t <dihedral_t<POTTSQ>, potts_t<POTTSQ>> sim_t;
+
+int main(int argc, char *argv[]) {
+
+  count_t N = (count_t)1e4;
+
+  D_t D = 2;
+  L_t L = 128;
+  double T = 2.26918531421;
+  double *H_vec = (double *)calloc(MAX_Q, sizeof(double));
+
+  bool silent = false;
+  bool draw = false;
+  unsigned int window_size = 512;
+
+  int opt;
+  q_t H_ind = 0;
+
+  while ((opt = getopt(argc, argv, "N:D:L:T:H:sdw:")) != -1) {
+    switch (opt) {
+    case 'N': // number of steps
+      N = (count_t)atof(optarg);
+      break;
+    case 'D': // dimension
+      D = atoi(optarg);
+      break;
+    case 'L': // linear size
+      L = atoi(optarg);
+      break;
+    case 'T': // temperature 
+      T = atof(optarg);
+      break;
+    case 'H': // external field. nth call couples to state n
+      H_vec[H_ind] = atof(optarg);
+      H_ind++;
+      break;
+    case 's': // don't print anything during simulation. speeds up slightly
+      silent = true;
+      break;
+    case 'd':
+#ifdef HAVE_GLUT
+      draw = true;
+      break;
+#else
+      printf("You didn't compile this with the glut library installed!\n");
+      exit(EXIT_FAILURE);
+#endif
+    case 'w':
+      window_size = atoi(optarg);
+      break;
+    default:
+      exit(EXIT_FAILURE);
+    }
+  }
+
+  // initialize random number generator
+  randutils::auto_seed_128 seeds;
+  std::mt19937 rng{seeds};
+
+  // define spin-spin coupling
+  std::function <double(const potts_t<POTTSQ>&, const potts_t<POTTSQ>&)> Z = [] (const potts_t<POTTSQ>& s1, const potts_t<POTTSQ>& s2) -> double {
+    return cos(2 * M_PI * (double)(s1.x + POTTSQ - s2.x) / (double)POTTSQ);
+  };
+
+  // define spin-field coupling
+  std::function <double(const potts_t<POTTSQ>&)> B = [=] (const potts_t<POTTSQ>& s) -> double {
+    return H_vec[s.x];
+  };
+
+  // initialize state object
+  state_t <dihedral_t<POTTSQ>, potts_t<POTTSQ>> s(D, L, T, Z, B);
+
+  // define function that generates self-inverse rotations
+  std::function <dihedral_t<POTTSQ>(std::mt19937&, potts_t<POTTSQ>)> gen_R = [] (std::mt19937& r, potts_t<POTTSQ> v) -> dihedral_t<POTTSQ> {
+    dihedral_t<POTTSQ> rot;
+    rot.is_reflection = true;
+    std::uniform_int_distribution<q_t> dist(0, POTTSQ - 1);
+    q_t x = dist(r);
+    rot.x = (2 * v.x + x + 1) % POTTSQ;
+
+    return rot;
+  };
+
+  // define function that updates any number of measurements
+  std::function <void(const sim_t&)> measurement;
+
+  double average_M = 0;
+  if (!draw) {
+    // a very simple example: measure the average magnetization
+    measurement = [&] (const sim_t& s) {
+      average_M += (double)s.M[0] / (double)N / (double)s.nv;
+    };
+  } else {
+    // a more complex example: measure the average magnetization, and draw the spin configuration to the screen
+
+#ifdef HAVE_GLUT
+    // initialize glut
+    glutInit(&argc, argv);
+    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
+    glutInitWindowSize(window_size, window_size);
+    glutCreateWindow("wolff");
+    glClearColor(0.0,0.0,0.0,0.0);
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
+    gluOrtho2D(0.0, L, 0.0, L);
+
+    measurement = [&] (const sim_t& s) {
+      average_M += (double)s.M[0] / (double)N / (double)s.nv;
+      glClear(GL_COLOR_BUFFER_BIT);
+      for (v_t i = 0; i < pow(L, 2); i++) {
+        potts_t<POTTSQ> tmp_s = s.R.act_inverse(s.spins[i]);
+        glColor3f(hue_to_R(tmp_s.x * 2 * M_PI / POTTSQ), hue_to_G(tmp_s.x * 2 * M_PI / POTTSQ), hue_to_B(tmp_s.x * 2 * M_PI / POTTSQ));
+        glRecti(i / L, i % L, (i / L) + 1, (i % L) + 1);
+      }
+      glFlush();
+    };
+#endif
+  }
+
+  // run wolff for N cluster flips
+  wolff(N, s, gen_R, measurement, rng, silent);
+
+  // tell us what we found!
+  printf("%" PRIcount " %d-Potts runs completed. D = %" PRID ", L = %" PRIL ", T = %g, H = %g, <M> = %g\n", N, POTTSQ, D, L, T, H_vec[0], average_M);
+
+  // free the random number generator
+
+  if (draw) {
+  }
+
+  return 0;
+
+}
+
diff --git a/examples/src/models/potts/wolff_potts.cpp b/examples/src/models/potts/wolff_potts.cpp
new file mode 100644
index 0000000..a1e9284
--- /dev/null
+++ b/examples/src/models/potts/wolff_potts.cpp
@@ -0,0 +1,213 @@
+
+#include <getopt.h>
+#include <stdio.h>
+
+#ifdef HAVE_GLUT
+#include <GL/glut.h>
+#endif
+
+// include your group and spin space
+#include "symmetric.hpp"
+#include "potts.hpp"
+
+// hack to speed things up considerably
+#define N_STATES POTTSQ
+#include <wolff/finite_states.hpp>
+
+// include wolff.h
+#include <measure.hpp>
+#include <colors.h>
+#include <randutils/randutils.hpp>
+#include <wolff.hpp>
+
+typedef state_t <symmetric_t<POTTSQ>, potts_t<POTTSQ>> sim_t;
+
+int main(int argc, char *argv[]) {
+
+  count_t N = (count_t)1e4;
+
+  D_t D = 2;
+  L_t L = 128;
+  double T = 2.26918531421;
+  double *H_vec = (double *)calloc(MAX_Q, sizeof(double));
+
+  bool silent = false;
+  bool draw = false;
+  bool N_is_sweeps = false;
+  unsigned int window_size = 512;
+
+  // don't measure anything by default
+  unsigned char measurement_flags = 0;
+
+  int opt;
+  q_t H_ind = 0;
+
+  while ((opt = getopt(argc, argv, "N:D:L:T:H:sdw:M:S")) != -1) {
+    switch (opt) {
+    case 'N': // number of steps
+      N = (count_t)atof(optarg);
+      break;
+    case 'D': // dimension
+      D = atoi(optarg);
+      break;
+    case 'L': // linear size
+      L = atoi(optarg);
+      break;
+    case 'T': // temperature 
+      T = atof(optarg);
+      break;
+    case 'H': // external field. nth call couples to state n
+      H_vec[H_ind] = atof(optarg);
+      H_ind++;
+      break;
+    case 's': // don't print anything during simulation. speeds up slightly
+      silent = true;
+      break;
+    case 'S':
+      N_is_sweeps = true;
+      break;
+    case 'd':
+#ifdef HAVE_GLUT
+      draw = true;
+      break;
+#else
+      printf("You didn't compile this with the glut library installed!\n");
+      exit(EXIT_FAILURE);
+#endif
+    case 'w':
+      window_size = atoi(optarg);
+      break;
+    case 'M':
+      measurement_flags ^= 1 << atoi(optarg);
+      break;
+    default:
+      exit(EXIT_FAILURE);
+    }
+  }
+
+  // get nanosecond timestamp for unique run id
+  unsigned long timestamp;
+
+  {
+    struct timespec spec;
+    clock_gettime(CLOCK_REALTIME, &spec);
+    timestamp = spec.tv_sec*1000000000LL + spec.tv_nsec;
+  }
+
+  // initialize random number generator
+  randutils::auto_seed_128 seeds;
+  std::mt19937 rng{seeds};
+
+  // define spin-spin coupling
+  std::function <double(const potts_t<POTTSQ>&, const potts_t<POTTSQ>&)> Z = [] (const potts_t<POTTSQ>& s1, const potts_t<POTTSQ>& s2) -> double {
+    if (s1.x == s2.x) {
+      return 1.0;
+    } else {
+      return 0.0;
+    }
+  };
+
+  // define spin-field coupling
+  std::function <double(const potts_t<POTTSQ> &)> B = [=] (const potts_t<POTTSQ>& s) -> double {
+    return H_vec[s.x];
+  };
+
+  // initialize state object
+  state_t <symmetric_t<POTTSQ>, potts_t<POTTSQ>> s(D, L, T, Z, B);
+
+  // define function that generates self-inverse rotations
+  std::function <symmetric_t<POTTSQ>(std::mt19937&, potts_t<POTTSQ>)> gen_R = [] (std::mt19937& r, potts_t<POTTSQ> v) -> symmetric_t<POTTSQ> {
+    symmetric_t<POTTSQ> rot;
+
+    std::uniform_int_distribution<q_t> dist(0, POTTSQ - 1);
+    q_t j = dist(r);
+    q_t swap_v;
+    if (j < v.x) {
+      swap_v = j;
+    } else {
+      swap_v = j + 1;
+    }
+
+    rot[v.x] = swap_v;
+    rot[swap_v] = v.x;
+
+    return rot;
+  };
+
+  FILE **outfiles = measure_setup_files(measurement_flags, timestamp);
+
+  std::function <void(const sim_t&)> other_f;
+  uint64_t sum_of_clusterSize = 0;
+
+  if (N_is_sweeps) {
+    other_f = [&] (const sim_t& s) {
+      sum_of_clusterSize += s.last_cluster_size;
+    };
+  } else if (draw) {
+#ifdef HAVE_GLUT
+    // initialize glut
+    glutInit(&argc, argv);
+    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
+    glutInitWindowSize(window_size, window_size);
+    glutCreateWindow("wolff");
+    glClearColor(0.0,0.0,0.0,0.0);
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
+    gluOrtho2D(0.0, L, 0.0, L);
+
+    other_f = [] (const sim_t& s) {
+      glClear(GL_COLOR_BUFFER_BIT);
+      for (v_t i = 0; i < pow(s.L, 2); i++) {
+        potts_t<POTTSQ> tmp_s = s.R.act_inverse(s.spins[i]);
+        glColor3f(hue_to_R(tmp_s.x * 2 * M_PI / POTTSQ), hue_to_G(tmp_s.x * 2 * M_PI / POTTSQ), hue_to_B(tmp_s.x * 2 * M_PI / POTTSQ));
+        glRecti(i / s.L, i % s.L, (i / s.L) + 1, (i % s.L) + 1);
+      }
+      glFlush();
+    };
+#endif
+  } else {
+    other_f = [] (const sim_t& s) {};
+  }
+
+  std::function <void(const sim_t&)> measurements = measure_function_write_files(measurement_flags, outfiles, other_f);
+
+  // add line to metadata file with run info
+  {
+    FILE *outfile_info = fopen("wolff_metadata.txt", "a");
+
+    fprintf(outfile_info, "<| \"ID\" -> %lu, \"MODEL\" -> \"POTTS\", \"q\" -> %d, \"D\" -> %" PRID ", \"L\" -> %" PRIL ", \"NV\" -> %" PRIv ", \"NE\" -> %" PRIv ", \"T\" -> %.15f, \"H\" -> {", timestamp, POTTSQ, s.D, s.L, s.nv, s.ne, T);
+
+    for (q_t i = 0; i < POTTSQ; i++) {
+      fprintf(outfile_info, "%.15f", H_vec[i]);
+      if (i < POTTSQ - 1) {
+        fprintf(outfile_info, ", ");
+      }
+    }
+
+    fprintf(outfile_info, "} |>\n");
+
+    fclose(outfile_info);
+  }
+
+  // run wolff for N cluster flips
+  if (N_is_sweeps) {
+    count_t N_rounds = 0;
+    printf("\n");
+    while (sum_of_clusterSize < N * s.nv) {
+      printf("\033[F\033[J\033[F\033[JWOLFF: sweep %" PRIu64 " / %" PRIu64 ": E = %.2f, S = %" PRIv "\n", (count_t)((double)sum_of_clusterSize / (double)s.nv), N, s.E, s.last_cluster_size);
+      wolff(N, s, gen_R, measurements, rng, silent);
+      N_rounds++;
+    }
+    printf("\033[F\033[J\033[F\033[JWOLFF: sweep %" PRIu64 " / %" PRIu64 ": E = %.2f, S = %" PRIv "\n\n", (count_t)((double)sum_of_clusterSize / (double)s.nv), N, s.E, s.last_cluster_size);
+  } else {
+    wolff(N, s, gen_R, measurements, rng, silent);
+  }
+
+  // free the random number generator
+  free(H_vec);
+  measure_free_files(measurement_flags, outfiles);
+
+  return 0;
+
+}
+