In mapping/macros:

Updated macros to get them compiling and working again;
changed macros for St12 so that they are now by default executed
for both station types and both plane types.

diff --git a/MUON/mapping/macros/MUONCheckManu.C b/MUON/mapping/macros/MUONCheckManu.C
index 63ca73ebee2432647d5c5c82776ea32be1ecf9ac..5ade0864e450508f300368eefdece3eb633aedb7 100644 (file)
--- a/MUON/mapping/macros/MUONCheckManu.C
+++ b/MUON/mapping/macros/MUONCheckManu.C
@@ -17,6 +17,8 @@
 
 // By Ch. Finck, Subatech
 
+// 17/03/09  Does not compile
+
 #if !defined(__CINT__) || defined(__MAKECINT__)
 
 #include <Riostream.h>

diff --git a/MUON/mapping/macros/testAllIndices.C b/MUON/mapping/macros/testAllIndices.C
index 215ded1ff06e5939c80cf783eea38b58f136ced7..b6f8feb1c9ee60a1a761783665faef6d30005f41 100644 (file)
--- a/MUON/mapping/macros/testAllIndices.C
+++ b/MUON/mapping/macros/testAllIndices.C
@@ -3,10 +3,36 @@
 //
 // Test macro for testing which pad is seen as "existing" by AliMpSector.
 
