kmclab 0.1.4__py3-none-any.whl → 0.1.5__py3-none-any.whl

kmclab/__init__.py

@@ -1,5 +1,5 @@
-from .hex import hex_kmc
+from .hexa import hexa_kmc
 from .square import square_kmc
 
-__all__ = ["hex_kmc", "square_kmc"]
-__version__ = "0.1.0"
+__all__ = ["hexa_kmc", "square_kmc"]
+__version__ = "0.1.0"

kmclab/{hex.py → hexa.py}

@@ -1,4 +1,4 @@
-from __future__ import annotations       
+from __future__ import annotations
 import numpy as np
 from matplotlib.animation import FuncAnimation, PillowWriter
 import matplotlib.cm as cm
@@ -6,98 +6,131 @@ from numpy.polynomial.polynomial import Polynomial
 import matplotlib.pyplot as plt
 import matplotlib.patches as patches
 from scipy.stats import linregress
+        
 
-
-class hex_kmc:
+class hexa_kmc:
     
-    def __init__(self, n_atoms, n_defects, n_adsorbates, lattice_size, n_steps, defect_type = 1, adsorbates_freq = -1,  seed=1):
+    def __init__(self, n_atoms, n_defects, n_adsorbates, lattice_size, 
+                 T= 300, 
+                 defect_type = 1,
+                 k_0=1,
+                 seed=1, 
+                 len_vertical = 0.38e-3,
+                 len_horizontal = 0.51e-3,
+                 adsorbates_freq = -1,
+                 energy_barrier_north = 0.46,
+                 energy_barrier_south = 0.46,
+                 energy_barrier_northeast = 0.65,
+                 energy_barrier_northwest = 0.65,
+                 energy_barrier_southeast = 0.65,
+                 energy_barrier_southwest = 0.65,
+                 energy_barrier_trapping_defect_north = 1.2,
+                 energy_barrier_trapping_defect_south = 1.2,
+                 energy_barrier_trapping_defect_east = 1.1,
+                 energy_barrier_trapping_defect_west = 1.1,       
+                 energy_barrier_trapping_defect_northeast = 1.1,
+                 energy_barrier_trapping_defect_northwest = 1.1,
+                 energy_barrier_trapping_defect_southeast = 1.1,
+                 energy_barrier_trapping_defect_southwest = 1.1,
+                 energy_barrier_blocking_defect_north = 1.2,
+                 energy_barrier_blocking_defect_south = 1.2,    
+                 energy_barrier_blocking_defect_northeast = 1.2,
+                 energy_barrier_blocking_defect_northwest = 1.2,
+                 energy_barrier_blocking_defect_southeast = 1.2,
+                 energy_barrier_blocking_defect_southwest = 1.2,
+                 energy_barrier_adsorbate_north = 0.72,
+                 energy_barrier_adsorbate_south = 0.72, 
+                 energy_barrier_adsorbate_northeast = 0.72,        
+                 energy_barrier_adsorbate_northwest = 0.72,
+                 energy_barrier_adsorbate_southeast = 0.72,
+                 energy_barrier_adsorbate_southwest = 0.72,                   
+                 ):
+        
         
         np.random.seed(seed)    
-        # what is you desired coverage= n_atom/lattice * lattice
         self.n_atoms = n_atoms  # Number of atoms
-        self.n_defects = n_defects
-        self.n_adsorbates= n_adsorbates
+        self.n_defects = n_defects # Number of defects
+        self.n_adsorbates= n_adsorbates  # Number of adsorbates
         self.lattice_size = lattice_size  # Lattice size
-        self.n_steps = n_steps # Number of steps
-        self.defect_type = defect_type
-        self.adsorbates_freq = adsorbates_freq
-  
-        T = 300  # Temperature in Kelvin
+        self.T = T  # Temperature in Kelvin
+        self.defect_type = defect_type   # blocking = 2 , trapping = 1
+        self.k_0 = k_0
+        self.len_vertical = len_horizontal 
+        self.len_horizontal = len_horizontal 
+        self.adsorbates_freq = adsorbates_freq    
         k_B = 8.617e-5  # Boltzmann constant in eV/K
-        k_0 = 1
         h = 4.1357e-15  #Planck Constant (eV.s)
-        self.len_vertical = 0.38e-3 # in micrometer
-        self.len_horizontal = 0.51e-3 # in micrometer
-    
+
 
         # DFT calculated vaues for diffusion on the stoichiometric surface in different directions (eV)
