mcising 0.1__tar.gz

mcising-0.1/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.1
+Name: mcising
+Version: 0.1
+Summary: A package for generating Ising model data using Metropolis algorithm on a square lattice for nearest neighbor and next nearest neighbor interactions.
+Home-page: https://github.com/bcivitcioglu/mcising
+Author: Burak Ç.
+Author-email: bcivitcioglu@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+
+# mcising
+
+mcising is a Python package for generating Ising model data using Monte Carlo simulations.
+
+## Installation
+
+You can install the package using pip:
+
+`pip install mcising`
+
+## Usage
+
+You can generate Ising model data from the command line:
+
+`generate_ising_data <seed> <lattice_size> <num_configs> <j1> <j2> [--T_init <T_init>] [--T_final <T_final>] [--T_step <T_step>] [--sweep_steps <sweep_steps>] [--thermalization_scans <thermalization_scans>] [--calculate_correlation]`
+
+An example usage:
+
+`generate_ising_data 42 10 100 1.0 0.5 --T_init 4.0 --T_final 0.1 --T_step 0.05 --sweep_steps 10 --thermalization_scans 5 --calculate_correlation`
+
+## Licence
+
+This project is licensed under the MIT License.

mcising-0.1/README.md

@@ -0,0 +1,23 @@
+# mcising
+
+mcising is a Python package for generating Ising model data using Monte Carlo simulations.
+
+## Installation
+
+You can install the package using pip:
+
+`pip install mcising`
+
+## Usage
+
+You can generate Ising model data from the command line:
+
+`generate_ising_data <seed> <lattice_size> <num_configs> <j1> <j2> [--T_init <T_init>] [--T_final <T_final>] [--T_step <T_step>] [--sweep_steps <sweep_steps>] [--thermalization_scans <thermalization_scans>] [--calculate_correlation]`
+
+An example usage:
+
+`generate_ising_data 42 10 100 1.0 0.5 --T_init 4.0 --T_final 0.1 --T_step 0.05 --sweep_steps 10 --thermalization_scans 5 --calculate_correlation`
+
+## Licence
+
+This project is licensed under the MIT License.

mcising-0.1/mcising/__init__.py

@@ -0,0 +1,3 @@
+# mcising/__init__.py
+from .isinglattice import IsingLattice
+from .montecarlo import collect_monte_carlo_data

mcising-0.1/mcising/ising_data_generate.py

@@ -0,0 +1,44 @@
+# mcising/ising_data_generate.py
+
+import numpy as np
+import argparse
+import montecarlo
+
+def main(args):
+    temperature = np.arange(args.T_init, args.T_final - args.T_step, -args.T_step)
+
+    montecarlo.collect_monte_carlo_data(
+        seed=args.seed,
+        lattice_size=args.lattice_size,
+        J1=args.j1, 
+        J2=args.j2,
+        h=0.0,
+        num_scans=args.sweep_steps * (args.num_configs - 1),
+        temperature=temperature,
+        thermalization_scans=args.thermalization_scans,
+        frequency_sweeps_to_collect_magnetization=args.sweep_steps,
+        calculate_correlation=args.calculate_correlation
+    )
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Generate Ising model data using Monte Carlo simulation.")
+    parser.add_argument("seed", type=int, help="Random seed for the simulation")
+    parser.add_argument("lattice_size", type=int, help="Size of the lattice")
+    parser.add_argument("num_configs", type=int, help="Number of configurations to generate")
+    parser.add_argument("j1", type=float, help="Interaction parameter J1")
+    parser.add_argument("j2", type=float, help="Interaction parameter J2")
+    parser.add_argument("--T_init", type=float, default=4.0, help="Initial temperature (default: 4.0)")
+    parser.add_argument("--T_final", type=float, default=0.075, help="Final temperature (default: 0.075)")
+    parser.add_argument("--T_step", type=float, default=0.025, help="Temperature step (default: 0.025)")
+    parser.add_argument("--sweep_steps", type=int, default=1, help="Number of sweep steps (default: 1)")
+    parser.add_argument("--thermalization_scans", type=int, default=3, help="Number of thermalization scans (default: 3)")
+    parser.add_argument("--calculate_correlation", action="store_true", help="Calculate correlation function and length")
+
+    args = parser.parse_args()
+
+    if args.T_step <= 0:
+        print("Error: T_step must be greater than 0")
+    elif args.T_init <= args.T_final:
+        print("Error: T_init must be greater than T_final")
+    else:
+        main(args)

