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