common.h

Go to the documentation of this file.

/*
 * This file is part of Vlasiator.
 * Copyright 2010-2016 Finnish Meteorological Institute
 *
 * For details of usage, see the COPYING file and read the "Rules of the Road"
 * at http://www.physics.helsinki.fi/vlasiator/
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
#ifndef COMMON_H
#define COMMON_H
 
#include <limits>
#include <string>
#include <vector>
#include <span>
#include "definitions.h"
 
// Include architecture specific definitions
#include "arch/arch_device_api.h"
 
#ifdef DEBUG_SOLVERS
#define CHECK_FLOAT(x) \
   if ((x) != (x)) {\
      std::cerr << __FILE__ << ":" << __LINE__ << " Illegal value: " << x << std::endl;\
      abort();\
   }
#else
#define CHECK_FLOAT(x) {}
#endif
 
void bailout(
   const bool condition,
   const std::string& message
);
void bailout(
   const bool condition,
   const char * const file,
   const int line
);
void bailout(
   const bool condition,
   const std::string& message,
   const char * const file,
   const int line
);
 
[[ noreturn ]] void abort_mpi(const std::string str, const int err_type = 0);
 
#define sqr(x) ((x)*(x))
#define pow2(x) sqr(x)
#define pow3(x) ((x)*(x)*(x))
 
#define MASTER_RANK 0
 
 
/* Maximum number of blocks in each dimension in velocity space. The
   size of velocity space defined in cfg can at maximum be this large
*/
#define MAX_BLOCKS_PER_DIM 256
 
namespace Neighborhoods {
   enum {
      VLASOV_SOLVER,   
      VLASOV_SOLVER_X, 
      VLASOV_SOLVER_Y, 
      VLASOV_SOLVER_Z, 
      VLASOV_SOLVER_TARGET_X, 
      VLASOV_SOLVER_TARGET_Y, 
      VLASOV_SOLVER_TARGET_Z, 
      SYSBOUNDARIES, 
      SYSBOUNDARIES_EXTENDED, 
      NEAREST,  
      FULL,      
      DIST_FUNC, 
      SHIFT_P_X, 
      SHIFT_P_Y, 
      SHIFT_P_Z, 
      SHIFT_M_X, 
      SHIFT_M_Y, 
      SHIFT_M_Z, 
      VLASOV_SOLVER_X_GHOST, 
      VLASOV_SOLVER_Y_GHOST,  
      VLASOV_SOLVER_Z_GHOST, 
      VLASOV_SOLVER_GHOST, 
      VLASOV_SOLVER_GHOST_REQNEIGH, 
      N_NEIGHBORHOODS
   };
}
 

namespace BlockParams {
   enum {
      VXCRD,   
      VYCRD,   
      VZCRD,   
      DVX,     
      DVY,     
      DVZ,     
      N_VELOCITY_BLOCK_PARAMS
   };
}

namespace CellParams {
   enum {
      XCRD,   
      YCRD,   
      ZCRD,   
      // DX,DY,DZ have to be consecutive.
      DX,     
      DY,     
      DZ,     
      RHOM,    
      VX,  
      VY,  
      VZ,  
      RHOQ,    
      RHOM_DT2,    
      VX_DT2,  
      VY_DT2,  
      VZ_DT2,  
      RHOQ_DT2,    
      BGBXVOL,   
      BGBYVOL,   
      BGBZVOL,   
      PERBXVOL,  
      PERBYVOL,  
      PERBZVOL,  
      EXGRADPE,         
      EYGRADPE,         
      EZGRADPE,         
      RHOM_R,     
      VX_R,   
      VY_R,   
      VZ_R,   
      RHOQ_R,     
      RHOM_V,     
      VX_V,   
      VY_V,   
      VZ_V,   
      RHOQ_V,     
      P_11,     
      P_22,     
      P_33,     
      P_23,     
      P_13,     
      P_12,     
      P_11_DT2, 
      P_22_DT2, 
      P_33_DT2, 
      P_23_DT2, 
      P_13_DT2, 
      P_12_DT2, 
      P_11_R,   
      P_22_R,   
      P_33_R,   
      P_23_R,   
      P_13_R,   
      P_12_R,   
      P_11_V,   
      P_22_V,   
      P_33_V,   
      P_23_V,   
      P_12_V,   
      P_13_V,   
      EXVOL,    
      EYVOL,    
      EZVOL,    
      MAXVDT,             
      MAXRDT,             
      MAXFDT,             
      LBWEIGHTCOUNTER,    
      ISCELLSAVINGF,      
      FSGRID_RANK, 
      FSGRID_BOUNDARYTYPE, 
      CELLID, 
      REFINEMENT_LEVEL, 
      CONNECTION, 
      CONNECTION_FW_X, 
      CONNECTION_FW_Y, 
      CONNECTION_FW_Z, 
      CONNECTION_BW_X, 
      CONNECTION_BW_Y, 
      CONNECTION_BW_Z, 
      CURVATUREX, 
      CURVATUREY, 
      CURVATUREZ, 
      FLUXROPE,   
      AMR_DRHO,
      AMR_DU,
      AMR_DPSQ,
      AMR_DBSQ,
      AMR_DB,
      AMR_ALPHA1,
      AMR_ALPHA2,
      P_ANISOTROPY,
      AMR_VORTICITY,
      RECENTLY_REFINED,
      BULKV_FORCING_X, 
      BULKV_FORCING_Y, 
      BULKV_FORCING_Z, 
      NU0, 
      N_SPATIAL_CELL_PARAMS
   };
}