mcising-0.1/mcising/isinglattice.py

@@ -0,0 +1,222 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import random
+
+class IsingLattice:
+    """
+    A class to represent an Ising model lattice.
+    
+    Attributes
+    ----------
+    lattice_size : int
+        The size of the lattice.
+    num_sites : int
+        The total number of sites in the lattice.
+    J1 : float
+        Interaction parameter for nearest neighbors.
+    J2 : float
+        Interaction parameter for next nearest neighbors.
+    h : float
+        External magnetic field.
+    lattice_state : np.ndarray
+        The state of the lattice.
+    """
+    
+    def __init__(self, lattice_size, J1, J2, h):
+        """
+        Initializes the lattice with random spins.
+        
+        Parameters
+        ----------
+        lattice_size : int
+            The size of the lattice.
+        J1 : float
+            Interaction parameter for nearest neighbors.
+        J2 : float
+            Interaction parameter for next nearest neighbors.
+        h : float
+            External magnetic field.
+        """
+        self.lattice_size = lattice_size
+        self.num_sites = lattice_size * lattice_size
+        self.J1 = J1
+        self.J2 = J2
+        self.h = h
+        
+        # Randomly initialize the lattice with -1 and 1
+        lattice_state = np.random.choice([-1, 1], size=(self.lattice_size, self.lattice_size))
+        self.lattice_state = lattice_state
+
+    def plot_lattice(self, print_info=False): 
+        """
+        Plot the current lattice configuration.
+        
+        Parameters
+        ----------
+        print_info : bool, optional
+            If True, prints the lattice information. Default is False.
+        """
+        plt.figure()
+        plt.imshow(self.lattice_state, cmap='gray')
+        plt.title("Ising Lattice")
+        plt.show()
+        if print_info:
+            self.print_info()
+
+    def print_info(self):
+        """
+        Print information about the lattice.
+        """
+        print(f"Lattice size: {self.lattice_size} x {self.lattice_size}. J1: {self.J1}, J2: {self.J2}, h: {self.h}")
+
+    def flip_spin(self, i, j):
+        """
+        Flip the spin at the given site (i, j).
+        
+        Parameters
+        ----------
+        i : int
+            Row index of the site.
+        j : int
+            Column index of the site.
+        """
+        self.lattice_state[i, j] *= -1
+
+    def spin_energy(self, i, j):
+        """
+        Calculate the energy of the spin at the given site (i, j).
+        
+        Parameters
+        ----------
+        i : int
+            Row index of the site.
+        j : int
+            Column index of the site.
+        
+        Returns
+        -------
+        float
+            The energy of the spin at the given site.
+        """
+        spin_ij = self.lattice_state[i, j]
+
+        # Periodic boundary conditions
+        sum_neighbouring_spins = (
+            self.lattice_state[(i + 1) % self.lattice_size, j] +
+            self.lattice_state[i, (j + 1) % self.lattice_size] +
+            self.lattice_state[(i - 1) % self.lattice_size, j] +
+            self.lattice_state[i, (j - 1) % self.lattice_size]
+        )
+
+        sum_second_neighbouring_spins = (
+            self.lattice_state[(i + 1) % self.lattice_size, (j + 1) % self.lattice_size] +
+            self.lattice_state[(i + 1) % self.lattice_size, (j - 1) % self.lattice_size] +
+            self.lattice_state[(i - 1) % self.lattice_size, (j + 1) % self.lattice_size] +
+            self.lattice_state[(i - 1) % self.lattice_size, (j - 1) % self.lattice_size]
+        )
+
+        interaction_term = (
+            -self.J1 * spin_ij * sum_neighbouring_spins +
+            -self.J2 * spin_ij * sum_second_neighbouring_spins
+        )
+        
+        if self.h != 0:
+            magnetic_field_term = -self.h * spin_ij
+            return interaction_term + magnetic_field_term
+        
+        return interaction_term
+
+    def energy(self):
+        """
+        Calculate the total energy of the lattice.
+        
+        Returns
+        -------
+        float
+            The total energy of the lattice.
+        """
+        E = 0.0
+        for i in np.arange(self.lattice_size):
+            for j in np.arange(self.lattice_size):
+                E += self.spin_energy(i, j)
+        E /= 2.0 * self.num_sites
+        if self.h != 0:
+            E -= self.h * np.sum(self.lattice_state) / self.num_sites
+        return E
+
+    def magnetization(self):
+        """
+        Calculate the net magnetization of the lattice.
+        
+        Returns
+        -------
+        float
+            The net magnetization of the lattice.
+        """
+        return np.sum(self.lattice_state) / self.num_sites
+
+    def correlation_function(self, plot=False):
+        """
+        Calculate the correlation function of the lattice.
+        
+        Parameters
+        ----------
+        plot : bool, optional
+            If True, plots the correlation function. Default is False.
+        
+        Returns
+        -------
+        tuple
+            The correlation function and the distances.
+        """
+        counter = 0
+        correlation_function = np.zeros(self.num_sites**2)
+        r_sq = np.zeros(self.num_sites**2).astype(int)
+
+        for i in np.arange(self.lattice_size):
+            for j in np.arange(self.lattice_size):
+                for k in np.arange(i, self.lattice_size):
+                    check_var = 0
+                    if i == k:
+                        check_var = j
+                    for l in np.arange(check_var, self.lattice_size):
+                        x_distance = abs(j - l)
+                        y_distance = abs(i - k)
+                        
+                        if x_distance > self.lattice_size / 2:
+                            x_distance = abs(self.lattice_size - x_distance)
+                        if y_distance > self.lattice_size / 2:
+                            y_distance = abs(self.lattice_size - y_distance)
+                            
+                        distance = x_distance**2 + y_distance**2
+                        
+                        r_sq[counter] = distance
+                        correlation_function[counter] = self.lattice_state[i, j] * self.lattice_state[k, l]
+                        
+                        counter += 1
+        
+        corr = correlation_function[:counter]
+        dist = r_sq[:counter]
+
+        sort_ind = np.argsort(dist)
+        sorted_d = np.sort(dist)
+        sorted_c = corr[sort_ind]
+        
+        unique_d, unique_indices_d = np.unique(sorted_d, return_index=True)
+        averaged_c = np.zeros(unique_d.size)
+
+        for i in np.arange(averaged_c.size - 1):
+            denom = unique_indices_d[i + 1] - unique_indices_d[i]
+            averaged_c[i] = np.sum(sorted_c[unique_indices_d[i]:unique_indices_d[i + 1]]) / denom
+
+        denom = unique_indices_d[-1] - unique_indices_d[-2]
+        averaged_c[-1] = np.sum(sorted_c[unique_indices_d[-2]:unique_indices_d[-1]]) / denom
+        
+        if plot:
+            plt.plot(np.sqrt(unique_d), averaged_c)
+            plt.xlabel("Distance")
+            plt.ylabel("Correlation Function")
+            plt.title("Correlation Function vs Distance")
+            plt.show()
+
+        return averaged_c - self.magnetization()**2, np.sqrt(unique_d)

