Reference Manual

struct buff_part

#include <structures.h>

Particle buffer, managing particles’ MPI communications and injection.

This structure contains all required information when particles need to be either injected or communicated from one MPI process to another.

Public Members

int idx_free[buff_size_cst]

An array containing indices of free particles, indices corresponding to the particles’ pool object.

int next_idx = 0

Gives a single temporary index of a particle.

float buff_send[7 * buff_size_cst]

Send buffer, containing pool indices of particles to be communicated out.

float buff_rece[7 * buff_size_cst]

Receive buffer, containing pool indices of particles to be communicated in.

int next_idx_comm = 0

Temporary index.

int nb_part_send = 0

Number of particles to be sent.

int nb_part_rece = 0

Number of particles to be received.

int exosphere[3][nb_part_add_pla_cst]

float exo_proba[len_x_cst * len_y_cst * len_z_cst]

struct fields_time_space

#include <structures.h>

Public Members

float E[3][len_save_t_cst][len_save_x_cst]

float B[3][len_save_t_cst][len_save_x_cst]

float density[len_save_t_cst][len_save_x_cst]

struct house_keeping

#include <structures.h>

Public Members

int nbTruePart = 0

int nbFreeIndTot = 0

int nbPartSW[len_save_t_cst]

int nbPartPla[len_save_t_cst]

float simuTime[len_save_t_cst]

int runTime[len_save_t_cst]

int nb_part_comm_up[len_save_t_cst]

int nb_part_comm_down[len_save_t_cst]

int nb_pla_proba[len_save_t_cst]

struct injector

#include <structures.h>

Public Members

float B[3][2 + nb_cell_per_shift_cst][len_y_cst + 4][len_z_cst + 4]

float E[3][2 + nb_cell_per_shift_cst][len_y_cst + 4][len_z_cst + 4]

float Ji[3][2 + nb_cell_per_shift_cst][len_y_cst + 4][len_z_cst + 4]

float density[2 + nb_cell_per_shift_cst][len_y_cst + 4][len_z_cst + 4]

float rx[injec_size_cst]

float ry[injec_size_cst]

float rz[injec_size_cst]

float vx[injec_size_cst]

float vy[injec_size_cst]

float vz[injec_size_cst]

struct moments

#include <structures.h>

Public Members

float E_mag[len_save_t_cst]

float E_elec[len_save_t_cst]

float E_kin[len_save_t_cst]

float B_mean[3][len_save_t_cst]

float B_var[3][len_save_t_cst]

float dens_tot[len_save_t_cst]

float vel_tot[len_save_t_cst]

float Ji_mean[3][len_save_t_cst]

float vel_part[3][len_save_t_cst]

float vel_th_part[3][len_save_t_cst]

float temp_tot[len_save_t_cst]

int nb_part_tot[len_save_t_cst]

struct cnpy::NpyArray

#include <cnpy.h>

Public Functions

inline NpyArray(const std::vector<size_t> &_shape, size_t _word_size, bool _fortran_order)

inline NpyArray()

template<typename T>
inline T *data()

template<typename T>
inline const T *data() const

template<typename T>
inline std::vector<T> as_vec() const

inline size_t num_bytes() const

Public Members

std::shared_ptr<std::vector<char>> data_holder

std::vector<size_t> shape

size_t word_size

bool fortran_order

size_t num_vals

struct particles

#include <structures.h>

Public Members

float rx[pool_size_cst]

float ry[pool_size_cst]

float rz[pool_size_cst]

float vx[pool_size_cst]

float vy[pool_size_cst]

float vz[pool_size_cst]

bool active[pool_size_cst]

int ID[pool_size_cst]

struct root_mean_sqr

#include <structures.h>

Public Members

float meansqr

float mean

float B[3][len_save_t_cst]

float E[3][len_save_t_cst]

float Ji[3][len_save_t_cst]

float J_tot[3][len_save_t_cst]

float vort[3][len_save_t_cst]

struct simu_B_field

#include <structures.h>

Public Members

float B[3][len_x_cst + 4][len_y_cst + 4][len_z_cst + 4]

float B_dip[3][len_x_cst + 4][len_y_cst + 4][len_z_cst + 4]

class simu_B_field_2

#include <structures.h>

Public Functions

inline simu_B_field_2(simu_param *sP)

inline ~simu_B_field_2()

Public Members

float ***B

struct simu_fields

#include <structures.h>

Public Members

float E[3][len_x_cst + 4][len_y_cst + 4][len_z_cst + 4]

float density[len_x_cst + 4][len_y_cst + 4][len_z_cst + 4]

float density_b[len_x_cst + 4][len_y_cst + 4][len_z_cst + 4]

float counts[len_x_cst + 4][len_y_cst + 4][len_z_cst + 4]

