phase_transition_mpi.cpp

Go to the documentation of this file.

 
#include "data_type.hpp"
#include "monte_carlo.hpp"
#include "utils.hpp"
 
#include <algorithm>
#include <fstream>
#include <iostream>
#include <iterator>
#include <mpi.h>
#include <sstream>
 
int main(int argc, char **argv)
{
    if (argc < 5) {
        std::cout << "You need at least 4 arguments" << std::endl;
        abort();
    }
    double t0, t1;
    t0 = MPI_Wtime();
    double start = atof(argv[1]), end = atof(argv[2]);
    int points = atoi(argv[3]), N;
    int lattice_sizes[] = {20, 40, 60, 80, 100};
    double dt = (end - start) / points;
    int cycles = atoi(argv[4]);
    std::ofstream ofile;
 
    data_t data[points];
 
    // MPI stuff
    int rank, cluster_size;
 
    // Initialize MPI
    MPI_Init(&argc, &argv);
 
    // Get the cluster size and rank
    MPI_Comm_size(MPI_COMM_WORLD, &cluster_size);
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
 
    int remainder = points % cluster_size;
    double i_start;
    int i_points;
    // Distribute temperature points
    if (rank < remainder) {
        i_points = points / cluster_size + 1;
        i_start = start + dt * i_points * rank;
    }
    else {
        i_points = points / cluster_size;
        i_start = start + dt * (i_points * rank + remainder);
    }
 
    data_t i_data[i_points];
    std::cout << "Rank " << rank << ": " << i_points << ',' << i_start << '\n';
 
    for (int L : lattice_sizes) {
        N = L * L;
        for (size_t i = 0; i < i_points; i++) {
            i_data[i] = monte_carlo_parallel(L, i_start + dt * i, cycles);
        }
 
        if (rank == 0) {
            std::copy_n(i_data, i_points, data);
            for (size_t i = 1; i < cluster_size; i++) {
                if (rank < remainder) {
                    MPI_Recv((void *)i_data,
                             sizeof(data_t) * (points / cluster_size + 1),
                             MPI_CHAR, i, MPI_ANY_TAG, MPI_COMM_WORLD,
                             MPI_STATUS_IGNORE);
                    std::copy_n(i_data, points / cluster_size + 1,
                                data + (points / cluster_size) * i);
                }
                else {
                    MPI_Recv((void *)i_data,
                             sizeof(data_t) * (points / cluster_size), MPI_CHAR,
                             i, MPI_ANY_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
                    std::copy_n(i_data, points / cluster_size,
                                data + (points / cluster_size) * i + remainder);
                }
            }
            std::stringstream outfile;
            outfile << "output/phase_transition/size_" << L << ".txt";
            utils::mkpath(utils::dirname(outfile.str()));
            ofile.open(outfile.str());
 
            double temp, CV, X;
 
            using utils::scientific_format;
            for (size_t i = 0; i < points; i++) {
                temp = start + dt * i;
                CV = (data[i].E2 - data[i].E * data[i].E)
                     / ((double)N * temp * temp);
                X = (data[i].M2 - data[i].M_abs * data[i].M_abs)
                    / ((double)N * temp);
 
                ofile << scientific_format(temp) << ','
                      << scientific_format(data[i].E / N) << ','
                      << scientific_format(data[i].M_abs / N) << ','
                      << scientific_format(CV) << ',' << scientific_format(X)
                      << '\n';
            }
            ofile.close();
        }
        else {
            MPI_Send(i_data, i_points * sizeof(data_t), MPI_CHAR, 0, rank,
                     MPI_COMM_WORLD);
        }
    }
 
    t1 = MPI_Wtime();
 
    if (rank == 0) {
        std::cout << "Time: " << t1 - t0 << " seconds\n";
    }
 
    MPI_Finalize();
}