MTK++ Latest version: 0.2.0

index.h
Go to the documentation of this file.
00001 
00033 #ifndef INDEX_H
00034 #define INDEX_H
00035 
00036 #include "Diagnostics/MTKException.h"
00037 
00038 #include <iostream>
00039 #include <vector>
00040 #include <algorithm>
00041 
00042 namespace MTKpp
00043 {
00044 
00045 // ============================================================
00046 // Function: index2dTo1d
00047 // ------------------------------------------------------------
00048 // Returns unique index of i and j
00049 /*
00050 
00051   j -> 
00052     +-                   -+       +-                   -+
00053     | 1,1 .,. .,. .,. 1,m |       | 0                   |
00054  i  | 2,1 2,2 .,. .,. 2,m |       | 1  2                |
00055  |  | 3,1 .,. 3,3 .,. 3,m |  ==>  | 3  4  5             |
00056 \./ | 4,1 .,. .,. 4,4 4,m |       | 6  7  8  9          |
00057     | n,. .,. .,. .,. n,m |       |                     |
00058     +-                   -+       +-                   -+
00059 */
00060 // ============================================================
00061 inline int index2dTo1d(int i, int j)
00062 {
00063     if ((i < 1) || (j < 1)) {
00064       return -1;
00065     }
00066 
00067     int ki = std::max(i, j);
00068     int kj = std::min(i, j);
00069     int index = ( ki*(ki-1) )/2 + kj - 1;
00070     return index;
00071 };
00072 
00073 // ============================================================
00074 // Function: indexAB
00075 // ------------------------------------------------------------
00076 // Returns unique index of a and b ( Bond )
00077 // a -- b
00078 // ============================================================
00079 inline int indexAB(int a, int b, unsigned int Nb)
00080 {
00081     if ((a < 1) || (b < 1)  || (Nb < 1)) {
00082       return -1;
00083     }
00084 
00085     if (b < a) {
00086       int btemp = a;
00087       a = b;
00088       b = btemp;
00089     }
00090     return ((a-1)*Nb + (b-1));
00091 };
00092 
00093 // ============================================================
00094 // Function: indexABC
00095 // ------------------------------------------------------------
00096 // Returns unique index of a, b and c ( Angle )
00097 /*
00098        b
00099       / \
00100      a   c
00101 */
00102 // ============================================================
00103 inline int indexABC(int a, int b, int c, unsigned int Nb, unsigned int Nc)
00104 {
00105     if ((a < 1) || (b < 1) || (Nb < 1) || (Nc < 1)) {
00106       return -1;
00107     }
00108 
00109     if (c < a) {
00110       int ctemp = a;
00111       a = c;
00112       c = ctemp;
00113     }
00114     return ((a-1)*(Nb*Nc) + (b-1)*Nc + (c-1));
00115 };
00116 
00117 // ============================================================
00118 // Function: indexABC_LL
00119 // ------------------------------------------------------------
00120 // Returns unique index of a, b and c ( Angle )
00121 /*
00122        b
00123       / \
00124      a   c
00125 */
00126 // ============================================================
00127 inline ULONG_KIND indexABC_ULL(int a, int b, int c,
00128                                unsigned int Nb, unsigned int Nc)
00129 {
00130     if ((a < 1) || (b < 1) || (Nb < 1) || (Nc < 1)) {
00131       throw MTKException(" Error in indexABC_ULL ... exiting ");
00132     }
00133 
00134     if (c < a) {
00135       int ctemp = a;
00136       a = c;
00137       c = ctemp;
00138     }
00139 
00140     ULONG_KIND i = ((a-1)*(Nb*Nc) + (b-1)*Nc + (c-1));
00141 
00142     return i;
00143 };
00144 
00145 // ============================================================
00146 // Function: indexABCD
00147 // ------------------------------------------------------------
00148 // Returns unique index of a, b, c and d ( Torsion )
00149 /*     b -- c
00150       /      \
00151      a        d
00152 */
00153 // ============================================================
00154 inline int indexABCD(int a, int b, int c, int d,
00155            unsigned int Nb, unsigned int Nc, unsigned int Nd)
00156 {
00157     if ((a < 1) || (b < 1) || (Nb < 1) || (Nc < 1) || (Nd < 1)) {
00158       return -1;
00159     }
00160 
00161     if (d < a) {
00162       int dtemp = a;
00163       a = d;
00164       d = dtemp;
00165       int ctemp = b;
00166       b = c;
00167       c = ctemp;
00168     }
00169     int i = ((a-1)*(Nb*Nc*Nd) + (b-1)*(Nc*Nd) + (c-1)*Nd + (d-1));
00170     return i;
00171 };
00172 
00173 // ============================================================
00174 // Function: indexABCD_ULL
00175 // ------------------------------------------------------------
00176 // Returns unique index of a, b, c and d ( Torsion )
00177 /*     b -- c
00178       /      \
00179      a        d
00180 */
00181 // ============================================================
00182 inline ULONG_KIND indexABCD_ULL(int a, int b, int c, int d,
00183                           unsigned int Nb, unsigned int Nc, unsigned int Nd)
00184 {
00185     if ((a < 1) || (b < 1) || (Nb < 1) || (Nc < 1) || (Nd < 1)) {
00186       throw MTKException(" Error in indexABCD_ULL ... exiting ");
00187     }
00188 
00189     if (d < a) {
00190       int dtemp = a;
00191       a = d;
00192       d = dtemp;
00193       int ctemp = b;
00194       b = c;
00195       c = ctemp;
00196     }
00197 
00198     ULONG_KIND i = ((a-1)*(Nb*Nc*Nd) + (b-1)*(Nc*Nd) + (c-1)*Nd + (d-1));
00199     return i;
00200 };
00201 
00202 // ============================================================
00203 // Function: indexABCD
00204 // ------------------------------------------------------------
00205 // Returns unique index of a, b, c and d ( Torsion )
00206 /*
00207              e
00208            /
00209      a---b
00210           \
00211            d
00212 */
00213 // ============================================================
00214 inline int indexABCDb(int a, int b, int c, int d,
00215            unsigned int Nb, unsigned int Nc, unsigned int Nd)
00216 {
00217     if ((a < 1) || (b < 1) || (Nb < 1) || (Nc < 1) || (Nd < 1)) {
00218       return -1;
00219     }
00220     std::vector<int> tempVec;
00221     tempVec.push_back(a);
00222     tempVec.push_back(b);
00223     tempVec.push_back(c);
00224     tempVec.push_back(d);
00225     sort( tempVec.begin(), tempVec.end() );
00226 
00227     return ((tempVec[0]-1)*(Nb*Nc*Nd) + (tempVec[1]-1)*(Nc*Nd) + (tempVec[2]-1)*Nd + (tempVec[3]-1));
00228 };
00229 
00230 } // MTKpp namespace
00231 
00232 #endif // INDEX_H
00233 

Generated on Fri Dec 23 2011 09:28:50 for MTK++ by Doxygen 1.7.5.1