-        energy_barrier_north = 0.46
-        energy_barrier_south = 0.46
-        energy_barrier_northeast = 0.65
-        energy_barrier_northwest = 0.65
-        energy_barrier_southeast = 0.65
-        energy_barrier_southwest = 0.65
+        self.energy_barrier_north = energy_barrier_north
+        self.energy_barrier_south = energy_barrier_south
+        self.energy_barrier_northeast = energy_barrier_northeast
+        self.energy_barrier_northwest = energy_barrier_northwest
+        self.energy_barrier_southeast = energy_barrier_southeast
+        self.energy_barrier_southwest = energy_barrier_southwest
 
 
         # DFT calculated vaues for diffusion out of trapping deffect in different directions (eV)
-        energy_barrier_trapping_defect_north = 1.2
-        energy_barrier_trapping_defect_south = 1.2
-        energy_barrier_trapping_defect_east = 1.1
-        energy_barrier_trapping_defect_west = 1.1       
-        energy_barrier_trapping_defect_northeast = 1.1
-        energy_barrier_trapping_defect_northwest = 1.1
-        energy_barrier_trapping_defect_southeast = 1.1
-        energy_barrier_trapping_defect_southwest = 1.1
+        self.energy_barrier_trapping_defect_north = energy_barrier_trapping_defect_north
+        self.energy_barrier_trapping_defect_south = energy_barrier_trapping_defect_south
+        self.energy_barrier_trapping_defect_east = energy_barrier_trapping_defect_east
+        self.energy_barrier_trapping_defect_west = energy_barrier_trapping_defect_west       
+        self.energy_barrier_trapping_defect_northeast = energy_barrier_trapping_defect_northeast
+        self.energy_barrier_trapping_defect_northwest = energy_barrier_trapping_defect_northwest
+        self.energy_barrier_trapping_defect_southeast = energy_barrier_trapping_defect_southeast
+        self.energy_barrier_trapping_defect_southwest = energy_barrier_trapping_defect_southwest
 
         
         # DFT calculated vaues for diffusion over a blocking deffect in different directions (eV)
-        energy_barrier_blocking_defect_north = 1.2
-        energy_barrier_blocking_defect_south = 1.2    
-        energy_barrier_blocking_defect_northeast = 1.2
-        energy_barrier_blocking_defect_northwest = 1.2
-        energy_barrier_blocking_defect_southeast = 1.2
-        energy_barrier_blocking_defect_southwest = 1.2
+        self.energy_barrier_blocking_defect_north = energy_barrier_blocking_defect_north
+        self.energy_barrier_blocking_defect_south = energy_barrier_blocking_defect_south 
+        self.energy_barrier_blocking_defect_northeast = energy_barrier_blocking_defect_northeast
+        self.energy_barrier_blocking_defect_northwest = energy_barrier_blocking_defect_northwest
+        self.energy_barrier_blocking_defect_southeast = energy_barrier_blocking_defect_southeast
+        self.energy_barrier_blocking_defect_southwest = energy_barrier_blocking_defect_southwest
+        
         # DFT calculated vaues for diffusion over an adsorbate in different directions (eV)
         
-        energy_barrier_adsorbate_north = 0.72
-        energy_barrier_adsorbate_south = 0.72 
-        energy_barrier_adsorbate_northeast = 0.72        
-        energy_barrier_adsorbate_northwest = 0.72
-        energy_barrier_adsorbate_southeast = 0.72
-        energy_barrier_adsorbate_southwest = 0.72        
+        self.energy_barrier_adsorbate_north = energy_barrier_adsorbate_north
+        self.energy_barrier_adsorbate_south = energy_barrier_adsorbate_south 
+        self.energy_barrier_adsorbate_northeast = energy_barrier_adsorbate_northeast        
+        self.energy_barrier_adsorbate_northwest = energy_barrier_adsorbate_northwest
+        self.energy_barrier_adsorbate_southeast = energy_barrier_adsorbate_southeast
+        self.energy_barrier_adsorbate_southwest = energy_barrier_adsorbate_southwest       
         
                       
         # Calculate rate constants
