ITS/AliITS.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 /*
  17 $Log$
  18 Revision 1.9.2.3  2000/02/02 13:42:09  barbera
  19 fixed AliITS.cxx for new AliRun structure. Added ITS hits list to list of hits which will have their track numbers updated
  20
  21 Revision 1.9.2.2  2000/01/23 03:03:13  nilsen
  22 //fixed FillModule. Removed fi(fabs(xl)<dx....
  23
  24 Revision 1.9.2.1  2000/01/12 19:03:32  nilsen
  25 This is the version of the files after the merging done in December 1999.
  26 See the ReadMe110100.txt file for details
  27
  28 Revision 1.9  1999/11/14 14:33:25  fca
  29 Correct problems with distructors and pointers, thanks to I.Hrivnacova
  30
  31 Revision 1.8  1999/09/29 09:24:19  fca
  32 Introduction of the Copyright and cvs Log
  33
  34 */
  35
  36 ///////////////////////////////////////////////////////////////////////////////
  37 //
  38 //      An overview of the basic philosophy of the ITS code development
  39 // and analysis is show in the figure below.
  40 //Begin_Html
  41 /*
  42 <img src="picts/ITS/ITS_Analysis_schema.gif">
  43 </pre>
  44 <br clear=left>
  45 <font size=+2 color=red>
  46 <p>Roberto Barbera is in charge of the ITS Offline code (1999).
  47 <a href="mailto:roberto.barbera@ct.infn.it">Roberto Barbera</a>.
  48 </font>
  49 <pre>
  50 */
  51 //End_Html
  52 //
  53 //  AliITS. Inner Traking System base class.
  54 //  This class contains the base procedures for the Inner Tracking System
  55 //
  56 //Begin_Html
  57 /*
  58 <img src="picts/ITS/AliITS_Class_Diagram.gif">
  59 </pre>
  60 <br clear=left>
  61 <font size=+2 color=red>
  62 <p>This show the class diagram of the different elements that are part of
  63 the AliITS class.
  64 </font>
  65 <pre>
  66 */
  67 //End_Html
  68 //
  69 // Version: 0
  70 // Written by Rene Brun, Federico Carminati, and Roberto Barbera
  71 //
  72 // Version: 1
  73 // Modified and documented by Bjorn S. Nilsen
  74 // July 11 1999
  75 //
  76 // Version: 2
  77 // Modified and documented by A. Bologna
  78 // October 18 1999
  79 //
  80 // AliITS is the general base class for the ITS. Also see AliDetector for
  81 // futher information.
  82 //
  83 ///////////////////////////////////////////////////////////////////////////////
  84
  85 #include <TMath.h>
  86 #include <TRandom.h>
  87 #include <TVector.h>
  88 #include <TObjArray.h>
  89 #include <TROOT.h>
  90 #include <TObjectTable.h>
  91
  92
  93
  94 #include "AliRun.h"
  95 #include "AliITS.h"
  96 #include "AliITSMap.h"
  97 #include "AliITSDetType.h"
  98 #include "AliITSClusterFinder.h"
  99 #include "AliITSsimulation.h"
 100 #include "AliITSsegmentationSPD.h"
 101 #include "AliITSresponseSPD.h"
 102 #include "AliITSsegmentationSDD.h"
 103 #include "AliITSresponseSDD.h"
 104 #include "AliITSsegmentationSSD.h"
 105 #include "AliITSresponseSSD.h"
 106
 107
 108
 109 ClassImp(AliITS)
 110
 111 //_____________________________________________________________________________
 112 AliITS::AliITS() : AliDetector() {
 113   //
 114   // Default initialiser for ITS
 115   //     The default constructor of the AliITS class. In addition to
 116   // creating the AliITS class it zeros the variables fIshunt (a member
 117   // of AliDetector class), fEuclidOut, and fIdN, and zeros the pointers
 118   // fITSpoints, fIdSens, and fIdName. The AliDetector default constructor
 119   // is also called.
 120   //
 121
 122   fIshunt     = 0;
 123   fEuclidOut  = 0;
 124
 125   //fNDetTypes = fgkNTYPES;
 126   fIdN        = 0;
 127   fIdName     = 0;
 128   fIdSens     = 0;
 129   fITSmodules = 0;
 130   //
 131   fDetTypes   = 0;
 132   //
 133   fDtype  = 0;
 134   fNdtype = 0;
 135   fCtype  = 0;
 136   fNctype = 0;
 137   fRecPoints = 0;
 138   fNRecPoints = 0;
 139   fTreeC = 0;
 140   //
 141   fITSgeom=0;
 142 }
 143
 144 //_____________________________________________________________________________
 145 AliITS::AliITS(const char *name, const char *title):AliDetector(name,title){
 146   //
 147   // Default initialiser for ITS
 148   //     The constructor of the AliITS class. In addition to creating the
 149   // AliITS class, it allocates memory for the TClonesArrays fHits and
 150   // fDigits, and for the TObjArray fITSpoints. It also zeros the variables
 151   // fIshunt (a member of AliDetector class), fEuclidOut, and fIdN, and zeros
 152   // the pointers fIdSens and fIdName. To help in displaying hits via the ROOT
 153   // macro display.C AliITS also sets the marker color to red. The variables
 154   // passes with this constructor, const char *name and *title, are used by
 155   // the constructor of AliDetector class. See AliDetector class for a
 156   // description of these parameters and its constructor functions.
 157   //
 158
 159   fHits       = new TClonesArray("AliITShit", 1560);
 160   gAlice->AddHitList(fHits);
 161
 162   //fNDetTypes = fgkNTYPES;
 163
 164   fNdtype = new Int_t[fgkNTYPES];
 165   fDtype = new TObjArray(fgkNTYPES);
 166
 167   fNctype = new Int_t[fgkNTYPES];
 168   fCtype = new TObjArray(fgkNTYPES);
 169
 170
 171   fRecPoints = 0;
 172   fNRecPoints = 0;
 173
 174   fTreeC = 0;
 175
 176   fITSmodules = 0;
 177
 178   fIshunt     = 0;
 179   fEuclidOut  = 0;
 180   fIdN        = 0;
 181   fIdName     = 0;
 182   fIdSens     = 0;
 183
 184   fDetTypes = new TObjArray(fgkNTYPES);
 185
 186   Int_t i;
 187   for(i=0;i<fgkNTYPES;i++) {
 188     (*fDetTypes)[i]=new AliITSDetType();
 189     fNdtype[i]=0;
 190     fNctype[i]=0;
 191    }
 192   //
 193
 194   SetMarkerColor(kRed);
 195
 196   fITSgeom=0;
 197 }
 198 //___________________________________________________________________________
 199 AliITS::AliITS(AliITS &source){
 200   // copy constructor
 201   if(this==&source) return;
 202   printf("Error: You are not allowed to make a copy of the AliITS\n");
 203   exit(1);
 204 }
 205 //____________________________________________________________________________
 206 AliITS& AliITS::operator=(AliITS &source){
 207   // assignment operator
 208   if(this==&source) return *this;
 209   printf("Error: You are not allowed to make a copy of the AliITS\n");
 210   exit(1);
 211   return *this; //fake return
 212 }
 213 //____________________________________________________________________________
 214 void AliITS::ClearModules(){
 215
 216   //clear the modules TObjArray
 217   Int_t i;
 218
 219   if(fITSmodules!=0) {
 220         Int_t indSPD = fITSgeom->GetModuleIndex(2,fITSgeom->GetNladders(2),
 221                                                 fITSgeom->GetNdetectors(2));
 222         Int_t indSDD = fITSgeom->GetModuleIndex(4,fITSgeom->GetNladders(4),
 223                                                 fITSgeom->GetNdetectors(4));
 224       for(i=0;i<fITSmodules->GetEntriesFast();i++){
 225             if(!fITSmodules->At(i)) continue;
 226             if(i<indSPD)
 227               delete (AliITSmodule *) fITSmodules->At(i);
 228             else if(i<indSDD)
 229               delete (AliITSmodule *) fITSmodules->At(i);
 230             else
 231               delete (AliITSmodule *) fITSmodules->At(i);
 232       } // end for i
 233   }// end if fITSmodules!=0
 234
 235 }
 236 //_____________________________________________________________________________
 237 AliITS::~AliITS(){
 238   //
 239   // Default distructor for ITS
 240   //     The default destructor of the AliITS class. In addition to deleting
 241   // the AliITS class it deletes the memory pointed to by the fHits, fDigits,
 242   // fIdSens, fIdName, and fITSpoints.
 243   //
 244
 245
 246   delete fHits;
 247   delete fDigits;
 248   delete fRecPoints;
 249   if(fIdName!=0) delete[] fIdName;
 250   if(fIdSens!=0) delete[] fIdSens;
 251   if(fITSmodules!=0) {
 252       this->ClearModules();
 253       delete fITSmodules;
 254   }// end if fITSmodules!=0
 255
 256   //
 257   Int_t i;
 258   if(fDtype) {
 259     for (i=0;i<fgkNTYPES;i++) {
 260       delete (*fDtype)[i];
 261       fNdtype[i]=0;
 262     }
 263   }
 264
 265   for (i=0;i<fgkNTYPES;i++) {
 266       delete (*fCtype)[i];
 267       fNctype[i]=0;
 268   }
 269
 270   //
 271
 272   if (fDetTypes) {
 273     fDetTypes->Delete();
 274     delete fDetTypes;
 275   }
 276
 277   if (fTreeC) delete fTreeC;
 278
 279 }
 280
 281 //___________________________________________
 282 AliITSDetType* AliITS::DetType(Int_t id)
 283 {
 284   //return pointer to id detector type
 285     return ((AliITSDetType*) (*fDetTypes)[id]);
 286
 287 }
 288 //___________________________________________
 289 void AliITS::SetClasses(Int_t id, const char *digit, const char *cluster)
 290 {
 291   //set the digit and cluster classes to be used for the id detector type
 292     ((AliITSDetType*) (*fDetTypes)[id])->ClassNames(digit,cluster);
 293
 294 }
 295 //___________________________________________
 296 void AliITS::SetResponseModel(Int_t id, AliITSresponse *response)
 297 {
 298   //set the response model for the id detector type
 299
 300     ((AliITSDetType*) (*fDetTypes)[id])->ResponseModel(response);
 301
 302 }
 303
 304 //___________________________________________
 305 void AliITS::SetSegmentationModel(Int_t id, AliITSsegmentation *seg)
 306 {
 307   //set the segmentation model for the id detector type
 308
 309     ((AliITSDetType*) (*fDetTypes)[id])->SegmentationModel(seg);
 310
 311 }
 312
 313 //___________________________________________
 314 void AliITS::SetSimulationModel(Int_t id, AliITSsimulation *sim)
 315 {
 316   //set the simulation model for the id detector type
 317
 318    ((AliITSDetType*) (*fDetTypes)[id])->SimulationModel(sim);
 319
 320 }
 321 //___________________________________________
 322 void AliITS::SetReconstructionModel(Int_t id, AliITSClusterFinder *reconst)
 323 {
 324   //set the cluster finder model for the id detector type
 325
 326    ((AliITSDetType*) (*fDetTypes)[id])->ReconstructionModel(reconst);
 327
 328 }
 329
 330 //_____________________________________________________________________________
 331 void AliITS::AddHit(Int_t track, Int_t *vol, Float_t *hits){
 332   //
 333   // Add an ITS hit
 334   //     The function to add information to the AliITShit class. See the
 335   // AliITShit class for a full description. This function allocates the
 336   // necessary new space for the hit information and passes the variable
 337   // track, and the pointers *vol and *hits to the AliITShit constructor
 338   // function.
 339   //
 340   TClonesArray &lhits = *fHits;
 341   new(lhits[fNhits++]) AliITShit(fIshunt,track,vol,hits);
 342 }
 343 //_____________________________________________________________________________
 344 void AliITS::AddRealDigit(Int_t id, Int_t *digits)
 345 {
 346   // add a real digit - as coming from data
 347
 348   TClonesArray &ldigits = *((TClonesArray*)(*fDtype)[id]);
 349   new(ldigits[fNdtype[id]++]) AliITSdigit(digits);
 350
 351 }
 352 //_____________________________________________________________________________
 353 void AliITS::AddSimDigit(Int_t id, AliITSdigit *d)
 354 {
 355
 356   // add a simulated digit
 357
 358   TClonesArray &ldigits = *((TClonesArray*)(*fDtype)[id]);
 359
 360   switch(id)
 361   {
 362   case 0:
 363      new(ldigits[fNdtype[id]++]) AliITSdigitSPD(*((AliITSdigitSPD*)d));
 364      break;
 365   case 1:
 366      new(ldigits[fNdtype[id]++]) AliITSdigitSDD(*((AliITSdigitSDD*)d));
 367      break;
 368   case 2:
 369      new(ldigits[fNdtype[id]++]) AliITSdigitSSD(*((AliITSdigitSSD*)d));
 370      break;
 371   }
 372
 373 }
 374
 375 //_____________________________________________________________________________
 376 void AliITS::AddSimDigit(Int_t id,Float_t phys,Int_t *digits,Int_t *tracks,Int_t *hits,Float_t *charges){
 377
 378   // add a simulated digit to the list
 379
 380   TClonesArray &ldigits = *((TClonesArray*)(*fDtype)[id]);
 381   switch(id)
 382   {
 383   case 0:
 384      new(ldigits[fNdtype[id]++]) AliITSdigitSPD(digits,tracks,hits);
 385      break;
 386   case 1:
 387      new(ldigits[fNdtype[id]++]) AliITSdigitSDD(phys,digits,tracks,hits,charges);
 388      break;
 389   case 2:
 390      new(ldigits[fNdtype[id]++]) AliITSdigitSSD(digits,tracks,hits);
 391      break;
 392   }
 393
 394 }
 395
 396 //_____________________________________________________________________________
 397 void AliITS::AddCluster(Int_t id, AliITSRawCluster *c)
 398 {
 399
 400   // add a cluster to the list
 401
 402   TClonesArray &lcl = *((TClonesArray*)(*fCtype)[id]);
 403
 404   switch(id)
 405   {
 406   case 0:
 407      new(lcl[fNctype[id]++]) AliITSRawClusterSPD(*((AliITSRawClusterSPD*)c));
 408      break;
 409   case 1:
 410      new(lcl[fNctype[id]++]) AliITSRawClusterSDD(*((AliITSRawClusterSDD*)c));
 411      break;
 412   case 2:
 413      new(lcl[fNctype[id]++]) AliITSRawClusterSSD(*((AliITSRawClusterSSD*)c));
 414      break;
 415   }
 416
 417 }
 418
 419
 420 //_____________________________________________________________________________
 421 void AliITS::AddRecPoint(const AliITSRecPoint &r)
 422 {
 423   //
 424   // Add a reconstructed space point to the list
 425   //
 426   TClonesArray &lrecp = *fRecPoints;
 427   new(lrecp[fNRecPoints++]) AliITSRecPoint(r);
 428 }
 429
 430
 431 //____________________________________________
 432 void AliITS::ResetDigits()
 433 {
 434     //
 435     // Reset number of digits and the digits array for thE ITS detector
 436     //
 437
 438     if (!fDtype) return;
 439
 440     Int_t i;
 441     for (i=0;i<fgkNTYPES;i++ ) {
 442         if ((*fDtype)[i])    ((TClonesArray*)(*fDtype)[i])->Clear();
 443         if (fNdtype)  fNdtype[i]=0;
 444     }
 445 }
 446
 447 //____________________________________________
 448 void AliITS::ResetDigits(Int_t i)
 449 {
 450     //
 451     // Reset number of digits and the digits array for this branch
 452     //
 453   if ((*fDtype)[i])    ((TClonesArray*)(*fDtype)[i])->Clear();
 454   if (fNdtype)  fNdtype[i]=0;
 455 }
 456
 457
 458 //____________________________________________
 459 void AliITS::ResetClusters()
 460 {
 461     //
 462     // Reset number of clusters and the clusters array for ITS
 463     //
 464
 465     Int_t i;
 466     for (i=0;i<fgkNTYPES;i++ ) {
 467         if ((*fCtype)[i])    ((TClonesArray*)(*fCtype)[i])->Clear();
 468         if (fNctype)  fNctype[i]=0;
 469     }
 470
 471 }
 472
 473 //____________________________________________
 474 void AliITS::ResetClusters(Int_t i)
 475 {
 476     //
 477     // Reset number of clusters and the clusters array for this branch
 478     //
 479         if ((*fCtype)[i])    ((TClonesArray*)(*fCtype)[i])->Clear();
 480         if (fNctype)  fNctype[i]=0;
 481
 482 }
 483
 484
 485 //____________________________________________
 486 void AliITS::ResetRecPoints()
 487 {
 488     //
 489     // Reset number of rec points and the rec points array
 490     //
 491     fNRecPoints = 0;
 492     if (fRecPoints) fRecPoints->Clear();
 493
 494 }
 495
 496 //_____________________________________________________________________________
 497 Int_t AliITS::DistancetoPrimitive(Int_t , Int_t ){
 498   //
 499   // Distance from mouse to ITS on the screen. Dummy routine
 500   //     A dummy routine used by the ROOT macro display.C to allow for the
 501   // use of the mouse (pointing device) in the macro. In general this should
 502   // never be called. If it is it returns the number 9999 for any value of
 503   // x and y.
 504   //
 505   return 9999;
 506 }
 507
 508 //_____________________________________________________________________________
 509 void AliITS::Init(){
 510   //
 511   // Initialise ITS after it has been built
 512   //     This routine initializes the AliITS class. It is intended to be called
 513   // from the Init function in AliITSv?. Besides displaying a banner
 514   // indicating that it has been called it initializes the array fIdSens
 515   // and sets the default segmentation, response, digit and raw cluster classes
 516   // Therefore it should be called after a call to CreateGeometry.
 517   //
 518
 519
 520   SetDefaults();
 521
 522   Int_t i;
 523   printf("\n");
 524   for(i=0;i<35;i++) printf("*");
 525   printf(" ITS_INIT ");
 526   for(i=0;i<35;i++) printf("*");
 527   printf("\n");
 528   //
 529   //
 530   for(i=0;i<fIdN;i++) fIdSens[i] = gMC->VolId(fIdName[i]);
 531   //
 532   for(i=0;i<80;i++) printf("*");
 533   printf("\n");
 534 }
 535
 536 //_____________________________________________________________________________
 537 void AliITS::SetDefaults()
 538 {
 539   // sets the default segmentation, response, digit and raw cluster classes
 540
 541
 542   AliITSDetType *iDetType;
 543
 544   //SPD
 545
 546   AliITSsegmentationSPD *seg0=new AliITSsegmentationSPD(fITSgeom);
 547   AliITSresponseSPD *resp0=new AliITSresponseSPD();
 548   iDetType=DetType(0);
 549   if (!iDetType->GetSegmentationModel()) SetSegmentationModel(0,seg0);
 550   if (!iDetType->GetResponseModel()) SetResponseModel(0,resp0);
 551   // set digit and raw cluster classes to be used
 552   const char *kData0=resp0->DataType();
 553   if (strstr(kData0,"real")) {
 554       iDetType->ClassNames("AliITSdigit","AliITSRawClusterSPD");
 555   } else iDetType->ClassNames("AliITSdigitSPD","AliITSRawClusterSPD");
 556
 557   // SDD                                          //
 558   AliITSresponseSDD *resp1=new AliITSresponseSDD();
 559   AliITSsegmentationSDD *seg1=new AliITSsegmentationSDD(fITSgeom,resp1);
 560   iDetType=DetType(1);
 561   if (!iDetType->GetSegmentationModel()) SetSegmentationModel(1,seg1);
 562   if (!iDetType->GetResponseModel()) SetResponseModel(1,resp1);
 563   const char *kData1=resp1->DataType();
 564   const char *kopt=resp1->ZeroSuppOption();
 565   if ((!strstr(kopt,"2D")) && (!strstr(kopt,"1D")) || strstr(kData1,"real") ) {
 566       iDetType->ClassNames("AliITSdigit","AliITSRawClusterSDD");
 567   } else iDetType->ClassNames("AliITSdigitSDD","AliITSRawClusterSDD");
 568
 569   // SSD
 570   AliITSsegmentationSSD *seg2=new AliITSsegmentationSSD(fITSgeom);
 571   AliITSresponseSSD *resp2=new AliITSresponseSSD();
 572   iDetType=DetType(2);
 573   if (!iDetType->GetSegmentationModel()) SetSegmentationModel(2,seg2);
 574   if (!iDetType->GetResponseModel()) SetResponseModel(2,resp2);
 575   const char *kData2=resp2->DataType();
 576   if (strstr(kData2,"real")) {
 577       iDetType->ClassNames("AliITSdigit","AliITSRawClusterSSD");
 578   } else iDetType->ClassNames("AliITSdigitSSD","AliITSRawClusterSSD");
 579
 580   if (fgkNTYPES>3) {
 581     Warning("SetDefaults","Only the three basic detector types are initialised!");
 582   }
 583
 584 }
 585
 586
 587 //_____________________________________________________________________________
 588 void AliITS::SetDefaultSimulation()
 589 {
 590   // to be written
 591
 592 }
 593 //_____________________________________________________________________________
 594 void AliITS::SetDefaultClusterFinders()
 595 {
 596   // to be written
 597
 598 }
 599 //_____________________________________________________________________________
 600
 601 void AliITS::MakeTreeC(Option_t *option)
 602 {
 603   // create a separate tree to store the clusters
 604
 605      char *optC = strstr(option,"C");
 606      if (optC && !fTreeC) fTreeC = new TTree("TC","Clusters in ITS");
 607
 608      Int_t buffersize = 4000;
 609      char branchname[30];
 610
 611      char *det[3] = {"SPD","SDD","SSD"};
 612
 613      // one branch for Clusters per type of detector
 614      Int_t i;
 615      for (i=0; i<fgkNTYPES ;i++) {
 616         if (fgkNTYPES==3) sprintf(branchname,"%sClusters%s",GetName(),det[i]);
 617         else  sprintf(branchname,"%sClusters%d",GetName(),i+1);
 618         if (fCtype   && fTreeC) {
 619            TreeC()->Branch(branchname,&((*fCtype)[i]), buffersize);
 620            printf("Making Branch %s for Clusters of detector type %d\n",branchname,i+1);
 621         }
 622      }
 623
 624 }
 625
 626 //_____________________________________________________________________________
 627 void AliITS::GetTreeC(Int_t event)
 628 {
 629
 630   // get the clusters tree for this event and set the branch address
 631     char treeName[20];
 632     char branchname[30];
 633
 634     char *det[3] = {"SPD","SDD","SSD"};
 635
 636     ResetClusters();
 637     if (fTreeC) {
 638           delete fTreeC;
 639     }
 640
 641     sprintf(treeName,"TreeC%d",event);
 642     fTreeC = (TTree*)gDirectory->Get(treeName);
 643
 644
 645     TBranch *branch;
 646     if (fTreeC) {
 647         Int_t i;
 648         for (i=0; i<fgkNTYPES; i++) {
 649            if (fgkNTYPES==3) sprintf(branchname,"%sClusters%s",GetName(),det[i]);
 650            else  sprintf(branchname,"%sClusters%d",GetName(),i+1);
 651            if (fCtype) {
 652                 branch = fTreeC->GetBranch(branchname);
 653                 if (branch) branch->SetAddress(&((*fCtype)[i]));
 654             }
 655         }
 656     } else {
 657         printf("ERROR: cannot find Clusters Tree for event:%d\n",event);
 658     }
 659
 660 }
 661 //_____________________________________________________________________________
 662 void AliITS::MakeBranch(Option_t* option){
 663   //
 664   // Creates Tree branches for the ITS.
 665   //
 666
 667
 668   Int_t buffersize = 4000;
 669   char branchname[30];
 670   sprintf(branchname,"%s",GetName());
 671
 672   AliDetector::MakeBranch(option);
 673
 674
 675 // one branch for digits per type of detector
 676
 677    char *det[3] = {"SPD","SDD","SSD"};
 678
 679    char digclass[40];
 680    char clclass[40];
 681
 682    Int_t i;
 683    for (i=0; i<fgkNTYPES ;i++) {
 684        AliITSDetType *iDetType=DetType(i);
 685        iDetType->GetClassNames(digclass,clclass);
 686        //printf("i, digclass, recclass %d %s %s\n",i,digclass,clclass);
 687        // digits
 688        (*fDtype)[i] = new TClonesArray(digclass,10000);
 689        // clusters
 690        (*fCtype)[i] = new TClonesArray(clclass,10000);
 691    }
 692
 693
 694   for (i=0; i<fgkNTYPES ;i++) {
 695       if (fgkNTYPES==3) sprintf(branchname,"%sDigits%s",GetName(),det[i]);
 696       else  sprintf(branchname,"%sDigits%d",GetName(),i+1);
 697
 698       if (fDtype   && gAlice->TreeD()) {
 699           gAlice->TreeD()->Branch(branchname,&((*fDtype)[i]), buffersize);
 700           printf("Making Branch %s for digits of type %d\n",branchname,i+1);
 701       }
 702   }
 703
 704   // only one branch for rec points for all detector types
 705   sprintf(branchname,"%sRecPoints",GetName());
 706
 707   fRecPoints=new TClonesArray("AliITSRecPoint",10000);
 708
 709   if (fRecPoints && gAlice->TreeR()) {
 710     gAlice->TreeR()->Branch(branchname,&fRecPoints, buffersize);
 711     printf("Making Branch %s for reconstructed space points\n",branchname);
 712   }
 713
 714
 715 }
 716
 717 //___________________________________________
 718 void AliITS::SetTreeAddress()
 719 {
 720
 721   // Set branch address for the Trees.
 722
 723   char branchname[30];
 724   AliDetector::SetTreeAddress();
 725
 726   char *det[3] = {"SPD","SDD","SSD"};
 727
 728   TBranch *branch;
 729   TTree *treeD = gAlice->TreeD();
 730   TTree *treeR = gAlice->TreeR();
 731
 732   Int_t i;
 733   if (treeD) {
 734       for (i=0; i<fgkNTYPES; i++) {
 735           if (fgkNTYPES==3) sprintf(branchname,"%sDigits%s",GetName(),det[i]);
 736           else  sprintf(branchname,"%sDigits%d",GetName(),i+1);
 737           if (fDtype) {
 738               branch = treeD->GetBranch(branchname);
 739               if (branch) branch->SetAddress(&((*fDtype)[i]));
 740           }
 741       }
 742   }
 743
 744
 745   if (treeR) {
 746     sprintf(branchname,"%sRecPoints",GetName());
 747     if (fRecPoints) {
 748       branch = treeR->GetBranch(branchname);
 749       if (branch) branch->SetAddress(&fRecPoints);
 750     }
 751   }
 752
 753
 754 }
 755
 756 //____________________________________________________________________________
 757 void AliITS::InitModules(Int_t size,Int_t &nmodules){
 758
 759   //initialize the modules array
 760
 761   if(fITSmodules){
 762     //this->ClearModules();
 763       delete fITSmodules;
 764   }
 765
 766     Int_t nl,indexMAX,index;
 767     Int_t indSPD,indSDD;
 768
 769     if(size<=0){ // default to using data stored in AliITSgeom
 770         if(fITSgeom==0) {
 771             printf("Error in AliITS::InitModule fITSgeom not defined\n");
 772             return;
 773         } // end if fITSgeom==0
 774         nl = fITSgeom->GetNlayers();
 775         indexMAX = fITSgeom->GetModuleIndex(nl,fITSgeom->GetNladders(nl),
 776                                             fITSgeom->GetNdetectors(nl))+1;
 777         nmodules = indexMAX;
 778         fITSmodules = new TObjArray(indexMAX);
 779         indSPD = fITSgeom->GetModuleIndex(2,fITSgeom->GetNladders(2),
 780                                             fITSgeom->GetNdetectors(2));
 781         indSDD = fITSgeom->GetModuleIndex(4,fITSgeom->GetNladders(4),
 782                                             fITSgeom->GetNdetectors(4));
 783         for(index=0;index<indexMAX;index++){
 784             if(index<=indSPD)
 785                 fITSmodules->AddAt( new AliITSmodule(index),index);
 786             else if(index<=indSDD)
 787                 fITSmodules->AddAt( new AliITSmodule(index),index);
 788             else
 789                 fITSmodules->AddAt( new AliITSmodule(index),index);
 790         } // end for index
 791     }else{
 792         fITSmodules = new TObjArray(size);
 793         nmodules = size;
 794     } // end i size<=0
 795 }
 796
 797 //____________________________________________________________________________
 798 void AliITS::FillModules(Int_t evnt,Int_t bgrev,Int_t nmodules,Option_t *option,Text_t *filename){
 799
 800   // fill the modules with the sorted by module hits; add hits from background
 801   // if option=Add
 802
 803     static TTree *trH1;                 //Tree with background hits
 804     static TClonesArray *fHits2;        //List of hits for one track only
 805
 806     static Bool_t first=kTRUE;
 807     static TFile *file;
 808     char *addBgr = strstr(option,"Add");
 809
 810
 811     if (addBgr ) {
 812         if(first) {
 813             cout<<"filename "<<filename<<endl;
 814             file=new TFile(filename);
 815             cout<<"I have opened "<<filename<<" file "<<endl;
 816             fHits2     = new TClonesArray("AliITShit",1000  );
 817         }
 818         first=kFALSE;
 819         file->cd();
 820         file->ls();
 821         // Get Hits Tree header from file
 822         if(fHits2) fHits2->Clear();
 823         if(trH1) delete trH1;
 824         trH1=0;
 825
 826         char treeName[20];
 827         sprintf(treeName,"TreeH%d",bgrev);
 828         trH1 = (TTree*)gDirectory->Get(treeName);
 829         //printf("TrH1 %p of treename %s for event %d \n",trH1,treeName,bgrev);
 830
 831         if (!trH1) {
 832             printf("ERROR: cannot find Hits Tree for event:%d\n",bgrev);
 833         }
 834         // Set branch addresses
 835         TBranch *branch;
 836         char branchname[20];
 837         sprintf(branchname,"%s",GetName());
 838         if (trH1 && fHits2) {
 839             branch = trH1->GetBranch(branchname);
 840             if (branch) branch->SetAddress(&fHits2);
 841         }
 842
 843         // test
 844         //Int_t ntracks1 =(Int_t)TrH1->GetEntries();
 845         //printf("background - ntracks1 - %d\n",ntracks1);
 846    }
 847
 848     Int_t npart = gAlice->GetEvent(evnt);
 849     if(npart<=0) return;
 850     TClonesArray *itsHits = this->Hits();
 851     Int_t lay,lad,det,index;
 852     AliITShit *itsHit=0;
 853     AliITSmodule *mod=0;
 854
 855     TTree *iTH = gAlice->TreeH();
 856     Int_t ntracks =(Int_t) iTH->GetEntries();
 857
 858     Int_t t,h;
 859     for(t=0; t<ntracks; t++){
 860         gAlice->ResetHits();
 861         iTH->GetEvent(t);
 862         Int_t nhits = itsHits->GetEntriesFast();
 863         if (!nhits) continue;
 864         for(h=0; h<nhits; h++){
 865             itsHit = (AliITShit *)itsHits->UncheckedAt(h);
 866             itsHit->GetDetectorID(lay,lad,det);
 867             index = fITSgeom->GetModuleIndex(lay,lad,det);
 868             mod = this->GetModule(index);
 869             if(lay == 1 || lay == 2)
 870                 mod->AddHit((AliITShit *) itsHit,t,h);
 871             else if(lay == 3 || lay == 4)
 872                     mod->AddHit((AliITShit *) itsHit,t,h);
 873             else if(lay == 5 || lay ==6)
 874                 mod->AddHit((AliITShit *)itsHit,t,h);
 875             else
 876                 mod->AddHit(itsHit,t,h);
 877
 878         } // end loop over hits
 879     } // end loop over tracks
 880
 881     // open the file with background
 882
 883     if (addBgr ) {
 884           Int_t track,i;
 885           ntracks =(Int_t)trH1->GetEntries();
 886             //printf("background - ntracks1 %d\n",ntracks);
 887             //printf("background - Start loop over tracks \n");
 888             //   Loop over tracks
 889
 890             for (track=0; track<ntracks; track++) {
 891
 892                 if (fHits2)       fHits2->Clear();
 893                 trH1->GetEvent(track);
 894                 //   Loop over hits
 895                 for(i=0;i<fHits2->GetEntriesFast();++i) {
 896
 897                     itsHit=(AliITShit*) (*fHits2)[i];
 898                     itsHit->GetDetectorID(lay,lad,det);
 899                     index = fITSgeom->GetModuleIndex(lay,lad,det);
 900                     mod = this->GetModule(index);
 901
 902                     if(lay == 1 || lay == 2)
 903                        mod->AddHit((AliITShit *) itsHit,track,i);
 904                     else if(lay == 3 || lay == 4)
 905                             mod->AddHit((AliITShit *) itsHit,track,i);
 906                     else if(lay == 5 || lay ==6)
 907                             mod->AddHit((AliITShit *)itsHit,track,i);
 908                     else
 909                        mod->AddHit(itsHit,track,i);
 910
 911
 912                }  // end loop over hits
 913             } // end loop over tracks
 914
 915             TTree *fAli=gAlice->TreeK();
 916             TFile *fileAli=0;
 917
 918             if (fAli) fileAli =fAli->GetCurrentFile();
 919             file->cd();
 920
 921     } // end if add
 922
 923     //gObjectTable->Print();
 924
 925 }
 926
 927
 928 //____________________________________________________________________________
 929 void AliITS::HitsToDigits(Int_t evNumber,Int_t bgrev,Int_t size, Option_t *option, Option_t *opt,Text_t *filename)
 930 {
 931     // keep galice.root for signal and name differently the file for
 932     // background when add! otherwise the track info for signal will be lost !
 933
 934    char *all = strstr(opt,"All");
 935    char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),strstr(opt,"SSD")};
 936
 937    Int_t nmodules;
 938    InitModules(size,nmodules);
 939    FillModules(evNumber,bgrev,nmodules,option,filename);
 940
 941    TBranch *branch;
 942    AliITSsimulation* sim;
 943
 944    TObjArray *branches=gAlice->TreeD()->GetListOfBranches();
 945    AliITSgeom *geom = GetITSgeom();
 946
 947    Int_t id,module;
 948    for (id=0;id<fgkNTYPES;id++) {
 949         if (!all && !det[id]) continue;
 950         branch = (TBranch*)branches->UncheckedAt(id);
 951         AliITSDetType *iDetType=DetType(id);
 952         sim = (AliITSsimulation*)iDetType->GetSimulationModel();
 953         if (!sim) {
 954            Error("HitsToDigits","The simulation class was not instantiated!");
 955            exit(1);
 956            // or SetDefaultSimulation();
 957         }
 958         Int_t first = geom->GetStartDet(id);
 959         Int_t last = geom->GetLastDet(id);
 960         printf("det type %d first, last %d %d \n",id,first,last);
 961         for(module=first;module<=last;module++) {
 962             AliITSmodule *mod = (AliITSmodule *)fITSmodules->At(module);
 963             sim->DigitiseModule(mod,module,evNumber);
 964             // fills all branches - wasted disk space
 965             gAlice->TreeD()->Fill();
 966             ResetDigits();
 967             // try and fill only the branch
 968             //branch->Fill();
 969             //ResetDigits(id);
 970         } // loop over modules
 971    } // loop over detector types
 972
 973    ClearModules();
 974
 975    Int_t nentries=(Int_t)gAlice->TreeD()->GetEntries();
 976    printf("nentries in TreeD %d\n",nentries);
 977
 978    char hname[30];
 979    sprintf(hname,"TreeD%d",evNumber);
 980    gAlice->TreeD()->Write(hname);
 981    // reset tree
 982    gAlice->TreeD()->Reset();
 983
 984 }
 985
 986
 987 //____________________________________________________________________________
 988 void AliITS::DigitsToRecPoints(Int_t evNumber,Int_t lastentry,Option_t *opt)
 989 {
 990   // cluster finding and reconstruction of space points
 991
 992    char *all = strstr(opt,"All");
 993    char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),strstr(opt,"SSD")};
 994
 995    static Bool_t first=kTRUE;
 996    if (first) {
 997        MakeTreeC("C");
 998        first=kFALSE;
 999    }
