mcx_utils.h

Go to the documentation of this file.

/***************************************************************************/
/***************************************************************************/
#ifndef _MCEXTREME_UTILITIES_H
#define _MCEXTREME_UTILITIES_H

#include <stdio.h>
#include <vector_types.h>
#include "cjson/cJSON.h"
#include "float.h"
#include "nifti1.h"

#ifdef _OPENMP                      
    #include <omp.h>
#endif

#define EPS                FLT_EPSILON                   
#define VERY_BIG           (1.f/FLT_EPSILON)             
#define MAX_FULL_PATH       2048                         
#define MAX_PATH_LENGTH     1024                         
#define MAX_SESSION_LENGTH  256                          
#define MAX_DEVICE          256                          
#define MCX_CUDA_ERROR_LAUNCH_FAILED    719              
#ifndef MCX_CUDA_ARCH
    #define MCX_CUDA_ARCH       100                      
#endif

#define MCX_ERROR(id,msg)   mcx_error(id,msg,__FILE__,__LINE__)  
#define MIN(a,b)           ((a)<(b)?(a):(b))             
#define MAX(a,b)           ((a)>(b)?(a):(b))             
typedef unsigned int   uint;                             
typedef unsigned short ushort;                           
enum TOutputType {otFlux, otFluence, otEnergy, otJacobian, otWP, otDCS, otRF, otL};   
enum TMCXParent  {mpStandalone, mpMATLAB, mpPython};                   
enum TOutputFormat {ofMC2, ofNifti, ofAnalyze, ofUBJSON, ofTX3, ofJNifti, ofBJNifti};           
enum TBoundary {bcUnknown, bcReflect, bcAbsorb, bcMirror, bcCyclic};            
enum TBJData {JDB_mixed, JDB_nulltype, JDB_noop, JDB_true, JDB_false,
              JDB_char, JDB_string, JDB_hp, JDB_int8, JDB_uint8, JDB_int16, JDB_uint16, JDB_int32, JDB_uint32,
              JDB_int64, JDB_uint64, JDB_half, JDB_single, JDB_double, JDB_array, JDB_object, JDB_numtypes
             };

typedef struct MCXMedium {
    float mua;                     
    float mus;                     
    float g;                       
    float n;                       
} Medium;

typedef struct MCXPolarizeMedium {
    float mua;                     
    float r;                       
    float rho;                     
    float nsph;                    
    float nmed;                    
} POLMedium;

typedef struct MCXHistoryHeader {
    char magic[4];                 
    unsigned int  version;         
    unsigned int  maxmedia;        
    unsigned int  detnum;          
    unsigned int  colcount;        
    unsigned int  totalphoton;     
    unsigned int  detected;        
    unsigned int  savedphoton;     
    float unitinmm;                
    unsigned int  seedbyte;        
    float normalizer;              
    int respin;                    
    unsigned int  srcnum;          
    unsigned int  savedetflag;     
    int reserved[2];               
} History;

typedef struct PhotonReplay {
    int*   detid;                 
    void*  seed;                  
    float* weight;                
    float* tof;                   
} Replay;

typedef struct MCXGPUInfo {
    char name[MAX_SESSION_LENGTH];
    int id;                       
    int devcount;                 
    int major;                    
    int minor;                    
    size_t globalmem;             
    size_t constmem;              
    size_t sharedmem;             
    int regcount;                 
    int clock;                    
    int sm;                       
    int core;                     
    int autoblock;                
    int autothread;               
    int maxgate;                  
    int maxmpthread;              
} GPUInfo;

typedef struct MCXConfig {
    size_t nphoton;               
    unsigned int nblocksize;      
    unsigned int nthread;         
    int seed;                     
    float4 srcpos;                
    float4 srcdir;                
    float4 srciquv;               
    float tstart;                 
    float tstep;                  
    float tend;                   
    float3 steps;                 
    uint3 dim;                    
    uint3 crop0;                  
    uint3 crop1;                  
    unsigned int medianum;        
    unsigned int polmedianum;     
    unsigned int detnum;          
    unsigned int maxdetphoton;    
    float detradius;              
    float sradius;                
    Medium* prop;                 
    POLMedium* polprop;           
    float4* detpos;               
    float4* smatrix;              
    unsigned int maxgate;         
    int respin;                   
    unsigned int printnum;        
    int gpuid;                    
    unsigned int* vol;            
    char session[MAX_SESSION_LENGTH]; 
    char isrowmajor;             
    char isreflect;              
    char isref3;                 
    char isrefint;               
    char isnormalized;           
    char issavedet;              
    char issave2pt;              
    char isgpuinfo;              
    char isspecular;             
    char issrcfrom0;             
    char isdumpmask;             
    char autopilot;              
    char issaveseed;             
    char issaveexit;             
    char issaveref;              
    char ismomentum;             
    char isdumpjson;             
    char internalsrc;            
    int  zipid;                  
    char srctype;                
    char outputtype;             
    char outputformat;           
    char faststep;               
    float minenergy;             
    float unitinmm;              
    float omega;                 
    float lambda;                
    FILE* flog;                  
    History his;                 
    float* exportfield;          
    float* exportdetected;       
    unsigned long int detectedcount;  
    char rootpath[MAX_PATH_LENGTH]; 
    char* shapedata;             
    char* extrajson;             
    int maxvoidstep;             
    int voidtime;                
    float4 srcparam1;            
    float4 srcparam2;            
    unsigned int srcnum;         
    float* srcpattern;           
    Replay replay;               
    void* seeddata;              
    int replaydet;               
    char seedfile[MAX_PATH_LENGTH];
    char jsonfile[MAX_PATH_LENGTH];
    unsigned int debuglevel;     
    unsigned int savedetflag;    
    char deviceid[MAX_DEVICE];   
    float workload[MAX_DEVICE];  
    int parentid;                
    unsigned int runtime;        
    double energytot;            
    double energyabs;            
    double energyesc;            
    float normalizer;            
    unsigned int maxjumpdebug;   
    unsigned int debugdatalen;   
    unsigned int gscatter;       
    float* exportdebugdata;      
    uint mediabyte;              
    float* dx;                   
    float* dy;                   
    float* dz;                   
    char bc[12];                 
    unsigned int nphase;         
    float* invcdf;               
} Config;

