TEvtGen/EvtGenBase/EvtCyclic3.cxx

   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