particle.h

Go to the documentation of this file.

#ifndef PARTICLE_H
#define PARTICLE_H
 
#include "ascot5.h"
#include "B_field.h"
#include "E_field.h"
#include "error.h"

typedef struct {
    real r;           
    real phi;         
    real z;           
    real ppar;        
    real mu;          
    real zeta;        
    real rprt;        
    real phiprt;      
    real zprt;        
    real p_r;         
    real p_phi;       
    real p_z;         
    real mass;        
    real charge;      
    int  anum;        
    int  znum;        
    real weight;      
    real time;        
    real mileage;     
    real cputime;     
    real rho;         
    real theta;       
    integer id;       
    integer endcond;  
    integer walltile; 
    real B_r;         
    real B_phi;       
    real B_z;         
    real B_r_dr;      
    real B_phi_dr;    
    real B_z_dr;      
    real B_r_dphi;    
    real B_phi_dphi;  
    real B_z_dphi;    
    real B_r_dz;      
    real B_phi_dz;    
    real B_z_dz;      
 
    a5err err;        
} particle_state;

typedef struct {
    real r;      
    real phi;    
    real z;      
    real p_r;    
    real p_phi;  
    real p_z;    
    real mass;   
    real charge; 
    int  anum;   
    int  znum;   
    real weight; 
    real time;   
    integer id;  
} particle;

typedef struct {
    real r;      
    real phi;    
    real z;      
    real energy; 
    real pitch;  
    real zeta;   
    real mass;   
    real charge; 
    int  anum;   
    int  znum;   
    real weight; 
    real time;   
    integer id;  
} particle_gc;

typedef struct {
    real r;      
    real phi;    
    real z;      
    real pitch;  
    real weight; 
    real time;   
    integer id;  
} particle_ml;

typedef struct {
    int n;                 
    particle_state** p;    
    volatile int next;     
    volatile int finished; 
} particle_queue;

typedef enum input_particle_type {
    input_particle_type_p,  
    input_particle_type_gc, 
    input_particle_type_ml, 
    input_particle_type_s   
} input_particle_type;

typedef struct {
    input_particle_type type; 
    union {
        particle p;           
        particle_gc p_gc;     
        particle_ml p_ml;     
        particle_state p_s;   
    };
} input_particle;

typedef struct {
    /* Physical coordinates and parameters */
    real* r;       
    real* phi;     
    real* z;       
    real* p_r;     
    real* p_phi;   
    real* p_z;     
    real* mass;    
    real* charge;  
    real* time;    
    int* znum;     
    int* anum;     
 
    /* Magnetic field data */
    real* B_r;        
    real* B_phi;      
    real* B_z;        
 
    real* B_r_dr;     
    real* B_phi_dr;   
    real* B_z_dr;     
    real* B_r_dphi;   
    real* B_phi_dphi; 
    real* B_z_dphi;   
    real* B_r_dz;     
    real* B_phi_dz;   
    real* B_z_dz;     
 
    /* Quantities used in diagnostics */
    int* bounces;  
    real* weight;  
    real* cputime; 
    real* rho;     
    real* theta;   
 
    integer* id;       
    integer* endcond;  
    integer* walltile; 
 
    /* Meta data */
    real* mileage;    
    integer* running; 
    a5err* err;       
    integer* index;   
    size_t n_mrk;     
} particle_simd_fo;

typedef struct {
    /* Physical coordinates and parameters */
    real* r;      
    real* phi;    
    real* z;      
    real* ppar;   
    real* mu;     
    real* zeta;   
    real* mass;   
    real* charge; 
    real* time;   
 
    /* Magnetic field data */
    real* B_r;        
    real* B_phi;      
    real* B_z;        
 
    real* B_r_dr;     
    real* B_phi_dr;   
    real* B_z_dr;     
    real* B_r_dphi;   
    real* B_phi_dphi; 
    real* B_z_dphi;   
    real* B_r_dz;     
    real* B_phi_dz;   
    real* B_z_dz;     
 
    /* Quantities used in diagnostics */
    int* bounces;  
    real* weight;  
    real* cputime; 
    real* rho;     
    real* theta;   
 
    integer* id;       
    integer* endcond;  
    integer* walltile; 
 
    /* Meta data */
    real* mileage;    
    integer* running; 
    a5err* err;       
    integer* index;   
    size_t n_mrk;     
} particle_simd_gc;

