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