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