namespace bvolderivatives {
   enum {
      dPERBXVOLdx, 
      dPERBXVOLdy, 
      dPERBXVOLdz, 
      dPERBYVOLdx, 
      dPERBYVOLdy, 
      dPERBYVOLdz, 
      dPERBZVOLdx, 
      dPERBZVOLdy, 
      dPERBZVOLdz, 
      N_BVOL_DERIVATIVES
   };
}
 
namespace vderivatives {
   // Essentially a copy from dmoments
   enum {
      dVxdx,     
      dVxdy,     
      dVxdz,     
      dVydx,     
      dVydy,     
      dVydz,     
      dVzdx,     
      dVzdy,     
      dVzdz,     
      N_V_DERIVATIVES
   };
}

namespace fsgrids {
   enum bfield : int {
      PERBX,  
      PERBY,  
      PERBZ,  
      N_BFIELD
   };
 
   enum efield {
      EX,     
      EY,     
      EZ,     
      N_EFIELD
   };
 
   enum ehall {
      EXHALL_000_100,   
      EYHALL_000_010,   
      EZHALL_000_001,   
      EYHALL_100_110,   
      EZHALL_100_101,   
      EXHALL_010_110,   
      EZHALL_010_011,   
      EZHALL_110_111,   
      EXHALL_001_101,   
      EYHALL_001_011,   
      EYHALL_101_111,   
      EXHALL_011_111,   
      N_EHALL
   };
 
   enum egradpe {
      EXGRADPE,         
      EYGRADPE,         
      EZGRADPE,         
      N_EGRADPE
   };
 
   enum moments {
      RHOM, 
      RHOQ, 
      VX,   
      VY,   
      VZ,   
      P_11, 
      P_22, 
      P_33, 
      N_MOMENTS
   };
 
   enum dperb {
      dPERBxdy,     
      dPERBxdz,     
      dPERBydx,     
      dPERBydz,     
      dPERBzdx,     
      dPERBzdy,     
      dPERBxdyy,     
      dPERBxdzz,     
      dPERBxdyz,     
      dPERBydxx,     
      dPERBydzz,     
      dPERBydxz,     
      dPERBzdxx,     
      dPERBzdyy,     
      dPERBzdxy,     
      N_DPERB
   };
 
   enum dmoments {
      drhomdx,    
      drhomdy,    
      drhomdz,    
      drhoqdx,    
      drhoqdy,    
      drhoqdz,    
      dp11dx,        
      dp11dy,        
      dp11dz,        
      dp22dx,        
      dp22dy,        
      dp22dz,        
      dp33dx,        
      dp33dy,        
      dp33dz,        
      dVxdx,     
      dVxdy,     
      dVxdz,     
      dVydx,     
      dVydy,     
      dVydz,     
      dVzdx,     
      dVzdy,     
      dVzdz,     
      dPedx,    
      dPedy,    
      dPedz,    
      N_DMOMENTS
   };
 
   // NOTE This contains the BGB derivatives as they do not change either
   enum bgbfield : int  {
      BGBX,   
      BGBY,   
      BGBZ,   
      BGBXVOL,   
      BGBYVOL,   
      BGBZVOL,   
      BGBXVDCORR, 
      BGBYVDCORR, 
      BGBZVDCORR, 
      dBGBxdy,     
      dBGBxdz,     
      dBGBydx,     
      dBGBydz,     
      dBGBzdx,     
      dBGBzdy,     
      dBGBXVOLdx,  
      dBGBXVOLdy,  
      dBGBXVOLdz,  
      dBGBYVOLdx,  
      dBGBYVOLdy,  
      dBGBYVOLdz,  
      dBGBZVOLdx,  
      dBGBZVOLdy,  
      dBGBZVOLdz,  
      N_BGB
   };
 
   // NOTE This contains the PERBVOL derivatives
   enum volfields {
      PERBXVOL,  
      PERBYVOL,  
      PERBZVOL,  
      dPERBXVOLdx, 
      dPERBXVOLdy, 
      dPERBXVOLdz, 
      dPERBYVOLdx, 
      dPERBYVOLdy, 
      dPERBYVOLdz, 
      dPERBZVOLdx, 
      dPERBZVOLdy, 
      dPERBZVOLdz, 
      EXVOL,   
      EYVOL,   
      EZVOL,   
      CURVATUREX, 
      CURVATUREY, 
      CURVATUREZ, 
      N_VOL
   };
 
   struct technical {
      uint sysBoundaryFlag;  
      int sysBoundaryLayer; 
      Real maxFsDt;         
      int fsGridRank;       
      uint SOLVE;           
      int refLevel;         
   };
 