#ifdef  __cplusplus
extern "C" {
#endif
void mcx_savedata(float* dat, size_t len, Config* cfg);
void mcx_savenii(float* dat, size_t len, char* name, int type32bit, int outputformatid, Config* cfg);
void mcx_error(const int id, const char* msg, const char* file, const int linenum);
void mcx_loadconfig(FILE* in, Config* cfg);
void mcx_saveconfig(FILE* in, Config* cfg);
void mcx_readconfig(char* fname, Config* cfg);
void mcx_writeconfig(char* fname, Config* cfg);
void mcx_initcfg(Config* cfg);
void mcx_clearcfg(Config* cfg);
void mcx_preprocess(Config* cfg);
void mcx_parsecmd(int argc, char* argv[], Config* cfg);
void mcx_usage(Config* cfg, char* exename);
void mcx_printheader(Config* cfg);
void mcx_loadvolume(char* filename, Config* cfg, int isbuf);
void mcx_normalize(float field[], float scale, int fieldlen, int option, int pidx, int srcnum);
void mcx_kahanSum(float* sum, float* kahanc, float input);
int  mcx_readarg(int argc, char* argv[], int id, void* output, const char* type);
void mcx_printlog(Config* cfg, char* str);
int  mcx_remap(char* opt);
void mcx_maskdet(Config* cfg);
void mcx_dumpmask(Config* cfg);
void mcx_version(Config* cfg);
void mcx_convertrow2col(unsigned int** vol, uint3* dim);
void mcx_convertrow2col64(size_t** vol, uint3* dim);
void mcx_convertcol2row(unsigned int** vol, uint3* dim);
void mcx_convertcol2row4d(unsigned int** vol, uint4* dim);
int  mcx_loadjson(cJSON* root, Config* cfg);
int  mcx_keylookup(char* key, const char* table[]);
int  mcx_lookupindex(char* key, const char* index);
int  mcx_parsedebugopt(char* debugopt, const char* debugflag);
void mcx_savedetphoton(float* ppath, void* seeds, int count, int seedbyte, Config* cfg);
void mcx_loadseedfile(Config* cfg);
void mcx_cleargpuinfo(GPUInfo** gpuinfo);
int  mcx_isbinstr(const char* str);
void mcx_progressbar(float percent, Config* cfg);
void mcx_flush(Config* cfg);
int  mcx_run_from_json(char* jsonstr);
float mcx_updatemua(unsigned int mediaid, Config* cfg);
void mcx_savejdata(char* filename, Config* cfg);
int  mcx_jdataencode(void* vol,  int ndim, uint* dims, char* type, int byte, int zipid, void* obj, int isubj, Config* cfg);
int  mcx_jdatadecode(void** vol, int* ndim, uint* dims, int maxdim, char** type, cJSON* obj, Config* cfg);
void mcx_savejnii(float* vol, int ndim, uint* dims, float* voxelsize, char* name, int isfloat, Config* cfg);
void mcx_savebnii(float* vol, int ndim, uint* dims, float* voxelsize, char* name, int isfloat, Config* cfg);
void mcx_savejdet(float* ppath, void* seeds, uint count, int doappend, Config* cfg);
int  mcx_svmc_bgvoxel(int vol);
void mcx_loadseedjdat(char* filename, Config* cfg);
void mcx_prep_polarized(Config* cfg);
void mcx_replayinit(Config* cfg, float* detps, int dimdetps[2], int seedbyte);
void mcx_validatecfg(Config* cfg, float* detps, int dimdetps[2], int seedbyte);

#ifdef MCX_CONTAINER
#ifdef __cplusplus
extern "C"
#endif
int  mcx_throw_exception(const int id, const char* msg, const char* filename, const int linenum);
void mcx_matlab_flush(void);
void mcx_python_flush(void);
#endif

#if defined(MCX_CONTAINER) && (defined(MATLAB_MEX_FILE) || defined(OCTAVE_API_VERSION_NUMBER))
#ifdef _OPENMP
#define MCX_FPRINTF(fp,...) {if(omp_get_thread_num()==0) mexPrintf(__VA_ARGS__);}  
#else
#define MCX_FPRINTF(fp,...) mexPrintf(__VA_ARGS__) 
#endif
#else
#define MCX_FPRINTF(fp,...) fprintf(fp,__VA_ARGS__) 
#endif

#if defined(MATLAB_MEX_FILE) || defined(OCTAVE_API_VERSION_NUMBER)
int mexPrintf(const char* format, ... );
#else
int mexPrintf(const char* format, ... );
#endif
int mexEvalString(const char* command);

#ifdef  __cplusplus
}
#endif

#endif