float counts_pla[len_x_cst + 4][len_y_cst + 4][len_z_cst + 4]

float Lambda[len_x_cst + 4][len_y_cst + 4][len_z_cst + 4]

float Ji[3][len_x_cst + 4][len_y_cst + 4][len_z_cst + 4]

float Ji_b[3][len_x_cst + 4][len_y_cst + 4][len_z_cst + 4]

float fluxNum[3][len_x_cst + 4][len_y_cst + 4][len_z_cst + 4]

float fluxNum_pla[3][len_x_cst + 4][len_y_cst + 4][len_z_cst + 4]

float Gamma[3][len_x_cst + 4][len_y_cst + 4][len_z_cst + 4]

float J_tot[3][len_x_cst + 4][len_y_cst + 4][len_z_cst + 4]

float pres[len_x_cst + 4][len_y_cst + 4][len_z_cst + 4]

float vort[3][len_x_cst + 4][len_y_cst + 4][len_z_cst + 4]

float E_mot[3][len_x_cst + 4][len_y_cst + 4][len_z_cst + 4]

float E_hal[3][len_x_cst + 4][len_y_cst + 4][len_z_cst + 4]

float E_amb[3][len_x_cst + 4][len_y_cst + 4][len_z_cst + 4]

float E_res[3][len_x_cst + 4][len_y_cst + 4][len_z_cst + 4]

float smooth[len_x_cst + 4][len_y_cst + 4][len_z_cst + 4]

float buff_send_1d[4 * (len_x_cst + 4) * (len_z_cst + 4)]

float buff_reci_1d[4 * (len_x_cst + 4) * (len_z_cst + 4)]

struct simu_grid

#include <structures.h>

Public Members

float xGrid[len_x_cst + 4]

float yGrid[len_y_cst + 4]

float xMin

float xMax

float yMin

float yMax

float centre_x

float centre_y

float zGrid[len_z_cst + 4]

float zMin

float zMax

float centre_z

float rsq[len_x_cst + 4][len_y_cst + 4][len_z_cst + 4]

struct simu_param

#include <parameters.h>

Public Functions

inline void printout_parameters()

inline void output_parameters()

Public Members

float dX = 1.

float dt = 0.1

float n0_no_norm = 1.e6

float B0_no_norm = 2.5e-9

float v0 = 0.

float E0 = -v0 * B0_no_norm

float beta = 1.

float Ti_inf = beta * B0_no_norm * B0_no_norm / (n0_no_norm * k_B * 2. * mu0)

float Te_inf = 1. * Ti_inf

float e_mot = 1.

float e_hal = 1.

float e_amb = 1.

float poly_ind = 1.

float eta_res_norm = 0.

float eta_hyp_res = 1.e-2

float eta_res_vac = 1.e1

float eta_sm = 0.

float fluctu_sqrt = 0.5

float B0_x = 0.

float B0_y = 0.

float B0_z = -1.

float Q = 5.e26

float nu_i = 2.e-7

float nu_d = 5.0e-7

float u0 = 1000.

int Z_pla = 18

float centre_x = 5. / 8.

float centre_y = 1. / 2.

float centre_z = 1. / 2.

float dip_mom = 1.e5

float r_obs = 57.

float omega_i = std::sqrt(e * e * n0_no_norm / (eps0 * m_i))

float omega_ci = e * B0_no_norm / m_i

float v_A = B0_no_norm / std::sqrt(mu0 * m_i * n0_no_norm)

float t0 = 1 / omega_ci

float x0 = v_A / omega_ci

float q0 = e * n0_no_norm * x0 * x0 * x0

float m0 = m_i * n0_no_norm * x0 * x0 * x0

float p0 = B0_no_norm * B0_no_norm / (2. * mu0)

float d_i = c / omega_i

float omega_e = std::sqrt(e * e * n0_no_norm / (eps0 * m_e))

float omega_ce = e * B0_no_norm / m_e

float d_e = c / omega_e

float v_thi = std::sqrt(2. * k_B * Ti_inf / m_i)

float v_the = std::sqrt(2. * k_B * Te_inf / m_e)

float v_s = std::sqrt(k_B * (Te_inf + 3 * Ti_inf) / m_i)

float v_ms = std::sqrt(c * c * (v_A * v_A + v_s * v_s) / (v_A * v_A + c * c))

float lambda_D = std::sqrt(eps0 * k_B * Te_inf / (n0_no_norm * e * e))

float Beta_p = 2 * mu0 * n0_no_norm * k_B * Ti_inf / (B0_no_norm * B0_no_norm)

float Beta_e = 2 * mu0 * n0_no_norm * k_B * Te_inf / (B0_no_norm * B0_no_norm)

float v0_com = v_A * dX * nb_cell_per_shift_cst / (nb_it_per_shift_cst * dt)

