00001 #include "EvtGenBase/EvtPatches.hh"
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011 #include <assert.h>
00012 #include <string.h>
00013 #include <iostream>
00014 #include "EvtGenBase/EvtCyclic3.hh"
00015 using std::ostream;
00016
00017 using namespace EvtCyclic3;
00018
00019
00020 Index EvtCyclic3::permute(Index i, Perm p)
00021 {
00022 if(p == ABC) return i;
00023 else if(p == BCA) {
00024 if(i == A) return C;
00025 else if(i == B) return A;
00026 else if(i == C) return B;
00027 }
00028 else if(p == BCA) {
00029 if(i == A) return C;
00030 else if(i == B) return A;
00031 else if(i == C) return B;
00032 }
00033 else if(p == CAB) {
00034 if(i == A) return B;
00035 else if(i == B) return C;
00036 else if(i == C) return A;
00037 }
00038 else if(p == CBA) {
00039 if(i == A) return C;
00040 else if(i == B) return B;
00041 else if(i == C) return A;
00042 }
00043 else if(p == BAC) {
00044 if(i == A) return B;
00045 else if(i == B) return A;
00046 else if(i == C) return C;
00047 }
00048 else if(p == ACB) {
00049 if(i == A) return A;
00050 else if(i == B) return C;
00051 else if(i == C) return B;
00052 }
00053 return A;
00054 }
00055
00056 Perm EvtCyclic3::permutation(Index i1,Index i2,Index i3)
00057 {
00058 assert(i1 != i2 && i2 != i3 && i3 != i1);
00059 if(i1 == A) return (i2 == B) ? ABC : ACB;
00060 if(i1 == B) return (i2 == C) ? BCA : BAC;
00061 if(i1 == C) return (i2 == A) ? CAB : CBA;
00062 return ABC;
00063 }
00064
00065
00066 Perm EvtCyclic3::permute(Perm i,Perm p)
00067 {
00068 Index i1 = permute(permute(A,i),p);
00069 Index i2 = permute(permute(B,i),p);
00070 Index i3 = permute(permute(C,i),p);
00071
00072 return permutation(i1,i2,i3);
00073 }
00074
00075 Pair EvtCyclic3::permute(Pair i, Perm p)
00076 {
00077 Index i1 = permute(first(i),p);
00078 Index i2 = permute(second(i),p);
00079 return combine(i1,i2);
00080 }
00081
00082
00083 Pair EvtCyclic3::i2pair(int i)
00084 {
00085 assert(0<=i && i<=2);
00086 switch(i) {
00087 case 0: return BC;
00088 case 1: return CA;
00089 case 2: return AB;
00090 }
00091 assert(0); return AB;
00092 }
00093
00094
00095
00096 Index EvtCyclic3::prev(Index i)
00097 {
00098 switch(i) {
00099 case A: return C;
00100 case B: return A;
00101 case C: return B;
00102 }
00103 assert(0); return A;
00104 }
00105
00106
00107 Index EvtCyclic3::next(Index i)
00108 {
00109 switch(i) {
00110 case A: return B;
00111 case B: return C;
00112 case C: return A;
00113 }
00114 assert(0); return A;
00115 }
00116
00117
00118 Index EvtCyclic3::other(Index i, Index j)
00119 {
00120 assert(i != j);
00121 switch(i) {
00122 case A:
00123 switch(j) {
00124 case B: return C;
00125 case C: return B;
00126 default: assert(0);
00127 }
00128 case B:
00129 switch(j) {
00130 case C: return A;
00131 case A: return C;
00132 default: assert(0);
00133 }
00134 case C:
00135 switch(j) {
00136 case A: return B;
00137 case B: return A;
00138 default: assert(0);
00139 }
00140 }
00141 assert(0); return A;
00142 }
00143
00144
00145
00146
00147 Pair EvtCyclic3::other(Index i)
00148 {
00149 switch(i) {
00150 case A: return BC;
00151 case B: return CA;
00152 case C: return AB;
00153 }
00154 assert(0); return AB;
00155 }
00156
00157
00158 Pair EvtCyclic3::combine(Index i, Index j)
00159 {
00160 return other(other(i,j));
00161 }
00162
00163
00164
00165
00166 Pair EvtCyclic3::prev(Pair i)
00167 {
00168 Pair ret = CA;
00169 if(i == BC) ret = AB;
00170 else
00171 if(i == CA) ret = BC;
00172
00173 return ret;
00174 }
00175
00176 Pair EvtCyclic3::next(Pair i)
00177 {
00178 Pair ret = BC;
00179 if(i == BC) ret = CA;
00180 else
00181 if(i == CA) ret = AB;
00182
00183 return ret;
00184 }
00185
00186 Pair EvtCyclic3::other(Pair i, Pair j)
00187 {
00188 return combine(other(i),other(j));
00189 }
00190
00191
00192
00193
00194
00195 Index EvtCyclic3::first(Pair i)
00196 {
00197 switch(i) {
00198 case BC: return B;
00199 case CA: return C;
00200 case AB: return A;
00201 }
00202 assert(0); return A;
00203 }
00204
00205
00206 Index EvtCyclic3::second(Pair i)
00207 {
00208 switch(i) {
00209 case BC: return C;
00210 case CA: return A;
00211 case AB: return B;
00212 }
00213 assert(0); return A;
00214 }
00215
00216
00217 Index EvtCyclic3::other(Pair i)
00218 {
00219 switch(i) {
00220 case BC: return A;
00221 case CA: return B;
00222 case AB: return C;
00223 }
00224 assert(0); return A;
00225 }
00226
00227
00228 Index EvtCyclic3::common(Pair i, Pair j)
00229 {
00230 return other(other(i,j));
00231 }
00232
00233
00234 Index EvtCyclic3::strToIndex(const char* str)
00235 {
00236 if(strcmp(str,"A")) return A;
00237 else if(strcmp(str,"B")) return B;
00238 else if(strcmp(str,"C")) return C;
00239 else assert(0);
00240 }
00241
00242
00243 Pair EvtCyclic3::strToPair(const char* str)
00244 {
00245 if(!strcmp(str,"AB") || !strcmp(str,"BA")) return AB;
00246 else if(!strcmp(str,"BC") || !strcmp(str,"CB")) return BC;
00247 else if(!strcmp(str,"CA") || !strcmp(str,"AC")) return CA;
00248 else assert(0);
00249 }
00250
00251
00252 char* EvtCyclic3::c_str(Index i)
00253 {
00254 switch(i) {
00255 case A: return "A";
00256 case B: return "B";
00257 case C: return "C";
00258 }
00259 assert(0); return 0;
00260 }
00261
00262
00263 char* EvtCyclic3::c_str(Pair i)
00264 {
00265 switch(i) {
00266 case BC: return "BC";
00267 case CA: return "CA";
00268 case AB: return "AB";
00269 }
00270 assert(0); return 0;
00271 }
00272
00273 char* EvtCyclic3::c_str(Perm p)
00274 {
00275 if(p == ABC) return "ABC";
00276 if(p == BCA) return "BCA";
00277 if(p == CAB) return "CAB";
00278 if(p == CBA) return "CBA";
00279 if(p == BAC) return "BAC";
00280 if(p == ACB) return "ACB";
00281 return "???";
00282 }
00283
00284 char* EvtCyclic3::append(const char* str, EvtCyclic3::Index i)
00285 {
00286
00287 char* s = new char[strlen(str)+2];
00288 strcpy(s,str);
00289 strcat(s,c_str(i));
00290
00291 return s;
00292 }
00293
00294 char* EvtCyclic3::append(const char* str, EvtCyclic3::Pair i)
00295 {
00296
00297 char* s = new char[strlen(str)+3];
00298 strcpy(s,str);
00299 strcat(s,c_str(i));
00300
00301 return s;
00302 }
00303
00304
00305 ostream& operator<<(ostream& os, EvtCyclic3::Index i)
00306 {
00307 switch(i) {
00308 case A: { os << "A"; return os; }
00309 case B: { os << "B"; return os; }
00310 case C: { os << "C"; return os; }
00311 }
00312 assert(0); return os;
00313 }
00314
00315
00316 ostream& operator<<(ostream& os, EvtCyclic3::Pair i)
00317 {
00318 switch(i) {
00319 case BC: { os << "BC"; return os; }
00320 case CA: { os << "CA"; return os; }
00321 case AB: { os << "AB"; return os; }
00322 }
00323 assert(0); return os;
00324 }
00325
00326
00327
00328