   typedef std::span<std::array<Real, fsgrids::bfield::N_BFIELD>> perbspan;
   typedef std::span<const std::array<Real, fsgrids::bfield::N_BFIELD>> constperbspan;
   typedef std::span<std::array<Real, fsgrids::efield::N_EFIELD>> efieldspan;
   typedef std::span<const std::array<Real, fsgrids::efield::N_EFIELD>> constefieldspan;
   typedef std::span<std::array<Real, fsgrids::ehall::N_EHALL>> ehallspan;
   typedef std::span<const std::array<Real, fsgrids::ehall::N_EHALL>> constehallspan;
   typedef std::span<std::array<Real, fsgrids::egradpe::N_EGRADPE>> egradpespan;
   typedef std::span<const std::array<Real, fsgrids::egradpe::N_EGRADPE>> constegradpespan;
   typedef std::span<std::array<Real, fsgrids::dperb::N_DPERB>> dperbspan;
   typedef std::span<const std::array<Real, fsgrids::dperb::N_DPERB>> constdperbspan;
   typedef std::span<std::array<Real, bgbfield::N_BGB>> bgbspan;
   typedef std::span<const std::array<Real, bgbfield::N_BGB>> constbgbspan;
   typedef std::span<std::array<Real, fsgrids::moments::N_MOMENTS>> momentsspan;
   typedef std::span<const std::array<Real, fsgrids::moments::N_MOMENTS>> constmomentsspan;
   typedef std::span<std::array<Real, fsgrids::dmoments::N_DMOMENTS>> dmomentsspan;
   typedef std::span<const std::array<Real, fsgrids::dmoments::N_DMOMENTS>> constdmomentsspan;
   typedef std::span<std::array<Real, fsgrids::volfields::N_VOL>> volspan;
   typedef std::span<const std::array<Real, fsgrids::volfields::N_VOL>> constvolspan;
   typedef std::span<technical> technicalspan;
   typedef std::span<const technical> consttechnicalspan;
 
}
 
// Ionosphere node parameters
enum ionosphereParameters {
  SOURCE,    
  SIGMA,   SIGMA12, SIGMA13,
  SIGMA21, SIGMA22, SIGMA23, 
  SIGMA31, SIGMA32, SIGMA33,
 
  SIGMAP,   
  SIGMAH,   
  SIGMAPARALLEL, 
  PRECIP,   
  RHON,     
  TEMPERATURE, 
  NODE_BX,NODE_BY,NODE_BZ, 
  UPMAPPED_BX,UPMAPPED_BY,UPMAPPED_BZ, 
  SOLUTION, 
  BEST_SOLUTION, 
  RESIDUAL, 
  RRESIDUAL,
  ZPARAM, ZZPARAM,
  PPPARAM, PPARAM,
  N_IONOSPHERE_PARAMETERS
};

namespace sysboundarytype {
   enum {
      DO_NOT_COMPUTE,   
      NOT_SYSBOUNDARY,  
      IONOSPHERE,       
      OUTFLOW,          
      MAXWELLIAN,       
      COPYSPHERE,       
      OUTER_BOUNDARY_PADDING, 
      N_SYSBOUNDARY_CONDITIONS
   };
}
 
namespace compute {
   const uint BX = (1 << 0); // 1
   const uint BY = (1 << 1); // 2
   const uint BZ = (1 << 2); // 4
   const uint EX = (1 << 3); // 8
   const uint EY = (1 << 4); // 16
   const uint EZ = (1 << 5); // 32
}

enum {RK_ORDER1,   
RK_ORDER2_STEP1,   
RK_ORDER2_STEP2    
};
 
#ifndef WID
#define WID (4)              
#endif
const int WID2 = WID*WID;  
const int WID3 = WID2*WID; 

template<typename INT> ARCH_HOSTDEV inline INT cellIndex(const INT& i,const INT& j,const INT& k) {
   return k*WID2 + j*WID + i;
}
 
const int SIZE_VELBLOCK    = WID3; 
 
template<typename T> inline int sign(const T& value) {
   const T ZERO = 0.0;
   if (value < ZERO) return -1;
   return 1;
}

struct globalflags {
   static int bailingOut; 
   static bool writeRestart; 
   static bool writeRecover; 
   static bool balanceLoad; 
   static bool doRefine; 
   static bool ionosphereJustSolved; 
};
 
namespace donow {
   enum {
      SAVE,
      DORC,
      DOLB,
      DOMR,
      N_DONOW
   };
}
 

namespace hook {
   enum {
      END_OF_TIME_STEP
   };
}
 
 
// Natural constants
namespace physicalconstants {
   const Real EPS_0 = 8.85418782e-12; 
   const Real MU_0 = 1.25663706e-6;  
   const Real K_B = 1.3806503e-23;   
   const Real CHARGE = 1.60217653e-19; 
   const Real MASS_ELECTRON = 9.10938188e-31; 
   const Real MASS_PROTON = 1.67262158e-27; 
   const Real R_E = 6.3712e6; 
}
 
const std::vector<CellID>& getLocalCells();
 
#endif