Mesa implementation of Ising Model

examples/ising/README.md

@@ -0,0 +1,25 @@
+# Ising Model
+
+## Summary
+
+The Ising model (or Lenz–Ising model), named after the physicists Ernst Ising and Wilhelm Lenz, is a mathematical model of ferromagnetism in statistical mechanics. The model consists of discrete variables that represent magnetic dipole moments of atomic "spins" that can be in one of two states (+1 or −1). The spins are arranged in a graph, usually a lattice (where the local structure repeats periodically in all directions), allowing each spin to interact with its neighbors. Neighboring spins that agree have a lower energy than those that disagree; the system tends to the lowest energy but heat disturbs this tendency, thus creating the possibility of different structural phases. The model allows the identification of phase transitions as a simplified model of reality. The two-dimensional square-lattice Ising model is one of the simplest statistical models to show a phase transition.
+
+## How to Run
+
+To run the model interactively, run ``solara run run.py`` in this directory. e.g.
+
+Then open your browser to [http://127.0.0.1:8521/](http://127.0.0.1:8521/) and press ``run``.
+
+## Things to Try
+
+What happens when the temperature slider is very high? (This is called the "paramagnetic" state.) Try this with different **Spin Up Probability** values.
+
+What happens when the temperature slider is set very low? (This is called the "ferromagnetic" state.) Again, try this with different **Spin Up Probability** values.
+
+Between these two very different behaviors is a transition point. On an infinite grid, the transition point can be proved to be $2 / ln (1 + sqrt 2)$, which is about 2.27. On a large enough finite toroidal grid, the transition point is near this number.
+
+## References
+
+(NetLogo Ising)[https://ccl.northwestern.edu/netlogo/models/Ising]
+
+(Introduction to Monte Carlo methods for an Ising Model of a Ferromagnet)[https://arxiv.org/pdf/0803.0217]

examples/ising/ising/model.py

@@ -0,0 +1,47 @@
+import mesa
+import numpy as np
+
+from .spin import Spin
+
+
+class IsingModel(mesa.Model):
+    def __init__(
+        self,
+        width=50,
+        height=50,
+        spin_up_probability: float = 0.7,
+        temperature: float = 1,
+    ):
+        super().__init__()
+        self.temperature = temperature
+        self.grid = mesa.space.SingleGrid(width, height, torus=True)
+
+        for contents, (x, y) in self.grid.coord_iter():
+            cell = Spin((x, y), self, Spin.DOWN)
+            if self.random.random() < spin_up_probability:
+                cell.state = cell.UP
+            self.grid.place_agent(cell, (x, y))
+
+        self.running = True
+
+    def step(self):
+        agents_list = list(self.agents)
+        self._steps += 1000
+        for i in range(1000):
+            random_spin = self.random.choice(agents_list)
+            dE = self.get_energy_change(random_spin)
+            if dE < 0:
+                random_spin.state *= -1
+            else:
+                if self.random.random() < self.boltzmann_factor(dE):
+                    random_spin.state *= -1
+
+    def get_energy_change(self, spin: Spin):
+        neighbors = spin.neighbors()
+        sum_over_neighbors = 0
+        for neighbor in neighbors:
+            sum_over_neighbors += neighbor.state
+        return sum_over_neighbors * 2 * spin.state
+
+    def boltzmann_factor(self, dE):
+        return np.exp(-dE / self.temperature)

examples/ising/ising/portrayal.py

@@ -0,0 +1,15 @@
+def portray_spin(spin):
+    """
+    This function is registered with the visualization server to be called
+    each tick to indicate how to draw the cell in its current state.
+    :param cell:  the cell in the simulation
+    :return: the portrayal dictionary.
+    """
+    if spin is None:
+        raise AssertionError
+    return {
+        "marker": "s",
+        "x": spin.x,
+        "y": spin.y,
+        "color": "grey" if spin.state is spin.UP else "black",
+    }

examples/ising/ising/spin.py

@@ -0,0 +1,19 @@
+import mesa
+
+
+class Spin(mesa.Agent):
+    """Represents a single ALIVE or DEAD cell in the simulation."""
+
+    UP = 1
+    DOWN = -1
+
+    def __init__(self, pos, model, init_state):
+        """
+        Create a cell, in the given state, at the given x, y position.
+        """
+        super().__init__(pos, model)
+        self.x, self.y = pos
+        self.state = init_state
+
+    def neighbors(self):
+        return self.model.grid.iter_neighbors((self.x, self.y), True)

examples/ising/run.py

@@ -0,0 +1,28 @@
+import solara
+from ising.model import IsingModel
+from ising.portrayal import portray_spin
+from mesa.visualization import JupyterViz
+from mesa.visualization.UserParam import Slider
+
+model_params = {
+    "temperature": Slider(
+        label="Temperature", value=2, min=0.01, max=10, step=0.06, dtype=float
+    ),
+    "spin_up_probability": Slider(
+        label="Spin Up Probability",
+        value=0.5,
+        min=0,
+        max=1,
+        step=0.05,
+    ),
+}
+
+
+@solara.component
+def Page():
+    JupyterViz(
+        IsingModel,
+        model_params,
+        name="Ising Model",
+        agent_portrayal=portray_spin,
+    )