float v_obs = dX * nb_cell_per_shift_cst / (nb_it_per_shift_cst * dt)

float R_gyr_norm = Z_pla * v0_com / v_A

float R_gyr = Z_pla * m_i * v0_com / (e * B0_no_norm)

int xLen = len_x_cst

int yLen = len_y_cst

int zLen = len_z_cst

float dX_i = 1. / dX

int nb_dim = NB_DIM

float tMax = dt * nb_it_max_cst

int nb_sub_cycles = 11

float sub_dt = dt / nb_sub_cycles

int rateSaveIt = std::max(1, int(.05 * tMax / dt))

int nb_nodes = len_x_cst * len_y_cst * len_z_cst

int nb_nodes_tot = (len_x_cst + 4) * (len_y_cst + 4) * (len_z_cst + 4)

int nb_part_add_sw = len_y_cst * len_z_cst * nb_part_node_cst

int nb_part_add_pla = 0

float sum_pla_proba = 0

float w_sw = 1. / nb_part_node_cst

float w_pla = 1.

float dens_min = 0.05

float nb_oscillations = 3.

float lambda_oscillation = xLen * dX / nb_oscillations

float k_oscillation = 2. * PI / lambda_oscillation

float omega_iaw = k_oscillation * v_s / v_A

float period_iaw = 2. * PI / omega_iaw

int mpi_rank = 0

int mpi_nb_proc = 0

int len_buff_field = int(4 * (len_x_cst + 4) * (len_z_cst + 4))

int nb_part_tank = 0

struct simu_tank

#include <structures.h>

Public Members

float B[3][len_x_cst + 4][len_y_cst + 4][len_z_cst + 4]

float E[3][len_x_cst + 4][len_y_cst + 4][len_z_cst + 4]

float Ji[3][len_x_cst + 4][len_y_cst + 4][len_z_cst + 4]

float density[len_x_cst + 4][len_y_cst + 4][len_z_cst + 4]

std::vector<size_t> idx_ordered

int sliceWidth[int(len_x_cst / nb_cell_per_shift_cst)]

int indFirstPartSlice[int(len_x_cst / nb_cell_per_shift_cst)]

int idx_x = 0

struct state_solver

#include <structures.h>

Public Members

bool breakSolver = false

bool invalidB = false

bool invalidE = false

bool invalidDens = false

bool invalidCurr = false

bool invalidCurrTot = false

bool invalid_new_part_idx = false

int error_ID = 0

std::string cuda_error_str = "cudaSuccess"

std::string error_str2[20] = {std::string("Error ID 1, cudaMalloc of particles."), std::string("Error ID 2, cudaMalloc of fields."), std::string("Error ID 3, empty."), std::string("Error ID 4, empty."), std::string("Error ID 5, empty."), std::string("Error ID 6, empty."), std::string("Error ID 7, empty."), std::string("Error ID 8, empty."), std::string("Error ID 9, empty."), std::string("Error ID 10, empty."), std::string("Error ID 11, empty."), std::string("Error ID 12, empty."), std::string("Error ID 13, empty."), std::string("Error ID 14, empty."), std::string("Error ID 15, empty."), std::string("Error ID 16, empty."), std::string("Error ID 17, empty."), std::string("Error ID 18, empty."), std::string("Error ID 19, empty."), std::string("Error ID 20, empty.")}

struct trajectory

#include <structures.h>

Public Members

float rx[len_save_t_cst]

float ry[len_save_t_cst]

float rz[len_save_t_cst]

float vx[len_save_t_cst]

float vy[len_save_t_cst]

float vz[len_save_t_cst]

namespace cnpy

Typedefs

using npz_t = std::map<std::string, NpyArray>

Functions

char BigEndianTest()

char map_type(const std::type_info &t)

template<typename T>
std::vector<char> create_npy_header(const std::vector<size_t> &shape)

void parse_npy_header(FILE *fp, size_t &word_size, std::vector<size_t> &shape, bool &fortran_order)

void parse_npy_header(unsigned char *buffer, size_t &word_size, std::vector<size_t> &shape, bool &fortran_order)

void parse_zip_footer(FILE *fp, uint16_t &nrecs, size_t &global_header_size, size_t &global_header_offset)

npz_t npz_load(std::string fname)

NpyArray npz_load(std::string fname, std::string varname)

NpyArray npy_load(std::string fname)

template<typename T>
std::vector<char> &operator+=(std::vector<char> &lhs, const T rhs)

template<>
std::vector<char> &operator+=(std::vector<char> &lhs, const std::string rhs)

template<>
std::vector<char> &operator+=(std::vector<char> &lhs, const char *rhs)

template<typename T>
void npy_save(std::string fname, const T *data, const std::vector<size_t> shape, std::string mode = "w")

