e821a454bbe27161204d865af4ef5636e109960c
[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 /* $Id$ */
17
18
19 ///////////////////////////////////////////////////////////////////////////////
20 //                                                                           //
21 //      An overview of the basic philosophy of the ITS code development      //
22 // and analysis is show in the figure below.                                 //
23 //Begin_Html                                                                 //
24 /*                                               
25 <img src="picts/ITS/ITS_Analysis_schema.gif">
26 </pre>
27 <br clear=left>
28 <font size=+2 color=red>
29 <p>Roberto Barbera is in charge of the ITS Offline code (1999).
30 <a href="mailto:roberto.barbera@ct.infn.it">Roberto Barbera</a>.
31 </font>
32 <pre>
33 */
34 //End_Html
35 //
36 //  AliITS. Inner Traking System base class.
37 //  This class contains the base procedures for the Inner Tracking System
38 //
39 //Begin_Html
40 /*
41 <img src="picts/ITS/AliITS_Class_Diagram.gif">
42 </pre>
43 <br clear=left>
44 <font size=+2 color=red>
45 <p>This show the class diagram of the different elements that are part of
46 the AliITS class.
47 </font>
48 <pre>
49 */
50 //End_Html
51 //
52 // Version: 0
53 // Written by Rene Brun, Federico Carminati, and Roberto Barbera
54 //
55 // Version: 1
56 // Modified and documented by Bjorn S. Nilsen
57 // July 11 1999
58 //
59 // Version: 2
60 // Modified and documented by A. Bologna
61 // October 18 1999
62 //
63 // AliITS is the general base class for the ITS. Also see AliDetector for
64 // futher information.
65 //
66 ///////////////////////////////////////////////////////////////////////////////
67
68 #include <Riostream.h>
69 #include <stdlib.h>
70
71 #include <TBranch.h>
72 #include <TClonesArray.h>
73 #include <TFile.h>
74 #include <TMath.h>
75 #include <TObjectTable.h>
76 #include <TROOT.h>
77 #include <TRandom.h>
78 #include <TString.h>
79 #include <TTree.h>
80 #include <TVector.h>
81 #include <TVirtualMC.h>
82
83 #include "AliConfig.h"
84 #include "AliHeader.h"
85 #include "AliITS.h"
86 #include "AliITSClusterFinderSDD.h"
87 #include "AliITSClusterFinderSPD.h"
88 #include "AliITSClusterFinderSSD.h"
89 #include "AliITSClusterFinderV2SDD.h"
90 #include "AliITSClusterFinderV2SPD.h"
91 #include "AliITSClusterFinderV2SSD.h"
92 #include "AliITSDetType.h"
93 #include "AliITSLoader.h"
94 #include "AliITSRawClusterSPD.h"
95 #include "AliITSRawClusterSDD.h"
96 #include "AliITSRawClusterSSD.h"
97 #include "AliITSRecPoint.h"
98 #include "AliITSclusterV2.h"
99 #include "AliITSdigitSPD.h"
100 #include "AliITSdigitSDD.h"
101 #include "AliITSdigitSSD.h"
102 #include "AliITSgeom.h"
103 #include "AliITShit.h"
104 #include "AliITSmodule.h"
105 #include "AliITSpList.h"
106 #include "AliITSresponseSDD.h"
107 #include "AliITSresponseSPD.h"
108 #include "AliITSresponseSSD.h"
109 #include "AliITSsegmentationSDD.h"
110 #include "AliITSsegmentationSPD.h"
111 #include "AliITSsegmentationSSD.h"
112 #include "AliITSsimulationSDD.h"
113 #include "AliITSsimulationSPD.h"
114 #include "AliITSsimulationSSD.h"
115 #include "AliMC.h"
116 #include "AliITSDigitizer.h"
117 #include "AliITSDDLRawData.h"
118 #include "AliRun.h"
119 #include "AliRawReader.h"
120 #include "AliLog.h"
121
122 ClassImp(AliITS)
123
124 //______________________________________________________________________
125 AliITS::AliITS() : AliDetector(),
126     fITSgeom(0),
127     fEuclidOut(0),
128     fITSmodules(0),
129     fOpt("All"),
130     fIdN(0),
131     fIdSens(0),
132     fIdName(0),
133     fNDetTypes(kNTYPES),
134     fDetTypes(0),
135     fSDigits(0),
136     fNSDigits(0),
137     fDtype(0),
138     fNdtype(0),
139     fCtype(0),
140     fNctype(0),
141     fRecPoints(0),
142     fNRecPoints(0),
143     fClustersV2(0),
144     fNClustersV2(0),               
145     fSelectedVertexer(0){
146     // Default initializer for ITS
147     //      The default constructor of the AliITS class. In addition to
148     // creating the AliITS class it zeros the variables fIshunt (a member
149     // of AliDetector class), fEuclidOut, and fIdN, and zeros the pointers
150     // fITSpoints, fIdSens, and fIdName. The AliDetector default constructor
151     // is also called.
152     // Inputs:
153     //      none.
154     // Outputs:
155     //      none.
156     // Return:
157     //      Blank ITS class.
158
159     fIshunt     = 0;   // not zeroed in AliDetector.
160
161     // AliITS variables.
162 //    SetDetectors(); // default to fOpt="All". This variable not written out.
163     SetMarkerColor(kRed);
164     SelectVertexer(" ");
165 }
166 //______________________________________________________________________
167 AliITS::AliITS(const char *name, const char *title):AliDetector(name,title),
168     fITSgeom(0),
169     fEuclidOut(0),
170     fITSmodules(0),
171     fOpt("All"),
172     fIdN(0),
173     fIdSens(0),
174     fIdName(0),
175     fNDetTypes(kNTYPES),
176     fDetTypes(0),
177     fSDigits(0),
178     fNSDigits(0),
179     fDtype(0),
180     fNdtype(0),
181     fCtype(0),
182     fNctype(0),
183     fRecPoints(0),
184     fNRecPoints(0),
185     fClustersV2(0),
186     fNClustersV2(0),                                                
187     fSelectedVertexer(0){
188     //     The standard Constructor for the ITS class. In addition to 
189     // creating the AliITS class, it allocates memory for the TClonesArrays 
190     // fHits, fSDigits, fDigits, fITSpoints, and the TObjArray of fCtype 
191     // (clusters). It also zeros the variables
192     // fIshunt (a member of AliDetector class), fEuclidOut, and fIdN, and zeros
193     // the pointers fIdSens and fIdName. To help in displaying hits via the
194     // ROOT macro display.C AliITS also sets the marker color to red. The
195     // variables passes with this constructor, const char *name and *title,
196     // are used by the constructor of AliDetector class. See AliDetector
197     // class for a description of these parameters and its constructor
198     // functions.
199     // Inputs:
200     //      const char *name      Detector name. Should always be "ITS"
201     //      const char *title     Detector title.
202     // Outputs:
203     //      none.
204     // Return:
205     //      An ITS class.
206
207     fIshunt     = 0;  // not zeroed in AliDetector
208     fHits       = new TClonesArray("AliITShit", 1560);//not done in AliDetector
209     // Not done in AliDetector.
210     if(gAlice->GetMCApp()) gAlice->GetMCApp()->AddHitList(fHits);
211
212     fEuclidOut  = 0;
213     fITSgeom    = 0;
214     fITSmodules = 0;
215     SetDetectors(); // default to fOpt="All". This variable not written out.
216
217     fIdN        = 0;
218     fIdName     = 0;
219     fIdSens     = 0;
220
221     fNDetTypes  = kNTYPES;
222     fDetTypes   = new TObjArray(fNDetTypes);
223
224     fSDigits    = new TClonesArray("AliITSpListItem",1000);
225     fNSDigits   = 0;
226
227     fNdtype     = new Int_t[fNDetTypes];
228     fDtype      = new TObjArray(fNDetTypes);
229
230     fCtype      = new TObjArray(fNDetTypes);
231     fNctype     = new Int_t[fNDetTypes];
232
233     fRecPoints  = new TClonesArray("AliITSRecPoint",1000);
234     fNRecPoints = 0;
235     fClustersV2 = new TClonesArray("AliITSclusterV2",3000);
236     fNClustersV2=0;
237
238     Int_t i;
239     for(i=0;i<fNDetTypes;i++) {
240         fDetTypes->AddAt(new AliITSDetType(),i); 
241         fNdtype[i] = 0;
242         fNctype[i] = 0;
243     } // end for i
244
245     SetMarkerColor(kRed);
246     SelectVertexer(" ");
247 }
248 //______________________________________________________________________
249 AliITS::~AliITS(){
250     // Default destructor for ITS.
251     //     The default destructor of the AliITS class. In addition to deleting
252     // the AliITS class it deletes the memory pointed to by the fHits, fDigits,
253     // fSDigits, fCtype, fITSmodules, fITSgeom, fRecPoints, fIdSens, fIdName, 
254     // fITSpoints, fDetType and it's contents.
255     // Inputs:
256     //      none.
257     // Outputs:
258     //      none.
259     // Return:
260     //      none.
261
262     if (fHits) {
263       fHits->Delete();
264       delete fHits;
265       fHits=0;
266     }
267     if (fSDigits) {
268       fSDigits->Delete();
269       delete fSDigits;
270       fSDigits=0;
271     }
272     if (fDigits) {
273       fDigits->Delete();
274       delete fDigits;
275       fDigits=0;
276     }
277     if (fRecPoints) {
278       fRecPoints->Delete();
279       delete fRecPoints;
280       fRecPoints=0;
281     }
282     if(fClustersV2){
283       fClustersV2->Delete();
284       delete fClustersV2;
285       fClustersV2=0;
286     }
287     delete[] fIdName;  // Array of TStrings
288     delete[] fIdSens;
289     if(fITSmodules) {
290         this->ClearModules();
291         delete fITSmodules;
292         fITSmodules = 0;
293     }// end if fITSmodules!=0
294
295     if(fDtype) {
296         fDtype->Delete();
297         delete fDtype;
298     } // end if fDtype
299     delete [] fNdtype;
300     if (fCtype) {
301         fCtype->Delete();
302         delete fCtype;
303         fCtype = 0;
304     } // end if fCtype
305     delete [] fNctype;
306
307     if (fDetTypes) {
308         fDetTypes->Delete();
309         delete fDetTypes;
310         fDetTypes = 0;
311     } // end if fDetTypes
312
313
314     if (fITSgeom) delete fITSgeom;
315 }
316 //______________________________________________________________________
317 AliITS::AliITS(const AliITS &source) : AliDetector(source){
318     // Copy constructor. This is a function which is not allowed to be
319     // done to the ITS. It exits with an error.
320     // Inputs:
321     //      AliITS &source  An AliITS class.
322     // Outputs:
323     //      none.
324     // Return:
325     //      none.
326
327     if(this==&source) return;
328     Error("Copy constructor",
329           "You are not allowed to make a copy of the AliITS");
330     exit(1);
331 }
332 //______________________________________________________________________
333 AliITS& AliITS::operator=(AliITS &source){
334     // Assignment operator. This is a function which is not allowed to be
335     // done to the ITS. It exits with an error.
336     // Inputs:
337     //      AliITS &source  An AliITS class.
338     // Outputs:
339     //      none.
340     // Return:
341     //      none.
342
343     if(this==&source) return *this;
344     Error("operator=","You are not allowed to make a copy of the AliITS");
345     exit(1);
346     return *this; //fake return
347 }
348 //______________________________________________________________________
349 AliDigitizer* AliITS::CreateDigitizer(AliRunDigitizer* manager)const{
350     // Creates the AliITSDigitizer in a standard way for use via AliModule.
351     // This function can not be included in the .h file because of problems
352     // with the order of inclusion (recursive).
353     // Inputs:
354     //    AliRunDigitizer *manager  The Manger class for Digitization
355     // Output:
356     //    none.
357     // Return:
358     //    A new AliITSRunDigitizer (cast as a AliDigitizer).
359
360      return new AliITSDigitizer(manager);
361 }
362 //______________________________________________________________________
363 void AliITS::Init(){
364     // Initializer ITS after it has been built
365     //     This routine initializes the AliITS class. It is intended to be
366     // called from the Init function in AliITSv?. Besides displaying a banner
367     // indicating that it has been called it initializes the array fIdSens
368     // and sets the default segmentation, response, digit and raw cluster
369     // classes therefore it should be called after a call to CreateGeometry.
370     // Inputs:
371     //      none.
372     // Outputs:
373     //      none.
374     // Return:
375     //      none.
376     Int_t i;
377
378     SetDefaults();
379     // Array of TStrings
380     if(gMC) for(i=0;i<fIdN;i++) fIdSens[i] = gMC->VolId(fIdName[i]);
381 }
382 //______________________________________________________________________
383 void AliITS::SetDefaults(){
384     // sets the default segmentation, response, digit and raw cluster classes.
385     // Inputs:
386     //      none.
387     // Outputs:
388     //      none.
389     // Return:
390     //      none.
391     AliITSsegmentation *seg;
392     AliITSresponse    *resp;
393     AliITSDetType *iDetType;
394
395     AliInfoClass("Seting Defaults");
396
397     //SPD
398     iDetType = DetType(kSPD);
399     if(iDetType){
400         if (!iDetType->GetSegmentationModel()) {
401             seg = new AliITSsegmentationSPD(fITSgeom);
402             SetSegmentationModel(kSPD,seg); 
403         } // end if
404         if (!iDetType->GetResponseModel()) {
405             SetResponseModel(kSPD,new AliITSresponseSPD()); 
406         } // end if
407         // set digit and raw cluster classes to be used
408
409         const char *kData0=(iDetType->GetResponseModel())->DataType();
410         if (strstr(kData0,"real")) {
411             iDetType->ClassNames("AliITSdigit","AliITSRawClusterSPD");
412         } else iDetType->ClassNames("AliITSdigitSPD","AliITSRawClusterSPD");
413     } // end if iDetType
414
415     // SDD
416     iDetType = DetType(kSDD); 
417     if(iDetType){
418         if (!iDetType->GetResponseModel()) {
419             SetResponseModel(kSDD,new AliITSresponseSDD("simulated")); 
420         } // end if
421         resp = iDetType->GetResponseModel();
422         if (!iDetType->GetSegmentationModel()) {
423             seg = new AliITSsegmentationSDD(fITSgeom,resp);
424             SetSegmentationModel(kSDD,seg); 
425         } // end if
426         const char *kData1 = (iDetType->GetResponseModel())->DataType();
427         const char *kopt = iDetType->GetResponseModel()->ZeroSuppOption();
428         if((!strstr(kopt,"2D"))&&(!strstr(kopt,"1D")) || 
429                                    strstr(kData1,"real") ){
430             iDetType->ClassNames("AliITSdigit","AliITSRawClusterSDD");
431         } else iDetType->ClassNames("AliITSdigitSDD","AliITSRawClusterSDD");
432     } // end if iDetType
433
434     // SSD
435     iDetType = DetType(kSSD); 
436     if(iDetType){
437         if (!iDetType->GetSegmentationModel()) {
438             seg = new AliITSsegmentationSSD(fITSgeom);
439             SetSegmentationModel(kSSD,seg); 
440         } // end if
441         if (!iDetType->GetResponseModel()) {
442             SetResponseModel(kSSD,new AliITSresponseSSD("simulated"));
443         } // end if
444         const char *kData2 = (iDetType->GetResponseModel())->DataType();
445         if (strstr(kData2,"real")) {
446             iDetType->ClassNames("AliITSdigit","AliITSRawClusterSSD");
447         } else iDetType->ClassNames("AliITSdigitSSD","AliITSRawClusterSSD");
448     } // end if iDetType
449
450     if (kNTYPES>3) {
451         Warning("SetDefaults",
452                 "Only the three basic detector types are initialized!");
453     }  // end if
454 }
455 //______________________________________________________________________
456 void AliITS::SetDefaultSimulation(){
457     // sets the default simulation.
458     // Inputs:
459     //      none.
460     // Outputs:
461     //      none.
462     // Return:
463     //      none.
464     AliITSDetType *iDetType;
465     AliITSsimulation *sim;
466     AliITSsegmentation *seg;
467     AliITSresponse *res;
468
469     iDetType = DetType(kSPD);
470     if(iDetType){
471         sim = iDetType->GetSimulationModel();
472         if (!sim) {
473             seg = (AliITSsegmentation*)iDetType->GetSegmentationModel();
474             res = (AliITSresponse*)iDetType->GetResponseModel();
475             sim = new AliITSsimulationSPD(seg,res);
476             SetSimulationModel(kSPD,sim);
477         }else{ // simulation exists, make sure it is set up properly.
478             if(sim->GetResponseModel()==0) sim->SetResponseModel(
479                 (AliITSresponse*)iDetType->GetResponseModel());
480             if(sim->GetSegmentationModel()==0) sim->SetSegmentationModel(
481                 (AliITSsegmentation*)iDetType->GetSegmentationModel());
482             sim->Init();
483         } // end if
484     }// end if iDetType
485     iDetType  = DetType(kSDD);
486     if(iDetType){
487         sim = iDetType->GetSimulationModel();
488         if (!sim) {
489             seg = (AliITSsegmentation*)iDetType->GetSegmentationModel();
490             res =  (AliITSresponse*)iDetType->GetResponseModel();
491             sim = new AliITSsimulationSDD(seg,res);
492             SetSimulationModel(kSDD,sim);
493         }else{ // simulation exists, make sure it is set up properly.
494             if(sim->GetResponseModel()==0) sim->SetResponseModel(
495                 (AliITSresponse*)iDetType->GetResponseModel());
496             if(sim->GetSegmentationModel()==0) sim->SetSegmentationModel(
497                 (AliITSsegmentation*)iDetType->GetSegmentationModel());
498             sim->Init();
499         } //end if
500     }// end if iDetType
501     iDetType = DetType(kSSD);
502     if(iDetType){
503         sim = iDetType->GetSimulationModel();
504         if (!sim) {
505             seg =(AliITSsegmentation*)iDetType->GetSegmentationModel();
506             res =  (AliITSresponse*)iDetType->GetResponseModel();
507             sim = new AliITSsimulationSSD(seg,res);
508             SetSimulationModel(kSSD,sim);
509         }else{ // simulation exists, make sure it is set up properly.
510             if(sim->GetResponseModel()==0) sim->SetResponseModel(
511                 (AliITSresponse*)iDetType->GetResponseModel());
512             if(sim->GetSegmentationModel()==0) sim->SetSegmentationModel(
513                 (AliITSsegmentation*)iDetType->GetSegmentationModel());
514             sim->Init();
515         } // end if
516     } // end if iDetType
517 }
518 //______________________________________________________________________
519 void AliITS::SetDefaultClusterFinders(){
520     // Sets the default cluster finders. Used in finding RecPoints.
521     // Inputs:
522     //      none.
523     // Outputs:
524     //      none.
525     // Return:
526     //      none.
527     AliITSDetType *iDetType;
528     AliITSsegmentation *seg;
529     AliITSClusterFinder *clf;
530     AliITSresponse *res;
531
532     MakeTreeC();
533
534     // SPD
535     iDetType=DetType(kSPD);
536     if(iDetType){
537         if (!iDetType->GetReconstructionModel()) {
538             seg =(AliITSsegmentation*)iDetType->GetSegmentationModel();
539             TClonesArray  *dig0 = DigitsAddress(0);
540             TClonesArray *recp0 = ClustersAddress(0);
541             clf = new AliITSClusterFinderSPD(seg,dig0,recp0);
542             SetReconstructionModel(kSPD,clf);
543         } // end if
544     } // end if iDetType
545
546     // SDD
547     iDetType=DetType(kSDD);
548     if(iDetType){
549         if (!iDetType->GetReconstructionModel()) {
550             seg = (AliITSsegmentation*)iDetType->GetSegmentationModel();
551             res = (AliITSresponse*)iDetType->GetResponseModel();
552             TClonesArray  *dig1 = DigitsAddress(1);
553             TClonesArray *recp1 = ClustersAddress(1);
554             clf = new AliITSClusterFinderSDD(seg,res,dig1,recp1);
555             SetReconstructionModel(kSDD,clf);
556         } // end if
557     } // end if iDetType
558
559     // SSD
560     iDetType=DetType(kSSD);
561     if(iDetType){
562         if (!iDetType->GetReconstructionModel()) {
563             seg = (AliITSsegmentation*)iDetType->GetSegmentationModel();
564             TClonesArray *dig2 = DigitsAddress(2);
565             clf = new AliITSClusterFinderSSD(seg,dig2);
566             SetReconstructionModel(kSSD,clf);
567         } // end if
568     } // end if iDetType
569 }
570
571
572 //______________________________________________________________________
573 void AliITS::SetDefaultClusterFindersV2(){
574     // Sets the default cluster finders. Used in finding RecPoints.
575     // Inputs:
576     //      none.
577     // Outputs:
578     //      none.
579     // Return:
580     //      none.
581     AliITSDetType *iDetType;
582     AliITSsegmentation *seg;
583     AliITSClusterFinder *clf;
584
585     MakeTreeC();
586
587     // SPD
588     iDetType=DetType(kSPD);
589     if(iDetType){
590         if (!iDetType->GetReconstructionModel()) {
591             seg =(AliITSsegmentation*)iDetType->GetSegmentationModel();
592             clf = new AliITSClusterFinderV2SPD();
593             clf->SetSegmentation(seg);
594             clf->SetDigits(DigitsAddress(0));
595             SetReconstructionModel(kSPD,clf);
596         } // end if
597     } // end if iDetType
598
599     // SDD
600     iDetType=DetType(kSDD);
601     if(iDetType){
602         if (!iDetType->GetReconstructionModel()) {
603             seg = (AliITSsegmentation*)iDetType->GetSegmentationModel();
604             clf = new AliITSClusterFinderV2SDD();
605             clf->SetSegmentation(seg);
606             clf->SetDigits(DigitsAddress(1));
607             SetReconstructionModel(kSDD,clf);
608         } // end if
609     } // end if iDetType
610
611     // SSD
612     iDetType=DetType(kSSD);
613     if(iDetType){
614         if (!iDetType->GetReconstructionModel()) {
615             seg = (AliITSsegmentation*)iDetType->GetSegmentationModel();
616             clf = new AliITSClusterFinderV2SSD();
617             clf->SetSegmentation(seg);
618             clf->SetDigits(DigitsAddress(2));
619             SetReconstructionModel(kSSD,clf);
620         } // end if
621     } // end if iDetType
622 }
623
624
625 //______________________________________________________________________
626 void AliITS::MakeBranch(Option_t* option){
627     // Creates Tree branches for the ITS.
628     // Inputs:
629     //      Option_t *option    String of Tree types S,D, and/or R.
630     //      const char *file    String of the file name where these branches
631     //                          are to be stored. If blank then these branches
632     //                          are written to the same tree as the Hits were
633     //                          read from.
634     // Outputs:
635     //      none.
636     // Return:
637     //      none.
638     Bool_t cH = (strstr(option,"H")!=0);
639     Bool_t cS = (strstr(option,"S")!=0);
640     Bool_t cD = (strstr(option,"D")!=0);
641     Bool_t cR = (strstr(option,"R")!=0);
642     Bool_t cRF = (strstr(option,"RF")!=0);
643     Bool_t v2 = (strstr(option,"v2")!=0);
644     
645
646     if(cRF)cR = kFALSE;
647     if(cH && (fHits == 0x0)) fHits  = new TClonesArray("AliITShit", 1560);
648     
649     AliDetector::MakeBranch(option);
650
651     if(cS) MakeBranchS(0);
652     if(cD) MakeBranchD(0);
653     if(cR) MakeBranchR(0);
654     if(cRF) MakeBranchRF(0);
655     if(v2) MakeBranchR(0,"v2");
656 }
657 //______________________________________________________________________
658 void AliITS::SetTreeAddress(){
659     // Set branch address for the Trees.
660     // Inputs:
661     //      none.
662     // Outputs:
663     //      none.
664     // Return:
665     //      none.
666     TTree *treeS = fLoader->TreeS();
667     TTree *treeD = fLoader->TreeD();
668     TTree *treeR = fLoader->TreeR();
669     if (fLoader->TreeH() && (fHits == 0x0)) 
670         fHits = new TClonesArray("AliITShit", 1560);
671
672     AliDetector::SetTreeAddress();
673
674     SetTreeAddressS(treeS);
675     SetTreeAddressD(treeD);
676     SetTreeAddressR(treeR);
677 }
678 //______________________________________________________________________
679 void AliITS::AddHit(Int_t track, Int_t *vol, Float_t *hits){
680     // Add an ITS hit
681     //     The function to add information to the AliITShit class. See the
682     // AliITShit class for a full description. This function allocates the
683     // necessary new space for the hit information and passes the variable
684     // track, and the pointers *vol and *hits to the AliITShit constructor
685     // function.
686     // Inputs:
687     //      Int_t   track   Track number which produced this hit.
688     //      Int_t   *vol    Array of Integer Hit information. See AliITShit.h
689     //      Float_t *hits   Array of Floating Hit information.  see AliITShit.h
690     // Outputs:
691     //      none.
692     // Return:
693     //      none.
694
695     TClonesArray &lhits = *fHits;
696     new(lhits[fNhits++]) AliITShit(fIshunt,track,vol,hits);
697 }
698 //______________________________________________________________________
699 void AliITS::InitModules(Int_t size,Int_t &nmodules){
700     // Initialize the modules array.
701     // Inputs:
702     //      Int_t size  Size of array of the number of modules to be
703     //                  created. If size <=0 then the number of modules
704     //                  is gotten from AliITSgeom class kept in fITSgeom.
705     // Outputs:
706     //      Int_t &nmodules The number of modules existing.
707     // Return:
708     //      none.
709
710     if(fITSmodules){ 
711         fITSmodules->Delete();
712         delete fITSmodules;
713     } // end fir fITSmoudles
714
715     Int_t nl,indexMAX,index;
716
717     if(size<=0){ // default to using data stored in AliITSgeom
718         if(fITSgeom==0) {
719             Error("InitModules","fITSgeom not defined");
720             return;
721         } // end if fITSgeom==0
722         nl = fITSgeom->GetNlayers();
723         indexMAX = fITSgeom->GetIndexMax();
724         nmodules = indexMAX;
725         fITSmodules = new TObjArray(indexMAX);
726         for(index=0;index<indexMAX;index++){
727             fITSmodules->AddAt( new AliITSmodule(index),index);
728         } // end for index
729     }else{
730         fITSmodules = new TObjArray(size);
731         for(index=0;index<size;index++) {
732             fITSmodules->AddAt( new AliITSmodule(index),index);
733         } // end for index
734
735         nmodules = size;
736     } // end i size<=0
737 }
738 //______________________________________________________________________
739 void AliITS::FillModules(Int_t evnt,Int_t bgrev,Int_t nmodules,
740                          Option_t *option, const char *filename){
741     // fill the modules with the sorted by module hits; add hits from
742     // background if option=Add.
743     // Inputs:
744     //      Int_t evnt       Event to be processed.
745     //      Int_t bgrev      Background Hit tree number.
746     //      Int_t nmodules   Not used.
747     //      Option_t *option String indicating if merging hits or not. To
748     //                       merge hits set equal to "Add". Otherwise no
749     //                       background hits are considered.
750     //      Test_t *filename File name containing the background hits..
751     // Outputs:
752     //      none.
753     // Return:
754     //      none.
755     static TTree *trH1;                 //Tree with background hits
756     static Bool_t first=kTRUE;
757     static TFile *file;
758     const char *addBgr = strstr(option,"Add");
759
760     evnt = nmodules; // Dummy use of variables to remove warnings
761     if (addBgr ) {
762         if(first) {
763             file=new TFile(filename);
764         } // end if first
765         first=kFALSE;
766         file->cd();
767         file->ls();
768         // Get Hits Tree header from file
769         if(trH1) delete trH1;
770         trH1=0;
771
772         char treeName[20];
773         sprintf(treeName,"TreeH%d",bgrev);
774         trH1 = (TTree*)gDirectory->Get(treeName);
775         if (!trH1) {
776             Error("FillModules","cannot find Hits Tree for event:%d",bgrev);
777         } // end if !trH1
778         // Set branch addresses
779     } // end if addBgr
780
781     FillModules(fLoader->TreeH(),0); // fill from this file's tree.
782     
783     if (addBgr ) {
784         FillModules(trH1,10000000); // Default mask 10M.
785         TTree *fAli=fLoader->GetRunLoader()->TreeK();
786         TFile *fileAli=0;
787         if (fAli) fileAli =fAli->GetCurrentFile();
788         fileAli->cd();
789     } // end if add
790 }
791 //______________________________________________________________________
792 void AliITS::FillModules(TTree *treeH, Int_t mask) {
793     // fill the modules with the sorted by module hits; 
794     // can be called many times to do a merging
795     // Inputs:
796     //      TTree *treeH  The tree containing the hits to be copied into
797     //                    the modules.
798     //      Int_t mask    The track number mask to indecate which file
799     //                    this hits came from.
800     // Outputs:
801     //      none.
802     // Return:
803     //      none.
804
805     if (treeH == 0x0)
806      {
807        Error("FillModules","Tree is NULL");
808      }
809     Int_t lay,lad,det,index;
810     AliITShit *itsHit=0;
811     AliITSmodule *mod=0;
812     char branchname[20];
813     sprintf(branchname,"%s",GetName());
814     TBranch *branch = treeH->GetBranch(branchname);
815     if (!branch) {
816         Error("FillModules","%s branch in TreeH not found",branchname);
817         return;
818     } // end if !branch
819     branch->SetAddress(&fHits);
820     Int_t nTracks =(Int_t) treeH->GetEntries();
821     Int_t iPrimTrack,h;
822     for(iPrimTrack=0; iPrimTrack<nTracks; iPrimTrack++){
823         ResetHits();
824         Int_t nBytes = treeH->GetEvent(iPrimTrack);
825         if (nBytes <= 0) continue;
826         Int_t nHits = fHits->GetEntriesFast();
827         for(h=0; h<nHits; h++){
828             itsHit = (AliITShit *)fHits->UncheckedAt(h);
829             itsHit->GetDetectorID(lay,lad,det);
830             if (fITSgeom) {
831                 index = fITSgeom->GetModuleIndex(lay,lad,det);
832             } else {
833                 index=det-1; // This should not be used.
834             } // end if [You must have fITSgeom for this to work!]
835             mod = GetModule(index);
836             itsHit->SetTrack(itsHit->GetTrack()+mask); // Set track mask.
837             mod->AddHit(itsHit,iPrimTrack,h);
838         } // end loop over hits 
839     } // end loop over tracks
840 }
841 //______________________________________________________________________
842 void AliITS::MakeBranchS(const char *fl){
843     // Creates Tree Branch for the ITS summable digits.
844     // Inputs:
845     //      cont char *fl  File name where SDigits branch is to be written
846     //                     to. If blank it write the SDigits to the same
847     //                     file in which the Hits were found.
848     // Outputs:
849     //      none.
850     // Return:
851     //      none.
852     Int_t buffersize = 4000;
853     char branchname[30];
854
855     // only one branch for SDigits.
856     sprintf(branchname,"%s",GetName());
857     
858
859     if(fLoader->TreeS()){
860         if(fSDigits==0x0) fSDigits = new TClonesArray("AliITSpListItem",1000);
861         MakeBranchInTree(fLoader->TreeS(),branchname,&fSDigits,buffersize,fl);
862     } // end if
863 }
864 //______________________________________________________________________
865 void AliITS::SetTreeAddressS(TTree *treeS){
866     // Set branch address for the ITS summable digits Trees.
867     // Inputs:
868     //      TTree *treeS   Tree containing the SDigits.
869     // Outputs:
870     //      none.
871     // Return:
872     //      none.
873     char branchname[30];
874
875     if(!treeS) return;
876     if (fSDigits == 0x0)  fSDigits = new TClonesArray("AliITSpListItem",1000);
877     TBranch *branch;
878     sprintf(branchname,"%s",GetName());
879     branch = treeS->GetBranch(branchname);
880     if (branch) branch->SetAddress(&fSDigits);
881 }
882 //______________________________________________________________________
883 void AliITS::MakeBranchInTreeD(TTree *treeD,const char *file){
884     // Creates Tree branches for the ITS.
885     // Inputs:
886     //      TTree     *treeD Pointer to the Digits Tree.
887     //      cont char *file  File name where Digits branch is to be written
888     //                       to. If blank it write the SDigits to the same
889     //                       file in which the Hits were found.
890     // Outputs:
891     //      none.
892     // Return:
893     //      none.
894     // one branch for digits per type of detector
895     const Char_t *det[3] = {"SPD","SDD","SSD"};
896     TString digclass;
897     Int_t i;
898     Int_t buffersize = 4000;
899     Char_t branchname[30];
900
901     if (fDtype == 0x0) fDtype = new TObjArray(fNDetTypes);
902     for (i=0; i<kNTYPES ;i++) {
903         digclass = DetType(i)->GetDigitClassName();
904         // digits
905         if(!(fDtype->At(i))){
906             fDtype->AddAt(new TClonesArray(digclass.Data(),1000),i);
907         }else{
908             ResetDigits(i);
909         } // end if
910         if (kNTYPES==3) sprintf(branchname,"%sDigits%s",GetName(),det[i]);
911         else  sprintf(branchname,"%sDigits%d",GetName(),i+1);      
912         if (fDtype && treeD) {
913             MakeBranchInTree(treeD,branchname,&((*fDtype)[i]),buffersize,file);
914         } // end if
915     } // end for i
916          /*
917     for (i=0; i<kNTYPES ;i++) {
918         if (kNTYPES==3) sprintf(branchname,"%sDigits%s",GetName(),det[i]);
919         else  sprintf(branchname,"%sDigits%d",GetName(),i+1);      
920         if (fDtype && treeD) {
921             MakeBranchInTree(treeD,branchname,&((*fDtype)[i]),buffersize,file);
922         } // end if
923     } // end for i
924          */
925 }
926 //______________________________________________________________________
927 void AliITS::SetTreeAddressD(TTree *treeD){
928     // Set branch address for the Trees.
929     // Inputs:
930     //      TTree *treeD   Tree containing the Digits.
931     // Outputs:
932     //      none.
933     // Return:
934     //      none.
935     const char *det[3] = {"SPD","SDD","SSD"};
936     TBranch *branch;
937     TString digclass;
938     Int_t i;
939     char branchname[30];
940
941     if(!treeD) return;
942     if (fDtype == 0x0) fDtype = new TObjArray(fNDetTypes);
943     for (i=0; i<kNTYPES; i++) {
944         digclass = DetType(i)->GetDigitClassName();
945         // digits
946         if(!(fDtype->At(i))) {
947             fDtype->AddAt(new TClonesArray(digclass.Data(),1000),i);
948         }else{
949             ResetDigits(i);
950         } // end if
951         if (kNTYPES==3) sprintf(branchname,"%sDigits%s",GetName(),det[i]);
952         else  sprintf(branchname,"%sDigits%d",GetName(),i+1);
953         if (fDtype) {
954             branch = treeD->GetBranch(branchname);
955             if (branch) branch->SetAddress(&((*fDtype)[i]));
956         } // end if fDtype
957     } // end for i
958 }
959 //______________________________________________________________________
960 void AliITS::Hits2SDigits(){
961     // Standard Hits to summable Digits function.
962     // Inputs:
963     //      none.
964     // Outputs:
965     //      none.
966
967     fLoader->LoadHits("read");
968     fLoader->LoadSDigits("recreate");
969     AliRunLoader* rl = fLoader->GetRunLoader(); 
970
971     for (Int_t iEvent = 0; iEvent < rl->GetNumberOfEvents(); iEvent++) {
972         // Do the Hits to Digits operation. Use Standard input values.
973         // Event number from file, no background hit merging , use size from
974         // AliITSgeom class, option="All", input from this file only.
975         rl->GetEvent(iEvent);
976         if (!fLoader->TreeS()) fLoader->MakeTree("S");
977         MakeBranch("S");
978         SetTreeAddress();
979         HitsToPreDigits(iEvent,0,-1," ",fOpt," ");
980     } // end for iEvent
981     
982     fLoader->UnloadHits();
983     fLoader->UnloadSDigits();
984 }
985 //______________________________________________________________________
986 void AliITS::SDigitsToDigits(Option_t *opt){
987     // Standard Summable digits to Digits function.
988     // Inputs:
989     //      none.
990     // Outputs:
991     //      none.
992     char name[20] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
993
994     if(!GetITSgeom()) return; // need transformations to do digitization.
995     AliITSgeom *geom = GetITSgeom();
996
997     const char *all = strstr(opt,"All");
998     const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),
999                           strstr(opt,"SSD")};
1000     if( !det[0] && !det[1] && !det[2] ) all = "All";
1001     else all = 0;
1002     static Bool_t setDef = kTRUE;
1003     if(setDef) SetDefaultSimulation();
1004     setDef = kFALSE;
1005
1006     AliITSsimulation *sim      = 0;
1007     AliITSDetType    *iDetType = 0;
1008     TTree            *trees    = fLoader->TreeS();
1009     if( !(trees && this->GetSDigits()) ){
1010         Error("SDigits2Digits","Error: No trees or SDigits. Returning.");
1011         return;
1012     } // end if
1013     sprintf( name, "%s", this->GetName() );
1014     TBranch *brchSDigits = trees->GetBranch( name );
1015     
1016     Int_t id,module;
1017     for(module=0;module<geom->GetIndexMax();module++){
1018         id       = geom->GetModuleType(module);
1019         if (!all && !det[id]) continue;
1020         iDetType = DetType(id);
1021         sim      = (AliITSsimulation*)iDetType->GetSimulationModel();
1022         if (!sim) {
1023             Error("SDigit2Digits","The simulation class was not "
1024                   "instanciated for module %d type %s!",module,
1025                   geom->GetModuleTypeName(module));
1026             exit(1);
1027         } // end if !sim
1028         sim->InitSimulationModule(module,gAlice->GetEvNumber());
1029         //
1030         // add summable digits to module
1031         this->GetSDigits()->Clear();
1032         brchSDigits->GetEvent(module);
1033         sim->AddSDigitsToModule(GetSDigits(),0);
1034         //
1035         // Digitise current module sum(SDigits)->Digits
1036         sim->FinishSDigitiseModule();
1037
1038         // fills all branches - wasted disk space
1039         fLoader->TreeD()->Fill();
1040         this->ResetDigits();
1041     } // end for module
1042
1043     fLoader->TreeD()->GetEntries();
1044
1045     fLoader->TreeD()->AutoSave();
1046     // reset tree
1047     fLoader->TreeD()->Reset();
1048     
1049 }
1050 //______________________________________________________________________
1051 void AliITS::Hits2Digits(){
1052     // Standard Hits to Digits function.
1053     // Inputs:
1054     //      none.
1055     // Outputs:
1056     //      none.
1057
1058     fLoader->LoadHits("read");
1059     fLoader->LoadDigits("recreate");
1060     AliRunLoader* rl = fLoader->GetRunLoader(); 
1061
1062     for (Int_t iEvent = 0; iEvent < rl->GetNumberOfEvents(); iEvent++) {
1063         // Do the Hits to Digits operation. Use Standard input values.
1064         // Event number from file, no background hit merging , use size from
1065         // AliITSgeom class, option="All", input from this file only.
1066         rl->GetEvent(iEvent);
1067         if (!fLoader->TreeD()) fLoader->MakeTree("D");
1068         MakeBranch("D");
1069         SetTreeAddress();   
1070         HitsToDigits(iEvent,0,-1," ",fOpt," ");
1071     } // end for iEvent
1072
1073     fLoader->UnloadHits();
1074     fLoader->UnloadDigits();
1075 }
1076 //______________________________________________________________________
1077 void AliITS::HitsToPreDigits(Int_t evNumber,Int_t bgrev,Int_t size,
1078                              Option_t *option,Option_t *opt,
1079                              const char *filename){
1080     //   Keep galice.root for signal and name differently the file for 
1081     // background when add! otherwise the track info for signal will be lost !
1082     // the condition below will disappear when the geom class will be
1083     // initialized for all versions - for the moment it is only for v5 !
1084     // 7 is the SDD beam test version.
1085     // Inputs:
1086     //      Int_t evnt       Event to be processed.
1087     //      Int_t bgrev      Background Hit tree number.
1088     //      Int_t nmodules   Not used.
1089     //      Option_t *option String indicating if merging hits or not. To
1090     //                       merge hits set equal to "Add". Otherwise no
1091     //                       background hits are considered.
1092     //      Test_t *filename File name containing the background hits..
1093     // Outputs:
1094     //      none.
1095     // Return:
1096     //      none.
1097
1098     if(!GetITSgeom()) return; // need transformations to do digitization.
1099     AliITSgeom *geom = GetITSgeom();
1100
1101     const char *all = strstr(opt,"All");
1102     const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),
1103                           strstr(opt,"SSD")};
1104     static Bool_t setDef=kTRUE;
1105     if (setDef) SetDefaultSimulation();
1106     setDef=kFALSE;
1107
1108     Int_t nmodules;
1109     InitModules(size,nmodules);
1110     FillModules(evNumber,bgrev,nmodules,option,filename);
1111
1112     AliITSsimulation *sim      = 0;
1113     AliITSDetType    *iDetType = 0;
1114     AliITSmodule     *mod      = 0;
1115     Int_t id,module;
1116     for(module=0;module<geom->GetIndexMax();module++){
1117         id       = geom->GetModuleType(module);
1118         if (!all && !det[id]) continue;
1119         iDetType = DetType(id);
1120         sim      = (AliITSsimulation*)iDetType->GetSimulationModel();
1121         if (!sim) {
1122             Error("HitsToSDigits","The simulation class was not "
1123                   "instanciated for module %d type %s!",module,
1124                   geom->GetModuleTypeName(module));
1125             exit(1);
1126         } // end if !sim
1127         mod      = (AliITSmodule *)fITSmodules->At(module);
1128         sim->SDigitiseModule(mod,module,evNumber);
1129         // fills all branches - wasted disk space
1130         fLoader->TreeS()->Fill(); 
1131         ResetSDigits();
1132     } // end for module
1133
1134     ClearModules();
1135
1136     fLoader->TreeS()->GetEntries();
1137     fLoader->TreeS()->AutoSave();
1138     fLoader->WriteSDigits("OVERWRITE");
1139     // reset tree
1140     fLoader->TreeS()->Reset();
1141 }
1142 //______________________________________________________________________
1143 void AliITS::HitsToDigits(Int_t evNumber,Int_t bgrev,Int_t size,
1144                           Option_t *option,Option_t *opt,
1145                           const char *filename){
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     // the condition below will disappear when the geom class will be
1149     // initialized for all versions - for the moment it is only for v5 !
1150     // 7 is the SDD beam test version.
1151     // Inputs:
1152     //      Int_t evnt       Event to be processed.
1153     //      Int_t bgrev      Background Hit tree number.
1154     //      Int_t nmodules   Not used.
1155     //      Option_t *option String indicating if merging hits or not. To
1156     //                       merge hits set equal to "Add". Otherwise no
1157     //                       background hits are considered.
1158     //      Test_t *filename File name containing the background hits..
1159     // Outputs:
1160     //      none.
1161     // Return:
1162     //      none.
1163
1164
1165     if(!GetITSgeom()) return; // need transformations to do digitization.
1166     AliITSgeom *geom = GetITSgeom();
1167
1168     const char *all = strstr(opt,"All");
1169     const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),
1170                           strstr(opt,"SSD")};
1171     static Bool_t setDef=kTRUE;
1172     if (setDef) SetDefaultSimulation();
1173     setDef=kFALSE;
1174
1175     Int_t nmodules;
1176     InitModules(size,nmodules);
1177     FillModules(evNumber,bgrev,nmodules,option,filename);
1178
1179     AliITSsimulation *sim      = 0;
1180     AliITSDetType    *iDetType = 0;
1181     AliITSmodule     *mod      = 0;
1182     Int_t id,module;
1183     for(module=0;module<geom->GetIndexMax();module++){
1184         id       = geom->GetModuleType(module);
1185         if (!all && !det[id]) continue;
1186         iDetType = DetType(id);
1187         sim      = (AliITSsimulation*)iDetType->GetSimulationModel();
1188         if (!sim) {
1189             Error("HitsToDigits","The simulation class was not "
1190                   "instanciated for module %d type %s!",module,
1191                   geom->GetModuleTypeName(module));
1192             exit(1);
1193         } // end if !sim
1194         mod      = (AliITSmodule *)fITSmodules->At(module);
1195         sim->DigitiseModule(mod,module,evNumber);
1196         // fills all branches - wasted disk space
1197         fLoader->TreeD()->Fill(); 
1198         ResetDigits();
1199     } // end for module
1200
1201     ClearModules();
1202
1203     fLoader->TreeD()->GetEntries();
1204     fLoader->TreeD()->AutoSave();
1205     // reset tree
1206     fLoader->TreeD()->Reset();
1207 }
1208 //______________________________________________________________________
1209 void AliITS::ResetDigits(){
1210     // Reset number of digits and the digits array for the ITS detector.
1211     // Inputs:
1212     //      none.
1213     // Outputs:
1214     //      none.
1215
1216     if (!fDtype) return;
1217
1218     Int_t i;
1219     for (i=0;i<kNTYPES;i++ ) {
1220         ResetDigits(i);
1221     } // end for i
1222 }
1223 //______________________________________________________________________
1224 void AliITS::ResetDigits(Int_t i){
1225     // Reset number of digits and the digits array for this branch.
1226     // Inputs:
1227     //      none.
1228     // Outputs:
1229     //      none.
1230
1231     if (fDtype->At(i)) ((TClonesArray*)fDtype->At(i))->Clear();
1232     if (fNdtype)       fNdtype[i]=0;
1233 }
1234 //______________________________________________________________________
1235 void AliITS::AddSumDigit(AliITSpListItem &sdig){
1236     // Adds the a module full of summable digits to the summable digits tree.
1237     // Inputs:
1238     //      AliITSpListItem &sdig   SDigit to be added to SDigits tree.
1239     // Outputs:
1240     //      none.
1241     // Return:
1242     //      none.
1243
1244     TClonesArray &lsdig = *fSDigits;
1245     new(lsdig[fNSDigits++]) AliITSpListItem(sdig);
1246 }
1247 //______________________________________________________________________
1248 void AliITS::AddRealDigit(Int_t id, Int_t *digits){
1249     //   Add a real digit - as coming from data.
1250     // Inputs:
1251     //      Int_t id        Detector type number.
1252     //      Int_t *digits   Integer array containing the digits info. See 
1253     //                      AliITSdigit.h
1254     // Outputs:
1255     //      none.
1256     // Return:
1257     //      none.
1258
1259     TClonesArray &ldigits = *((TClonesArray*)fDtype->At(id));
1260     new(ldigits[fNdtype[id]++]) AliITSdigit(digits);
1261 }
1262 //______________________________________________________________________
1263 void AliITS::AddSimDigit(Int_t id, AliITSdigit *d){
1264     //    Add a simulated digit.
1265     // Inputs:
1266     //      Int_t id        Detector type number.
1267     //      AliITSdigit *d  Digit to be added to the Digits Tree. See 
1268     //                      AliITSdigit.h
1269     // Outputs:
1270     //      none.
1271     // Return:
1272     //      none.
1273
1274     TClonesArray &ldigits = *((TClonesArray*)fDtype->At(id));
1275
1276     switch(id){
1277     case 0:
1278         new(ldigits[fNdtype[id]++]) AliITSdigitSPD(*((AliITSdigitSPD*)d));
1279         break;
1280     case 1:
1281         new(ldigits[fNdtype[id]++]) AliITSdigitSDD(*((AliITSdigitSDD*)d));
1282         break;
1283     case 2:
1284         new(ldigits[fNdtype[id]++]) AliITSdigitSSD(*((AliITSdigitSSD*)d));
1285         break;
1286     } // end switch id
1287 }
1288 //______________________________________________________________________
1289 void AliITS::AddSimDigit(Int_t id,Float_t phys,Int_t *digits,Int_t *tracks,
1290                          Int_t *hits,Float_t *charges){
1291   //   Add a simulated digit to the list.
1292   // Inputs:
1293   //      Int_t id        Detector type number.
1294   //      Float_t phys    Physics indicator. See AliITSdigits.h
1295   //      Int_t *digits   Integer array containing the digits info. See 
1296   //                      AliITSdigit.h
1297   //      Int_t *tracks   Integer array [AliITSdigitS?D::GetNTracks()] 
1298   //                      containing the track numbers that contributed to
1299   //                      this digit.
1300   //      Int_t *hits     Integer array [AliITSdigitS?D::GetNTracks()]
1301   //                      containing the hit numbers, from AliITSmodule, that
1302   //                      contributed to this digit.
1303   //      Float_t *charge Floating point array of the signals contributed
1304   //                      to this digit by each track.
1305   // Outputs:
1306   //      none.
1307   // Return:
1308   //      none.
1309
1310   TClonesArray &ldigits = *((TClonesArray*)fDtype->At(id));
1311   AliITSresponseSDD *resp = 0;
1312   switch(id){
1313   case 0:
1314       new(ldigits[fNdtype[id]++]) AliITSdigitSPD(digits,tracks,hits);
1315       break;
1316   case 1:
1317       resp = (AliITSresponseSDD*)DetType(1)->GetResponseModel();
1318       new(ldigits[fNdtype[id]++]) AliITSdigitSDD(phys,digits,tracks,
1319                                                  hits,charges,resp);
1320       break;
1321   case 2:
1322       new(ldigits[fNdtype[id]++]) AliITSdigitSSD(digits,tracks,hits);
1323       break;
1324   } // end switch id
1325 }
1326 //______________________________________________________________________
1327 void AliITS::Digits2Raw(){
1328     // convert digits of the current event to raw data
1329
1330   fLoader->LoadDigits();
1331   TTree* digits = fLoader->TreeD();
1332   if (!digits) {
1333       Error("Digits2Raw", "no digits tree");
1334       return;
1335   }
1336   SetTreeAddressD(digits);
1337
1338   AliITSDDLRawData rawWriter;
1339   //Verbose level
1340   // 0: Silent
1341   // 1: cout messages
1342   // 2: txt files with digits 
1343   //BE CAREFUL, verbose level 2 MUST be used only for debugging and
1344   //it is highly suggested to use this mode only for debugging digits files
1345   //reasonably small, because otherwise the size of the txt files can reach
1346   //quickly several MB wasting time and disk space.
1347   rawWriter.SetVerbose(0);
1348     
1349   //SILICON PIXEL DETECTOR
1350   Info("Digits2Raw", "Formatting raw data for SPD");
1351   rawWriter.RawDataSPD(digits->GetBranch("ITSDigitsSPD"));
1352     
1353   //SILICON DRIFT DETECTOR
1354   Info("Digits2Raw", "Formatting raw data for SDD");
1355   rawWriter.RawDataSDD(digits->GetBranch("ITSDigitsSDD"));
1356     
1357   //SILICON STRIP DETECTOR
1358   Info("Digits2Raw", "Formatting raw data for SSD");
1359   rawWriter.RawDataSSD(digits->GetBranch("ITSDigitsSSD"));
1360
1361   fLoader->UnloadDigits();
1362 }
1363
1364 //______________________________________________________________________
1365 void AliITS::MakeTreeC(Option_t *option){
1366   //   Create a separate tree to store the clusters.
1367   // Inputs:
1368   //      Option_t *option  string which must contain "C" otherwise
1369   //                        no Cluster Tree is created.
1370   // Outputs:
1371   //      none.
1372   // Return:
1373   //      none.
1374
1375   AliITSLoader *pITSLoader = (AliITSLoader*)fLoader;    
1376     
1377   if (pITSLoader == 0x0) {
1378       Error("MakeTreeC","fLoader == 0x0 option=%s",option);
1379       return;
1380   }
1381   if (pITSLoader->TreeC() == 0x0) pITSLoader->MakeTree("C");
1382   MakeBranchC();
1383 }
1384 //----------------------------------------------------------------------
1385 void AliITS::MakeBranchC(){
1386     //Makes barnches in treeC
1387     AliITSLoader *pITSLoader = (AliITSLoader*)fLoader;    
1388     if (pITSLoader == 0x0) {
1389         Error("MakeTreeC","fLoader == 0x0");
1390         return;
1391     }
1392     TTree * lTC = pITSLoader->TreeC();
1393     if (lTC == 0x0){
1394         Error("MakeTreeC","Can not get TreeC from Loader");
1395         return;
1396     }
1397
1398     Int_t buffersize = 4000;
1399     char branchname[30];
1400     const char *det[3] = {"SPD","SDD","SSD"};
1401     char digclass[40];
1402     char clclass[40];
1403     
1404     // one branch for Clusters per type of detector
1405     Int_t i;   
1406     for (i=0; i<kNTYPES ;i++) {
1407         AliITSDetType *iDetType=DetType(i); 
1408         iDetType->GetClassNames(digclass,clclass);
1409         // clusters
1410         if (fCtype == 0x0) fCtype  = new TObjArray(fNDetTypes);
1411         if(!ClustersAddress(i)){
1412             fCtype->AddAt(new TClonesArray(clclass,1000),i);
1413         }
1414         if (kNTYPES==3) sprintf(branchname,"%sClusters%s",GetName(),det[i]);
1415         else  sprintf(branchname,"%sClusters%d",GetName(),i+1);
1416         if (fCtype  && lTC) {
1417             if (lTC->GetBranch(branchname)){
1418                 Warning("MakeBranchC","Branch %s alread exists in TreeC",
1419                         branchname);
1420             }else{
1421                 Info("MakeBranchC","Creating branch %s in TreeC",branchname);
1422                 lTC->Branch(branchname,&((*fCtype)[i]), buffersize);
1423             }
1424         } // end if fCtype && lTC
1425     } // end for i
1426 }
1427 //______________________________________________________________________
1428 void AliITS::GetTreeC(Int_t event){
1429     //    Get the clusters tree for this event and set the branch address.
1430     // Inputs:
1431     //      Int_t event    Event number for the cluster tree.
1432     // Outputs:
1433     //      none.
1434     // Return:
1435     //      none.
1436     char branchname[30];
1437     const char *det[3] = {"SPD","SDD","SSD"};
1438
1439     AliITSLoader *pITSLoader = (AliITSLoader*)fLoader;
1440     TTree * lTC = pITSLoader->TreeC();
1441
1442     ResetClusters();
1443     if (lTC) {
1444         pITSLoader->CleanRawClusters();
1445     } // end if TreeC()
1446
1447     TBranch *branch;
1448
1449     if (lTC) {
1450         Int_t i;
1451         char digclass[40];
1452         char clclass[40];
1453         for (i=0; i<kNTYPES; i++) {
1454             AliITSDetType *iDetType=DetType(i); 
1455             iDetType->GetClassNames(digclass,clclass);
1456             // clusters
1457             if (fCtype == 0x0) fCtype  = new TObjArray(fNDetTypes);
1458             if(!fCtype->At(i)) fCtype->AddAt(new TClonesArray(clclass,1000),i);
1459             if(kNTYPES==3) sprintf(branchname,"%sClusters%s",GetName(),det[i]);
1460             else  sprintf(branchname,"%sClusters%d",GetName(),i+1);
1461             if (fCtype) {
1462                 branch = lTC->GetBranch(branchname);
1463                 if (branch) branch->SetAddress(&((*fCtype)[i]));
1464             } // end if fCtype
1465         } // end for i
1466     } else {
1467         Error("GetTreeC","cannot find Clusters Tree for event:%d",event);
1468     } // end if lTC
1469 }
1470 //______________________________________________________________________
1471 void AliITS::AddCluster(Int_t id, AliITSRawCluster *c){
1472     //   Add a cluster to the list.
1473     // Inputs:
1474     //      Int_t id             Detector type number.
1475     //      AliITSRawCluster *c  Cluster class to be added to the tree of
1476     //                           clusters.
1477     // Outputs:
1478     //      none.
1479     // Return:
1480     //      none.
1481
1482     TClonesArray &lc = *((TClonesArray*)fCtype->At(id));
1483
1484     switch(id){
1485     case 0:
1486         new(lc[fNctype[id]++]) AliITSRawClusterSPD(*((AliITSRawClusterSPD*)c));
1487         break;
1488     case 1:
1489         new(lc[fNctype[id]++]) AliITSRawClusterSDD(*((AliITSRawClusterSDD*)c));
1490         break;
1491     case 2:
1492         new(lc[fNctype[id]++]) AliITSRawClusterSSD(*((AliITSRawClusterSSD*)c));
1493         break;
1494     } // end switch id
1495 }
1496 //______________________________________________________________________
1497 void AliITS::ResetClusters(Int_t i){
1498     //    Reset number of clusters and the clusters array for this branch.
1499     // Inputs:
1500     //      Int_t i        Detector type number.
1501     // Outputs:
1502     //      none.
1503     // Return:
1504     //      none.
1505
1506     if (fCtype->At(i))    ((TClonesArray*)fCtype->At(i))->Clear();
1507     if (fNctype)  fNctype[i]=0;
1508 }
1509 //______________________________________________________________________
1510 void AliITS::MakeBranchR(const char *file, Option_t *opt){
1511     // Creates Tree branches for the ITS Reconstructed points.
1512     // Inputs:
1513     //      cont char *file  File name where RecPoints branch is to be written
1514     //                       to. If blank it write the SDigits to the same
1515     //                       file in which the Hits were found.
1516     // Outputs:
1517     //      none.
1518     // Return:
1519     //      none.
1520     Int_t buffsz = 4000;
1521     char branchname[30];
1522
1523     // only one branch for rec points for all detector types
1524     Bool_t oFast= (strstr(opt,"Fast")!=0);
1525     Bool_t v2 = (strstr(opt,"v2")!=0);
1526     
1527
1528     if(oFast){
1529         sprintf(branchname,"%sRecPointsF",GetName());
1530     } else if(v2){
1531         sprintf(branchname,"Clusters");
1532     } else {
1533         sprintf(branchname,"%sRecPoints",GetName());
1534     }
1535
1536     if(v2){
1537       
1538       if(!fClustersV2)fClustersV2 = new TClonesArray("AliITSclusterV2",3000);
1539       if(fLoader->TreeR()){
1540         if(fClustersV2==0x0) fClustersV2 = new TClonesArray("AliITSclusterV2",3000);
1541         MakeBranchInTree(fLoader->TreeR(),branchname,&fClustersV2,buffsz,file);
1542
1543       }
1544     }else{
1545       if(!fRecPoints)fRecPoints = new TClonesArray("AliITSRecPoint",1000);
1546       if (fLoader->TreeR()) {
1547         if(fRecPoints==0x0) fRecPoints = new TClonesArray("AliITSRecPoint",
1548                                                           1000);
1549         MakeBranchInTree(fLoader->TreeR(),branchname,&fRecPoints,buffsz,file);
1550       } // end if
1551     }
1552 }
1553 //______________________________________________________________________
1554 void AliITS::SetTreeAddressR(TTree *treeR){
1555     // Set branch address for the Reconstructed points Trees.
1556     // Inputs:
1557     //      TTree *treeR   Tree containing the RecPoints.
1558     // Outputs:
1559     //      none.
1560     // Return:
1561     //      none.
1562     char branchname[30];
1563
1564     if(!treeR) return;
1565     if(fRecPoints==0x0) fRecPoints = new TClonesArray("AliITSRecPoint",1000);
1566     TBranch *branch1;
1567     sprintf(branchname,"Clusters");
1568     branch1 = treeR->GetBranch(branchname);
1569     if(branch1){
1570       if(fClustersV2==0x0) fClustersV2 = new TClonesArray("AliITSclusterV2",3000);
1571       branch1->SetAddress(&fClustersV2);
1572     }
1573     else{
1574       TBranch *branch;
1575       sprintf(branchname,"%sRecPoints",GetName());
1576       branch = treeR->GetBranch(branchname);
1577       if (branch) {
1578         branch->SetAddress(&fRecPoints);
1579       }else {
1580         sprintf(branchname,"%sRecPointsF",GetName());
1581         branch = treeR->GetBranch(branchname);
1582         if (branch) {
1583           branch->SetAddress(&fRecPoints);
1584         }
1585       }
1586     }
1587 }
1588 //______________________________________________________________________
1589 void AliITS::AddRecPoint(const AliITSRecPoint &r){
1590     // Add a reconstructed space point to the list
1591     // Inputs:
1592     //      const AliITSRecPoint &r RecPoint class to be added to the tree
1593     //                              of reconstructed points TreeR.
1594     // Outputs:
1595     //      none.
1596     // Return:
1597     //      none.
1598
1599     TClonesArray &lrecp = *fRecPoints;
1600     new(lrecp[fNRecPoints++]) AliITSRecPoint(r);
1601 }
1602 //______________________________________________________________________
1603 void AliITS::AddClusterV2(const AliITSclusterV2 &r){
1604     // Add a reconstructed space point to the list
1605     // Inputs:
1606     //      const AliITSClusterV2 &r class to be added to the tree
1607     //                              of reconstructed points TreeR.
1608     // Outputs:
1609     //      none.
1610     // Return:
1611     //      none.
1612
1613     TClonesArray &lrecp = *fClustersV2;
1614     new(lrecp[fNClustersV2++]) AliITSclusterV2(r);
1615 }
1616 //______________________________________________________________________
1617 void AliITS::HitsToFastRecPoints(Int_t evNumber,Int_t bgrev,Int_t size,
1618                                   Option_t *opt0,Option_t *opt1,
1619                                  const char *flnm){
1620     // keep galice.root for signal and name differently the file for 
1621     // background when add! otherwise the track info for signal will be lost !
1622     // the condition below will disappear when the geom class will be
1623     // initialized for all versions - for the moment it is only for v5 !
1624     // Inputs:
1625     //      Int_t evnt       Event to be processed.
1626     //      Int_t bgrev      Background Hit tree number.
1627     //      Int_t size       Size used by InitModules. See InitModules.
1628     //      Option_t *opt0   Option passed to FillModules. See FillModules.
1629     //      Option_t *opt1   String indicating if merging hits or not. To
1630     //                       merge hits set equal to "Add". Otherwise no
1631     //                       background hits are considered.
1632     //      Test_t *flnm     File name containing the background hits..
1633     // Outputs:
1634     //      none.
1635     // Return:
1636     //      none.
1637
1638     if(!GetITSgeom()) return;
1639     AliITSLoader *pITSloader = (AliITSLoader*)fLoader;
1640     AliITSgeom *geom = GetITSgeom();
1641
1642     const char *all = strstr(opt1,"All");
1643     const char *det[3] ={strstr(opt1,"SPD"),strstr(opt1,"SDD"),
1644                          strstr(opt1,"SSD")};
1645     Int_t nmodules;
1646     InitModules(size,nmodules);
1647     FillModules(evNumber,bgrev,nmodules,opt0,flnm);
1648
1649     AliITSsimulation *sim      = 0;
1650     AliITSDetType    *iDetType = 0;
1651     AliITSmodule     *mod      = 0;
1652     Int_t id,module;
1653
1654     //m.b. : this change is nothing but a nice way to make sure
1655     //the CPU goes up !
1656     
1657     AliDebugClassStream(1) <<"HitsToFastRecPoints: N mod = "<<
1658                        geom->GetIndexMax()<<endl;
1659     for(module=0;module<geom->GetIndexMax();module++){
1660         id       = geom->GetModuleType(module);
1661         if (!all && !det[id]) continue;
1662         iDetType = DetType(id);
1663         sim      = (AliITSsimulation*)iDetType->GetSimulationModel();
1664         if (!sim) {
1665             Error("HitsToFastPoints","The simulation class was not "
1666                   "instanciated for module %d type %x!",module,
1667                   geom->GetModuleTypeName(module));
1668             exit(1);
1669         } // end if !sim
1670         mod      = (AliITSmodule *)fITSmodules->At(module);
1671         sim->CreateFastRecPoints(mod,module,gRandom);
1672         cout<<module<<"\r";fflush(0);
1673         //gAlice->TreeR()->Fill();
1674         TTree *lTR = pITSloader->TreeR();
1675         TBranch *br=lTR->GetBranch("ITSRecPointsF");
1676         br->Fill();
1677         ResetRecPoints();
1678     } // end for module
1679
1680     ClearModules();
1681     fLoader->WriteRecPoints("OVERWRITE");
1682 }
1683 //______________________________________________________________________
1684 void AliITS::DigitsToRecPoints(Int_t evNumber,Int_t lastentry,Option_t *opt){
1685   // cluster finding and reconstruction of space points
1686   // the condition below will disappear when the geom class will be
1687   // initialized for all versions - for the moment it is only for v5 !
1688   // 7 is the SDD beam test version
1689   // Inputs:
1690   //      Int_t evNumber   Event number to be processed.
1691   //      Int_t lastentry  Offset for module when not all of the modules
1692   //                       are processed.
1693   //      Option_t *opt    String indicating which ITS sub-detectors should
1694   //                       be processed. If ="All" then all of the ITS
1695   //                       sub detectors are processed.
1696   // Outputs:
1697   //      none.
1698   // Return:
1699   //      none.
1700
1701   if(!GetITSgeom()) return;
1702   AliITSgeom *geom = GetITSgeom();
1703     
1704   const char *all = strstr(opt,"All");
1705   const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),
1706                         strstr(opt,"SSD")};
1707   static Bool_t setRec=kTRUE;
1708   if (setRec) SetDefaultClusterFinders();
1709   setRec=kFALSE;
1710
1711   AliITSLoader *pITSloader = (AliITSLoader*)fLoader;
1712   TTree *treeC=pITSloader->TreeC();
1713   AliITSClusterFinder *rec     = 0;
1714   AliITSDetType      *iDetType = 0;
1715   Int_t id,module,first=0;
1716   for(module=0;module<geom->GetIndexMax();module++){
1717       id       = geom->GetModuleType(module);
1718       if (!all && !det[id]) continue;
1719       if(det[id]) first = geom->GetStartDet(id);
1720       iDetType = DetType(id);
1721       rec = (AliITSClusterFinder*)iDetType->GetReconstructionModel();
1722       TClonesArray *itsDigits  = this->DigitsAddress(id);
1723       if (!rec) {
1724           Error("DigitsToRecPoints",
1725                 "The reconstruction class was not instanciated! event=%d",
1726                 evNumber);
1727           exit(1);
1728       } // end if !rec
1729       this->ResetDigits();
1730       TTree *lTD = pITSloader->TreeD();
1731       if (all) {
1732           lTD->GetEvent(lastentry+module);
1733       }else {
1734           lTD->GetEvent(lastentry+(module-first));
1735       }
1736       Int_t ndigits = itsDigits->GetEntriesFast();
1737       if(ndigits>0){
1738           rec->SetDigits(DigitsAddress(id));
1739           rec->SetClusters(ClustersAddress(id));
1740           rec->FindRawClusters(module);
1741       } // end if
1742       pITSloader->TreeR()->Fill();
1743       ResetRecPoints();
1744       ResetClustersV2();
1745       treeC->Fill();
1746       ResetClusters();
1747   } // end for module
1748
1749   pITSloader->WriteRecPoints("OVERWRITE");
1750   pITSloader->WriteRawClusters("OVERWRITE");
1751 }
1752 //______________________________________________________________________
1753 void AliITS::DigitsToRecPoints(AliRawReader* rawReader){
1754   // cluster finding and reconstruction of space points
1755   // the condition below will disappear when the geom class will be
1756   // initialized for all versions - for the moment it is only for v5 !
1757   // 7 is the SDD beam test version
1758   // Inputs:
1759   //      Int_t evNumber   Event number to be processed.
1760   //      Int_t lastentry  Offset for module when not all of the modules
1761   //                       are processed.
1762   //      Option_t *opt    String indicating which ITS sub-detectors should
1763   //                       be processed. If ="All" then all of the ITS
1764   //                       sub detectors are processed.
1765   // Outputs:
1766   //      none.
1767   // Return:
1768   //      none.
1769   if(!GetITSgeom()) return;
1770   AliITSgeom *geom = GetITSgeom();
1771   
1772     
1773   SetDefaultClusterFindersV2();
1774   
1775   AliITSLoader *pITSloader = (AliITSLoader*)fLoader;
1776   AliITSClusterFinderV2 *rec     = 0;
1777   AliITSDetType      *iDetType = 0;
1778   Int_t id=0;
1779
1780   if(!pITSloader->TreeR()) pITSloader->MakeTree("R");
1781   TTree* cTree = pITSloader->TreeR();
1782   TClonesArray *array=new TClonesArray("AliITSclusterV2",1000);
1783   cTree->Branch("Clusters",&array);
1784   delete array;
1785  
1786   TClonesArray** clusters = new TClonesArray*[geom->GetIndexMax()]; 
1787   for (Int_t iModule = 0; iModule < geom->GetIndexMax(); iModule++) {
1788     clusters[iModule] = NULL;
1789   }
1790   for(id=0;id<3;id++){
1791     iDetType = DetType(id);
1792     rec = (AliITSClusterFinderV2*)iDetType->GetReconstructionModel();
1793     if (!rec) {
1794       Error("DigitsToRecPoints",
1795             "The reconstruction class was not instanciated");
1796       exit(1);
1797     } 
1798     rec->RawdataToClusters(rawReader,clusters);    
1799   } 
1800   Int_t nClusters =0;
1801   for(Int_t iModule=0;iModule<geom->GetIndexMax();iModule++){
1802     array = clusters[iModule];
1803     if(!array){
1804       Error("DigitsToRecPoints","data for module %d missing!",iModule);
1805       array = new TClonesArray("AliITSclusterV2");
1806     }
1807     cTree->SetBranchAddress("Clusters",&array);
1808     cTree->Fill();
1809     nClusters+=array->GetEntriesFast();
1810     delete array;
1811   }
1812   pITSloader->WriteRecPoints("OVERWRITE");
1813
1814   delete[] clusters;
1815   Info("DigitsToRecPoints", "total number of found clustersV2 in ITS: %d\n", 
1816        nClusters);
1817   
1818 }
1819
1820 //______________________________________________________________________
1821 AliLoader* AliITS::MakeLoader(const char* topfoldername){ 
1822     //builds ITSgetter (AliLoader type)
1823     //if detector wants to use castomized getter, it must overload this method
1824
1825     Info("MakeLoader","Creating AliITSLoader. Top folder is %s.",
1826          topfoldername);
1827     fLoader = new AliITSLoader(GetName(),topfoldername);
1828     return fLoader;
1829 }