Simulation.hpp

 
#ifndef SIMULATION_HPP
#define SIMULATION_HPP
 
#include "Cell.hpp"
 
#include <fstream>
#include <vector>
#include <SFML/Graphics.hpp>
 
class Simulation{
private:
 
    int m_length_box; // Length of the box
    int m_number_of_cases; // Number of cases in the box
    int m_number_of_steps; // Number of steps in the simulation
 
    float m_kT; // Temperature
 
    std::vector<Cell*> m_cells_array;
    std::vector<std::vector<int>> m_lattice; // Lattice of integer for cell id
 
    std::vector<std::vector <float>> m_J; // J matrix
    std::vector<float> m_lambda_surface; // Lambda surface vector for each cell type
    std::vector<float> m_lambda_length; // Lambda length vector for each cell type
    std::vector<float> m_lambda_chemotaxis; // Lambda chemotaxis vector for each cell type
 
    std::vector<std::vector<double>> m_concentration_matrix; // Matrix for the concentration of every elements
 
public:
    // Constructor/Destructor
    Simulation(int length_box, int number_of_steps, std::vector<std::vector <float>> J, std::vector<float> lambda_surface, std::vector<float> lambda_length, 
        std::vector<float> lambda_chemotaxis, float kT);
    ~Simulation();
 
    // Getters
    int get_length_box();
    int get_number_of_cases();
    int get_number_of_steps();
    int get_number_of_cells();
    std::vector<Cell*> get_cells_array();
    std::vector<std::vector<int>> get_lattice();
    std::vector<std::vector <float>> get_J();
    std::vector<float> get_lambda_surface();
 
    // Setters
    void set_cells_array(std::vector<Cell*> cells_array);
    void set_lattice(std::vector<std::vector<int>> lattice);
 
    // Methods
 
    // LATTICE MANIPULATION -----------------------------------------------------
 
    // Initialize lattice
    void initialize_lattice(bool is_periodic);
    // Display lattice
    void display_lattice();
 
    // CELL MANIPULATION --------------------------------------------------------
 
    // Create a cell
    Cell* create_cell(int type, int target_surface, float target_length,sf::Color color);
    // Add a cell to the lattice
    void add_cell_to_lattice(Cell* c, int safe_distance);
    // Remove a cell from the lattice
    void remove_cell_from_lattice(Cell* c);
    // Update the length of cells
    void updateCellsLength();
 
    // SAVING --------------------------------------------------------------------
    
    // Create header of data file
    void write_header(std::ofstream &file);
    // Write tail of data file
    void write_tail(std::ofstream &file, float total_time);
    // Save the lattice
    void save_lattice(std::ofstream &file, int step, float time);
 
    // SIMULATION ----------------------------------------------------------------
 
    float calculate_energy_of_two_sites(int x1, int y1, int x2, int y2);
 
    float calculate_energy_of_site(int x, int y);
 
    // Hamiltonian
    float calculate_total_hamiltonian();
 
    // Check if the connectivity is broken
    bool is_connectivity_broken(int x_trial, int y_trial, int cell_id);
 
    // Local hamiltonian, should be enough to calculate the change in energy
    float calculate_local_hamiltonian(int x_trial, int y_trial, int cell_id_trial, int x, int y, int cell_id);
 
    // Metropolis algorithm
    void metropolis_algorithm(int x, int y, int x_trial, int y_trial, float delta_H);
 
    // Monte Carlo step
    std::vector<int> monte_carlo_step();
 
    // Simulation step
    void simulation_step();
 
    // Running the simulation -----------------------------------------------------
 
    // Run the simulation (no rendering)
    void run_simulation();
 
    // Run the simulation (no rendering) and save the data
    void run_and_save_simulation(int nb_save, const char* filename);
 
    // SMFL RENDERING ------------------------------------------------------------
 
    void run_simulation_sfml(const char* filename);
 
    void run_simulation_sfml_diff(const char* filename);
 
    void updateCellShape(int x, int y, sf::RectangleShape& shape);
};
 
 
#endif // SIMULATION_HPP