template<typename T>
void npz_save(std::string zipname, std::string fname, const T *data, const std::vector<size_t> &shape, std::string mode = "w")

template<typename T>
void npy_save(std::string fname, const std::vector<T> data, std::string mode = "w")

template<typename T>
void npz_save(std::string zipname, std::string fname, const std::vector<T> data, std::string mode = "w")

file cnpy.cpp

#include “cnpy.h”#include <complex>#include <cstdlib>#include <algorithm>#include <cstring>#include <iomanip>#include <stdint.h>#include <stdexcept>#include <regex>

Functions

cnpy::NpyArray load_the_npy_file(FILE *fp)

cnpy::NpyArray load_the_npz_array(FILE *fp, uint32_t compr_bytes, uint32_t uncompr_bytes)

file cnpy.h

#include <string>#include <stdexcept>#include <sstream>#include <vector>#include <cstdio>#include <typeinfo>#include <iostream>#include <cassert>#include <zlib.h>#include <map>#include <memory>#include <stdint.h>#include <numeric>

file functions_i.cpp

#include <cmath>#include <time.h>#include “parameters.h”#include “structures.h”#include “functions_i.h”#include “functions_o.h”#include “cnpy.h”#include <iostream>#include <fstream>#include <algorithm>#include “mpi.h”

Functions

template<typename T>
int sgn(T val)

float normalSample(float mean = 0.0, float standardDeviation = 1.0)

… Yo ye yi …

void shuffleOwn(int *arr, size_t n)

void init_house_keeping(moments *mom, trajectory *traj, root_mean_sqr *rms, simu_param *sP, house_keeping *h_k, state_solver *sta_sol)

void init_grid(simu_grid *grid, simu_param *sP)

void init_fields(simu_fields *fields, simu_param *sP)

void init_B(simu_B_field *B, simu_param *sP)

void init_B_2(simu_B_field_2 *B, simu_param *sP)

void init_B_dipole(simu_B_field *B, simu_param *sP, simu_grid *grid)

void init_alfven_fluctuations(simu_B_field *B, simu_param *sP)

void init_part_node(particles *p, simu_grid *grid, simu_param *sP)

Initialises the particles “locally”.

Iterates over each node, distributing nb_part_nodes_cst per node uniformly, using a maxwellian distribution for velocity components.

Param

void init_part_acoustic(particles *p, simu_grid *grid, simu_param *sP)

void init_part_2_stream(particles *p, simu_grid *grid, simu_param *sP)

void init_fluctuations(simu_B_field *B, particles *p, simu_grid *grid, simu_param *sP, MPI_Comm comm)

void init_exosphere(buff_part *b_p, simu_grid *grid, simu_param *sP, MPI_Comm comm)

void load_B_field(simu_B_field *B, simu_tank *tank, simu_param *sP)

void load_fields(simu_fields *fields, simu_tank *tank, simu_param *sP)

void load_particles(particles *p, simu_grid *grid, simu_tank *tank, simu_param *sP, MPI_Comm comm)

file functions_i.h

#include “parameters.h”#include “mpi.h”

Functions

float normalSample(float mean, float standardDeviation)

… Yo ye yi …

void shuffleOwn(int *arr, size_t n)

void init_house_keeping(moments *mom, trajectory *traj, root_mean_sqr *rms, simu_param *sP, house_keeping *h_k, state_solver *sta_sol)

void init_grid(simu_grid *grid, simu_param *sP)

void init_grid_test(simu_grid *grid, simu_param *sP)

void init_fields(simu_fields *fields, simu_param *sP)

void init_B(simu_B_field *B, simu_param *sP)

void init_B_2(simu_B_field_2 *B, simu_param *sP)

void init_B_dipole(simu_B_field *B, simu_param *sP, simu_grid *grid)

void init_alfven_fluctuations(simu_B_field *B, simu_param *sP)

void init_part_node(particles *p, simu_grid *grid, simu_param *sP)

Initialises the particles “locally”.

Iterates over each node, distributing nb_part_nodes_cst per node uniformly, using a maxwellian distribution for velocity components.

Param

void init_part_global(particles *p, simu_grid *grid, simu_param *sP)

void init_part_2_stream(particles *p, simu_grid *grid, simu_param *sP)

void init_part_acoustic(particles *p, simu_grid *grid, simu_param *sP)

void correctBulk(particles *p, simu_param *sP)

void addFluctuations(simu_B_field *B, particles *p, simu_grid *grid, simu_param *sP, MPI_Comm comm)

void init_fluctuations(simu_B_field *B, particles *p, simu_grid *grid, simu_param *sP, MPI_Comm comm)

void initFluctuations(simu_B_field *B, particles *p, simu_grid *grid, simu_param *sP)

