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