mmc_utils.h

Go to the documentation of this file.

/***************************************************************************/
/***************************************************************************/
#ifndef _MMC_UTILITIES_H
#define _MMC_UTILITIES_H

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

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

#define MAX_FULL_PATH       2048                         
#define MAX_PATH_LENGTH     1024                         
#define MAX_SESSION_LENGTH  64                           
#define MAX_CHECKPOINT      16                           
#define DET_PHOTON_BUF      100000                       
#define SEED_FROM_FILE      -999                         
#define MIN(a,b)            ((a)<(b)?(a):(b))            
#define MMC_ERROR(id,msg)   mcx_error(id,msg,__FILE__,__LINE__)
#define MMC_INFO            -99999
#define MAX_DEVICE          256

#ifndef MCX_CONTAINER
    #define S_RED     "\x1b[31m"
    #define S_GREEN   "\x1b[32m"
    #define S_YELLOW  "\x1b[33m"
    #define S_BLUE    "\x1b[34m"
    #define S_MAGENTA "\x1b[35m"
    #define S_CYAN    "\x1b[36m"
    #define S_BOLD     "\x1b[1m"
    #define S_ITALIC   "\x1b[3m"
    #define S_RESET   "\x1b[0m"
#else
    #define S_RED
    #define S_GREEN
    #define S_YELLOW
    #define S_BLUE
    #define S_MAGENTA
    #define S_CYAN
    #define S_BOLD
    #define S_ITALIC
    #define S_RESET
#endif


typedef double OutputType;

enum TDebugLevel {dlMove = 1, dlTracing = 2, dlBary = 4, dlWeight = 8, dlDist = 16, dlTracingEnter = 32,
                  dlTracingExit = 64, dlEdge = 128, dlAccum = 256, dlTime = 512, dlReflect = 1024,
                  dlProgress = 2048, dlExit = 4096
                 };

enum TRTMethod {rtPlucker, rtHavel, rtBadouel, rtBLBadouel, rtBLBadouelGrid};
enum TMCMethod {mmMCX, mmMCML};
enum TComputeBackend {cbSSE, cbOpenCL, cbCUDA};

enum TSrcType {stPencil, stIsotropic, stCone, stGaussian, stPlanar,
               stPattern, stFourier, stArcSin, stDisk, stFourierX,
               stFourier2D, stZGaussian, stLine, stSlit
              };
enum TOutputType {otFlux, otFluence, otEnergy, otJacobian, otWL, otWP};
enum TOutputFormat {ofASCII, ofBin, ofNifti, ofAnalyze, ofMC2, ofTX3, ofJNifti, ofBJNifti};
enum TOutputDomain {odMesh, odGrid};
enum TDeviceVendor {dvUnknown, dvNVIDIA, dvAMD, dvIntel, dvIntelGPU};
enum TMCXParent  {mpStandalone, mpMATLAB};
enum TBoundary {bcNoReflect, bcReflect, bcAbsorbExterior, bcMirror /*, bcCylic*/};
enum TRayHitType {htNone, htInOut, htOutIn, htNoHitIn, htNoHitOut};
enum TROIType {rtNone, rtEdge, rtNode, rtFace};

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_int32,
              JDB_int64, JDB_single, JDB_double, JDB_array, JDB_object, JDB_numtypes,
              JDB_uint16 = 10, JDB_uint32, JDB_uint64
             };

/***************************************************************************/
typedef struct MMC_medium {
    float mua;                     
    float mus;                     
    float g;                       
    float n;                       
} medium;

typedef struct MMC_history {
    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;              
    unsigned int  srcnum;          
    int respin;                    
    unsigned int  savedetflag;     
    int reserved[2];               
} history;


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

