TEvtGen/EvtGen/EvtGenBase/EvtCyclic3.cpp

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