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