/***************************************************************************/
typedef struct MMC_config {
    size_t nphoton;                
    int nblocksize;                
    int nthread;                   
    int seed;                      
    int e0;                        
    float3 srcpos;                 
    float4 srcdir;                 
    int srctype;                   
    float4 srcparam1;          
    float4 srcparam2;          
    float* srcpattern;         
    int voidtime;
    float4 bary0;                  
    float tstart;                  
    float tstep;                   
    float tend;                    
    float3 steps;                  
    uint3 dim;                     
    uint4 crop0;                   
    uint4 crop1;                   
    int medianum;                  
    int srcnum;            
    int detnum;                    
    float detradius;               
    float sradius;                 
    medium* prop;                  
    float4* detpos;                
    float4 detparam1;          
    float4 detparam2;          
    float* detpattern;         
    float  minstep;                
    int maxgate;                   
    int respin;                    
    int printnum;                  
    int replaydet;                 
    unsigned char* vol;            
    char session[MAX_SESSION_LENGTH];
    char meshtag[MAX_SESSION_LENGTH];
    char isrowmajor;               
    char isreflect;                
    char isref3;                   
    char isnormalized;             
    char issavedet;                
    char ismomentum;               
    char issaveexit;               
    char issave2pt;                
    char isgpuinfo;                
    char isspecular;               
    char issaveseed;               
    char issaveref;                
    char isatomic;                 
    char method;                   
    int implicit;              
    char basisorder;               
    char outputtype;               
    char outputformat;             
    int  mcmethod;                 
    float roulettesize;            
    float minenergy;               
    float nout;                    
    int isextdet;                  
    FILE* flog;                    
    char rootpath[MAX_PATH_LENGTH];
    unsigned int debuglevel;       
    int debugphoton;               
    float unitinmm;                
    history his;                   
    unsigned int checkpt[MAX_CHECKPOINT]; 
    void* photonseed;              
    float* replayweight;           
    float* replaytime;             
    char seedfile[MAX_PATH_LENGTH];
    char deviceid[MAX_DEVICE];
    float workload[MAX_DEVICE];
    char compileropt[MAX_PATH_LENGTH];
    char kernelfile[MAX_SESSION_LENGTH];
    char* clsource;
    int parentid;
    int optlevel;
    unsigned int maxdetphoton; /*anticipated maximum detected photons*/
    double* exportfield;     /*memory buffer when returning the flux to external programs such as matlab*/
    unsigned char* exportseed;     /*memory buffer when returning the RNG seed to matlab*/
    float* exportdetected;  /*memory buffer when returning the partial length info to external programs such as matlab*/
    double energytot, energyabs, energyesc;
    unsigned int detectedcount; 
    unsigned int runtime;
    char autopilot;     
    float normalizer;            
    unsigned int nbuffer;        
    unsigned int gpuid;
    int compute;
    char isdumpjson;             
    int  zipid;                  
    unsigned int savedetflag;    
    uint mediabyte;
    char* shapedata;    
    char jsonfile[MAX_PATH_LENGTH];
} mcconfig;

#ifdef  __cplusplus
extern "C" {
#endif
void mcx_savedata(OutputType* dat, size_t len, mcconfig* cfg, int isref);
void mcx_savenii(OutputType* dat, size_t len, char* name, int type32bit, int outputformatid, mcconfig* cfg);
void mcx_error(const int id, const char* msg, const char* file, const int linenum);
void mcx_loadconfig(FILE* in, mcconfig* cfg);
void mcx_saveconfig(FILE* in, mcconfig* cfg);
void mcx_readconfig(char* fname, mcconfig* cfg);
void mcx_writeconfig(char* fname, mcconfig* cfg);
void mcx_initcfg(mcconfig* cfg);
void mcx_clearcfg(mcconfig* cfg);
void mcx_validatecfg(mcconfig* cfg);
void mcx_parsecmd(int argc, char* argv[], mcconfig* cfg);
void mcx_usage(char* exename, mcconfig* cfg);
void mcx_loadvolume(char* filename, mcconfig* cfg, int isbuf);
void mcx_normalize(float field[], float scale, int fieldlen);
int  mcx_readarg(int argc, char* argv[], int id, void* output, const char* type);
void mcx_printlog(mcconfig* cfg, char* str);
int  mcx_remap(char* opt);
int  mcx_lookupindex(char* key, const char* index);
int  mcx_keylookup(char* key, const char* table[]);
int  mcx_parsedebugopt(char* debugopt);
void mcx_progressbar(float percent);
int  mcx_loadjson(cJSON* root, mcconfig* cfg);
void mcx_version(mcconfig* cfg);
int  mcx_loadfromjson(char* jbuf, mcconfig* cfg);
void mcx_prep(mcconfig* cfg);
void mcx_printheader(mcconfig* cfg);
void mcx_cleargpuinfo(GPUInfo** gpuinfo);
void mcx_convertcol2row(unsigned int** vol, uint3* dim);
void mcx_convertcol2row4d(unsigned int** vol, uint4* dim);
void mcx_savejdata(char* filename, mcconfig* cfg);
int  mcx_jdataencode(void* vol,  int ndim, uint* dims, char* type, int byte, int zipid, void* obj, int isubj, mcconfig* cfg);
int  mcx_jdatadecode(void** vol, int* ndim, uint* dims, int maxdim, char** type, cJSON* obj, mcconfig* cfg);
void mcx_savejnii(OutputType* vol, int ndim, uint* dims, float* voxelsize, char* name, int isfloat, mcconfig* cfg);
void mcx_savebnii(OutputType* vol, int ndim, uint* dims, float* voxelsize, char* name, int isfloat, mcconfig* cfg);
void mcx_savejdet(float* ppath, void* seeds, uint count, int doappend, mcconfig* cfg);
void mcx_fflush(FILE* out);

#ifdef MCX_CONTAINER
#ifdef _OPENMP
#define MMC_FPRINTF(fp,...) {if(omp_get_thread_num()==0) mexPrintf(__VA_ARGS__);}
#else
#define MMC_FPRINTF(fp,...) mexPrintf(__VA_ARGS__)
#endif
#else
#define MMC_FPRINTF(fp,...) fprintf(fp,__VA_ARGS__)
#endif

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

#define MMCDEBUG(cfg,debugflag,outputstr)  {\
        if((cfg)->debuglevel & (debugflag)) {\
            MMC_FPRINTF outputstr ;\
            fflush((cfg)->flog);\
        }\
    }


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


#ifdef  __cplusplus
}
#endif

#endif