typedef struct {
    /* Physical coordinates and parameters */
    real r[NSIMD] __memalign__;     
    real phi[NSIMD] __memalign__;   
    real z[NSIMD] __memalign__;     
    real pitch[NSIMD] __memalign__; 
    real time[NSIMD] __memalign__;  
 
    /* Magnetic field data */
    real B_r[NSIMD] __memalign__;        
    real B_phi[NSIMD] __memalign__;      
    real B_z[NSIMD] __memalign__;        
 
    real B_r_dr[NSIMD] __memalign__;     
    real B_phi_dr[NSIMD] __memalign__;   
    real B_z_dr[NSIMD] __memalign__;     
    real B_r_dphi[NSIMD] __memalign__;   
    real B_phi_dphi[NSIMD] __memalign__; 
    real B_z_dphi[NSIMD] __memalign__;   
    real B_r_dz[NSIMD] __memalign__;     
    real B_phi_dz[NSIMD] __memalign__;   
    real B_z_dz[NSIMD] __memalign__;     
 
    /* Quantities used in diagnostics */
    real weight[NSIMD] __memalign__;  
    real cputime[NSIMD] __memalign__; 
    real rho[NSIMD] __memalign__;     
    real theta[NSIMD] __memalign__;   
 
    integer id[NSIMD] __memalign__;       
    integer endcond[NSIMD] __memalign__;  
    integer walltile[NSIMD] __memalign__; 
 
    /* Meta data */
    real mileage[NSIMD] __memalign__;    
    integer running[NSIMD] __memalign__; 
    a5err err[NSIMD] __memalign__;       
    integer index[NSIMD] __memalign__;   
} particle_simd_ml;
 
 
void particle_allocate_fo(particle_simd_fo* p_fo, int nmrk);
void particle_allocate_gc(particle_simd_gc* p_gc, int nmrk);
void particle_to_fo_dummy(particle_simd_fo* p_fo, int j);
void particle_to_gc_dummy(particle_simd_gc* p_gc, int j);
void particle_to_fo_dummy(particle_simd_fo* p_fo, int j);
void particle_to_gc_dummy(particle_simd_gc* p_gc, int j);
void particle_to_ml_dummy(particle_simd_ml* p_ml, int j);
 
int particle_cycle_fo(particle_queue* q, particle_simd_fo* p,
                      B_field_data* Bdata, int* cycle);
int particle_cycle_gc(particle_queue* q, particle_simd_gc* p,
                      B_field_data* Bdata, int* cycle);
int particle_cycle_ml(particle_queue* q, particle_simd_ml* p,
                      B_field_data* Bdata, int* cycle);
 
void particle_input_to_state(input_particle* p, particle_state* ps,
                             B_field_data* Bdata);
a5err particle_input_p_to_state(particle* p, particle_state* ps,
                                B_field_data* Bdata);
a5err particle_input_gc_to_state(particle_gc* p, particle_state* ps,
                                 B_field_data* Bdata);
a5err particle_input_ml_to_state(particle_ml* p, particle_state* ps,
                                 B_field_data* Bdata);
 
void particle_offload_fo(particle_simd_fo* p);
void particle_onload_fo(particle_simd_fo* p);
void particle_offload_gc(particle_simd_gc* p);
void particle_onload_gc(particle_simd_gc* p);
 
DECLARE_TARGET_SIMD_UNIFORM(Bdata)
a5err particle_state_to_fo(particle_state* p, int i, particle_simd_fo* p_fo,
                           int j, B_field_data* Bdata);
DECLARE_TARGET_SIMD_UNIFORM(Bdata)
void particle_fo_to_state(particle_simd_fo* p_fo, int j, particle_state* p,
                          B_field_data* Bdata);
DECLARE_TARGET_SIMD_UNIFORM(Bdata)
a5err particle_state_to_gc(particle_state* p, int i, particle_simd_gc* p_gc,
                           int j, B_field_data* Bdata);
DECLARE_TARGET_SIMD_UNIFORM(Bdata)
void particle_gc_to_state(particle_simd_gc* p_gc, int j, particle_state* p,
                          B_field_data* Bdata);
DECLARE_TARGET_SIMD_UNIFORM(Bdata)
a5err particle_state_to_ml(particle_state* p, int i, particle_simd_ml* p_ml,
                           int j, B_field_data* Bdata);
DECLARE_TARGET_SIMD_UNIFORM(Bdata)
void particle_ml_to_state(particle_simd_ml* p_ml, int j, particle_state* p,
                          B_field_data* Bdata);
DECLARE_TARGET_SIMD_UNIFORM(p_fo,Bdata)
int particle_fo_to_gc(particle_simd_fo* p_fo, int j, particle_simd_gc* p_gc,
                      B_field_data* Bdata);
GPU_DECLARE_TARGET_SIMD
void particle_copy_fo(particle_simd_fo* p1, int i, particle_simd_fo* p2, int j);
DECLARE_TARGET_END
GPU_DECLARE_TARGET_SIMD
void particle_copy_gc(particle_simd_gc* p1, int i, particle_simd_gc* p2, int j);
DECLARE_TARGET_SIMD
void particle_copy_ml(particle_simd_ml* p1, int i, particle_simd_ml* p2, int j);
 
#endif