]>
Commit | Line | Data |
---|---|---|
da0e9ce3 | 1 | #include "EvtGenBase/EvtPatches.hh" |
2 | /******************************************************************************* | |
3 | * Project: BaBar detector at the SLAC PEP-II B-factory | |
4 | * Package: EvtGenBase | |
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 | |
7 | * | |
8 | * Copyright (C) 2002 Caltech | |
9 | *******************************************************************************/ | |
10 | ||
11 | #include <assert.h> | |
12 | #include <string.h> | |
13 | #include <iostream> | |
14 | #include "EvtGenBase/EvtCyclic3.hh" | |
15 | using std::ostream; | |
16 | ||
17 | using namespace EvtCyclic3; | |
18 | ||
19 | ||
20 | Index EvtCyclic3::permute(Index i, Perm p) | |
21 | { | |
22 | if(p == ABC) return i; | |
23 | else if(p == BCA) { | |
24 | if(i == A) return C; | |
25 | else if(i == B) return A; | |
26 | else if(i == C) return B; | |
27 | } | |
28 | else if(p == BCA) { | |
29 | if(i == A) return C; | |
30 | else if(i == B) return A; | |
31 | else if(i == C) return B; | |
32 | } | |
33 | else if(p == CAB) { | |
34 | if(i == A) return B; | |
35 | else if(i == B) return C; | |
36 | else if(i == C) return A; | |
37 | } | |
38 | else if(p == CBA) { | |
39 | if(i == A) return C; | |
40 | else if(i == B) return B; | |
41 | else if(i == C) return A; | |
42 | } | |
43 | else if(p == BAC) { | |
44 | if(i == A) return B; | |
45 | else if(i == B) return A; | |
46 | else if(i == C) return C; | |
47 | } | |
48 | else if(p == ACB) { | |
49 | if(i == A) return A; | |
50 | else if(i == B) return C; | |
51 | else if(i == C) return B; | |
52 | } | |
53 | assert(0); | |
54 | return A; | |
55 | } | |
56 | ||
57 | Perm EvtCyclic3::permutation(Index i1,Index i2,Index i3) | |
58 | { | |
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; | |
63 | assert(0); | |
64 | return ABC; | |
65 | } | |
66 | ||
67 | ||
68 | Perm EvtCyclic3::permute(Perm i,Perm p) | |
69 | { | |
70 | Index i1 = permute(permute(A,i),p); | |
71 | Index i2 = permute(permute(B,i),p); | |
72 | Index i3 = permute(permute(C,i),p); | |
73 | ||
74 | return permutation(i1,i2,i3); | |
75 | } | |
76 | ||
77 | Pair EvtCyclic3::permute(Pair i, Perm p) | |
78 | { | |
79 | Index i1 = permute(first(i),p); | |
80 | Index i2 = permute(second(i),p); | |
81 | return combine(i1,i2); | |
82 | } | |
83 | ||
84 | ||
85 | Pair EvtCyclic3::i2pair(int i) | |
86 | { | |
87 | assert(0<=i && i<=2); | |
88 | switch(i) { | |
89 | case 0: return BC; | |
90 | case 1: return CA; | |
91 | case 2: return AB; | |
92 | } | |
93 | assert(0); return AB; // should never get here | |
94 | } | |
95 | ||
96 | ||
97 | ||
98 | Index EvtCyclic3::prev(Index i) | |
99 | { | |
100 | switch(i) { | |
101 | case A: return C; | |
102 | case B: return A; | |
103 | case C: return B; | |
104 | } | |
105 | assert(0); return A; // should never get here | |
106 | } | |
107 | ||
108 | ||
109 | Index EvtCyclic3::next(Index i) | |
110 | { | |
111 | switch(i) { | |
112 | case A: return B; | |
113 | case B: return C; | |
114 | case C: return A; | |
115 | } | |
116 | assert(0); return A; // should never get here | |
117 | } | |
118 | ||
119 | ||
120 | Index EvtCyclic3::other(Index i, Index j) | |
121 | { | |
122 | assert(i != j); | |
123 | switch(i) { | |
124 | case A: | |
125 | switch(j) { | |
126 | case B: return C; | |
127 | case C: return B; | |
128 | default: assert(0); | |
129 | } | |
130 | case B: | |
131 | switch(j) { | |
132 | case C: return A; | |
133 | case A: return C; | |
134 | default: assert(0); | |
135 | } | |
136 | case C: | |
137 | switch(j) { | |
138 | case A: return B; | |
139 | case B: return A; | |
140 | default: assert(0); | |
141 | } | |
142 | } | |
143 | assert(0); return A; // should never get here | |
144 | } | |
145 | ||
146 | ||
147 | // Index-to-pair conversions | |
148 | ||
149 | Pair EvtCyclic3::other(Index i) | |
150 | { | |
151 | switch(i) { | |
152 | case A: return BC; | |
153 | case B: return CA; | |
154 | case C: return AB; | |
155 | } | |
156 | assert(0); return AB; // should never get here | |
157 | } | |
158 | ||
159 | ||
160 | Pair EvtCyclic3::combine(Index i, Index j) | |
161 | { | |
162 | return other(other(i,j)); | |
163 | } | |
164 | ||
165 | ||
166 | // Pair-to-pair conversions | |
167 | ||
168 | Pair EvtCyclic3::prev(Pair i) | |
169 | { | |
170 | Pair ret = CA; | |
171 | if(i == BC) ret = AB; | |
172 | else | |
173 | if(i == CA) ret = BC; | |
174 | ||
175 | return ret; | |
176 | } | |
177 | ||
178 | Pair EvtCyclic3::next(Pair i) | |
179 | { | |
180 | Pair ret = BC; | |
181 | if(i == BC) ret = CA; | |
182 | else | |
183 | if(i == CA) ret = AB; | |
184 | ||
185 | return ret; | |
186 | } | |
187 | ||
188 | Pair EvtCyclic3::other(Pair i, Pair j) | |
189 | { | |
190 | return combine(other(i),other(j)); | |
191 | } | |
192 | ||
193 | ||
194 | // Pair-to-index conversions | |
195 | ||
196 | ||
197 | Index EvtCyclic3::first(Pair i) | |
198 | { | |
199 | switch(i) { | |
200 | case BC: return B; | |
201 | case CA: return C; | |
202 | case AB: return A; | |
203 | } | |
204 | assert(0); return A; // should never get here | |
205 | } | |
206 | ||
207 | ||
208 | Index EvtCyclic3::second(Pair i) | |
209 | { | |
210 | switch(i) { | |
211 | case BC: return C; | |
212 | case CA: return A; | |
213 | case AB: return B; | |
214 | } | |
215 | assert(0); return A; // should never get here | |
216 | } | |
217 | ||
218 | ||
219 | Index EvtCyclic3::other(Pair i) | |
220 | { | |
221 | switch(i) { | |
222 | case BC: return A; | |
223 | case CA: return B; | |
224 | case AB: return C; | |
225 | } | |
226 | assert(0); return A; // should never get here | |
227 | } | |
228 | ||
229 | ||
230 | Index EvtCyclic3::common(Pair i, Pair j) | |
231 | { | |
232 | return other(other(i,j)); | |
233 | } | |
234 | ||
235 | ||
236 | Index EvtCyclic3::strToIndex(const char* str) | |
237 | { | |
238 | if(strcmp(str,"A")) return A; | |
239 | else if(strcmp(str,"B")) return B; | |
240 | else if(strcmp(str,"C")) return C; | |
241 | else assert(0); | |
242 | } | |
243 | ||
244 | ||
245 | Pair EvtCyclic3::strToPair(const char* str) | |
246 | { | |
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; | |
250 | else assert(0); | |
251 | } | |
252 | ||
253 | ||
254 | const char* EvtCyclic3::c_str(Index i) | |
255 | { | |
256 | switch(i) { | |
257 | case A: return "A"; | |
258 | case B: return "B"; | |
259 | case C: return "C"; | |
260 | } | |
261 | assert(0); return 0; // sngh | |
262 | } | |
263 | ||
264 | ||
265 | const char* EvtCyclic3::c_str(Pair i) | |
266 | { | |
267 | switch(i) { | |
268 | case BC: return "BC"; | |
269 | case CA: return "CA"; | |
270 | case AB: return "AB"; | |
271 | } | |
272 | assert(0); return 0; // sngh | |
273 | } | |
274 | ||
275 | const char* EvtCyclic3::c_str(Perm p) | |
276 | { | |
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"; | |
283 | assert(0); | |
284 | return "ABC"; | |
285 | } | |
286 | ||
287 | char* EvtCyclic3::append(const char* str, EvtCyclic3::Index i) | |
288 | { | |
289 | // str + null + 1 character | |
290 | char* s = new char[strlen(str)+2]; | |
291 | strcpy(s,str); | |
292 | strcat(s,c_str(i)); | |
293 | ||
294 | return s; | |
295 | } | |
296 | ||
297 | char* EvtCyclic3::append(const char* str, EvtCyclic3::Pair i) | |
298 | { | |
299 | // str + null + 2 characters | |
300 | char* s = new char[strlen(str)+3]; | |
301 | strcpy(s,str); | |
302 | strcat(s,c_str(i)); | |
303 | ||
304 | return s; | |
305 | } | |
306 | ||
307 | ||
308 | ostream& operator<<(ostream& os, EvtCyclic3::Index i) | |
309 | { | |
310 | switch(i) { | |
311 | case A: { os << "A"; return os; } | |
312 | case B: { os << "B"; return os; } | |
313 | case C: { os << "C"; return os; } | |
314 | } | |
315 | assert(0); return os; // should never get here | |
316 | } | |
317 | ||
318 | ||
319 | ostream& operator<<(ostream& os, EvtCyclic3::Pair i) | |
320 | { | |
321 | switch(i) { | |
322 | case BC: { os << "BC"; return os; } | |
323 | case CA: { os << "CA"; return os; } | |
324 | case AB: { os << "AB"; return os; } | |
325 | } | |
326 | assert(0); return os; // should never get here | |
327 | } | |
328 | ||
329 | ||
330 | ||
331 |