void initFluctuationsNew(simu_B_field *B, particles *p, simu_grid *grid, simu_param *sP)

void init_exosphere(buff_part *b_p, simu_grid *grid, simu_param *sP, MPI_Comm comm)

void load_B_field(simu_B_field *B, simu_tank *tank, simu_param *sP)

void load_fields(simu_fields *fields, simu_tank *tank, simu_param *sP)

void load_particles(particles *p, simu_grid *grid, simu_tank *tank, simu_param *sP, MPI_Comm comm)

file functions_o.cpp

#include <cmath>#include <time.h>#include “parameters.h”#include “structures.h”#include “functions_o.h”#include “cnpy.h”#include <iostream>#include <fstream>#include <algorithm>#include “mpi.h”

Functions

template<typename T>
int sgn(T val)

void output_HK(house_keeping *HK, trajectory *traj, moments *mom, root_mean_sqr *rms, simu_param *sP, int idx_save)

void output_particles(particles *p, int indIt, simu_param *sP)

void output_fields(simu_fields *fields, int indIt, simu_param *sP)

void output_fields_time_space(fields_time_space *fields_t_s, int indIt, simu_param *sP)

void output_density_species(simu_fields *fields, int ind_it, simu_param *sP)

void output_ohm_components(simu_B_field *B, simu_fields *fields, simu_param *sP, int ind_it)

void output_B_field(simu_B_field *B, int ind_it, simu_param *sP)

void output_grid(simu_grid *grid, simu_param *sP)

file functions_o.h

#include “parameters.h”

Functions

void output_HK(house_keeping *HK, trajectory *traj, moments *mom, root_mean_sqr *rms, simu_param *sP, int idx_save)

void output_particles(particles *p, int indIt, simu_param *sP)

void output_fields(simu_fields *fields, int indIt, simu_param *sP)

void output_fields_time_space(fields_time_space *fields_t_s, int indIt, simu_param *sP)

void output_density_species(simu_fields *fields, int ind_it, simu_param *sP)

void output_ohm_components(simu_B_field *B, simu_fields *fields, simu_param *sP, int ind_it)

void output_B_field(simu_B_field *B, int indIt, simu_param *sP)

void output_grid(simu_grid *grid, simu_param *sP)

void outputFiles(particles *p, simu_grid *grid, float curr[3][len_x_cst][len_y_cst], float dens[len_x_cst][len_y_cst], float E[3][len_x_cst][len_y_cst], float B[3][len_x_cst][len_y_cst], int indIt, float energies[12][nb_it_max_cst])

void sortie()

file kernels_calls.h

#include “kernels_fields.cuh”#include “kernels_particles.cuh”#include “kernels_HK.cuh”#include “kernels_particles_to_grid.cuh”#include “mpi.h”

Functions

void count_rms(simu_B_field *B, simu_fields *fields, root_mean_sqr *rms, int idx_save, int threadsPerBlock, simu_param *sP_h, simu_param *sP_d)

void copy_guard_cells(float G[3][len_x_cst + 4][len_y_cst + 4][len_z_cst + 4])

void add_copy_guard_cells_scalar(float G[len_x_cst + 4][len_y_cst + 4][len_z_cst + 4])

void add_copy_guard_cells_vector(float G[3][len_x_cst + 4][len_y_cst + 4][len_z_cst + 4])

void MPI_receive_send_guard_cells_down(simu_fields *fields, simu_param *sP, MPI_Comm comm)

void MPI_receive_send_guard_cells_up(simu_fields *fields, simu_param *sP, MPI_Comm comm)

void MPI_communicate_scalar(float G[len_x_cst + 4][len_y_cst + 4][len_z_cst + 4], simu_fields *fields, simu_param *sP, MPI_Comm comm, bool copy_long = true)

void comm_boundaries_density(simu_fields *fields, float density[len_x_cst + 4][len_y_cst + 4][len_z_cst + 4], injector *injec, simu_param *sP, MPI_Comm comm, int idx_it)

void comm_boundaries_curr(simu_fields *fields, float Ji[3][len_x_cst + 4][len_y_cst + 4][len_z_cst + 4], injector *injec, simu_param *sP, MPI_Comm comm)

void comm_boundaries_vector_field(simu_fields *fields, float G[3][len_x_cst + 4][len_y_cst + 4][len_z_cst + 4], simu_param *sP, MPI_Comm comm)

void moments_mapping(particles *pa, simu_fields *fields, simu_grid *grid, injector *injec, simu_param *sP_d, simu_param *sP_h, int idx_it, bool moments_b, int tag)

void ohm(simu_B_field *B, simu_fields *fields, simu_grid *grid, int indIt, simu_param *sP_h, simu_param *sP_d, MPI_Comm comm, int ohm_ID)