mcising-0.1/mcising/montecarlo.py

@@ -0,0 +1,319 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import random
+import pickle as pkl
+import imageio
+import time
+import os
+from .isinglattice import IsingLattice
+
+INF_TEMP = 100
+
+def get_index(data):
+    """
+    Get the index where data falls below a threshold.
+    
+    Parameters
+    ----------
+    data : np.ndarray
+        The array of data.
+        
+    Returns
+    -------
+    int
+        The index where data falls below 10^-8.
+    """
+    for i in range(data.size):
+        if data[i] < 10**(-8):
+            return i
+    return data.size
+
+def data2cut(data, index):
+    """
+    Cut data up to a given index.
+    
+    Parameters
+    ----------
+    data : np.ndarray
+        The array of data.
+    index : int
+        The index to cut data.
+        
+    Returns
+    -------
+    np.ndarray
+        The cut data.
+    """
+    return data[:index]
+
+def distance2cut(distance, index):
+    """
+    Cut distances up to a given index.
+    
+    Parameters
+    ----------
+    distance : np.ndarray
+        The array of distances.
+    index : int
+        The index to cut distances.
+        
+    Returns
+    -------
+    np.ndarray
+        The cut distances.
+    """
+    return distance[:index]
+
+def get_cor_len(cor_func, dist, index):
+    """
+    Calculate the correlation length.
+    
+    Parameters
+    ----------
+    cor_func : np.ndarray
+        The correlation function values.
+    dist : np.ndarray
+        The distances.
+    index : int
+        The index up to which the data is considered.
+        
+    Returns
+    -------
+    float
+        The correlation length.
+    """
+    cor_func_cut = data2cut(cor_func, index)
+    distance_cut = distance2cut(dist, index)
+
+    correlation_negative_check = np.sum(cor_func_cut * (distance_cut ** 2))
+    correlation_zero_check = np.sum(6 * cor_func_cut)
+    
+    if correlation_zero_check == 0:
+        return 0
+    elif correlation_negative_check / correlation_zero_check < 0:
+        return 0
+    else:
+        return np.sqrt(correlation_negative_check / correlation_zero_check)
+
+def scan_lattice(ising_lattice, temperature):
+    """
+    Perform a single Metropolis scan of the lattice.
+    
+    Parameters
+    ----------
+    ising_lattice : IsingLattice
+        The Ising lattice.
+    temperature : float
+        The temperature of the system.
+    """
+    for _ in range(ising_lattice.num_sites):
+        i = random.randint(0, ising_lattice.lattice_size - 1)
+        j = random.randint(0, ising_lattice.lattice_size - 1)
+
+        energy_initial = ising_lattice.spin_energy(i, j)
+        ising_lattice.flip_spin(i, j)
+        energy_final = ising_lattice.spin_energy(i, j)
+        energy_change = energy_final - energy_initial
+        ising_lattice.flip_spin(i, j)
+        
+        if temperature != 0:
+            if energy_change <= 0 or random.uniform(0, 1) <= np.exp(-energy_change / temperature):
+                ising_lattice.flip_spin(i, j)
+
+def calculate_corr_size(lattice_size):
+    """
+    Calculate CORR_SIZE dynamically based on lattice size.
+    
+    Parameters
+    ----------
+    lattice_size : int
+        The size of the lattice.
+        
+    Returns
+    -------
+    int
+        The calculated CORR_SIZE.
+    """
+    unique_distances = set()
+
+    for i in range(lattice_size):
+        for j in range(lattice_size):
+            for k in range(lattice_size):
+                for l in range(lattice_size):
+                    x_distance = min(abs(i - k), lattice_size - abs(i - k))
+                    y_distance = min(abs(j - l), lattice_size - abs(j - l))
+                    distance_squared = x_distance**2 + y_distance**2
+                    unique_distances.add(distance_squared)
+    
+    return len(unique_distances)
+
+def monte_carlo_simulation(ising_lattice, temperature, num_scans, frequency_sweeps_to_collect_magnetization, plot_result=False, print_info=False, calculate_correlation=False):
+    """
+    Perform Monte Carlo simulation on the Ising lattice.
+    
+    Parameters
+    ----------
+    ising_lattice : IsingLattice
+        The Ising lattice.
+    temperature : float
+        The temperature of the system.
+    num_scans : int
+        The number of scans to perform.
+    frequency_sweeps_to_collect_magnetization : int
+        The frequency of sweeps to collect magnetization.
+    plot_result : bool, optional
+        Whether to plot the result. Default is False.
+    print_info : bool, optional
+        Whether to print information. Default is False.
+    calculate_correlation : bool, optional
+        Whether to calculate correlation function and length. Default is False.
+        
+    Returns
+    -------
+    tuple
+        Lattice configurations, energy records, magnetization records, correlation function records, correlation length records, distances.
+    """
+    start_time = time.time()
+    
+    if print_info:
+        ising_lattice.print_info()
+    
+    total_num_records = int(num_scans / frequency_sweeps_to_collect_magnetization) + 1
+    energy_records = np.zeros(total_num_records)
+    magnetization_records = np.zeros(total_num_records)
+    
+    corr_size = calculate_corr_size(ising_lattice.lattice_size) if calculate_correlation else 0
+    correlation_function_records = np.zeros((total_num_records, corr_size)) if calculate_correlation else None
+    correlation_length_records = np.zeros(total_num_records) if calculate_correlation else None
+    
+    increment_records = 0
+    
+    lattice_configs = np.zeros((total_num_records, ising_lattice.lattice_size, ising_lattice.lattice_size))
+
+    for k in range(num_scans + frequency_sweeps_to_collect_magnetization):
+        scan_lattice(ising_lattice, temperature)
+        if k % frequency_sweeps_to_collect_magnetization == 0:
+            energy_records[increment_records] = ising_lattice.energy()
+            magnetization_records[increment_records] = ising_lattice.magnetization()
+            lattice_configs[increment_records] = ising_lattice.lattice_state
+            
+            if calculate_correlation:
+                correlations, distances = ising_lattice.correlation_function(False)
+                correlation_function_records[increment_records] = correlations[:corr_size]
+                
+                index = get_index(correlations)
+                correlation_length_records[increment_records] = get_cor_len(correlations, distances, index)
+            
+            increment_records += 1
+            print(f"{increment_records} / {total_num_records} samples saved.")
+    
+    print(f"For temperature= {temperature}, MC simulation executed in: {round(time.time() - start_time, 2)} seconds")
+    
+    if plot_result:
+        ising_lattice.plot_lattice()
+    
+    return (
+        lattice_configs, 
+        energy_records, 
+        magnetization_records, 
+        correlation_function_records if calculate_correlation else None, 
+        correlation_length_records if calculate_correlation else None, 
+        distances if calculate_correlation else None
+    )
+
+def dir_name(lattice_size, J1, J2, h, temperature):
+    return f'SQ_L_{lattice_size}_J1_{J1:.3f}_J2_{J2:.3f}_h_{h:.3f}_T_{temperature:.3f}'
+
+def file_name(lattice_size, J1, J2, h, temperature, seed):
+    return f'SQ_L_{lattice_size}_J1_{J1:.3f}_J2_{J2:.3f}_h_{h:.3f}_T_{temperature:.3f}_s_{seed}'
+
+def write_to_sub_directory(quantity, dir_name, file_name):
+    if not os.path.exists(dir_name):
+        os.mkdir(dir_name)
+    with open(os.path.join(dir_name, file_name), "wb") as file:
+        pkl.dump(quantity, file)
+
+def write_txt_files(quantity, dir_name, file_name):
+    if not os.path.exists(dir_name):
+        os.mkdir(dir_name)
+    np.savetxt(os.path.join(dir_name, file_name), quantity, fmt='%1.3f')
+
+def save_image_to_sub_directory(data, directory_name, file_name):
+    if not os.path.exists(directory_name):
+        os.mkdir(directory_name)
+    imageio.imwrite(os.path.join(directory_name, f"{file_name}.png"), data)
+
+def thermalize(ising_lattice, num_scans, from_T, to_T):
+    """
+    Thermalize the lattice from a given temperature to a target temperature.
+    
+    Parameters
+    ----------
+    ising_lattice : IsingLattice
+        The Ising lattice.
+    num_scans : int
+        The number of scans for thermalization.
+    from_T : float
+        The initial temperature.
+    to_T : float
+        The target temperature.
+    """
+    print(f"Equilibrating to T = {to_T:.2f} starting from T = {from_T:.2f}")
+    for k in np.linspace(from_T, to_T, num=num_scans):
+        scan_lattice(ising_lattice, k)
+    print(f"Reached T={to_T:.2f}. Beginning to collect data.")
+
+def collect_monte_carlo_data(seed, lattice_size, J1, J2, h, num_scans, temperature, thermalization_scans, frequency_sweeps_to_collect_magnetization, calculate_correlation=False):
+    random.seed(seed)
+    print(f"Lattice size: {lattice_size} x {lattice_size}, J1= {J1}, J2= {J2}, h= {h}, SEED= {seed}\n")
+    temperature = np.append(INF_TEMP, temperature)
+    
+    if 0 in temperature:
+        raise ValueError("Monte-Carlo does not work properly at T=0.")
+    if np.any(temperature < 0):
+        raise ValueError("Temperature cannot be a negative value.")
+    
+    ising_lattice = IsingLattice(lattice_size, J1, J2, h)
+    num_temps = temperature.size
+    
+    for i in range(num_temps - 1):
+        file_name_lattice = file_name(lattice_size, J1, J2, h, temperature[i+1], seed)
+        dir_name_data = dir_name(lattice_size, J1, J2, h, temperature[i+1])
+        
+        total_num_configurations = int(num_scans / frequency_sweeps_to_collect_magnetization) + 1
+        file_exists = [os.path.isfile(os.path.join(dir_name_data, f"{file_name_lattice}_n_{configs * frequency_sweeps_to_collect_magnetization}.pkl")) for configs in range(total_num_configurations)]
+        
+        if os.path.exists(dir_name_data) and not np.all(file_exists):
+            print(f"{np.argwhere(np.array(file_exists) == False)[0][0]} Previous configurations for SEED = {seed} with L = {lattice_size} T = {temperature[i+1]:.2f} J1 = {J1} J2 = {J2} h = {h}\n")
+
+        if np.all(file_exists):
+            print(f"ALL requested configurations for SEED = {seed} with L = {lattice_size} T = {temperature[i+1]:.2f} J1 = {J1} J2 = {J2} h = {h} already exist!\n")
+            continue
+        
+        thermalize(ising_lattice, thermalization_scans, temperature[i], temperature[i+1])
+        print(f"START - MC simulation {i+1} / {num_temps-1}, T = {temperature[i+1]:.2f}")
+
+        lattice_configs, energy_records, magnetization_records, correlation_function_records, correlation_length_records, distances = monte_carlo_simulation(
+            ising_lattice, temperature[i+1], num_scans, frequency_sweeps_to_collect_magnetization, calculate_correlation=calculate_correlation)
+
+        for img in range(total_num_configurations):
+            file_name_img = f"{file_name_lattice}_n_{img * frequency_sweeps_to_collect_magnetization}"
+            data_sample = {
+                'configuration': lattice_configs[img],
+                'energy': energy_records[img],
+                'magnetization': magnetization_records[img],
+                'correlation_length': correlation_length_records[img] if calculate_correlation else None,
+                'correlation_function': correlation_function_records[img] if calculate_correlation else None,
+                'distances': distances if calculate_correlation else None
+            }
+
+            txt_data = np.array([data_sample['energy'], data_sample['magnetization'], data_sample['correlation_length']])
+            correlation_function_txt_data = np.array(data_sample['correlation_function']) if calculate_correlation else None
+            write_to_sub_directory(data_sample, dir_name_data, f"{file_name_img}.pkl")
+            save_image_to_sub_directory(lattice_configs[img].astype(np.uint8), dir_name_data, file_name_img)
+            write_txt_files(txt_data, dir_name_data, f"{file_name_img}.txt")
+            if calculate_correlation:
+                write_txt_files(correlation_function_txt_data, dir_name_data, f"{file_name_img}_correlation_function.txt")
+                write_txt_files(distances, dir_name_data, f"{file_name_img}_distances.txt")
+
+        print(f"END --- MC simulation {i+1} / {num_temps-1}, T = {temperature[i+1]:.2f}\n")

