1 #include "EvtGenBase/EvtPatches.hh"
2 /*******************************************************************************
3 * Project: BaBar detector at the SLAC PEP-II B-factory
5 * File: $Id: EvtCyclic3.cc,v 1.16 2009/02/18 03:31:37 ryd Exp $
6 * Author: Alexei Dvoretskii, dvoretsk@slac.stanford.edu, 2001-2002
8 * Copyright (C) 2002 Caltech
9 *******************************************************************************/
14 #include "EvtGenBase/EvtCyclic3.hh"
17 using namespace EvtCyclic3;
20 Index EvtCyclic3::permute(Index i, Perm p)
22 if(p == ABC) return i;
25 else if(i == B) return A;
26 else if(i == C) return B;
30 else if(i == B) return A;
31 else if(i == C) return B;
35 else if(i == B) return C;
36 else if(i == C) return A;
40 else if(i == B) return B;
41 else if(i == C) return A;
45 else if(i == B) return A;
46 else if(i == C) return C;
50 else if(i == B) return C;
51 else if(i == C) return B;
57 Perm EvtCyclic3::permutation(Index i1,Index i2,Index i3)
59 assert(i1 != i2 && i2 != i3 && i3 != i1);
60 if(i1 == A) return (i2 == B) ? ABC : ACB;
61 if(i1 == B) return (i2 == C) ? BCA : BAC;
62 if(i1 == C) return (i2 == A) ? CAB : CBA;
68 Perm EvtCyclic3::permute(Perm i,Perm p)
70 Index i1 = permute(permute(A,i),p);
71 Index i2 = permute(permute(B,i),p);
72 Index i3 = permute(permute(C,i),p);
74 return permutation(i1,i2,i3);
77 Pair EvtCyclic3::permute(Pair i, Perm p)
79 Index i1 = permute(first(i),p);
80 Index i2 = permute(second(i),p);
81 return combine(i1,i2);
85 Pair EvtCyclic3::i2pair(int i)
93 assert(0); return AB; // should never get here
98 Index EvtCyclic3::prev(Index i)
105 assert(0); return A; // should never get here
109 Index EvtCyclic3::next(Index i)
116 assert(0); return A; // should never get here
120 Index EvtCyclic3::other(Index i, Index j)
143 assert(0); return A; // should never get here
147 // Index-to-pair conversions
149 Pair EvtCyclic3::other(Index i)
156 assert(0); return AB; // should never get here
160 Pair EvtCyclic3::combine(Index i, Index j)
162 return other(other(i,j));
166 // Pair-to-pair conversions
168 Pair EvtCyclic3::prev(Pair i)
171 if(i == BC) ret = AB;
173 if(i == CA) ret = BC;
178 Pair EvtCyclic3::next(Pair i)
181 if(i == BC) ret = CA;
183 if(i == CA) ret = AB;
188 Pair EvtCyclic3::other(Pair i, Pair j)
190 return combine(other(i),other(j));
194 // Pair-to-index conversions
197 Index EvtCyclic3::first(Pair i)
204 assert(0); return A; // should never get here
208 Index EvtCyclic3::second(Pair i)
215 assert(0); return A; // should never get here
219 Index EvtCyclic3::other(Pair i)
226 assert(0); return A; // should never get here
230 Index EvtCyclic3::common(Pair i, Pair j)
232 return other(other(i,j));
236 Index EvtCyclic3::strToIndex(const char* str)
238 if(strcmp(str,"A")) return A;
239 else if(strcmp(str,"B")) return B;
240 else if(strcmp(str,"C")) return C;
245 Pair EvtCyclic3::strToPair(const char* str)
247 if(!strcmp(str,"AB") || !strcmp(str,"BA")) return AB;
248 else if(!strcmp(str,"BC") || !strcmp(str,"CB")) return BC;
249 else if(!strcmp(str,"CA") || !strcmp(str,"AC")) return CA;
254 const char* EvtCyclic3::c_str(Index i)
261 assert(0); return 0; // sngh
265 const char* EvtCyclic3::c_str(Pair i)
268 case BC: return "BC";
269 case CA: return "CA";
270 case AB: return "AB";
272 assert(0); return 0; // sngh
275 const char* EvtCyclic3::c_str(Perm p)
277 if(p == ABC) return "ABC";
278 if(p == BCA) return "BCA";
279 if(p == CAB) return "CAB";
280 if(p == CBA) return "CBA";
281 if(p == BAC) return "BAC";
282 if(p == ACB) return "ACB";
287 char* EvtCyclic3::append(const char* str, EvtCyclic3::Index i)
289 // str + null + 1 character
290 char* s = new char[strlen(str)+2];
297 char* EvtCyclic3::append(const char* str, EvtCyclic3::Pair i)
299 // str + null + 2 characters
300 char* s = new char[strlen(str)+3];
308 ostream& operator<<(ostream& os, EvtCyclic3::Index i)
311 case A: { os << "A"; return os; }
312 case B: { os << "B"; return os; }
313 case C: { os << "C"; return os; }
315 assert(0); return os; // should never get here
319 ostream& operator<<(ostream& os, EvtCyclic3::Pair i)
322 case BC: { os << "BC"; return os; }
323 case CA: { os << "CA"; return os; }
324 case AB: { os << "AB"; return os; }
326 assert(0); return os; // should never get here