void faraday(simu_B_field *Bb, simu_B_field *Ba, simu_fields *fields, float sub_dt, simu_param *sP_d, simu_param *sP_h)

void check_grids(simu_B_field *B, simu_fields *fields, state_solver *staSol, int indIt, int nb_nodes_tot, int tag, simu_param *sP_h, simu_param *sP_d)

void increment_ind_slice(simu_tank *tank_h)

void copy_injector(particles *p, simu_tank *tank_h, injector *injec_h, int nb_part_in_slice, simu_param *sP, int idx_it)

void receive_send_part_down(buff_part *b_p, simu_param *sP, house_keeping *h_k, MPI_Comm comm, int idx_it)

void receive_send_part_up(buff_part *b_p, simu_param *sP, house_keeping *h_k, MPI_Comm comm, int idx_it)

void comm_part(particles *p, simu_grid *grid, buff_part *b_p, simu_param *sP_h, simu_param *sP_d, house_keeping *h_k, MPI_Comm comm, int idx_it)

file kernels_fields.cuh

#include <cuda_runtime.h>#include <curand.h>#include <curand_kernel.h>#include “parameters.h”

Defines

__KERNELSFIELDS_CUH_INCLUDED__

Functions

__global__ void faraday_k (simu_B_field *Bout, simu_B_field *Bin, simu_fields *fields, float deltaT, simu_param *sP)

__global__ void curlB_k (simu_B_field *B, simu_fields *fields, simu_param *sP)

__global__ void pressure_k (simu_fields *fields, float dens[len_x_cst+4][len_y_cst+4][len_z_cst+4], simu_param *sP)

__global__ void ohm_k (simu_fields *fields, simu_B_field *B, simu_grid *grid, float density[len_x_cst+4][len_y_cst+4][len_z_cst+4], float Ji[3][len_x_cst+4][len_y_cst+4][len_z_cst+4], int indIt, simu_param *sP)

__global__ void ohm_components_k (simu_fields *fields, simu_B_field *B, int indIt, simu_param *sP)

__global__ void predict_correct_k (simu_B_field *Bout, simu_B_field *Bin)

__global__ void add_counts_k (simu_fields *fields, simu_param *sP)

__global__ void add_curr_k (simu_fields *fields, simu_param *sP)

__global__ void add_counts_b_k (simu_fields *fields, simu_param *sP)

__global__ void add_curr_b_k (simu_fields *fields, simu_param *sP, int ind_it)

__global__ void current_advance_k (simu_fields *fields, simu_B_field *B, simu_param *sP, int indIt)

__global__ void average_moments_k (simu_fields *fields)

__global__ void copy_fields_k (simu_B_field *Ba, simu_B_field *Bb, simu_fields *fields)

__global__ void shift_field_k (simu_B_field *Bb, simu_B_field *Ba, simu_fields *fields)

__global__ void inject_E_B_k (injector *injec, simu_B_field *Ba, simu_B_field *Bb, simu_fields *fields)

__global__ void inject_dens_k (injector *injec, float density[len_x_cst+4][len_y_cst+4][len_z_cst+4])

__global__ void inject_curr_k (injector *injec, float Ji[3][len_x_cst+4][len_y_cst+4][len_z_cst+4])

__global__ void inject_const_B_k (simu_B_field *B, simu_param *sP)

__global__ void inject_dens_const_k (float density[len_x_cst+4][len_y_cst+4][len_z_cst+4], simu_param *sP)

__global__ void clear_counts_flux_num_k (simu_fields *fields)

__global__ void add_copy_guard_X_k (float G[len_x_cst+4][len_y_cst+4][len_z_cst+4])

__global__ void add_copy_guard_Y_k (float G[len_x_cst+4][len_y_cst+4][len_z_cst+4])

__global__ void add_copy_guard_Z_k (float G[len_x_cst+4][len_y_cst+4][len_z_cst+4])

__global__ void copy_guard_X_k (float G[len_x_cst+4][len_y_cst+4][len_z_cst+4])

__global__ void copy_guard_Y_k (float G[len_x_cst+4][len_y_cst+4][len_z_cst+4])

__global__ void copy_guard_Z_k (float G[len_x_cst+4][len_y_cst+4][len_z_cst+4])

__global__ void copy_neighbour_X_k (float G[len_x_cst+4][len_y_cst+4][len_z_cst+4])

__global__ void fill_buff_down_k (simu_fields *fields, float G[len_x_cst+4][len_y_cst+4][len_z_cst+4])

__global__ void add_buff_down_k (simu_fields *fields, float G[len_x_cst+4][len_y_cst+4][len_z_cst+4])

__global__ void copy_buff_down_long_k (simu_fields *fields, float G[len_x_cst+4][len_y_cst+4][len_z_cst+4])

