NanoShaper  0.3.1
NanoShaper is a tool able to triangulate and inspect an arbitray triangulated surface or several types of molecular surfaces such as the Gaussian, Skin and the SES
C:/Documents and Settings/sdecherchi/My Documents/Ricerca/software nostro/NanoShaper 0.3.1/NanoShaper/src/globals.h
00001 
00002 //---------------------------------------------------------
00003 /*    @file             globals.h
00004 *     @brief    globals.h Includes all the common global parameters
00005 *                                                                                                               */
00006 //---------------------------------------------------------
00007 
00008 #ifndef globals_h
00009 #define globals_h
00010 
00011 
00012 #define VERSION "0.3.1"
00013 #define PROGNAME "NanoShaper" 
00014 
00016 #include<iostream>
00017 #include<math.h>
00018 #include<vector>
00019 #include<fstream>
00020 #include<assert.h>
00021 #include<algorithm>
00022 #include<stdio.h>
00023 #include<cstring>
00024 #include<map>
00025 #include<list>
00026 #include<set>
00027 #include<time.h>
00028 #include<queue>
00029 #include<limits>
00031 
00032 using namespace std;
00033 
00035 #define WARN " <<WARNING>> "
00036 #define ERR " <<ERROR>> "
00037 #define INFO " <<INFO>> "
00038 #define REMARK " <<REMARK>> "
00039 
00040 
00041 // access to EPSMAP colum-major as in Fortran
00042 #define EPSMAP(i,j,k,l,NX,NY,NZ) epsmap[(i)+(NX)*((j)+(NY)*((k)+(NZ)*(l)))]
00043 #define IDEBMAP(i,j,k,NX,NY) idebmap[(i)+(NX)*((j)+(NY)*(k))]
00044 
00045 
00046 //#undef ENABLE_BOOST
00048 //#define ENABLE_CGAL
00050 //#define DBGMEM_CRT
00052 
00053 #ifdef ENABLE_BOOST
00054         #include <boost/thread/thread.hpp>
00055         #include <boost/thread/mutex.hpp>
00056 #endif
00057 
00058 #ifndef __GNUC__
00059         #define INFINITY 1e100
00060 #endif
00061 
00062 //if Microsoft C++ is not idenfied memory leak is deactivated
00063 #ifndef _MSC_VER 
00064         #undef DBGMEM_CRT
00065 #endif
00066 
00067 #ifdef DBGMEM_CRT
00068         #pragma message(" MESSAGE Microsoft Memory Leaks Detector is Enabled!")
00069         #define _CRTDBG_MAP_ALLOC
00070         #define _CRTDBG_MAP_ALLOC_NEW
00071         #include <stdlib.h>
00072         #include <crtdbg.h>
00073 #endif
00074 
00076 
00078 #define BUFLEN 1024
00079 
00080 #define PI 3.14159265
00081 #define HALF_PI 1.57079633
00082 #define QUARTER_PI 0.785398163
00083 #define TWO_PI 6.28318531
00084 
00086 
00087 #define ABS(x) (x < 0 ? -(x) : (x))
00088 
00090 #define CROSS(dest,v1,v2) \
00091                 dest[0]=(v1[1])*(v2[2])-(v1[2])*(v2[1]); \
00092                 dest[1]=(v1[2])*(v2[0])-(v1[0])*(v2[2]); \
00093                 dest[2]=(v1[0])*(v2[1])-(v1[1])*(v2[0]);
00094 
00096 #define DOT(v1,v2) ((v1[0])*(v2[0])+(v1[1])*(v2[1])+(v1[2])*(v2[2]))
00097 
00100 #define NORMALIZE(v,t) \
00101                 t=sqrt(v[0]*v[0]+v[1]*v[1]+v[2]*v[2]); \
00102                 v[0]=v[0]/t; \
00103                 v[1]=v[1]/t; \
00104                 v[2]=v[2]/t;
00105 
00106 #define NORMALIZE_PLANE(v,t) \
00107                 t=sqrt(v[0]*v[0]+v[1]*v[1]+v[2]*v[2]); \
00108                 v[0]=v[0]/t; \
00109                 v[1]=v[1]/t; \
00110                 v[2]=v[2]/t; \
00111                 v[3]=v[3]/t;
00112 
00113 #define NORMALIZE_S(v,t) \
00114                 t=sqrt(v[0]*v[0]+v[1]*v[1]+v[2]*v[2]); \
00115                 v[0]=v[0]/(t+1e-20); \
00116                 v[1]=v[1]/(t+1e-20); \
00117                 v[2]=v[2]/(t+1e-20);
00118 
00119 #define NORMALIZE_S_ASSIGN(w,v,t) \
00120                 t=sqrt(v[0]*v[0]+v[1]*v[1]+v[2]*v[2]); \
00121                 w[0]=v[0]/(t+1e-20); \
00122                 w[1]=v[1]/(t+1e-20); \
00123                 w[2]=v[2]/(t+1e-20);
00124 
00126 #define ASSIGN(u,v) \
00127                 { u[0]=v[0]; \
00128                 u[1]=v[1]; \
00129                 u[2]=v[2]; }
00130 
00132 #define ASSIGN4(u,v) \
00133                 { u[0]=v[0]; \
00134                 u[1]=v[1]; \
00135                 u[2]=v[2];\
00136                 u[3]=v[3];}
00137 
00138 
00140 #define SUB(dest,v1,v2)\
00141           dest[0]=v1[0]-v2[0]; \
00142           dest[1]=v1[1]-v2[1]; \
00143           dest[2]=v1[2]-v2[2];
00144 
00146 #define ADD(dest,v1,v2)\
00147           dest[0]=v1[0]+v2[0]; \
00148           dest[1]=v1[1]+v2[1]; \
00149           dest[2]=v1[2]+v2[2];
00150 
00152 #define MID(dest,v1,v2)\
00153           dest[0]=(v1[0]+v2[0])*0.5; \
00154           dest[1]=(v1[1]+v2[1])*0.5; \
00155           dest[2]=(v1[2]+v2[2])*0.5;
00156 
00158 #define ADD_MUL(dest,v1,v2,a)\
00159           dest[0]=v1[0]+a*v2[0]; \
00160           dest[1]=v1[1]+a*v2[1]; \
00161           dest[2]=v1[2]+a*v2[2];
00162 
00164 #define VEC_MUL(dest,v,a)\
00165           dest[0]=a*v[0]; \
00166           dest[1]=a*v[1]; \
00167           dest[2]=a*v[2];
00168 
00169 #define DIST(dist,v1,v2)\
00170           dist=sqrt((v1[0]-v2[0])*(v1[0]-v2[0])+(v1[1]-v2[1])*(v1[1]-v2[1])+(v1[2]-v2[2])*(v1[2]-v2[2])); 
00171 
00172 #define DIST2(dist,v1,v2)\
00173           dist=((v1[0]-v2[0])*(v1[0]-v2[0])+(v1[1]-v2[1])*(v1[1]-v2[1])+(v1[2]-v2[2])*(v1[2]-v2[2])); 
00174 
00176 #define MIN(x, y) ((x)<(y) ? (x):(y))
00177 
00179 #define MAX(x, y) ((x)>(y) ? (x):(y))
00180 
00181 
00182 /*      determinant of matrix
00183         Computes determinant of matrix m, returning d
00184  */
00185 #define DETERMINANT_2X2(d,m)                                            \
00186 {                                                                                                       \
00187         d = m[0][0] * m[1][1] - m[0][1] * m[1][0];              \
00188 }
00189 
00190 /*      determinant of matrix
00191         Computes determinant of matrix m, returning d
00192  */
00193 
00194 #define DETERMINANT_3X3(d,m)                                                            \
00195 {                                                                                                                       \
00196         d = m[0][0] * (m[1][1]*m[2][2] - m[1][2] * m[2][1]);    \
00197         d -= m[0][1] * (m[1][0]*m[2][2] - m[1][2] * m[2][0]);   \
00198         d += m[0][2] * (m[1][0]*m[2][1] - m[1][1] * m[2][0]);   \
00199 }
00200 
00201 /* compute adjoint of matrix and scale
00202  Computes adjoint of matrix m, scales it by s, returning a
00203  */
00204 
00205 #define SCALE_ADJOINT_2X2(a,s,m) \
00206 {                               \
00207         a[0][0] = (s) * m[1][1];    \
00208         a[1][0] = - (s) * m[1][0];  \
00209         a[0][1] = - (s) * m[0][1];  \
00210         a[1][1] = (s) * m[0][0];    \
00211 }
00212 
00213  
00214 /*      compute adjoint of matrix and scale
00215         Computes adjoint of matrix m, scales it by s, returning a
00216  */
00217 
00218 #define SCALE_ADJOINT_3X3(a,s,m)        \
00219 {                                                                       \
00220         a[0][0] = (s) * (m[1][1] * m[2][2] - m[1][2] * m[2][1]); \
00221         a[1][0] = (s) * (m[1][2] * m[2][0] - m[1][0] * m[2][2]); \
00222         a[2][0] = (s) * (m[1][0] * m[2][1] - m[1][1] * m[2][0]); \
00223         \
00224         a[0][1] = (s) * (m[0][2] * m[2][1] - m[0][1] * m[2][2]); \
00225         a[1][1] = (s) * (m[0][0] * m[2][2] - m[0][2] * m[2][0]); \
00226         a[2][1] = (s) * (m[0][1] * m[2][0] - m[0][0] * m[2][1]); \
00227         \
00228         a[0][2] = (s) * (m[0][1] * m[1][2] - m[0][2] * m[1][1]); \
00229         a[1][2] = (s) * (m[0][2] * m[1][0] - m[0][0] * m[1][2]); \
00230         a[2][2] = (s) * (m[0][0] * m[1][1] - m[0][1] * m[1][0]); \
00231 }
00232 
00233 /*      inverse of matrix 
00234         Compute inverse of matrix a, returning determinant m and inverse b
00235  */
00236 
00237 #define INVERT_2X2(b,det,a)                     \
00238 {                                                                       \
00239         double tmp;                                             \
00240         DETERMINANT_2X2 (det, a);               \
00241         tmp = 1.0 / (det);              \
00242         SCALE_ADJOINT_2X2 (b, tmp, a);  \
00243 }
00244 
00245 /*      inverse of matrix 
00246         Compute inverse of matrix a, returning determinant m and inverse b
00247  */
00248 
00249 #define INVERT_3X3(b,det,a)             \
00250 {                                                               \
00251    double tmp;                                  \
00252    DETERMINANT_3X3 (det, a);    \
00253    tmp = 1.0 / (det);           \
00254    SCALE_ADJOINT_3X3 (b, tmp, a); \
00255 }
00256 
00257 #define PRINT_MAT3(mat) \
00258 { \
00259         cout << endl;                                   \
00260         for (int i=0;i<3;i++) \
00261         {                                               \
00262                 cout << mat[i][0] << "," << mat[i][1] << "," << mat[i][2];\
00263                 cout << endl;   \
00264         } \
00265 }
00266 
00267 #define PRINT_VEC3(vec) \
00268 { \
00269         cout << endl;                                   \
00270         cout << vec[0] << "," << vec[1] << "," << vec[2];\
00271         cout << endl;   \
00272         \
00273 }
00274 
00275 
00276 static fstream errorStream("stderror.txt",fstream::out);
00277 
00278 #endif
00279