mcising-0.1/mcising.egg-info/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.1
+Name: mcising
+Version: 0.1
+Summary: A package for generating Ising model data using Metropolis algorithm on a square lattice for nearest neighbor and next nearest neighbor interactions.
+Home-page: https://github.com/bcivitcioglu/mcising
+Author: Burak Ç.
+Author-email: bcivitcioglu@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+
+# mcising
+
+mcising is a Python package for generating Ising model data using Monte Carlo simulations.
+
+## Installation
+
+You can install the package using pip:
+
+`pip install mcising`
+
+## Usage
+
+You can generate Ising model data from the command line:
+
+`generate_ising_data <seed> <lattice_size> <num_configs> <j1> <j2> [--T_init <T_init>] [--T_final <T_final>] [--T_step <T_step>] [--sweep_steps <sweep_steps>] [--thermalization_scans <thermalization_scans>] [--calculate_correlation]`
+
+An example usage:
+
+`generate_ising_data 42 10 100 1.0 0.5 --T_init 4.0 --T_final 0.1 --T_step 0.05 --sweep_steps 10 --thermalization_scans 5 --calculate_correlation`
+
+## Licence
+
+This project is licensed under the MIT License.

mcising-0.1/mcising.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+setup.py
+mcising/__init__.py
+mcising/ising_data_generate.py
+mcising/isinglattice.py
+mcising/montecarlo.py
+mcising.egg-info/PKG-INFO
+mcising.egg-info/SOURCES.txt
+mcising.egg-info/dependency_links.txt
+mcising.egg-info/entry_points.txt
+mcising.egg-info/requires.txt
+mcising.egg-info/top_level.txt
+tests/__init__.py
+tests/test_isinglattice.py
+tests/test_montecarlo.py

