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