__global__ void copy_buff_down_short_k (simu_fields *fields, float G[len_x_cst+4][len_y_cst+4][len_z_cst+4])

__global__ void fill_buff_up_k (simu_fields *fields, float G[len_x_cst+4][len_y_cst+4][len_z_cst+4])

__global__ void copy_buff_up_long_k (simu_fields *fields, float G[len_x_cst+4][len_y_cst+4][len_z_cst+4])

__global__ void copy_buff_up_short_k (simu_fields *fields, float G[len_x_cst+4][len_y_cst+4][len_z_cst+4])

__global__ void vorticity_k (simu_fields *fields, int nbNode, simu_param *sP)

__global__ void smooth_field_k (float G[len_x_cst+4][len_y_cst+4][len_z_cst+4], simu_fields *fields)

__global__ void copy_smooth_k (float G[len_x_cst+4][len_y_cst+4][len_z_cst+4], simu_fields *fields)

file kernels_HK.cuh

#include <cuda_runtime.h>#include <curand.h>#include <curand_kernel.h>#include “parameters.h”

Defines

__KERNELSHK_H_INCLUDED__

Functions

__global__ void print_param_k (simu_param *sP)

__global__ void moments_particles_k (particles *p, moments *mom, int idx_save, simu_param *sP, house_keeping *HK)

__global__ void moments_grids_k (simu_B_field *B, simu_fields *fields, moments *mom, int idx_save)

__global__ void divide_moments_k (moments *mom, int idx_save, simu_param *sP)

__global__ void update_traj_k (particles *p, trajectory *traj, int ind_it, int indPart)

__global__ void update_fields_time_space_k (simu_fields *fields, simu_B_field *B, fields_time_space *fields_t_s, int idx_save, simu_param *sP)

__global__ void reset_rms_k (root_mean_sqr *rms)

__global__ void rms_k (root_mean_sqr *rms, simu_param *sP, float G[len_x_cst+4][len_y_cst+4][len_z_cst+4])

__global__ void sum_rms_k (root_mean_sqr *rms, simu_param *sP, float G[nb_it_max_cst], int idx_save)

__global__ void reset_state_solver_k (state_solver *sta_sol)

__global__ void check_grids_k (simu_B_field *B, simu_fields *fields, state_solver *staSol, int indIt, int nbNode, int tag, simu_param *sP)

__global__ void print_sta_sol_k (state_solver *staSol, int indIt, int tag)

__global__ void HK_run_time_k (house_keeping *HK, int idx_save, float t, int run_time)

__global__ void HK_nb_part_send_down_k (house_keeping *h_k, int nb_part_send, int idx_save)

__global__ void HK_nb_part_send_up_k (house_keeping *h_k, int nb_part_send, int idx_save)

file kernels_particles.cuh

#include <cuda_runtime.h>#include <curand.h>#include <curand_kernel.h>#include “parameters.h”

Defines

__KERNELSPARTICLES_CUH_INCLUDED__

Functions

__global__ void setup_rand_k (curandState *state, unsigned long seed, int n)

__device__ float generate (curandState *globalState, int ind)

__global__ void rand_uniform_k (float *randomFloatUni, curandState *globalState, int n)

__device__ float normal_sample_k (float mean=0.0, float standardDeviation=1.0, float u1=1., float u2=1.)

__global__ void boris_pos_k (particles *p, simu_grid *grid, simu_param *sP)

__global__ void boris_vel_k (particles *p, simu_fields *fields, simu_B_field *B, simu_grid *grid, simu_param *sP)

__global__ void boundaries_per_spec_k (particles *p, simu_grid *grid, simu_param *sP)

__global__ void upstream_downstream_boundary_k (particles *p, simu_grid *grid, simu_param *sP, int idx_it)

__global__ void add_part_SW_node_k (particles *p, buff_part *b_p, simu_grid *grid, float *randomFloatUni, simu_param *sP, float dx=0.)

__global__ void add_part_com_node_k (particles *p, buff_part *b_p, simu_grid *grid, float *randomFloatUni, int indIt, simu_param *sP)

__global__ void add_proba_com_k (particles *p, buff_part *b_p, simu_grid *grid, float *randomFloatUni, int indIt, simu_param *sP, state_solver *sta_sol, house_keeping *h_k)

__global__ void reset_idx_free_k (buff_part *b_p)

__global__ void update_idx_free_k (particles *p, buff_part *b_p)

__global__ void reset_idx_comm_k (buff_part *b_p)

__global__ void print_idx_comm_k (buff_part *b_p, int mpi_rank)

__global__ void search_idx_down_k (particles *p, simu_grid *grid, buff_part *b_p, simu_param *sP, int idx_it)

__global__ void search_idx_up_k (particles *p, simu_grid *grid, buff_part *b_p, simu_param *sP)

