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