-void testAllIndices(AliMp::StationType station = AliMp::kStation1,
-                    AliMp::PlaneType plane = AliMp::kBendingPlane) 
+#if !defined(__CINT__) || defined(__MAKECINT__)
+
+#include "AliMpStation12Type.h"
+#include "AliMpPlaneType.h"
+#include "AliMpDataProcessor.h"
+#include "AliMpDataMap.h"
+#include "AliMpDataStreams.h"
+#include "AliMpSector.h"
+#include "AliMpSectorReader.h"
+#include "AliMpSectorSegmentation.h" 
+#include "AliMpVPainter.h" 
+#include "AliMpRow.h"
+#include "AliMpVRowSegment.h"
+#include "AliMpMotifMap.h"
+#include "AliMpMotifPosition.h"
+#include "AliMpMotifType.h"
+
+#include <Riostream.h>
+#include <TCanvas.h>
+#include <TH2.h>
+
+#endif
+
+void testAllIndices(AliMq::Station12Type station, AliMp::PlaneType plane) 
 {
-  AliMpSectorReader r(station, plane);
+  AliMpDataProcessor mp;
+  AliMpDataMap* dataMap = mp.CreateDataMap("data");
+  AliMpDataStreams dataStreams(dataMap);
+
+  AliMpSectorReader r(dataStreams, station, plane);
 
   AliMpSector *sector=r.BuildSector();
   AliMpSectorSegmentation segmentation(sector);
@@ -26,11 +52,11 @@ void testAllIndices(AliMp::StationType station = AliMp::kStation1,
   TH2C* histo  = new TH2C("histo","Existing pads", 
                           nx, -0.5, nx-0.5, ny, -0.5, ny-0.5);
 
-  Int_t nx2 = 950/2;
-  Int_t ny2 = 950/2;
-  if (station == AliMp::kStation2) {
-    nx2 = 1200/2;
-    ny2 = 1200/2;
+  Int_t nx2 = 95/2;
+  Int_t ny2 = 95/2;
+  if (station == AliMq::kStation2) {
+    nx2 = 120/2;
+    ny2 = 120/2;
   }
   TH2F* histo2 = new TH2F("histo2","Existing positions",
                           nx2, 0, nx2*2, ny2, 0, ny2*2);
@@ -39,22 +65,22 @@ void testAllIndices(AliMp::StationType station = AliMp::kStation1,
   TCanvas* c2 = new TCanvas("c2","Only existing pads are filled");
   TCanvas* c3 = new TCanvas("c3","Positions");
   
-  for (Int_t irow=0;irow<sector->GetNofRows();irow++){
+  for ( Int_t irow=0; irow<sector->GetNofRows(); irow++ ) {
     AliMpRow* row = sector->GetRow(irow);
     
-    for (Int_t  iseg=0;iseg<row->GetNofRowSegments();iseg++){
+    for ( Int_t  iseg=0; iseg<row->GetNofRowSegments(); iseg++ ) {
       AliMpVRowSegment* seg = row->GetRowSegment(iseg);
       
-      for (Int_t imot=0;imot<seg->GetNofMotifs();imot++){
+      for ( Int_t imot=0; imot<seg->GetNofMotifs(); imot++) {
         AliMpMotifPosition* motifPos 
          = sector->GetMotifMap()->FindMotifPosition(seg->GetMotifPositionId(imot));
          
-        for (Int_t gassNum=0;gassNum<64;gassNum++){
+        for ( Int_t gassNum=0; gassNum<64; gassNum++ ) {
           if (motifPos->GetMotif()->GetMotifType()->FindConnectionByGassiNum(gassNum)){
           
             AliMpPad pad = segmentation.PadByLocation(AliMpIntPair(motifPos->GetID(),gassNum));
             if (pad != AliMpPad::Invalid()) {
-              histo->Fill (pad.GetIndices().GetFirst(),
+              histo->Fill(pad.GetIndices().GetFirst(),
                           pad.GetIndices().GetSecond());
               histo2->Fill(pad.Position().X(),
                            pad.Position().Y());
@@ -69,3 +95,23 @@ void testAllIndices(AliMp::StationType station = AliMp::kStation1,
   c3->cd();
   histo2->Draw("box");
 }
+
+void testAllIndices()
+{
+  AliMq::Station12Type  station[2] = { AliMq::kStation1, AliMq::kStation2 }; 
+  AliMp::PlaneType      plane[2]   = { AliMp::kBendingPlane, AliMp::kNonBendingPlane };
+  
+  for ( Int_t is = 0; is < 2; is++ ) {
+    for ( Int_t ip = 0; ip < 2; ip++ ) {
+    
+      cout << "Running testAllIndices for " 
+           << AliMq::Station12TypeName(station[is]) << "  "
+           << AliMp::PlaneTypeName(plane[ip])  << " ... " << endl;
+       
+      testAllIndices(station[is], plane[ip]);
+    
+      cout << "... end running " << endl << endl;
+    }  
+  }   
+}  
+  

diff --git a/MUON/mapping/macros/testAnyPadIterators.C b/MUON/mapping/macros/testAnyPadIterators.C
index 2c24eaa69f83129d7631e48444e5856f2bacf9ed..348284a112d177161730cf1e9d407e5a2c9a6fd0 100644 (file)
--- a/MUON/mapping/macros/testAnyPadIterators.C
+++ b/MUON/mapping/macros/testAnyPadIterators.C
@@ -3,6 +3,32 @@
 //
 // Test macro for reading  sector, and iterate over it
 
+#if !defined(__CINT__) || defined(__MAKECINT__)
+
+#include "AliMpStation12Type.h"
+#include "AliMpPlaneType.h"
+#include "AliMpDataProcessor.h"
+#include "AliMpDataMap.h"
+#include "AliMpDataStreams.h"
+#include "AliMpSector.h"
+#include "AliMpSectorReader.h"
+#include "AliMpSectorSegmentation.h" 
+#include "AliMpMotifType.h"
+#include "AliMpMotifMap.h"
+#include "AliMpVMotif.h"
+#include "AliMpVPadIterator.h"
+#include "AliMpSectorPadIterator.h"
+#include "AliMpNeighboursPadIterator.h"
+#include "AliMpMotifPositionPadIterator.h"
+#include "AliMpConstants.h"
+
+#include <Riostream.h>
+#include <TCanvas.h>
+#include <TMarker.h>
+#include <TH2.h>
+
+#endif
+
 class AliMpVPadIterator;
 void MarkPads(AliMpVPadIterator& it,Int_t xmax,Int_t ymax,Bool_t print=kTRUE)
 {
@@ -24,54 +50,69 @@ void MarkPads(AliMpVPadIterator& it,Int_t xmax,Int_t ymax,Bool_t print=kTRUE)
   }
 }
 
-void testAnyPadIterators(AliMp::StationType station = AliMp::kStation1,
-                         AliMp::PlaneType plane = AliMp::kBendingPlane, 
-                        Bool_t rootInput = false,
+void testAnyPadIterators(AliMq::Station12Type station, AliMp::PlaneType plane,
                          Int_t i=50, Int_t j=50)
 {
-  AliMpSector *sector = 0;
-  if (!rootInput) {
-    AliMpSectorReader r(station, plane);
-    sector=r.BuildSector();
-  }
-  else  {
-    TString filePath = AliMpFiles::SectorFilePath(station,plane);
-    filePath.ReplaceAll("zones.dat", "sector.root"); 
+  AliMpDataProcessor mp;
+  AliMpDataMap* dataMap = mp.CreateDataMap("data");
+  AliMpDataStreams dataStreams(dataMap);
 
-    TFile f(filePath.Data(), "READ");
-    sector = (AliMpSector*)f.Get("Sector");
-  }  
+  AliMpSectorReader r(dataStreams, station, plane);
+  AliMpSector* sector = r.BuildSector();
+  AliMpSectorSegmentation segmentation(sector);
     
   TCanvas *canv = new TCanvas("canv");
   canv->Divide(2,2);
-  //canv_1->Divide(2);
   
   canv->cd(1);
-  MarkPads(AliMpSectorPadIterator(sector), 150, 250, kFALSE);
+  AliMpSectorPadIterator its(sector);
+  MarkPads(its, 150, 250, kFALSE);
+
   canv->cd(2);
   AliMpVMotif* motif = sector->FindMotif(TVector2(30,3));
-
-  if (motif) {
+  if ( motif ) {
     AliMpMotifType* motifType = motif->GetMotifType();
-    MarkPads(AliMpMotifTypePadIterator(motifType),15,15);
-    cout<<"______________ MotifType " << motifType->GetID() 
-        <<"__________________________"<<endl;
-  } else cout<<"No motif found at given position..."<<endl;
+    AliMpMotifTypePadIterator itm(motifType);
+    MarkPads(itm,15,15);
+    cout << "______________ MotifType "  << motifType->GetID() 
+         << "__________________________" << endl;
+  } 
+  else 
+    cout << "No motif found at given position..." << endl;
   
   canv->cd(3);
-  //MarkPads(*AliMpPadIteratorPtr(AliMpSectorSegmentation(sector)->CreateIterator(AliMpIntPair(i,j)))
-  AliMpSectorSegmentation segm(sector);
-  AliMpPad pad = segm.PadByIndices(AliMpIntPair(i,j));
-  MarkPads(AliMpNeighboursPadIterator(&AliMpSectorSegmentation(sector),pad)
-           ,i+8,j+8);
+  AliMpPad pad = segmentation.PadByIndices(AliMpIntPair(i,j));
+  AliMpNeighboursPadIterator itn(&segmentation,pad);
+  MarkPads(itn,i+8,j+8);
   cout<<"________________ Neighbours __________________________"<<endl;
+  
   canv->cd(4);
   Int_t motifPosId = 20 | AliMpConstants::ManuMask(plane); 
-  if (plane == AliMp::kNonBendingPlane) motifPosId = 19;
+  if ( plane == AliMp::kNonBendingPlane ) motifPosId = 19;
   AliMpMotifPosition* motifPos = sector->GetMotifMap()->FindMotifPosition(motifPosId);
-  if (motifPos){
-    //MarkPads(*AliMpPadIteratorPtr(motifPos->CreateIterator()),15,15);
-    MarkPads(AliMpMotifPositionPadIterator(motifPos),15,15);
+  if ( motifPos ){
+    AliMpMotifPositionPadIterator itmp(motifPos);
+    MarkPads(itmp,15,15);
     cout<<"_________________ MotifPosition _________________________"<<endl;
   }
 }
+
+void testAnyPadIterators()
+{
+  AliMq::Station12Type  station[2] = { AliMq::kStation1, AliMq::kStation2 }; 
+  AliMp::PlaneType      plane[2]   = { AliMp::kBendingPlane, AliMp::kNonBendingPlane };
+  
+  for ( Int_t is = 0; is < 2; is++ ) {
+    for ( Int_t ip = 0; ip < 2; ip++ ) {
+    
+      cout << "Running testAnyPadIterators for " 
+           << AliMq::Station12TypeName(station[is]) << "  "
+           << AliMp::PlaneTypeName(plane[ip])  << " ... " << endl;
+       
+      testAnyPadIterators(station[is], plane[ip]);
+    
+      cout << "... end running " << endl << endl;
+    }  
+  }   
+}  
+  

diff --git a/MUON/mapping/macros/testDE.C b/MUON/mapping/macros/testDE.C
index 65ebad8ce7f66d03f752bdc3aa29f9b7f732598c..f47e05d27fcbb770711f1448665d4049c2a4aabe 100644 (file)
--- a/MUON/mapping/macros/testDE.C
+++ b/MUON/mapping/macros/testDE.C
@@ -3,24 +3,39 @@
 //
 // Test AliMpDEIterator & AliMpSegFactory classes
 
+#if !defined(__CINT__) || defined(__MAKECINT__)
+
+#include "AliMpDEIterator.h"
+#include "AliMpSegmentation.h"
+#include "AliMpVSegmentation.h"
+#include "AliMpCDB.h"
+#include "AliMpIntPair.h"
+#include "AliMpPad.h"
+
+#include <Riostream.h>
+
+#endif
+
 void testDE() 
 {
+  AliMpCDB::LoadMpSegmentation2();
+
   AliMpDEIterator it;
   for ( it.First(); ! it.IsDone(); it.Next() ) {
     cout << "In detection element: " << it.CurrentDEId() << endl;
 
     // Create/get segmentation via factory
-    AliMpVSegmentation* segmentation 
+    const AliMpVSegmentation* kSegmentation 
       = AliMpSegmentation::Instance()
           ->GetMpSegmentation(it.CurrentDEId(), AliMp::kCath0);
       
     // Print number of pads
-   cout << "   number of pads: " << segmentation->NofPads() << endl;   
+   cout << "   number of pads: " << kSegmentation->NofPads() << endl;   
       
     // Find pad by indices in this DE
-    AliMpIntPair indices(segmentation->MaxPadIndexX()/2 , 
-                         segmentation->MaxPadIndexY()/2);
-    AliMpPad pad = segmentation->PadByIndices(indices, false);
+    AliMpIntPair indices(kSegmentation->MaxPadIndexX()/2 , 
+                         kSegmentation->MaxPadIndexY()/2);
+    AliMpPad pad = kSegmentation->PadByIndices(indices, false);
     
     cout << "   found pad: " << pad << endl << endl;
   }

diff --git a/MUON/mapping/macros/testExistingPads.C b/MUON/mapping/macros/testExistingPads.C
index 091e9d02d9d32389623eafac6834ab6c1fb80ce2..5a54911128d0ae984067cfbae876e61561cabca6 100644 (file)
--- a/MUON/mapping/macros/testExistingPads.C
+++ b/MUON/mapping/macros/testExistingPads.C
@@ -26,13 +26,9 @@
 #include <TCanvas.h>
 #include <TH2.h>
 
-#include <iomanip>
-#include <fstream>
-
 #endif
 
-void testExistingPads(AliMq::Station12Type station = AliMq::kStation1,
-                      AliMp::PlaneType plane = AliMp::kBendingPlane)
+void testExistingPads(AliMq::Station12Type station,AliMp::PlaneType plane)
 {
   AliMpDataProcessor mp;
   AliMpDataMap* dataMap = mp.CreateDataMap("data");
@@ -90,3 +86,22 @@ void testExistingPads(AliMq::Station12Type station = AliMq::kStation1,
   
   delete fast;
 }
+
+void testExistingPads()
+{
+  AliMq::Station12Type  station[2] = { AliMq::kStation1, AliMq::kStation2 }; 
+  AliMp::PlaneType      plane[2]   = { AliMp::kBendingPlane, AliMp::kNonBendingPlane };
+  
+  for ( Int_t is = 0; is < 2; is++ ) {
+    for ( Int_t ip = 0; ip < 2; ip++ ) {
+    
+      cout << "Running testExistingPads for " 
+           << AliMq::Station12TypeName(station[is]) << "  "
+           << AliMp::PlaneTypeName(plane[ip])  << " ... " << endl;
+       
+      testExistingPads(station[is], plane[ip]);
+    
+      cout << "... end running " << endl << endl;
+    }  
+  }   
+}  

diff --git a/MUON/mapping/macros/testExistingPads2.C b/MUON/mapping/macros/testExistingPads2.C
index 75584df5db19abccebeacb58b2df42b9d5c413ce..3a9618a594e9fddcd2e0179f8070db80a26c2747 100644 (file)
--- a/MUON/mapping/macros/testExistingPads2.C
+++ b/MUON/mapping/macros/testExistingPads2.C
@@ -26,15 +26,12 @@
 #include "AliMpVPadIterator.h"
 
 #include <Riostream.h>
-
-#include <iomanip>
-#include <fstream>
+#include <TString.h>
 
 #endif
 
-void testExistingPads2(Bool_t useFastSegmentation = kTRUE,
-                       AliMq::Station12Type station = AliMq::kStation1,
-                       AliMp::PlaneType plane = AliMp::kBendingPlane) 
+void testExistingPads2(AliMq::Station12Type station, AliMp::PlaneType plane,
+                       Bool_t useFastSegmentation = kTRUE) 
 {
   // Read data
   AliMpDataProcessor mp;
@@ -51,8 +48,14 @@ void testExistingPads2(Bool_t useFastSegmentation = kTRUE,
     segmentation = new AliMpSectorSegmentation(sector);
     
   // Output files 
-  ofstream out1("testExistingPads.ixiy.out", ios::out);
-  ofstream out2("testExistingPads.iter.out", ios::out);
+  TString outName = "testExistingPads.";
+  outName += AliMq::Station12TypeName(station);
+  outName += AliMp::PlaneTypeName(plane);
+  TString out1Name = outName + ".ixiy.out";
+  TString out2Name = outName + ".iter.out";
+
+  ofstream out1(out1Name.Data(), ios::out);
+  ofstream out2(out2Name.Data(), ios::out);
   
   // First loop over indices
   cout << "Iterating via indices ..." << endl;
@@ -90,3 +93,23 @@ void testExistingPads2(Bool_t useFastSegmentation = kTRUE,
   
   delete segmentation;
 }
+
+void testExistingPads2()
+{
+  AliMq::Station12Type  station[2] = { AliMq::kStation1, AliMq::kStation2 }; 
+  AliMp::PlaneType      plane[2]   = { AliMp::kBendingPlane, AliMp::kNonBendingPlane };
+  
+  for ( Int_t is = 0; is < 2; is++ ) {
+    for ( Int_t ip = 0; ip < 2; ip++ ) {
+    
+      cout << "Running testExistingPads2 for " 
+           << AliMq::Station12TypeName(station[is]) << "  "
+           << AliMp::PlaneTypeName(plane[ip])  << " ... " << endl;
+       
+      testExistingPads2(station[is], plane[ip]);
+    
+      cout << "... end running " << endl << endl;
+    }  
+  }   
+}  
+  

diff --git a/MUON/mapping/macros/testGraphics.C b/MUON/mapping/macros/testGraphics.C
index ed4f319e4db99ad6459828420e488e61ca7f26b7..d42d8fb26f488732f55a81353984eaf133bc6979 100644 (file)
--- a/MUON/mapping/macros/testGraphics.C
+++ b/MUON/mapping/macros/testGraphics.C
@@ -3,24 +3,36 @@
 //
 // Test macro for drawing sector data.
 
-void testGraphics(AliMp::StationType station = AliMp::kStation1,
-                  AliMp::PlaneType plane = AliMp::kBendingPlane,
-                 Bool_t rootInput = false) 
+#if !defined(__CINT__) || defined(__MAKECINT__)
+
+#include "AliMpStation12Type.h"
+#include "AliMpPlaneType.h"
+#include "AliMpDataProcessor.h"
+#include "AliMpDataMap.h"
+#include "AliMpDataStreams.h"
+#include "AliMpSector.h"
+#include "AliMpSectorReader.h"
+#include "AliMpRow.h"
+#include "AliMpVRowSegment.h"
+#include "AliMpMotifMap.h"
+#include "AliMpMotifPosition.h"
+#include "AliMpVPainter.h"
+
+#include <Riostream.h>
+#include <TCanvas.h>
+
+#endif
+
+void testGraphics(AliMq::Station12Type station, AliMp::PlaneType plane) 
 {
-  AliMpSector *sector = 0;
-  if (!rootInput) {
-    AliMpSectorReader r(station, plane);
-    sector=r.BuildSector();
-  }
-  else  {
-    TString filePath = AliMpFiles::SectorFilePath(station,plane);
-    filePath.ReplaceAll("zones.dat", "sector.root"); 
+  AliMpDataProcessor mp;
+  AliMpDataMap* dataMap = mp.CreateDataMap("data");
+  AliMpDataStreams dataStreams(dataMap);
 
-    TFile f(filePath.Data(), "READ");
-    sector = (AliMpSector*)f.Get("Sector");
-  }  
+  AliMpSectorReader r(dataStreams, station, plane);
+  AliMpSector* sector = r.BuildSector();
     
-  AliMpVPainter *painter=AliMpVPainter::CreatePainter(sector);
+  AliMpVPainter* painter = AliMpVPainter::CreatePainter(sector);
 
   TCanvas* canvas  = new TCanvas();
   TCanvas* canvas2 = new TCanvas();
@@ -30,7 +42,7 @@ void testGraphics(AliMp::StationType station = AliMp::kStation1,
     c[i]->Divide(2,2);
   }  
 
- //first, paint the whole sector
+  //first, paint the whole sector
   canvas->cd();
   painter->Draw("");
   //now paint each rows
@@ -86,12 +98,13 @@ void testGraphics(AliMp::StationType station = AliMp::kStation1,
   // each motifs, in each row segments, ... with its name
   c[3]->cd(4);
   painter->Draw("ZSSMT");
+
   // now, draw a specific motif, in a whole canvas, and
   // print all its pad names
   Int_t id = sector->GetRow(5)->GetRowSegment(0)->GetMotifPositionId(0);
   AliMpMotifPosition* motifPos = sector->GetMotifMap()->FindMotifPosition(id);
-  motifPainter = AliMpVPainter::CreatePainter(motifPos);
-  TCanvas* onepad = new TCanvas("onepad","One motif");
+  AliMpVPainter* motifPainter = AliMpVPainter::CreatePainter(motifPos);
+  new TCanvas("onepad","One motif");
   motifPainter->Draw("PT");
   
   //////////////////////////////  
@@ -99,3 +112,23 @@ void testGraphics(AliMp::StationType station = AliMp::kStation1,
   canvas2->cd();
   painter->Draw("RSMCI");
 }
+
+void testGraphics()
+{
+  AliMq::Station12Type  station[2] = { AliMq::kStation1, AliMq::kStation2 }; 
+  AliMp::PlaneType      plane[2]   = { AliMp::kBendingPlane, AliMp::kNonBendingPlane };
+  
+  for ( Int_t is = 0; is < 2; is++ ) {
+    for ( Int_t ip = 0; ip < 2; ip++ ) {
+    
+      cout << "Running testGraphics for " 
+           << AliMq::Station12TypeName(station[is]) << "  "
+           << AliMp::PlaneTypeName(plane[ip])  << " ... " << endl;
+       
+      testGraphics(station[is], plane[ip]);
+    
+      cout << "... end running " << endl << endl;
+    }  
+  }   
+}  
+  

diff --git a/MUON/mapping/macros/testGraphicsSlat.C b/MUON/mapping/macros/testGraphicsSlat.C
index 61c2fb225fa31da92c6c70e118ba716473842ef3..787fc220e87e44c2bf78f32c3e11b67e1c6452bc 100644 (file)
--- a/MUON/mapping/macros/testGraphicsSlat.C
+++ b/MUON/mapping/macros/testGraphicsSlat.C
@@ -23,6 +23,12 @@
 #if !defined(__CINT__) || defined(__MAKECINT__)
 
 // MUON includes
+#include "AliMpStationType.h"
+#include "AliMpStation12Type.h"
+#include "AliMpPlaneType.h"
+#include "AliMpDataProcessor.h"
+#include "AliMpDataMap.h"
+#include "AliMpDataStreams.h"
 #include "AliMpSt345Reader.h"
 #include "AliMpPCB.h"
 #include "AliMpSlat.h"
@@ -32,9 +38,11 @@
 #include "AliMpMotifPosition.h"
 #include "AliMpMotif.h"
 #include "AliMpSlatMotifMap.h"
+#include "AliMpDataStreams.h"
+
 #include "TVector2.h"
 #include "TCanvas.h"
-#include "AliMpDataStreams.h"
+
 #endif
 
 void testGraphicsMotif(Option_t* motifType = "R43", const TVector2& padSizes = TVector2(5,0.5))
@@ -42,8 +50,15 @@ void testGraphicsMotif(Option_t* motifType = "R43", const TVector2& padSizes = T
   // Warning : this function leaks memory. But should be fine as only used 
   // interactively to check a few motifs at once...
   //
-  AliMpDataStreams ds;
-  AliMpMotifReader reader(ds,AliMp::kStation345,AliMp::kBendingPlane);
+  AliMpDataProcessor mp;
+  AliMpDataMap* dataMap = mp.CreateDataMap("data");
+  AliMpDataStreams dataStreams(dataMap);
+
+  AliMp::StationType station = AliMp::kStation345;
+  AliMq::Station12Type station12 = AliMq::kNotSt12;
+  AliMp::PlaneType plane = AliMp::kBendingPlane;
+  
+  AliMpMotifReader reader(dataStreams, station, station12, plane);
   AliMpMotifType* type = reader.BuildMotifType(motifType);
   if (!type)
   {
@@ -77,6 +92,13 @@ void testGraphicsSlat(AliMp::PlaneType planeType = AliMp::kBendingPlane,
   // P pad
   // I indices
 
+  AliMpDataProcessor mp;
+  AliMpDataMap* dataMap = mp.CreateDataMap("data");
+  AliMpDataStreams dataStreams(dataMap);
+
+  AliMpSlatMotifMap* motifMap = new AliMpSlatMotifMap();
+  AliMpSt345Reader* reader = new AliMpSt345Reader(dataStreams, motifMap);
+
   // PMPT to get manu channels numbering
   
   Char_t *slatName[19] = {"122000SR1", "112200SR2", "122200S", "222000N", "220000N",
@@ -93,8 +115,7 @@ void testGraphicsSlat(AliMp::PlaneType planeType = AliMp::kBendingPlane,
     c1[i]= new TCanvas(c1Name,slatName[i],10,10,1200,800);     
 
     Char_t* slatType = slatName[i];
-    AliMpDataStreams ds;
-    AliMpSt345Reader* reader = new AliMpSt345Reader(ds);
+
     AliMpSlat* slat = reader->ReadSlat(slatType, planeType);
     AliMpVPainter* painter = AliMpVPainter::CreatePainter(slat);
     painter->Draw(option);
@@ -106,7 +127,6 @@ void testGraphicsSlat(AliMp::PlaneType planeType = AliMp::kBendingPlane,
     
     if (saveJPG) c1[i]->Print(c1NameJpg);
   }
- 
 }
 
 void testGraphicsPCB(const char* pcbName="S2B",
@@ -116,8 +136,12 @@ void testGraphicsPCB(const char* pcbName="S2B",
   
   TCanvas* c = new TCanvas(pcbName,pcbName,10,10,1200,800);     
     
-  AliMpDataStreams ds;
-  AliMpSt345Reader* reader = new AliMpSt345Reader(ds);
+  AliMpDataProcessor mp;
+  AliMpDataMap* dataMap = mp.CreateDataMap("data");
+  AliMpDataStreams dataStreams(dataMap);
+
+  AliMpSlatMotifMap* motifMap = new AliMpSlatMotifMap();
+  AliMpSt345Reader* reader = new AliMpSt345Reader(dataStreams, motifMap);
   AliMpPCB* pcb = reader->ReadPCB(pcbName);
   if (!pcb) 
   {

diff --git a/MUON/mapping/macros/testIndicesLimits.C b/MUON/mapping/macros/testIndicesLimits.C
index 20e666a80cdbd8258474c9ae2213774eda93dd2b..59c7f2c278c37b4632642661de0165918d522ae2 100644 (file)
--- a/MUON/mapping/macros/testIndicesLimits.C
+++ b/MUON/mapping/macros/testIndicesLimits.C
@@ -3,22 +3,38 @@
 //
 // Test macro for indices limits.
 
-void testIndicesLimits(AliMp::StationType station = AliMp::kStation1,
-                       AliMp::PlaneType plane = AliMp::kBendingPlane, 
-                      Bool_t rootInput = false)
+#if !defined(__CINT__) || defined(__MAKECINT__)
+
+#include "AliMpStation12Type.h"
+#include "AliMpPlaneType.h"
+#include "AliMpDataProcessor.h"
+#include "AliMpDataMap.h"
+#include "AliMpDataStreams.h"
+#include "AliMpSector.h"
+#include "AliMpSectorReader.h"
+#include "AliMpSectorSegmentation.h" 
+#include "AliMpRow.h"
+#include "AliMpVRowSegment.h"
+#include "AliMpMotifMap.h"
+#include "AliMpMotifPosition.h"
+#include "AliMpMotifType.h"
+
+#include <Riostream.h>
+#include <TCanvas.h>
+#include <TH2.h>
+
+#endif
+
+void testIndicesLimits(AliMq::Station12Type station,AliMp::PlaneType plane)
 {
-  AliMpSector *sector = 0;
-  if (!rootInput) {
-    AliMpSectorReader r(station, plane);
-    sector=r.BuildSector();
-  }
-  else  {
-    TString filePath = AliMpFiles::SectorFilePath(station,plane);
-    filePath.ReplaceAll("zones.dat", "sector.root"); 
+  AliMpDataProcessor mp;
+  AliMpDataMap* dataMap = mp.CreateDataMap("data");
+  AliMpDataStreams dataStreams(dataMap);
+
+  AliMpSectorReader r(dataStreams, station, plane);
 
-    TFile f(filePath.Data(), "READ");
-    sector = (AliMpSector*)f.Get("Sector");
-  }  
+  AliMpSector *sector=r.BuildSector();
+  AliMpSectorSegmentation segmentation(sector);
 
   // Loop over rows
   for (Int_t i=0; i<sector->GetNofRows(); i++) {
@@ -60,5 +76,25 @@ void testIndicesLimits(AliMp::StationType station = AliMp::kStation1,
   delete sector;
 }                             
       
+void testIndicesLimits()
+{
+  AliMq::Station12Type  station[2] = { AliMq::kStation1, AliMq::kStation2 }; 
+  AliMp::PlaneType      plane[2]   = { AliMp::kBendingPlane, AliMp::kNonBendingPlane };
+  
+  for ( Int_t is = 0; is < 2; is++ ) {
+    for ( Int_t ip = 0; ip < 2; ip++ ) {
+    
+      cout << "Running testIndicesLimits for " 
+           << AliMq::Station12TypeName(station[is]) << "  "
+           << AliMp::PlaneTypeName(plane[ip])  << " ... " << endl;
+       
+      testIndicesLimits(station[is], plane[ip]);
+    
+      cout << "... end running " << endl << endl;
+    }  
+  }   
+}  
+  
+ 
 
  

diff --git a/MUON/mapping/macros/testManuListSt345.C b/MUON/mapping/macros/testManuListSt345.C
index c167748b63d98f13462b3e6c5303ffd0d4cbdb3a..d6ca11e0ab00a6198d356fe4d795aac7bcc7ff54 100644 (file)
--- a/MUON/mapping/macros/testManuListSt345.C
+++ b/MUON/mapping/macros/testManuListSt345.C
@@ -18,7 +18,7 @@
 //
 // Macro to generate manu list per buspatch for station 3, 4 and 5
 // Christian Finck, Subatech
-//
+// 17/03/09  Not working
 
 #if !defined(__CINT__) || defined(__MAKECINT__)
 

diff --git a/MUON/mapping/macros/testMotifTypeIterators.C b/MUON/mapping/macros/testMotifTypeIterators.C
index 65a188a92d13d5be0951b94d22f5c59d20cec3f3..0673c79e84ea33eebfc61efb15d68e4ce1da6a8b 100644 (file)
--- a/MUON/mapping/macros/testMotifTypeIterators.C
+++ b/MUON/mapping/macros/testMotifTypeIterators.C
@@ -3,19 +3,38 @@
 //
 // Test macro for reading motif type data and iterate over them.
 
-void testMotifTypeIterators(AliMp::StationType station = AliMp::kStation1,
-                            AliMp::PlaneType plane = AliMp::kBendingPlane,
-                           Bool_t rootInput = false)
+#if !defined(__CINT__) || defined(__MAKECINT__)
+
+#include "AliMpStation12Type.h"
+#include "AliMpPlaneType.h"
+#include "AliMpDataProcessor.h"
+#include "AliMpDataMap.h"
+#include "AliMpDataStreams.h"
+#include "AliMpMotifReader.h"
+#include "AliMpMotifType.h"
+#include "AliMpMotifTypePadIterator.h"
+
+#include <Riostream.h>
+#include <TCanvas.h>
+#include <TMarker.h>
+#include <TH2.h>
+
+#include <vector>
+
+#endif
+
+void testMotifTypeIterators(AliMq::Station12Type station, AliMp::PlaneType plane)
 {
   TString names;
   TString names2;
   Int_t nv =0;
-  if ( station == AliMp::kStation1 )
+  if ( station == AliMq::kStation1 ) {
     if ( plane == AliMp::kBendingPlane ) 
       names ="ABCDEFGHI";
     else
       names = "ABCDEFGHIJKLMN";
-  else if ( station == AliMp::kStation2 ) 
+  }    
+  else if ( station == AliMq::kStation2 ) {
     if ( plane == AliMp::kBendingPlane ) {
       names ="ABCDEFGHIJKLMNOPQRSTUVWXY";
       names2 ="abcdefghimnptuvvvvv";
@@ -26,23 +45,25 @@ void testMotifTypeIterators(AliMp::StationType station = AliMp::kStation1,
       names2 ="abcdefgijklmnopqrstuwvvvvv";
       nv = 5;
     }  
+  }  
   Int_t nofMotifs = names.Length() + names2.Length(); 
   // cout << " nofMotifs: " << nofMotifs << endl;   
     
-  TH2C* histos[] = new TH2C* [nofMotifs];
-  TCanvas* canv[] = new TCanvas* [1+(nofMotifs-1)/4];
+  std::vector<TH2C*> histos;
+  std::vector<TCanvas*> cvs;
   Int_t i;
   for (i=0;i<1+(nofMotifs-1)/4;++i){
-    // canv[i] = new TCanvas(Form("canv%d",i),"Iterator viewing...");
-               // CINT limitation on DEC
-              
     TString cname("canv"); cname += i;
-    canv[i] = new TCanvas(cname.Data(),"Iterator viewing...");
-    
-    canv[i]->Divide(2,2); 
+    TCanvas* canv = new TCanvas(cname.Data(),"Iterator viewing...");
+    canv->Divide(2,2); 
+    cvs.push_back(canv);
   }
     
-  AliMpMotifReader r(station, plane);
+  AliMpDataProcessor mp;
+  AliMpDataMap* dataMap = mp.CreateDataMap("data");
+  AliMpDataStreams dataStreams(dataMap);
+
+  AliMpMotifReader r(dataStreams, AliMp::kStation12, station, plane);
   //r.SetVerboseLevel(2);
 
   for (i=0;i<nofMotifs;++i){
@@ -63,7 +84,7 @@ void testMotifTypeIterators(AliMp::StationType station = AliMp::kStation1,
    
     AliMpMotifType *mt = r.BuildMotifType(mname);
 
-    canv[i/4]->cd(1+ (i%4));
+    cvs[i/4]->cd(1+ (i%4));
     //histos[i] = new TH2C(Form("h%d",i),Form("Motif type %c",names[i]),
     //                     mt->GetNofPadsX(),-0.5,mt->GetNofPadsX()-0.5,
     //                     mt->GetNofPadsY(),-0.5,mt->GetNofPadsY()-0.5);
@@ -71,9 +92,10 @@ void testMotifTypeIterators(AliMp::StationType station = AliMp::kStation1,
 
     TString hname("h"); hname += i;
 
-    histos[i] = new TH2C(hname.Data(), mname.Data(),
+    TH2C* histo = new TH2C(hname.Data(), mname.Data(),
                          mt->GetNofPadsX(),-0.5,mt->GetNofPadsX()-0.5,
                          mt->GetNofPadsY(),-0.5,mt->GetNofPadsY()-0.5);
+    histos.push_back(histo);                         
 
     cout<<"Motif Type "<<mt->GetID()<<endl;
     cout<<"--------------------------------"<<endl;
@@ -84,12 +106,31 @@ void testMotifTypeIterators(AliMp::StationType station = AliMp::kStation1,
     for (it.First(); ! it.IsDone(); it.Next()) {
       cout << "Iterator " << num << ' '<< it.CurrentItem().GetIndices() << endl;
       ++num;
-      histos[i]->Fill(it.CurrentItem().GetIndices().GetFirst(),
-                      it.CurrentItem().GetIndices().GetSecond(),num);
+      histo->Fill(it.CurrentItem().GetIndices().GetFirst(),
+                  it.CurrentItem().GetIndices().GetSecond(),num);
     }
 
     //delete mt;
-    histos[i]->Draw("text");
-    canv[i/4]->Update();
+    histo->Draw("text");
+    cvs[i/4]->Update();
   }
 }
+void testMotifTypeIterators()
+{
+  AliMq::Station12Type  station[2] = { AliMq::kStation1, AliMq::kStation2 }; 
+  AliMp::PlaneType      plane[2]   = { AliMp::kBendingPlane, AliMp::kNonBendingPlane };
+  
+  for ( Int_t is = 0; is < 2; is++ ) {
+    for ( Int_t ip = 0; ip < 2; ip++ ) {
+    
+      cout << "Running testMotifTypeIterators for " 
+           << AliMq::Station12TypeName(station[is]) << "  "
+           << AliMp::PlaneTypeName(plane[ip])  << " ... " << endl;
+       
+      testMotifTypeIterators(station[is], plane[ip]);
+    
+      cout << "... end running " << endl << endl;
+    }  
+  }   
+}  
+  

diff --git a/MUON/mapping/macros/testNeighboursPadIterator.C b/MUON/mapping/macros/testNeighboursPadIterator.C
index c8238938f152516f94fe1df95961fda8341761dd..bf6f2125edf5c170f2958579e3bf645d330f19bd 100644 (file)
--- a/MUON/mapping/macros/testNeighboursPadIterator.C
+++ b/MUON/mapping/macros/testNeighboursPadIterator.C
@@ -3,27 +3,38 @@
 //
 // Test macro for reading  sector, and iterate over it
 
-void testNeighboursPadIterator(AliMp::StationType station = AliMp::kStation1,
-                               AliMp::PlaneType plane = AliMp::kBendingPlane, 
-                              Bool_t rootInput = false,
+#if !defined(__CINT__) || defined(__MAKECINT__)
+
+#include "AliMpStation12Type.h"
+#include "AliMpPlaneType.h"
+#include "AliMpDataProcessor.h"
+#include "AliMpDataMap.h"
+#include "AliMpDataStreams.h"
+#include "AliMpSector.h"
+#include "AliMpSectorSegmentation.h"
+#include "AliMpSectorReader.h"
+#include "AliMpPad.h"
+#include "AliMpArea.h"
+#include "AliMpNeighboursPadIterator.h"
+
+#include <Riostream.h>
+#include <TCanvas.h>
+#include <TMarker.h>
+
+#endif
+
+void testNeighboursPadIterator(AliMq::Station12Type station, AliMp::PlaneType plane,
                                Int_t i=50, Int_t j=50)
 {
-  AliMpSector *sector = 0;
-  if (!rootInput) {
-    AliMpSectorReader r(station, plane);
-    sector=r.BuildSector();
-  }
-  else  {
-    TString filePath = AliMpFiles::SectorFilePath(station,plane);
-    filePath.ReplaceAll("zones.dat", "sector.root"); 
-
-    TFile f(filePath.Data(), "READ");
-    sector = (AliMpSector*)f.Get("Sector");
-  }  
+  AliMpDataProcessor mp;
+  AliMpDataMap* dataMap = mp.CreateDataMap("data");
+  AliMpDataStreams dataStreams(dataMap);
 
+  AliMpSectorReader r(dataStreams, station, plane);
+  AliMpSector* sector = r.BuildSector();
   AliMpSectorSegmentation segm(sector);  
   
-  TCanvas *can = new TCanvas("canv");
+  new TCanvas("canv");
 
   const Double_t xmax=75;
   const Double_t ymax=120;
@@ -45,14 +56,33 @@ void testNeighboursPadIterator(AliMp::StationType station = AliMp::kStation1,
   AliMpVPadIterator* iter2
     = segm.CreateIterator(AliMpArea(pad.Position(),2.*pad.Dimensions()*1.1));
 
-  Int_t i=0;
+  Int_t counter = 0;
   for( iter2->First(); !iter2->IsDone() && i<10; iter2->Next()) {
-    Int_t ix = iter2->CurrentItem().GetIndices().GetFirst();
-    Int_t iy = iter2->CurrentItem().GetIndices().GetSecond();
-    cout<<"Iterator number "<< i << " at "<< iter2->CurrentItem().GetIndices() <<endl;
-    i++;
+    //Int_t ix = iter2->CurrentItem().GetIndices().GetFirst();
+    //Int_t iy = iter2->CurrentItem().GetIndices().GetSecond();
+    cout<<"Iterator number "<< counter++ << " at "<< iter2->CurrentItem().GetIndices() <<endl;
   }
   
   delete iter2;
   delete sector;
 }
+
+void testNeighboursPadIterator()
+{
+  AliMq::Station12Type  station[2] = { AliMq::kStation1, AliMq::kStation2 }; 
+  AliMp::PlaneType      plane[2]   = { AliMp::kBendingPlane, AliMp::kNonBendingPlane };
+  
+  for ( Int_t is = 0; is < 2; is++ ) {
+    for ( Int_t ip = 0; ip < 2; ip++ ) {
+    
+      cout << "Running testNeighboursPadIterator for " 
+           << AliMq::Station12TypeName(station[is]) << "  "
+           << AliMp::PlaneTypeName(plane[ip])  << " ... " << endl;
+       
+      testNeighboursPadIterator(station[is], plane[ip]);
+    
+      cout << "... end running " << endl << endl;
+    }  
+  }   
+}  
+  

diff --git a/MUON/mapping/macros/testPadDimensions.C b/MUON/mapping/macros/testPadDimensions.C
index a4fc70e81d8c9d8f31d607d7987b2c16d04a44ab..0fe05dd60902f10b29ced6cbedee49c74a1c5c45 100644 (file)
--- a/MUON/mapping/macros/testPadDimensions.C
+++ b/MUON/mapping/macros/testPadDimensions.C
@@ -4,23 +4,29 @@
 // Test macro for testing retrieving of pad dimensions from
 // the map in AliMpSectorSegmentation.
 
-void testPadDimensions(AliMp::StationType station = AliMp::kStation1,
-                       AliMp::PlaneType plane = AliMp::kBendingPlane,
-                      Bool_t rootInput = false)
+#if !defined(__CINT__) || defined(__MAKECINT__)
+
+#include "AliMpStation12Type.h"
+#include "AliMpPlaneType.h"
+#include "AliMpDataProcessor.h"
+#include "AliMpDataMap.h"
+#include "AliMpDataStreams.h"
+#include "AliMpSector.h"
+#include "AliMpSectorSegmentation.h"
+#include "AliMpSectorReader.h"
+
+#include <Riostream.h>
+
+#endif
+
+void testPadDimensions(AliMq::Station12Type station, AliMp::PlaneType plane)
 {
-  AliMpSector *sector = 0;
-  if (!rootInput) {
-    AliMpSectorReader r(station, plane);
-    sector=r.BuildSector();
-  }
-  else  {
-    TString filePath = AliMpFiles::SectorFilePath(station,plane);
-    filePath.ReplaceAll("zones.dat", "sector.root"); 
-
-    TFile f(filePath.Data(), "READ");
-    sector = (AliMpSector*)f.Get("Sector");
-  }  
+  AliMpDataProcessor mp;
+  AliMpDataMap* dataMap = mp.CreateDataMap("data");
+  AliMpDataStreams dataStreams(dataMap);
 
+  AliMpSectorReader r(dataStreams, station, plane);
+  AliMpSector* sector = r.BuildSector();
   AliMpSectorSegmentation segmentation(sector);  
   segmentation.PrintZones(); 
   
@@ -48,3 +54,23 @@ void testPadDimensions(AliMp::StationType station = AliMp::kStation1,
      }
    }
 }
+
+void testPadDimensions()
+{
+  AliMq::Station12Type  station[2] = { AliMq::kStation1, AliMq::kStation2 }; 
+  AliMp::PlaneType      plane[2]   = { AliMp::kBendingPlane, AliMp::kNonBendingPlane };
+  
+  for ( Int_t is = 0; is < 2; is++ ) {
+    for ( Int_t ip = 0; ip < 2; ip++ ) {
+    
+      cout << "Running testPadDimensions for " 
+           << AliMq::Station12TypeName(station[is]) << "  "
+           << AliMp::PlaneTypeName(plane[ip])  << " ... " << endl;
+       
+      testPadDimensions(station[is], plane[ip]);
+    
+      cout << "... end running " << endl << endl;
+    }  
+  }   
+}  
+  

diff --git a/MUON/mapping/macros/testPadsUpEtc.C b/MUON/mapping/macros/testPadsUpEtc.C
index 1401ad485783f9a94baad9025adf887700560359..0625e9b761121468d6587e2d7802e072768d5e03 100644 (file)
--- a/MUON/mapping/macros/testPadsUpEtc.C
+++ b/MUON/mapping/macros/testPadsUpEtc.C
@@ -5,23 +5,29 @@
 // all pads up, down, right, left from this pad
 // (up to the plane border).
 
-void testPadsUpEtc(AliMp::StationType station = AliMp::kStation1,
-                   AliMp::PlaneType  plane = AliMp::kBendingPlane,
-                  Bool_t rootInput = false)
+#if !defined(__CINT__) || defined(__MAKECINT__)
+
+#include "AliMpStation12Type.h"
+#include "AliMpPlaneType.h"
+#include "AliMpDataProcessor.h"
+#include "AliMpDataMap.h"
+#include "AliMpDataStreams.h"
+#include "AliMpSector.h"
+#include "AliMpSectorSegmentation.h"
+#include "AliMpSectorReader.h"
+
+#include <Riostream.h>
+
+#endif
+
+void testPadsUpEtc(AliMq::Station12Type station, AliMp::PlaneType  plane)
 {
-  AliMpSector *sector = 0;
-  if (!rootInput) {
-    AliMpSectorReader r(station, plane);
-    sector=r.BuildSector();
-  }
-  else  {
-    TString filePath = AliMpFiles::SectorFilePath(station,plane);
-    filePath.ReplaceAll("zones.dat", "sector.root"); 
+  AliMpDataProcessor mp;
+  AliMpDataMap* dataMap = mp.CreateDataMap("data");
+  AliMpDataStreams dataStreams(dataMap);
 
-    TFile f(filePath.Data(), "READ");
-    sector = (AliMpSector*)f.Get("Sector");
-  }  
-    
+  AliMpSectorReader r(dataStreams, station, plane);
+  AliMpSector* sector = r.BuildSector();
   AliMpSectorSegmentation segmentation(sector);
   
   AliMpIntPair indices(85, 101);
@@ -70,3 +76,23 @@ void testPadsUpEtc(AliMp::StationType station = AliMp::kStation1,
     }
   }  
 }
+
+void testPadsUpEtc()
+{
+  AliMq::Station12Type  station[2] = { AliMq::kStation1, AliMq::kStation2 }; 
+  AliMp::PlaneType      plane[2]   = { AliMp::kBendingPlane, AliMp::kNonBendingPlane };
+  
+  for ( Int_t is = 0; is < 2; is++ ) {
+    for ( Int_t ip = 0; ip < 2; ip++ ) {
+    
+      cout << "Running testPadsUpEtc for " 
+           << AliMq::Station12TypeName(station[is]) << "  "
+           << AliMp::PlaneTypeName(plane[ip])  << " ... " << endl;
+       
+      testPadsUpEtc(station[is], plane[ip]);
+    
+      cout << "... end running " << endl << endl;
+    }  
+  }   
+}  
+  

diff --git a/MUON/mapping/macros/testPrintLimits.C b/MUON/mapping/macros/testPrintLimits.C
index d239530151d9ad8afcba143a2f366987902ed5b1..7a86262078573c66cb2bf820107de00a64ce0925 100644 (file)
--- a/MUON/mapping/macros/testPrintLimits.C
+++ b/MUON/mapping/macros/testPrintLimits.C
@@ -4,23 +4,37 @@
 // Test macro for making an output file, where all mapping elements
 // indices & positions are written.
 
-void testPrintLimits(AliMp::StationType station = AliMp::kStation1,
-                     AliMp::PlaneType plane = AliMp::kBendingPlane, 
-                    Bool_t rootInput = false,
+#if !defined(__CINT__) || defined(__MAKECINT__)
+
+#include "AliMpStation12Type.h"
+#include "AliMpPlaneType.h"
+#include "AliMpDataProcessor.h"
+#include "AliMpDataMap.h"
+#include "AliMpDataStreams.h"
+#include "AliMpSector.h"
+#include "AliMpSectorReader.h"
+#include "AliMpRow.h"
+#include "AliMpVRowSegment.h"
+#include "AliMpMotifMap.h"
+#include "AliMpMotifPosition.h"
+#include "AliMpVPainter.h"
+
+#include <Riostream.h>
+#include <TCanvas.h>
+
+#endif
+
+void testPrintLimits(AliMq::Station12Type station, AliMp::PlaneType  plane,
                     ostream& out=cout)
 {
-  AliMpSector *sector = 0;
-  if (!rootInput) {
-    AliMpSectorReader r(station, plane);
-    sector=r.BuildSector();
-  }
-  else  {
-    TString filePath = AliMpFiles::SectorFilePath(station,plane);
-    filePath.ReplaceAll("zones.dat", "sector.root"); 
+  AliMpDataProcessor mp;
+  AliMpDataMap* dataMap = mp.CreateDataMap("data");
+  AliMpDataStreams dataStreams(dataMap);
 
-    TFile f(filePath.Data(), "READ");
-    sector = (AliMpSector*)f.Get("Sector");
-  }  
+  AliMpSectorReader r(dataStreams, station, plane);
+  AliMpSector* sector = r.BuildSector();
+  
+  new TCanvas();
 
   AliMpVPainter* painter = AliMpVPainter::CreatePainter(sector);
   painter->Draw("ZSSMP");
@@ -81,3 +95,23 @@ void testPrintLimits(AliMp::StationType station = AliMp::kStation1,
     }
   }
 }
+
+void testPrintLimits()
+{
+  AliMq::Station12Type  station[2] = { AliMq::kStation1, AliMq::kStation2 }; 
+  AliMp::PlaneType      plane[2]   = { AliMp::kBendingPlane, AliMp::kNonBendingPlane };
+  
+  for ( Int_t is = 0; is < 2; is++ ) {
+    for ( Int_t ip = 0; ip < 2; ip++ ) {
+    
+      cout << "Running testPrintLimits for " 
+           << AliMq::Station12TypeName(station[is]) << "  "
+           << AliMp::PlaneTypeName(plane[ip])  << " ... " << endl;
+       
+      testPrintLimits(station[is], plane[ip]);
+    
+      cout << "... end running " << endl << endl;
+    }  
+  }   
+}  
+  

diff --git a/MUON/mapping/macros/testReadMotifType.C b/MUON/mapping/macros/testReadMotifType.C
index 4c01df5c04ae71b8fc28ab31e091043da7a75c30..9b824b128132c7618ad4fc26405dde973e16faae 100644 (file)
--- a/MUON/mapping/macros/testReadMotifType.C
+++ b/MUON/mapping/macros/testReadMotifType.C
@@ -3,22 +3,45 @@
 //
 // Test macro for reading motif type data.
 
-void testReadMotifType(AliMp::StationType station = AliMp::kStation1,
-                       AliMp::PlaneType plane = AliMp::kBendingPlane,
-                      Bool_t rootInput = false)
+#if !defined(__CINT__) || defined(__MAKECINT__)
+
+#include "AliMpStation12Type.h"
+#include "AliMpPlaneType.h"
+#include "AliMpDataProcessor.h"
+#include "AliMpDataMap.h"
+#include "AliMpDataStreams.h"
+#include "AliMpMotifReader.h"
+#include "AliMpVMotif.h"
+#include "AliMpMotifType.h"
+#include "AliMpMotifMap.h"
+#include "AliMpConstants.h"
+
+#include <Riostream.h>
+#include <TCanvas.h>
+#include <TH2.h>
+
+#endif
+
+
+void testReadMotifType(AliMq::Station12Type station, AliMp::PlaneType plane)
 {
-  AliMpMotifReader r(station, plane);
+  AliMpDataProcessor mp;
+  AliMpDataMap* dataMap = mp.CreateDataMap("data");
+  AliMpDataStreams dataStreams(dataMap);
+
+  AliMpMotifReader r(dataStreams, AliMp::kStation12, station, plane);
   //r.SetVerboseLevel(2);
 
   TString names;
   TString names2;
   Int_t nv =0;
-  if ( station == AliMp::kStation1 )
+  if ( station == AliMq::kStation1 ) {
     if ( plane == AliMp::kBendingPlane ) 
       names ="ABCDEFGHI";
     else
       names = "ABCDEFGHIJKLMN";
-  else if ( station == AliMp::kStation2 ) 
+  }    
+  else if ( station == AliMq::kStation2 ) {
     if ( plane == AliMp::kBendingPlane ) {
       names ="ABCDEFGHIJKLMNOPQRSTUVWXY";
       names2 ="abcdefghimnptuv";
@@ -29,6 +52,7 @@ void testReadMotifType(AliMp::StationType station = AliMp::kStation1,
       names2 ="abcdefgijklmnopqrstuwv";
       nv = 5;
     }  
+  }  
     
   for (Int_t i=0;i<names.Length();++i){
      r.BuildMotifType(names[i])->Print("G");
@@ -49,3 +73,23 @@ void testReadMotifType(AliMp::StationType station = AliMp::kStation1,
       r.BuildMotifType(mtName)->Print("G");
   }
 }
+
+void testReadMotifType()
+{
+  AliMq::Station12Type  station[2] = { AliMq::kStation1, AliMq::kStation2 }; 
+  AliMp::PlaneType      plane[2]   = { AliMp::kBendingPlane, AliMp::kNonBendingPlane };
+  
+  for ( Int_t is = 0; is < 2; is++ ) {
+    for ( Int_t ip = 0; ip < 2; ip++ ) {
+    
+      cout << "Running testReadMotifType for " 
+           << AliMq::Station12TypeName(station[is]) << "  "
+           << AliMp::PlaneTypeName(plane[ip])  << " ... " << endl;
+       
+      testReadMotifType(station[is], plane[ip]);
+    
+      cout << "... end running " << endl << endl;
+    }  
+  }   
+}  
+  

diff --git a/MUON/mapping/macros/testReadMotifTypeSlat.C b/MUON/mapping/macros/testReadMotifTypeSlat.C
index f436e935c5f4f42eb30b3ebdabfec137890e00ae..e01584899570acbbf8706e7dcee668b013938aee 100644 (file)
--- a/MUON/mapping/macros/testReadMotifTypeSlat.C
+++ b/MUON/mapping/macros/testReadMotifTypeSlat.C
@@ -2,9 +2,17 @@
 // $MpId: testReadMotifTypeSlat.C,v 1.1 2005/09/19 19:02:53 ivana Exp $
 
 #if !defined(__CINT__) || defined(__MAKECINT__)
+
+#include "AliMpStation12Type.h"
+#include "AliMpPlaneType.h"
+#include "AliMpDataProcessor.h"
+#include "AliMpDataMap.h"
+#include "AliMpDataStreams.h"
 #include "AliMpMotifReader.h"
-#include "Riostream.h"
 #include "AliMpMotifType.h"
+
+#include <Riostream.h>
+
 #endif
 
 Int_t test(AliMpMotifReader& r, const char letter, Int_t from, Int_t to)
@@ -30,7 +38,11 @@ Int_t test(AliMpMotifReader& r, const char letter, Int_t from, Int_t to)
 
 void testReadMotifTypeSlat()
 {
-  AliMpMotifReader r(AliMp::kStation345,AliMp::kNonBendingPlane); 
+  AliMpDataProcessor mp;
+  AliMpDataMap* dataMap = mp.CreateDataMap("data");
+  AliMpDataStreams dataStreams(dataMap);
+
+  AliMpMotifReader r(dataStreams, AliMp::kStation345, AliMq::kNotSt12, AliMp::kNonBendingPlane);
   // note that second parameter is not used for station345.
 
   Int_t n = 0;

diff --git a/MUON/mapping/macros/testReadPCB.C b/MUON/mapping/macros/testReadPCB.C
index 789f5d052bb6e8df23df4b196e066edb5e11da79..2ab7e0c4923c6cbf819961a5bdb4d00dacb835e7 100644 (file)
--- a/MUON/mapping/macros/testReadPCB.C
+++ b/MUON/mapping/macros/testReadPCB.C
@@ -2,14 +2,30 @@
 // $MpId: testReadPCB.C,v 1.1 2005/09/19 19:02:53 ivana Exp $
 
 #if !defined(__CINT__) || defined(__MAKECINT__)
+
+#include "AliMpStation12Type.h"
+#include "AliMpPlaneType.h"
+#include "AliMpDataProcessor.h"
+#include "AliMpDataMap.h"
+#include "AliMpDataStreams.h"
+#include "AliMpSlatMotifMap.h"
 #include "AliMpSt345Reader.h"
 #include "AliMpPCB.h"
 #include "AliMpMotifPosition.h"
-#include "Riostream.h"
+
+#include <Riostream.h>
+
 #endif
 
 void testReadPCB()
 {
+  AliMpDataProcessor mp;
+  AliMpDataMap* dataMap = mp.CreateDataMap("data");
+  AliMpDataStreams dataStreams(dataMap);
+
+  AliMpSlatMotifMap* motifMap = new AliMpSlatMotifMap();
+  AliMpSt345Reader r(dataStreams, motifMap);
+
   const char* pcbToTest[] = { "B1", "B2", "B3+", "B3-", "N1", "N2+", "N2-", 
   "N3", "R1B", "R1N", "R2B", "R2N", "R3B", "R3N", "S2B", "S2N" };
   
@@ -17,7 +33,7 @@ void testReadPCB()
   
   for ( Int_t i = 0; i < N; ++i )
   {
-    AliMpPCB* pcb = AliMpSt345Reader::ReadPCB(pcbToTest[i]);
+    AliMpPCB* pcb = r.ReadPCB(pcbToTest[i]);
     if (pcb)
     {
       pcb->Print();

diff --git a/MUON/mapping/macros/testReadSector.C b/MUON/mapping/macros/testReadSector.C
index 3fb31b5e7e29ad71d71c1458322ef1962c4edd60..e07909a3c5beddb2c0fb0ce64186d21d87aab1e8 100644 (file)
--- a/MUON/mapping/macros/testReadSector.C
+++ b/MUON/mapping/macros/testReadSector.C
@@ -3,36 +3,35 @@
 //
 // Test macro for reading sector data.
 
-#include <iomanip>
+#if !defined(__CINT__) || defined(__MAKECINT__)
 
-void testReadSector(AliMp::StationType station = AliMp::kStation1,
-                    AliMp::PlaneType plane = AliMp::kBendingPlane, 
-                   Bool_t rootInput = false)
-{
-  AliMpSector *sector = 0;
-  if (!rootInput) {
-    AliMpSectorReader r(station, plane);
-    //reader.SetVerboseLevel(1);
-    sector=r.BuildSector();
+#include "AliMpStation12Type.h"
+#include "AliMpPlaneType.h"
+#include "AliMpDataProcessor.h"
+#include "AliMpDataMap.h"
+#include "AliMpDataStreams.h"
+#include "AliMpSector.h"
+#include "AliMpSectorReader.h"
+#include "AliMpRow.h"
+#include "AliMpVRowSegment.h"
+#include "AliMpVMotif.h"
+#include "AliMpMotifMap.h"
+#include "AliMpConstants.h"
 
-    // Write sector on Root file
-    TString filePath = AliMpFiles::SectorFilePath(station,plane);
-    filePath.ReplaceAll("zones.dat", "sector.root"); 
-  
-    TFile f(filePath.Data(), "RECREATE");
-    sector->Write();
-    f.Close();
-  }
-  else  {
-    TString filePath = AliMpFiles::SectorFilePath(station,plane);
-    filePath.ReplaceAll("zones.dat", "sector.root"); 
+#include <Riostream.h>
+#include <TCanvas.h>
+#include <TH2.h>
 
-    TFile f(filePath.Data(), "READ");
-    sector = (AliMpSector*)f.Get("Sector");
-  }  
+#endif
 
-  cout << endl;
+void testReadSector(AliMq::Station12Type station, AliMp::PlaneType plane)
+{
+  AliMpDataProcessor mp;
+  AliMpDataMap* dataMap = mp.CreateDataMap("data");
+  AliMpDataStreams dataStreams(dataMap);
 
+  AliMpSectorReader r(dataStreams, station, plane);
+  AliMpSector* sector = r.BuildSector();
   // Sector geometry
   sector->PrintGeometry();
 
@@ -75,7 +74,7 @@ void testReadSector(AliMp::StationType station = AliMp::kStation1,
   for (Int_t i=0; i<2 ; i++) {
     TVector2 pos(0.5, 18.6 - i*2.);  // i=0 in motif 1001,
                                      // i=1 outside (below) motif 1001
-    AliMpMotif* motif = sector->FindMotif(pos);
+    AliMpVMotif* motif = sector->FindMotif(pos);
     cout << "In the position " << pos.X() << " " << pos.Y();
     
     if (motif)
@@ -111,6 +110,24 @@ void testReadSector(AliMp::StationType station = AliMp::kStation1,
   
   delete sector;
 }                             
-      
-
+     
+void testReadSector()
+{
+  AliMq::Station12Type  station[2] = { AliMq::kStation1, AliMq::kStation2 }; 
+  AliMp::PlaneType      plane[2]   = { AliMp::kBendingPlane, AliMp::kNonBendingPlane };
+  
+  for ( Int_t is = 0; is < 2; is++ ) {
+    for ( Int_t ip = 0; ip < 2; ip++ ) {
+    
+      cout << "Running testReadSector for " 
+           << AliMq::Station12TypeName(station[is]) << "  "
+           << AliMp::PlaneTypeName(plane[ip])  << " ... " << endl;
+       
+      testReadSector(station[is], plane[ip]);
+    
+      cout << "... end running " << endl << endl;
+    }  
+  }   
+}  
+  
  

diff --git a/MUON/mapping/macros/testReadSlat.C b/MUON/mapping/macros/testReadSlat.C
index dc3056360bc2b517f7f36cddc014a66565768c43..0f33a3ba138373b7873b84a704ce0232f5f74e31 100644 (file)
--- a/MUON/mapping/macros/testReadSlat.C
+++ b/MUON/mapping/macros/testReadSlat.C
@@ -2,15 +2,32 @@
 // $MpId: testReadSlat.C,v 1.4 2005/09/19 19:02:53 ivana Exp $
 
 #if !defined(__CINT__) || defined(__MAKECINT__)
-#include "Riostream.h"
+
+#include "AliMpStation12Type.h"
+#include "AliMpPlaneType.h"
+#include "AliMpDataProcessor.h"
+#include "AliMpDataMap.h"
+#include "AliMpDataStreams.h"
+#include "AliMpSlatMotifMap.h"
+#include "AliMpSt345Reader.h"
 #include "AliMpSlat.h"
 #include "AliMpSt345Reader.h"
-#include "TObjArray.h"
-#include "TObjString.h"
+
+#include <Riostream.h>
+#include <TObjArray.h>
+#include <TObjString.h>
+
 #endif
 
 void testReadSlat()
 {
+  AliMpDataProcessor mp;
+  AliMpDataMap* dataMap = mp.CreateDataMap("data");
+  AliMpDataStreams dataStreams(dataMap);
+
+  AliMpSlatMotifMap* motifMap = new AliMpSlatMotifMap();
+  AliMpSt345Reader r(dataStreams, motifMap);
+
   ifstream in("slats.list");
   char line[80];
   TObjArray slatsToTest;
@@ -27,8 +44,8 @@ void testReadSlat()
     TString slat( ((TObjString*)slatsToTest[i])->String());
     
     cout << "Trying to read " << slat << endl;
-    AliMpSlat* b = AliMpSt345Reader::ReadSlat(slat.Data(),AliMp::kBendingPlane);
-    AliMpSlat* nb = AliMpSt345Reader::ReadSlat(slat.Data(),AliMp::kNonBendingPlane);
+    AliMpSlat* b = r.ReadSlat(slat.Data(),AliMp::kBendingPlane);
+    AliMpSlat* nb = r.ReadSlat(slat.Data(),AliMp::kNonBendingPlane);
     if ( !b ) cout << " Missing BENDING !" << endl;
     if ( !nb ) cout << " Missing NONBENDING !" << endl;
     if ( b && nb )

diff --git a/MUON/mapping/macros/testSectorAreaIterator.C b/MUON/mapping/macros/testSectorAreaIterator.C
index e3a7430a2be2a4a1226e929d8892ae2753cdf308..aa7bad42adf4559e3ab0f1119bba17cd35a965d5 100644 (file)
--- a/MUON/mapping/macros/testSectorAreaIterator.C
+++ b/MUON/mapping/macros/testSectorAreaIterator.C
@@ -3,7 +3,27 @@
 //
 // Test macro for iterating over the whole sector
 
-#include <iomanip>
+#if !defined(__CINT__) || defined(__MAKECINT__)
+
+#include "AliMpStation12Type.h"
+#include "AliMpPlaneType.h"
+#include "AliMpDataProcessor.h"
+#include "AliMpDataMap.h"
+#include "AliMpDataStreams.h"
+#include "AliMpSector.h"
+#include "AliMpSectorSegmentation.h"
+#include "AliMpSectorReader.h"
+#include "AliMpArea.h"
+#include "AliMpVPadIterator.h"
+#include "AliMpVPainter.h"
+
+#include <Riostream.h>
+#include <TCanvas.h>
+#include <TMarker.h>
+#include <TH2.h>
+#include <TStopwatch.h>
+
+#endif
 
 class AliMpVPadIterator;
 
@@ -47,37 +67,48 @@ void MarkPads(AliMpVPadIterator& it, Double_t xmax, Double_t ymax,
   //timer.Print();
 }
 
-void testSectorAreaIterator(AliMp::StationType station = AliMp::kStation1,
-                            AliMp::PlaneType plane = AliMp::kBendingPlane,
-                           Bool_t rootInput = false)
+void testSectorAreaIterator(AliMq::Station12Type station, AliMp::PlaneType plane)
 {
-  AliMpSector *sector = 0;
-  if (!rootInput) {
-    AliMpSectorReader r(station, plane);
-    sector=r.BuildSector();
-  }
-  else  {
-    TString filePath = AliMpFiles::SectorFilePath(station,plane);
-    filePath.ReplaceAll("zones.dat", "sector.root"); 
-
-    TFile f(filePath.Data(), "READ");
-    sector = (AliMpSector*)f.Get("Sector");
-  }  
+  AliMpDataProcessor mp;
+  AliMpDataMap* dataMap = mp.CreateDataMap("data");
+  AliMpDataStreams dataStreams(dataMap);
 
+  AliMpSectorReader r(dataStreams, station, plane);
+  AliMpSector* sector = r.BuildSector();
   AliMpSectorSegmentation segmentation(sector);
 
   AliMpArea area;
-  if ( station == AliMp::kStation1 )
+  if ( station == AliMq::kStation1 )
     area = AliMpArea(TVector2(45.,45.),TVector2(45.,45.));
   else   
     area = AliMpArea(TVector2(60.,60.),TVector2(60.,60.));
   AliMpVPadIterator* iter = segmentation.CreateIterator(area);
 
-  TCanvas* graph = new TCanvas("Graph");
+  new TCanvas("Graph");
   AliMpVPainter::CreatePainter(sector)->Draw("ZSSMP");
 
-  TCanvas *canv = new TCanvas("canv");
+  TCanvas* canv = new TCanvas("canv");
   canv->Range(-1,-1,1,1);
   MarkPads(*iter, TMath::Abs(area.Position().X())+area.Dimensions().X(),
                   TMath::Abs(area.Position().Y())+area.Dimensions().Y(), kTRUE);
 }
+     
+void testSectorAreaIterator()
+{
+  AliMq::Station12Type  station[2] = { AliMq::kStation1, AliMq::kStation2 }; 
+  AliMp::PlaneType      plane[2]   = { AliMp::kBendingPlane, AliMp::kNonBendingPlane };
+  
+  for ( Int_t is = 0; is < 2; is++ ) {
+    for ( Int_t ip = 0; ip < 2; ip++ ) {
+    
+      cout << "Running testSectorAreaIterator for " 
+           << AliMq::Station12TypeName(station[is]) << "  "
+           << AliMp::PlaneTypeName(plane[ip])  << " ... " << endl;
+       
+      testSectorAreaIterator(station[is], plane[ip]);
+    
+      cout << "... end running " << endl << endl;
+    }  
+  }   
+}  
+  

diff --git a/MUON/mapping/macros/testSectorFind.C b/MUON/mapping/macros/testSectorFind.C
index d03ac2c1a59a8a68a653db9a9327371f8561e4f6..df663caedd59ea6ded2a531d0b9889cc166f3615 100644 (file)
--- a/MUON/mapping/macros/testSectorFind.C
+++ b/MUON/mapping/macros/testSectorFind.C
@@ -4,24 +4,36 @@
 // Test macro for which verify that all FindPosition, FindIndices
 // and FindLocation methods are consistents between them.
 
-void testSectorFind(AliMp::StationType station = AliMp::kStation1,
-                    AliMp::PlaneType plane = AliMp::kBendingPlane,
-                   Bool_t rootInput = false) 
-{
-  AliMpSector *sector = 0;
-  if (!rootInput) {
-    AliMpSectorReader r(station, plane);
-    sector=r.BuildSector();
-  }
-  else  {
-    TString filePath = AliMpFiles::SectorFilePath(station,plane);
-    filePath.ReplaceAll("zones.dat", "sector.root"); 
+#if !defined(__CINT__) || defined(__MAKECINT__)
+
+#include "AliMpStation12Type.h"
+#include "AliMpPlaneType.h"
+#include "AliMpDataProcessor.h"
+#include "AliMpDataMap.h"
+#include "AliMpDataStreams.h"
+#include "AliMpSector.h"
+#include "AliMpSectorSegmentation.h"
+#include "AliMpSectorReader.h"
+#include "AliMpArea.h"
+#include "AliMpVPadIterator.h"
+#include "AliMpVPainter.h"
+
+#include <Riostream.h>
+#include <TCanvas.h>
 
-    TFile f(filePath.Data(), "READ");
-    sector = (AliMpSector*)f.Get("Sector");
-  }  
+#endif
 
+void testSectorFind(AliMq::Station12Type station, AliMp::PlaneType plane) 
+{
+  AliMpDataProcessor mp;
+  AliMpDataMap* dataMap = mp.CreateDataMap("data");
+  AliMpDataStreams dataStreams(dataMap);
+
+  AliMpSectorReader r(dataStreams, station, plane);
+  AliMpSector* sector = r.BuildSector();
   AliMpSectorSegmentation segmentation(sector);
+  
+  new TCanvas();
   AliMpVPainter* painter = AliMpVPainter::CreatePainter(sector);
   painter->Draw("ZSSMP");
 
@@ -32,3 +44,23 @@ void testSectorFind(AliMp::StationType station = AliMp::kStation1,
       segmentation.CircleTest(AliMpIntPair(i,j));    
   }
 }
+
+void testSectorFind()
+{
+  AliMq::Station12Type  station[2] = { AliMq::kStation1, AliMq::kStation2 }; 
+  AliMp::PlaneType      plane[2]   = { AliMp::kBendingPlane, AliMp::kNonBendingPlane };
+  
+  for ( Int_t is = 0; is < 2; is++ ) {
+    for ( Int_t ip = 0; ip < 2; ip++ ) {
+    
+      cout << "Running testSectorFind for " 
+           << AliMq::Station12TypeName(station[is]) << "  "
+           << AliMp::PlaneTypeName(plane[ip])  << " ... " << endl;
+       
+      testSectorFind(station[is], plane[ip]);
+    
+      cout << "... end running " << endl << endl;
+    }  
+  }   
+}  
+  

diff --git a/MUON/mapping/macros/testSectorPadIterators.C b/MUON/mapping/macros/testSectorPadIterators.C
index affa16542783d462fbaed771a40af3563f69984c..bf616ae8daa45a6af9a873fc9e31eab9a59a651a 100644 (file)
--- a/MUON/mapping/macros/testSectorPadIterators.C
+++ b/MUON/mapping/macros/testSectorPadIterators.C
@@ -3,26 +3,39 @@
 //
 // Test macro for reading  sector, and iterate over it
 
-void testSectorPadIterators(AliMp::StationType station = AliMp::kStation1,
-                            AliMp::PlaneType plane = AliMp::kBendingPlane,
-                           Bool_t rootInput = false)
+#if !defined(__CINT__) || defined(__MAKECINT__)
+
+#include "AliMpStation12Type.h"
+#include "AliMpPlaneType.h"
+#include "AliMpDataProcessor.h"
+#include "AliMpDataMap.h"
+#include "AliMpDataStreams.h"
+#include "AliMpSector.h"
+#include "AliMpSectorPadIterator.h"
+#include "AliMpSectorReader.h"
+#include "AliMpArea.h"
+#include "AliMpVPadIterator.h"
+#include "AliMpVPainter.h"
+
+#include <Riostream.h>
+#include <TCanvas.h>
+#include <TMarker.h>
+
+#endif
+
+void testSectorPadIterators(AliMq::Station12Type station, AliMp::PlaneType plane)
 {
-  AliMpSector *sector = 0;
-  if (!rootInput) {
-    AliMpSectorReader r(station, plane);
-    sector=r.BuildSector();
-  }
-  else  {
-    TString filePath = AliMpFiles::SectorFilePath(station,plane);
-    filePath.ReplaceAll("zones.dat", "sector.root"); 
+  AliMpDataProcessor mp;
+  AliMpDataMap* dataMap = mp.CreateDataMap("data");
+  AliMpDataStreams dataStreams(dataMap);
 
-    TFile f(filePath.Data(), "READ");
-    sector = (AliMpSector*)f.Get("Sector");
-  }  
+  AliMpSectorReader r(dataStreams, station, plane);
+  AliMpSector* sector = r.BuildSector();
   
   Int_t num=0;
   
-  TCanvas *can = new TCanvas("canv");
+  //new TCanvas("canv");
+  new TCanvas();
 
   const Double_t xmax=150;
   const Double_t ymax=250;
@@ -41,3 +54,23 @@ void testSectorPadIterators(AliMp::StationType station = AliMp::kStation1,
   
   delete sector;
 }
+
+void testSectorPadIterators()
+{
+  AliMq::Station12Type  station[2] = { AliMq::kStation1, AliMq::kStation2 }; 
+  AliMp::PlaneType      plane[2]   = { AliMp::kBendingPlane, AliMp::kNonBendingPlane };
+  
+  for ( Int_t is = 0; is < 2; is++ ) {
+    for ( Int_t ip = 0; ip < 2; ip++ ) {
+    
+      cout << "Running testSectorPadIterators for " 
+           << AliMq::Station12TypeName(station[is]) << "  "
+           << AliMp::PlaneTypeName(plane[ip])  << " ... " << endl;
+       
+      testSectorPadIterators(station[is], plane[ip]);
+    
+      cout << "... end running " << endl << endl;
+    }  
+  }   
+}  
+  

diff --git a/MUON/mapping/macros/testSegmentation.C b/MUON/mapping/macros/testSegmentation.C
index 12dbb878837149ca0365b5d1a15e33d0c8e93d63..fe797690b8a207113bafc3b2d2db8f681bbed158 100644 (file)
--- a/MUON/mapping/macros/testSegmentation.C
+++ b/MUON/mapping/macros/testSegmentation.C
@@ -1,6 +1,8 @@
 // $Id$
 // $MpId: testSegmentation.C,v 1.1 2005/09/19 19:02:53 ivana Exp $
 
+// Obsolete ??
+
 #include "AliRun.h"
 #include "AliMUON.h"
 #include "AliMUONChamber.h"

diff --git a/MUON/mapping/macros/testSlatPads.C b/MUON/mapping/macros/testSlatPads.C
index a0fe9f5262c914fc2fce3af1bec710fe9cfb3e1b..e8bfb4186ff34af0e9b760b0878b6d4f102ff62c 100644 (file)
--- a/MUON/mapping/macros/testSlatPads.C
+++ b/MUON/mapping/macros/testSlatPads.C
@@ -18,23 +18,28 @@
 ///         the list of slats' name to be tested, e.g. 112233NR3, etc...
 
 #if !defined(__CINT__) || defined(__MAKECINT__)
+
+#include "AliMpStation12Type.h"
+#include "AliMpPlaneType.h"
+#include "AliMpDataProcessor.h"
+#include "AliMpDataMap.h"
+#include "AliMpDataStreams.h"
+#include "AliMpSlatMotifMap.h"
 #include "AliMpSlat.h"
 #include "AliMpSlatSegmentation.h"
 #include "AliMpPad.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"
+
+#include <TObjArray.h>
+#include <TObjString.h>
+#include <TList.h>
+#include <TString.h>
+#include <TStopwatch.h>
+#include <Riostream.h>
+
 #endif
 
 //______________________________________________________________________________
@@ -217,8 +222,12 @@ void testSlatPads(const char* slatlist)
   
   in.close();
   
-  AliMpSlatMotifMap mm;
-  AliMpSt345Reader reader(mm);
+  AliMpDataProcessor mp;
+  AliMpDataMap* dataMap = mp.CreateDataMap("data");
+  AliMpDataStreams dataStreams(dataMap);
+
+  AliMpSlatMotifMap* motifMap = new AliMpSlatMotifMap();
+  AliMpSt345Reader reader(dataStreams, motifMap);
   
   for ( Int_t i = 0; i < slatsToTest.GetEntriesFast(); ++i )
   {

diff --git a/MUON/mapping/macros/testUpdateGlobalIndices.C b/MUON/mapping/macros/testUpdateGlobalIndices.C
index 32a85e0c0a72c95992a5931b37b8fa72ef6c2f01..427cdfccaa1784011eb0a92bae0344a3e3bc8be6 100644 (file)
--- a/MUON/mapping/macros/testUpdateGlobalIndices.C
+++ b/MUON/mapping/macros/testUpdateGlobalIndices.C
@@ -3,13 +3,31 @@
 //
 // Tests updating global indices of motif positions from file.
 
+#if !defined(__CINT__) || defined(__MAKECINT__)
+
+#include "AliMpStation12Type.h"
+#include "AliMpPlaneType.h"
+#include "AliMpDataProcessor.h"
+#include "AliMpDataMap.h"
+#include "AliMpDataStreams.h"
+#include "AliMpSector.h"
+#include "AliMpSectorReader.h"
+#include "AliMpMotifMap.h"
+#include "AliMpVPainter.h"
+
+#include <Riostream.h>
+#include <TCanvas.h>
+
+#endif
+
 void testUpdateGlobalIndices()
 {
-  AliMpSectorReader reader(AliMp::kStation1, AliMp::kNonBendingPlane);  
-  //reader.SetVerboseLevel(1);
-  
-  // Read data 
-  AliMpSector* sector = reader.BuildSector();
+  AliMpDataProcessor mp;
+  AliMpDataMap* dataMap = mp.CreateDataMap("data");
+  AliMpDataStreams dataStreams(dataMap);
+
+  AliMpSectorReader r(dataStreams, AliMq::kStation1, AliMp::kNonBendingPlane);
+  AliMpSector* sector = r.BuildSector();
 
   sector->GetMotifMap()->UpdateGlobalIndices("motif_map.dat");  
   

diff --git a/MUON/mapping/macros/timeMapping.C b/MUON/mapping/macros/timeMapping.C
index a3f0ac2b017a08c855fa003021bc1e9596cc80f6..96a504c7672deec0ebad87624e83b6ccfaaf8a7e 100644 (file)
--- a/MUON/mapping/macros/timeMapping.C
+++ b/MUON/mapping/macros/timeMapping.C
@@ -73,10 +73,12 @@
 #include "AliMpDEIterator.h"
 #include "AliMpCathodType.h"
 #include "AliMpStationType.h"
-#include "TObjArray.h"
-#include "TVector2.h"
 #include "AliMpVPadIterator.h"
+
 #include "AliSysInfo.h"
+
+#include <TObjArray.h>
+#include <TVector2.h>
 #include <TTree.h>
 
 // The line below should be commented if you want to try this macro
@@ -260,4 +262,4 @@ void timeMapping(Int_t nloop=1)
   AliCodeTimer::Instance()->Print();
 }
 
-#endif
\ No newline at end of file
+#endif