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