globals.hpp

Go to the documentation of this file.

#ifndef GLOBALS_HPP
#define GLOBALS_HPP
#include <limits.h>
#include <string>
#include <cassert>
#include "space_settings.hpp"
#include "array_deep_copy.hpp"
#include "access_add.hpp"
#include "simd.hpp"
#ifdef USE_MPI
#include "my_mpi.hpp"
#endif

/* Return true if MPI rank is zero
 * */
inline bool is_rank_zero(){
#ifdef USE_MPI
    return SML_COMM_RANK==0;
#else
    return true;
#endif
}

/* Safely abort and exit the code
 * */
inline void exit_XGC(std::string msg){
    printf("%s",msg.c_str());
    fflush(stdout);
#ifdef USE_MPI
    MPI_Abort(SML_COMM_WORLD, 1);
#else
    exit(1);
#endif
}

/* Asserts condition
 * (Callable from Device)
 * (C++ has no standardized assert with a message)
 * */
KOKKOS_INLINE_FUNCTION void assert_XGC(bool cond, const char* msg){
    if(!cond){
        DEVICE_PRINTF("%s",msg);
        assert(false);
    }
}

/* Check that two integers multiplied together doesn't cause an overflow
 * */
inline bool causes_multiplication_overflow(int a,int b){
    int c = a*b;
    if(b==0) return false; // No overflow
    return !(c/b == a);
}

/* Check that two integers added together doesn't cause an overflow
 * */
inline bool causes_addition_overflow(int a,int b){
    if ( ((b > 0) && (a > INT_MAX - b))    // a + b would overflow
       ||((b < 0) && (a < INT_MIN - b)) ){ // a + b would underflow
        return true;
    } else {
        return false;
    }
}

enum SpeciesType {
    ELECTRON = 0,
    MAIN_ION = 1
};

enum KinType{
    DriftKin=0,
    GyroKin=1
};

enum ParticlePhase {
    PIR = 0, 
    PIZ,     
    PIP,     
    PIRHO,   
    PIW1,    
    PIW2,    
    PTL_NPHASE
};

enum ParticleConsts {
    PIM = 0, 
    PIW0,    
    PIF0,    
    PTL_NCONST
};

const double UNIT_CHARGE = 1.6022e-19; 
const double EV_2_J=UNIT_CHARGE;       
const double J_2_EV=1.0/EV_2_J;        
const double PROTON_MASS = 1.6720e-27;            //< proton mass (MKS)
const double PI        = 3.1415926535897932;    //< pi
const double TWOPI     = 6.2831853071795862;    //< 2 pi

// Divide two integers, then round up
KOKKOS_INLINE_FUNCTION int divide_and_round_up(int a, int b){
    return (a+b-1)/b;
}

/*** SIMD structures (probably temporary) ****/


struct SimdVector2D{
    Simd<double> r;
    Simd<double> z;
};

struct SimdVector{
    Simd<double> r;
    Simd<double> z;
    Simd<double> phi;

    // Vector operation, sets SimdVector to 0.0
    KOKKOS_INLINE_FUNCTION void zero(){
        for (int i_simd = 0; i_simd<SIMD_SIZE; i_simd++){
            r[i_simd] = 0.0;
            z[i_simd] = 0.0;
            phi[i_simd] = 0.0;
        }
    }
};

#endif