-        rate_north = k_0 * ((k_B * T)/h) * np.exp(-energy_barrier_north / (k_B * T))
-        rate_south = k_0 * ((k_B * T)/h) * np.exp(-energy_barrier_south / (k_B * T))
-        rate_northeast = k_0 * ((k_B * T)/h) * np.exp(-energy_barrier_northeast / (k_B * T))
-        rate_northwest = k_0 * ((k_B * T)/h) * np.exp(-energy_barrier_northwest / (k_B * T))
-        rate_southeast = k_0 * ((k_B * T)/h) * np.exp(-energy_barrier_southeast / (k_B * T))
-        rate_southwest = k_0 * ((k_B * T)/h) * np.exp(-energy_barrier_southwest / (k_B * T))
+        rate_north = self.k_0 * ((k_B * self.T)/h) * np.exp(-self.energy_barrier_north / (k_B * self.T))
+        rate_south = self.k_0 * ((k_B * self.T)/h) * np.exp(-self.energy_barrier_south / (k_B * self.T))
+        rate_northeast = self.k_0 * ((k_B * self.T)/h) * np.exp(-self.energy_barrier_northeast / (k_B * self.T))
+        rate_northwest = self.k_0 * ((k_B * self.T)/h) * np.exp(-self.energy_barrier_northwest / (k_B * self.T))
+        rate_southeast = self.k_0 * ((k_B * self.T)/h) * np.exp(-self.energy_barrier_southeast / (k_B * self.T))
+        rate_southwest = self.k_0 * ((k_B * self.T)/h) * np.exp(-self.energy_barrier_southwest / (k_B * self.T))
         
-        rate_trapping_defect_north = k_0 * ((k_B * T)/h) * np.exp(-energy_barrier_trapping_defect_north / (k_B * T))
-        rate_trapping_defect_south = k_0 * ((k_B * T)/h) * np.exp(-energy_barrier_trapping_defect_south / (k_B * T))
-        rate_trapping_defect_east = k_0 * ((k_B * T)/h) * np.exp(-energy_barrier_trapping_defect_east / (k_B * T))
-        rate_trapping_defect_west = k_0 * ((k_B * T)/h) * np.exp(-energy_barrier_trapping_defect_west / (k_B * T))
-        rate_trapping_defect_northeast = k_0 * ((k_B * T)/h) * np.exp(-energy_barrier_trapping_defect_northeast / (k_B * T))
-        rate_trapping_defect_northwest = k_0 * ((k_B * T)/h) * np.exp(-energy_barrier_trapping_defect_northwest / (k_B * T))
-        rate_trapping_defect_southeast = k_0 * ((k_B * T)/h) * np.exp(-energy_barrier_trapping_defect_southeast / (k_B * T))
-        rate_trapping_defect_southwest = k_0 * ((k_B * T)/h) * np.exp(-energy_barrier_trapping_defect_southwest / (k_B * T))
+        rate_trapping_defect_north = self.k_0 * ((k_B * self.T)/h) * np.exp(-self.energy_barrier_trapping_defect_north / (k_B * self.T))
+        rate_trapping_defect_south = self.k_0 * ((k_B * self.T)/h) * np.exp(-self.energy_barrier_trapping_defect_south / (k_B * self.T))
+        rate_trapping_defect_east = self.k_0 * ((k_B * self.T)/h) * np.exp(-self.energy_barrier_trapping_defect_east / (k_B * self.T))
+        rate_trapping_defect_west = self.k_0 * ((k_B * self.T)/h) * np.exp(-self.energy_barrier_trapping_defect_west / (k_B * self.T))
+        rate_trapping_defect_northeast = self.k_0 * ((k_B * self.T)/h) * np.exp(-self.energy_barrier_trapping_defect_northeast / (k_B * self.T))
+        rate_trapping_defect_northwest = self.k_0 * ((k_B * self.T)/h) * np.exp(-self.energy_barrier_trapping_defect_northwest / (k_B * self.T))
+        rate_trapping_defect_southeast = self.k_0 * ((k_B * self.T)/h) * np.exp(-self.energy_barrier_trapping_defect_southeast / (k_B *self.T))
+        rate_trapping_defect_southwest = self.k_0 * ((k_B * self.T)/h) * np.exp(-self.energy_barrier_trapping_defect_southwest / (k_B * self.T))
        
    
-        rate_blocking_defect_north = k_0 * ((k_B * T)/h) * np.exp(-energy_barrier_blocking_defect_north / (k_B * T))
-        rate_blocking_defect_south = k_0 * ((k_B * T)/h) * np.exp(-energy_barrier_blocking_defect_south / (k_B * T))
-        rate_blocking_defect_northeast = k_0 * ((k_B * T)/h) * np.exp(-energy_barrier_blocking_defect_northeast / (k_B * T))
-        rate_blocking_defect_northwest = k_0 * ((k_B * T)/h) * np.exp(-energy_barrier_blocking_defect_northwest / (k_B * T))
-        rate_blocking_defect_southeast = k_0 * ((k_B * T)/h) * np.exp(-energy_barrier_blocking_defect_southeast / (k_B * T))
-        rate_blocking_defect_southwest = k_0 * ((k_B * T)/h) * np.exp(-energy_barrier_blocking_defect_southwest / (k_B * T))
+        rate_blocking_defect_north = self.k_0 * ((k_B * self.T)/h) * np.exp(-self.energy_barrier_blocking_defect_north / (k_B * self.T))
+        rate_blocking_defect_south = self.k_0 * ((k_B * self.T)/h) * np.exp(-self.energy_barrier_blocking_defect_south / (k_B * self.T))
+        rate_blocking_defect_northeast = self.k_0 * ((k_B * self.T)/h) * np.exp(-self.energy_barrier_blocking_defect_northeast / (k_B * self.T))
+        rate_blocking_defect_northwest = self.k_0 * ((k_B * self.T)/h) * np.exp(-self.energy_barrier_blocking_defect_northwest / (k_B * self.T))
+        rate_blocking_defect_southeast = self.k_0 * ((k_B * self.T)/h) * np.exp(-self.energy_barrier_blocking_defect_southeast / (k_B * self.T))
+        rate_blocking_defect_southwest = self.k_0 * ((k_B * self.T)/h) * np.exp(-self.energy_barrier_blocking_defect_southwest / (k_B * self.T))
        
