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