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 /* $Id$ */
  17
  18
  19 ///////////////////////////////////////////////////////////////////////////////
  20 //
  21 //      An overview of the basic philosophy of the ITS code development
  22 // and analysis is show in the figure below.
  23 //Begin_Html
  24 /*
  25 <img src="picts/ITS/ITS_Analysis_schema.gif">
  26 </pre>
  27 <br clear=left>
  28 <font size=+2 color=red>
  29 <p>Roberto Barbera is in charge of the ITS Offline code (1999).
  30 <a href="mailto:roberto.barbera@ct.infn.it">Roberto Barbera</a>.
  31 </font>
  32 <pre>
  33 */
  34 //End_Html
  35 //
  36 //  AliITS. Inner Traking System base class.
  37 //  This class contains the base procedures for the Inner Tracking System
  38 //
  39 //Begin_Html
  40 /*
  41 <img src="picts/ITS/AliITS_Class_Diagram.gif">
  42 </pre>
  43 <br clear=left>
  44 <font size=+2 color=red>
  45 <p>This show the class diagram of the different elements that are part of
  46 the AliITS class.
  47 </font>
  48 <pre>
  49 */
  50 //End_Html
  51 //
  52 // Version: 0
  53 // Written by Rene Brun, Federico Carminati, and Roberto Barbera
  54 //
  55 // Version: 1
  56 // Modified and documented by Bjorn S. Nilsen
  57 // July 11 1999
  58 //
  59 // Version: 2
  60 // Modified and documented by A. Bologna
  61 // October 18 1999
  62 //
  63 // AliITS is the general base class for the ITS. Also see AliDetector for
  64 // futher information.
  65 //
  66 ///////////////////////////////////////////////////////////////////////////////
  67
  68 #include <Riostream.h>
  69 #include <stdlib.h>
  70
  71 #include <TBranch.h>
  72 #include <TClonesArray.h>
  73 #include <TFile.h>
  74 #include <TMath.h>
  75 #include <TObjectTable.h>
  76 #include <TROOT.h>
  77 #include <TRandom.h>
  78 #include <TString.h>
  79 #include <TTree.h>
  80 #include <TVector.h>
  81 #include <TVirtualMC.h>
  82
  83 #include "AliConfig.h"
  84 #include "AliHeader.h"
  85 #include "AliITS.h"
  86 #include "AliITSClusterFinderSDD.h"
  87 #include "AliITSClusterFinderSPD.h"
  88 #include "AliITSClusterFinderSSD.h"
  89 #include "AliITSDetType.h"
  90 #include "AliITSLoader.h"
  91 #include "AliITSRawClusterSPD.h"
  92 #include "AliITSRawClusterSDD.h"
  93 #include "AliITSRawClusterSSD.h"
  94 #include "AliITSRecPoint.h"
  95 #include "AliITSdigitSPD.h"
  96 #include "AliITSdigitSDD.h"
  97 #include "AliITSdigitSSD.h"
  98 #include "AliITSgeom.h"
  99 #include "AliITShit.h"
 100 #include "AliITSmodule.h"
 101 #include "AliITSpList.h"
 102 #include "AliITSresponseSDD.h"
 103 #include "AliITSresponseSPD.h"
 104 #include "AliITSresponseSSD.h"
 105 #include "AliITSsegmentationSDD.h"
 106 #include "AliITSsegmentationSPD.h"
 107 #include "AliITSsegmentationSSD.h"
 108 #include "AliITSsimulationSDD.h"
 109 #include "AliITSsimulationSPD.h"
 110 #include "AliITSsimulationSSD.h"
 111 #include "AliMC.h"
 112 #include "AliITSDigitizer.h"
 113 #include "AliITSDDLRawData.h"
 114 #include "AliRun.h"
 115
 116 ClassImp(AliITS)
 117
 118 //______________________________________________________________________
 119 AliITS::AliITS() : AliDetector(),
 120     fITSgeom(0),
 121     fEuclidOut(0),
 122     fITSmodules(0),
 123     fOpt("All"),
 124     fIdN(0),
 125     fIdSens(0),
 126     fIdName(0),
 127     fNDetTypes(kNTYPES),
 128     fDetTypes(0),
 129     fSDigits(0),
 130     fNSDigits(0),
 131     fDtype(0),
 132     fNdtype(0),
 133     fCtype(0),
 134     fNctype(0),
 135     fRecPoints(0),
 136     fNRecPoints(0),
 137     fSelectedVertexer(0){
 138     // Default initializer for ITS
 139     //      The default constructor of the AliITS class. In addition to
 140     // creating the AliITS class it zeros the variables fIshunt (a member
 141     // of AliDetector class), fEuclidOut, and fIdN, and zeros the pointers
 142     // fITSpoints, fIdSens, and fIdName. The AliDetector default constructor
 143     // is also called.
 144     // Inputs:
 145     //      none.
 146     // Outputs:
 147     //      none.
 148     // Return:
 149     //      Blank ITS class.
 150
 151     fIshunt     = 0;   // not zeroed in AliDetector.
 152
 153     // AliITS variables.
 154 //    SetDetectors(); // default to fOpt="All". This variable not written out.
 155     SetMarkerColor(kRed);
 156     SelectVertexer(" ");
 157 }
 158 //______________________________________________________________________
 159 AliITS::AliITS(const char *name, const char *title):AliDetector(name,title),
 160     fITSgeom(0),
 161     fEuclidOut(0),
 162     fITSmodules(0),
 163     fOpt("All"),
 164     fIdN(0),
 165     fIdSens(0),
 166     fIdName(0),
 167     fNDetTypes(kNTYPES),
 168     fDetTypes(0),
 169     fSDigits(0),
 170     fNSDigits(0),
 171     fDtype(0),
 172     fNdtype(0),
 173     fCtype(0),
 174     fNctype(0),
 175     fRecPoints(0),
 176     fNRecPoints(0),
 177     fSelectedVertexer(0){
 178     //     The standard Constructor for the ITS class. In addition to
 179     // creating the AliITS class, it allocates memory for the TClonesArrays
 180     // fHits, fSDigits, fDigits, fITSpoints, and the TObjArray of fCtype
 181     // (clusters). It also zeros the variables
 182     // fIshunt (a member of AliDetector class), fEuclidOut, and fIdN, and zeros
 183     // the pointers fIdSens and fIdName. To help in displaying hits via the
 184     // ROOT macro display.C AliITS also sets the marker color to red. The
 185     // variables passes with this constructor, const char *name and *title,
 186     // are used by the constructor of AliDetector class. See AliDetector
 187     // class for a description of these parameters and its constructor
 188     // functions.
 189     // Inputs:
 190     //      const char *name      Detector name. Should always be "ITS"
 191     //      const char *title     Detector title.
 192     // Outputs:
 193     //      none.
 194     // Return:
 195     //      An ITS class.
 196
 197     fIshunt     = 0;  // not zeroed in AliDetector
 198     fHits       = new TClonesArray("AliITShit", 1560);//not done in AliDetector
 199     // Not done in AliDetector.
 200     if(gAlice->GetMCApp()) gAlice->GetMCApp()->AddHitList(fHits);
 201
 202     fEuclidOut  = 0;
 203     fITSgeom    = 0;
 204     fITSmodules = 0;
 205     SetDetectors(); // default to fOpt="All". This variable not written out.
 206
 207     fIdN        = 0;
 208     fIdName     = 0;
 209     fIdSens     = 0;
 210
 211     fNDetTypes  = kNTYPES;
 212     fDetTypes   = new TObjArray(fNDetTypes);
 213
 214     fSDigits    = new TClonesArray("AliITSpListItem",1000);
 215     fNSDigits   = 0;
 216
 217     fNdtype     = new Int_t[fNDetTypes];
 218     fDtype      = new TObjArray(fNDetTypes);
 219
 220     fCtype      = new TObjArray(fNDetTypes);
 221     fNctype     = new Int_t[fNDetTypes];
 222
 223     fRecPoints  = new TClonesArray("AliITSRecPoint",1000);
 224     fNRecPoints = 0;
 225
 226     Int_t i;
 227     for(i=0;i<fNDetTypes;i++) {
 228         fDetTypes->AddAt(new AliITSDetType(),i);
 229         fNdtype[i] = 0;
 230         fNctype[i] = 0;
 231     } // end for i
 232
 233     SetMarkerColor(kRed);
 234     SelectVertexer(" ");
 235 }
 236 //______________________________________________________________________
 237 AliITS::~AliITS(){
 238     // Default destructor for ITS.
 239     //     The default destructor of the AliITS class. In addition to deleting
 240     // the AliITS class it deletes the memory pointed to by the fHits, fDigits,
 241     // fSDigits, fCtype, fITSmodules, fITSgeom, fRecPoints, fIdSens, fIdName,
 242     // fITSpoints, fDetType and it's contents.
 243     // Inputs:
 244     //      none.
 245     // Outputs:
 246     //      none.
 247     // Return:
 248     //      none.
 249
 250     if (fHits) {
 251       fHits->Delete();
 252       delete fHits;
 253       fHits=0;
 254     }
 255     if (fSDigits) {
 256       fSDigits->Delete();
 257       delete fSDigits;
 258       fSDigits=0;
 259     }
 260     if (fDigits) {
 261       fDigits->Delete();
 262       delete fDigits;
 263       fDigits=0;
 264     }
 265     if (fRecPoints) {
 266       fRecPoints->Delete();
 267       delete fRecPoints;
 268       fRecPoints=0;
 269     }
 270     delete[] fIdName;  // Array of TStrings
 271     delete[] fIdSens;
 272     if(fITSmodules) {
 273         this->ClearModules();
 274         delete fITSmodules;
 275         fITSmodules = 0;
 276     }// end if fITSmodules!=0
 277
 278     if(fDtype) {
 279         fDtype->Delete();
 280         delete fDtype;
 281     } // end if fDtype
 282     delete [] fNdtype;
 283     if (fCtype) {
 284         fCtype->Delete();
 285         delete fCtype;
 286         fCtype = 0;
 287     } // end if fCtype
 288     delete [] fNctype;
 289
 290     if (fDetTypes) {
 291         fDetTypes->Delete();
 292         delete fDetTypes;
 293         fDetTypes = 0;
 294     } // end if fDetTypes
 295
 296
 297     if (fITSgeom) delete fITSgeom;
 298 }
 299 //______________________________________________________________________
 300 AliITS::AliITS(const AliITS &source) : AliDetector(source){
 301     // Copy constructor. This is a function which is not allowed to be
 302     // done to the ITS. It exits with an error.
 303     // Inputs:
 304     //      AliITS &source  An AliITS class.
 305     // Outputs:
 306     //      none.
 307     // Return:
 308     //      none.
 309
 310     if(this==&source) return;
 311     Error("Copy constructor",
 312           "You are not allowed to make a copy of the AliITS");
 313     exit(1);
 314 }
 315 //______________________________________________________________________
 316 AliITS& AliITS::operator=(AliITS &source){
 317     // Assignment operator. This is a function which is not allowed to be
 318     // done to the ITS. It exits with an error.
 319     // Inputs:
 320     //      AliITS &source  An AliITS class.
 321     // Outputs:
 322     //      none.
 323     // Return:
 324     //      none.
 325
 326     if(this==&source) return *this;
 327     Error("operator=","You are not allowed to make a copy of the AliITS");
 328     exit(1);
 329     return *this; //fake return
 330 }
 331 //______________________________________________________________________
 332 AliDigitizer* AliITS::CreateDigitizer(AliRunDigitizer* manager)const{
 333     // Creates the AliITSDigitizer in a standard way for use via AliModule.
 334     // This function can not be included in the .h file because of problems
 335     // with the order of inclusion (recursive).
 336     // Inputs:
 337     //    AliRunDigitizer *manager  The Manger class for Digitization
 338     // Output:
 339     //    none.
 340     // Return:
 341     //    A new AliITSRunDigitizer (cast as a AliDigitizer).
 342
 343      return new AliITSDigitizer(manager);
 344 }
 345 //______________________________________________________________________
 346 void AliITS::Init(){
 347     // Initializer ITS after it has been built
 348     //     This routine initializes the AliITS class. It is intended to be
 349     // called from the Init function in AliITSv?. Besides displaying a banner
 350     // indicating that it has been called it initializes the array fIdSens
 351     // and sets the default segmentation, response, digit and raw cluster
 352     // classes therefore it should be called after a call to CreateGeometry.
 353     // Inputs:
 354     //      none.
 355     // Outputs:
 356     //      none.
 357     // Return:
 358     //      none.
 359     Int_t i;
 360
 361     SetDefaults();
 362     // Array of TStrings
 363     if(gMC) for(i=0;i<fIdN;i++) fIdSens[i] = gMC->VolId(fIdName[i]);
 364 }
 365 //______________________________________________________________________
 366 void AliITS::SetDefaults(){
 367     // sets the default segmentation, response, digit and raw cluster classes.
 368     // Inputs:
 369     //      none.
 370     // Outputs:
 371     //      none.
 372     // Return:
 373     //      none.
 374     AliITSsegmentation *seg;
 375     AliITSresponse    *resp;
 376     AliITSDetType *iDetType;
 377
 378     if(fDebug) Info("SetDefauls","%s: SetDefaults",ClassName());
 379
 380     //SPD
 381     iDetType = DetType(kSPD);
 382     if(iDetType){
 383         if (!iDetType->GetSegmentationModel()) {
 384             seg = new AliITSsegmentationSPD(fITSgeom);
 385             SetSegmentationModel(kSPD,seg);
 386         } // end if
 387         if (!iDetType->GetResponseModel()) {
 388             SetResponseModel(kSPD,new AliITSresponseSPD());
 389         } // end if
 390         // set digit and raw cluster classes to be used
 391
 392         const char *kData0=(iDetType->GetResponseModel())->DataType();
 393         if (strstr(kData0,"real")) {
 394             iDetType->ClassNames("AliITSdigit","AliITSRawClusterSPD");
 395         } else iDetType->ClassNames("AliITSdigitSPD","AliITSRawClusterSPD");
 396     } // end if iDetType
 397
 398     // SDD
 399     iDetType = DetType(kSDD);
 400     if(iDetType){
 401         if (!iDetType->GetResponseModel()) {
 402             SetResponseModel(kSDD,new AliITSresponseSDD("simulated"));
 403         } // end if
 404         resp = iDetType->GetResponseModel();
 405         if (!iDetType->GetSegmentationModel()) {
 406             seg = new AliITSsegmentationSDD(fITSgeom,resp);
 407             SetSegmentationModel(kSDD,seg);
 408         } // end if
 409         const char *kData1 = (iDetType->GetResponseModel())->DataType();
 410         const char *kopt = iDetType->GetResponseModel()->ZeroSuppOption();
 411         if((!strstr(kopt,"2D"))&&(!strstr(kopt,"1D")) ||
 412                                    strstr(kData1,"real") ){
 413             iDetType->ClassNames("AliITSdigit","AliITSRawClusterSDD");
 414         } else iDetType->ClassNames("AliITSdigitSDD","AliITSRawClusterSDD");
 415     } // end if iDetType
 416
 417     // SSD
 418     iDetType = DetType(kSSD);
 419     if(iDetType){
 420         if (!iDetType->GetSegmentationModel()) {
 421             seg = new AliITSsegmentationSSD(fITSgeom);
 422             SetSegmentationModel(kSSD,seg);
 423         } // end if
 424         if (!iDetType->GetResponseModel()) {
 425             SetResponseModel(kSSD,new AliITSresponseSSD("simulated"));
 426         } // end if
 427         const char *kData2 = (iDetType->GetResponseModel())->DataType();
 428         if (strstr(kData2,"real")) {
 429             iDetType->ClassNames("AliITSdigit","AliITSRawClusterSSD");
 430         } else iDetType->ClassNames("AliITSdigitSSD","AliITSRawClusterSSD");
 431     } // end if iDetType
 432
 433     if (kNTYPES>3) {
 434         Warning("SetDefaults",
 435                 "Only the three basic detector types are initialized!");
 436     }  // end if
 437 }
 438 //______________________________________________________________________
 439 void AliITS::SetDefaultSimulation(){
 440     // sets the default simulation.
 441     // Inputs:
 442     //      none.
 443     // Outputs:
 444     //      none.
 445     // Return:
 446     //      none.
 447     AliITSDetType *iDetType;
 448     AliITSsimulation *sim;
 449     AliITSsegmentation *seg;
 450     AliITSresponse *res;
 451
 452     iDetType = DetType(kSPD);
 453     if(iDetType){
 454         sim = iDetType->GetSimulationModel();
 455         if (!sim) {
 456             seg = (AliITSsegmentation*)iDetType->GetSegmentationModel();
 457             res = (AliITSresponse*)iDetType->GetResponseModel();
 458             sim = new AliITSsimulationSPD(seg,res);
 459             SetSimulationModel(kSPD,sim);
 460         }else{ // simulation exists, make sure it is set up properly.
 461             if(sim->GetResponseModel()==0) sim->SetResponseModel(
 462                 (AliITSresponse*)iDetType->GetResponseModel());
 463             if(sim->GetSegmentationModel()==0) sim->SetSegmentationModel(
 464                 (AliITSsegmentation*)iDetType->GetSegmentationModel());
 465             sim->Init();
 466         } // end if
 467     }// end if iDetType
 468     iDetType  = DetType(kSDD);
 469     if(iDetType){
 470         sim = iDetType->GetSimulationModel();
 471         if (!sim) {
 472             seg = (AliITSsegmentation*)iDetType->GetSegmentationModel();
 473             res =  (AliITSresponse*)iDetType->GetResponseModel();
 474             sim = new AliITSsimulationSDD(seg,res);
 475             SetSimulationModel(kSDD,sim);
 476         }else{ // simulation exists, make sure it is set up properly.
 477             if(sim->GetResponseModel()==0) sim->SetResponseModel(
 478                 (AliITSresponse*)iDetType->GetResponseModel());
 479             if(sim->GetSegmentationModel()==0) sim->SetSegmentationModel(
 480                 (AliITSsegmentation*)iDetType->GetSegmentationModel());
 481             sim->Init();
 482         } //end if
 483     }// end if iDetType
 484     iDetType = DetType(kSSD);
 485     if(iDetType){
 486         sim = iDetType->GetSimulationModel();
 487         if (!sim) {
 488             seg =(AliITSsegmentation*)iDetType->GetSegmentationModel();
 489             res =  (AliITSresponse*)iDetType->GetResponseModel();
 490             sim = new AliITSsimulationSSD(seg,res);
 491             SetSimulationModel(kSSD,sim);
 492         }else{ // simulation exists, make sure it is set up properly.
 493             if(sim->GetResponseModel()==0) sim->SetResponseModel(
 494                 (AliITSresponse*)iDetType->GetResponseModel());
 495             if(sim->GetSegmentationModel()==0) sim->SetSegmentationModel(
 496                 (AliITSsegmentation*)iDetType->GetSegmentationModel());
 497             sim->Init();
 498         } // end if
 499     } // end if iDetType
 500 }
 501 //______________________________________________________________________
 502 void AliITS::SetDefaultClusterFinders(){
 503     // Sets the default cluster finders. Used in finding RecPoints.
 504     // Inputs:
 505     //      none.
 506     // Outputs:
 507     //      none.
 508     // Return:
 509     //      none.
 510     AliITSDetType *iDetType;
 511     AliITSsegmentation *seg;
 512     AliITSClusterFinder *clf;
 513     AliITSresponse *res;
 514
 515     MakeTreeC();
 516
 517     // SPD
 518     iDetType=DetType(kSPD);
 519     if(iDetType){
 520         if (!iDetType->GetReconstructionModel()) {
 521             seg =(AliITSsegmentation*)iDetType->GetSegmentationModel();
 522             TClonesArray  *dig0 = DigitsAddress(0);
 523             TClonesArray *recp0 = ClustersAddress(0);
 524             clf = new AliITSClusterFinderSPD(seg,dig0,recp0);
 525             SetReconstructionModel(kSPD,clf);
 526         } // end if
 527     } // end if iDetType
 528
 529     // SDD
 530     iDetType=DetType(kSDD);
 531     if(iDetType){
 532         if (!iDetType->GetReconstructionModel()) {
 533             seg = (AliITSsegmentation*)iDetType->GetSegmentationModel();
 534             res = (AliITSresponse*)iDetType->GetResponseModel();
 535             TClonesArray  *dig1 = DigitsAddress(1);
 536             TClonesArray *recp1 = ClustersAddress(1);
 537             clf = new AliITSClusterFinderSDD(seg,res,dig1,recp1);
 538             SetReconstructionModel(kSDD,clf);
 539         } // end if
 540     } // end if iDetType
 541
 542     // SSD
 543     iDetType=DetType(kSSD);
 544     if(iDetType){
 545         if (!iDetType->GetReconstructionModel()) {
 546             seg = (AliITSsegmentation*)iDetType->GetSegmentationModel();
 547             TClonesArray *dig2 = DigitsAddress(2);
 548             clf = new AliITSClusterFinderSSD(seg,dig2);
 549             SetReconstructionModel(kSSD,clf);
 550         } // end if
 551     } // end if iDetType
 552 }
 553 //______________________________________________________________________
 554 void AliITS::MakeBranch(Option_t* option){
 555     // Creates Tree branches for the ITS.
 556     // Inputs:
 557     //      Option_t *option    String of Tree types S,D, and/or R.
 558     //      const char *file    String of the file name where these branches
 559     //                          are to be stored. If blank then these branches
 560     //                          are written to the same tree as the Hits were
 561     //                          read from.
 562     // Outputs:
 563     //      none.
 564     // Return:
 565     //      none.
 566     Bool_t cH = (strstr(option,"H")!=0);
 567     Bool_t cS = (strstr(option,"S")!=0);
 568     Bool_t cD = (strstr(option,"D")!=0);
 569     Bool_t cR = (strstr(option,"R")!=0);
 570     Bool_t cRF = (strstr(option,"RF")!=0);
 571
 572     if(cRF)cR = kFALSE;
 573     if(cH && (fHits == 0x0)) fHits  = new TClonesArray("AliITShit", 1560);
 574
 575     AliDetector::MakeBranch(option);
 576
 577     if(cS) MakeBranchS(0);
 578     if(cD) MakeBranchD(0);
 579     if(cR) MakeBranchR(0);
 580     if(cRF) MakeBranchRF(0);
 581 }
 582 //______________________________________________________________________
 583 void AliITS::SetTreeAddress(){
 584     // Set branch address for the Trees.
 585     // Inputs:
 586     //      none.
 587     // Outputs:
 588     //      none.
 589     // Return:
 590     //      none.
 591     TTree *treeS = fLoader->TreeS();
 592     TTree *treeD = fLoader->TreeD();
 593     TTree *treeR = fLoader->TreeR();
 594     if (fLoader->TreeH() && (fHits == 0x0))
 595         fHits = new TClonesArray("AliITShit", 1560);
 596
 597     AliDetector::SetTreeAddress();
 598
 599     SetTreeAddressS(treeS);
 600     SetTreeAddressD(treeD);
 601     SetTreeAddressR(treeR);
 602 }
 603 //______________________________________________________________________
 604 void AliITS::AddHit(Int_t track, Int_t *vol, Float_t *hits){
 605     // Add an ITS hit
 606     //     The function to add information to the AliITShit class. See the
 607     // AliITShit class for a full description. This function allocates the
 608     // necessary new space for the hit information and passes the variable
 609     // track, and the pointers *vol and *hits to the AliITShit constructor
 610     // function.
 611     // Inputs:
 612     //      Int_t   track   Track number which produced this hit.
 613     //      Int_t   *vol    Array of Integer Hit information. See AliITShit.h
 614     //      Float_t *hits   Array of Floating Hit information.  see AliITShit.h
 615     // Outputs:
 616     //      none.
 617     // Return:
 618     //      none.
 619
 620     TClonesArray &lhits = *fHits;
 621     new(lhits[fNhits++]) AliITShit(fIshunt,track,vol,hits);
 622 }
 623 //______________________________________________________________________
 624 void AliITS::InitModules(Int_t size,Int_t &nmodules){
 625     // Initialize the modules array.
 626     // Inputs:
 627     //      Int_t size  Size of array of the number of modules to be
 628     //                  created. If size <=0 then the number of modules
 629     //                  is gotten from AliITSgeom class kept in fITSgeom.
 630     // Outputs:
 631     //      Int_t &nmodules The number of modules existing.
 632     // Return:
 633     //      none.
 634
 635     if(fITSmodules){
 636         fITSmodules->Delete();
 637         delete fITSmodules;
 638     } // end fir fITSmoudles
 639
 640     Int_t nl,indexMAX,index;
 641
 642     if(size<=0){ // default to using data stored in AliITSgeom
 643         if(fITSgeom==0) {
 644             Error("InitModules","fITSgeom not defined");
 645             return;
 646         } // end if fITSgeom==0
 647         nl = fITSgeom->GetNlayers();
 648         indexMAX = fITSgeom->GetModuleIndex(nl,fITSgeom->GetNladders(nl),
 649                                             fITSgeom->GetNdetectors(nl))+1;
 650         nmodules = indexMAX;
 651         fITSmodules = new TObjArray(indexMAX);
 652         for(index=0;index<indexMAX;index++){
 653             fITSmodules->AddAt( new AliITSmodule(index),index);
 654         } // end for index
 655     }else{
 656         fITSmodules = new TObjArray(size);
 657         for(index=0;index<size;index++) {
 658             fITSmodules->AddAt( new AliITSmodule(index),index);
 659         } // end for index
 660
 661         nmodules = size;
 662     } // end i size<=0
 663 }
 664 //______________________________________________________________________
 665 void AliITS::FillModules(Int_t evnt,Int_t bgrev,Int_t nmodules,
 666                          Option_t *option, const char *filename){
 667     // fill the modules with the sorted by module hits; add hits from
 668     // background if option=Add.
 669     // Inputs:
 670     //      Int_t evnt       Event to be processed.
 671     //      Int_t bgrev      Background Hit tree number.
 672     //      Int_t nmodules   Not used.
 673     //      Option_t *option String indicating if merging hits or not. To
 674     //                       merge hits set equal to "Add". Otherwise no
 675     //                       background hits are considered.
 676     //      Test_t *filename File name containing the background hits..
 677     // Outputs:
 678     //      none.
 679     // Return:
 680     //      none.
 681     static TTree *trH1;                 //Tree with background hits
 682     static Bool_t first=kTRUE;
 683     static TFile *file;
 684     const char *addBgr = strstr(option,"Add");
 685
 686     evnt = nmodules; // Dummy use of variables to remove warnings
 687     if (addBgr ) {
 688         if(first) {
 689             file=new TFile(filename);
 690         } // end if first
 691         first=kFALSE;
 692         file->cd();
 693         file->ls();
 694         // Get Hits Tree header from file
 695         if(trH1) delete trH1;
 696         trH1=0;
 697
 698         char treeName[20];
 699         sprintf(treeName,"TreeH%d",bgrev);
 700         trH1 = (TTree*)gDirectory->Get(treeName);
 701         if (!trH1) {
 702             Error("FillModules","cannot find Hits Tree for event:%d",bgrev);
 703         } // end if !trH1
 704         // Set branch addresses
 705     } // end if addBgr
 706
 707     FillModules(fLoader->TreeH(),0); // fill from this file's tree.
 708
 709     if (addBgr ) {
 710         FillModules(trH1,10000000); // Default mask 10M.
 711         TTree *fAli=fLoader->GetRunLoader()->TreeK();
 712         TFile *fileAli=0;
 713         if (fAli) fileAli =fAli->GetCurrentFile();
 714         fileAli->cd();
 715     } // end if add
 716 }
 717 //______________________________________________________________________
 718 void AliITS::FillModules(TTree *treeH, Int_t mask) {
 719     // fill the modules with the sorted by module hits;
 720     // can be called many times to do a merging
 721     // Inputs:
 722     //      TTree *treeH  The tree containing the hits to be copied into
 723     //                    the modules.
 724     //      Int_t mask    The track number mask to indecate which file
 725     //                    this hits came from.
 726     // Outputs:
 727     //      none.
 728     // Return:
 729     //      none.
 730
 731     if (treeH == 0x0)
 732      {
 733        Error("FillModules","Tree is NULL");
 734      }
 735     Int_t lay,lad,det,index;
 736     AliITShit *itsHit=0;
 737     AliITSmodule *mod=0;
 738     char branchname[20];
 739     sprintf(branchname,"%s",GetName());
 740     TBranch *branch = treeH->GetBranch(branchname);
 741     if (!branch) {
 742         Error("FillModules","%s branch in TreeH not found",branchname);
 743         return;
 744     } // end if !branch
 745     branch->SetAddress(&fHits);
 746     Int_t nTracks =(Int_t) treeH->GetEntries();
 747     Int_t iPrimTrack,h;
 748     for(iPrimTrack=0; iPrimTrack<nTracks; iPrimTrack++){
 749         ResetHits();
 750         Int_t nBytes = treeH->GetEvent(iPrimTrack);
 751         if (nBytes <= 0) continue;
 752         Int_t nHits = fHits->GetEntriesFast();
 753         for(h=0; h<nHits; h++){
 754             itsHit = (AliITShit *)fHits->UncheckedAt(h);
 755             itsHit->GetDetectorID(lay,lad,det);
 756             if (fITSgeom) {
 757                 index = fITSgeom->GetModuleIndex(lay,lad,det);
 758             } else {
 759                 index=det-1; // This should not be used.
 760             } // end if [You must have fITSgeom for this to work!]
 761             mod = GetModule(index);
 762             itsHit->SetTrack(itsHit->GetTrack()+mask); // Set track mask.
 763             mod->AddHit(itsHit,iPrimTrack,h);
 764         } // end loop over hits
 765     } // end loop over tracks
 766 }
 767 //______________________________________________________________________
 768 void AliITS::MakeBranchS(const char *fl){
 769     // Creates Tree Branch for the ITS summable digits.
 770     // Inputs:
 771     //      cont char *fl  File name where SDigits branch is to be written
 772     //                     to. If blank it write the SDigits to the same
 773     //                     file in which the Hits were found.
 774     // Outputs:
 775     //      none.
 776     // Return:
 777     //      none.
 778     Int_t buffersize = 4000;
 779     char branchname[30];
 780
 781     // only one branch for SDigits.
 782     sprintf(branchname,"%s",GetName());
 783
 784
 785     if(fLoader->TreeS()){
 786         if(fSDigits==0x0) fSDigits = new TClonesArray("AliITSpListItem",1000);
 787         MakeBranchInTree(fLoader->TreeS(),branchname,&fSDigits,buffersize,fl);
 788     } // end if
 789 }
 790 //______________________________________________________________________
 791 void AliITS::SetTreeAddressS(TTree *treeS){
 792     // Set branch address for the ITS summable digits Trees.
 793     // Inputs:
 794     //      TTree *treeS   Tree containing the SDigits.
 795     // Outputs:
 796     //      none.
 797     // Return:
 798     //      none.
 799     char branchname[30];
 800
 801     if(!treeS) return;
 802     if (fSDigits == 0x0)  fSDigits = new TClonesArray("AliITSpListItem",1000);
 803     TBranch *branch;
 804     sprintf(branchname,"%s",GetName());
 805     branch = treeS->GetBranch(branchname);
 806     if (branch) branch->SetAddress(&fSDigits);
 807 }
 808 //______________________________________________________________________
 809 void AliITS::MakeBranchInTreeD(TTree *treeD,const char *file){
 810     // Creates Tree branches for the ITS.
 811     // Inputs:
 812     //      TTree     *treeD Pointer to the Digits Tree.
 813     //      cont char *file  File name where Digits branch is to be written
 814     //                       to. If blank it write the SDigits to the same
 815     //                       file in which the Hits were found.
 816     // Outputs:
 817     //      none.
 818     // Return:
 819     //      none.
 820     // one branch for digits per type of detector
 821     const Char_t *det[3] = {"SPD","SDD","SSD"};
 822     TString digclass;
 823     Int_t i;
 824     Int_t buffersize = 4000;
 825     Char_t branchname[30];
 826
 827     if (fDtype == 0x0) fDtype = new TObjArray(fNDetTypes);
 828     for (i=0; i<kNTYPES ;i++) {
 829         digclass = DetType(i)->GetDigitClassName();
 830         // digits
 831         if(!(fDtype->At(i))){
 832             fDtype->AddAt(new TClonesArray(digclass.Data(),1000),i);
 833         }else{
 834             ResetDigits(i);
 835         } // end if
 836         if (kNTYPES==3) sprintf(branchname,"%sDigits%s",GetName(),det[i]);
 837         else  sprintf(branchname,"%sDigits%d",GetName(),i+1);
 838         if (fDtype && treeD) {
 839             MakeBranchInTree(treeD,branchname,&((*fDtype)[i]),buffersize,file);
 840         } // end if
 841     } // end for i
 842          /*
 843     for (i=0; i<kNTYPES ;i++) {
 844         if (kNTYPES==3) sprintf(branchname,"%sDigits%s",GetName(),det[i]);
 845         else  sprintf(branchname,"%sDigits%d",GetName(),i+1);
 846         if (fDtype && treeD) {
 847             MakeBranchInTree(treeD,branchname,&((*fDtype)[i]),buffersize,file);
 848         } // end if
 849     } // end for i
 850          */
 851 }
 852 //______________________________________________________________________
 853 void AliITS::SetTreeAddressD(TTree *treeD){
 854     // Set branch address for the Trees.
 855     // Inputs:
 856     //      TTree *treeD   Tree containing the Digits.
 857     // Outputs:
 858     //      none.
 859     // Return:
 860     //      none.
 861     const char *det[3] = {"SPD","SDD","SSD"};
 862     TBranch *branch;
 863     TString digclass;
 864     Int_t i;
 865     char branchname[30];
 866
 867     if(!treeD) return;
 868     if (fDtype == 0x0) fDtype = new TObjArray(fNDetTypes);
 869     for (i=0; i<kNTYPES; i++) {
 870         digclass = DetType(i)->GetDigitClassName();
 871         // digits
 872         if(!(fDtype->At(i))) {
 873             fDtype->AddAt(new TClonesArray(digclass.Data(),1000),i);
 874         }else{
 875             ResetDigits(i);
 876         } // end if
 877         if (kNTYPES==3) sprintf(branchname,"%sDigits%s",GetName(),det[i]);
 878         else  sprintf(branchname,"%sDigits%d",GetName(),i+1);
 879         if (fDtype) {
 880             branch = treeD->GetBranch(branchname);
 881             if (branch) branch->SetAddress(&((*fDtype)[i]));
 882         } // end if fDtype
 883     } // end for i
 884 }
 885 //______________________________________________________________________
 886 void AliITS::Hits2SDigits(){
 887     // Standard Hits to summable Digits function.
 888     // Inputs:
 889     //      none.
 890     // Outputs:
 891     //      none.
 892
 893     fLoader->LoadHits("read");
 894     fLoader->LoadSDigits("recreate");
 895     AliRunLoader* rl = fLoader->GetRunLoader();
 896
 897     for (Int_t iEvent = 0; iEvent < rl->GetNumberOfEvents(); iEvent++) {
 898         // Do the Hits to Digits operation. Use Standard input values.
 899         // Event number from file, no background hit merging , use size from
 900         // AliITSgeom class, option="All", input from this file only.
 901         rl->GetEvent(iEvent);
 902         if (!fLoader->TreeS()) fLoader->MakeTree("S");
 903         MakeBranch("S");
 904         SetTreeAddress();
 905         HitsToPreDigits(iEvent,0,-1," ",fOpt," ");
 906     } // end for iEvent
 907
 908     fLoader->UnloadHits();
 909     fLoader->UnloadSDigits();
 910 }
 911 //______________________________________________________________________
 912 void AliITS::SDigitsToDigits(Option_t *opt){
 913     // Standard Summable digits to Digits function.
 914     // Inputs:
 915     //      none.
 916     // Outputs:
 917     //      none.
 918     char name[20] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
 919
 920     if(!GetITSgeom()) return; // need transformations to do digitization.
 921     AliITSgeom *geom = GetITSgeom();
 922
 923     const char *all = strstr(opt,"All");
 924     const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),
 925                           strstr(opt,"SSD")};
 926     if( !det[0] && !det[1] && !det[2] ) all = "All";
 927     else all = 0;
 928     static Bool_t setDef = kTRUE;
 929     if(setDef) SetDefaultSimulation();
 930     setDef = kFALSE;
 931
 932     AliITSsimulation *sim      = 0;
 933     AliITSDetType    *iDetType = 0;
 934     TTree            *trees    = fLoader->TreeS();
 935     if( !(trees && this->GetSDigits()) ){
 936         Error("SDigits2Digits","Error: No trees or SDigits. Returning.");
 937         return;
 938     } // end if
 939     sprintf( name, "%s", this->GetName() );
 940     TBranch *brchSDigits = trees->GetBranch( name );
 941
 942     Int_t id,module;
 943     for(module=0;module<geom->GetIndexMax();module++){
 944         id       = geom->GetModuleType(module);
 945         if (!all && !det[id]) continue;
 946         iDetType = DetType(id);
 947         sim      = (AliITSsimulation*)iDetType->GetSimulationModel();
 948         if (!sim) {
 949             Error("SDigit2Digits","The simulation class was not "
 950                   "instanciated for module %d type %s!",module,
 951                   geom->GetModuleTypeName(module));
 952             exit(1);
 953         } // end if !sim
 954         sim->InitSimulationModule(module,gAlice->GetEvNumber());
 955         //
 956         // add summable digits to module
 957         this->GetSDigits()->Clear();
 958         brchSDigits->GetEvent(module);
 959         sim->AddSDigitsToModule(GetSDigits(),0);
 960         //
 961         // Digitise current module sum(SDigits)->Digits
 962         sim->FinishSDigitiseModule();
 963
 964         // fills all branches - wasted disk space
 965         fLoader->TreeD()->Fill();
 966         this->ResetDigits();
 967     } // end for module
 968
 969     fLoader->TreeD()->GetEntries();
 970
 971     fLoader->TreeD()->AutoSave();
 972     // reset tree
 973     fLoader->TreeD()->Reset();
 974
 975 }
 976 //______________________________________________________________________
 977 void AliITS::Hits2Digits(){
 978     // Standard Hits to Digits function.
 979     // Inputs:
 980     //      none.
 981     // Outputs:
 982     //      none.
 983
 984     fLoader->LoadHits("read");
 985     fLoader->LoadDigits("recreate");
 986     AliRunLoader* rl = fLoader->GetRunLoader();
 987
 988     for (Int_t iEvent = 0; iEvent < rl->GetNumberOfEvents(); iEvent++) {
 989         // Do the Hits to Digits operation. Use Standard input values.
 990         // Event number from file, no background hit merging , use size from
 991         // AliITSgeom class, option="All", input from this file only.
 992         rl->GetEvent(iEvent);
 993         if (!fLoader->TreeD()) fLoader->MakeTree("D");
 994         MakeBranch("D");
 995         SetTreeAddress();
 996         HitsToDigits(iEvent,0,-1," ",fOpt," ");
 997     } // end for iEvent
 998
 999     fLoader->UnloadHits();
1000     fLoader->UnloadDigits();
1001 }
1002 //______________________________________________________________________
1003 void AliITS::HitsToPreDigits(Int_t evNumber,Int_t bgrev,Int_t size,
1004                              Option_t *option,Option_t *opt,
1005                              const char *filename){
1006     //   Keep galice.root for signal and name differently the file for
1007     // background when add! otherwise the track info for signal will be lost !
1008     // the condition below will disappear when the geom class will be
1009     // initialized for all versions - for the moment it is only for v5 !
1010     // 7 is the SDD beam test version.
1011     // Inputs:
1012     //      Int_t evnt       Event to be processed.
1013     //      Int_t bgrev      Background Hit tree number.
1014     //      Int_t nmodules   Not used.
1015     //      Option_t *option String indicating if merging hits or not. To
1016     //                       merge hits set equal to "Add". Otherwise no
1017     //                       background hits are considered.
1018     //      Test_t *filename File name containing the background hits..
1019     // Outputs:
1020     //      none.
1021     // Return:
1022     //      none.
1023
1024     if(!GetITSgeom()) return; // need transformations to do digitization.
1025     AliITSgeom *geom = GetITSgeom();
1026
1027     const char *all = strstr(opt,"All");
1028     const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),
1029                           strstr(opt,"SSD")};
1030     static Bool_t setDef=kTRUE;
1031     if (setDef) SetDefaultSimulation();
1032     setDef=kFALSE;
1033
1034     Int_t nmodules;
1035     InitModules(size,nmodules);
1036     FillModules(evNumber,bgrev,nmodules,option,filename);
1037
1038     AliITSsimulation *sim      = 0;
1039     AliITSDetType    *iDetType = 0;
1040     AliITSmodule     *mod      = 0;
1041     Int_t id,module;
1042     for(module=0;module<geom->GetIndexMax();module++){
1043         id       = geom->GetModuleType(module);
1044         if (!all && !det[id]) continue;
1045         iDetType = DetType(id);
1046         sim      = (AliITSsimulation*)iDetType->GetSimulationModel();
1047         if (!sim) {
1048             Error("HitsToSDigits","The simulation class was not "
1049                   "instanciated for module %d type %s!",module,
1050                   geom->GetModuleTypeName(module));
1051             exit(1);
1052         } // end if !sim
1053         mod      = (AliITSmodule *)fITSmodules->At(module);
1054         sim->SDigitiseModule(mod,module,evNumber);
1055         // fills all branches - wasted disk space
1056         fLoader->TreeS()->Fill();
1057         ResetSDigits();
1058     } // end for module
1059
1060     ClearModules();
1061
1062     fLoader->TreeS()->GetEntries();
1063     fLoader->TreeS()->AutoSave();
1064     fLoader->WriteSDigits("OVERWRITE");
1065     // reset tree
1066     fLoader->TreeS()->Reset();
1067 }
1068 //______________________________________________________________________
1069 void AliITS::HitsToDigits(Int_t evNumber,Int_t bgrev,Int_t size,
1070                           Option_t *option,Option_t *opt,
1071                           const char *filename){
1072     //   Keep galice.root for signal and name differently the file for
1073     // background when add! otherwise the track info for signal will be lost !
1074     // the condition below will disappear when the geom class will be
1075     // initialized for all versions - for the moment it is only for v5 !
1076     // 7 is the SDD beam test version.
1077     // Inputs:
1078     //      Int_t evnt       Event to be processed.
1079     //      Int_t bgrev      Background Hit tree number.
1080     //      Int_t nmodules   Not used.
1081     //      Option_t *option String indicating if merging hits or not. To
1082     //                       merge hits set equal to "Add". Otherwise no
1083     //                       background hits are considered.
1084     //      Test_t *filename File name containing the background hits..
1085     // Outputs:
1086     //      none.
1087     // Return:
1088     //      none.
1089
1090     if(!GetITSgeom()) return; // need transformations to do digitization.
1091     AliITSgeom *geom = GetITSgeom();
1092
1093     const char *all = strstr(opt,"All");
1094     const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),
1095                           strstr(opt,"SSD")};
1096     static Bool_t setDef=kTRUE;
1097     if (setDef) SetDefaultSimulation();
1098     setDef=kFALSE;
1099
1100     Int_t nmodules;
1101     InitModules(size,nmodules);
1102     FillModules(evNumber,bgrev,nmodules,option,filename);
1103
1104     AliITSsimulation *sim      = 0;
1105     AliITSDetType    *iDetType = 0;
1106     AliITSmodule     *mod      = 0;
1107     Int_t id,module;
1108     for(module=0;module<geom->GetIndexMax();module++){
1109         id       = geom->GetModuleType(module);
1110         if (!all && !det[id]) continue;
1111         iDetType = DetType(id);
1112         sim      = (AliITSsimulation*)iDetType->GetSimulationModel();
1113         if (!sim) {
1114             Error("HitsToDigits","The simulation class was not "
1115                   "instanciated for module %d type %s!",module,
1116                   geom->GetModuleTypeName(module));
1117             exit(1);
1118         } // end if !sim
1119         mod      = (AliITSmodule *)fITSmodules->At(module);
1120         sim->DigitiseModule(mod,module,evNumber);
1121         // fills all branches - wasted disk space
1122         fLoader->TreeD()->Fill();
1123         ResetDigits();
1124     } // end for module
1125
1126     ClearModules();
1127
1128     fLoader->TreeD()->GetEntries();
1129     fLoader->TreeD()->AutoSave();
1130     // reset tree
1131     fLoader->TreeD()->Reset();
1132 }
1133 //______________________________________________________________________
1134 void AliITS::ResetDigits(){
1135     // Reset number of digits and the digits array for the ITS detector.
1136     // Inputs:
1137     //      none.
1138     // Outputs:
1139     //      none.
1140
1141     if (!fDtype) return;
1142
1143     Int_t i;
1144     for (i=0;i<kNTYPES;i++ ) {
1145         ResetDigits(i);
1146     } // end for i
1147 }
1148 //______________________________________________________________________
1149 void AliITS::ResetDigits(Int_t i){
1150     // Reset number of digits and the digits array for this branch.
1151     // Inputs:
1152     //      none.
1153     // Outputs:
1154     //      none.
1155
1156     if (fDtype->At(i)) ((TClonesArray*)fDtype->At(i))->Clear();
1157     if (fNdtype)       fNdtype[i]=0;
1158 }
1159 //______________________________________________________________________
1160 void AliITS::AddSumDigit(AliITSpListItem &sdig){
1161     // Adds the a module full of summable digits to the summable digits tree.
1162     // Inputs:
1163     //      AliITSpListItem &sdig   SDigit to be added to SDigits tree.
1164     // Outputs:
1165     //      none.
1166     // Return:
1167     //      none.
1168
1169     TClonesArray &lsdig = *fSDigits;
1170     new(lsdig[fNSDigits++]) AliITSpListItem(sdig);
1171 }
1172 //______________________________________________________________________
1173 void AliITS::AddRealDigit(Int_t id, Int_t *digits){
1174     //   Add a real digit - as coming from data.
1175     // Inputs:
1176     //      Int_t id        Detector type number.
1177     //      Int_t *digits   Integer array containing the digits info. See
1178     //                      AliITSdigit.h
1179     // Outputs:
1180     //      none.
1181     // Return:
1182     //      none.
1183
1184     TClonesArray &ldigits = *((TClonesArray*)fDtype->At(id));
1185     new(ldigits[fNdtype[id]++]) AliITSdigit(digits);
1186 }
1187 //______________________________________________________________________
1188 void AliITS::AddSimDigit(Int_t id, AliITSdigit *d){
1189     //    Add a simulated digit.
1190     // Inputs:
1191     //      Int_t id        Detector type number.
1192     //      AliITSdigit *d  Digit to be added to the Digits Tree. See
1193     //                      AliITSdigit.h
1194     // Outputs:
1195     //      none.
1196     // Return:
1197     //      none.
1198
1199     TClonesArray &ldigits = *((TClonesArray*)fDtype->At(id));
1200
1201     switch(id){
1202     case 0:
1203         new(ldigits[fNdtype[id]++]) AliITSdigitSPD(*((AliITSdigitSPD*)d));
1204         break;
1205     case 1:
1206         new(ldigits[fNdtype[id]++]) AliITSdigitSDD(*((AliITSdigitSDD*)d));
1207         break;
1208     case 2:
1209         new(ldigits[fNdtype[id]++]) AliITSdigitSSD(*((AliITSdigitSSD*)d));
1210         break;
1211     } // end switch id
1212 }
1213 //______________________________________________________________________
1214 void AliITS::AddSimDigit(Int_t id,Float_t phys,Int_t *digits,Int_t *tracks,
1215                          Int_t *hits,Float_t *charges){
1216   //   Add a simulated digit to the list.
1217   // Inputs:
1218   //      Int_t id        Detector type number.
1219   //      Float_t phys    Physics indicator. See AliITSdigits.h
1220   //      Int_t *digits   Integer array containing the digits info. See
1221   //                      AliITSdigit.h
1222   //      Int_t *tracks   Integer array [AliITSdigitS?D::GetNTracks()]
1223   //                      containing the track numbers that contributed to
1224   //                      this digit.
1225   //      Int_t *hits     Integer array [AliITSdigitS?D::GetNTracks()]
1226   //                      containing the hit numbers, from AliITSmodule, that
1227   //                      contributed to this digit.
1228   //      Float_t *charge Floating point array of the signals contributed
1229   //                      to this digit by each track.
1230   // Outputs:
1231   //      none.
1232   // Return:
1233   //      none.
1234
1235   TClonesArray &ldigits = *((TClonesArray*)fDtype->At(id));
1236   AliITSresponseSDD *resp = 0;
1237   switch(id){
1238   case 0:
1239       new(ldigits[fNdtype[id]++]) AliITSdigitSPD(digits,tracks,hits);
1240       break;
1241   case 1:
1242       resp = (AliITSresponseSDD*)DetType(1)->GetResponseModel();
1243       new(ldigits[fNdtype[id]++]) AliITSdigitSDD(phys,digits,tracks,
1244                                                  hits,charges,resp);
1245       break;
1246   case 2:
1247       new(ldigits[fNdtype[id]++]) AliITSdigitSSD(digits,tracks,hits);
1248       break;
1249   } // end switch id
1250 }
1251 //______________________________________________________________________
1252 void AliITS::Digits2Raw(){
1253     // convert digits of the current event to raw data
1254
1255   fLoader->LoadDigits();
1256   TTree* digits = fLoader->TreeD();
1257   if (!digits) {
1258       Error("Digits2Raw", "no digits tree");
1259       return;
1260   }
1261   SetTreeAddressD(digits);
1262
1263   AliITSDDLRawData rawWriter;
1264   //Verbose level
1265   // 0: Silent
1266   // 1: cout messages
1267   // 2: txt files with digits
1268   //BE CAREFUL, verbose level 2 MUST be used only for debugging and
1269   //it is highly suggested to use this mode only for debugging digits files
1270   //reasonably small, because otherwise the size of the txt files can reach
1271   //quickly several MB wasting time and disk space.
1272   rawWriter.SetVerbose(0);
1273
1274   //SILICON PIXEL DETECTOR
1275   Info("Digits2Raw", "Formatting raw data for SPD");
1276   rawWriter.RawDataSPD(digits->GetBranch("ITSDigitsSPD"));
1277
1278   //SILICON DRIFT DETECTOR
1279   Info("Digits2Raw", "Formatting raw data for SDD");
1280   rawWriter.RawDataSDD(digits->GetBranch("ITSDigitsSDD"));
1281
1282   //SILICON STRIP DETECTOR
1283   Info("Digits2Raw", "Formatting raw data for SSD");
1284   rawWriter.RawDataSSD(digits->GetBranch("ITSDigitsSSD"));
1285
1286   fLoader->UnloadDigits();
1287 }
1288
1289 //______________________________________________________________________
1290 void AliITS::MakeTreeC(Option_t *option){
1291   //   Create a separate tree to store the clusters.
1292   // Inputs:
1293   //      Option_t *option  string which must contain "C" otherwise
1294   //                        no Cluster Tree is created.
1295   // Outputs:
1296   //      none.
1297   // Return:
1298   //      none.
1299
1300   AliITSLoader *pITSLoader = (AliITSLoader*)fLoader;
1301
1302   if (pITSLoader == 0x0) {
1303       Error("MakeTreeC","fLoader == 0x0 option=%s",option);
1304       return;
1305   }
1306   if (pITSLoader->TreeC() == 0x0) pITSLoader->MakeTree("C");
1307   MakeBranchC();
1308 }
1309 //----------------------------------------------------------------------
1310 void AliITS::MakeBranchC(){
1311     //Makes barnches in treeC
1312     AliITSLoader *pITSLoader = (AliITSLoader*)fLoader;
1313     if (pITSLoader == 0x0) {
1314         Error("MakeTreeC","fLoader == 0x0");
1315         return;
1316     }
1317     TTree * lTC = pITSLoader->TreeC();
1318     if (lTC == 0x0){
1319         Error("MakeTreeC","Can not get TreeC from Loader");
1320         return;
1321     }
1322
1323     Int_t buffersize = 4000;
1324     char branchname[30];
1325     const char *det[3] = {"SPD","SDD","SSD"};
1326     char digclass[40];
1327     char clclass[40];
1328
1329     // one branch for Clusters per type of detector
1330     Int_t i;
1331     for (i=0; i<kNTYPES ;i++) {
1332         AliITSDetType *iDetType=DetType(i);
1333         iDetType->GetClassNames(digclass,clclass);
1334         // clusters
1335         if (fCtype == 0x0) fCtype  = new TObjArray(fNDetTypes);
1336         if(!ClustersAddress(i)){
1337             fCtype->AddAt(new TClonesArray(clclass,1000),i);
1338         }
1339         if (kNTYPES==3) sprintf(branchname,"%sClusters%s",GetName(),det[i]);
1340         else  sprintf(branchname,"%sClusters%d",GetName(),i+1);
1341         if (fCtype  && lTC) {
1342             if (lTC->GetBranch(branchname)){
1343                 Warning("MakeBranchC","Branch %s alread exists in TreeC",
1344                         branchname);
1345             }else{
1346                 Info("MakeBranchC","Creating branch %s in TreeC",branchname);
1347                 lTC->Branch(branchname,&((*fCtype)[i]), buffersize);
1348             }
1349         } // end if fCtype && lTC
1350     } // end for i
1351 }
1352 //______________________________________________________________________
1353 void AliITS::GetTreeC(Int_t event){
1354     //    Get the clusters tree for this event and set the branch address.
1355     // Inputs:
1356     //      Int_t event    Event number for the cluster tree.
1357     // Outputs:
1358     //      none.
1359     // Return:
1360     //      none.
1361     char branchname[30];
1362     const char *det[3] = {"SPD","SDD","SSD"};
1363
1364     AliITSLoader *pITSLoader = (AliITSLoader*)fLoader;
1365     TTree * lTC = pITSLoader->TreeC();
1366
1367     ResetClusters();
1368     if (lTC) {
1369         pITSLoader->CleanRawClusters();
1370     } // end if TreeC()
1371
1372     TBranch *branch;
1373
1374     if (lTC) {
1375         Int_t i;
1376         char digclass[40];
1377         char clclass[40];
1378         for (i=0; i<kNTYPES; i++) {
1379             AliITSDetType *iDetType=DetType(i);
1380             iDetType->GetClassNames(digclass,clclass);
1381             // clusters
1382             if (fCtype == 0x0) fCtype  = new TObjArray(fNDetTypes);
1383             if(!fCtype->At(i)) fCtype->AddAt(new TClonesArray(clclass,1000),i);
1384             if(kNTYPES==3) sprintf(branchname,"%sClusters%s",GetName(),det[i]);
1385             else  sprintf(branchname,"%sClusters%d",GetName(),i+1);
1386             if (fCtype) {
1387                 branch = lTC->GetBranch(branchname);
1388                 if (branch) branch->SetAddress(&((*fCtype)[i]));
1389             } // end if fCtype
1390         } // end for i
1391     } else {
1392         Error("GetTreeC","cannot find Clusters Tree for event:%d",event);
1393     } // end if lTC
1394 }
1395 //______________________________________________________________________
1396 void AliITS::AddCluster(Int_t id, AliITSRawCluster *c){
1397     //   Add a cluster to the list.
1398     // Inputs:
1399     //      Int_t id             Detector type number.
1400     //      AliITSRawCluster *c  Cluster class to be added to the tree of
1401     //                           clusters.
1402     // Outputs:
1403     //      none.
1404     // Return:
1405     //      none.
1406
1407     TClonesArray &lc = *((TClonesArray*)fCtype->At(id));
1408
1409     switch(id){
1410     case 0:
1411         new(lc[fNctype[id]++]) AliITSRawClusterSPD(*((AliITSRawClusterSPD*)c));
1412         break;
1413     case 1:
1414         new(lc[fNctype[id]++]) AliITSRawClusterSDD(*((AliITSRawClusterSDD*)c));
1415         break;
1416     case 2:
1417         new(lc[fNctype[id]++]) AliITSRawClusterSSD(*((AliITSRawClusterSSD*)c));
1418         break;
1419     } // end switch id
1420 }
1421 //______________________________________________________________________
1422 void AliITS::ResetClusters(Int_t i){
1423     //    Reset number of clusters and the clusters array for this branch.
1424     // Inputs:
1425     //      Int_t i        Detector type number.
1426     // Outputs:
1427     //      none.
1428     // Return:
1429     //      none.
1430
1431     if (fCtype->At(i))    ((TClonesArray*)fCtype->At(i))->Clear();
1432     if (fNctype)  fNctype[i]=0;
1433 }
1434 //______________________________________________________________________
1435 void AliITS::MakeBranchR(const char *file, Option_t *opt){
1436     // Creates Tree branches for the ITS Reconstructed points.
1437     // Inputs:
1438     //      cont char *file  File name where RecPoints branch is to be written
1439     //                       to. If blank it write the SDigits to the same
1440     //                       file in which the Hits were found.
1441     // Outputs:
1442     //      none.
1443     // Return:
1444     //      none.
1445     Int_t buffsz = 4000;
1446     char branchname[30];
1447
1448     // only one branch for rec points for all detector types
1449     Bool_t oFast= (strstr(opt,"Fast")!=0);
1450     if(oFast){
1451         sprintf(branchname,"%sRecPointsF",GetName());
1452     } else {
1453         sprintf(branchname,"%sRecPoints",GetName());
1454     }
1455
1456     if(!fRecPoints)fRecPoints = new TClonesArray("AliITSRecPoint",1000);
1457     if (fLoader->TreeR()) {
1458         if(fRecPoints==0x0) fRecPoints = new TClonesArray("AliITSRecPoint",
1459                                                           1000);
1460         MakeBranchInTree(fLoader->TreeR(),branchname,&fRecPoints,buffsz,file);
1461     } // end if
1462 }
1463 //______________________________________________________________________
1464 void AliITS::SetTreeAddressR(TTree *treeR){
1465     // Set branch address for the Reconstructed points Trees.
1466     // Inputs:
1467     //      TTree *treeR   Tree containing the RecPoints.
1468     // Outputs:
1469     //      none.
1470     // Return:
1471     //      none.
1472     char branchname[30];
1473
1474     if(!treeR) return;
1475     if(fRecPoints==0x0) fRecPoints = new TClonesArray("AliITSRecPoint",1000);
1476     TBranch *branch;
1477     sprintf(branchname,"%sRecPoints",GetName());
1478     branch = treeR->GetBranch(branchname);
1479     if (branch) {
1480         branch->SetAddress(&fRecPoints);
1481     }else {
1482         sprintf(branchname,"%sRecPointsF",GetName());
1483         branch = treeR->GetBranch(branchname);
1484         if (branch) {
1485             branch->SetAddress(&fRecPoints);
1486         }
1487     }
1488 }
1489 //______________________________________________________________________
1490 void AliITS::AddRecPoint(const AliITSRecPoint &r){
1491     // Add a reconstructed space point to the list
1492     // Inputs:
1493     //      const AliITSRecPoint &r RecPoint class to be added to the tree
1494     //                              of reconstructed points TreeR.
1495     // Outputs:
1496     //      none.
1497     // Return:
1498     //      none.
1499
1500     TClonesArray &lrecp = *fRecPoints;
1501     new(lrecp[fNRecPoints++]) AliITSRecPoint(r);
1502 }
1503 //______________________________________________________________________
1504 void AliITS::HitsToFastRecPoints(Int_t evNumber,Int_t bgrev,Int_t size,
1505                                   Option_t *opt0,Option_t *opt1,
1506                                  const char *flnm){
1507     // keep galice.root for signal and name differently the file for
1508     // background when add! otherwise the track info for signal will be lost !
1509     // the condition below will disappear when the geom class will be
1510     // initialized for all versions - for the moment it is only for v5 !
1511     // Inputs:
1512     //      Int_t evnt       Event to be processed.
1513     //      Int_t bgrev      Background Hit tree number.
1514     //      Int_t size       Size used by InitModules. See InitModules.
1515     //      Option_t *opt0   Option passed to FillModules. See FillModules.
1516     //      Option_t *opt1   String indicating if merging hits or not. To
1517     //                       merge hits set equal to "Add". Otherwise no
1518     //                       background hits are considered.
1519     //      Test_t *flnm     File name containing the background hits..
1520     // Outputs:
1521     //      none.
1522     // Return:
1523     //      none.
1524
1525     if(!GetITSgeom()) return;
1526     AliITSLoader *pITSloader = (AliITSLoader*)fLoader;
1527     AliITSgeom *geom = GetITSgeom();
1528
1529     const char *all = strstr(opt1,"All");
1530     const char *det[3] ={strstr(opt1,"SPD"),strstr(opt1,"SDD"),
1531                          strstr(opt1,"SSD")};
1532     Int_t nmodules;
1533     InitModules(size,nmodules);
1534     FillModules(evNumber,bgrev,nmodules,opt0,flnm);
1535
1536     AliITSsimulation *sim      = 0;
1537     AliITSDetType    *iDetType = 0;
1538     AliITSmodule     *mod      = 0;
1539     Int_t id,module;
1540
1541     //m.b. : this change is nothing but a nice way to make sure
1542     //the CPU goes up !
1543
1544     if(GetDebug()) cout<<"HitsToFastRecPoints: N mod = "<<
1545                        geom->GetIndexMax()<<endl;
1546     for(module=0;module<geom->GetIndexMax();module++){
1547         id       = geom->GetModuleType(module);
1548         if (!all && !det[id]) continue;
1549         iDetType = DetType(id);
1550         sim      = (AliITSsimulation*)iDetType->GetSimulationModel();
1551         if (!sim) {
1552             Error("HitsToFastPoints","The simulation class was not "
1553                   "instanciated for module %d type %x!",module,
1554                   geom->GetModuleTypeName(module));
1555             exit(1);
1556         } // end if !sim
1557         mod      = (AliITSmodule *)fITSmodules->At(module);
1558         sim->CreateFastRecPoints(mod,module,gRandom);
1559         cout<<module<<"\r";fflush(0);
1560         //gAlice->TreeR()->Fill();
1561         TTree *lTR = pITSloader->TreeR();
1562         TBranch *br=lTR->GetBranch("ITSRecPointsF");
1563         br->Fill();
1564         ResetRecPoints();
1565     } // end for module
1566
1567     ClearModules();
1568     fLoader->WriteRecPoints("OVERWRITE");
1569 }
1570 //______________________________________________________________________
1571 void AliITS::DigitsToRecPoints(Int_t evNumber,Int_t lastentry,Option_t *opt){
1572   // cluster finding and reconstruction of space points
1573   // the condition below will disappear when the geom class will be
1574   // initialized for all versions - for the moment it is only for v5 !
1575   // 7 is the SDD beam test version
1576   // Inputs:
1577   //      Int_t evNumber   Event number to be processed.
1578   //      Int_t lastentry  Offset for module when not all of the modules
1579   //                       are processed.
1580   //      Option_t *opt    String indicating which ITS sub-detectors should
1581   //                       be processed. If ="All" then all of the ITS
1582   //                       sub detectors are processed.
1583   // Outputs:
1584   //      none.
1585   // Return:
1586   //      none.
1587
1588   if(!GetITSgeom()) return;
1589   AliITSgeom *geom = GetITSgeom();
1590
1591   const char *all = strstr(opt,"All");
1592   const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),
1593                         strstr(opt,"SSD")};
1594   static Bool_t setRec=kTRUE;
1595   if (setRec) SetDefaultClusterFinders();
1596   setRec=kFALSE;
1597
1598   AliITSLoader *pITSloader = (AliITSLoader*)fLoader;
1599   TTree *treeC=pITSloader->TreeC();
1600   AliITSClusterFinder *rec     = 0;
1601   AliITSDetType      *iDetType = 0;
1602   Int_t id,module,first=0;
1603   for(module=0;module<geom->GetIndexMax();module++){
1604       id       = geom->GetModuleType(module);
1605       if (!all && !det[id]) continue;
1606       if(det[id]) first = geom->GetStartDet(id);
1607       iDetType = DetType(id);
1608       rec = (AliITSClusterFinder*)iDetType->GetReconstructionModel();
1609       TClonesArray *itsDigits  = this->DigitsAddress(id);
1610       if (!rec) {
1611           Error("DigitsToRecPoints",
1612                 "The reconstruction class was not instanciated! event=%d",
1613                 evNumber);
1614           exit(1);
1615       } // end if !rec
1616       this->ResetDigits();
1617       TTree *lTD = pITSloader->TreeD();
1618       if (all) {
1619           lTD->GetEvent(lastentry+module);
1620       }else {
1621           lTD->GetEvent(lastentry+(module-first));
1622       }
1623       Int_t ndigits = itsDigits->GetEntriesFast();
1624       if(ndigits>0){
1625           rec->SetDigits(DigitsAddress(id));
1626           rec->SetClusters(ClustersAddress(id));
1627           rec->FindRawClusters(module);
1628       } // end if
1629       pITSloader->TreeR()->Fill();
1630       ResetRecPoints();
1631       treeC->Fill();
1632       ResetClusters();
1633   } // end for module
1634
1635   pITSloader->WriteRecPoints("OVERWRITE");
1636   pITSloader->WriteRawClusters("OVERWRITE");
1637 }
1638 //______________________________________________________________________
1639 AliLoader* AliITS::MakeLoader(const char* topfoldername){
1640     //builds ITSgetter (AliLoader type)
1641     //if detector wants to use castomized getter, it must overload this method
1642
1643     Info("MakeLoader","Creating AliITSLoader. Top folder is %s.",
1644          topfoldername);
1645     fLoader = new AliITSLoader(GetName(),topfoldername);
1646     return fLoader;
1647 }