-        rate_adsorbate_north = k_0 * ((k_B * T)/h) * np.exp(-energy_barrier_adsorbate_north / (k_B * T))
-        rate_adsorbate_south = k_0 * ((k_B * T)/h) * np.exp(-energy_barrier_adsorbate_south / (k_B * T))         
-        rate_adsorbate_northeast = k_0 * ((k_B * T)/h) * np.exp(-energy_barrier_adsorbate_northeast / (k_B * T))
-        rate_adsorbate_northwest = k_0 * ((k_B * T)/h) * np.exp(-energy_barrier_adsorbate_northwest / (k_B * T))
-        rate_adsorbate_southeast = k_0 * ((k_B * T)/h) * np.exp(-energy_barrier_adsorbate_southeast / (k_B * T))
-        rate_adsorbate_southwest = k_0 * ((k_B * T)/h) * np.exp(-energy_barrier_adsorbate_southwest / (k_B * T))
+        rate_adsorbate_north = self.k_0 * ((k_B * self.T)/h) * np.exp(-self.energy_barrier_adsorbate_north / (k_B * self.T))
+        rate_adsorbate_south = self.k_0 * ((k_B * self.T)/h) * np.exp(-self.energy_barrier_adsorbate_south / (k_B * self.T))         
+        rate_adsorbate_northeast = self.k_0 * ((k_B * self.T)/h) * np.exp(-self.energy_barrier_adsorbate_northeast / (k_B * self.T))
+        rate_adsorbate_northwest = self.k_0 * ((k_B * self.T)/h) * np.exp(-self.energy_barrier_adsorbate_northwest / (k_B * self.T))
+        rate_adsorbate_southeast = self.k_0 * ((k_B * self.T)/h) * np.exp(-self.energy_barrier_adsorbate_southeast / (k_B * self.T))
+        rate_adsorbate_southwest = self.k_0 * ((k_B * self.T)/h) * np.exp(-self.energy_barrier_adsorbate_southwest / (k_B * self.T))
        
   
         self.moves = {
@@ -156,8 +189,10 @@ class hex_kmc:
         
         self.generate_adsorbates()
         
-    def run(self):
+    def run(self, n_steps):
+        
         
+        self.n_steps = n_steps 
         self.time = np.zeros(self.n_steps + 1)
         self.msd = np.zeros(self.n_steps)
         self.md = np.zeros(self.n_steps)
@@ -267,8 +302,7 @@ class hex_kmc:
                                         total_rate += list(self.move_rates_trapping_defects.values())[dir_idx]
                                         possible_moves.append((atom_idx, dir_idx, list(self.move_rates_trapping_defects.values())[dir_idx], (new_x, new_y), dx, dy))
                                             
-                                                        
-    
+                   
                      
                     else:     
                     
@@ -570,11 +604,11 @@ class hex_kmc:
                 raise ValueError(f"n_defects ({n_defects}) is too large for lattice_size={lattice_size}!")
 
             if n_defects == 0:  
-                return np.empty((0, 2), dtype=int)  # Return an empty 2D array when no vacancies are needed
+                return np.empty((0, 2), dtype=int) 
 
             positions_base_defects = set()
             attempts = 0
-            max_attempts = 20000  # Allow more attempts to fit more vacancies
+            max_attempts = 20000  
             
             y_values_even = np.arange(0, lattice_size -1, 1)
             y_values_odd = np.arange(0.5, lattice_size - 0.5, 1)
@@ -599,10 +633,8 @@ class hex_kmc:
 
             positions_base_defects = np.array(list(positions_base_defects))
             
-            # Compute the "above" positions (shifted by one row up)
             positions_above_defects = np.column_stack((positions_base_defects[:, 0], ((positions_base_defects[:, 1] + 1) % lattice_size)))
             
-            # Combine base and above positions
             positions_defects = np.vstack((positions_base_defects, positions_above_defects))
 
             return positions_defects
@@ -616,43 +648,34 @@ class hex_kmc:
         
         self.positions_adsorbates = []
         attempts = 0
-        max_attempts = 1000  # Avoid infinite loops
+        max_attempts = 1000  
 
         while len(self.positions_adsorbates) < self.n_adsorbates and attempts < max_attempts:
             
-            # print(f'attempt = {attempts}')
             attempts += 1
             
             i = np.random.choice(len(self.hex_lattice), replace=False)
             pos_adsorbates= self.hex_lattice[i]
-            
-            # Check if hydroxyl overlaps with an oxygen vacancy (not allowed)
+           
             if pos_adsorbates in map(tuple, self.positions_defects) or pos_adsorbates in map(tuple, self.positions_atoms):
-                continue  # Reject and try again
+                continue  
             
-
-            # If all conditions are met, accept the position
             self.positions_adsorbates.append(pos_adsorbates)
 
         self.positions_adsorbates = np.array(self.positions_adsorbates)
     
 
-    
- 
-    
-    def anim1panels(self, filename):
+    def anim1panel(self, filename = "movie1panel", figsize = (6,6)):
 
-    
         # ===================== Figure & Axes =====================
-        fig, ax_main = plt.subplots(figsize=(6, 6))
+        fig, ax_main = plt.subplots(figsize=figsize)
         ax_main.set_xlim(-1, self.lattice_size + 1)
         ax_main.set_ylim(-1, self.lattice_size + 1)
         ax_main.set_xticks(range(self.lattice_size))
         ax_main.set_yticks(range(self.lattice_size))
         ax_main.grid(True, linestyle='--', linewidth=0.5)
-        ax_main.set_aspect('equal', adjustable='box')  # ensure circles look like circles
+        ax_main.set_aspect('equal', adjustable='box')  
     
-        # Background lattice (optional)
         if hasattr(self, "hex_lattice") and len(self.hex_lattice) > 0:
             hx, hy = zip(*self.hex_lattice)
             ax_main.scatter(hx, hy, s=20, color="gray", alpha=0.5, label="Lattice Sites")
@@ -664,11 +687,11 @@ class hex_kmc:
             for defect1, defect2 in self.defects_pairs:
                 x_min = min(defect1[0], defect2[0])
                 y_min = min(defect1[1], defect2[1])
-                if defect1[1] == defect2[1]:      # horizontal
+                if defect1[1] == defect2[1]:      
                     width, height = abs(defect1[0] - defect2[0]) + 1, 1
-                elif defect1[0] == defect2[0]:    # vertical
+                elif defect1[0] == defect2[0]:   
                     width, height = 1, abs(defect1[1] - defect2[1]) + 1
-                else:                     # diagonal/block
+                else:                   
                     width  = abs(defect1[0] - defect2[0]) + 1
                     height = abs(defect1[1] - defect2[1]) + 1
     
@@ -688,16 +711,14 @@ class hex_kmc:
                 adsorbates_circles.append(c)
     
         # ===================== Atom Gradient Setup =====================
-        # Baby blue gradient: bright center -> slightly darker edge
-        # Lightsteelblue gradient: center almost white → edge lightsteelblue
-        center_color = np.array([240/255, 245/255, 250/255, 1.0])  # very light (near white)
-        edge_color   = np.array([176/255, 196/255, 222/255, 1.0])  #
+        center_color = np.array([240/255, 245/255, 250/255, 1.0])  
+        edge_color   = np.array([176/255, 196/255, 222/255, 1.0])  
     
         def radial_gradient_image(resolution=256):
             y, x = np.ogrid[-1:1:complex(0, resolution), -1:1:complex(0, resolution)]
             r = np.sqrt(x*x + y*y)
             r = np.clip(r, 0, 1)
-            grad = (1 - r)[..., None] * center_color + r[..., None] * edge_color  # (H,W,4)
+            grad = (1 - r)[..., None] * center_color + r[..., None] * edge_color  
             return grad.astype(float)
     
         grad_img = radial_gradient_image(256)
@@ -705,11 +726,10 @@ class hex_kmc:
         atom_radius = 0.25
         outline_color = 'midnightblue'
         outline_width = 1.5
-    
-        # Create atom visuals: (circle outline + clipped gradient image) per atom
-        atom_artists = []  # list of (circle_patch, image_artist)
+
+        atom_artists = []  
         for _ in range(self.n_atoms):
-            # Circle outline (above the gradient)
+        
             circle = patches.Circle(
                 (0, 0), radius=atom_radius,
                 edgecolor=outline_color, facecolor='none',
@@ -717,7 +737,7 @@ class hex_kmc:
             )
             ax_main.add_patch(circle)
     
-            # Gradient image (under the outline), then clip to the circle
+         
             im = ax_main.imshow(
                 grad_img,
                 extent=[-atom_radius, atom_radius, -atom_radius, atom_radius],
@@ -726,12 +746,12 @@ class hex_kmc:
                 zorder=6,
                 alpha=1.0
             )
-            im.set_clip_path(circle)  # critical: clip the image to the circle
+            im.set_clip_path(circle)  
             im.set_clip_on(True)
     
             atom_artists.append((circle, im))
     
-        # Transparent numbers centered inside atoms
+      
         labels = [
             ax_main.text(
                 0, 0, str(i),
@@ -745,30 +765,30 @@ class hex_kmc:
     
         # ===================== Update Function =====================
         def update(frame):
-            # Move atoms
+           
             for i, (circle, im) in enumerate(atom_artists):
                 x, y = self.positions_over_time[frame][i]
                 circle.center = (x, y)
                 im.set_extent([x - atom_radius, x + atom_radius, y - atom_radius, y + atom_radius])
-                # (re)set clip path (safe across some backends)
+             
                 im.set_clip_path(circle)
                 labels[i].set_position((x, y))
     
-            # Title
+           
             if hasattr(self, "selected_moves_info") and frame < len(self.selected_moves_info):
                 atom_idx, move_name = self.selected_moves_info[frame]
                 title_text.set_text(f"next: selected atom is atom_{atom_idx} and selected move is {move_name}")
             else:
                 title_text.set_text("")
     
-            # Move hydroxyls
+           
             if adsorbates_circles:
                 for i, pos in enumerate(self.positions_adsorbates_over_time[frame]):
                     adsorbates_circles[i].center = (pos[0], pos[1])
     
         # ===================== Animate (pause on last frame) =====================
         interval_ms = 100
-        pause_frames = int(10_000 / interval_ms)  # 10 sec
+        pause_frames = int(10_000 / interval_ms)  
         def update_with_pause(frame):
             if frame < self.n_steps:
                 update(frame)
@@ -778,23 +798,18 @@ class hex_kmc:
         ani = FuncAnimation(fig, update_with_pause, frames=self.n_steps + pause_frames, interval=interval_ms)
         ani.save(f"{filename}.gif", writer=PillowWriter(fps=20))
         plt.show()
-
-
-
     
-        
-    def anim2panels(self, filename):
+    def anim2panel(self, filename = "movie2panel", figsize = (12, 6)):
 
-        fig, axes = plt.subplots(1, 2, figsize=(12, 6), gridspec_kw={'width_ratios': [2, 1]})
+        fig, axes = plt.subplots(1, 2, figsize=figsize, gridspec_kw={'width_ratios': [2, 1]})
         ax_main, ax_msd = axes[0], axes[1]
     
-        # ---- Main lattice view ----
         ax_main.set_xlim(-1, self.lattice_size + 1)
         ax_main.set_ylim(-1, self.lattice_size + 1)
         ax_main.set_xticks(range(self.lattice_size))
         ax_main.set_yticks(range(self.lattice_size))
         ax_main.grid(True, linestyle='--', linewidth=0.5)
-        ax_main.set_aspect('equal', adjustable='box')  # keep circles round
+        ax_main.set_aspect('equal', adjustable='box')  
     
         if hasattr(self, "hex_lattice") and len(self.hex_lattice) > 0:
             hex_x, hex_y = zip(*self.hex_lattice)
@@ -803,15 +818,15 @@ class hex_kmc:
         title_text = ax_main.set_title("")
     
         # ---- OV rectangles: whitesmoke fill with adjustable transparency ----
-        defect_alpha = 0.4  # <— tweak this for more/less transparent OV fill
+        defect_alpha = 0.4  
         if hasattr(self, "defects_pairs"):
             for defect1, defect2 in self.defects_pairs:
                 x_min = min(defect1[0], defect2[0])
                 y_min = min(defect1[1], defect2[1])
     
-                if defect1[1] == defect2[1]:  # Horizontal pair
+                if defect1[1] == defect2[1]:  
                     width, height = abs(defect1[0] - defect2[0]) + 1, 1
-                elif defect1[0] == defect2[0]:  # Vertical pair
+                elif defect1[0] == defect2[0]:  
                     width, height = 1, abs(defect1[1] - defect2[1]) + 1
                 else:
                     width  = abs(defect1[0] - defect2[0]) + 1
@@ -835,16 +850,15 @@ class hex_kmc:
                 ax_main.add_patch(c)
                 adsorbates_circles.append(c)
     
-        # ---- Atoms: lightsteelblue radial gradient + gray outline ----
-        # Gradient colors: center almost white -> edge lightsteelblue
-        center_color = np.array([240/255, 245/255, 250/255, 1.0])  # near white
-        edge_color   = np.array([176/255, 196/255, 222/255, 1.0])  # lightsteelblue (#B0C4DE)
+    
+        center_color = np.array([240/255, 245/255, 250/255, 1.0]) 
+        edge_color   = np.array([176/255, 196/255, 222/255, 1.0])  
     
         def radial_gradient_image(resolution=256):
             y, x = np.ogrid[-1:1:complex(0, resolution), -1:1:complex(0, resolution)]
             r = np.sqrt(x*x + y*y)
             r = np.clip(r, 0, 1)
-            grad = (1 - r)[..., None] * center_color + r[..., None] * edge_color  # (H,W,4)
+            grad = (1 - r)[..., None] * center_color + r[..., None] * edge_color  
             return grad.astype(float)
     
         grad_img = radial_gradient_image(256)
@@ -853,7 +867,7 @@ class hex_kmc:
         outline_width = 1.5
     
         # Create per-atom (circle outline + clipped gradient image)
-        atom_artists = []  # list of (circle_patch, image_artist)
+        atom_artists = []  
         for _ in range(self.n_atoms):
             circle = patches.Circle(
                 (0, 0), radius=atom_radius,
@@ -875,7 +889,7 @@ class hex_kmc:
     
             atom_artists.append((circle, im))
     
-        # Atom labels: centered, semi-transparent
+      
         labels = [
             ax_main.text(
                 0, 0, str(i),
@@ -915,7 +929,7 @@ class hex_kmc:
     
         # ---- Frame update ----
         def update(frame):
-            # Atoms
+         
             for i, (circle, im) in enumerate(atom_artists):
                 x, y = self.positions_over_time[frame][i]
                 circle.center = (x, y)
@@ -923,18 +937,18 @@ class hex_kmc:
                 im.set_clip_path(circle)  # safe across backends
                 labels[i].set_position((x, y))
     
-            # Title
+       
             atom_idx, selected_move_name = self.selected_moves_info[frame]
             title_text.set_text(f"next: selected atom is atom_{atom_idx} and selected move is {selected_move_name}")
     
-            # Hydroxyls
+    
             for i, pos in enumerate(self.positions_adsorbates_over_time[frame]):
                 adsorbates_circles[i].center = (pos[0], pos[1])
     
-            # MSD trace
+       
             msd_line.set_data(self.time[:frame], self.msd[:frame])
     
-            # Move percentages up to current frame
+    
             move_counts_up_to_frame = {m: 0 for m in move_labels}
             for _, mname in self.selected_moves_info[:frame]:
                 move_counts_up_to_frame[mname] += 1
@@ -943,7 +957,7 @@ class hex_kmc:
                 pct = 100.0 * move_counts_up_to_frame[m] / total_moves
                 move_texts[i].set_text(f"{m}: {pct:.1f}%")
     
-            # Linear fit for diffusion slope
+        
             if frame > 1:
                 x_fit = self.time[:frame]
                 y_fit = self.msd[:frame]
@@ -957,7 +971,7 @@ class hex_kmc:
     
         # ---- Animate with pause at end ----
         interval_ms = 100
-        pause_frames = int(10_000 / interval_ms)  # 10 sec hold
+        pause_frames = int(10_000 / interval_ms)  
         def update_with_pause(frame):
             if frame < self.n_steps:
                 update(frame)
@@ -967,16 +981,13 @@ class hex_kmc:
         ani = FuncAnimation(fig, update_with_pause, frames=self.n_steps + pause_frames, interval=interval_ms)
         ani.save(f"{filename}.gif", writer=PillowWriter(fps=20))
         plt.show()
-        
-        
-        
-       
-    def msdplot(self, filename):
+         
+    def msdplot(self, filename = "msd"):
         
         time = self.time[:-1]
 
         ## Calculate overall diffusion coefficient
-        transient_cutoff = int(0 * self.n_steps)  # Ignore the first 10% of steps
+        transient_cutoff = int(0 * self.n_steps)  # Ignore the first 0% of steps
         valid_time = time[transient_cutoff:]  # Exclude transient region
         valid_msd = self.msd[transient_cutoff:]    # Exclude transient region
 
@@ -992,13 +1003,12 @@ class hex_kmc:
         plt.figure(figsize=(8, 6))
         plt.plot(time, self.msd,  color="#89CFF0", label="Individual MSD Trajectory")
         plt.plot(valid_time, fit_line, linestyle="--", color="blue", label="Linear Fit")
-        #plt.axvline(x=time[transient_cutoff], color='r', linestyle='--', label="Transient cutoff")
         plt.xlabel("Time (s)")
         plt.ylabel("MSD (µm²)")
         plt.legend()
         plt.title(f"Mean Squared Displacement vs Time - {self.n_steps} steps")
         plt.text(0.05 * max(time), 0.8 * max(self.msd),  # Adjust placement (x, y) as needed
-                 f" Diffusion Coefficient = {diffusion_coefficient_corrected:.4f} µm²/s", 
+                 f" Diffusion Coefficient = {diffusion_coefficient_corrected:.1e} µm²/s", 
                  fontsize=12, color='blue', bbox=dict(facecolor="white", alpha=0.5))
         plt.minorticks_on()
         plt.grid(True, which='major', linestyle='-', linewidth=0.6)
@@ -1006,15 +1016,12 @@ class hex_kmc:
         plt.savefig(f'{filename}.png', dpi = 600)
         plt.show()  
         
+    def msd_histogram(self, filename = "average_msd", n_seeds = 25):
         
-
-    def msd_histogram(self, n_seeds, msd_folder = "random_seeds/msd", 
-                      time_folder = "random_seeds/time", 
-                      save_folder = "random_seeds/average_msd.png",
-                      msd_trajs_color = "pink",
-                      msd_average_color = "#C71585"):
-        
-        
+        msd_folder = "random_seeds/msd"
+        time_folder = "random_seeds/time"
+        save_folder = f"random_seeds/{filename}.png"
+                          
         msd_list = []
         time_list = []
 
@@ -1034,7 +1041,7 @@ class hex_kmc:
         time_avg = np.mean(time_array, axis=0)
 
         # Fit a linear function: MSD = a * Time + b
-       # slope, intercept = np.polyfit(time_avg, msd_avg, 1)
+    
         slope, intercept, r_value, p_value, slope_std_err = linregress(time_avg, msd_avg)
         fitted_line = slope * time_avg + intercept  # Compute the fitted line
 
@@ -1045,23 +1052,23 @@ class hex_kmc:
         # Plot all MSD curves in light pink
         plt.figure(figsize=(8, 6))
         for i in range(n_seeds):
-            plt.plot(time_array[i], msd_array[i], color=msd_trajs_color, alpha=0.5, linewidth=1)
+            plt.plot(time_array[i], msd_array[i], color="pink", alpha=0.5, linewidth=1)
 
         # Plot average MSD with error bars at 20 selected points in dark pink
-        plt.plot(time_avg, msd_avg, color=msd_average_color, linewidth=2, label="Average MSD")
-        plt.errorbar(time_avg[indices], msd_avg[indices], yerr=msd_std[indices], fmt='o', color=msd_average_color, capsize=3)
+        plt.plot(time_avg, msd_avg, color="#C71585", linewidth=2, label="Average MSD")
+        plt.errorbar(time_avg[indices], msd_avg[indices], yerr=msd_std[indices], fmt='o', color="#C71585", capsize=3)
 
         # Plot fitted line
-        #plt.plot(time_avg, fitted_line, linestyle="--", color="blue", linewidth=2, label=f"Linear Fit: Slope = {slope:.4f} ± {slope_std_err:.2f} (um²/s)")
+       
         plt.plot(time_avg, fitted_line, linestyle="--", color="blue", linewidth=2, label="Linear Fit")
 
         # Labels and legend
         plt.xlabel("Time(s)")
         plt.ylabel("MSD (µm²)")
-        plt.title("T=300K - Lattice Size =10*10 - OH Coverage=0.5ML - OH Frequency=OFF")
+        plt.title("Average Mean Square Displacement vs Time")
 
         # Display slope inside the plot
-        plt.text(0.05 * max(time_avg), 0.8 * max(msd_avg), f"Diffusion Coefficient = {slope/4:.6f} ± {slope_std_err/4:.1e} (µm²/s)", fontsize=12, color="blue", bbox=dict(facecolor="white", alpha=0.5))
+        plt.text(0.05 * max(time_avg), 0.8 * max(msd_avg), f"Diffusion Coefficient = {slope/4:.1e} ± {slope_std_err/4:.1e} (µm²/s)", fontsize=12, color="blue", bbox=dict(facecolor="white", alpha=0.5))
         plt.legend()
         plt.minorticks_on()
         plt.grid(True, which='major', linestyle='-', linewidth=0.6)
@@ -1069,4 +1076,4 @@ class hex_kmc:
         plt.savefig(save_folder, dpi = 600)
         plt.show()
     
-   
+