mcising-0.1/mcising.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mcising-0.1/mcising.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+generate_ising_data = mcising.ising_data_generate:main

mcising-0.1/mcising.egg-info/requires.txt

@@ -0,0 +1,3 @@
+numpy
+matplotlib
+imageio

mcising-0.1/mcising.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+mcising
+tests

mcising-0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

mcising-0.1/setup.py

@@ -0,0 +1,33 @@
+# setup.py
+from setuptools import setup, find_packages
+
+setup(
+    name="mcising",
+    version="0.1",
+    packages=find_packages(),
+    install_requires=[
+        "numpy",
+        "matplotlib",
+        "imageio"
+    ],
+    tests_require=[
+        "unittest",
+        "pytest"
+    ],
+    entry_points={
+        'console_scripts': [
+            'generate_ising_data=mcising.ising_data_generate:main',
+        ],
+    },
+    author="Burak Ç.",
+    author_email="bcivitcioglu@gmail.com",
+    description="A package for generating Ising model data using Metropolis algorithm on a square lattice for nearest neighbor and next nearest neighbor interactions.",
+    long_description=open('README.md').read(),
+    long_description_content_type='text/markdown',
+    url="https://github.com/bcivitcioglu/mcising",
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+)

mcising-0.1/tests/__init__.py

