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