FMD/scripts/TestIndex.C

   1 //____________________________________________________________________
   2 //
   3 // $Id$
   4 //
   5 /** @file    TestIndex.C
   6     @author  Christian Holm Christensen <cholm@nbi.dk>
   7     @date    Thu Mar 30 01:20:02 2006
   8     @brief   Test AliFMDIndex and AliFMDObjIndex
   9 */
  10 #ifndef __CINT__
  11 #include <AliFMDIndex.h>
  12 #include <iostream>
  13 #include <TFile.h>
  14 #endif
  15 /** @defgroup index_test Test of AliFMDIndex and AliFMDObjIndex
  16     @ingroup FMD_script
  17 */
  18 /** Write an AliFMDIndex object to output stream
  19     @ingroup index_test
  20     @param o Stream
  21     @param i Index object
  22     @return @a o */
  23 std::ostream&
  24 operator << (std::ostream& o, const AliFMDIndex& i)
  25 {
  26   return o << i.Name();
  27 }
  28
  29 /** Do the comparision, and print to standard out
  30     @ingroup index_test
  31     @param lhs Left hand side
  32     @param rhs Right hand side
  33     @return @f$ lhs < rhs @f$ */
  34 bool
  35 cmp(const AliFMDIndex& lhs, const AliFMDIndex& rhs)
  36 {
  37   bool ret = lhs < rhs;
  38   std::cout << "    (" << lhs << " <  " << rhs << "): " << ret << std::endl;
  39   return ret;
  40 }
  41
  42 /** Test if two index objects are equivilant (are the same).
  43     Equivilance is defined as
  44     @f[
  45     lhs \equiv rhs: \not (lhs < rhs \vee rhs < lhs)
  46     @f]
  47     @ingroup index_test
  48     @param lhs Left hand side
  49     @param rhs Right hand side
  50     @return @c true if @a lhs and @a rhs are equivilant */
  51 bool
  52 equiv(const AliFMDIndex& lhs, const AliFMDIndex& rhs)
  53 {
  54   bool ret = !(cmp(lhs,rhs) || cmp(rhs,lhs));
  55   std::cout << "    (" << lhs << " <> " << rhs << "): " << ret << std::endl;
  56   return ret;
  57 }
  58
  59 /** Check that @f$ \not (x < x)@f$
  60     @ingroup index_test
  61     @param x Object to test
  62     @return @c true if @a x is not less than itself */
  63 bool
  64 self(const AliFMDIndex& x)
  65 {
  66   bool ret = !cmp(x,x);
  67   std::cout << "  !(" << x << " < " << x << "): " << ret << std::endl;
  68   return ret;
  69 }
  70
  71 /** Check if @f$ a \wedge b \Rightarrow c@f$
  72     @ingroup index_test
  73     @param a First condition
  74     @param b Second condition
  75     @param c Implication
  76     @return @c true if the implication is valid */
  77 bool
  78 imply(bool a, bool b, bool c)
  79 {
  80   bool ret = ((a && b) && c) || (!(a && b));
  81   return ret;
  82 }
  83
  84 /** Check if the comparison operator is transitive, that is
  85     @f[
  86     (x < y \wedge y < z) \Rightarrow x < z
  87     @f]
  88     @ingroup index_test
  89     @param x First object
  90     @param y Second object
  91     @param z Third object
  92     @return @c true if the implication is met. */
  93 bool
  94 trans(const AliFMDIndex& x, const AliFMDIndex& y, const AliFMDIndex& z)
  95 {
  96   bool ret  = imply(cmp(x,y), cmp(y,z), cmp(x,z));
  97   std::cout << "  (" << x << " < " << y << " && " << y << " < " << z
  98             << ") => " << x << " < " << z << " "
  99             << (ret ? "holds" : "violated") << std::endl;
 100   return ret;
 101
 102 }
 103
 104 /** Check that the comparison operator preserves equivilance, that is
 105     @f[
 106     (x \equiv y \wedge y \equiv z) \Rightarrow (x \equiv z)
 107     @f]
 108     @ingroup index_test
 109     @param x First object
 110     @param y Second argument
 111     @param z Third object
 112     @return @c true if the implication holds. */
 113 bool
 114 equiv(const AliFMDIndex& x, const AliFMDIndex& y, const AliFMDIndex& z)
 115 {
 116   bool ret  = imply(equiv(x,y), equiv(y,z), equiv(x,z));
 117   std::cout << "  (" << x << " <> " << y << " && " << y << " <> " << z
 118             << ") => " << x << " <> " << z << " "
 119             << (ret ? "holds" : "violated") << std::endl;
 120   return ret;
 121 }
 122
 123
 124 /** Check if the comparison operator is a @e strictly @e weak @e ordering
 125     @ingroup index_test
 126  */
 127 void
 128 TestIndex()
 129 {
 130   AliFMDIndex i1(1, 'I', 5, 63);
 131   AliFMDIndex i2(i1);
 132   AliFMDIndex i3(i1);
 133   AliFMDIndex i4(1, 'I', 5, 127);
 134   AliFMDIndex i5(1, 'I', 15, 63);
 135   AliFMDIndex i6(2, 'O', 15, 60);
 136   std::cout << "Is !(x < x): " << std::endl;
 137   self(i1);
 138   std::cout << "Does (x < y && y < z) imply x < z: " << std::endl;
 139   // true, true
 140   trans(i1, i4, i5);
 141   // true, false
 142   trans(i1, i6, i5);
 143   // false, true
 144   trans(i4, i1, i5);
 145   // false, false
 146   trans(i6, i5, i1);
 147   std::cout << "Does !(x < y || x > y) && !(y < z || z > y) imply "
 148             << "!(x < z || x > z)" << std::endl;
 149   // true, true
 150   equiv(i1, i2, i3);
 151   // true, false
 152   equiv(i1, i2, i4);
 153   // false, true
 154   equiv(i4, i1, i2);
 155   // false, false
 156   equiv(i1, i4, i5);
 157
 158
 159
 160   TFile* file = TFile::Open("index.root", "RECREATE");
 161   file->WriteObject(&i1,"i1");
 162   file->Write();
 163   file->Close();
 164
 165   AliFMDIndex* i7 = 0;
 166   file = TFile::Open("index.root", "READ");
 167   file->GetObject("i1", i7);
 168   file->Close();
 169   std::cout << *i7 << " == " << i1 << ": " << (*i7 == i1) << std::endl;
 170
 171 }
 172
 173 /** Check if the comparison operator is a @e strictly @e weak @e ordering
 174     @ingroup index_test
 175  */
 176 void
 177 TestObjIndex()
 178 {
 179   AliFMDObjIndex i1(1, 'I', 5, 63);
 180   AliFMDObjIndex i2(i1);
 181   AliFMDObjIndex i3(i1);
 182   AliFMDObjIndex i4(1, 'I', 5, 127);
 183   AliFMDObjIndex i5(1, 'I', 15, 63);
 184   AliFMDObjIndex i6(2, 'O', 15, 60);
 185   std::cout << "Is !(x < x): " << std::endl;
 186   self(i1);
 187   std::cout << "Does (x < y && y < z) imply x < z: " << std::endl;
 188   // true, true
 189   trans(i1, i4, i5);
 190   // true, false
 191   trans(i1, i6, i5);
 192   // false, true
 193   trans(i4, i1, i5);
 194   // false, false
 195   trans(i6, i5, i1);
 196   std::cout << "Does !(x < y || x > y) && !(y < z || z > y) imply "
 197             << "!(x < z || x > z)" << std::endl;
 198   // true, true
 199   equiv(i1, i2, i3);
 200   // true, false
 201   equiv(i1, i2, i4);
 202   // false, true
 203   equiv(i4, i1, i2);
 204   // false, false
 205   equiv(i1, i4, i5);
 206
 207
 208
 209   TFile* file = TFile::Open("index.root", "RECREATE");
 210   i1.Write("i1");
 211   file->Write();
 212   file->Close();
 213
 214   file = TFile::Open("index.root", "READ");
 215   AliFMDObjIndex* i7 = (AliFMDObjIndex*)(file->Get("i1"));
 216   file->Close();
 217   std::cout << *i7 << " == " << i1 << ": " << (*i7 == i1) << std::endl;
 218
 219 }
 220
 221 /** Check that we can sort an array of index objects
 222     @ingroup index_test
 223  */
 224 void
 225 SortIndex()
 226 {
 227   TList l;
 228   for (size_t i = 0; i < 30; i++) {
 229     UShort_t det  = gRandom->Integer(3)+1;
 230     Char_t   ring = (gRandom->Uniform() > .5 ? 'O' : 'I');
 231     UShort_t sec  = gRandom->Integer(ring == 'I' ?  20 :  40);
 232     UShort_t str  = gRandom->Integer(ring == 'I' ? 512 : 256);
 233     l.AddAt(new AliFMDObjIndex(det, ring, sec, str), i);
 234   }
 235   std::cout << "Before sort" << std::endl;
 236   l.ls();
 237   l.Sort();
 238   std::cout << "After sort" << std::endl;
 239   l.ls();
 240 }
 241
 242
 243 //____________________________________________________________________
 244 //
 245 // EOF
 246 //