@@ -0,0 +1 @@
+# tests/__init__.py

mcising-0.1/tests/test_isinglattice.py

@@ -0,0 +1,21 @@
+import unittest
+from mcising.isinglattice import IsingLattice
+
+class TestIsingLattice(unittest.TestCase):
+
+    def test_initialization(self):
+        lattice = IsingLattice(lattice_size=10, J1=1.0, J2=0.5, h=0.0)
+        self.assertEqual(lattice.lattice_size, 10)
+        self.assertEqual(lattice.J1, 1.0)
+        self.assertEqual(lattice.J2, 0.5)
+        self.assertEqual(lattice.h, 0.0)
+        self.assertEqual(lattice.lattice_state.shape, (10, 10))
+
+    def test_flip_spin(self):
+        lattice = IsingLattice(lattice_size=10, J1=1.0, J2=0.5, h=0.0)
+        initial_spin = lattice.lattice_state[0, 0]
+        lattice.flip_spin(0, 0)
+        self.assertEqual(lattice.lattice_state[0, 0], -initial_spin)
+
+if __name__ == '__main__':
+    unittest.main()

mcising-0.1/tests/test_montecarlo.py

@@ -0,0 +1,49 @@
+import unittest
+from mcising.isinglattice import IsingLattice
+from mcising.montecarlo import scan_lattice, monte_carlo_simulation
+
+class TestMonteCarlo(unittest.TestCase):
+
+    def setUp(self):
+        self.lattice = IsingLattice(lattice_size=10, J1=1.0, J2=0.5, h=0.0)
+        self.temperature = 1.0
+        self.num_scans = 100
+        self.frequency_sweeps_to_collect_magnetization = 10
+
+    def test_scan_lattice(self):
+        initial_energy = self.lattice.energy()
+        scan_lattice(self.lattice, self.temperature)
+        self.assertNotEqual(self.lattice.energy(), initial_energy)
+
+    def test_monte_carlo_simulation_without_correlation(self):
+        configs, energies, magnetizations, corrs, corr_lengths, distances = monte_carlo_simulation(
+            self.lattice,
+            self.temperature,
+            self.num_scans,
+            self.frequency_sweeps_to_collect_magnetization,
+            calculate_correlation=False
+        )
+        self.assertIsNotNone(configs)
+        self.assertIsNotNone(energies)
+        self.assertIsNotNone(magnetizations)
+        self.assertIsNone(corrs)
+        self.assertIsNone(corr_lengths)
+        self.assertIsNone(distances)
+
+    def test_monte_carlo_simulation_with_correlation(self):
+        configs, energies, magnetizations, corrs, corr_lengths, distances = monte_carlo_simulation(
+            self.lattice,
+            self.temperature,
+            self.num_scans,
+            self.frequency_sweeps_to_collect_magnetization,
+            calculate_correlation=True
+        )
+        self.assertIsNotNone(configs)
+        self.assertIsNotNone(energies)
+        self.assertIsNotNone(magnetizations)
+        self.assertIsNotNone(corrs)
+        self.assertIsNotNone(corr_lengths)
+        self.assertIsNotNone(distances)
+
+if __name__ == '__main__':
+    unittest.main()