MUON/AliMUONTest.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 // $Id$
  17 //
  18 // Class AliMUONTest
  19 // -----------------
  20 // Class with functions for testing
  21 //
  22 // Author: Ivana Hrivnacova, IPN Orsay
  23
  24 #include <TStopwatch.h>
  25 #include <Riostream.h>
  26 #include <TH2F.h>
  27 #include <TPave.h>
  28 #include <TCanvas.h>
  29
  30 #include "AliRun.h"
  31 #include "AliSegmentation.h"
  32 #include "AliLog.h"
  33
  34 #include "AliMUONTest.h"
  35 #include "AliMUON.h"
  36 #include "AliMUONConstants.h"
  37 #include "AliMUONGeometryModule.h"
  38 #include "AliMUONGeometryStore.h"
  39 #include "AliMUONGeometrySegmentation.h"
  40 #include "AliMUONSt12QuadrantSegmentation.h"
  41 #include "AliMUONSt345SlatSegmentation.h"
  42
  43 ClassImp(AliMUONTest)
  44
  45 //__________________________________________________________________
  46   AliMUONTest::AliMUONTest(const TString& configMacro)
  47   : TObject(),
  48     fCanvas(0)
  49 {
  50 // Standard Constructor
  51 //
  52   // Initialize AliRoot
  53   gAlice->Init(configMacro.Data());
  54 }
  55
  56 //__________________________________________________________________
  57 AliMUONTest::AliMUONTest()
  58   : TObject(),
  59     fCanvas(0)
  60 {
  61 // Default Constructor
  62 //
  63 }
  64
  65 //____________________________________________________________________
  66 AliMUONTest::AliMUONTest(const AliMUONTest& rhs)
  67  : TObject(rhs)
  68 {
  69 // Protected copy constructor
  70
  71   AliFatal("Not implemented.");
  72 }
  73
  74 //____________________________________________________________________
  75 AliMUONTest::~AliMUONTest()
  76 {
  77 // Destructor
  78
  79   delete fCanvas;
  80 }
  81
  82 //________________________________________________________________________
  83 AliMUONTest& AliMUONTest::operator = (const AliMUONTest& rhs)
  84 {
  85 // Protected assignement operator
  86
  87   if (this == &rhs) return *this;
  88
  89   AliFatal("Not implemented.");
  90
  91   return *this;
  92 }
  93
  94 //
  95 // private methods
  96 //
  97
  98 //________________________________________________________________________
  99 AliMUONGeometrySegmentation*
 100 AliMUONTest::CreateSt1Segmentation(Int_t chamberId, Int_t cathod)
 101 {
 102 // Create St1 geometry segmentation for given chamber and cathod
 103
 104   AliMUON* muon = (AliMUON*)gAlice->GetModule("MUON");
 105   if (!muon) {
 106     AliFatal("MUON detector not defined.");
 107     return 0;
 108   }
 109
 110   AliMUONGeometrySegmentation* segmentation
 111     = new AliMUONGeometrySegmentation(muon->Chamber(chamberId).GetGeometry());
 112
 113   // Quadrant segmentations:
 114   AliMUONSt12QuadrantSegmentation* bendSt1
 115     = new AliMUONSt12QuadrantSegmentation(kStation1, kBendingPlane);
 116   AliMUONSt12QuadrantSegmentation* nonbendSt1
 117     = new AliMUONSt12QuadrantSegmentation(kStation1, kNonBendingPlane);
 118
 119   // The same configuration for both chambers of Station 1
 120   Int_t id0 = (chamberId+1)*100;
 121
 122   // Configure  St1 chamber segmentations
 123   if (cathod == 0) {
 124     segmentation->Add(id0,      bendSt1);
 125     segmentation->Add(id0 +  1, nonbendSt1);
 126     segmentation->Add(id0 + 50, bendSt1);
 127     segmentation->Add(id0 + 51, nonbendSt1);
 128   }
 129   else if (cathod == 1) {
 130     segmentation->Add(id0,      nonbendSt1);
 131     segmentation->Add(id0 +  1, bendSt1);
 132     segmentation->Add(id0 + 50, nonbendSt1);
 133     segmentation->Add(id0 + 51, bendSt1);
 134   }
 135   else {
 136     AliError("Wrong cathod number");
 137     return 0;
 138   }
 139
 140   return segmentation;
 141 }
 142
 143 //_____________________________________________________________________________
 144 AliMUONGeometrySegmentation*
 145 AliMUONTest::CreateSlatSegmentation(Int_t chamberId, Int_t cathod)
 146 {
 147 // Create St1 geometry segmentation for given chamber and cathod
 148
 149   AliMUON* muon = (AliMUON*)gAlice->GetModule("MUON");
 150   if (!muon) {
 151     AliFatal("MUON detector not defined.");
 152     return 0;
 153   }
 154
 155   AliMUONGeometrySegmentation *chamberSeg = new AliMUONGeometrySegmentation(muon->Chamber(chamberId).GetGeometry());
 156
 157    //Slats Segmentations
 158   AliMUONSt345SlatSegmentation *slatsegB[14]; // Types of segmentation for St3 in this framework
 159   AliMUONSt345SlatSegmentation *slatsegNB[14]; // Types of segmentation for St3 in this framework
 160                                                // Bending
 161   Int_t ndiv[4] ={ 4, 4, 2, 1};  // densities zones
 162   for(Int_t i=0; i<14; i++) {
 163     slatsegB[i] = new AliMUONSt345SlatSegmentation(1);
 164     slatsegB[i]->SetPadSize(10.,0.5);
 165     slatsegB[i]->SetPadDivision(ndiv);
 166     slatsegB[i]->SetId(1);
 167     slatsegB[i]->SetDAnod(0.25);
 168     slatsegNB[i] = new AliMUONSt345SlatSegmentation(0);
 169     slatsegNB[i]->SetPadSize(1.,10.); // must be 0.713 !!!
 170     slatsegNB[i]->SetPadDivision(ndiv);
 171     slatsegNB[i]->SetId(1);
 172     slatsegNB[i]->SetDAnod(0.25);
 173   }
 174
 175
 176   //******************************************************************************************
 177   // Station 3
 178   //******************************************************************************************
 179
 180   if (chamberId == 4 || chamberId == 5) {
 181     // Type 112200 for 500, 501, 508, 509, 510, 517 in Ch5 (similar for Ch6) for the futur official numbering
 182     // Type 112200 for 503, 504, 505, 555, 554, 553 in Ch5 (similar for Ch6) actual numbering in the code to be changed in jan05
 183     Int_t n0[4] = { 0, 2, 2, 0 };
 184     slatsegB[0]->SetPcbBoards(n0);
 185     slatsegB[0]->Init(0);
 186     slatsegNB[0]->SetPcbBoards(n0);
 187     slatsegNB[0]->Init(0);
 188
 189     // Type 122200 for 502, 507, 511, 516 (similar in Ch6) for future official numbering of ALICE
 190     // Type 122200 for 502, 506, 556, 552 (similiarin Ch6) for actual numbering in muon code to be changed in jan05
 191     Int_t n1[4] = { 0, 1, 3, 0 };
 192     slatsegB[1]->SetPcbBoards(n1);
 193     slatsegB[1]->Init(0);
 194     slatsegNB[1]->SetPcbBoards(n1);
 195     slatsegNB[1]->Init(0);
 196
 197     // Type 222000 for 503, 506, 512, 515 (similar in Ch6) for future official numbering of ALICE
 198     // Type 222000 for 501, 507, 557, 551 (similiarin Ch6) for actual numbering in muon code to be changed in jan05
 199     Int_t n2[4] = { 0, 0, 3, 0 };
 200     slatsegB[2]->SetPcbBoards(n2);
 201     slatsegB[2]->Init(0);
 202     slatsegNB[2]->SetPcbBoards(n2);
 203     slatsegNB[2]->Init(0);
 204
 205     // Type 220000 for 504, 505, 513, 514 (similar in Ch6) for future official numbering of ALICE
 206     // Type 220000 for 500, 508, 558, 550 (similiarin Ch6) for actual numbering in muon code to be changed in jan05
 207     Int_t n3[4] = { 0, 0, 2, 0 };
 208     slatsegB[3]->SetPcbBoards(n3);
 209     slatsegB[3]->Init(0);
 210     slatsegNB[3]->SetPcbBoards(n3);
 211     slatsegNB[3]->Init(0);
 212   }
 213
 214
 215   //***************************************************************************************
 216   // Station 4 & 5
 217   //****************************************************************************************
 218
 219   if (chamberId >= 6 && chamberId <= 9) {
 220     // Type 122330 for 700, 713 in Ch7 (similar for Ch8) for the futur official numbering
 221     // Type 122330 for 706, 756 in Ch7 (similar for Ch8) actual numbering in the code to be changed in jan05
 222     // Type 122330 for 900, 913 in Ch9 (similar for Ch10) for the futur official numbering
 223     // Type 122330 for 906, 956 in Ch9 (similar for Ch10) actual numbering in the code to be changed in jan05
 224
 225     Int_t n4[4] = { 0, 1, 2, 2 };
 226     slatsegB[4]->SetPcbBoards(n4);
 227     slatsegB[4]->Init(0); // 0 detection element id
 228     slatsegNB[4]->SetPcbBoards(n4);
 229     slatsegNB[4]->Init(0); // 0 detection element id
 230
 231     // Type 112233 for 701, 712, 714, 725 in Ch7 (similar for Ch8) for the futur official numbering
 232     // Type 112233 for 705, 707, 755, 757 in Ch7 (similar for Ch8) actual numbering in the code to be changed in jan05
 233     // Type 112233 for 901, 902, 911, 912, 914, 915, 924, 925 in Ch9 (similar for Ch10) for the futur official numbering
 234     // Type 112233 for 904, 905, 907, 908, 954, 955, 957, 958 in Ch9 (similar for Ch10) actual numbering in the code to be changed in jan05
 235     Int_t n5[4] = { 0, 2, 2, 2 };
 236     slatsegB[5]->SetPcbBoards(n5);
 237     slatsegB[5]->Init(0); // 0 detection element id
 238     slatsegNB[5]->SetPcbBoards(n5);
 239     slatsegNB[5]->Init(0); // 0 detection element id
 240
 241     // Type 112230 for 702, 711, 715, 724 in Ch7 (similar for Ch8) for the futur official numbering
 242     // Type 112230 for 704, 708, 754, 758 in Ch7 (similar for Ch8) actual numbering in the code to be changed in jan05
 243     Int_t n6[4] = { 0, 2, 2, 1 };
 244     slatsegB[6]->SetPcbBoards(n6);
 245     slatsegB[6]->Init(0); // 0 detection element id
 246     slatsegNB[6]->SetPcbBoards(n6);
 247     slatsegNB[6]->Init(0); // 0 detection element id
 248
 249     // Type 222330 for 703, 710, 716, 723 in Ch7 (similar for Ch8) for the futur official numbering
 250     // Type 222330 for 703, 709, 753, 759 in Ch7 (similar for Ch8) actual numbering in the code to be changed in jan05
 251     Int_t n7[4] = { 0, 0, 3, 2 };
 252     slatsegB[7]->SetPcbBoards(n7);
 253     slatsegB[7]->Init(0); // 0 detection element id
 254     slatsegNB[7]->SetPcbBoards(n7);
 255     slatsegNB[7]->Init(0); // 0 detection element id
 256
 257     // Type 223300 for 704, 709, 717, 722 in Ch7 (similar for Ch8) for the futur official numbering
 258     // Type 223300 for 702, 710, 752, 760 in Ch7 (similar for Ch8) actual numbering in the code to be changed in jan05
 259     Int_t n8[4] = { 0, 0, 2, 2 };
 260     slatsegB[8]->SetPcbBoards(n8);
 261     slatsegB[8]->Init(0); // 0 detection element id
 262     slatsegNB[8]->SetPcbBoards(n8);
 263     slatsegNB[8]->Init(0); // 0 detection element id
 264
 265     // Type 333000 for 705, 708, 718, 721 in Ch7 (similar for Ch8) for the futur official numbering
 266     // Type 333000 for 701, 711, 751, 761 in Ch7 (similar for Ch8) actual numbering in the code to be changed in jan05
 267     // Type 333000 for 906, 907, 919, 920 in Ch9 (similar for Ch10) for the futur official numbering
 268     // Type 333000 for 900, 912, 950, 962 in Ch9 (similar for Ch10) actual numbering in the code to be changed in jan05
 269     Int_t n9[4] = { 0, 0, 0, 3 };
 270     slatsegB[9]->SetPcbBoards(n9);
 271     slatsegB[9]->Init(0); // 0 detection element id
 272     slatsegNB[9]->SetPcbBoards(n9);
 273     slatsegNB[9]->Init(0); // 0 detection element id
 274
 275     // Type 330000 for 706, 707, 719, 720 in Ch7 (similar for Ch8) for the futur official numbering
 276     // Type 330000 for 700, 712, 750, 762 in Ch7 (similar for Ch8) actual numbering in the code to be changed in jan05
 277     Int_t n10[4] = { 0, 0, 0, 2 };
 278     slatsegB[10]->SetPcbBoards(n10);
 279     slatsegB[10]->Init(0); // 0 detection element id
 280     slatsegNB[10]->SetPcbBoards(n10);
 281     slatsegNB[10]->Init(0); // 0 detection element id
 282
 283     // Type 222333 for 903, 910, 916, 923 in Ch9 (similar for Ch10) for the futur official numbering
 284     // Type 222333 for 903, 909, 953, 959 in Ch9 (similar for Ch10) actual numbering in the code to be changed in jan05
 285     Int_t n11[4] = { 0, 0, 3, 3 };
 286     slatsegB[11]->SetPcbBoards(n11);
 287     slatsegB[11]->Init(0); // 0 detection element id
 288     slatsegNB[11]->SetPcbBoards(n11);
 289     slatsegNB[11]->Init(0); // 0 detection element id
 290
 291     // Type 223330 for 904, 909, 917, 922 in Ch9 (similar for Ch10) for the futur official numbering
 292     // Type 223330 for 902, 910, 952, 960 in Ch9 (similar for Ch10) actual numbering in the code to be changed in jan05
 293     Int_t n12[4] = { 0, 0, 2, 3 };
 294     slatsegB[12]->SetPcbBoards(n12);
 295     slatsegB[12]->Init(0); // 0 detection element id
 296     slatsegNB[12]->SetPcbBoards(n12);
 297     slatsegNB[12]->Init(0); // 0 detection element id
 298
 299     // Type 333300 for 905, 908, 918, 921 in Ch9 (similar for Ch10) for the futur official numbering
 300     // Type 333300 for 901, 911, 951, 961 in Ch9 (similar for Ch10) actual numbering in the code to be changed in jan05
 301     Int_t n13[4] = { 0, 0, 0, 4 };
 302     slatsegB[13]->SetPcbBoards(n13);
 303     slatsegB[13]->Init(0); // 0 detection element id
 304     slatsegNB[13]->SetPcbBoards(n13);
 305     slatsegNB[13]->Init(0); // 0 detection element id
 306
 307   }
 308
 309   Int_t id0 = 0;
 310
 311   // For St3
 312   if (chamberId == 4 || chamberId == 5) {
 313     // Create chamber segmentations
 314
 315     id0=(chamberId+1)*100;
 316     // type 220000
 317     if (cathod == 0) {
 318       chamberSeg->Add(id0, slatsegB[3]);
 319       chamberSeg->Add(id0+ 8, slatsegB[3]);
 320       chamberSeg->Add(id0+50, slatsegB[3]);
 321       chamberSeg->Add(id0+58, slatsegB[3]);
 322     } else {
 323       chamberSeg->Add(id0, slatsegNB[3]);
 324       chamberSeg->Add(id0+ 8, slatsegNB[3]);
 325       chamberSeg->Add(id0+50, slatsegNB[3]);
 326       chamberSeg->Add(id0+58, slatsegNB[3]);
 327     }
 328     // type 222000
 329     if (cathod == 0) {
 330       chamberSeg->Add(id0+ 1, slatsegB[2]);
 331       chamberSeg->Add(id0+ 7, slatsegB[2]);
 332       chamberSeg->Add(id0+51, slatsegB[2]);
 333       chamberSeg->Add(id0+57, slatsegB[2]);
 334     } else {
 335       chamberSeg->Add(id0+ 1, slatsegNB[2]);
 336       chamberSeg->Add(id0+ 7, slatsegNB[2]);
 337       chamberSeg->Add(id0+51, slatsegNB[2]);
 338       chamberSeg->Add(id0+57, slatsegNB[2]);
 339     }
 340     // type 122200
 341     if (cathod == 0) {
 342       chamberSeg->Add(id0+ 2, slatsegB[1]);
 343       chamberSeg->Add(id0+ 6, slatsegB[1]);
 344       chamberSeg->Add(id0+52, slatsegB[1]);
 345       chamberSeg->Add(id0+56, slatsegB[1]);
 346     } else {
 347       chamberSeg->Add(id0+ 2, slatsegNB[1]);
 348       chamberSeg->Add(id0+ 6, slatsegNB[1]);
 349       chamberSeg->Add(id0+52, slatsegNB[1]);
 350       chamberSeg->Add(id0+56, slatsegNB[1]);
 351     }
 352     // type 112200
 353     if (cathod == 0) {
 354       chamberSeg->Add(id0+ 3, slatsegB[0]);
 355       chamberSeg->Add(id0+ 4, slatsegB[0]);
 356       chamberSeg->Add(id0+ 5, slatsegB[0]);
 357       chamberSeg->Add(id0+53, slatsegB[0]);
 358       chamberSeg->Add(id0+54, slatsegB[0]);
 359       chamberSeg->Add(id0+55, slatsegB[0]);
 360     } else {
 361       chamberSeg->Add(id0+ 3, slatsegNB[0]);
 362       chamberSeg->Add(id0+ 4, slatsegNB[0]);
 363       chamberSeg->Add(id0+ 5, slatsegNB[0]);
 364       chamberSeg->Add(id0+53, slatsegNB[0]);
 365       chamberSeg->Add(id0+54, slatsegNB[0]);
 366       chamberSeg->Add(id0+55, slatsegNB[0]);
 367     }
 368
 369   }
 370
 371   // For St4
 372   if (chamberId == 6 || chamberId == 7) {
 373     // Create chamber segmentations
 374     id0=(chamberId+1)*100;
 375     // type 122330
 376     if (cathod == 0) {
 377       chamberSeg->Add(id0+ 6, slatsegB[4]);
 378       chamberSeg->Add(id0+56, slatsegB[4]);
 379     } else {
 380       chamberSeg->Add(id0+ 6, slatsegNB[4]);
 381       chamberSeg->Add(id0+56, slatsegNB[4]);
 382     }
 383     // type 112233
 384     if (cathod == 0) {
 385       chamberSeg->Add(id0+ 5, slatsegB[5]);
 386       chamberSeg->Add(id0+ 7, slatsegB[5]);
 387       chamberSeg->Add(id0+55, slatsegB[5]);
 388       chamberSeg->Add(id0+57, slatsegB[5]);
 389     } else {
 390       chamberSeg->Add(id0+ 5, slatsegNB[5]);
 391       chamberSeg->Add(id0+ 7, slatsegNB[5]);
 392       chamberSeg->Add(id0+55, slatsegNB[5]);
 393       chamberSeg->Add(id0+57, slatsegNB[5]);
 394     }
 395     // type 112230
 396     if (cathod == 0) {
 397       chamberSeg->Add(id0+ 4, slatsegB[6]);
 398       chamberSeg->Add(id0+ 8, slatsegB[6]);
 399       chamberSeg->Add(id0+54, slatsegB[6]);
 400       chamberSeg->Add(id0+58, slatsegB[6]);
 401     } else {
 402       chamberSeg->Add(id0+ 4, slatsegNB[6]);
 403       chamberSeg->Add(id0+ 8, slatsegNB[6]);
 404       chamberSeg->Add(id0+54, slatsegNB[6]);
 405       chamberSeg->Add(id0+58, slatsegNB[6]);
 406     }
 407     // type 222330
 408     if (cathod == 0) {
 409       chamberSeg->Add(id0+ 3, slatsegB[7]);
 410       chamberSeg->Add(id0+ 9, slatsegB[7]);
 411       chamberSeg->Add(id0+53, slatsegB[7]);
 412       chamberSeg->Add(id0+59, slatsegB[7]);
 413     } else {
 414       chamberSeg->Add(id0+ 3, slatsegNB[7]);
 415       chamberSeg->Add(id0+ 9, slatsegNB[7]);
 416       chamberSeg->Add(id0+53, slatsegNB[7]);
 417       chamberSeg->Add(id0+59, slatsegNB[7]);
 418     }
 419     // type 223300
 420     if (cathod == 0) {
 421       chamberSeg->Add(id0+ 2, slatsegB[8]);
 422       chamberSeg->Add(id0+10, slatsegB[8]);
 423       chamberSeg->Add(id0+52, slatsegB[8]);
 424       chamberSeg->Add(id0+60, slatsegB[8]);
 425     } else {
 426       chamberSeg->Add(id0+ 2, slatsegNB[8]);
 427       chamberSeg->Add(id0+10, slatsegNB[8]);
 428       chamberSeg->Add(id0+52, slatsegNB[8]);
 429       chamberSeg->Add(id0+60, slatsegNB[8]);
 430     }
 431     // type 333000
 432     if (cathod == 0) {
 433       chamberSeg->Add(id0+ 1, slatsegB[9]);
 434       chamberSeg->Add(id0+11, slatsegB[9]);
 435       chamberSeg->Add(id0+51, slatsegB[9]);
 436       chamberSeg->Add(id0+61, slatsegB[9]);
 437     } else {
 438       chamberSeg->Add(id0+ 1, slatsegNB[9]);
 439       chamberSeg->Add(id0+11, slatsegNB[9]);
 440       chamberSeg->Add(id0+51, slatsegNB[9]);
 441       chamberSeg->Add(id0+61, slatsegNB[9]);
 442     }
 443     // type 330000
 444     if (cathod == 0) {
 445       chamberSeg->Add(id0   , slatsegB[10]);
 446       chamberSeg->Add(id0+12, slatsegB[10]);
 447       chamberSeg->Add(id0+50, slatsegB[10]);
 448       chamberSeg->Add(id0+62, slatsegB[10]);
 449     } else {
 450       chamberSeg->Add(id0   , slatsegNB[10]);
 451       chamberSeg->Add(id0+12, slatsegNB[10]);
 452       chamberSeg->Add(id0+50, slatsegNB[10]);
 453       chamberSeg->Add(id0+62, slatsegNB[10]);
 454     }
 455   }
 456
 457   // For St5
 458   if (chamberId == 8 || chamberId == 9) {
 459     // Create chamber segmentations
 460     id0=(chamberId+1)*100;
 461     // type 122330
 462     if (cathod == 0) {
 463       chamberSeg->Add(id0+ 6, slatsegB[4]);
 464       chamberSeg->Add(id0+56, slatsegB[4]);
 465     } else {
 466       chamberSeg->Add(id0+ 6, slatsegNB[4]);
 467       chamberSeg->Add(id0+56, slatsegNB[4]);
 468     }
 469     // type 112233
 470     if (cathod == 0) {
 471       chamberSeg->Add(id0+ 4, slatsegB[5]);
 472       chamberSeg->Add(id0+ 5, slatsegB[5]);
 473       chamberSeg->Add(id0+ 7, slatsegB[5]);
 474       chamberSeg->Add(id0+ 8, slatsegB[5]);
 475       chamberSeg->Add(id0+54, slatsegB[5]);
 476       chamberSeg->Add(id0+55, slatsegB[5]);
 477       chamberSeg->Add(id0+57, slatsegB[5]);
 478       chamberSeg->Add(id0+58, slatsegB[5]);
 479     } else {
 480       chamberSeg->Add(id0+ 4, slatsegNB[5]);
 481       chamberSeg->Add(id0+ 5, slatsegNB[5]);
 482       chamberSeg->Add(id0+ 7, slatsegNB[5]);
 483       chamberSeg->Add(id0+ 8, slatsegNB[5]);
 484       chamberSeg->Add(id0+54, slatsegNB[5]);
 485       chamberSeg->Add(id0+55, slatsegNB[5]);
 486       chamberSeg->Add(id0+57, slatsegNB[5]);
 487       chamberSeg->Add(id0+58, slatsegNB[5]);
 488     }
 489     // type 222333
 490     if (cathod == 0) {
 491       chamberSeg->Add(id0+ 3, slatsegB[11]);
 492       chamberSeg->Add(id0+ 9, slatsegB[11]);
 493       chamberSeg->Add(id0+53, slatsegB[11]);
 494       chamberSeg->Add(id0+59, slatsegB[11]);
 495     } else {
 496       chamberSeg->Add(id0+ 3, slatsegNB[11]);
 497       chamberSeg->Add(id0+ 9, slatsegNB[11]);
 498       chamberSeg->Add(id0+53, slatsegNB[11]);
 499       chamberSeg->Add(id0+59, slatsegNB[11]);
 500     }
 501     // type 223330
 502     if (cathod == 0) {
 503       chamberSeg->Add(id0+ 2, slatsegB[12]);
 504       chamberSeg->Add(id0+10, slatsegB[12]);
 505       chamberSeg->Add(id0+52, slatsegB[12]);
 506       chamberSeg->Add(id0+60, slatsegB[12]);
 507     } else {
 508       chamberSeg->Add(id0+ 2, slatsegNB[12]);
 509       chamberSeg->Add(id0+10, slatsegNB[12]);
 510       chamberSeg->Add(id0+52, slatsegNB[12]);
 511       chamberSeg->Add(id0+60, slatsegNB[12]);
 512     }
 513     // type 333300
 514     if (cathod == 0) {
 515       chamberSeg->Add(id0+ 1, slatsegB[13]);
 516       chamberSeg->Add(id0+11, slatsegB[13]);
 517       chamberSeg->Add(id0+51, slatsegB[13]);
 518       chamberSeg->Add(id0+61, slatsegB[13]);
 519     } else {
 520       chamberSeg->Add(id0+ 1, slatsegNB[13]);
 521       chamberSeg->Add(id0+11, slatsegNB[13]);
 522       chamberSeg->Add(id0+51, slatsegNB[13]);
 523       chamberSeg->Add(id0+61, slatsegNB[13]);
 524     }
 525     // type 333000
 526     if (cathod == 0) {
 527       chamberSeg->Add(id0   , slatsegB[9]);
 528       chamberSeg->Add(id0+12, slatsegB[9]);
 529       chamberSeg->Add(id0+50, slatsegB[9]);
 530       chamberSeg->Add(id0+62, slatsegB[9]);
 531     } else {
 532       chamberSeg->Add(id0   , slatsegNB[9]);
 533       chamberSeg->Add(id0+12, slatsegNB[9]);
 534       chamberSeg->Add(id0+50, slatsegNB[9]);
 535       chamberSeg->Add(id0+62, slatsegNB[9]);
 536     }
 537   }
 538
 539
 540   if (!id0) {
 541     AliWarning(Form("Segmentation for chamber %d , cathod %d is not yet defined",
 542                     chamberId, cathod));
 543     return 0;
 544
 545   }
 546
 547   DrawSegmentation(chamberSeg);
 548   return chamberSeg;
 549
 550 }
 551
 552 //
 553 // public methods
 554 //
 555
 556 //______________________________________________________________________________
 557 AliMUONGeometrySegmentation*
 558 AliMUONTest::CreateSegmentation(Int_t chamberId, Int_t cath)
 559 {
 560 // Create geometry segmentation for the specified chamber and cathod
 561
 562   switch (chamberId) {
 563
 564     // Station1
 565     case 0:
 566     case 1:
 567         return CreateSt1Segmentation(chamberId, cath);
 568         break;
 569
 570     // Station2
 571     case 2:
 572     case 3:
 573         AliWarning("Not yet implemented");
 574         return 0;
 575         break;
 576
 577     // Slat stations
 578     case 4:
 579     case 5:
 580     case 6:
 581     case 7:
 582     case 8:
 583     case 9:
 584         return CreateSlatSegmentation(chamberId, cath);
 585         break;
 586
 587     // Trigger stations
 588     case 10:
 589     case 11:
 590     case 12:
 591     case 13:
 592         //return CreateTriggerSegmentation(chamberId, cath);
 593         AliWarning("Not yet implemented");
 594         return 0;
 595         break;
 596
 597     default:
 598         AliWarning("Wrong chamber Id");
 599         return 0;
 600         break;
 601   }
 602 }
 603
 604 //______________________________________________________________________________
 605 void  AliMUONTest::DetElemTransforms()
 606 {
 607 //
 608   AliMUON* muon = (AliMUON*)gAlice->GetModule("MUON");
 609   if (!muon) {
 610     AliFatal("MUON detector not defined.");
 611     return;
 612   }
 613
 614   // Loop over chambers
 615   for (Int_t i=0; i<AliMUONConstants::NCh(); i++) {
 616
 617     AliMUONGeometryModule* geometry = muon->Chamber(i).GetGeometry();
 618     AliMUONGeometryStore* detElements = geometry->GetDetElementStore();
 619
 620     // Loop over detection elements
 621     for (Int_t j=0; j<detElements->GetNofEntries(); j++) {
 622
 623       //Int_t detElemId = geometry->GetDetElemId(j);
 624       Int_t detElemId = detElements->GetEntry(j)->GetUniqueID();
 625       cout << "Detection element Id: " << detElemId << endl;
 626
 627       Double_t x, y, z;
 628       geometry->Local2Global(detElemId, 0., 0., 0., x, y, z);
 629       cout << "  Global DE position:            "
 630            <<  x << ",  " << y << ",  " << z << endl;
 631
 632       Double_t x2, y2, z2;
 633       geometry->Global2Local(detElemId, 0., 0., 0., x2, y2, z2);
 634       cout << "  ALIC center in the local frame: "
 635            <<  x2 << ",  " << y2 << ",  " << z2 << endl;
 636
 637       Double_t x3, y3, z3;
 638       geometry->Global2Local(detElemId, x, y, z, x3, y3, z3);
 639       cout << "  Back in the local frame: "
 640            <<  x3 << ",  " << y3 << ",  " << z3 << endl;
 641       cout << endl;
 642     }
 643   }
 644 }
 645
 646 //________________________________________________________________________
 647 void AliMUONTest::PrintPadPositionsOld()
 648 {
 649 // Iterate over all old chamber segmentations and prints
 650 // global pad positions
 651
 652   AliMUON* muon = (AliMUON*)gAlice->GetModule("MUON");
 653   if (!muon) {
 654     AliFatal("MUON detector not defined.");
 655     return;
 656   }
 657
 658   // Loop over chambers
 659   for (Int_t i=0; i<1; i++) {
 660
 661     // Create chamber segmentations
 662     AliSegmentation* seg[2];
 663     seg[0] = muon->Chamber(i).SegmentationModel(0);
 664     seg[1] = muon->Chamber(i).SegmentationModel(1);
 665
 666     // Iterate over the whole plane and return pad indices and
 667     // global/local positions
 668     cout << "Go to loop over pads" << endl;
 669     for (Int_t cath=0; cath<2; cath++) {
 670
 671       cout << setw(6) << "Pads in chamber " << i << " cathod " << cath << endl;
 672       cout << "===================================" << endl;
 673       TStopwatch timer;
 674       timer.Start();
 675
 676       Int_t counter = 0;
 677       for ( seg[cath]->FirstPad(70., 70., 0., 80., 80.);
 678             seg[cath]->MorePads();
 679             seg[cath]->NextPad() )
 680       {
 681         cout << setw(6) << "counter " << counter++ << "   ";
 682
 683         Int_t ix = seg[cath]->Ix();
 684         Int_t iy = seg[cath]->Iy();
 685         cout << "Pad indices:  ( " << ix << ", " << iy << " )  " ;
 686
 687         Float_t x, y, z;
 688         seg[cath]->GetPadC(ix, iy, x, y, z);
 689         cout << "Pad position: ( " << x << ", " << y << ", " << z << " )" << endl;
 690       }
 691       timer.Stop();
 692       timer.Print();
 693     }
 694   }
 695 }
 696
 697 //______________________________________________________________________________
 698 void AliMUONTest::ForWhole(AliMUONTests testCase)
 699 {
 700 // Perform test for all chambers and first cathod
 701
 702   AliMUON* muon = (AliMUON*)gAlice->GetModule("MUON");
 703   if (!muon) {
 704     AliFatal("MUON detector not defined.");
 705     return;
 706   }
 707
 708   TStopwatch timer;
 709   timer.Start();
 710
 711   // Loop over chambers
 712   for (Int_t iChamber=0; iChamber<AliMUONConstants::NCh(); iChamber++) {
 713
 714     // Loop over cathods
 715     //for (Int_t cath=0; cath<2; cath++) {
 716     for (Int_t cath=0; cath<1; cath++) {
 717
 718       AliMUONGeometrySegmentation* segmentation
 719         = CreateSegmentation(iChamber, cath);
 720
 721       if (!segmentation) continue;
 722
 723       cout << setw(6) << "Pads in chamber " << iChamber
 724            << " cathod " << cath << endl;
 725       cout << "===================================" << endl;
 726
 727       ForSegmentation(testCase, segmentation);
 728
 729       //if (testCase == kDrawPads) {
 730       //}
 731     }
 732   }
 733   timer.Stop();
 734   timer.Print();
 735 }
 736
 737 //______________________________________________________________________________
 738 void AliMUONTest::ForSegmentation(AliMUONTests testCase,
 739                                   AliMUONGeometrySegmentation *segmentation)
 740 {
 741 // Perform test for a given segmentation
 742
 743   TStopwatch timer;
 744   timer.Start();
 745
 746   Before(testCase);
 747
 748   // Loop over detection elements
 749   //
 750   AliMUONGeometryStore* detElements
 751     = segmentation->GetGeometry()->GetDetElementStore();
 752
 753   for (Int_t j=0; j<detElements->GetNofEntries(); j++) {
 754
 755     Int_t detElemId = detElements->GetEntry(j)->GetUniqueID();
 756     cout << "Detection element id: " << detElemId << endl;
 757
 758     ForDetElement(testCase, detElemId, segmentation);
 759   }
 760
 761   After(testCase);
 762
 763   timer.Stop();
 764   timer.Print();
 765 }
 766
 767 //______________________________________________________________________________
 768 void AliMUONTest::ForDetElement(AliMUONTests testCase,
 769                                 Int_t detElemId,
 770                                 AliMUONGeometrySegmentation *segmentation)
 771 {
 772 // Prints global pad positions for given detection element
 773 // in a given geometry segmentation
 774
 775
 776   Int_t counter = 0;
 777
 778   // Loop over pads in a detection element
 779   //
 780
 781   for(Int_t ix=1; ix<=segmentation->Npx(detElemId); ix++)
 782     for(Int_t iy=1; iy<=segmentation->Npy(detElemId); iy++)
 783     {
 784        switch (testCase) {
 785
 786          case kPrintPads:
 787            PrintPad(counter, detElemId, ix, iy, segmentation);
 788            break;
 789
 790          case kDrawPads:
 791            DrawPad(counter, detElemId, ix, iy, segmentation);
 792            break;
 793       }
 794     }
 795 }
 796
 797 //______________________________________________________________________________
 798 void AliMUONTest::Before(AliMUONTests testCase)
 799 {
 800 // Do some initialization if necessary
 801
 802   switch (testCase) {
 803
 804     case kPrintPads:
 805       break;
 806
 807     case kDrawPads:
 808       if (!fCanvas) {
 809         fCanvas = new TCanvas("c1","c1", 0, 0, 600, 600);
 810         fCanvas->Range(-300,-300, 300, 300);
 811         fCanvas->cd();
 812       }
 813       break;
 814   }
 815 }
 816
 817 //______________________________________________________________________________
 818 void AliMUONTest::After(AliMUONTests testCase)
 819 {
 820 // Do some cleanup if necessary
 821
 822   switch (testCase) {
 823
 824     case kPrintPads:
 825       break;
 826
 827     case kDrawPads:
 828       fCanvas->Update();
 829       cout << "Print any key + enter to continue ..." << endl;
 830       char c;
 831       cin >> c;
 832       fCanvas->Clear();
 833       break;
 834   }
 835 }
 836
 837 //______________________________________________________________________________
 838 void AliMUONTest::PrintPad(Int_t& counter,
 839                            Int_t detElemId, Int_t ix, Int_t iy,
 840                            AliMUONGeometrySegmentation* segmentation)
 841 {
 842 // Prints global pad positions for the given pad
 843
 844   Float_t x, y, z;
 845   Bool_t success
 846     = segmentation->GetPadC(detElemId, ix, iy, x, y, z);
 847
 848   if (!success) return;
 849
 850   cout << setw(6) << "counter " << counter++ << "   ";
 851   cout << "Pad indices:  ( " << detElemId << "; " << ix << ", " << iy << " )  " ;
 852   cout << "Pad position: ( " << x << ", " << y << ", " << z << " )" << endl;
 853 }
 854
 855 //______________________________________________________________________________
 856 void AliMUONTest::DrawPad(Int_t& counter,
 857                           Int_t detElemId, Int_t ix, Int_t iy,
 858                           AliMUONGeometrySegmentation* segmentation)
 859 {
 860 // Prints global pad positions for the given pad
 861
 862   Float_t x, y, z;
 863   Bool_t success
 864     = segmentation->GetPadC(detElemId, ix, iy, x, y, z);
 865
 866   if (!success) return;
 867
 868   // PrintPad(counter,detElemId, ix, iy, segmentation);
 869
 870   counter++;
 871
 872   Int_t sector = segmentation->Sector(detElemId, ix, iy);
 873   Float_t dpx = segmentation->Dpx(detElemId, sector);
 874   Float_t dpy = segmentation->Dpy(detElemId, sector);
 875
 876   //printf(" ***** Pad position is ix: %d iy: %d x: %f y: %f sector: %d dpx: %f dpy: %f \n",
 877   //       ix, iy, x, y, sector, dpx, dpy);
 878
 879   if (!fCanvas) Before(kDrawPads);
 880
 881   fCanvas->cd();
 882   TPave* pave = new TPave(x-dpx/2., y-dpy/2., x+dpx/2., y+dpy/2., 1);
 883   pave->Draw();
 884 }
 885
 886 //______________________________________________________________________________
 887 void AliMUONTest::DrawSegmentation(AliMUONGeometrySegmentation *seg)
 888 {
 889 // TBR
 890
 891   // Drawing slat504
 892   Int_t ix, iy, deId;
 893   Float_t x, y, z;
 894   Float_t dpx, dpy;
 895 //   TH2F * frame = new TH2F(" "," ",10,-10.,245.,10, -5., 45.);
 896 //   TH2F * frame = new TH2F(" "," ",10,-300.,300.,10, -300., 300.);
 897   TH2F * frame = new TH2F(" "," ",10,-200.,200.,10, -200., 200.);
 898   frame->Draw();
 899 //   (new TPave(  0.,  0., 40., 40.,2))->Draw();
 900 //   (new TPave( 40.,  0., 80., 40.,2))->Draw();
 901 //   (new TPave( 80.,  0.,120., 40.,2))->Draw();
 902 //   (new TPave(120.,  0.,160., 40.,2))->Draw();
 903 //   (new TPave(160.,  0.,200., 40.,2))->Draw();
 904 //   (new TPave(200.,  0.,240., 40.,2))->Draw();
 905
 906   // Loop over detection elements
 907   //
 908   AliMUONGeometryStore* detElements
 909     = seg->GetGeometry()->GetDetElementStore();
 910
 911   for (Int_t iDE=0; iDE<detElements->GetNofEntries(); iDE++) {
 912
 913     deId = detElements->GetEntry(iDE)->GetUniqueID();
 914     cout << "Detection element id: " << deId << endl;
 915
 916
 917     //   for ( seg->FirstPad(detElementId,  0., 0., 0., 100., 100.);
 918     //  seg->MorePads(detElementId);
 919     //  seg->NextPad(detElementId) ) {
 920     for(ix=1; ix<=seg->Npx(deId); ix++) {
 921       for(iy=1; iy<=seg->Npy(deId); iy++) {
 922
 923         seg->GetPadC(deId, ix, iy, x, y, z);
 924         Int_t sector = seg->Sector(deId, ix, iy);
 925         dpx = seg->Dpx(deId,sector);
 926         dpy = seg->Dpy(deId,sector);
 927
 928         //printf(" ***** Pad position is ix: %d iy: %d x: %f y: %f sector: %d dpx: %f dpy: %f \n",ix, iy, x, y, sector, dpx, dpy);
 929         (new TPave(x-dpx/2., y-dpy/2., x+dpx/2., y+dpy/2., 1))->Draw();
 930       }
 931
 932     }
 933   }
 934 }
 935