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