Introduce the function Digits2Reco() and write the defaults for simulation and recons...
[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.56  2001/07/05 12:49:49  mariana
19 Temporary patches required by root.v3.01.05
20
21 Revision 1.55  2001/06/14 14:59:00  barbera
22 Tracking V1 decoupled from AliITS
23
24 Revision 1.54  2001/05/31 20:37:56  barbera
25 Bari/Salerno model set as defaault SPD simulation
26
27 Revision 1.53  2001/05/31 18:52:24 barbera 
28 Bari model becomes the default
29
30 Revision 1.53  2001/05/30 07:52:24  hristov
31 TPC and CONTAINERS included in the search path
32
33 Revision 1.52  2001/05/30 06:04:58  hristov
34 Changes made to be consitant with changes in TPC tracking classes (B.Nilsen)
35
36 Revision 1.51  2001/05/16 14:57:15  alibrary
37 New files for folders and Stack
38
39 Revision 1.50  2001/05/11 09:15:21  barbera
40 Corrected to make fast point creation working with PPR geometry
41
42 Revision 1.49  2001/05/11 07:37:49  hristov
43 Legacy lines commented
44
45 Revision 1.48  2001/05/10 18:14:25  barbera
46 A typo corrected
47
48 Revision 1.47  2001/05/10 17:55:59  barbera
49 Modified to create rec points also for PPR geometries
50
51 Revision 1.46  2001/05/10 00:05:28  nilsen
52 Allowed for HitsToDigits function to work with versions 5, 7, 8, and 9. This
53 should probably be cleaned up to only check to make sure that fITSgeom has
54 been properly defined.
55
56 Revision 1.45  2001/05/01 22:35:48  nilsen
57 Remove/commented a number of cout<< statements. and made change needed by
58 SSD code.
59
60 Revision 1.44  2001/04/26 22:44:01  nilsen
61 Removed dependence on layer 5/6 in AliITS::HitsToDigits. This will be
62 done properly in AliITSv???.cxx via SetDefaults.
63
64 Revision 1.43  2001/04/26 13:22:52  barbera
65 TMatrix and TVector elimininated to speed up the code
66
67 Revision 1.42  2001/04/25 21:55:12  barbera
68 Updated version to be compatible with actual verion of STEER and TPC
69
70 Revision 1.41  2001/04/21 15:16:51  barbera
71 Updated with the new SSD reconstruction code
72
73 Revision 1.40  2001/03/17 15:07:06  mariana
74 Update SDD response parameters
75
76 Revision 1.39  2001/03/12 17:45:32  hristov
77 Changes needed on Sun with CC 5.0
78
79 Revision 1.38  2001/03/07 14:04:51  barbera
80 Some vector dimensions increased to cope with full events
81
82 Revision 1.37  2001/03/07 12:36:35  barbera
83 A change added in the tracking part to manage delta rays
84
85 Revision 1.36  2001/03/02 19:44:11  barbera
86  modified to taking into account new version tracking v1
87
88 Revision 1.35  2001/02/28 18:16:46  mariana
89 Make the code compatible with the new AliRun
90
91 Revision 1.34  2001/02/11 15:51:39  mariana
92 Set protection in MakeBranch
93
94 Revision 1.33  2001/02/10 22:26:39  mariana
95 Move the initialization of the containers for raw clusters in MakeTreeC()
96
97 Revision 1.32  2001/02/08 23:55:31  nilsen
98 Removed fMajor/MinorVersion variables in favor of variables in derived classes.
99 Set arrays char *det[3] = {"SPD","SDD","SSD"} as const.
100
101 Revision 1.31  2001/02/02 23:57:28  nilsen
102 Added include file that are no londer included in AliITSgeom.h
103
104 Revision 1.30  2001/01/30 09:23:13  hristov
105 Streamers removed (R.Brun)
106
107 Revision 1.29  2001/01/26 20:01:09  hristov
108 Major upgrade of AliRoot code
109
110 Revision 1.28  2000/12/18 14:02:00  barbera
111 new version of the ITS tracking to take into account the new TPC track parametrization
112
113 Revision 1.27  2000/12/08 13:49:27  barbera
114 Hidden declaration in a for loop removed to be compliant with HP-UX compiler
115
116 Revision 1.26  2000/11/27 13:12:13  barbera
117 New version containing the files for tracking
118
119 Revision 1.25  2000/11/12 22:38:05  barbera
120 Added header file for the SPD Bari model
121
122 Revision 1.24  2000/10/09 22:18:12  barbera
123 Bug fixes from MAriana to le AliITStest.C run correctly
124
125 Revision 1.23  2000/10/05 20:47:42  nilsen
126 fixed dependencies of include files. Tryed but failed to get a root automaticly
127 generates streamer function to work. Modified SetDefaults.
128
129 Revision 1.9.2.15  2000/10/04 16:56:40  nilsen
130 Needed to include stdlib.h
131
132 =======
133 Revision 1.22  2000/10/04 19:45:52  barbera
134 Corrected by F. Carminati for v3.04
135
136 Revision 1.21  2000/10/02 21:28:08  fca
137 Removal of useless dependecies via forward declarations
138
139 Revision 1.20  2000/10/02 16:31:39  barbera
140 General code clean-up
141
142 Revision 1.9.2.14  2000/10/02 15:43:51  barbera
143 General code clean-up (e.g., printf -> cout)
144
145 Revision 1.19  2000/09/22 12:13:25  nilsen
146 Patches and updates for fixes to this and other routines.
147
148 Revision 1.18  2000/07/12 05:32:20  fca
149 Correcting several syntax problem with static members
150
151 Revision 1.17  2000/07/10 16:07:18  fca
152 Release version of ITS code
153
154 Revision 1.9.2.3  2000/02/02 13:42:09  barbera
155 fixed AliITS.cxx for new AliRun structure. Added ITS hits list to list of hits which will have their track numbers updated
156
157 Revision 1.9.2.2  2000/01/23 03:03:13  nilsen
158 //fixed FillModule. Removed fi(fabs(xl)<dx....
159
160 Revision 1.9.2.1  2000/01/12 19:03:32  nilsen
161 This is the version of the files after the merging done in December 1999.
162 See the ReadMe110100.txt file for details
163
164 Revision 1.9  1999/11/14 14:33:25  fca
165 Correct problems with distructors and pointers, thanks to I.Hrivnacova
166
167 Revision 1.8  1999/09/29 09:24:19  fca
168 Introduction of the Copyright and cvs Log
169
170 */
171
172 ///////////////////////////////////////////////////////////////////////////////
173 //
174 //      An overview of the basic philosophy of the ITS code development
175 // and analysis is show in the figure below.
176 //Begin_Html
177 /*
178 <img src="picts/ITS/ITS_Analysis_schema.gif">
179 </pre>
180 <br clear=left>
181 <font size=+2 color=red>
182 <p>Roberto Barbera is in charge of the ITS Offline code (1999).
183 <a href="mailto:roberto.barbera@ct.infn.it">Roberto Barbera</a>.
184 </font>
185 <pre>
186 */
187 //End_Html
188 //
189 //  AliITS. Inner Traking System base class.
190 //  This class contains the base procedures for the Inner Tracking System
191 //
192 //Begin_Html
193 /*
194 <img src="picts/ITS/AliITS_Class_Diagram.gif">
195 </pre>
196 <br clear=left>
197 <font size=+2 color=red>
198 <p>This show the class diagram of the different elements that are part of
199 the AliITS class.
200 </font>
201 <pre>
202 */
203 //End_Html
204 //
205 // Version: 0
206 // Written by Rene Brun, Federico Carminati, and Roberto Barbera
207 //
208 // Version: 1
209 // Modified and documented by Bjorn S. Nilsen
210 // July 11 1999
211 //
212 // Version: 2
213 // Modified and documented by A. Bologna
214 // October 18 1999
215 //
216 // AliITS is the general base class for the ITS. Also see AliDetector for
217 // futher information.
218 //
219 ///////////////////////////////////////////////////////////////////////////////
220 #include <iostream.h>
221 #include <iomanip.h>
222 #include <fstream.h>
223 #include <stdlib.h>
224 #include <TMath.h>
225 #include <TRandom.h>
226 #include <TBranch.h>
227 #include <TVector.h>
228 #include <TClonesArray.h>
229 #include <TROOT.h>
230 #include <TObjectTable.h>
231 #include <TFile.h>
232 #include <TTree.h>
233 #include <TString.h>
234
235
236
237 #include "AliMC.h"
238 #include "AliRun.h"
239 #include "AliHeader.h"
240
241 #include "AliITS.h"
242 #include "AliITSDetType.h"
243 #include "AliITSresponseSPD.h"
244 #include "AliITSresponseSDD.h"
245 #include "AliITSresponseSSD.h"
246 #include "AliITSsegmentationSPD.h"
247 #include "AliITSsegmentationSDD.h"
248 #include "AliITSsegmentationSSD.h"
249 #include "AliITSsimulationSPD.h"
250 #include "AliITSsimulationSDD.h"
251 #include "AliITSsimulationSSD.h"
252 #include "AliITSClusterFinderSPD.h"
253 #include "AliITSClusterFinderSDD.h"
254 #include "AliITSClusterFinderSSD.h"
255
256 #include "AliITShit.h"
257 #include "AliITSgeom.h"
258 #include "AliITSdigit.h"
259 #include "AliITSmodule.h"
260 #include "AliITSRecPoint.h"
261 #include "AliITSRawCluster.h"
262
263
264 ClassImp(AliITS)
265  
266 //_____________________________________________________________________________
267 AliITS::AliITS() : AliDetector() {
268   //
269   // Default initialiser for ITS
270   //     The default constructor of the AliITS class. In addition to
271   // creating the AliITS class it zeros the variables fIshunt (a member
272   // of AliDetector class), fEuclidOut, and fIdN, and zeros the pointers
273   // fITSpoints, fIdSens, and fIdName. The AliDetector default constructor
274   // is also called.
275   //
276
277
278   fIshunt     = 0;
279   fEuclidOut  = 0;
280
281   fNDetTypes = kNTYPES;
282   fIdN        = 0;
283   fIdName     = 0;
284   fIdSens     = 0;
285   fITSmodules = 0;
286   //
287   fDetTypes   = 0;
288   //
289   fDtype  = 0;
290   fNdtype = 0;
291   fCtype  = 0;
292   fNctype = 0;
293   fRecPoints = 0;
294   fNRecPoints = 0;
295   fTreeC = 0;
296   //
297   fITSgeom=0;
298 }
299
300 //_____________________________________________________________________________
301 AliITS::AliITS(const char *name, const char *title):AliDetector(name,title){
302   //
303   // Default initialiser for ITS
304   //     The constructor of the AliITS class. In addition to creating the
305   // AliITS class, it allocates memory for the TClonesArrays fHits and
306   // fDigits, and for the TObjArray fITSpoints. It also zeros the variables
307   // fIshunt (a member of AliDetector class), fEuclidOut, and fIdN, and zeros
308   // the pointers fIdSens and fIdName. To help in displaying hits via the ROOT
309   // macro display.C AliITS also sets the marker color to red. The variables
310   // passes with this constructor, const char *name and *title, are used by
311   // the constructor of AliDetector class. See AliDetector class for a
312   // description of these parameters and its constructor functions.
313   //
314
315
316   fHits       = new TClonesArray("AliITShit", 1560);
317   gAlice->AddHitList(fHits);
318
319   fNDetTypes = kNTYPES;
320
321   fNdtype = new Int_t[kNTYPES];
322   fDtype = new TObjArray(kNTYPES);
323
324   fNctype = new Int_t[kNTYPES];
325   fCtype = new TObjArray(kNTYPES);
326
327
328
329   fRecPoints=new TClonesArray("AliITSRecPoint",1000);
330   fNRecPoints = 0;
331
332   fTreeC = 0;
333
334   fITSmodules = 0; 
335
336   fIshunt     = 0;
337   fEuclidOut  = 0;
338   fIdN        = 0;
339   fIdName     = 0;
340   fIdSens     = 0;
341  
342   fDetTypes = new TObjArray(kNTYPES);  
343
344   Int_t i;
345   for(i=0;i<kNTYPES;i++) {
346     fDetTypes->AddAt(new AliITSDetType(),i); 
347     fNdtype[i]=0;
348     fNctype[i]=0;
349    }
350   //
351
352   SetMarkerColor(kRed);
353
354   fITSgeom=0;
355 }
356 //___________________________________________________________________________
357 AliITS::AliITS(AliITS &source){
358   // copy constructor
359   if(this==&source) return;
360   Error("AliITS::Copy constructor",
361         "You are not allowed to make a copy of the AliITS");
362   exit(1);
363 }
364 //____________________________________________________________________________
365 AliITS& AliITS::operator=(AliITS &source){
366   // assignment operator
367   if(this==&source) return *this;
368   Error("AliITS::operator=",
369         "You are not allowed to make a copy of the AliITS");
370   exit(1);
371   return *this; //fake return
372 }
373 //____________________________________________________________________________
374 void AliITS::ClearModules(){
375   //clear the modules TObjArray
376
377   if(fITSmodules) fITSmodules->Delete();
378
379 }
380 //_____________________________________________________________________________
381 AliITS::~AliITS(){
382   //
383   // Default distructor for ITS
384   //     The default destructor of the AliITS class. In addition to deleting
385   // the AliITS class it deletes the memory pointed to by the fHits, fDigits,
386   // fIdSens, fIdName, and fITSpoints.
387   //
388
389
390   delete fHits;
391   delete fDigits;
392   delete fRecPoints;
393 //  delete fIdName;        // TObjArray of TObjStrings
394   if(fIdName!=0) delete[] fIdName;  // Array of TStrings
395   if(fIdSens!=0) delete[] fIdSens;
396   if(fITSmodules!=0) {
397       this->ClearModules();
398       delete fITSmodules;
399   }// end if fITSmodules!=0
400
401   //
402   if(fDtype) {
403     fDtype->Delete();
404     delete fDtype;
405   }
406   delete [] fNdtype;
407   if (fCtype) {
408     fCtype->Delete();
409     delete fCtype;
410   }
411   delete [] fNctype;
412   //
413
414   if (fDetTypes) {
415     fDetTypes->Delete();
416     delete fDetTypes;
417   }
418
419   if (fTreeC) delete fTreeC;
420
421   if (fITSgeom) delete fITSgeom;
422
423 }
424
425 //___________________________________________
426 AliITSDetType* AliITS::DetType(Int_t id)
427 {
428   //return pointer to id detector type
429     return ((AliITSDetType*) (*fDetTypes)[id]);
430
431 }
432 //___________________________________________
433 void AliITS::SetClasses(Int_t id, const char *digit, const char *cluster)
434 {
435   //set the digit and cluster classes to be used for the id detector type
436     ((AliITSDetType*) (*fDetTypes)[id])->ClassNames(digit,cluster);
437
438 }
439 //___________________________________________
440 void AliITS::SetResponseModel(Int_t id, AliITSresponse *response)
441 {
442   //set the response model for the id detector type
443
444     ((AliITSDetType*) (*fDetTypes)[id])->ResponseModel(response);
445
446 }
447
448 //___________________________________________
449 void AliITS::SetSegmentationModel(Int_t id, AliITSsegmentation *seg)
450 {
451   //set the segmentation model for the id detector type
452
453     ((AliITSDetType*) (*fDetTypes)[id])->SegmentationModel(seg);
454
455 }
456
457 //___________________________________________
458 void AliITS::SetSimulationModel(Int_t id, AliITSsimulation *sim)
459 {
460   //set the simulation model for the id detector type
461
462    ((AliITSDetType*) (*fDetTypes)[id])->SimulationModel(sim);
463
464 }
465 //___________________________________________
466 void AliITS::SetReconstructionModel(Int_t id, AliITSClusterFinder *reconst)
467 {
468   //set the cluster finder model for the id detector type
469
470    ((AliITSDetType*) (*fDetTypes)[id])->ReconstructionModel(reconst);
471
472 }
473
474 //_____________________________________________________________________________
475 void AliITS::AddHit(Int_t track, Int_t *vol, Float_t *hits){
476   //
477   // Add an ITS hit
478   //     The function to add information to the AliITShit class. See the
479   // AliITShit class for a full description. This function allocates the
480   // necessary new space for the hit information and passes the variable
481   // track, and the pointers *vol and *hits to the AliITShit constructor
482   // function.
483   //
484   TClonesArray &lhits = *fHits;
485   new(lhits[fNhits++]) AliITShit(fIshunt,track,vol,hits);
486 }
487 //_____________________________________________________________________________
488 void AliITS::AddRealDigit(Int_t id, Int_t *digits) 
489 {
490   // add a real digit - as coming from data
491
492   TClonesArray &ldigits = *((TClonesArray*)(*fDtype)[id]);
493   new(ldigits[fNdtype[id]++]) AliITSdigit(digits);
494
495 }
496 //_____________________________________________________________________________
497 void AliITS::AddSimDigit(Int_t id, AliITSdigit *d) 
498 {
499
500   // add a simulated digit
501
502   TClonesArray &ldigits = *((TClonesArray*)(*fDtype)[id]);
503
504   switch(id)
505   {
506   case 0:
507      new(ldigits[fNdtype[id]++]) AliITSdigitSPD(*((AliITSdigitSPD*)d));
508      break;
509   case 1:
510      new(ldigits[fNdtype[id]++]) AliITSdigitSDD(*((AliITSdigitSDD*)d));
511      break;
512   case 2:
513      new(ldigits[fNdtype[id]++]) AliITSdigitSSD(*((AliITSdigitSSD*)d));
514      break;
515   }
516
517 }
518
519 //_____________________________________________________________________________
520 void AliITS::AddSimDigit(Int_t id,Float_t phys,Int_t *digits,Int_t *tracks,Int_t *hits,Float_t *charges){
521
522   // add a simulated digit to the list
523
524   TClonesArray &ldigits = *((TClonesArray*)(*fDtype)[id]);
525   switch(id)
526   {
527   case 0:
528      new(ldigits[fNdtype[id]++]) AliITSdigitSPD(digits,tracks,hits);
529      break;
530   case 1:
531      new(ldigits[fNdtype[id]++]) AliITSdigitSDD(phys,digits,tracks,hits,charges);
532      break;
533   case 2:
534      new(ldigits[fNdtype[id]++]) AliITSdigitSSD(digits,tracks,hits);
535      break;
536   }
537  
538 }
539
540 //_____________________________________________________________________________
541 void AliITS::AddCluster(Int_t id, AliITSRawCluster *c) 
542 {
543
544   // add a cluster to the list
545
546   TClonesArray &lcl = *((TClonesArray*)(*fCtype)[id]);
547
548   switch(id)
549   {
550   case 0:
551      new(lcl[fNctype[id]++]) AliITSRawClusterSPD(*((AliITSRawClusterSPD*)c));
552      break;
553   case 1:
554      new(lcl[fNctype[id]++]) AliITSRawClusterSDD(*((AliITSRawClusterSDD*)c));
555      break;
556   case 2:
557      new(lcl[fNctype[id]++]) AliITSRawClusterSSD(*((AliITSRawClusterSSD*)c));
558      break;
559   }
560
561 }
562
563
564 //_____________________________________________________________________________
565 void AliITS::AddRecPoint(const AliITSRecPoint &r)
566 {
567   //
568   // Add a reconstructed space point to the list
569   //
570   TClonesArray &lrecp = *fRecPoints;
571   new(lrecp[fNRecPoints++]) AliITSRecPoint(r);
572 }
573  
574
575 //____________________________________________
576 void AliITS::ResetDigits()
577 {
578     //
579     // Reset number of digits and the digits array for the ITS detector
580     //
581
582     if (!fDtype) return;
583
584     Int_t i;
585     for (i=0;i<kNTYPES;i++ ) {
586         if ((*fDtype)[i])    ((TClonesArray*)(*fDtype)[i])->Clear();
587         if (fNdtype)  fNdtype[i]=0;
588     }
589 }
590
591 //____________________________________________
592 void AliITS::ResetDigits(Int_t i)
593 {
594     //
595     // Reset number of digits and the digits array for this branch
596     //
597   if ((*fDtype)[i])    ((TClonesArray*)(*fDtype)[i])->Clear();
598   if (fNdtype)  fNdtype[i]=0;
599 }
600
601
602 //____________________________________________
603 void AliITS::ResetClusters()
604 {
605     //
606     // Reset number of clusters and the clusters array for ITS
607     //
608
609     Int_t i;
610     for (i=0;i<kNTYPES;i++ ) {
611         if ((*fCtype)[i])    ((TClonesArray*)(*fCtype)[i])->Clear();
612         if (fNctype)  fNctype[i]=0;
613     }
614
615 }
616
617 //____________________________________________
618 void AliITS::ResetClusters(Int_t i)
619 {
620     //
621     // Reset number of clusters and the clusters array for this branch
622     //
623         if ((*fCtype)[i])    ((TClonesArray*)(*fCtype)[i])->Clear();
624         if (fNctype)  fNctype[i]=0;
625
626 }
627
628
629 //____________________________________________
630 void AliITS::ResetRecPoints()
631 {
632     //
633     // Reset number of rec points and the rec points array 
634     //
635     if (fRecPoints) fRecPoints->Clear();
636     fNRecPoints = 0;
637
638 }
639
640 //_____________________________________________________________________________
641 Int_t AliITS::DistancetoPrimitive(Int_t , Int_t ){
642   //
643   // Distance from mouse to ITS on the screen. Dummy routine
644   //     A dummy routine used by the ROOT macro display.C to allow for the
645   // use of the mouse (pointing device) in the macro. In general this should
646   // never be called. If it is it returns the number 9999 for any value of
647   // x and y.
648   //
649   return 9999;
650 }
651
652 //_____________________________________________________________________________
653 void AliITS::Init(){
654   //
655   // Initialise ITS after it has been built
656   //     This routine initializes the AliITS class. It is intended to be called
657   // from the Init function in AliITSv?. Besides displaying a banner
658   // indicating that it has been called it initializes the array fIdSens
659   // and sets the default segmentation, response, digit and raw cluster classes
660   // Therefore it should be called after a call to CreateGeometry.
661   //
662   Int_t i;
663
664 //
665   SetDefaults();
666 // Array of TStrings
667   for(i=0;i<fIdN;i++) fIdSens[i] = gMC->VolId(fIdName[i]);
668 //
669 }
670
671 //_____________________________________________________________________________
672 void AliITS::SetDefaults()
673 {
674   // sets the default segmentation, response, digit and raw cluster classes
675
676   if(fDebug) printf("%s: SetDefaults\n",ClassName());
677
678   AliITSDetType *iDetType;
679
680
681   //SPD 
682
683   iDetType=DetType(0); 
684   if (!iDetType->GetSegmentationModel()) {
685     AliITSsegmentationSPD *seg0=new AliITSsegmentationSPD(fITSgeom);
686     SetSegmentationModel(0,seg0); 
687   }
688   if (!iDetType->GetResponseModel()) {
689      SetResponseModel(0,new AliITSresponseSPD()); 
690   }
691   // set digit and raw cluster classes to be used
692   
693   const char *kData0=(iDetType->GetResponseModel())->DataType();
694   if (strstr(kData0,"real")) {
695       iDetType->ClassNames("AliITSdigit","AliITSRawClusterSPD");
696   } else iDetType->ClassNames("AliITSdigitSPD","AliITSRawClusterSPD");
697
698   // SDD                                          //
699   iDetType=DetType(1); 
700   if (!iDetType->GetResponseModel()) {
701     SetResponseModel(1,new AliITSresponseSDD()); 
702   }
703   AliITSresponse *resp1=iDetType->GetResponseModel();
704   if (!iDetType->GetSegmentationModel()) {
705     AliITSsegmentationSDD *seg1=new AliITSsegmentationSDD(fITSgeom,resp1);
706     SetSegmentationModel(1,seg1); 
707   }
708   const char *kData1=(iDetType->GetResponseModel())->DataType();
709   const char *kopt=iDetType->GetResponseModel()->ZeroSuppOption();
710   if ((!strstr(kopt,"2D")) && (!strstr(kopt,"1D")) || strstr(kData1,"real") ) {
711       iDetType->ClassNames("AliITSdigit","AliITSRawClusterSDD");
712   } else iDetType->ClassNames("AliITSdigitSDD","AliITSRawClusterSDD");
713
714   // SSD
715   iDetType=DetType(2); 
716   if (!iDetType->GetSegmentationModel()) {
717     AliITSsegmentationSSD *seg2=new AliITSsegmentationSSD(fITSgeom);
718     SetSegmentationModel(2,seg2); 
719   }
720   if (!iDetType->GetResponseModel()) {
721     SetResponseModel(2,new AliITSresponseSSD()); 
722   }
723   const char *kData2=(iDetType->GetResponseModel())->DataType();
724   if (strstr(kData2,"real")) {
725       iDetType->ClassNames("AliITSdigit","AliITSRawClusterSSD");
726   } else iDetType->ClassNames("AliITSdigitSSD","AliITSRawClusterSSD");
727
728   if (kNTYPES>3) {
729     Warning("SetDefaults","Only the three basic detector types are initialised!");
730   } 
731
732 }
733 //_____________________________________________________________________________
734 void AliITS::SetDefaultSimulation()
735 {
736   // sets the default simulation
737
738
739   AliITSDetType *iDetType;
740   iDetType=DetType(0);
741   if (!iDetType->GetSimulationModel()) {
742       AliITSsegmentation *seg0=
743                     (AliITSsegmentation*)iDetType->GetSegmentationModel();
744       AliITSresponse *res0 = (AliITSresponse*)iDetType->GetResponseModel();
745       AliITSsimulationSPD *sim0=new AliITSsimulationSPD(seg0,res0);
746       SetSimulationModel(0,sim0);
747   }
748   iDetType=DetType(1);
749   if (!iDetType->GetSimulationModel()) {
750       AliITSsegmentation *seg1=
751                     (AliITSsegmentation*)iDetType->GetSegmentationModel();
752       AliITSresponse *res1 = (AliITSresponse*)iDetType->GetResponseModel();
753       AliITSsimulationSDD *sim1=new AliITSsimulationSDD(seg1,res1);
754       SetSimulationModel(1,sim1);
755   }
756   iDetType=DetType(2);
757   if (!iDetType->GetSimulationModel()) {
758       AliITSsegmentation *seg2=
759                     (AliITSsegmentation*)iDetType->GetSegmentationModel();
760       AliITSresponse *res2 = (AliITSresponse*)iDetType->GetResponseModel();
761       AliITSsimulationSSD *sim2=new AliITSsimulationSSD(seg2,res2);
762       SetSimulationModel(2,sim2);
763   }
764
765
766 }
767 //_____________________________________________________________________________
768 void AliITS::SetDefaultClusterFinders()
769 {
770   // sets the default cluster finders
771
772   MakeTreeC();
773   AliITSDetType *iDetType;
774   iDetType=DetType(0);
775   if (!iDetType->GetReconstructionModel()) {
776       AliITSsegmentation *seg0=
777                    (AliITSsegmentation*)iDetType->GetSegmentationModel();
778       TClonesArray *dig0=DigitsAddress(0);
779       TClonesArray *recp0=ClustersAddress(0);
780       AliITSClusterFinderSPD *rec0=new AliITSClusterFinderSPD(seg0,dig0,recp0);
781       SetReconstructionModel(0,rec0);
782   }
783   iDetType=DetType(1);
784   if (!iDetType->GetReconstructionModel()) {
785       AliITSsegmentation *seg1=
786                      (AliITSsegmentation*)iDetType->GetSegmentationModel();
787       AliITSresponse *res1 = (AliITSresponse*)iDetType->GetResponseModel();
788       TClonesArray *dig1=DigitsAddress(1);
789       TClonesArray *recp1=ClustersAddress(1);
790       AliITSClusterFinderSDD *rec1=
791                            new AliITSClusterFinderSDD(seg1,res1,dig1,recp1);
792
793       SetReconstructionModel(1,rec1);
794   }
795   iDetType=DetType(2);
796   if (!iDetType->GetReconstructionModel()) {
797       AliITSsegmentation *seg2=
798                     (AliITSsegmentation*)iDetType->GetSegmentationModel();
799
800       TClonesArray *dig2=DigitsAddress(2);
801       AliITSClusterFinderSSD *rec2= new AliITSClusterFinderSSD(seg2,dig2);
802       SetReconstructionModel(2,rec2);
803   }
804
805 }
806 //_____________________________________________________________________________
807
808 void AliITS::MakeTreeC(Option_t *option)
809 {
810   // create a separate tree to store the clusters
811
812 //  cout << "AliITS::MakeTreeC" << endl;
813
814      const char *optC = strstr(option,"C");
815      if (optC && !fTreeC) fTreeC = new TTree("TC","Clusters in ITS");
816      else return;
817
818
819      Int_t buffersize = 4000;
820      char branchname[30];
821
822      const char *det[3] = {"SPD","SDD","SSD"};
823
824      char digclass[40];
825      char clclass[40];
826
827      // one branch for Clusters per type of detector
828      Int_t i;
829      for (i=0; i<kNTYPES ;i++) {
830         AliITSDetType *iDetType=DetType(i); 
831         iDetType->GetClassNames(digclass,clclass);
832         // clusters
833         fCtype->AddAt(new TClonesArray(clclass,1000),i);
834         if (kNTYPES==3) sprintf(branchname,"%sClusters%s",GetName(),det[i]);
835         else  sprintf(branchname,"%sClusters%d",GetName(),i+1);
836         if (fCtype   && fTreeC) {
837            TreeC()->Branch(branchname,&((*fCtype)[i]), buffersize);
838 //         cout << "Making Branch " << branchname;
839 //         cout << " for Clusters of detector type " << i+1 << endl;
840         }       
841      }
842
843 }
844
845 //_____________________________________________________________________________
846 void AliITS::GetTreeC(Int_t event)
847 {
848
849 //  cout << "AliITS::GetTreeC" << endl;
850
851   // get the clusters tree for this event and set the branch address
852     char treeName[20];
853     char branchname[30];
854
855     const char *det[3] = {"SPD","SDD","SSD"};
856
857     ResetClusters();
858     if (fTreeC) {
859           delete fTreeC;
860     }
861
862     sprintf(treeName,"TreeC%d",event);
863     fTreeC = (TTree*)gDirectory->Get(treeName);
864
865     TBranch *branch;
866
867     if (fTreeC) {
868         Int_t i;
869         char digclass[40];
870         char clclass[40];
871         for (i=0; i<kNTYPES; i++) {
872
873            AliITSDetType *iDetType=DetType(i); 
874            iDetType->GetClassNames(digclass,clclass);
875            // clusters
876            if(!(*fCtype)[i]) fCtype->AddAt(new TClonesArray(clclass,1000),i); 
877            if (kNTYPES==3) sprintf(branchname,"%sClusters%s",GetName(),det[i]);
878            else  sprintf(branchname,"%sClusters%d",GetName(),i+1);
879            if (fCtype) {
880                 branch = fTreeC->GetBranch(branchname);
881                 if (branch) branch->SetAddress(&((*fCtype)[i]));
882             }
883         }
884     } else {
885         Error("AliITS::GetTreeC",
886                 "cannot find Clusters Tree for event:%d\n",event);
887     }
888
889 }
890 //_____________________________________________________________________________
891 void AliITS::MakeBranch(Option_t* option, const char *file)
892 {
893   //
894   // Creates Tree branches for the ITS.
895   //
896   //
897   Int_t buffersize = 4000;
898   char branchname[30];
899   sprintf(branchname,"%s",GetName());
900
901   AliDetector::MakeBranch(option,file);
902
903   const char *cD = strstr(option,"D");
904   const char *cR = strstr(option,"R");
905
906   if (cD) {
907   //
908   // one branch for digits per type of detector
909   //
910    const char *det[3] = {"SPD","SDD","SSD"};
911
912    char digclass[40];
913    char clclass[40];
914
915    Int_t i;
916    for (i=0; i<kNTYPES ;i++) {
917        DetType(i)->GetClassNames(digclass,clclass);
918        // digits
919        if(!((*fDtype)[i])) fDtype->AddAt(new TClonesArray(digclass,1000),i);
920        else ResetDigits(i);
921    }
922
923    for (i=0; i<kNTYPES ;i++) {
924       if (kNTYPES==3) sprintf(branchname,"%sDigits%s",GetName(),det[i]);
925       else  sprintf(branchname,"%sDigits%d",GetName(),i+1);      
926       if (fDtype && gAlice->TreeD()) {
927         MakeBranchInTree(gAlice->TreeD(), 
928                          branchname, &((*fDtype)[i]), buffersize, file);
929 //          cout << "Making Branch " << branchname;
930 //          cout << " for digits of type "<< i+1 << endl;
931       } 
932     }
933   }
934
935   if (cR) {
936   //
937   // only one branch for rec points for all detector types
938   //
939     sprintf(branchname,"%sRecPoints",GetName());
940  
941     //if(!fRecPoints) fRecPoints=new TClonesArray("AliITSRecPoint",1000);
942
943     if (fRecPoints && gAlice->TreeR()) {
944       MakeBranchInTree(gAlice->TreeR(), 
945                                branchname, &fRecPoints, buffersize, file) ;
946 //      cout << "Making Branch " << branchname;
947 //      cout << " for reconstructed space points" << endl;
948     }
949   }     
950 }
951
952 //___________________________________________
953 void AliITS::SetTreeAddress()
954 {
955
956   // Set branch address for the Trees.
957
958
959   char branchname[30];
960   AliDetector::SetTreeAddress();
961
962   const char *det[3] = {"SPD","SDD","SSD"};
963
964   TBranch *branch;
965   TTree *treeD = gAlice->TreeD();
966   TTree *treeR = gAlice->TreeR();
967
968   char digclass[40];
969   char clclass[40];
970
971   Int_t i;
972   if (treeD) {
973       for (i=0; i<kNTYPES; i++) {
974         DetType(i)->GetClassNames(digclass,clclass);
975           // digits
976         if(!((*fDtype)[i])) fDtype->AddAt(new TClonesArray(digclass,1000),i);
977         else ResetDigits(i);
978
979         if (kNTYPES==3) sprintf(branchname,"%sDigits%s",GetName(),det[i]);
980         else  sprintf(branchname,"%sDigits%d",GetName(),i+1);
981         if (fDtype) {
982            branch = treeD->GetBranch(branchname);
983            if (branch) branch->SetAddress(&((*fDtype)[i]));
984         }
985       }
986   }
987
988  
989   if (treeR) {
990     sprintf(branchname,"%sRecPoints",GetName());
991       branch = treeR->GetBranch(branchname);
992       if (branch) branch->SetAddress(&fRecPoints);
993   }
994   
995
996 }
997
998 //____________________________________________________________________________
999 void AliITS::InitModules(Int_t size,Int_t &nmodules){
1000
1001   //initialize the modules array
1002
1003   if(fITSmodules){ 
1004       fITSmodules->Delete();
1005       delete fITSmodules;
1006   }
1007
1008     Int_t nl,indexMAX,index;
1009
1010     if(size<=0){ // default to using data stored in AliITSgeom
1011         if(fITSgeom==0) {
1012             Error("AliITS::InitModules",
1013                 "in AliITS::InitModule fITSgeom not defined\n");
1014             return;
1015         } // end if fITSgeom==0
1016         nl = fITSgeom->GetNlayers();
1017         indexMAX = fITSgeom->GetModuleIndex(nl,fITSgeom->GetNladders(nl),
1018                                             fITSgeom->GetNdetectors(nl))+1;
1019         nmodules = indexMAX;
1020         fITSmodules = new TObjArray(indexMAX);
1021         for(index=0;index<indexMAX;index++){
1022                 fITSmodules->AddAt( new AliITSmodule(index),index);
1023         } // end for index
1024     }else{
1025         fITSmodules = new TObjArray(size);
1026         for(index=0;index<size;index++) {
1027             fITSmodules->AddAt( new AliITSmodule(index),index);
1028         }
1029
1030         nmodules = size;
1031     } // end i size<=0
1032 }
1033
1034 //____________________________________________________________________________
1035 void AliITS::FillModules(Int_t evnt,Int_t bgrev,Int_t nmodules,Option_t *option,Text_t *filename){
1036
1037   // fill the modules with the sorted by module hits; add hits from background
1038   // if option=Add
1039
1040
1041     static TTree *trH1;                 //Tree with background hits
1042     static TClonesArray *fHits2;        //List of hits for one track only
1043
1044     static Bool_t first=kTRUE;
1045     static TFile *file;
1046     const char *addBgr = strstr(option,"Add");
1047
1048
1049     if (addBgr ) {
1050         if(first) {
1051 //          cout<<"filename "<<filename<<endl;
1052             file=new TFile(filename);
1053 //          cout<<"I have opened "<<filename<<" file "<<endl;
1054             fHits2     = new TClonesArray("AliITShit",1000  );
1055         }           
1056         first=kFALSE;
1057         file->cd();
1058         file->ls();
1059         // Get Hits Tree header from file
1060         if(fHits2) fHits2->Clear();
1061         if(trH1) delete trH1;
1062         trH1=0;
1063         
1064         char treeName[20];
1065         sprintf(treeName,"TreeH%d",bgrev);
1066         trH1 = (TTree*)gDirectory->Get(treeName);
1067         //printf("TrH1 %p of treename %s for event %d \n",trH1,treeName,bgrev);
1068         
1069         if (!trH1) {
1070             Error("AliITS::FillModules",
1071             "cannot find Hits Tree for event:%d\n",bgrev);
1072         }
1073         // Set branch addresses
1074         TBranch *branch;
1075         char branchname[20];
1076         sprintf(branchname,"%s",GetName());
1077         if (trH1 && fHits2) {
1078             branch = trH1->GetBranch(branchname);
1079             if (branch) branch->SetAddress(&fHits2);
1080         }
1081
1082         // test
1083         //Int_t ntracks1 =(Int_t)TrH1->GetEntries();
1084         //printf("background - ntracks1 - %d\n",ntracks1);
1085    }
1086
1087     //Int_t npart = gAlice->GetEvent(evnt);
1088     //if(npart<=0) return;
1089     TClonesArray *itsHits = this->Hits();
1090     Int_t lay,lad,det,index;
1091     AliITShit *itsHit=0;
1092     AliITSmodule *mod=0;
1093
1094     TTree *iTH = gAlice->TreeH();
1095     Int_t ntracks =(Int_t) iTH->GetEntries();
1096
1097     Int_t t,h;
1098     for(t=0; t<ntracks; t++){
1099         gAlice->ResetHits();
1100         iTH->GetEvent(t);
1101         Int_t nhits = itsHits->GetEntriesFast();
1102         //printf("nhits %d\n",nhits);
1103         if (!nhits) continue;
1104         for(h=0; h<nhits; h++){
1105             itsHit = (AliITShit *)itsHits->UncheckedAt(h);
1106             itsHit->GetDetectorID(lay,lad,det);
1107             // temporarily index=det-1 !!!
1108             if(fITSgeom) index = fITSgeom->GetModuleIndex(lay,lad,det);
1109             else index=det-1;
1110             //
1111             mod = this->GetModule(index);
1112             mod->AddHit(itsHit,t,h);
1113         } // end loop over hits 
1114     } // end loop over tracks
1115
1116     // open the file with background
1117     
1118     if (addBgr ) {
1119           Int_t track,i;
1120           ntracks =(Int_t)trH1->GetEntries();
1121             //printf("background - ntracks1 %d\n",ntracks);
1122             //printf("background - Start loop over tracks \n");     
1123             //   Loop over tracks
1124
1125             for (track=0; track<ntracks; track++) {
1126
1127                 if (fHits2)       fHits2->Clear();
1128                 trH1->GetEvent(track);
1129                 //   Loop over hits
1130                 for(i=0;i<fHits2->GetEntriesFast();++i) {
1131
1132                     itsHit=(AliITShit*) (*fHits2)[i];
1133                     itsHit->GetDetectorID(lay,lad,det);
1134                     // temporarily index=det-1 !!!
1135                     if(fITSgeom) index = fITSgeom->GetModuleIndex(lay,lad,det);
1136                     else index=det-1;
1137                     //
1138                     mod = this->GetModule(index);
1139                     mod->AddHit(itsHit,track,i);
1140                }  // end loop over hits
1141             } // end loop over tracks
1142
1143             TTree *fAli=gAlice->TreeK();
1144             TFile *fileAli=0;
1145             
1146             if (fAli) fileAli =fAli->GetCurrentFile();
1147             fileAli->cd();
1148
1149     } // end if add
1150
1151     //gObjectTable->Print();
1152
1153 }
1154
1155 //____________________________________________________________________________
1156
1157 void AliITS::SDigits2Digits()
1158 {
1159
1160   cerr<<"Digitizing ITS...\n";
1161
1162   TStopwatch timer;
1163   timer.Start();
1164   AliHeader *header=gAlice->GetHeader();
1165   HitsToDigits(header->GetEvent(),0,-1," ","All"," ");
1166   timer.Stop(); timer.Print();
1167
1168 }
1169
1170
1171 //____________________________________________________________________________
1172 void AliITS::HitsToDigits(Int_t evNumber,Int_t bgrev,Int_t size, Option_t *option, Option_t *opt,Text_t *filename)
1173 {
1174     // keep galice.root for signal and name differently the file for 
1175     // background when add! otherwise the track info for signal will be lost !
1176   
1177    // the condition below will disappear when the geom class will be
1178    // initialised for all versions - for the moment it is only for v5 !
1179    // 7 is the SDD beam test version  
1180    Int_t ver = this->IsVersion(); 
1181    if(ver!=5 && ver!=7 && ver!=8 && ver!=9) return; 
1182
1183    const char *all = strstr(opt,"All");
1184    const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),strstr(opt,"SSD")};
1185
1186    static Bool_t setDef=kTRUE;
1187    if (setDef) SetDefaultSimulation();
1188    setDef=kFALSE;
1189
1190
1191 //   cout<<" 1 AliITS "<<endl;
1192    Int_t nmodules;
1193    InitModules(size,nmodules); 
1194 //   cout<<" 2 AliITS "<<endl;
1195    FillModules(evNumber,bgrev,nmodules,option,filename);
1196 //   cout<<" 3 AliITS "<<endl;
1197
1198    //TBranch *branch;
1199    AliITSsimulation* sim;
1200    //TObjArray *branches=gAlice->TreeD()->GetListOfBranches();
1201    AliITSgeom *geom = GetITSgeom();
1202
1203    Int_t id,module;
1204 //   Int_t lay, lad, detect;
1205    Int_t first,last;
1206    for (id=0;id<kNTYPES;id++) {
1207         if (!all && !det[id]) continue;
1208         //branch = (TBranch*)branches->UncheckedAt(id);
1209         AliITSDetType *iDetType=DetType(id); 
1210         sim = (AliITSsimulation*)iDetType->GetSimulationModel();
1211         if(geom) {
1212           first = geom->GetStartDet(id);
1213           last = geom->GetLastDet(id);
1214         } else first=last=0;
1215         printf("first module - last module %d %d\n",first,last);
1216         for(module=first;module<=last;module++) {
1217             AliITSmodule *mod = (AliITSmodule *)fITSmodules->At(module);
1218             sim->DigitiseModule(mod,module,evNumber);
1219             // fills all branches - wasted disk space
1220             gAlice->TreeD()->Fill(); 
1221             ResetDigits();
1222             // try and fill only the branch 
1223             //branch->Fill();
1224             //ResetDigits(id);
1225         } // loop over modules
1226    } // loop over detector types
1227
1228    ClearModules();
1229
1230 //   Int_t nentries=(Int_t)
1231    gAlice->TreeD()->GetEntries();
1232 //   cout << "nentries in TreeD" << nentries << endl;
1233
1234    char hname[30];
1235    sprintf(hname,"TreeD%d",evNumber);
1236    gAlice->TreeD()->Write(hname,TObject::kOverwrite);
1237    // reset tree
1238    gAlice->TreeD()->Reset();
1239
1240 }
1241
1242
1243 //_____________________________________________________________________________
1244 void AliITS::Digits2Reco()
1245 {
1246   // find clusters and reconstruct space points
1247
1248   AliHeader *header=gAlice->GetHeader();
1249   printf("header->GetEvent() %d\n",header->GetEvent());
1250   DigitsToRecPoints(header->GetEvent(),0,"All");
1251
1252 }
1253 //____________________________________________________________________________
1254 void AliITS::DigitsToRecPoints(Int_t evNumber,Int_t lastentry,Option_t *opt)
1255 {
1256   // cluster finding and reconstruction of space points
1257   
1258    // the condition below will disappear when the geom class will be
1259    // initialised for all versions - for the moment it is only for v5 !
1260    // 7 is the SDD beam test version  
1261    Int_t ver = this->IsVersion(); 
1262    if(ver!=5 && ver!=8 && ver!=9) return;
1263
1264    const char *all = strstr(opt,"All");
1265    const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),strstr(opt,"SSD")};
1266
1267    static Bool_t setRec=kTRUE;
1268    if (setRec) SetDefaultClusterFinders();
1269    setRec=kFALSE;
1270
1271
1272    TTree *treeC=TreeC();
1273  
1274
1275    //TBranch *branch;
1276    AliITSClusterFinder* rec;
1277
1278    //TObjArray *branches=gAlice->TreeR()->GetListOfBranches();
1279    AliITSgeom *geom = GetITSgeom();
1280
1281    Int_t id,module;
1282    for (id=0;id<kNTYPES;id++) {
1283         if (!all && !det[id]) continue;
1284         //branch = (TBranch*)branches->UncheckedAt(id);
1285         AliITSDetType *iDetType=DetType(id); 
1286         rec = (AliITSClusterFinder*)iDetType->GetReconstructionModel();
1287         TClonesArray *itsDigits  = this->DigitsAddress(id);
1288         Int_t first,last;
1289         if(geom) {
1290           first = geom->GetStartDet(id);
1291           last = geom->GetLastDet(id);
1292         } else first=last=0;
1293         printf("first module - last module %d %d\n",first,last);
1294         for(module=first;module<=last;module++) {
1295               this->ResetDigits();
1296               if (all) gAlice->TreeD()->GetEvent(lastentry+module);
1297               else gAlice->TreeD()->GetEvent(lastentry+(module-first));
1298               Int_t ndigits = itsDigits->GetEntriesFast();
1299               if (ndigits) rec->FindRawClusters(module);
1300               gAlice->TreeR()->Fill(); 
1301               ResetRecPoints();
1302               treeC->Fill();
1303               ResetClusters();
1304               // try and fill only the branch 
1305               //branch->Fill();
1306               //ResetRecPoints(id);
1307         } // loop over modules
1308    } // loop over detector types
1309
1310
1311 //   Int_t nentries=(Int_t)
1312    gAlice->TreeR()->GetEntries();
1313 //   Int_t ncentries=(Int_t)
1314    treeC->GetEntries();
1315 //   cout << " nentries ncentries " << nentries << ncentries <<  endl;
1316
1317    char hname[30];
1318    sprintf(hname,"TreeR%d",evNumber);
1319    gAlice->TreeR()->Write(hname,TObject::kOverwrite);
1320    // reset tree
1321    gAlice->TreeR()->Reset();
1322
1323    sprintf(hname,"TreeC%d",evNumber);
1324    treeC->Write(hname,TObject::kOverwrite);
1325    treeC->Reset();
1326 }
1327 //____________________________________________________________________________
1328 void AliITS::HitsToFastRecPoints(Int_t evNumber,Int_t bgrev,Int_t size,
1329 Option_t *option,Option_t *opt,Text_t *filename)
1330 {
1331     // keep galice.root for signal and name differently the file for 
1332     // background when add! otherwise the track info for signal will be lost !
1333   
1334
1335    // the condition below will disappear when the geom class will be
1336    // initialised for all versions - for the moment it is only for v5 !  
1337    Int_t ver = this->IsVersion(); 
1338    if(ver!=5 && ver!=8 && ver!=9) return;
1339
1340
1341    const char *all = strstr(opt,"All");
1342    const char *det[3] ={strstr(opt,"SPD"),strstr(opt,"SDD"),strstr(opt,"SSD")};
1343
1344    Int_t nmodules;
1345    InitModules(size,nmodules);
1346    FillModules(evNumber,bgrev,nmodules,option,filename);
1347
1348
1349    AliITSsimulation* sim;
1350    AliITSgeom *geom = GetITSgeom();
1351
1352    TRandom *random=new TRandom[9];
1353    random[0].SetSeed(111);
1354    random[1].SetSeed(222);
1355    random[2].SetSeed(333);              
1356    random[3].SetSeed(444);
1357    random[4].SetSeed(555);
1358    random[5].SetSeed(666);              
1359    random[6].SetSeed(777);
1360    random[7].SetSeed(888);
1361    random[8].SetSeed(999);              
1362
1363
1364    Int_t id,module;
1365    for (id=0;id<kNTYPES;id++) {
1366         if (!all && !det[id]) continue;
1367         AliITSDetType *iDetType=DetType(id); 
1368         sim = (AliITSsimulation*)iDetType->GetSimulationModel();
1369         if (!sim) {
1370            Error("HitsToFastPoints",
1371                  "The simulation class was not instantiated!");
1372            exit(1);
1373            // or SetDefaultSimulation();
1374         }
1375
1376         Int_t first,last;
1377         if(geom) {
1378           first = geom->GetStartDet(id);
1379           last = geom->GetLastDet(id);
1380         } else first=last=0;
1381         printf("first module - last module %d %d\n",first,last);
1382         for(module=first;module<=last;module++) {
1383             AliITSmodule *mod = (AliITSmodule *)fITSmodules->At(module);
1384             sim->CreateFastRecPoints(mod,module,random);
1385             gAlice->TreeR()->Fill(); 
1386             ResetRecPoints();
1387         } // loop over modules
1388    } // loop over detector types
1389
1390
1391    ClearModules();
1392
1393    //Int_t nentries=(Int_t)gAlice->TreeR()->GetEntries();
1394
1395    char hname[30];
1396    sprintf(hname,"TreeR%d",evNumber);
1397    gAlice->TreeR()->Write(hname,TObject::kOverwrite);
1398    // reset tree
1399    gAlice->TreeR()->Reset();
1400
1401    delete [] random;
1402
1403
1404 }