ITS/AliITS.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /*
  17 $Log$
  18 Revision 1.59  2001/08/30 09:56:18  hristov
  19 The operator[] is replaced by At() or AddAt() in case of TObjArray.
  20
  21 Revision 1.58  2001/07/26 15:05:29  hristov
  22 Use global gRandom generator (M.Ivanov)
  23
  24 Revision 1.57  2001/07/24 14:26:11  mariana
  25 Introduce the function Digits2Reco() and write the defaults for simulation and reconstruction
  26
  27 Revision 1.56  2001/07/05 12:49:49  mariana
  28 Temporary patches required by root.v3.01.05
  29
  30 Revision 1.55  2001/06/14 14:59:00  barbera
  31 Tracking V1 decoupled from AliITS
  32
  33 Revision 1.54  2001/05/31 20:37:56  barbera
  34 Bari/Salerno model set as defaault SPD simulation
  35
  36 Revision 1.53  2001/05/31 18:52:24 barbera
  37 Bari model becomes the default
  38
  39 Revision 1.53  2001/05/30 07:52:24  hristov
  40 TPC and CONTAINERS included in the search path
  41
  42 Revision 1.52  2001/05/30 06:04:58  hristov
  43 Changes made to be consitant with changes in TPC tracking classes (B.Nilsen)
  44
  45 Revision 1.51  2001/05/16 14:57:15  alibrary
  46 New files for folders and Stack
  47
  48 Revision 1.50  2001/05/11 09:15:21  barbera
  49 Corrected to make fast point creation working with PPR geometry
  50
  51 Revision 1.49  2001/05/11 07:37:49  hristov
  52 Legacy lines commented
  53
  54 Revision 1.48  2001/05/10 18:14:25  barbera
  55 A typo corrected
  56
  57 Revision 1.47  2001/05/10 17:55:59  barbera
  58 Modified to create rec points also for PPR geometries
  59
  60 Revision 1.46  2001/05/10 00:05:28  nilsen
  61 Allowed for HitsToDigits function to work with versions 5, 7, 8, and 9. This
  62 should probably be cleaned up to only check to make sure that fITSgeom has
  63 been properly defined.
  64
  65 Revision 1.45  2001/05/01 22:35:48  nilsen
  66 Remove/commented a number of cout<< statements. and made change needed by
  67 SSD code.
  68
  69 Revision 1.44  2001/04/26 22:44:01  nilsen
  70 Removed dependence on layer 5/6 in AliITS::HitsToDigits. This will be
  71 done properly in AliITSv???.cxx via SetDefaults.
  72
  73 Revision 1.43  2001/04/26 13:22:52  barbera
  74 TMatrix and TVector elimininated to speed up the code
  75
  76 Revision 1.42  2001/04/25 21:55:12  barbera
  77 Updated version to be compatible with actual verion of STEER and TPC
  78
  79 Revision 1.41  2001/04/21 15:16:51  barbera
  80 Updated with the new SSD reconstruction code
  81
  82 Revision 1.40  2001/03/17 15:07:06  mariana
  83 Update SDD response parameters
  84
  85 Revision 1.39  2001/03/12 17:45:32  hristov
  86 Changes needed on Sun with CC 5.0
  87
  88 Revision 1.38  2001/03/07 14:04:51  barbera
  89 Some vector dimensions increased to cope with full events
  90
  91 Revision 1.37  2001/03/07 12:36:35  barbera
  92 A change added in the tracking part to manage delta rays
  93
  94 Revision 1.36  2001/03/02 19:44:11  barbera
  95  modified to taking into account new version tracking v1
  96
  97 Revision 1.35  2001/02/28 18:16:46  mariana
  98 Make the code compatible with the new AliRun
  99
 100 Revision 1.34  2001/02/11 15:51:39  mariana
 101 Set protection in MakeBranch
 102
 103 Revision 1.33  2001/02/10 22:26:39  mariana
 104 Move the initialization of the containers for raw clusters in MakeTreeC()
 105
 106 Revision 1.32  2001/02/08 23:55:31  nilsen
 107 Removed fMajor/MinorVersion variables in favor of variables in derived classes.
 108 Set arrays char *det[3] = {"SPD","SDD","SSD"} as const.
 109
 110 Revision 1.31  2001/02/02 23:57:28  nilsen
 111 Added include file that are no londer included in AliITSgeom.h
 112
 113 Revision 1.30  2001/01/30 09:23:13  hristov
 114 Streamers removed (R.Brun)
 115
 116 Revision 1.29  2001/01/26 20:01:09  hristov
 117 Major upgrade of AliRoot code
 118
 119 Revision 1.28  2000/12/18 14:02:00  barbera
 120 new version of the ITS tracking to take into account the new TPC track parametrization
 121
 122 Revision 1.27  2000/12/08 13:49:27  barbera
 123 Hidden declaration in a for loop removed to be compliant with HP-UX compiler
 124
 125 Revision 1.26  2000/11/27 13:12:13  barbera
 126 New version containing the files for tracking
 127
 128 Revision 1.25  2000/11/12 22:38:05  barbera
 129 Added header file for the SPD Bari model
 130
 131 Revision 1.24  2000/10/09 22:18:12  barbera
 132 Bug fixes from MAriana to le AliITStest.C run correctly
 133
 134 Revision 1.23  2000/10/05 20:47:42  nilsen
 135 fixed dependencies of include files. Tryed but failed to get a root automaticly
 136 generates streamer function to work. Modified SetDefaults.
 137
 138 Revision 1.9.2.15  2000/10/04 16:56:40  nilsen
 139 Needed to include stdlib.h
 140
 141 =======
 142 Revision 1.22  2000/10/04 19:45:52  barbera
 143 Corrected by F. Carminati for v3.04
 144
 145 Revision 1.21  2000/10/02 21:28:08  fca
 146 Removal of useless dependecies via forward declarations
 147
 148 Revision 1.20  2000/10/02 16:31:39  barbera
 149 General code clean-up
 150
 151 Revision 1.9.2.14  2000/10/02 15:43:51  barbera
 152 General code clean-up (e.g., printf -> cout)
 153
 154 Revision 1.19  2000/09/22 12:13:25  nilsen
 155 Patches and updates for fixes to this and other routines.
 156
 157 Revision 1.18  2000/07/12 05:32:20  fca
 158 Correcting several syntax problem with static members
 159
 160 Revision 1.17  2000/07/10 16:07:18  fca
 161 Release version of ITS code
 162
 163 Revision 1.9.2.3  2000/02/02 13:42:09  barbera
 164 fixed AliITS.cxx for new AliRun structure. Added ITS hits list to list of hits which will have their track numbers updated
 165
 166 Revision 1.9.2.2  2000/01/23 03:03:13  nilsen
 167 //fixed FillModule. Removed fi(fabs(xl)<dx....
 168
 169 Revision 1.9.2.1  2000/01/12 19:03:32  nilsen
 170 This is the version of the files after the merging done in December 1999.
 171 See the ReadMe110100.txt file for details
 172
 173 Revision 1.9  1999/11/14 14:33:25  fca
 174 Correct problems with distructors and pointers, thanks to I.Hrivnacova
 175
 176 Revision 1.8  1999/09/29 09:24:19  fca
 177 Introduction of the Copyright and cvs Log
 178
 179 */
 180
 181 ///////////////////////////////////////////////////////////////////////////////
 182 //
 183 //      An overview of the basic philosophy of the ITS code development
 184 // and analysis is show in the figure below.
 185 //Begin_Html
 186 /*
 187 <img src="picts/ITS/ITS_Analysis_schema.gif">
 188 </pre>
 189 <br clear=left>
 190 <font size=+2 color=red>
 191 <p>Roberto Barbera is in charge of the ITS Offline code (1999).
 192 <a href="mailto:roberto.barbera@ct.infn.it">Roberto Barbera</a>.
 193 </font>
 194 <pre>
 195 */
 196 //End_Html
 197 //
 198 //  AliITS. Inner Traking System base class.
 199 //  This class contains the base procedures for the Inner Tracking System
 200 //
 201 //Begin_Html
 202 /*
 203 <img src="picts/ITS/AliITS_Class_Diagram.gif">
 204 </pre>
 205 <br clear=left>
 206 <font size=+2 color=red>
 207 <p>This show the class diagram of the different elements that are part of
 208 the AliITS class.
 209 </font>
 210 <pre>
 211 */
 212 //End_Html
 213 //
 214 // Version: 0
 215 // Written by Rene Brun, Federico Carminati, and Roberto Barbera
 216 //
 217 // Version: 1
 218 // Modified and documented by Bjorn S. Nilsen
 219 // July 11 1999
 220 //
 221 // Version: 2
 222 // Modified and documented by A. Bologna
 223 // October 18 1999
 224 //
 225 // AliITS is the general base class for the ITS. Also see AliDetector for
 226 // futher information.
 227 //
 228 ///////////////////////////////////////////////////////////////////////////////
 229 #include <iostream.h>
 230 #include <iomanip.h>
 231 #include <fstream.h>
 232 #include <stdlib.h>
 233 #include <TMath.h>
 234 #include <TRandom.h>
 235 #include <TBranch.h>
 236 #include <TVector.h>
 237 #include <TClonesArray.h>
 238 #include <TROOT.h>
 239 #include <TObjectTable.h>
 240 #include <TFile.h>
 241 #include <TTree.h>
 242 #include <TString.h>
 243
 244 #include "AliMC.h"
 245 #include "AliRun.h"
 246 #include "AliHeader.h"
 247
 248 #include "AliITS.h"
 249 #include "AliITSDetType.h"
 250 #include "AliITSresponseSPD.h"
 251 #include "AliITSresponseSDD.h"
 252 #include "AliITSresponseSSD.h"
 253 #include "AliITSsegmentationSPD.h"
 254 #include "AliITSsegmentationSDD.h"
 255 #include "AliITSsegmentationSSD.h"
 256 #include "AliITSsimulationSPD.h"
 257 #include "AliITSsimulationSDD.h"
 258 #include "AliITSsimulationSSD.h"
 259 #include "AliITSClusterFinderSPD.h"
 260 #include "AliITSClusterFinderSDD.h"
 261 #include "AliITSClusterFinderSSD.h"
 262 #include "AliITShit.h"
 263 #include "AliITSgeom.h"
 264 #include "AliITSpList.h"
 265 #include "AliITSdigit.h"
 266 #include "AliITSmodule.h"
 267 #include "AliITSRecPoint.h"
 268 #include "AliITSRawCluster.h"
 269
 270 ClassImp(AliITS)
 271
 272 //______________________________________________________________________
 273 AliITS::AliITS() : AliDetector() {
 274     // Default initialiser for ITS
 275     //      The default constructor of the AliITS class. In addition to
 276     // creating the AliITS class it zeros the variables fIshunt (a member
 277     // of AliDetector class), fEuclidOut, and fIdN, and zeros the pointers
 278     // fITSpoints, fIdSens, and fIdName. The AliDetector default constructor
 279     // is also called.
 280
 281     fIshunt     = 0;   // not zeroed in AliDetector.
 282
 283     // AliITS variables.
 284     fEuclidOut  = 0;
 285     fITSgeom    = 0;
 286     fITSmodules = 0;
 287
 288     fIdN        = 0;
 289     fIdName     = 0;
 290     fIdSens     = 0;
 291
 292     fNDetTypes  = kNTYPES;
 293     fDetTypes   = 0;
 294
 295     fSDigits    = 0;
 296     fNSDigits   = 0;
 297
 298     fNdtype     = 0;
 299     fDtype      = 0;
 300
 301     fCtype      = 0;
 302     fNctype     = 0;
 303     fTreeC      = 0;
 304
 305     fRecPoints  = 0;
 306     fNRecPoints = 0;
 307
 308     SetMarkerColor(kRed);
 309 }
 310 //______________________________________________________________________
 311 AliITS::AliITS(const char *name, const char *title):AliDetector(name,title){
 312     // Default initialiser for ITS
 313     //     The constructor of the AliITS class. In addition to creating the
 314     // AliITS class, it allocates memory for the TClonesArrays fHits and
 315     // fDigits, and for the TObjArray fITSpoints. It also zeros the variables
 316     // fIshunt (a member of AliDetector class), fEuclidOut, and fIdN, and zeros
 317     // the pointers fIdSens and fIdName. To help in displaying hits via the
 318     // ROOT macro display.C AliITS also sets the marker color to red. The
 319     // variables passes with this constructor, const char *name and *title,
 320     // are used by the constructor of AliDetector class. See AliDetector
 321     // class for a description of these parameters and its constructor
 322     // functions.
 323
 324     fIshunt     = 0;  // not zeroed in AliDetector
 325     fHits       = new TClonesArray("AliITShit", 1560);//not done in AliDetector
 326     gAlice->AddHitList(fHits);  // Not done in AliDetector.
 327
 328     fEuclidOut  = 0;
 329     fITSgeom    = 0;
 330     fITSmodules = 0;
 331
 332     fIdN        = 0;
 333     fIdName     = 0;
 334     fIdSens     = 0;
 335
 336     fNDetTypes  = kNTYPES;
 337     fDetTypes   = new TObjArray(fNDetTypes);
 338
 339 //    fSDigits    = new TObjArray(1000);
 340     fSDigits    = new TClonesArray("AliITSpListItem",1000);
 341     fNSDigits   = 0;
 342
 343     fNdtype     = new Int_t[fNDetTypes];
 344     fDtype      = new TObjArray(fNDetTypes);
 345
 346     fCtype      = new TObjArray(fNDetTypes);
 347     fNctype     = new Int_t[fNDetTypes];
 348     fTreeC      = 0;
 349
 350     fRecPoints  = new TClonesArray("AliITSRecPoint",1000);
 351     fNRecPoints = 0;
 352
 353     Int_t i;
 354     for(i=0;i<fNDetTypes;i++) {
 355         fDetTypes->AddAt(new AliITSDetType(),i);
 356         fNdtype[i] = 0;
 357         fNctype[i] = 0;
 358     } // end for i
 359
 360     SetMarkerColor(kRed);
 361 }
 362 //______________________________________________________________________
 363 AliITS::~AliITS(){
 364     // Default distructor for ITS
 365     //     The default destructor of the AliITS class. In addition to deleting
 366     // the AliITS class it deletes the memory pointed to by the fHits, fDigits,
 367     // fIdSens, fIdName, and fITSpoints.
 368
 369     delete fHits;
 370     delete fSDigits;
 371     delete fDigits;
 372     delete fRecPoints;
 373 //  delete fIdName;        // TObjArray of TObjStrings
 374     if(fIdName!=0) delete[] fIdName;  // Array of TStrings
 375     if(fIdSens!=0) delete[] fIdSens;
 376     if(fITSmodules!=0) {
 377         this->ClearModules();
 378         delete fITSmodules;
 379     }// end if fITSmodules!=0
 380
 381     if(fDtype) {
 382         fDtype->Delete();
 383         delete fDtype;
 384     } // end if fDtype
 385     delete [] fNdtype;
 386     if (fCtype) {
 387         fCtype->Delete();
 388         delete fCtype;
 389     } // end if fCtype
 390     delete [] fNctype;
 391
 392     if (fDetTypes) {
 393         fDetTypes->Delete();
 394         delete fDetTypes;
 395     } // end if fDetTypes
 396
 397     if (fTreeC) delete fTreeC;
 398
 399     if (fITSgeom) delete fITSgeom;
 400 }
 401 //______________________________________________________________________
 402 AliITS::AliITS(AliITS &source){
 403     // copy constructor
 404
 405     if(this==&source) return;
 406     Error("AliITS::Copy constructor",
 407           "You are not allowed to make a copy of the AliITS");
 408     exit(1);
 409 }
 410 //______________________________________________________________________
 411 AliITS& AliITS::operator=(AliITS &source){
 412     // assignment operator
 413
 414     if(this==&source) return *this;
 415     Error("AliITS::operator=",
 416           "You are not allowed to make a copy of the AliITS");
 417     exit(1);
 418     return *this; //fake return
 419 }
 420 //______________________________________________________________________
 421 Int_t AliITS::DistancetoPrimitive(Int_t , Int_t ){
 422     // Distance from mouse to ITS on the screen. Dummy routine
 423     //     A dummy routine used by the ROOT macro display.C to allow for the
 424     // use of the mouse (pointing device) in the macro. In general this should
 425     // never be called. If it is it returns the number 9999 for any value of
 426     // x and y.
 427
 428     return 9999;
 429 }
 430 //______________________________________________________________________
 431 void AliITS::Init(){
 432     // Initialise ITS after it has been built
 433     //     This routine initializes the AliITS class. It is intended to be
 434     // called from the Init function in AliITSv?. Besides displaying a banner
 435     // indicating that it has been called it initializes the array fIdSens
 436     // and sets the default segmentation, response, digit and raw cluster
 437     // classes therefore it should be called after a call to CreateGeometry.
 438     Int_t i;
 439
 440     SetDefaults();
 441     // Array of TStrings
 442     for(i=0;i<fIdN;i++) fIdSens[i] = gMC->VolId(fIdName[i]);
 443 }
 444 //______________________________________________________________________
 445 void AliITS::SetDefaults(){
 446     // sets the default segmentation, response, digit and raw cluster classes
 447
 448     if(fDebug) printf("%s: SetDefaults\n",ClassName());
 449
 450     AliITSDetType *iDetType;
 451
 452     //SPD
 453     iDetType=DetType(0);
 454     if (!iDetType->GetSegmentationModel()) {
 455         AliITSsegmentationSPD *seg0=new AliITSsegmentationSPD(fITSgeom);
 456         SetSegmentationModel(0,seg0);
 457     } // end if
 458     if (!iDetType->GetResponseModel()) {
 459         SetResponseModel(0,new AliITSresponseSPD());
 460     } // end if
 461     // set digit and raw cluster classes to be used
 462
 463     const char *kData0=(iDetType->GetResponseModel())->DataType();
 464     if (strstr(kData0,"real")) {
 465         iDetType->ClassNames("AliITSdigit","AliITSRawClusterSPD");
 466     } else iDetType->ClassNames("AliITSdigitSPD","AliITSRawClusterSPD");
 467
 468     // SDD
 469     iDetType=DetType(1);
 470     if (!iDetType->GetResponseModel()) {
 471         SetResponseModel(1,new AliITSresponseSDD());
 472     } // end if
 473     AliITSresponse *resp1=iDetType->GetResponseModel();
 474     if (!iDetType->GetSegmentationModel()) {
 475         AliITSsegmentationSDD *seg1=new AliITSsegmentationSDD(fITSgeom,resp1);
 476         SetSegmentationModel(1,seg1);
 477     } // end if
 478     const char *kData1=(iDetType->GetResponseModel())->DataType();
 479     const char *kopt=iDetType->GetResponseModel()->ZeroSuppOption();
 480     if((!strstr(kopt,"2D")) && (!strstr(kopt,"1D")) || strstr(kData1,"real") ){
 481         iDetType->ClassNames("AliITSdigit","AliITSRawClusterSDD");
 482     } else iDetType->ClassNames("AliITSdigitSDD","AliITSRawClusterSDD");
 483
 484     // SSD
 485     iDetType=DetType(2);
 486     if (!iDetType->GetSegmentationModel()) {
 487         AliITSsegmentationSSD *seg2=new AliITSsegmentationSSD(fITSgeom);
 488         SetSegmentationModel(2,seg2);
 489     } // end if
 490     if (!iDetType->GetResponseModel()) {
 491         SetResponseModel(2,new AliITSresponseSSD());
 492     } // end if
 493     const char *kData2=(iDetType->GetResponseModel())->DataType();
 494     if (strstr(kData2,"real")) {
 495         iDetType->ClassNames("AliITSdigit","AliITSRawClusterSSD");
 496     } else iDetType->ClassNames("AliITSdigitSSD","AliITSRawClusterSSD");
 497
 498     if (kNTYPES>3) {
 499         Warning("SetDefaults",
 500                 "Only the three basic detector types are initialised!");
 501     }  // end if
 502 }
 503 //______________________________________________________________________
 504 void AliITS::SetDefaultSimulation(){
 505     // sets the default simulation
 506
 507     AliITSDetType *iDetType;
 508     iDetType=DetType(0);
 509     if (!iDetType->GetSimulationModel()) {
 510         AliITSsegmentation *seg0=
 511             (AliITSsegmentation*)iDetType->GetSegmentationModel();
 512         AliITSresponse *res0 = (AliITSresponse*)iDetType->GetResponseModel();
 513         AliITSsimulationSPD *sim0=new AliITSsimulationSPD(seg0,res0);
 514         SetSimulationModel(0,sim0);
 515     } // end if
 516     iDetType=DetType(1);
 517     if (!iDetType->GetSimulationModel()) {
 518         AliITSsegmentation *seg1=
 519             (AliITSsegmentation*)iDetType->GetSegmentationModel();
 520         AliITSresponse *res1 = (AliITSresponse*)iDetType->GetResponseModel();
 521         AliITSsimulationSDD *sim1=new AliITSsimulationSDD(seg1,res1);
 522         SetSimulationModel(1,sim1);
 523     } //end if
 524     iDetType=DetType(2);
 525     if (!iDetType->GetSimulationModel()) {
 526         AliITSsegmentation *seg2=
 527             (AliITSsegmentation*)iDetType->GetSegmentationModel();
 528         AliITSresponse *res2 = (AliITSresponse*)iDetType->GetResponseModel();
 529         AliITSsimulationSSD *sim2=new AliITSsimulationSSD(seg2,res2);
 530         SetSimulationModel(2,sim2);
 531     } // end if
 532 }
 533 //______________________________________________________________________
 534 void AliITS::SetDefaultClusterFinders(){
 535     // sets the default cluster finders
 536
 537     MakeTreeC();
 538     AliITSDetType *iDetType;
 539
 540     // SPD
 541     iDetType=DetType(0);
 542     if (!iDetType->GetReconstructionModel()) {
 543         AliITSsegmentation *seg0 =
 544             (AliITSsegmentation*)iDetType->GetSegmentationModel();
 545         TClonesArray *dig0=DigitsAddress(0);
 546         TClonesArray *recp0=ClustersAddress(0);
 547         AliITSClusterFinderSPD *rec0 = new AliITSClusterFinderSPD(seg0,dig0,
 548                                                                   recp0);
 549         SetReconstructionModel(0,rec0);
 550     } // end if
 551
 552     // SDD
 553     iDetType=DetType(1);
 554     if (!iDetType->GetReconstructionModel()) {
 555         AliITSsegmentation *seg1 =
 556             (AliITSsegmentation*)iDetType->GetSegmentationModel();
 557         AliITSresponse *res1 = (AliITSresponse*)iDetType->GetResponseModel();
 558         TClonesArray *dig1=DigitsAddress(1);
 559         TClonesArray *recp1=ClustersAddress(1);
 560         AliITSClusterFinderSDD *rec1 =
 561             new AliITSClusterFinderSDD(seg1,res1,dig1,recp1);
 562       SetReconstructionModel(1,rec1);
 563     } // end if
 564
 565     // SSD
 566     iDetType=DetType(2);
 567     if (!iDetType->GetReconstructionModel()) {
 568         AliITSsegmentation *seg2=
 569             (AliITSsegmentation*)iDetType->GetSegmentationModel();
 570         TClonesArray *dig2=DigitsAddress(2);
 571         AliITSClusterFinderSSD *rec2= new AliITSClusterFinderSSD(seg2,dig2);
 572         SetReconstructionModel(2,rec2);
 573     } // end if
 574 }
 575 //______________________________________________________________________
 576 void AliITS::MakeBranch(Option_t* option, const char *file){
 577     // Creates Tree branches for the ITS.
 578     const char *cS = strstr(option,"S");
 579     const char *cD = strstr(option,"D");
 580     const char *cR = strstr(option,"R");
 581
 582     AliDetector::MakeBranch(option,file);
 583
 584     if(cS) MakeBranchS(file);
 585     if(cD) MakeBranchD(file);
 586     if(cR) MakeBranchR(file);
 587 }
 588 //______________________________________________________________________
 589 void AliITS::SetTreeAddress(){
 590     // Set branch address for the Trees.
 591     TTree *treeS = gAlice->TreeS();
 592     TTree *treeD = gAlice->TreeD();
 593     TTree *treeR = gAlice->TreeR();
 594
 595     AliDetector::SetTreeAddress();
 596
 597     SetTreeAddressS(treeS);
 598     SetTreeAddressD(treeD);
 599     SetTreeAddressR(treeR);
 600 }
 601 //______________________________________________________________________
 602 AliITSDetType* AliITS::DetType(Int_t id){
 603     //return pointer to id detector type
 604
 605     return ((AliITSDetType*) fDetTypes->At(id));
 606 }
 607 //______________________________________________________________________
 608 void AliITS::SetResponseModel(Int_t id, AliITSresponse *response){
 609     //set the response model for the id detector type
 610
 611     ((AliITSDetType*) fDetTypes->At(id))->ResponseModel(response);
 612 }
 613 //______________________________________________________________________
 614 void AliITS::SetSegmentationModel(Int_t id, AliITSsegmentation *seg){
 615     //set the segmentation model for the id detector type
 616
 617     ((AliITSDetType*) fDetTypes->At(id))->SegmentationModel(seg);
 618 }
 619 //______________________________________________________________________
 620 void AliITS::SetSimulationModel(Int_t id, AliITSsimulation *sim){
 621     //set the simulation model for the id detector type
 622
 623    ((AliITSDetType*) fDetTypes->At(id))->SimulationModel(sim);
 624
 625 }
 626 //______________________________________________________________________
 627 void AliITS::SetReconstructionModel(Int_t id, AliITSClusterFinder *reconst){
 628     //set the cluster finder model for the id detector type
 629
 630     ((AliITSDetType*) fDetTypes->At(id))->ReconstructionModel(reconst);
 631 }
 632 //______________________________________________________________________
 633 void AliITS::SetClasses(Int_t id, const char *digit, const char *cluster){
 634     //set the digit and cluster classes to be used for the id detector type
 635
 636     ((AliITSDetType*) fDetTypes->At(id))->ClassNames(digit,cluster);
 637 }
 638 //______________________________________________________________________
 639 void AliITS::AddHit(Int_t track, Int_t *vol, Float_t *hits){
 640     // Add an ITS hit
 641     //     The function to add information to the AliITShit class. See the
 642     // AliITShit class for a full description. This function allocates the
 643     // necessary new space for the hit information and passes the variable
 644     // track, and the pointers *vol and *hits to the AliITShit constructor
 645     // function.
 646
 647     TClonesArray &lhits = *fHits;
 648     new(lhits[fNhits++]) AliITShit(fIshunt,track,vol,hits);
 649 }
 650 //______________________________________________________________________
 651 void AliITS::InitModules(Int_t size,Int_t &nmodules){
 652     //initialize the modules array
 653
 654     if(fITSmodules){
 655         fITSmodules->Delete();
 656         delete fITSmodules;
 657     } // end fir fITSmoudles
 658
 659     Int_t nl,indexMAX,index;
 660
 661     if(size<=0){ // default to using data stored in AliITSgeom
 662         if(fITSgeom==0) {
 663             Error("AliITS::InitModules",
 664                   "in AliITS::InitModule fITSgeom not defined\n");
 665             return;
 666         } // end if fITSgeom==0
 667         nl = fITSgeom->GetNlayers();
 668         indexMAX = fITSgeom->GetModuleIndex(nl,fITSgeom->GetNladders(nl),
 669                                             fITSgeom->GetNdetectors(nl))+1;
 670         nmodules = indexMAX;
 671         fITSmodules = new TObjArray(indexMAX);
 672         for(index=0;index<indexMAX;index++){
 673             fITSmodules->AddAt( new AliITSmodule(index),index);
 674         } // end for index
 675     }else{
 676         fITSmodules = new TObjArray(size);
 677         for(index=0;index<size;index++) {
 678             fITSmodules->AddAt( new AliITSmodule(index),index);
 679         } // end for index
 680
 681         nmodules = size;
 682     } // end i size<=0
 683 }
 684 //______________________________________________________________________
 685 void AliITS::FillModules(Int_t evnt,Int_t bgrev,Int_t nmodules,
 686                          Option_t *option,Text_t *filename){
 687     // fill the modules with the sorted by module hits; add hits from
 688     // background if option=Add
 689     static TTree *trH1;                 //Tree with background hits
 690     static TClonesArray *fHits2;        //List of hits for one track only
 691     static Bool_t first=kTRUE;
 692     static TFile *file;
 693     const char *addBgr = strstr(option,"Add");
 694
 695     if (addBgr ) {
 696         if(first) {
 697             file=new TFile(filename);
 698             fHits2     = new TClonesArray("AliITShit",1000  );
 699         } // end if first
 700         first=kFALSE;
 701         file->cd();
 702         file->ls();
 703         // Get Hits Tree header from file
 704         if(fHits2) fHits2->Clear();
 705         if(trH1) delete trH1;
 706         trH1=0;
 707
 708         char treeName[20];
 709         sprintf(treeName,"TreeH%d",bgrev);
 710         trH1 = (TTree*)gDirectory->Get(treeName);
 711         if (!trH1) {
 712             Error("AliITS::FillModules","cannot find Hits Tree for event:%d\n",
 713                   bgrev);
 714         } // end if !trH1
 715         // Set branch addresses
 716         TBranch *branch;
 717         char branchname[20];
 718         sprintf(branchname,"%s",GetName());
 719         if (trH1 && fHits2) {
 720             branch = trH1->GetBranch(branchname);
 721             if (branch) branch->SetAddress(&fHits2);
 722         } // end if trH1 && fHits
 723     } // end if addBgr
 724
 725     TClonesArray *itsHits = this->Hits();
 726     Int_t lay,lad,det,index;
 727     AliITShit *itsHit=0;
 728     AliITSmodule *mod=0;
 729     TTree *iTH = gAlice->TreeH();
 730     Int_t ntracks =(Int_t) iTH->GetEntries();
 731     Int_t t,h;
 732     for(t=0; t<ntracks; t++){
 733         gAlice->ResetHits();
 734         iTH->GetEvent(t);
 735         Int_t nhits = itsHits->GetEntriesFast();
 736         if (!nhits) continue;
 737         for(h=0; h<nhits; h++){
 738             itsHit = (AliITShit *)itsHits->UncheckedAt(h);
 739             itsHit->GetDetectorID(lay,lad,det);
 740             // temporarily index=det-1 !!!
 741             if(fITSgeom) index = fITSgeom->GetModuleIndex(lay,lad,det);
 742             else index=det-1;
 743             //
 744             mod = this->GetModule(index);
 745             mod->AddHit(itsHit,t,h);
 746         } // end loop over hits
 747     } // end loop over tracks
 748
 749     // open the file with background
 750
 751     if (addBgr ) {
 752         Int_t track,i;
 753         ntracks =(Int_t)trH1->GetEntries();
 754         // Loop over tracks
 755         for (track=0; track<ntracks; track++) {
 756             if (fHits2)       fHits2->Clear();
 757             trH1->GetEvent(track);
 758             //   Loop over hits
 759             for(i=0;i<fHits2->GetEntriesFast();++i) {
 760                 itsHit=(AliITShit*) (*fHits2)[i];
 761                 itsHit->GetDetectorID(lay,lad,det);
 762                 // temporarily index=det-1 !!!
 763                 if(fITSgeom) index = fITSgeom->GetModuleIndex(lay,lad,det);
 764                 else index=det-1;
 765                 //
 766                 mod = this->GetModule(index);
 767                 mod->AddHit(itsHit,track,i);
 768             }  // end loop over hits
 769         } // end loop over tracks
 770         TTree *fAli=gAlice->TreeK();
 771         TFile *fileAli=0;
 772         if (fAli) fileAli =fAli->GetCurrentFile();
 773         fileAli->cd();
 774     } // end if add
 775 }
 776 //______________________________________________________________________
 777 void AliITS::ClearModules(){
 778     //clear the modules TObjArray
 779
 780     if(fITSmodules) fITSmodules->Delete();
 781 }
 782 //______________________________________________________________________
 783 void AliITS::MakeBranchS(const char *file){
 784     // Creates Tree branche for the ITS summable digits.
 785     Int_t buffersize = 4000;
 786     char branchname[30];
 787
 788     // only one branch for SDigits.
 789     sprintf(branchname,"%s",GetName());
 790     if(fSDigits && gAlice->TreeS()){
 791         MakeBranchInTree(gAlice->TreeS(),branchname,&fSDigits,buffersize,file);
 792     } // end if
 793 }
 794 //______________________________________________________________________
 795 void AliITS::SetTreeAddressS(TTree *treeS){
 796     // Set branch address for the ITS summable digits Trees.
 797     char branchname[30];
 798
 799     if(!treeS) return;
 800     TBranch *branch;
 801     sprintf(branchname,"%s",GetName());
 802     branch = treeS->GetBranch(branchname);
 803     if (branch) branch->SetAddress(&fSDigits);
 804 }
 805 //______________________________________________________________________
 806 void AliITS::MakeBranchD(const char *file){
 807     // Creates Tree branches for the ITS.
 808     Int_t buffersize = 4000;
 809     char branchname[30];
 810
 811     sprintf(branchname,"%s",GetName());
 812     // one branch for digits per type of detector
 813     const char *det[3] = {"SPD","SDD","SSD"};
 814     char digclass[40];
 815     char clclass[40];
 816     Int_t i;
 817     for (i=0; i<kNTYPES ;i++) {
 818         DetType(i)->GetClassNames(digclass,clclass);
 819         // digits
 820         if(!(fDtype->At(i))) fDtype->AddAt(new TClonesArray(digclass,1000),i);
 821         else ResetDigits(i);
 822     } // end for i
 823     for (i=0; i<kNTYPES ;i++) {
 824         if (kNTYPES==3) sprintf(branchname,"%sDigits%s",GetName(),det[i]);
 825         else  sprintf(branchname,"%sDigits%d",GetName(),i+1);
 826         if (fDtype && gAlice->TreeD()) {
 827             MakeBranchInTree(gAlice->TreeD(),
 828                              branchname, &((*fDtype)[i]),buffersize,file);
 829         } // end if
 830     } // end for i
 831 }
 832 //______________________________________________________________________
 833 void AliITS::SetTreeAddressD(TTree *treeD){
 834     // Set branch address for the Trees.
 835     char branchname[30];
 836     const char *det[3] = {"SPD","SDD","SSD"};
 837     TBranch *branch;
 838     char digclass[40];
 839     char clclass[40];
 840     Int_t i;
 841
 842     if(!treeD) return;
 843     for (i=0; i<kNTYPES; i++) {
 844         DetType(i)->GetClassNames(digclass,clclass);
 845         // digits
 846         if(!(fDtype->At(i))) fDtype->AddAt(new TClonesArray(digclass,1000),i);
 847         else ResetDigits(i);
 848         if (kNTYPES==3) sprintf(branchname,"%sDigits%s",GetName(),det[i]);
 849         else  sprintf(branchname,"%sDigits%d",GetName(),i+1);
 850         if (fDtype) {
 851             branch = treeD->GetBranch(branchname);
 852             if (branch) branch->SetAddress(&((*fDtype)[i]));
 853         } // end if fDtype
 854     } // end for i
 855 }
 856 //______________________________________________________________________
 857 void AliITS::Hits2SDigits(){
 858     // Standard Hits to summable Digits function.
 859
 860     return; // Using Hits inplace of the larger sDigits.
 861     AliHeader *header=gAlice->GetHeader(); // Get event number from this file.
 862     // Do the Hits to Digits operation. Use Standard input values.
 863     // Event number from file, no background hit merging , use size from
 864     // AliITSgeom class, option="All", input from this file only.
 865     HitsToSDigits(header->GetEvent(),0,-1," ","All"," ");
 866 }
 867 //______________________________________________________________________
 868 void AliITS::Hits2PreDigits(){
 869     // Standard Hits to summable Digits function.
 870
 871     AliHeader *header=gAlice->GetHeader(); // Get event number from this file.
 872     // Do the Hits to Digits operation. Use Standard input values.
 873     // Event number from file, no background hit merging , use size from
 874     // AliITSgeom class, option="All", input from this file only.
 875     HitsToPreDigits(header->GetEvent(),0,-1," ","All"," ");
 876 }
 877 //______________________________________________________________________
 878 void AliITS::SDigits2Digits(){
 879     // Standard Summable digits to Digits function.
 880
 881     Hits2Digits();
 882 }
 883 //______________________________________________________________________
 884 void AliITS::Hits2Digits(){
 885     // Standard Hits to Digits function.
 886
 887     AliHeader *header=gAlice->GetHeader(); // Get event number from this file.
 888     // Do the Hits to Digits operation. Use Standard input values.
 889     // Event number from file, no background hit merging , use size from
 890     // AliITSgeom class, option="All", input from this file only.
 891     HitsToDigits(header->GetEvent(),0,-1," ","All"," ");
 892 }
 893 //______________________________________________________________________
 894 void AliITS::HitsToSDigits(Int_t evNumber,Int_t bgrev,Int_t size,
 895                           Option_t *option, Option_t *opt,Text_t *filename){
 896     // keep galice.root for signal and name differently the file for
 897     // background when add! otherwise the track info for signal will be lost !
 898     // the condition below will disappear when the geom class will be
 899     // initialised for all versions - for the moment it is only for v5 !
 900     // 7 is the SDD beam test version
 901     return; // using Hits instead of the larger sdigits.
 902 }
 903 //______________________________________________________________________
 904 void AliITS::HitsToPreDigits(Int_t evNumber,Int_t bgrev,Int_t size,
 905                           Option_t *option, Option_t *opt,Text_t *filename){
 906     // keep galice.root for signal and name differently the file for
 907     // background when add! otherwise the track info for signal will be lost !
 908     // the condition below will disappear when the geom class will be
 909     // initialised for all versions - for the moment it is only for v5 !
 910     // 7 is the SDD beam test version
 911
 912     if(!GetITSgeom()) return; // need transformations to do digitization.
 913     AliITSgeom *geom = GetITSgeom();
 914
 915     const char *all = strstr(opt,"All");
 916     const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),
 917                           strstr(opt,"SSD")};
 918     static Bool_t setDef=kTRUE;
 919     if (setDef) SetDefaultSimulation();
 920     setDef=kFALSE;
 921
 922     Int_t nmodules;
 923     InitModules(size,nmodules);
 924     FillModules(evNumber,bgrev,nmodules,option,filename);
 925
 926     AliITSsimulation *sim      = 0;
 927     AliITSDetType    *iDetType = 0;
 928     AliITSmodule     *mod      = 0;
 929     Int_t id,module;
 930     for(module=0;module<geom->GetIndexMax();module++){
 931         id       = geom->GetModuleType(module);
 932         if (!all && !det[id]) continue;
 933         iDetType = DetType(id);
 934         sim      = (AliITSsimulation*)iDetType->GetSimulationModel();
 935         if (!sim) {
 936             Error("HitsToSDigits",
 937                   "The simulation class was not instantiated!");
 938             exit(1);
 939         } // end if !sim
 940         mod      = (AliITSmodule *)fITSmodules->At(module);
 941         sim->SDigitiseModule(mod,module,evNumber);
 942         // fills all branches - wasted disk space
 943         gAlice->TreeS()->Fill();
 944         ResetSDigits();
 945     } // end for module
 946
 947     ClearModules();
 948
 949     gAlice->TreeS()->GetEntries();
 950
 951     char hname[30];
 952     sprintf(hname,"TreeS%d",evNumber);
 953     gAlice->TreeS()->Write(hname,TObject::kOverwrite);
 954     // reset tree
 955     gAlice->TreeS()->Reset();
 956 }
 957 //______________________________________________________________________
 958 void AliITS::HitsToDigits(Int_t evNumber,Int_t bgrev,Int_t size,
 959                           Option_t *option, Option_t *opt,Text_t *filename){
 960     // keep galice.root for signal and name differently the file for
 961     // background when add! otherwise the track info for signal will be lost !
 962     // the condition below will disappear when the geom class will be
 963     // initialised for all versions - for the moment it is only for v5 !
 964     // 7 is the SDD beam test version
 965 /*    Int_t ver = this->IsVersion();
 966     if(ver!=5 && ver!=7 && ver!=8 && ver!=9) return;
 967 */
 968     if(!GetITSgeom()) return; // need transformations to do digitization.
 969     AliITSgeom *geom = GetITSgeom();
 970
 971     const char *all = strstr(opt,"All");
 972     const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),
 973                           strstr(opt,"SSD")};
 974     static Bool_t setDef=kTRUE;
 975     if (setDef) SetDefaultSimulation();
 976     setDef=kFALSE;
 977
 978     Int_t nmodules;
 979     InitModules(size,nmodules);
 980     FillModules(evNumber,bgrev,nmodules,option,filename);
 981
 982     AliITSsimulation *sim      = 0;
 983     AliITSDetType    *iDetType = 0;
 984     AliITSmodule     *mod      = 0;
 985     Int_t id,module;
 986     for(module=0;module<geom->GetIndexMax();module++){
 987         id       = geom->GetModuleType(module);
 988         if (!all && !det[id]) continue;
 989         iDetType = DetType(id);
 990         sim      = (AliITSsimulation*)iDetType->GetSimulationModel();
 991         if (!sim) {
 992             Error("HitsToDigits",
 993                   "The simulation class was not instantiated!");
 994             exit(1);
 995         } // end if !sim
 996         mod      = (AliITSmodule *)fITSmodules->At(module);
 997         sim->DigitiseModule(mod,module,evNumber);
 998         // fills all branches - wasted disk space
 999         gAlice->TreeD()->Fill();
1000         ResetDigits();
1001     } // end for module
1002 /*
1003     Int_t id,module;
1004     Int_t first,last;
1005     for (id=0;id<kNTYPES;id++) {
1006         if (!all && !det[id]) continue;
1007         AliITSDetType *iDetType=DetType(id);
1008         sim = (AliITSsimulation*)iDetType->GetSimulationModel();
1009         if(geom) {
1010             first = geom->GetStartDet(id);
1011             last = geom->GetLastDet(id);
1012         } else first=last=0;
1013         for(module=first;module<=last;module++) {
1014             AliITSmodule *mod = (AliITSmodule *)fITSmodules->At(module);
1015             sim->DigitiseModule(mod,module,evNumber);
1016             // fills all branches - wasted disk space
1017             gAlice->TreeD()->Fill();
1018             ResetDigits();
1019         } // loop over modules
1020     } // loop over detector types
1021 */
1022     ClearModules();
1023
1024     gAlice->TreeD()->GetEntries();
1025
1026     char hname[30];
1027     sprintf(hname,"TreeD%d",evNumber);
1028     gAlice->TreeD()->Write(hname,TObject::kOverwrite);
1029     // reset tree
1030     gAlice->TreeD()->Reset();
1031 }
1032 //______________________________________________________________________
1033 void AliITS::ResetSDigits(){
1034     // Reset the Summable Digits array
1035
1036     if (fSDigits) fSDigits->Clear();
1037     fNSDigits = 0;
1038 }
1039 //______________________________________________________________________
1040 void AliITS::ResetDigits(){
1041     // Reset number of digits and the digits array for the ITS detector
1042
1043     if (!fDtype) return;
1044
1045     Int_t i;
1046     for (i=0;i<kNTYPES;i++ ) {
1047         if (fDtype->At(i))    ((TClonesArray*)fDtype->At(i))->Clear();
1048         if (fNdtype)  fNdtype[i]=0;
1049     } // end for i
1050 }
1051 //______________________________________________________________________
1052 void AliITS::ResetDigits(Int_t i){
1053     // Reset number of digits and the digits array for this branch
1054
1055     if (fDtype->At(i))    ((TClonesArray*)fDtype->At(i))->Clear();
1056     if (fNdtype)  fNdtype[i]=0;
1057 }
1058 //______________________________________________________________________
1059 void AliITS::AddSumDigit(AliITSpListItem &sdig){
1060     // adds the a module full of summable digits to the summable digits tree.
1061
1062     TClonesArray &lsdig = *fSDigits;
1063     new(lsdig[fNSDigits++]) AliITSpListItem(sdig);
1064 }
1065 //______________________________________________________________________
1066 void AliITS::AddRealDigit(Int_t id, Int_t *digits){
1067     // add a real digit - as coming from data
1068
1069     TClonesArray &ldigits = *((TClonesArray*)fDtype->At(id));
1070     new(ldigits[fNdtype[id]++]) AliITSdigit(digits);
1071 }
1072 //______________________________________________________________________
1073 void AliITS::AddSimDigit(Int_t id, AliITSdigit *d){
1074     // add a simulated digit
1075
1076     TClonesArray &ldigits = *((TClonesArray*)fDtype->At(id));
1077
1078     switch(id){
1079     case 0:
1080         new(ldigits[fNdtype[id]++]) AliITSdigitSPD(*((AliITSdigitSPD*)d));
1081         break;
1082     case 1:
1083         new(ldigits[fNdtype[id]++]) AliITSdigitSDD(*((AliITSdigitSDD*)d));
1084         break;
1085     case 2:
1086         new(ldigits[fNdtype[id]++]) AliITSdigitSSD(*((AliITSdigitSSD*)d));
1087         break;
1088     } // end switch id
1089 }
1090 //______________________________________________________________________
1091 void AliITS::AddSimDigit(Int_t id,Float_t phys,Int_t *digits,Int_t *tracks,
1092                          Int_t *hits,Float_t *charges){
1093     // add a simulated digit to the list
1094
1095     TClonesArray &ldigits = *((TClonesArray*)fDtype->At(id));
1096     switch(id){
1097     case 0:
1098         new(ldigits[fNdtype[id]++]) AliITSdigitSPD(digits,tracks,hits);
1099         break;
1100     case 1:
1101         new(ldigits[fNdtype[id]++]) AliITSdigitSDD(phys,digits,tracks,
1102                                                    hits,charges);
1103         break;
1104     case 2:
1105         new(ldigits[fNdtype[id]++]) AliITSdigitSSD(digits,tracks,hits);
1106         break;
1107     } // end switch id
1108 }
1109 //______________________________________________________________________
1110 void AliITS::MakeTreeC(Option_t *option){
1111     // create a separate tree to store the clusters
1112
1113     const char *optC = strstr(option,"C");
1114     if (optC && !fTreeC) fTreeC = new TTree("TC","Clusters in ITS");
1115     else return;
1116
1117     Int_t buffersize = 4000;
1118     char branchname[30];
1119     const char *det[3] = {"SPD","SDD","SSD"};
1120     char digclass[40];
1121     char clclass[40];
1122
1123     // one branch for Clusters per type of detector
1124     Int_t i;
1125     for (i=0; i<kNTYPES ;i++) {
1126         AliITSDetType *iDetType=DetType(i);
1127         iDetType->GetClassNames(digclass,clclass);
1128         // clusters
1129         fCtype->AddAt(new TClonesArray(clclass,1000),i);
1130         if (kNTYPES==3) sprintf(branchname,"%sClusters%s",GetName(),det[i]);
1131         else  sprintf(branchname,"%sClusters%d",GetName(),i+1);
1132         if (fCtype   && fTreeC) {
1133             TreeC()->Branch(branchname,&((*fCtype)[i]), buffersize);
1134         } // end if fCtype && fTreeC
1135     } // end for i
1136 }
1137 //______________________________________________________________________
1138 void AliITS::GetTreeC(Int_t event){
1139     // get the clusters tree for this event and set the branch address
1140     char treeName[20];
1141     char branchname[30];
1142     const char *det[3] = {"SPD","SDD","SSD"};
1143
1144     ResetClusters();
1145     if (fTreeC) {
1146         delete fTreeC;
1147     } // end if fTreeC
1148
1149     sprintf(treeName,"TreeC%d",event);
1150     fTreeC = (TTree*)gDirectory->Get(treeName);
1151
1152     TBranch *branch;
1153
1154     if (fTreeC) {
1155         Int_t i;
1156         char digclass[40];
1157         char clclass[40];
1158         for (i=0; i<kNTYPES; i++) {
1159             AliITSDetType *iDetType=DetType(i);
1160             iDetType->GetClassNames(digclass,clclass);
1161             // clusters
1162             if(!fCtype->At(i)) fCtype->AddAt(new TClonesArray(clclass,1000),i);
1163             if(kNTYPES==3) sprintf(branchname,"%sClusters%s",GetName(),det[i]);
1164             else  sprintf(branchname,"%sClusters%d",GetName(),i+1);
1165             if (fCtype) {
1166                 branch = fTreeC->GetBranch(branchname);
1167                 if (branch) branch->SetAddress(&((*fCtype)[i]));
1168             } // end if fCtype
1169         } // end for i
1170     } else {
1171         Error("AliITS::GetTreeC",
1172               "cannot find Clusters Tree for event:%d\n",event);
1173     } // end if fTreeC
1174 }
1175 //______________________________________________________________________
1176 void AliITS::AddCluster(Int_t id, AliITSRawCluster *c){
1177     // add a cluster to the list
1178
1179     TClonesArray &lc = *((TClonesArray*)fCtype->At(id));
1180
1181     switch(id){
1182     case 0:
1183         new(lc[fNctype[id]++]) AliITSRawClusterSPD(*((AliITSRawClusterSPD*)c));
1184         break;
1185     case 1:
1186         new(lc[fNctype[id]++]) AliITSRawClusterSDD(*((AliITSRawClusterSDD*)c));
1187         break;
1188     case 2:
1189         new(lc[fNctype[id]++]) AliITSRawClusterSSD(*((AliITSRawClusterSSD*)c));
1190         break;
1191     } // end switch id
1192 }
1193 //______________________________________________________________________
1194 void AliITS::ResetClusters(){
1195     // Reset number of clusters and the clusters array for ITS
1196
1197     Int_t i;
1198     for (i=0;i<kNTYPES;i++ ) {
1199         if (fCtype->At(i))    ((TClonesArray*)fCtype->At(i))->Clear();
1200         if (fNctype)  fNctype[i]=0;
1201     } // end for i
1202 }
1203 //______________________________________________________________________
1204 void AliITS::ResetClusters(Int_t i){
1205     // Reset number of clusters and the clusters array for this branch
1206
1207     if (fCtype->At(i))    ((TClonesArray*)fCtype->At(i))->Clear();
1208     if (fNctype)  fNctype[i]=0;
1209 }
1210 //______________________________________________________________________
1211 void AliITS::MakeBranchR(const char *file){
1212     // Creates Tree branches for the ITS Reconstructed points.
1213     Int_t buffersize = 4000;
1214     char branchname[30];
1215
1216 //    sprintf(branchname,"%s",GetName());
1217     // only one branch for rec points for all detector types
1218     sprintf(branchname,"%sRecPoints",GetName());
1219     if (fRecPoints && gAlice->TreeR()) {
1220         MakeBranchInTree(gAlice->TreeR(),branchname, &fRecPoints,
1221                          buffersize,file) ;
1222     } // end if
1223 }
1224 //______________________________________________________________________
1225 void AliITS::SetTreeAddressR(TTree *treeR){
1226     // Set branch address for the Reconstructed points Trees.
1227     char branchname[30];
1228
1229     if(!treeR) return;
1230     TBranch *branch;
1231 //    sprintf(branchname,"%s",GetName());
1232     sprintf(branchname,"%sRecPoints",GetName());
1233     branch = treeR->GetBranch(branchname);
1234     if (branch) branch->SetAddress(&fRecPoints);
1235 }
1236 //______________________________________________________________________
1237 void AliITS::AddRecPoint(const AliITSRecPoint &r){
1238     // Add a reconstructed space point to the list
1239
1240     TClonesArray &lrecp = *fRecPoints;
1241     new(lrecp[fNRecPoints++]) AliITSRecPoint(r);
1242 }
1243 //______________________________________________________________________
1244 void AliITS::HitsToFastRecPoints(Int_t evNumber,Int_t bgrev,Int_t size,
1245                                  Option_t *opt0,Option_t *opt1,Text_t *flnm){
1246     // keep galice.root for signal and name differently the file for
1247     // background when add! otherwise the track info for signal will be lost !
1248     // the condition below will disappear when the geom class will be
1249     // initialised for all versions - for the moment it is only for v5 !
1250 /*    Int_t ver = this->IsVersion();
1251     if(ver!=5 && ver!=8 && ver!=9) return;
1252 */
1253     if(!GetITSgeom()) return;
1254     AliITSgeom *geom = GetITSgeom();
1255
1256     const char *all = strstr(opt1,"All");
1257     const char *det[3] ={strstr(opt1,"SPD"),strstr(opt1,"SDD"),
1258                          strstr(opt1,"SSD")};
1259     Int_t nmodules;
1260     InitModules(size,nmodules);
1261     FillModules(evNumber,bgrev,nmodules,opt0,flnm);
1262
1263     AliITSsimulation *sim      = 0;
1264     AliITSDetType    *iDetType = 0;
1265     AliITSmodule     *mod      = 0;
1266     Int_t id,module;
1267     for(module=0;module<geom->GetIndexMax();module++){
1268         id       = geom->GetModuleType(module);
1269         if (!all && !det[id]) continue;
1270         iDetType = DetType(id);
1271         sim      = (AliITSsimulation*)iDetType->GetSimulationModel();
1272         if (!sim) {
1273             Error("HitsToFastPoints",
1274                   "The simulation class was not instantiated!");
1275             exit(1);
1276         } // end if !sim
1277         mod      = (AliITSmodule *)fITSmodules->At(module);
1278         sim->CreateFastRecPoints(mod,module,gRandom);
1279         // fills all branches - wasted disk space
1280         gAlice->TreeD()->Fill();
1281         ResetDigits();
1282     } // end for module
1283 /*
1284     Int_t id,module;
1285     for (id=0;id<kNTYPES;id++) {
1286         if (!all && !det[id]) continue;
1287         AliITSDetType *iDetType=DetType(id);
1288         sim = (AliITSsimulation*)iDetType->GetSimulationModel();
1289         if (!sim) {
1290             Error("HitsToFastPoints",
1291                   "The simulation class was not instantiated!");
1292             exit(1);
1293         } // end if !sim
1294         Int_t first,last;
1295         if(geom) {
1296             first = geom->GetStartDet(id);
1297             last = geom->GetLastDet(id);
1298         } else first=last=0;
1299         for(module=first;module<=last;module++) {
1300             AliITSmodule *mod = (AliITSmodule *)fITSmodules->At(module);
1301             sim->CreateFastRecPoints(mod,module,gRandom);
1302             gAlice->TreeR()->Fill();
1303             ResetRecPoints();
1304         } // loop over modules
1305     } // loop over detector types
1306 */
1307     ClearModules();
1308
1309     char hname[30];
1310     sprintf(hname,"TreeR%d",evNumber);
1311     gAlice->TreeR()->Write(hname,TObject::kOverwrite);
1312     // reset tree
1313     gAlice->TreeR()->Reset();
1314 }
1315 //______________________________________________________________________
1316 void AliITS::Digits2Reco(){
1317     // find clusters and reconstruct space points
1318
1319     AliHeader *header=gAlice->GetHeader();
1320     // to Digits to RecPoints for event in file, all digits in file, and
1321     // all ITS detectors.
1322     DigitsToRecPoints(header->GetEvent(),0,"All");
1323 }
1324 //______________________________________________________________________
1325 void AliITS::DigitsToRecPoints(Int_t evNumber,Int_t lastentry,Option_t *opt){
1326     // cluster finding and reconstruction of space points
1327     // the condition below will disappear when the geom class will be
1328     // initialised for all versions - for the moment it is only for v5 !
1329     // 7 is the SDD beam test version
1330 /*    Int_t ver = this->IsVersion();
1331     if(ver!=5 && ver!=8 && ver!=9) return;
1332 */
1333     if(!GetITSgeom()) return;
1334     AliITSgeom *geom = GetITSgeom();
1335
1336     const char *all = strstr(opt,"All");
1337     const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),
1338                           strstr(opt,"SSD")};
1339     static Bool_t setRec=kTRUE;
1340     if (setRec) SetDefaultClusterFinders();
1341     setRec=kFALSE;
1342
1343     TTree *treeC=TreeC();
1344
1345     AliITSClusterFinder *rec     = 0;
1346     AliITSDetType      *iDetType = 0;
1347     Int_t id,module,first=0;
1348     for(module=0;module<geom->GetIndexMax();module++){
1349         id       = geom->GetModuleType(module);
1350         if (!all && !det[id]) continue;
1351         if(det[id]) first = geom->GetStartDet(id);
1352         iDetType = DetType(id);
1353         rec = (AliITSClusterFinder*)iDetType->GetReconstructionModel();
1354         TClonesArray *itsDigits  = this->DigitsAddress(id);
1355         if (!rec) {
1356             Error("DigitsToRecPoints",
1357                   "The reconstruction class was not instantiated!");
1358             exit(1);
1359         } // end if !rec
1360         this->ResetDigits();
1361         if (all) gAlice->TreeD()->GetEvent(lastentry+module);
1362         else gAlice->TreeD()->GetEvent(lastentry+(module-first));
1363         Int_t ndigits = itsDigits->GetEntriesFast();
1364         if (ndigits) rec->FindRawClusters(module);
1365         gAlice->TreeR()->Fill();
1366         ResetRecPoints();
1367         treeC->Fill();
1368         ResetClusters();
1369     } // end for module
1370
1371 /*
1372     Int_t id,module;
1373     for (id=0;id<kNTYPES;id++) {
1374         if (!all && !det[id]) continue;
1375         AliITSDetType *iDetType=DetType(id);
1376         rec = (AliITSClusterFinder*)iDetType->GetReconstructionModel();
1377         TClonesArray *itsDigits  = this->DigitsAddress(id);
1378         Int_t first,last;
1379         if(geom) {
1380             first = geom->GetStartDet(id);
1381             last = geom->GetLastDet(id);
1382         } else first=last=0;
1383         printf("first module - last module %d %d\n",first,last);
1384         for(module=first;module<=last;module++) {
1385             this->ResetDigits();
1386             if (all) gAlice->TreeD()->GetEvent(lastentry+module);
1387             else gAlice->TreeD()->GetEvent(lastentry+(module-first));
1388             Int_t ndigits = itsDigits->GetEntriesFast();
1389             if (ndigits) rec->FindRawClusters(module);
1390             gAlice->TreeR()->Fill();
1391             ResetRecPoints();
1392             treeC->Fill();
1393             ResetClusters();
1394         } // loop over modules
1395     } // loop over detector types
1396 */
1397     gAlice->TreeR()->GetEntries();
1398     treeC->GetEntries();
1399
1400     char hname[30];
1401     sprintf(hname,"TreeR%d",evNumber);
1402     gAlice->TreeR()->Write(hname,TObject::kOverwrite);
1403     // reset tree
1404     gAlice->TreeR()->Reset();
1405
1406     sprintf(hname,"TreeC%d",evNumber);
1407     treeC->Write(hname,TObject::kOverwrite);
1408     treeC->Reset();
1409 }
1410 //______________________________________________________________________
1411 void AliITS::ResetRecPoints(){
1412     // Reset number of rec points and the rec points array
1413
1414     if (fRecPoints) fRecPoints->Clear();
1415     fNRecPoints = 0;
1416 }