__global__ void update_nb_part_rece_k (buff_part *b_p, int nb_part_rece)

__global__ void copy_buff_part_k (particles *p, buff_part *b_p)

__global__ void shift_particles_k (particles *p, simu_param *sP)

__global__ void inject_part_k (injector *injec, particles *p, buff_part *b_p, simu_grid *grid, simu_param *sP, int nb_part_add, bool reinjection)

file kernels_particles_to_grid.cuh

#include <cuda_runtime.h>#include <curand.h>#include <curand_kernel.h>#include “parameters.h”

Defines

__KERNELSPARTICLESTOGRID_CUH_INCLUDED__

Functions

__global__ void part2grid_counts_flux_num_k (particles *p, simu_grid *grid, simu_fields *fields, simu_param *sP, int ind_it, int flag)

file menura.cu

#include <stdio.h>#include <iostream>#include <fstream>#include “parameters.h”#include “structures.h”#include “functions_i.h”#include “functions_o.h”#include “utils.h”#include “kernels_calls.h”#include “kernels_particles.cuh”#include “kernels_fields.cuh”#include “kernels_HK.cuh”#include “mpi.h”#include <cuda.h>#include <cuda_runtime.h>

Functions

int main(int argc, char *argv[])

file output_parameters.cpp

#include <fstream>#include “parameters.h”#include “structures.h”

Functions

int main(int argc, char *argv[])

file parameters.h

#include <stdio.h>#include <iostream>#include <fstream>#include <cmath>

Defines

NB_DIM

decay_turb_cst

obstacle_cst

inject_pla_cst

inject_turb_cst

solid_body_cst

dipole_cst

Variables

const float e = 1.602e-19

const float m_i = 1.673e-27

const float m_e = 9.109e-31

const float mu0 = 1.257e-6

const float eps0 = 8.85e-12

const float k_B = 1.3806e-23

const float c = 299792458.

const float PI = 3.14159265359f

const int len_x_cst = 24

const int len_y_cst = 6

const int len_z_cst = 12

const int nb_part_node_cst = 140

const int rate_save_x_cst = 2

const int len_save_x_cst = int(len_x_cst / rate_save_x_cst)

const int rate_save_y_cst = 2

const int len_save_y_cst = int(len_y_cst / rate_save_y_cst)

const int nb_it_max_cst = 10000

const int rate_save_t_cst = 10

const int len_save_t_cst = int(nb_it_max_cst / rate_save_t_cst)

const int rate_save_field_cst = 200

const int rate_save_particles_cst = 4000

const int nb_it_per_shift_cst = 3

const int nb_cell_per_shift_cst = 1

const unsigned int nb_nodes_cst = len_x_cst * len_y_cst * len_z_cst

const unsigned int nb_nodes_tot_cst = (len_x_cst + 4) * (len_y_cst + 4) * (len_z_cst + 4)

const unsigned int pool_size_cst = static_cast<unsigned int>(1.02 * nb_part_node_cst * len_x_cst * len_y_cst * len_z_cst)

const unsigned int tank_size_cst = static_cast<unsigned int>(1.1 * nb_part_node_cst * len_x_cst * len_y_cst * len_z_cst)

const unsigned int buff_size_cst = static_cast<unsigned int>((2 * nb_cell_per_shift_cst + .5) * nb_part_node_cst * len_y_cst * len_z_cst)

const unsigned int injec_size_cst = static_cast<unsigned int>((2 * nb_cell_per_shift_cst + .5) * nb_part_node_cst * len_y_cst * len_z_cst)

const unsigned int nb_part_add_pla_cst = 1000

const int idx_it_inject_cst = 10000

const int seed_val_cst = 0

const int tpb_cst = 256

const bool debug_mode_cst = false

file structures.h

#include “parameters.h”#include <vector>

file utils.h

#include <stdio.h>#include <iostream>#include <fstream>#include <cuda.h>#include <cuda_runtime.h>#include “mpi.h”#include <sys/types.h>#include <sys/stat.h>

Functions

void pre_checks()

void initialisation_cuda()

void debug_leo(int idx_it, int ind_it_save, int str_ind_save, bool exit_leo, particles *pa_h, particles *pa_d, simu_fields *fields_h, simu_fields *fields_d, simu_B_field *B_h, simu_B_field *B_d, simu_param *simu_param_h, house_keeping *HK_h, trajectory *traj_h, trajectory *traj_d, moments *mom_h, moments *mom_d, root_mean_sqr *rms_h, root_mean_sqr *rms_d)

void check_state(state_solver *sta_sol, simu_param *s_p, int error_ID = 0, cudaError_t err = cudaSuccess)

void check_memory_device(int rank, int tag)

void sortie()

dir /home/etienneb/Models/Menura/menura

dir /home/etienneb/Models/Menura/menura/src