Doing some more checks (Laurent)
authorivana <ivana@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 12 Jan 2007 11:30:29 +0000 (11:30 +0000)
committerivana <ivana@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 12 Jan 2007 11:30:29 +0000 (11:30 +0000)
MUON/mapping/macros/testSlatPads.C

index b0e195d..4737337 100644 (file)
@@ -1,6 +1,22 @@
 // $Id$
 // $MpId: testSlatPads.C,v 1.1 2005/09/19 19:02:53 ivana Exp $
 
+/// Macro to check segmentation of slats.
+///
+/// What is tested :
+/// - first, that we can read both bending and non-bending for each slat
+/// - next, for each plane (b,nb), we retrieve all the pads
+///   in two different ways a) using a loop and HasPad method
+///   b) and using pad iterator. We check that both lead to the same set of pads
+///   and that each pad is retrieved only once ;-)
+/// - finally we do a "circular test" for all pads, i.e. we get a pad p1
+///   by indices and use p1's position to feed PadByPosition which gives us a
+///   pad p2. p1 should be equal to p2, of course.
+///
+/// Usage : .L testSlatPads.C++
+///         testSlatPads("slats.list"); where slats.list contains
+///         the list of slats' name to be tested, e.g. 112233NR3, etc...
+
 #if !defined(__CINT__) || defined(__MAKECINT__)
 #include "AliMpSlat.h"
 #include "AliMpSlatSegmentation.h"
 #include "AliMpVPadIterator.h"
 #include "AliMpArea.h"
 #include "AliMpSt345Reader.h"
+#include "AliMpSlatMotifMap.h"
 #include "AliMpPlaneType.h"
 #include "TObjArray.h"
 #include "TObjString.h"
 #include "Riostream.h"
 #include "TString.h"
 #include "AliMpIntPair.h"
+#include "TStopwatch.h"
 #include <fstream>
 #else
 #include "Riostream.h"
@@ -34,7 +52,7 @@ Int_t CircularTest(const AliMpSlat& slat)
       if ( pad.IsValid() )
       {
         ++n;
-        AliMpPad xcheck = seg.PadByPosition(pad.Position()+slat.Dimensions(),kFALSE);
+        AliMpPad xcheck = seg.PadByPosition(pad.Position(),kFALSE);
         if ( pad != xcheck ) 
         {
           cout << "(ix,iy)=" << i << "," << j << " ";
@@ -65,6 +83,12 @@ Int_t Count(const AliMpSlat& slat)
       }
     }
   }
+  Int_t n2 = seg.NofPads();
+  if ( n2 != n ) 
+  {
+    cout << Form("Count (%d) and NofPads (%d) give different results for slat %s",
+                 n,n2,slat.GetName()) << endl;
+  }
   return n;
 }
 
@@ -73,7 +97,7 @@ Int_t Iterate(const AliMpSlat& slat)
 {
   AliMpSlatSegmentation seg(&slat);
   
-  AliMpArea area(slat.Dimensions(),slat.Dimensions());
+  AliMpArea area(TVector2(0.0,0.0),slat.Dimensions());
   
   AliMpVPadIterator* it = seg.CreateIterator(area);
   
@@ -91,11 +115,103 @@ Int_t Iterate(const AliMpSlat& slat)
 }
 
 //______________________________________________________________________________
