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