1000    TTree *iTC=TreeC();
1001
1002    TBranch *branch;
1003    AliITSClusterFinder* rec;
1004
1005    TObjArray *branches=gAlice->TreeR()->GetListOfBranches();
1006    AliITSgeom *geom = GetITSgeom();
1007
1008    Int_t id,module;
1009    for (id=0;id<fgkNTYPES;id++) {
1010         if (!all && !det[id]) continue;
1011         branch = (TBranch*)branches->UncheckedAt(id);
1012         AliITSDetType *iDetType=DetType(id);
1013         rec = (AliITSClusterFinder*)iDetType->GetReconstructionModel();
1014         if (!rec) {
1015            Error("DigitsToRecPoints","The cluster finder class was not instantiated!");
1016            exit(1);
1017            // or SetDefaultClusterFinders();
1018         }
1019         TClonesArray *itsDigits  = this->DigitsAddress(id);
1020
1021         Int_t first = geom->GetStartDet(id);
1022         Int_t last = geom->GetLastDet(id);
1023         for(module=first;module<=last;module++) {
1024               this->ResetDigits();
1025               if (all) gAlice->TreeD()->GetEvent(lastentry+module);
1026               else gAlice->TreeD()->GetEvent(lastentry+(module-first));
1027               Int_t ndigits = itsDigits->GetEntriesFast();
1028               if (ndigits) rec->FindRawClusters();
1029               gAlice->TreeR()->Fill();
1030               ResetRecPoints();
1031               iTC->Fill();
1032               ResetClusters();
1033               // try and fill only the branch
1034               //branch->Fill();
1035               //ResetRecPoints(id);
1036         } // loop over modules
1037    } // loop over detector types
1038
1039
1040    Int_t nentries=(Int_t)gAlice->TreeR()->GetEntries();
1041    Int_t ncentries=(Int_t)iTC->GetEntries();
1042    printf(" nentries ncentries %d %d\n", nentries, ncentries);
1043
1044    char hname[30];
1045    sprintf(hname,"TreeR%d",evNumber);
1046    gAlice->TreeR()->Write(hname);
1047    // reset tree
1048    gAlice->TreeR()->Reset();
1049
1050    sprintf(hname,"TreeC%d",evNumber);
1051    iTC->Write(hname);
1052    iTC->Reset();
1053 }
1054
1055
1056 //____________________________________________________________________________
1057 void AliITS::HitsToFastRecPoints(Int_t evNumber,Int_t bgrev,Int_t size,
1058 Option_t *option,Option_t *opt,Text_t *filename)
1059 {
1060     // keep galice.root for signal and name differently the file for
1061     // background when add! otherwise the track info for signal will be lost !
1062
1063    char *all = strstr(opt,"All");
1064    char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),strstr(opt,"SSD")};
1065
1066    Int_t nmodules;
1067    InitModules(size,nmodules);
1068    FillModules(evNumber,bgrev,nmodules,option,filename);
1069
1070
1071    AliITSsimulation* sim;
1072    AliITSgeom *geom = GetITSgeom();
1073
1074    TRandom *random=new TRandom[9];
1075    random[0].SetSeed(111);
1076    random[1].SetSeed(222);
1077    random[2].SetSeed(333);
1078    random[3].SetSeed(444);
1079    random[4].SetSeed(555);
1080    random[5].SetSeed(666);
1081    random[6].SetSeed(777);
1082    random[7].SetSeed(888);
1083    random[8].SetSeed(999);
1084
1085
1086    Int_t id,module;
1087    for (id=0;id<fgkNTYPES;id++) {
1088         if (!all && !det[id]) continue;
1089         AliITSDetType *iDetType=DetType(id);
1090         sim = (AliITSsimulation*)iDetType->GetSimulationModel();
1091         if (!sim) {
1092            Error("HitsToFastPoints","The simulation class was not instantiated!");
1093            exit(1);
1094            // or SetDefaultSimulation();
1095         }
1096         Int_t first = geom->GetStartDet(id);
1097         Int_t last = geom->GetLastDet(id);
1098         for(module=first;module<=last;module++) {
1099             AliITSmodule *mod = (AliITSmodule *)fITSmodules->At(module);
1100             sim->CreateFastRecPoints(mod,module,random);
1101             gAlice->TreeR()->Fill();
1102             ResetRecPoints();
1103         } // loop over modules
1104    } // loop over detector types
1105
1106
1107    ClearModules();
1108
1109    //Int_t nentries=(Int_t)gAlice->TreeR()->GetEntries();
1110
1111    char hname[30];
1112    sprintf(hname,"TreeR%d",evNumber);
1113    gAlice->TreeR()->Write(hname);
1114    // reset tree
1115    gAlice->TreeR()->Reset();
1116
1117    delete [] random;
1118
1119 }
1120
1121 //____________________________________________________________________________
1122 void AliITS::Streamer(TBuffer &R__b){
1123    // Stream an object of class AliITS.
1124
1125    Int_t i;
1126
1127    if (R__b.IsReading()) {
1128       Version_t R__v = R__b.ReadVersion();
1129       if (R__v) {
1130           AliDetector::Streamer(R__b);
1131           R__b >> fIdN;
1132           R__b.ReadArray(fIdSens);
1133           for(i=0;i<fIdN;i++) fIdName[i].Streamer(R__b);
1134           R__b >> fITSgeom;
1135           R__b >> fITSmodules;
1136           R__b >> fEuclidOut;
1137           R__b >> fMajorVersion;
1138           R__b >> fMinorVersion;
1139           R__b >> fDetTypes;
1140           R__b >> fDtype;
1141           delete []fNdtype;
1142           fNdtype = new Int_t[fgkNTYPES];
1143           R__b.ReadFastArray(fNdtype,fgkNTYPES);
1144           R__b >> fCtype;
1145           delete []fNctype;
1146           fNctype = new Int_t[fgkNTYPES];
1147           R__b.ReadFastArray(fNctype,fgkNTYPES);
1148           R__b >> fRecPoints;
1149           R__b >> fNRecPoints;
1150           R__b >> fTreeC;
1151       } // end if R__v
1152    } else { // writing
1153       R__b.WriteVersion(AliITS::IsA());
1154       AliDetector::Streamer(R__b);
1155       R__b << fIdN;
1156       R__b.WriteArray(fIdSens,fIdN);
1157       for(i=0;i<fIdN;i++) fIdName[i].Streamer(R__b);
1158       R__b << fITSgeom;
1159       R__b << fITSmodules;
1160       R__b << fEuclidOut;
1161       R__b << fMajorVersion;
1162       R__b << fMinorVersion;
1163       R__b << fDetTypes;
1164       R__b << fDtype;
1165       R__b.WriteFastArray(fNdtype,fgkNTYPES);
1166       R__b << fCtype;
1167       R__b.WriteFastArray(fNctype,fgkNTYPES);
1168       R__b << fRecPoints;
1169       R__b << fNRecPoints;
1170       R__b << fTreeC;
1171    } // end if
1172
1173 }
1174
1175