-void testSlatPads()
+Int_t Contains(const TList& list, const AliMpPad& pad)
+{
+  TIter next(&list);
+  AliMpPad* p;
+  Int_t n(0);
+  
+  while ( ( p = (AliMpPad*)next() ) )
+  {
+    if ( pad == *p ) ++n;
+  }
+  return n;
+}
+
+//______________________________________________________________________________
+void CheckMultiple(const TList& list, const char* title, const char* what)
+{
+  // check whether the list contains each pad only once
+  
+  TIter next(&list);
+  AliMpPad* pad;
+  while ( ( pad = (AliMpPad*)next() ) )
+  {
+    if ( Contains(list,*pad) != 1 )
+    {
+      cout << title << " " << what << " pad found more than once : " << endl;
+      pad->Print();
+    }
+  }
+      
+}
+
+//______________________________________________________________________________
+void XCheck(const AliMpSlat& slat)
 {
-  ifstream in("slats.list");
+  // find out which pads are not found by iterator, as compared to HasPad method
+  TList l1,l2;
+  l1.SetOwner(kTRUE);
+  l2.SetOwner(kTRUE);
+  
+  AliMpSlatSegmentation seg(&slat);
+  
+  for ( Int_t i = 0; i <= seg.MaxPadIndexX(); ++i )
+  {
+    for ( Int_t j = 0; j <= seg.MaxPadIndexY(); ++j )
+    {
+      AliMpPad pad = seg.PadByIndices(AliMpIntPair(i,j),kFALSE);
+      if ( pad.IsValid() )
+      {
+        l1.Add(new AliMpPad(pad));
+      }
+    }
+  }
+  
+  AliMpArea area(TVector2(0.0,0.0),slat.Dimensions());
+  
+  AliMpVPadIterator* it = seg.CreateIterator(area);
+  
+  it->First();
+    
+  while ( !it->IsDone() )
+  {
+    l2.Add(new AliMpPad(it->CurrentItem()));
+    it->Next();
+  }
+
+  TIter next(&l1);
+  AliMpPad* pad;
+  while ( ( pad = (AliMpPad*)next() ) )
+  {
+    if ( Contains(l2,*pad) != 1)
+    {
+      cout << "The following pad is not found by iterator : " << endl;
+      pad->Print();
+    }
+  }
+  
+  CheckMultiple(l2,slat.GetName(),"iterator");
+
+  CheckMultiple(l1,slat.GetName(),"padByIndices");
+}
+
+//______________________________________________________________________________
+void testSlatPads(const char* slatlist)
+{
+  ifstream in(slatlist);
   char line[80];
   TObjArray slatsToTest;
+  slatsToTest.SetOwner(kTRUE);
+  
+  TStopwatch timerCount;
+  TStopwatch timerIterate;
+  TStopwatch timerCT;
+  
+  timerCount.Start(true); timerCount.Stop();
+  timerIterate.Start(true); timerIterate.Stop();
+  timerCT.Start(true); timerCT.Stop();
+  
   
   while ( in.getline(line,80) )
   {
@@ -104,22 +220,31 @@ void testSlatPads()
   }
   
   in.close();
-    
+  
+  AliMpSlatMotifMap mm;
+  AliMpSt345Reader reader(mm);
+  
   for ( Int_t i = 0; i < slatsToTest.GetEntriesFast(); ++i )
   {
     TString slatName( ((TObjString*)slatsToTest[i])->String());
     
-    AliMpSlat* bending = AliMpSt345Reader::ReadSlat(slatName.Data(),kBendingPlane);
-    AliMpSlat* nonbending = AliMpSt345Reader::ReadSlat(slatName.Data(),kNonBendingPlane);
-
+    AliMpSlat* bending = reader.ReadSlat(slatName.Data(),kBendingPlane);
+    AliMpSlat* nonbending = reader.ReadSlat(slatName.Data(),kNonBendingPlane);
+  
+    timerCount.Start(false);
     Int_t NumberOfBendingPads = Count(*bending);
     Int_t NumberOfNonBendingPads = Count(*nonbending);
+    timerCount.Stop();
     
+    timerIterate.Start(false);
     Int_t xcheck_b = Iterate(*bending);   
     Int_t xcheck_nb = Iterate(*nonbending);
+    timerIterate.Stop();
     
+    timerCT.Start(false);
     Int_t nc_b = CircularTest(*bending);   
     Int_t nc_nb = CircularTest(*nonbending);
+    timerCT.Stop();
     
     cout << setw(10) << slatName
       << " BENDING : " << setw(5) << NumberOfBendingPads
@@ -134,7 +259,10 @@ void testSlatPads()
       cout << "FAILED.";
     }
     cout << endl;
-    
+
+    XCheck(*nonbending);
+    XCheck(*bending);
+
     if ( xcheck_b != NumberOfBendingPads )
     {
       cout << setw(20) << " Bending : HasPad and Iterator give different results !" 
@@ -147,9 +275,12 @@ void testSlatPads()
     }
     
    }
-}
-
-int main()
-{
-  testSlatPads();
+  
+  cout << "Count : "; 
+  timerCount.Print();
+  cout << "Iterate : ";
+  timerIterate.Print();
+  cout << "CT : ";
+  timerCT.Print();
+  
 }