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.69  2002/05/05 21:06:55  nilsen
  19 Added GetSimulationMoel, and fixed up SetDefaultSimulation to do the
  20 proper initilization when a simulation has already been defined.
  21
  22 Revision 1.68  2002/05/02 18:51:53  nilsen
  23 AliITS.h
  24    Method MakeBranchR has now a second argument, with a default value:
  25        Option_t *opt=" ". Opt="Fast" is to create a separate branch
  26        for fast points in TreeR
  27    New method MakeBranchRF: it a separate branch in TreeR for Fast Points
  28
  29 AliITS.cxx
  30 1) TTree->Write() replaced with TTree->AutoSave for TreeS, TreeD and
  31    TreeR
  32 2) Changes in MakeBranchR to allow the creation of a special branch
  33    for fast points
  34
  35 Revision 1.67  2002/03/15 17:22:51  nilsen
  36 Intoduced SDigits2Digits and SDigitsToDigits functions.
  37
  38 Revision 1.66  2001/11/28 01:35:45  nilsen
  39 Using standard constructors instead of default constructors for Clusterfinder,
  40 Response, and FastSimulator.
  41
  42 Revision 1.65  2001/11/27 16:27:28  nilsen
  43 Adding AliITSDigitizer class to do merging and digitization . Based on the
  44 TTask method. AliITSDigitizer class added to the Makefile and ITSLinkDef.h
  45 file. The following files required minor changes. AliITS, added functions
  46 SetHitsAddressBranch, MakeBranchInTreeD and modified MakeBranchD.
  47 AliITSsimulationSDD.cxx needed a Tree indepenent way of returning back to
  48 the original Root Directory in function Compress1D. Now it uses gDirectory.
  49
  50 Revision 1.64  2001/11/19 16:17:02  nilsen
  51 Applyed fixes to bugs found by Rene Brun. With many thanks. Some additonal
  52 bugs found by Rene require more work to fix. Will be fixed soon.
  53
  54 Revision 1.63  2001/10/24 21:16:34  nilsen
  55 Removed some dead code and improved comments/documntation.
  56
  57 Revision 1.62  2001/10/21 19:23:21  nilsen
  58 Added function to allow to limit which detectors to digitize and reconstruct.
  59 The default is All. This change makes no changes to any root file.
  60
  61 Revision 1.61  2001/10/11 15:26:07  mariana
  62 Correct HitsToFastRecPoints
  63
  64 Revision 1.60  2001/10/04 22:38:10  nilsen
  65 Changes made to support PreDigits (SDigits) plus other helpful changes.
  66
  67 Revision 1.59  2001/08/30 09:56:18  hristov
  68 The operator[] is replaced by At() or AddAt() in case of TObjArray.
  69
  70 Revision 1.58  2001/07/26 15:05:29  hristov
  71 Use global gRandom generator (M.Ivanov)
  72
  73 Revision 1.57  2001/07/24 14:26:11  mariana
  74 Introduce the function Digits2Reco() and write the defaults for simulation and reconstruction
  75
  76 Revision 1.56  2001/07/05 12:49:49  mariana
  77 Temporary patches required by root.v3.01.05
  78
  79 Revision 1.55  2001/06/14 14:59:00  barbera
  80 Tracking V1 decoupled from AliITS
  81
  82 Revision 1.54  2001/05/31 20:37:56  barbera
  83 Bari/Salerno model set as defaault SPD simulation
  84
  85 Revision 1.53  2001/05/31 18:52:24 barbera
  86 Bari model becomes the default
  87
  88 Revision 1.53  2001/05/30 07:52:24  hristov
  89 TPC and CONTAINERS included in the search path
  90
  91 Revision 1.52  2001/05/30 06:04:58  hristov
  92 Changes made to be consitant with changes in TPC tracking classes (B.Nilsen)
  93
  94 Revision 1.51  2001/05/16 14:57:15  alibrary
  95 New files for folders and Stack
  96
  97 Revision 1.50  2001/05/11 09:15:21  barbera
  98 Corrected to make fast point creation working with PPR geometry
  99
 100 Revision 1.49  2001/05/11 07:37:49  hristov
 101 Legacy lines commented
 102
 103 Revision 1.48  2001/05/10 18:14:25  barbera
 104 A typo corrected
 105
 106 Revision 1.47  2001/05/10 17:55:59  barbera
 107 Modified to create rec points also for PPR geometries
 108
 109 Revision 1.46  2001/05/10 00:05:28  nilsen
 110 Allowed for HitsToDigits function to work with versions 5, 7, 8, and 9. This
 111 should probably be cleaned up to only check to make sure that fITSgeom has
 112 been properly defined.
 113
 114 Revision 1.45  2001/05/01 22:35:48  nilsen
 115 Remove/commented a number of cout<< statements. and made change needed by
 116 SSD code.
 117
 118 Revision 1.44  2001/04/26 22:44:01  nilsen
 119 Removed dependence on layer 5/6 in AliITS::HitsToDigits. This will be
 120 done properly in AliITSv???.cxx via SetDefaults.
 121
 122 Revision 1.43  2001/04/26 13:22:52  barbera
 123 TMatrix and TVector elimininated to speed up the code
 124
 125 Revision 1.42  2001/04/25 21:55:12  barbera
 126 Updated version to be compatible with actual verion of STEER and TPC
 127
 128 Revision 1.41  2001/04/21 15:16:51  barbera
 129 Updated with the new SSD reconstruction code
 130
 131 Revision 1.40  2001/03/17 15:07:06  mariana
 132 Update SDD response parameters
 133
 134 Revision 1.39  2001/03/12 17:45:32  hristov
 135 Changes needed on Sun with CC 5.0
 136
 137 Revision 1.38  2001/03/07 14:04:51  barbera
 138 Some vector dimensions increased to cope with full events
 139
 140 Revision 1.37  2001/03/07 12:36:35  barbera
 141 A change added in the tracking part to manage delta rays
 142
 143 Revision 1.36  2001/03/02 19:44:11  barbera
 144  modified to taking into account new version tracking v1
 145
 146 Revision 1.35  2001/02/28 18:16:46  mariana
 147 Make the code compatible with the new AliRun
 148
 149 Revision 1.34  2001/02/11 15:51:39  mariana
 150 Set protection in MakeBranch
 151
 152 Revision 1.33  2001/02/10 22:26:39  mariana
 153 Move the initialization of the containers for raw clusters in MakeTreeC()
 154
 155 Revision 1.32  2001/02/08 23:55:31  nilsen
 156 Removed fMajor/MinorVersion variables in favor of variables in derived classes.
 157 Set arrays char *det[3] = {"SPD","SDD","SSD"} as const.
 158
 159 Revision 1.31  2001/02/02 23:57:28  nilsen
 160 Added include file that are no londer included in AliITSgeom.h
 161
 162 Revision 1.30  2001/01/30 09:23:13  hristov
 163 Streamers removed (R.Brun)
 164
 165 Revision 1.29  2001/01/26 20:01:09  hristov
 166 Major upgrade of AliRoot code
 167
 168 Revision 1.28  2000/12/18 14:02:00  barbera
 169 new version of the ITS tracking to take into account the new TPC track parametrization
 170
 171 Revision 1.27  2000/12/08 13:49:27  barbera
 172 Hidden declaration in a for loop removed to be compliant with HP-UX compiler
 173
 174 Revision 1.26  2000/11/27 13:12:13  barbera
 175 New version containing the files for tracking
 176
 177 Revision 1.25  2000/11/12 22:38:05  barbera
 178 Added header file for the SPD Bari model
 179
 180 Revision 1.24  2000/10/09 22:18:12  barbera
 181 Bug fixes from MAriana to le AliITStest.C run correctly
 182
 183 Revision 1.23  2000/10/05 20:47:42  nilsen
 184 fixed dependencies of include files. Tryed but failed to get a root automaticly
 185 generates streamer function to work. Modified SetDefaults.
 186
 187 Revision 1.9.2.15  2000/10/04 16:56:40  nilsen
 188 Needed to include stdlib.h
 189
 190 =======
 191 Revision 1.22  2000/10/04 19:45:52  barbera
 192 Corrected by F. Carminati for v3.04
 193
 194 Revision 1.21  2000/10/02 21:28:08  fca
 195 Removal of useless dependecies via forward declarations
 196
 197 Revision 1.20  2000/10/02 16:31:39  barbera
 198 General code clean-up
 199
 200 Revision 1.9.2.14  2000/10/02 15:43:51  barbera
 201 General code clean-up (e.g., printf -> cout)
 202
 203 Revision 1.19  2000/09/22 12:13:25  nilsen
 204 Patches and updates for fixes to this and other routines.
 205
 206 Revision 1.18  2000/07/12 05:32:20  fca
 207 Correcting several syntax problem with static members
 208
 209 Revision 1.17  2000/07/10 16:07:18  fca
 210 Release version of ITS code
 211
 212 Revision 1.9.2.3  2000/02/02 13:42:09  barbera
 213 fixed AliITS.cxx for new AliRun structure. Added ITS hits list to list of hits which will have their track numbers updated
 214
 215 Revision 1.9.2.2  2000/01/23 03:03:13  nilsen
 216 //fixed FillModule. Removed fi(fabs(xl)<dx....
 217
 218 Revision 1.9.2.1  2000/01/12 19:03:32  nilsen
 219 This is the version of the files after the merging done in December 1999.
 220 See the ReadMe110100.txt file for details
 221
 222 Revision 1.9  1999/11/14 14:33:25  fca
 223 Correct problems with distructors and pointers, thanks to I.Hrivnacova
 224
 225 Revision 1.8  1999/09/29 09:24:19  fca
 226 Introduction of the Copyright and cvs Log
 227
 228 */
 229
 230 ///////////////////////////////////////////////////////////////////////////////
 231 //
 232 //      An overview of the basic philosophy of the ITS code development
 233 // and analysis is show in the figure below.
 234 //Begin_Html
 235 /*
 236 <img src="picts/ITS/ITS_Analysis_schema.gif">
 237 </pre>
 238 <br clear=left>
 239 <font size=+2 color=red>
 240 <p>Roberto Barbera is in charge of the ITS Offline code (1999).
 241 <a href="mailto:roberto.barbera@ct.infn.it">Roberto Barbera</a>.
 242 </font>
 243 <pre>
 244 */
 245 //End_Html
 246 //
 247 //  AliITS. Inner Traking System base class.
 248 //  This class contains the base procedures for the Inner Tracking System
 249 //
 250 //Begin_Html
 251 /*
 252 <img src="picts/ITS/AliITS_Class_Diagram.gif">
 253 </pre>
 254 <br clear=left>
 255 <font size=+2 color=red>
 256 <p>This show the class diagram of the different elements that are part of
 257 the AliITS class.
 258 </font>
 259 <pre>
 260 */
 261 //End_Html
 262 //
 263 // Version: 0
 264 // Written by Rene Brun, Federico Carminati, and Roberto Barbera
 265 //
 266 // Version: 1
 267 // Modified and documented by Bjorn S. Nilsen
 268 // July 11 1999
 269 //
 270 // Version: 2
 271 // Modified and documented by A. Bologna
 272 // October 18 1999
 273 //
 274 // AliITS is the general base class for the ITS. Also see AliDetector for
 275 // futher information.
 276 //
 277 ///////////////////////////////////////////////////////////////////////////////
 278 #include <iostream.h>
 279 #include <iomanip.h>
 280 #include <fstream.h>
 281 #include <stdlib.h>
 282 #include <TMath.h>
 283 #include <TRandom.h>
 284 #include <TBranch.h>
 285 #include <TVector.h>
 286 #include <TClonesArray.h>
 287 #include <TROOT.h>
 288 #include <TObjectTable.h>
 289 #include <TFile.h>
 290 #include <TTree.h>
 291 #include <TString.h>
 292
 293 #include "AliMC.h"
 294 #include "AliHeader.h"
 295
 296 #include "AliITS.h"
 297 #include "AliITSDetType.h"
 298 #include "AliITSresponseSPD.h"
 299 #include "AliITSresponseSDD.h"
 300 #include "AliITSresponseSSD.h"
 301 #include "AliITSsegmentationSPD.h"
 302 #include "AliITSsegmentationSDD.h"
 303 #include "AliITSsegmentationSSD.h"
 304 #include "AliITSsimulationSPD.h"
 305 #include "AliITSsimulationSDD.h"
 306 #include "AliITSsimulationSSD.h"
 307 #include "AliITSClusterFinderSPD.h"
 308 #include "AliITSClusterFinderSDD.h"
 309 #include "AliITSClusterFinderSSD.h"
 310 #include "AliITShit.h"
 311 #include "AliITSgeom.h"
 312 #include "AliITSpList.h"
 313 #include "AliITSdigit.h"
 314 #include "AliITSmodule.h"
 315 #include "AliITSRecPoint.h"
 316 #include "AliITSRawCluster.h"
 317
 318 ClassImp(AliITS)
 319
 320 //______________________________________________________________________
 321 AliITS::AliITS() : AliDetector() {
 322     // Default initializer for ITS
 323     //      The default constructor of the AliITS class. In addition to
 324     // creating the AliITS class it zeros the variables fIshunt (a member
 325     // of AliDetector class), fEuclidOut, and fIdN, and zeros the pointers
 326     // fITSpoints, fIdSens, and fIdName. The AliDetector default constructor
 327     // is also called.
 328     // Inputs:
 329     //      none.
 330     // Outputs:
 331     //      none.
 332     // Return:
 333     //      Blank ITS class.
 334
 335     fIshunt     = 0;   // not zeroed in AliDetector.
 336
 337     // AliITS variables.
 338     fEuclidOut  = 0;
 339     fITSgeom    = 0;
 340     fITSmodules = 0;
 341     fOpt        = "All";
 342 //    SetDetectors(); // default to fOpt="All". This variable not written out.
 343
 344     fIdN        = 0;
 345     fIdName     = 0;
 346     fIdSens     = 0;
 347
 348     fNDetTypes  = kNTYPES;
 349     fDetTypes   = 0;
 350
 351     fSDigits    = 0;
 352     fNSDigits   = 0;
 353
 354     fNdtype     = 0;
 355     fDtype      = 0;
 356
 357     fCtype      = 0;
 358     fNctype     = 0;
 359     fTreeC      = 0;
 360
 361     fRecPoints  = 0;
 362     fNRecPoints = 0;
 363
 364     SetMarkerColor(kRed);
 365 }
 366 //______________________________________________________________________
 367 AliITS::AliITS(const char *name, const char *title):AliDetector(name,title){
 368     //     The standard Constructor for the ITS class. In addition to
 369     // creating the AliITS class, it allocates memory for the TClonesArrays
 370     // fHits, fSDigits, fDigits, fITSpoints, and the TObjArray of fCtype
 371     // (clusters). It also zeros the variables
 372     // fIshunt (a member of AliDetector class), fEuclidOut, and fIdN, and zeros
 373     // the pointers fIdSens and fIdName. To help in displaying hits via the
 374     // ROOT macro display.C AliITS also sets the marker color to red. The
 375     // variables passes with this constructor, const char *name and *title,
 376     // are used by the constructor of AliDetector class. See AliDetector
 377     // class for a description of these parameters and its constructor
 378     // functions.
 379     // Inputs:
 380     //      const char *name      Detector name. Should always be "ITS"
 381     //      const char *title     Detector title.
 382     // Outputs:
 383     //      none.
 384     // Return:
 385     //      An ITS class.
 386
 387     fIshunt     = 0;  // not zeroed in AliDetector
 388     fHits       = new TClonesArray("AliITShit", 1560);//not done in AliDetector
 389     gAlice->AddHitList(fHits);  // Not done in AliDetector.
 390
 391     fEuclidOut  = 0;
 392     fITSgeom    = 0;
 393     fITSmodules = 0;
 394     SetDetectors(); // default to fOpt="All". This variable not written out.
 395
 396     fIdN        = 0;
 397     fIdName     = 0;
 398     fIdSens     = 0;
 399
 400     fNDetTypes  = kNTYPES;
 401     fDetTypes   = new TObjArray(fNDetTypes);
 402
 403     fSDigits    = new TClonesArray("AliITSpListItem",1000);
 404     fNSDigits   = 0;
 405
 406     fNdtype     = new Int_t[fNDetTypes];
 407     fDtype      = new TObjArray(fNDetTypes);
 408
 409     fCtype      = new TObjArray(fNDetTypes);
 410     fNctype     = new Int_t[fNDetTypes];
 411     fTreeC      = 0;
 412
 413     fRecPoints  = new TClonesArray("AliITSRecPoint",1000);
 414     fNRecPoints = 0;
 415
 416     Int_t i;
 417     for(i=0;i<fNDetTypes;i++) {
 418         fDetTypes->AddAt(new AliITSDetType(),i);
 419         fNdtype[i] = 0;
 420         fNctype[i] = 0;
 421     } // end for i
 422
 423     SetMarkerColor(kRed);
 424 }
 425 //______________________________________________________________________
 426 AliITS::~AliITS(){
 427     // Default destructor for ITS.
 428     //     The default destructor of the AliITS class. In addition to deleting
 429     // the AliITS class it deletes the memory pointed to by the fHits, fDigits,
 430     // fSDigits, fCtype, fITSmodules, fITSgeom, fRecPoints, fIdSens, fIdName,
 431     // fITSpoints, fDetType and it's contents.
 432     // Inputs:
 433     //      none.
 434     // Outputs:
 435     //      none.
 436     // Return:
 437     //      none.
 438
 439     delete fHits;
 440     delete fSDigits;
 441     delete fDigits;
 442     delete fRecPoints;
 443     if(fIdName!=0) delete[] fIdName;  // Array of TStrings
 444     if(fIdSens!=0) delete[] fIdSens;
 445     if(fITSmodules!=0) {
 446         this->ClearModules();
 447         delete fITSmodules;
 448     }// end if fITSmodules!=0
 449
 450     if(fDtype) {
 451         fDtype->Delete();
 452         delete fDtype;
 453     } // end if fDtype
 454     delete [] fNdtype;
 455     if (fCtype) {
 456         fCtype->Delete();
 457         delete fCtype;
 458     } // end if fCtype
 459     delete [] fNctype;
 460
 461     if (fDetTypes) {
 462         fDetTypes->Delete();
 463         delete fDetTypes;
 464     } // end if fDetTypes
 465
 466     if (fTreeC) delete fTreeC;
 467
 468     if (fITSgeom) delete fITSgeom;
 469 }
 470 //______________________________________________________________________
 471 AliITS::AliITS(AliITS &source){
 472     // Copy constructor. This is a function which is not allowed to be
 473     // done to the ITS. It exits with an error.
 474     // Inputs:
 475     //      AliITS &source  An AliITS class.
 476     // Outputs:
 477     //      none.
 478     // Return:
 479     //      none.
 480
 481     if(this==&source) return;
 482     Error("Copy constructor",
 483           "You are not allowed to make a copy of the AliITS");
 484     exit(1);
 485 }
 486 //______________________________________________________________________
 487 AliITS& AliITS::operator=(AliITS &source){
 488     // Assignment operator. This is a function which is not allowed to be
 489     // done to the ITS. It exits with an error.
 490     // Inputs:
 491     //      AliITS &source  An AliITS class.
 492     // Outputs:
 493     //      none.
 494     // Return:
 495     //      none.
 496
 497     if(this==&source) return *this;
 498     Error("operator=","You are not allowed to make a copy of the AliITS");
 499     exit(1);
 500     return *this; //fake return
 501 }
 502 //______________________________________________________________________
 503 Int_t AliITS::DistancetoPrimitive(Int_t,Int_t){
 504     // Distance from mouse to ITS on the screen. Dummy routine
 505     //     A dummy routine used by the ROOT macro display.C to allow for the
 506     // use of the mouse (pointing device) in the macro. In general this should
 507     // never be called. If it is it returns the number 9999 for any value of
 508     // x and y.
 509     // Inputs:
 510     //      Int_t     Dummy screen coordinate.
 511     //      Int_t     Dummy screen coordinate.
 512     // Outputs:
 513     //      none.
 514     // Return:
 515     //      Int_t     Dummy = 9999 distance to ITS.
 516
 517     return 9999;
 518 }
 519 //______________________________________________________________________
 520 void AliITS::Init(){
 521     // Initializer ITS after it has been built
 522     //     This routine initializes the AliITS class. It is intended to be
 523     // called from the Init function in AliITSv?. Besides displaying a banner
 524     // indicating that it has been called it initializes the array fIdSens
 525     // and sets the default segmentation, response, digit and raw cluster
 526     // classes therefore it should be called after a call to CreateGeometry.
 527     // Inputs:
 528     //      none.
 529     // Outputs:
 530     //      none.
 531     // Return:
 532     //      none.
 533     Int_t i;
 534
 535     SetDefaults();
 536     // Array of TStrings
 537     for(i=0;i<fIdN;i++) fIdSens[i] = gMC->VolId(fIdName[i]);
 538 }
 539 //______________________________________________________________________
 540 void AliITS::SetDefaults(){
 541     // sets the default segmentation, response, digit and raw cluster classes.
 542     // Inputs:
 543     //      none.
 544     // Outputs:
 545     //      none.
 546     // Return:
 547     //      none.
 548
 549     if(fDebug) printf("%s: SetDefaults\n",ClassName());
 550
 551     AliITSDetType *iDetType;
 552
 553     //SPD
 554     iDetType=DetType(0);
 555     if (!iDetType->GetSegmentationModel()) {
 556         AliITSsegmentationSPD *seg0=new AliITSsegmentationSPD(fITSgeom);
 557         SetSegmentationModel(0,seg0);
 558     } // end if
 559     if (!iDetType->GetResponseModel()) {
 560         SetResponseModel(0,new AliITSresponseSPD());
 561     } // end if
 562     // set digit and raw cluster classes to be used
 563
 564     const char *kData0=(iDetType->GetResponseModel())->DataType();
 565     if (strstr(kData0,"real")) {
 566         iDetType->ClassNames("AliITSdigit","AliITSRawClusterSPD");
 567     } else iDetType->ClassNames("AliITSdigitSPD","AliITSRawClusterSPD");
 568
 569     // SDD
 570     iDetType=DetType(1);
 571     if (!iDetType->GetResponseModel()) {
 572         SetResponseModel(1,new AliITSresponseSDD("simulated"));
 573     } // end if
 574     AliITSresponse *resp1=iDetType->GetResponseModel();
 575     if (!iDetType->GetSegmentationModel()) {
 576         AliITSsegmentationSDD *seg1=new AliITSsegmentationSDD(fITSgeom,resp1);
 577         SetSegmentationModel(1,seg1);
 578     } // end if
 579     const char *kData1=(iDetType->GetResponseModel())->DataType();
 580     const char *kopt=iDetType->GetResponseModel()->ZeroSuppOption();
 581     if((!strstr(kopt,"2D"))&&(!strstr(kopt,"1D")) || strstr(kData1,"real") ){
 582         iDetType->ClassNames("AliITSdigit","AliITSRawClusterSDD");
 583     } else iDetType->ClassNames("AliITSdigitSDD","AliITSRawClusterSDD");
 584
 585     // SSD
 586     iDetType=DetType(2);
 587     if (!iDetType->GetSegmentationModel()) {
 588         AliITSsegmentationSSD *seg2=new AliITSsegmentationSSD(fITSgeom);
 589         SetSegmentationModel(2,seg2);
 590     } // end if
 591     if (!iDetType->GetResponseModel()) {
 592         SetResponseModel(2,new AliITSresponseSSD("simulated"));
 593     } // end if
 594     const char *kData2=(iDetType->GetResponseModel())->DataType();
 595     if (strstr(kData2,"real")) {
 596         iDetType->ClassNames("AliITSdigit","AliITSRawClusterSSD");
 597     } else iDetType->ClassNames("AliITSdigitSSD","AliITSRawClusterSSD");
 598
 599     if (kNTYPES>3) {
 600         Warning("SetDefaults",
 601                 "Only the three basic detector types are initialized!");
 602     }  // end if
 603 }
 604 //______________________________________________________________________
 605 void AliITS::SetDefaultSimulation(){
 606     // sets the default simulation.
 607     // Inputs:
 608     //      none.
 609     // Outputs:
 610     //      none.
 611     // Return:
 612     //      none.
 613
 614     AliITSDetType *iDetType;
 615     AliITSsimulation *sim;
 616     iDetType=DetType(0);
 617     sim = iDetType->GetSimulationModel();
 618     if (!sim) {
 619         AliITSsegmentation *seg0=
 620             (AliITSsegmentation*)iDetType->GetSegmentationModel();
 621         AliITSresponse *res0 = (AliITSresponse*)iDetType->GetResponseModel();
 622         AliITSsimulationSPD *sim0=new AliITSsimulationSPD(seg0,res0);
 623         SetSimulationModel(0,sim0);
 624     }else{ // simulation exists, make sure it is set up properly.
 625         ((AliITSsimulationSPD*)sim)->Init(
 626             (AliITSsegmentationSPD*) iDetType->GetSegmentationModel(),
 627             (AliITSresponseSPD*) iDetType->GetResponseModel());
 628 //      if(sim->GetResponseModel()==0) sim->SetResponseModel(
 629 //          (AliITSresponse*)iDetType->GetResponseModel());
 630 //      if(sim->GetSegmentationModel()==0) sim->SetSegmentationModel(
 631 //          (AliITSsegmentation*)iDetType->GetSegmentationModel());
 632     } // end if
 633     iDetType=DetType(1);
 634     sim = iDetType->GetSimulationModel();
 635     if (!sim) {
 636         AliITSsegmentation *seg1=
 637             (AliITSsegmentation*)iDetType->GetSegmentationModel();
 638         AliITSresponse *res1 = (AliITSresponse*)iDetType->GetResponseModel();
 639         AliITSsimulationSDD *sim1=new AliITSsimulationSDD(seg1,res1);
 640         SetSimulationModel(1,sim1);
 641     }else{ // simulation exists, make sure it is set up properly.
 642         ((AliITSsimulationSDD*)sim)->Init(
 643             (AliITSsegmentationSDD*) iDetType->GetSegmentationModel(),
 644             (AliITSresponseSDD*) iDetType->GetResponseModel());
 645 //      if(sim->GetResponseModel()==0) sim->SetResponseModel(
 646 //          (AliITSresponse*)iDetType->GetResponseModel());
 647 //      if(sim->GetSegmentationModel()==0) sim->SetSegmentationModel(
 648 //          (AliITSsegmentation*)iDetType->GetSegmentationModel());
 649     } //end if
 650     iDetType=DetType(2);
 651     sim = iDetType->GetSimulationModel();
 652     if (!sim) {
 653         AliITSsegmentation *seg2=
 654             (AliITSsegmentation*)iDetType->GetSegmentationModel();
 655         AliITSresponse *res2 = (AliITSresponse*)iDetType->GetResponseModel();
 656         AliITSsimulationSSD *sim2=new AliITSsimulationSSD(seg2,res2);
 657         SetSimulationModel(2,sim2);
 658     }else{ // simulation exists, make sure it is set up properly.
 659         ((AliITSsimulationSSD*)sim)->Init(
 660             (AliITSsegmentationSSD*) iDetType->GetSegmentationModel(),
 661             (AliITSresponseSSD*) iDetType->GetResponseModel());
 662 //      if(sim->GetResponseModel()==0) sim->SetResponseModel(
 663 //          (AliITSresponse*)iDetType->GetResponseModel());
 664 //      if(sim->GetSegmentationModel()==0) sim->SetSegmentationModel(
 665 //          (AliITSsegmentation*)iDetType->GetSegmentationModel());
 666     } // end if
 667 }
 668 //______________________________________________________________________
 669 void AliITS::SetDefaultClusterFinders(){
 670     // Sets the default cluster finders. Used in finding RecPoints.
 671     // Inputs:
 672     //      none.
 673     // Outputs:
 674     //      none.
 675     // Return:
 676     //      none.
 677
 678     MakeTreeC();
 679     AliITSDetType *iDetType;
 680
 681     // SPD
 682     iDetType=DetType(0);
 683     if (!iDetType->GetReconstructionModel()) {
 684         AliITSsegmentation *seg0 =
 685             (AliITSsegmentation*)iDetType->GetSegmentationModel();
 686         TClonesArray *dig0=DigitsAddress(0);
 687         TClonesArray *recp0=ClustersAddress(0);
 688         AliITSClusterFinderSPD *rec0 = new AliITSClusterFinderSPD(seg0,dig0,
 689                                                                   recp0);
 690         SetReconstructionModel(0,rec0);
 691     } // end if
 692
 693     // SDD
 694     iDetType=DetType(1);
 695     if (!iDetType->GetReconstructionModel()) {
 696         AliITSsegmentation *seg1 =
 697             (AliITSsegmentation*)iDetType->GetSegmentationModel();
 698         AliITSresponse *res1 = (AliITSresponse*)iDetType->GetResponseModel();
 699         TClonesArray *dig1=DigitsAddress(1);
 700         TClonesArray *recp1=ClustersAddress(1);
 701         AliITSClusterFinderSDD *rec1 =
 702             new AliITSClusterFinderSDD(seg1,res1,dig1,recp1);
 703       SetReconstructionModel(1,rec1);
 704     } // end if
 705
 706     // SSD
 707     iDetType=DetType(2);
 708     if (!iDetType->GetReconstructionModel()) {
 709         AliITSsegmentation *seg2=
 710             (AliITSsegmentation*)iDetType->GetSegmentationModel();
 711         TClonesArray *dig2=DigitsAddress(2);
 712         AliITSClusterFinderSSD *rec2= new AliITSClusterFinderSSD(seg2,dig2);
 713         SetReconstructionModel(2,rec2);
 714     } // end if
 715 }
 716 //______________________________________________________________________
 717 void AliITS::MakeBranch(Option_t* option, const char *file){
 718     // Creates Tree branches for the ITS.
 719     // Inputs:
 720     //      Option_t *option    String of Tree types S,D, and/or R.
 721     //      const char *file    String of the file name where these branches
 722     //                          are to be stored. If blank then these branches
 723     //                          are written to the same tree as the Hits were
 724     //                          read from.
 725     // Outputs:
 726     //      none.
 727     // Return:
 728     //      none.
 729     Bool_t cS = (strstr(option,"S")!=0);
 730     Bool_t cD = (strstr(option,"D")!=0);
 731     Bool_t cR = (strstr(option,"R")!=0);
 732     Bool_t cRF = (strstr(option,"RF")!=0);
 733     if(cRF)cR = kFALSE;
 734
 735     AliDetector::MakeBranch(option,file);
 736
 737     if(cS) MakeBranchS(file);
 738     if(cD) MakeBranchD(file);
 739     if(cR) MakeBranchR(file);
 740     if(cRF) MakeBranchRF(file);
 741 }
 742 //______________________________________________________________________
 743 void AliITS::SetTreeAddress(){
 744     // Set branch address for the Trees.
 745     // Inputs:
 746     //      none.
 747     // Outputs:
 748     //      none.
 749     // Return:
 750     //      none.
 751     TTree *treeS = gAlice->TreeS();
 752     TTree *treeD = gAlice->TreeD();
 753     TTree *treeR = gAlice->TreeR();
 754
 755     AliDetector::SetTreeAddress();
 756
 757     SetTreeAddressS(treeS);
 758     SetTreeAddressD(treeD);
 759     SetTreeAddressR(treeR);
 760 }
 761 //______________________________________________________________________
 762 AliITSDetType* AliITS::DetType(Int_t id){
 763     // Return pointer to id detector type.
 764     // Inputs:
 765     //      Int_t id   detector id number.
 766     // Outputs:
 767     //      none.
 768     // Return:
 769     //      returned, a pointer to a AliITSDetType.
 770
 771     return ((AliITSDetType*) fDetTypes->At(id));
 772 }
 773 //______________________________________________________________________
 774 void AliITS::SetResponseModel(Int_t id, AliITSresponse *response){
 775     // Set the response model for the id detector type.
 776     // Inputs:
 777     //      Int_t id        detector id number.
 778     //      AliITSresponse* a pointer containing an instance of AliITSresponse
 779     //                      to be stored/owned b y AliITSDetType.
 780     // Outputs:
 781     //      none.
 782     // Return:
 783     //      none.
 784
 785     ((AliITSDetType*) fDetTypes->At(id))->ResponseModel(response);
 786 }
 787 //______________________________________________________________________
 788 void AliITS::SetSegmentationModel(Int_t id, AliITSsegmentation *seg){
 789     // Set the segmentation model for the id detector type.
 790     // Inputs:
 791     //      Int_t id            detector id number.
 792     //      AliITSsegmentation* a pointer containing an instance of
 793     //                          AliITSsegmentation to be stored/owned b y
 794     //                          AliITSDetType.
 795     // Outputs:
 796     //      none.
 797     // Return:
 798     //      none.
 799
 800     ((AliITSDetType*) fDetTypes->At(id))->SegmentationModel(seg);
 801 }
 802 //______________________________________________________________________
 803 void AliITS::SetSimulationModel(Int_t id, AliITSsimulation *sim){
 804     // Set the simulation model for the id detector type.
 805     // Inputs:
 806     //      Int_t id        detector id number.
 807     //      AliITSresponse* a pointer containing an instance of AliITSresponse
 808     //                      to be stored/owned b y AliITSDetType.
 809     // Outputs:
 810     //      none.
 811     // Return:
 812     //      none.
 813
 814    ((AliITSDetType*) fDetTypes->At(id))->SimulationModel(sim);
 815
 816 }
 817 //______________________________________________________________________
 818 void AliITS::SetReconstructionModel(Int_t id, AliITSClusterFinder *reconst){
 819     // Set the cluster finder model for the id detector type.
 820     // Inputs:
 821     //      Int_t id             detector id number.
 822     //      AliITSClusterFinder* a pointer containing an instance of
 823     //                           AliITSClusterFinder to be stored/owned b y
 824     //                           AliITSDetType.
 825     // Outputs:
 826     //      none.
 827     // Return:
 828     //      none.
 829
 830     ((AliITSDetType*) fDetTypes->At(id))->ReconstructionModel(reconst);
 831 }
 832 //______________________________________________________________________
 833 void AliITS::SetClasses(Int_t id, const char *digit, const char *cluster){
 834     // Set the digit and cluster classes name to be used for the id detector
 835     // type.
 836     // Inputs:
 837     //      Int_t id            detector id number.
 838     //      const char *digit   Digit class name for detector id.
 839     //      const char *cluster Cluster class name for detector id.
 840     // Outputs:
 841     //      none.
 842     // Return:
 843     //      none.
 844
 845     ((AliITSDetType*) fDetTypes->At(id))->ClassNames(digit,cluster);
 846 }
 847 //______________________________________________________________________
 848 void AliITS::AddHit(Int_t track, Int_t *vol, Float_t *hits){
 849     // Add an ITS hit
 850     //     The function to add information to the AliITShit class. See the
 851     // AliITShit class for a full description. This function allocates the
 852     // necessary new space for the hit information and passes the variable
 853     // track, and the pointers *vol and *hits to the AliITShit constructor
 854     // function.
 855     // Inputs:
 856     //      Int_t   track   Track number which produced this hit.
 857     //      Int_t   *vol    Array of Integer Hit information. See AliITShit.h
 858     //      Float_t *hits   Array of Floating Hit information.  see AliITShit.h
 859     // Outputs:
 860     //      none.
 861     // Return:
 862     //      none.
 863
 864     TClonesArray &lhits = *fHits;
 865     new(lhits[fNhits++]) AliITShit(fIshunt,track,vol,hits);
 866 }
 867 //______________________________________________________________________
 868 void AliITS::InitModules(Int_t size,Int_t &nmodules){
 869     // Initialize the modules array.
 870     // Inputs:
 871     //      Int_t size  Size of array of the number of modules to be
 872     //                  created. If size <=0 then the number of modules
 873     //                  is gotten from AliITSgeom class kept in fITSgeom.
 874     // Outputs:
 875     //      Int_t &nmodules The number of modules existing.
 876     // Return:
 877     //      none.
 878
 879     if(fITSmodules){
 880         fITSmodules->Delete();
 881         delete fITSmodules;
 882     } // end fir fITSmoudles
 883
 884     Int_t nl,indexMAX,index;
 885
 886     if(size<=0){ // default to using data stored in AliITSgeom
 887         if(fITSgeom==0) {
 888             Error("InitModules","fITSgeom not defined");
 889             return;
 890         } // end if fITSgeom==0
 891         nl = fITSgeom->GetNlayers();
 892         indexMAX = fITSgeom->GetModuleIndex(nl,fITSgeom->GetNladders(nl),
 893                                             fITSgeom->GetNdetectors(nl))+1;
 894         nmodules = indexMAX;
 895         fITSmodules = new TObjArray(indexMAX);
 896         for(index=0;index<indexMAX;index++){
 897             fITSmodules->AddAt( new AliITSmodule(index),index);
 898         } // end for index
 899     }else{
 900         fITSmodules = new TObjArray(size);
 901         for(index=0;index<size;index++) {
 902             fITSmodules->AddAt( new AliITSmodule(index),index);
 903         } // end for index
 904
 905         nmodules = size;
 906     } // end i size<=0
 907 }
 908 //______________________________________________________________________
 909 void AliITS::FillModules(Int_t evnt,Int_t bgrev,Int_t nmodules,
 910                          Option_t *option,Text_t *filename){
 911     // fill the modules with the sorted by module hits; add hits from
 912     // background if option=Add.
 913     // Inputs:
 914     //      Int_t evnt       Event to be processed.
 915     //      Int_t bgrev      Background Hit tree number.
 916     //      Int_t nmodules   Not used.
 917     //      Option_t *option String indicating if merging hits or not. To
 918     //                       merge hits set equal to "Add". Otherwise no
 919     //                       background hits are considered.
 920     //      Test_t *filename File name containing the background hits..
 921     // Outputs:
 922     //      none.
 923     // Return:
 924     //      none.
 925     static TTree *trH1;                 //Tree with background hits
 926     static TClonesArray *fHits2;        //List of hits for one track only
 927     static Bool_t first=kTRUE;
 928     static TFile *file;
 929     const char *addBgr = strstr(option,"Add");
 930
 931     if (addBgr ) {
 932         if(first) {
 933             file=new TFile(filename);
 934             fHits2     = new TClonesArray("AliITShit",1000  );
 935         } // end if first
 936         first=kFALSE;
 937         file->cd();
 938         file->ls();
 939         // Get Hits Tree header from file
 940         if(fHits2) fHits2->Clear();
 941         if(trH1) delete trH1;
 942         trH1=0;
 943
 944         char treeName[20];
 945         sprintf(treeName,"TreeH%d",bgrev);
 946         trH1 = (TTree*)gDirectory->Get(treeName);
 947         if (!trH1) {
 948             Error("FillModules","cannot find Hits Tree for event:%d",bgrev);
 949         } // end if !trH1
 950         // Set branch addresses
 951         TBranch *branch;
 952         char branchname[20];
 953         sprintf(branchname,"%s",GetName());
 954         if (trH1 && fHits2) {
 955             branch = trH1->GetBranch(branchname);
 956             if (branch) branch->SetAddress(&fHits2);
 957         } // end if trH1 && fHits
 958     } // end if addBgr
 959
 960     TClonesArray *itsHits = this->Hits();
 961     Int_t lay,lad,det,index;
 962     AliITShit *itsHit=0;
 963     AliITSmodule *mod=0;
 964     TTree *iTH = gAlice->TreeH();
 965     Int_t ntracks =(Int_t) iTH->GetEntries();
 966     Int_t t,h;
 967     for(t=0; t<ntracks; t++){
 968         gAlice->ResetHits();
 969         iTH->GetEvent(t);
 970         Int_t nhits = itsHits->GetEntriesFast();
 971         if (!nhits) continue;
 972         for(h=0; h<nhits; h++){
 973             itsHit = (AliITShit *)itsHits->UncheckedAt(h);
 974             itsHit->GetDetectorID(lay,lad,det);
 975             // temporarily index=det-1 !!!
 976             if(fITSgeom) index = fITSgeom->GetModuleIndex(lay,lad,det);
 977             else index=det-1;
 978             //
 979             mod = this->GetModule(index);
 980             mod->AddHit(itsHit,t,h);
 981         } // end loop over hits
 982     } // end loop over tracks
 983
 984     // open the file with background
 985
 986     if (addBgr ) {
 987         Int_t track,i;
 988         ntracks =(Int_t)trH1->GetEntries();
 989         // Loop over tracks
 990         for (track=0; track<ntracks; track++) {
 991             if (fHits2)       fHits2->Clear();
 992             trH1->GetEvent(track);
 993             //   Loop over hits
 994             for(i=0;i<fHits2->GetEntriesFast();++i) {
 995                 itsHit=(AliITShit*) (*fHits2)[i];
 996                 itsHit->GetDetectorID(lay,lad,det);
 997                 // temporarily index=det-1 !!!
 998                 if(fITSgeom) index = fITSgeom->GetModuleIndex(lay,lad,det);
 999                 else index=det-1;
1000                 //
1001                 mod = this->GetModule(index);
1002                 mod->AddHit(itsHit,track,i);
1003             }  // end loop over hits
1004         } // end loop over tracks
1005         TTree *fAli=gAlice->TreeK();
1006         TFile *fileAli=0;
1007         if (fAli) fileAli =fAli->GetCurrentFile();
1008         fileAli->cd();
1009     } // end if add
1010 }
1011 //______________________________________________________________________
1012 void AliITS::ClearModules(){
1013     // Clear the modules TObjArray.
1014     // Inputs:
1015     //      none.
1016     // Outputs:
1017     //      none.
1018
1019     if(fITSmodules) fITSmodules->Delete();
1020 }
1021 //______________________________________________________________________
1022 void AliITS::MakeBranchS(const char *fl){
1023     // Creates Tree Branch for the ITS summable digits.
1024     // Inputs:
1025     //      cont char *fl  File name where SDigits branch is to be written
1026     //                     to. If blank it write the SDigits to the same
1027     //                     file in which the Hits were found.
1028     // Outputs:
1029     //      none.
1030     // Return:
1031     //      none.
1032     Int_t buffersize = 4000;
1033     char branchname[30];
1034
1035     // only one branch for SDigits.
1036     sprintf(branchname,"%s",GetName());
1037     if(fSDigits && gAlice->TreeS()){
1038         MakeBranchInTree(gAlice->TreeS(),branchname,&fSDigits,buffersize,fl);
1039     } // end if
1040 }
1041 //______________________________________________________________________
1042 void AliITS::SetTreeAddressS(TTree *treeS){
1043     // Set branch address for the ITS summable digits Trees.
1044     // Inputs:
1045     //      TTree *treeS   Tree containing the SDigits.
1046     // Outputs:
1047     //      none.
1048     // Return:
1049     //      none.
1050     char branchname[30];
1051
1052     if(!treeS) return;
1053     TBranch *branch;
1054     sprintf(branchname,"%s",GetName());
1055     branch = treeS->GetBranch(branchname);
1056     if (branch) branch->SetAddress(&fSDigits);
1057 }
1058 //______________________________________________________________________
1059 void AliITS::MakeBranchInTreeD(TTree *treeD,const char *file){
1060     // Creates Tree branches for the ITS.
1061     // Inputs:
1062     //      TTree     *treeD Pointer to the Digits Tree.
1063     //      cont char *file  File name where Digits branch is to be written
1064     //                       to. If blank it write the SDigits to the same
1065     //                       file in which the Hits were found.
1066     // Outputs:
1067     //      none.
1068     // Return:
1069     //      none.
1070     Int_t buffersize = 4000;
1071     char branchname[30];
1072
1073     sprintf(branchname,"%s",GetName());
1074     // one branch for digits per type of detector
1075     const char *det[3] = {"SPD","SDD","SSD"};
1076     char digclass[40];
1077     char clclass[40];
1078     Int_t i;
1079     for (i=0; i<kNTYPES ;i++) {
1080         DetType(i)->GetClassNames(digclass,clclass);
1081         // digits
1082         if(!(fDtype->At(i))) fDtype->AddAt(new TClonesArray(digclass,1000),i);
1083         else ResetDigits(i);
1084     } // end for i
1085     for (i=0; i<kNTYPES ;i++) {
1086         if (kNTYPES==3) sprintf(branchname,"%sDigits%s",GetName(),det[i]);
1087         else  sprintf(branchname,"%sDigits%d",GetName(),i+1);
1088         if (fDtype && treeD) {
1089             MakeBranchInTree(treeD,
1090                              branchname, &((*fDtype)[i]),buffersize,file);
1091         } // end if
1092     } // end for i
1093 }
1094 //______________________________________________________________________
1095 void AliITS::SetTreeAddressD(TTree *treeD){
1096     // Set branch address for the Trees.
1097     // Inputs:
1098     //      TTree *treeD   Tree containing the Digits.
1099     // Outputs:
1100     //      none.
1101     // Return:
1102     //      none.
1103     char branchname[30];
1104     const char *det[3] = {"SPD","SDD","SSD"};
1105     TBranch *branch;
1106     char digclass[40];
1107     char clclass[40];
1108     Int_t i;
1109
1110     if(!treeD) return;
1111     for (i=0; i<kNTYPES; i++) {
1112         DetType(i)->GetClassNames(digclass,clclass);
1113         // digits
1114         if(!(fDtype->At(i))) fDtype->AddAt(new TClonesArray(digclass,1000),i);
1115         else ResetDigits(i);
1116         if (kNTYPES==3) sprintf(branchname,"%sDigits%s",GetName(),det[i]);
1117         else  sprintf(branchname,"%sDigits%d",GetName(),i+1);
1118         if (fDtype) {
1119             branch = treeD->GetBranch(branchname);
1120             if (branch) branch->SetAddress(&((*fDtype)[i]));
1121         } // end if fDtype
1122     } // end for i
1123 }
1124 //______________________________________________________________________
1125 void AliITS::Hits2SDigits(){
1126     // Standard Hits to summable Digits function.
1127     // Inputs:
1128     //      none.
1129     // Outputs:
1130     //      none.
1131
1132 //    return; // Using Hits in place of the larger sDigits.
1133     AliHeader *header=gAlice->GetHeader(); // Get event number from this file.
1134     // Do the Hits to Digits operation. Use Standard input values.
1135     // Event number from file, no background hit merging , use size from
1136     // AliITSgeom class, option="All", input from this file only.
1137     HitsToSDigits(header->GetEvent(),0,-1," ",fOpt," ");
1138 }
1139 //______________________________________________________________________
1140 void AliITS::Hits2PreDigits(){
1141     // Standard Hits to summable Digits function.
1142     // Inputs:
1143     //      none.
1144     // Outputs:
1145     //      none.
1146
1147     AliHeader *header=gAlice->GetHeader(); // Get event number from this file.
1148     // Do the Hits to Digits operation. Use Standard input values.
1149     // Event number from file, no background hit merging , use size from
1150     // AliITSgeom class, option="All", input from this file only.
1151     HitsToPreDigits(header->GetEvent(),0,-1," ",fOpt," ");
1152 }
1153 //______________________________________________________________________
1154 void AliITS::SDigitsToDigits(Option_t *opt){
1155     // Standard Summable digits to Digits function.
1156     // Inputs:
1157     //      none.
1158     // Outputs:
1159     //      none.
1160     char name[20] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
1161
1162     if(!GetITSgeom()) return; // need transformations to do digitization.
1163     AliITSgeom *geom = GetITSgeom();
1164
1165     const char *all = strstr(opt,"All");
1166     const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),
1167                           strstr(opt,"SSD")};
1168     if( !det[0] && !det[1] && !det[2] ) all = "All";
1169     else all = 0;
1170     static Bool_t setDef=kTRUE;
1171     if (setDef) SetDefaultSimulation();
1172     setDef=kFALSE;
1173
1174     AliITSsimulation *sim      = 0;
1175     AliITSDetType    *iDetType = 0;
1176     TTree            *trees    = gAlice->TreeS();
1177     if( !(trees && this->GetSDigits()) ){
1178         Error("SDigits2Digits","Error: No trees or SDigits. Returning.");
1179         return;
1180     } // end if
1181     sprintf( name, "%s", this->GetName() );
1182     TBranch *brchSDigits = trees->GetBranch( name );
1183
1184     Int_t id,module;
1185     for(module=0;module<geom->GetIndexMax();module++){
1186         id       = geom->GetModuleType(module);
1187         if (!all && !det[id]) continue;
1188         iDetType = DetType(id);
1189         sim      = (AliITSsimulation*)iDetType->GetSimulationModel();
1190         if (!sim) {
1191             Error("SDigit2Digits",
1192                   "The simulation class was not instanciated!");
1193             exit(1);
1194         } // end if !sim
1195         sim->InitSimulationModule(module,gAlice->GetEvNumber());
1196 //
1197         // add summable digits to module
1198         this->GetSDigits()->Clear();
1199         brchSDigits->GetEvent(module);
1200         sim->AddSDigitsToModule(GetSDigits(),0);
1201 //
1202         // Digitise current module sum(SDigits)->Digits
1203         sim->FinishSDigitiseModule();
1204
1205         // fills all branches - wasted disk space
1206         gAlice->TreeD()->Fill();
1207         this->ResetDigits();
1208     } // end for module
1209
1210     gAlice->TreeD()->GetEntries();
1211
1212     gAlice->TreeD()->AutoSave();
1213     // reset tree
1214     gAlice->TreeD()->Reset();
1215
1216 }
1217 //______________________________________________________________________
1218 void AliITS::Hits2Digits(){
1219     // Standard Hits to Digits function.
1220     // Inputs:
1221     //      none.
1222     // Outputs:
1223     //      none.
1224
1225     AliHeader *header=gAlice->GetHeader(); // Get event number from this file.
1226     // Do the Hits to Digits operation. Use Standard input values.
1227     // Event number from file, no background hit merging , use size from
1228     // AliITSgeom class, option="All", input from this file only.
1229     HitsToDigits(header->GetEvent(),0,-1," ",fOpt," ");
1230 }
1231 //______________________________________________________________________
1232 void AliITS::HitsToSDigits(Int_t evNumber,Int_t bgrev,Int_t size,
1233                           Option_t *option, Option_t *opt,Text_t *filename){
1234     // keep galice.root for signal and name differently the file for
1235     // background when add! otherwise the track info for signal will be lost !
1236     // the condition below will disappear when the geom class will be
1237     // initialized for all versions - for the moment it is only for v5 !
1238     // 7 is the SDD beam test version. Dummy routine. Hits are ITS's Summable
1239     // Digits.
1240     // Inputs:
1241     //      Int_t evnt       Event to be processed.
1242     //      Int_t bgrev      Background Hit tree number.
1243     //      Int_t nmodules   Not used.
1244     //      Option_t *option String indicating if merging hits or not. To
1245     //                       merge hits set equal to "Add". Otherwise no
1246     //                       background hits are considered.
1247     //      Test_t *filename File name containing the background hits..
1248     // Outputs:
1249     //      none.
1250     // Return:
1251     //      none.
1252 //    return; // using Hits instead of the larger sdigits.
1253
1254     HitsToPreDigits(evNumber,bgrev,size,option,opt,filename);
1255 }
1256 //______________________________________________________________________
1257 void AliITS::HitsToPreDigits(Int_t evNumber,Int_t bgrev,Int_t size,
1258                           Option_t *option, Option_t *opt,Text_t *filename){
1259     //   Keep galice.root for signal and name differently the file for
1260     // background when add! otherwise the track info for signal will be lost !
1261     // the condition below will disappear when the geom class will be
1262     // initialized for all versions - for the moment it is only for v5 !
1263     // 7 is the SDD beam test version.
1264     // Inputs:
1265     //      Int_t evnt       Event to be processed.
1266     //      Int_t bgrev      Background Hit tree number.
1267     //      Int_t nmodules   Not used.
1268     //      Option_t *option String indicating if merging hits or not. To
1269     //                       merge hits set equal to "Add". Otherwise no
1270     //                       background hits are considered.
1271     //      Test_t *filename File name containing the background hits..
1272     // Outputs:
1273     //      none.
1274     // Return:
1275     //      none.
1276
1277     if(!GetITSgeom()) return; // need transformations to do digitization.
1278     AliITSgeom *geom = GetITSgeom();
1279
1280     const char *all = strstr(opt,"All");
1281     const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),
1282                           strstr(opt,"SSD")};
1283     static Bool_t setDef=kTRUE;
1284     if (setDef) SetDefaultSimulation();
1285     setDef=kFALSE;
1286
1287     Int_t nmodules;
1288     InitModules(size,nmodules);
1289     FillModules(evNumber,bgrev,nmodules,option,filename);
1290
1291     AliITSsimulation *sim      = 0;
1292     AliITSDetType    *iDetType = 0;
1293     AliITSmodule     *mod      = 0;
1294     Int_t id,module;
1295     for(module=0;module<geom->GetIndexMax();module++){
1296         id       = geom->GetModuleType(module);
1297         if (!all && !det[id]) continue;
1298         iDetType = DetType(id);
1299         sim      = (AliITSsimulation*)iDetType->GetSimulationModel();
1300         if (!sim) {
1301             Error("HitsToSDigits",
1302                   "The simulation class was not instanciated!");
1303             exit(1);
1304         } // end if !sim
1305         mod      = (AliITSmodule *)fITSmodules->At(module);
1306         sim->SDigitiseModule(mod,module,evNumber);
1307         // fills all branches - wasted disk space
1308         gAlice->TreeS()->Fill();
1309         ResetSDigits();
1310     } // end for module
1311
1312     ClearModules();
1313
1314     gAlice->TreeS()->GetEntries();
1315     gAlice->TreeS()->AutoSave();
1316     // reset tree
1317     gAlice->TreeS()->Reset();
1318 }
1319 //______________________________________________________________________
1320 void AliITS::HitsToDigits(Int_t evNumber,Int_t bgrev,Int_t size,
1321                           Option_t *option, Option_t *opt,Text_t *filename){
1322     //   Keep galice.root for signal and name differently the file for
1323     // background when add! otherwise the track info for signal will be lost !
1324     // the condition below will disappear when the geom class will be
1325     // initialized for all versions - for the moment it is only for v5 !
1326     // 7 is the SDD beam test version.
1327     // Inputs:
1328     //      Int_t evnt       Event to be processed.
1329     //      Int_t bgrev      Background Hit tree number.
1330     //      Int_t nmodules   Not used.
1331     //      Option_t *option String indicating if merging hits or not. To
1332     //                       merge hits set equal to "Add". Otherwise no
1333     //                       background hits are considered.
1334     //      Test_t *filename File name containing the background hits..
1335     // Outputs:
1336     //      none.
1337     // Return:
1338     //      none.
1339
1340     if(!GetITSgeom()) return; // need transformations to do digitization.
1341     AliITSgeom *geom = GetITSgeom();
1342
1343     const char *all = strstr(opt,"All");
1344     const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),
1345                           strstr(opt,"SSD")};
1346     static Bool_t setDef=kTRUE;
1347     if (setDef) SetDefaultSimulation();
1348     setDef=kFALSE;
1349
1350     Int_t nmodules;
1351     InitModules(size,nmodules);
1352     FillModules(evNumber,bgrev,nmodules,option,filename);
1353
1354     AliITSsimulation *sim      = 0;
1355     AliITSDetType    *iDetType = 0;
1356     AliITSmodule     *mod      = 0;
1357     Int_t id,module;
1358     for(module=0;module<geom->GetIndexMax();module++){
1359         id       = geom->GetModuleType(module);
1360         if (!all && !det[id]) continue;
1361         iDetType = DetType(id);
1362         sim      = (AliITSsimulation*)iDetType->GetSimulationModel();
1363         if (!sim) {
1364             Error("HitsToDigits",
1365                   "The simulation class was not instanciated!");
1366             exit(1);
1367         } // end if !sim
1368         mod      = (AliITSmodule *)fITSmodules->At(module);
1369         sim->DigitiseModule(mod,module,evNumber);
1370         // fills all branches - wasted disk space
1371         gAlice->TreeD()->Fill();
1372         ResetDigits();
1373     } // end for module
1374
1375     ClearModules();
1376
1377     gAlice->TreeD()->GetEntries();
1378     gAlice->TreeD()->AutoSave();
1379     // reset tree
1380     gAlice->TreeD()->Reset();
1381 }
1382 //______________________________________________________________________
1383 void AliITS::ResetSDigits(){
1384     // Reset the Summable Digits array.
1385     // Inputs:
1386     //      none.
1387     // Outputs:
1388     //      none.
1389
1390     if (fSDigits) fSDigits->Clear();
1391     fNSDigits = 0;
1392 }
1393 //______________________________________________________________________
1394 void AliITS::ResetDigits(){
1395     // Reset number of digits and the digits array for the ITS detector.
1396     // Inputs:
1397     //      none.
1398     // Outputs:
1399     //      none.
1400
1401     if (!fDtype) return;
1402
1403     Int_t i;
1404     for (i=0;i<kNTYPES;i++ ) {
1405         if (fDtype->At(i))    ((TClonesArray*)fDtype->At(i))->Clear();
1406         if (fNdtype)  fNdtype[i]=0;
1407     } // end for i
1408 }
1409 //______________________________________________________________________
1410 void AliITS::ResetDigits(Int_t i){
1411     // Reset number of digits and the digits array for this branch.
1412     // Inputs:
1413     //      none.
1414     // Outputs:
1415     //      none.
1416
1417     if (fDtype->At(i))    ((TClonesArray*)fDtype->At(i))->Clear();
1418     if (fNdtype)  fNdtype[i]=0;
1419 }
1420 //______________________________________________________________________
1421 void AliITS::AddSumDigit(AliITSpListItem &sdig){
1422     // Adds the a module full of summable digits to the summable digits tree.
1423     // Inputs:
1424     //      AliITSpListItem &sdig   SDigit to be added to SDigits tree.
1425     // Outputs:
1426     //      none.
1427     // Return:
1428     //      none.
1429
1430     TClonesArray &lsdig = *fSDigits;
1431     new(lsdig[fNSDigits++]) AliITSpListItem(sdig);
1432 }
1433 //______________________________________________________________________
1434 void AliITS::AddRealDigit(Int_t id, Int_t *digits){
1435     //   Add a real digit - as coming from data.
1436     // Inputs:
1437     //      Int_t id        Detector type number.
1438     //      Int_t *digits   Integer array containing the digits info. See
1439     //                      AliITSdigit.h
1440     // Outputs:
1441     //      none.
1442     // Return:
1443     //      none.
1444
1445     TClonesArray &ldigits = *((TClonesArray*)fDtype->At(id));
1446     new(ldigits[fNdtype[id]++]) AliITSdigit(digits);
1447 }
1448 //______________________________________________________________________
1449 void AliITS::AddSimDigit(Int_t id, AliITSdigit *d){
1450     //    Add a simulated digit.
1451     // Inputs:
1452     //      Int_t id        Detector type number.
1453     //      AliITSdigit *d  Digit to be added to the Digits Tree. See
1454     //                      AliITSdigit.h
1455     // Outputs:
1456     //      none.
1457     // Return:
1458     //      none.
1459
1460     TClonesArray &ldigits = *((TClonesArray*)fDtype->At(id));
1461
1462     switch(id){
1463     case 0:
1464         new(ldigits[fNdtype[id]++]) AliITSdigitSPD(*((AliITSdigitSPD*)d));
1465         break;
1466     case 1:
1467         new(ldigits[fNdtype[id]++]) AliITSdigitSDD(*((AliITSdigitSDD*)d));
1468         break;
1469     case 2:
1470         new(ldigits[fNdtype[id]++]) AliITSdigitSSD(*((AliITSdigitSSD*)d));
1471         break;
1472     } // end switch id
1473 }
1474 //______________________________________________________________________
1475 void AliITS::AddSimDigit(Int_t id,Float_t phys,Int_t *digits,Int_t *tracks,
1476                          Int_t *hits,Float_t *charges){
1477     //   Add a simulated digit to the list.
1478     // Inputs:
1479     //      Int_t id        Detector type number.
1480     //      Float_t phys    Physics indicator. See AliITSdigits.h
1481     //      Int_t *digits   Integer array containing the digits info. See
1482     //                      AliITSdigit.h
1483     //      Int_t *tracks   Integer array [3] containing the track numbers that
1484     //                      contributed to this digit.
1485     //      Int_t *hits     Integer array [3] containing the hit numbers that
1486     //                      contributed to this digit.
1487     //      Float_t *charge Floating point array of the signals contributed
1488     //                      to this digit by each track.
1489     // Outputs:
1490     //      none.
1491     // Return:
1492     //      none.
1493
1494     TClonesArray &ldigits = *((TClonesArray*)fDtype->At(id));
1495     switch(id){
1496     case 0:
1497         new(ldigits[fNdtype[id]++]) AliITSdigitSPD(digits,tracks,hits);
1498         break;
1499     case 1:
1500         new(ldigits[fNdtype[id]++]) AliITSdigitSDD(phys,digits,tracks,
1501                                                    hits,charges);
1502         break;
1503     case 2:
1504         new(ldigits[fNdtype[id]++]) AliITSdigitSSD(digits,tracks,hits);
1505         break;
1506     } // end switch id
1507 }
1508 //______________________________________________________________________
1509 void AliITS::MakeTreeC(Option_t *option){
1510     //   Create a separate tree to store the clusters.
1511     // Inputs:
1512     //      Option_t *option  string which must contain "C" otherwise
1513     //                        no Cluster Tree is created.
1514     // Outputs:
1515     //      none.
1516     // Return:
1517     //      none.
1518   TDirectory *cwd = gDirectory;
1519   TFile *fileRecPoints = gAlice->GetTreeRFile();
1520   if(fileRecPoints)fileRecPoints->cd();
1521     const char *optC = strstr(option,"C");
1522     if (optC && !fTreeC) fTreeC = new TTree("TC","Clusters in ITS");
1523     else return;
1524
1525     Int_t buffersize = 4000;
1526     char branchname[30];
1527     const char *det[3] = {"SPD","SDD","SSD"};
1528     char digclass[40];
1529     char clclass[40];
1530
1531     // one branch for Clusters per type of detector
1532     Int_t i;
1533     for (i=0; i<kNTYPES ;i++) {
1534         AliITSDetType *iDetType=DetType(i);
1535         iDetType->GetClassNames(digclass,clclass);
1536         // clusters
1537         fCtype->AddAt(new TClonesArray(clclass,1000),i);
1538         if (kNTYPES==3) sprintf(branchname,"%sClusters%s",GetName(),det[i]);
1539         else  sprintf(branchname,"%sClusters%d",GetName(),i+1);
1540         if (fCtype   && fTreeC) {
1541             TreeC()->Branch(branchname,&((*fCtype)[i]), buffersize);
1542         } // end if fCtype && fTreeC
1543     } // end for i
1544     cwd->cd();
1545 }
1546 //______________________________________________________________________
1547 void AliITS::GetTreeC(Int_t event){
1548     //    Get the clusters tree for this event and set the branch address.
1549     // Inputs:
1550     //      Int_t event    Event number for the cluster tree.
1551     // Outputs:
1552     //      none.
1553     // Return:
1554     //      none.
1555     char treeName[20];
1556     char branchname[30];
1557     const char *det[3] = {"SPD","SDD","SSD"};
1558
1559     ResetClusters();
1560     if (fTreeC) {
1561         delete fTreeC;
1562     } // end if fTreeC
1563
1564     sprintf(treeName,"TreeC%d",event);
1565     TFile *fileRecPoints = gAlice->GetTreeRFile();
1566     if(!fileRecPoints){
1567       fTreeC = (TTree*)gDirectory->Get(treeName);
1568     }
1569     else {
1570       fTreeC = (TTree*)fileRecPoints->Get(treeName);
1571     }
1572
1573     TBranch *branch;
1574
1575     if (fTreeC) {
1576         Int_t i;
1577         char digclass[40];
1578         char clclass[40];
1579         for (i=0; i<kNTYPES; i++) {
1580             AliITSDetType *iDetType=DetType(i);
1581             iDetType->GetClassNames(digclass,clclass);
1582             // clusters
1583             if(!fCtype->At(i)) fCtype->AddAt(new TClonesArray(clclass,1000),i);
1584             if(kNTYPES==3) sprintf(branchname,"%sClusters%s",GetName(),det[i]);
1585             else  sprintf(branchname,"%sClusters%d",GetName(),i+1);
1586             if (fCtype) {
1587                 branch = fTreeC->GetBranch(branchname);
1588                 if (branch) branch->SetAddress(&((*fCtype)[i]));
1589             } // end if fCtype
1590         } // end for i
1591     } else {
1592         Error("GetTreeC","cannot find Clusters Tree for event:%d",event);
1593     } // end if fTreeC
1594 }
1595 //______________________________________________________________________
1596 void AliITS::AddCluster(Int_t id, AliITSRawCluster *c){
1597     //   Add a cluster to the list.
1598     // Inputs:
1599     //      Int_t id             Detector type number.
1600     //      AliITSRawCluster *c  Cluster class to be added to the tree of
1601     //                           clusters.
1602     // Outputs:
1603     //      none.
1604     // Return:
1605     //      none.
1606
1607     TClonesArray &lc = *((TClonesArray*)fCtype->At(id));
1608
1609     switch(id){
1610     case 0:
1611         new(lc[fNctype[id]++]) AliITSRawClusterSPD(*((AliITSRawClusterSPD*)c));
1612         break;
1613     case 1:
1614         new(lc[fNctype[id]++]) AliITSRawClusterSDD(*((AliITSRawClusterSDD*)c));
1615         break;
1616     case 2:
1617         new(lc[fNctype[id]++]) AliITSRawClusterSSD(*((AliITSRawClusterSSD*)c));
1618         break;
1619     } // end switch id
1620 }
1621 //______________________________________________________________________
1622 void AliITS::ResetClusters(){
1623     // Reset number of clusters and the clusters array for ITS.
1624     // Inputs:
1625     //      none.
1626     // Outputs:
1627     //      none.
1628
1629     Int_t i;
1630     for (i=0;i<kNTYPES;i++ ) ResetClusters(i);
1631 }
1632 //______________________________________________________________________
1633 void AliITS::ResetClusters(Int_t i){
1634     //    Reset number of clusters and the clusters array for this branch.
1635     // Inputs:
1636     //      Int_t i        Detector type number.
1637     // Outputs:
1638     //      none.
1639     // Return:
1640     //      none.
1641
1642     if (fCtype->At(i))    ((TClonesArray*)fCtype->At(i))->Clear();
1643     if (fNctype)  fNctype[i]=0;
1644 }
1645 //______________________________________________________________________
1646 void AliITS::MakeBranchR(const char *file, Option_t *opt){
1647     // Creates Tree branches for the ITS Reconstructed points.
1648     // Inputs:
1649     //      cont char *file  File name where RecPoints branch is to be written
1650     //                       to. If blank it write the SDigits to the same
1651     //                       file in which the Hits were found.
1652     // Outputs:
1653     //      none.
1654     // Return:
1655     //      none.
1656     Int_t buffsz = 4000;
1657     char branchname[30];
1658
1659     // only one branch for rec points for all detector types
1660     Bool_t oFast= (strstr(opt,"Fast")!=0);
1661     if(oFast){
1662       sprintf(branchname,"%sRecPointsF",GetName());
1663     } else {
1664       sprintf(branchname,"%sRecPoints",GetName());
1665     }
1666     if (fRecPoints && gAlice->TreeR()) {
1667         MakeBranchInTree(gAlice->TreeR(),branchname,&fRecPoints,buffsz,file);
1668     } // end if
1669 }
1670 //______________________________________________________________________
1671 void AliITS::SetTreeAddressR(TTree *treeR){
1672     // Set branch address for the Reconstructed points Trees.
1673     // Inputs:
1674     //      TTree *treeR   Tree containing the RecPoints.
1675     // Outputs:
1676     //      none.
1677     // Return:
1678     //      none.
1679     char branchname[30];
1680
1681     if(!treeR) return;
1682     TBranch *branch;
1683     sprintf(branchname,"%sRecPoints",GetName());
1684     branch = treeR->GetBranch(branchname);
1685     if (branch) {
1686       branch->SetAddress(&fRecPoints);
1687     }
1688     else {
1689       sprintf(branchname,"%sRecPointsF",GetName());
1690       branch = treeR->GetBranch(branchname);
1691       if (branch) {
1692         branch->SetAddress(&fRecPoints);
1693       }
1694     }
1695 }
1696 //______________________________________________________________________
1697 void AliITS::AddRecPoint(const AliITSRecPoint &r){
1698     // Add a reconstructed space point to the list
1699     // Inputs:
1700     //      const AliITSRecPoint &r RecPoint class to be added to the tree
1701     //                              of reconstructed points TreeR.
1702     // Outputs:
1703     //      none.
1704     // Return:
1705     //      none.
1706
1707     TClonesArray &lrecp = *fRecPoints;
1708     new(lrecp[fNRecPoints++]) AliITSRecPoint(r);
1709 }
1710 //______________________________________________________________________
1711 void AliITS::HitsToFastRecPoints(Int_t evNumber,Int_t bgrev,Int_t size,
1712                                  Option_t *opt0,Option_t *opt1,Text_t *flnm){
1713     // keep galice.root for signal and name differently the file for
1714     // background when add! otherwise the track info for signal will be lost !
1715     // the condition below will disappear when the geom class will be
1716     // initialized for all versions - for the moment it is only for v5 !
1717     // Inputs:
1718     //      Int_t evnt       Event to be processed.
1719     //      Int_t bgrev      Background Hit tree number.
1720     //      Int_t size       Size used by InitModules. See InitModules.
1721     //      Option_t *opt0   Option passed to FillModules. See FillModules.
1722     //      Option_t *opt1   String indicating if merging hits or not. To
1723     //                       merge hits set equal to "Add". Otherwise no
1724     //                       background hits are considered.
1725     //      Test_t *flnm     File name containing the background hits..
1726     // Outputs:
1727     //      none.
1728     // Return:
1729     //      none.
1730
1731     if(!GetITSgeom()) return;
1732     AliITSgeom *geom = GetITSgeom();
1733
1734     const char *all = strstr(opt1,"All");
1735     const char *det[3] ={strstr(opt1,"SPD"),strstr(opt1,"SDD"),
1736                          strstr(opt1,"SSD")};
1737     Int_t nmodules;
1738     InitModules(size,nmodules);
1739     FillModules(evNumber,bgrev,nmodules,opt0,flnm);
1740
1741     AliITSsimulation *sim      = 0;
1742     AliITSDetType    *iDetType = 0;
1743     AliITSmodule     *mod      = 0;
1744     Int_t id,module;
1745
1746     //m.b. : this change is nothing but a nice way to make sure
1747     //the CPU goes up !
1748     for(module=0;module<geom->GetIndexMax();module++){
1749         id       = geom->GetModuleType(module);
1750         if (!all && !det[id]) continue;
1751         iDetType = DetType(id);
1752         sim      = (AliITSsimulation*)iDetType->GetSimulationModel();
1753         if (!sim) {
1754             Error("HitsToFastPoints",
1755                   "The simulation class was not instanciated!");
1756             exit(1);
1757         } // end if !sim
1758         mod      = (AliITSmodule *)fITSmodules->At(module);
1759         sim->CreateFastRecPoints(mod,module,gRandom);
1760     //  gAlice->TreeR()->Fill();
1761     TBranch *br=gAlice->TreeR()->GetBranch("ITSRecPointsF");
1762     br->Fill();
1763         ResetRecPoints();
1764     } // end for module
1765
1766     ClearModules();
1767
1768     gAlice->TreeR()->AutoSave();
1769     // reset tree
1770     gAlice->TreeR()->Reset();
1771 }
1772 //______________________________________________________________________
1773 void AliITS::Digits2Reco(){
1774     // Find clusters and reconstruct space points.
1775     // Inputs:
1776     //      none.
1777     // Outputs:
1778     //      none.
1779
1780     AliHeader *header=gAlice->GetHeader();
1781     // to Digits to RecPoints for event in file, all digits in file, and
1782     // all ITS detectors.
1783     DigitsToRecPoints(header->GetEvent(),0,fOpt);
1784 }
1785 //______________________________________________________________________
1786 void AliITS::DigitsToRecPoints(Int_t evNumber,Int_t lastentry,Option_t *opt){
1787     // cluster finding and reconstruction of space points
1788     // the condition below will disappear when the geom class will be
1789     // initialized for all versions - for the moment it is only for v5 !
1790     // 7 is the SDD beam test version
1791     // Inputs:
1792     //      Int_t evNumber   Event number to be processed.
1793     //      Int_t lastentry  Offset for module when not all of the modules
1794     //                       are processed.
1795     //      Option_t *opt    String indicating which ITS sub-detectors should
1796     //                       be processed. If ="All" then all of the ITS
1797     //                       sub detectors are processed.
1798     // Outputs:
1799     //      none.
1800     // Return:
1801     //      none.
1802
1803     if(!GetITSgeom()) return;
1804     AliITSgeom *geom = GetITSgeom();
1805
1806     const char *all = strstr(opt,"All");
1807     const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),
1808                           strstr(opt,"SSD")};
1809     static Bool_t setRec=kTRUE;
1810     if (setRec) SetDefaultClusterFinders();
1811     setRec=kFALSE;
1812
1813     TTree *treeC=TreeC();
1814     AliITSClusterFinder *rec     = 0;
1815     AliITSDetType      *iDetType = 0;
1816     Int_t id,module,first=0;
1817     for(module=0;module<geom->GetIndexMax();module++){
1818         id       = geom->GetModuleType(module);
1819         if (!all && !det[id]) continue;
1820         if(det[id]) first = geom->GetStartDet(id);
1821         iDetType = DetType(id);
1822         rec = (AliITSClusterFinder*)iDetType->GetReconstructionModel();
1823         TClonesArray *itsDigits  = this->DigitsAddress(id);
1824         if (!rec) {
1825             Error("DigitsToRecPoints",
1826                   "The reconstruction class was not instanciated!");
1827             exit(1);
1828         } // end if !rec
1829         this->ResetDigits();
1830         if (all) gAlice->TreeD()->GetEvent(lastentry+module);
1831         else gAlice->TreeD()->GetEvent(lastentry+(module-first));
1832         Int_t ndigits = itsDigits->GetEntriesFast();
1833         if (ndigits) rec->FindRawClusters(module);
1834     gAlice->TreeR()->Fill();
1835         ResetRecPoints();
1836         treeC->Fill();
1837         ResetClusters();
1838     } // end for module
1839
1840     gAlice->TreeR()->GetEntries();
1841     treeC->GetEntries();
1842     gAlice->TreeR()->AutoSave();
1843     // reset tree
1844     gAlice->TreeR()->Reset();
1845
1846     treeC->AutoSave();
1847     treeC->Reset();
1848 }
1849 //______________________________________________________________________
1850 void AliITS::ResetRecPoints(){
1851     // Reset number of rec points and the rec points array.
1852     // Inputs:
1853     //      none.
1854     // Outputs:
1855     //      none.
1856
1857     if (fRecPoints) fRecPoints->Clear();
1858     fNRecPoints = 0;
1859 }