345dba92a9d7240a438a8dfb46e784a7902107b3
[u/mrichter/AliRoot.git] / ITS / AliITSDetTypeRec.cxx
1 /***************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Conributors 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  $Id$
18 */
19
20 ////////////////////////////////////////////////////////////////////////
21 // This class defines the "Standard" reconstruction for the ITS       // 
22 // detector.                                                          //
23 //                                                                    //
24 ////////////////////////////////////////////////////////////////////////
25 #include "TObjArray.h"
26 #include "TTree.h"
27
28 #include "AliCDBManager.h"
29 #include "AliCDBStorage.h"
30 #include "AliCDBEntry.h"
31 #include "AliITSClusterFinder.h"
32 #include "AliITSClusterFinderV2.h"
33 #include "AliITSClusterFinderV2SPD.h"
34 #include "AliITSClusterFinderV2SDD.h"
35 #include "AliITSClusterFinderV2SSD.h"
36 #include "AliITSClusterFinderSPD.h"
37 #include "AliITSClusterFinderSDD.h"
38 #include "AliITSClusterFinderSSD.h"
39 #include "AliITSDetTypeRec.h"
40 #include "AliITSRawCluster.h"
41 #include "AliITSRawClusterSPD.h"
42 #include "AliITSRawClusterSDD.h"
43 #include "AliITSRawClusterSSD.h"
44 #include "AliITSRecPoint.h"
45 #include "AliITSCalibrationSDD.h"
46 #include "AliITSsegmentationSPD.h"
47 #include "AliITSsegmentationSDD.h"
48 #include "AliITSsegmentationSSD.h"
49 #include "AliLog.h"
50
51
52 const Int_t AliITSDetTypeRec::fgkNdettypes = 3;
53 const Int_t AliITSDetTypeRec::fgkDefaultNModulesSPD =  240;
54 const Int_t AliITSDetTypeRec::fgkDefaultNModulesSDD =  260;
55 const Int_t AliITSDetTypeRec::fgkDefaultNModulesSSD = 1698;
56
57 ClassImp(AliITSDetTypeRec)
58
59 //________________________________________________________________
60 AliITSDetTypeRec::AliITSDetTypeRec(): TObject(),
61 fNMod(0),
62 fReconstruction(0),
63 fSegmentation(0),
64 fCalibration(0),
65 fPreProcess(0),
66 fPostProcess(0),
67 fDigits(0),
68 fNdtype(0),
69 fCtype(0),
70 fNctype(0),
71 fRecPoints(0),
72 fNRecPoints(0),
73 fSelectedVertexer(),
74 fLoader(0),
75 fRunNumber(0),
76 fFirstcall(kTRUE){
77     // Default Constructor
78     // Inputs:
79     //    none.
80     // Outputs:
81     //    none.
82     // Return:
83     //    A properly zero-ed AliITSDetTypeRec class.
84
85   for(Int_t i=0; i<3; i++){
86     fClusterClassName[i]=0;
87     fDigClassName[i]=0;
88     fRecPointClassName[i]=0;
89   }
90
91   SelectVertexer(" ");
92
93
94 }
95 //________________________________________________________________
96 AliITSDetTypeRec::AliITSDetTypeRec(AliITSLoader *loader): TObject(),
97 fNMod(0),
98 fReconstruction(0),
99 fSegmentation(0),
100 fCalibration(0),
101 fPreProcess(0),
102 fPostProcess(0),
103 fDigits(0),
104 fNdtype(0),
105 fCtype(0),
106 fNctype(0),
107 fRecPoints(0),
108 fNRecPoints(0),
109 fSelectedVertexer(),
110 fLoader(loader),
111 fRunNumber(0),
112 fFirstcall(kTRUE){
113     // Standard Constructor
114     // Inputs:
115     //    none.
116     // Outputs:
117     //    none.
118     // Return:
119     //   
120
121   fReconstruction = new TObjArray(fgkNdettypes);
122   fDigits = new TObjArray(fgkNdettypes);
123   for(Int_t i=0; i<3; i++){
124     fClusterClassName[i]=0;
125     fDigClassName[i]=0;
126     fRecPointClassName[i]=0;
127   }
128   fNdtype = new Int_t[fgkNdettypes];
129   fCtype = new TObjArray(fgkNdettypes);
130   fNctype = new Int_t[fgkNdettypes];
131   fNMod = new Int_t [fgkNdettypes];
132   fNMod[0] = fgkDefaultNModulesSPD;
133   fNMod[1] = fgkDefaultNModulesSDD;
134   fNMod[2] = fgkDefaultNModulesSSD;
135   fRecPoints = new TClonesArray("AliITSRecPoint",3000);
136   fNRecPoints = 0;
137   
138   for(Int_t i=0;i<fgkNdettypes;i++){
139     fNdtype[i]=0;
140     fNctype[i]=0;
141   }
142   
143   SelectVertexer(" "); 
144   SetRunNumber();
145 }
146
147 //______________________________________________________________________
148 AliITSDetTypeRec::AliITSDetTypeRec(const AliITSDetTypeRec & rec):TObject(rec),
149 fNMod(rec.fNMod),
150 fReconstruction(rec.fReconstruction),
151 fSegmentation(rec.fSegmentation),
152 fCalibration(rec.fCalibration),
153 fPreProcess(rec.fPreProcess),
154 fPostProcess(rec.fPostProcess),
155 fDigits(rec.fDigits),
156 fNdtype(rec.fNdtype),
157 fCtype(rec.fCtype),
158 fNctype(rec.fNctype),
159 fRecPoints(rec.fRecPoints),
160 fNRecPoints(rec.fNRecPoints),
161 fSelectedVertexer(rec.fSelectedVertexer),
162 fLoader(rec.fLoader),
163 fRunNumber(rec.fRunNumber),
164 fFirstcall(rec.fFirstcall)
165 {
166
167   // Copy constructor. 
168
169 }
170 //______________________________________________________________________
171 AliITSDetTypeRec& AliITSDetTypeRec::operator=(const AliITSDetTypeRec& source){
172     // Assignment operator. 
173     this->~AliITSDetTypeRec();
174     new(this) AliITSDetTypeRec(source);
175     return *this;
176
177 }
178
179 //_____________________________________________________________________
180 AliITSDetTypeRec::~AliITSDetTypeRec(){
181   //Destructor
182  
183   if(fReconstruction){
184     fReconstruction->Delete();
185     delete fReconstruction;
186     fReconstruction = 0;
187   }
188   if(fSegmentation){
189     fSegmentation->Delete();
190     delete fSegmentation;
191     fSegmentation = 0;
192   }
193   if(fCalibration && fRunNumber<0){
194     AliITSresponse* rspd = ((AliITSCalibration*)fCalibration->At(GetITSgeom()->GetStartSPD()))->GetResponse();    
195     AliITSresponse* rsdd = ((AliITSCalibration*)fCalibration->At(GetITSgeom()->GetStartSDD()))->GetResponse();
196     AliITSresponse* rssd = ((AliITSCalibration*)fCalibration->At(GetITSgeom()->GetStartSSD()))->GetResponse();
197     if(rspd) delete rspd;
198     if(rsdd) delete rsdd;
199     if(rssd) delete rssd;
200     fCalibration->Delete();
201     delete fCalibration;
202     fCalibration = 0;
203   }
204   if(fPreProcess) delete fPreProcess;
205   if(fPostProcess) delete fPostProcess;
206
207   if(fDigits){
208     fDigits->Delete();
209     delete fDigits;
210     fDigits=0;
211   }
212   if(fRecPoints){
213     fRecPoints->Delete();
214     delete fRecPoints;
215     fRecPoints=0;
216   }
217   if(fCtype) {
218     fCtype->Delete();
219     delete fCtype;
220     fCtype = 0;
221   }
222   delete [] fNctype;
223   delete [] fNdtype;
224   delete [] fNMod;
225   //if(fLoader) delete fLoader; // MvL: Loader is not owned by this class; do not delete
226   
227 }
228
229 //___________________________________________________________________
230 void AliITSDetTypeRec::SetReconstructionModel(Int_t dettype,AliITSClusterFinder *clf){
231
232   //Set reconstruction model for detector type
233
234   if(fReconstruction==0) fReconstruction = new TObjArray(fgkNdettypes);
235   if(fReconstruction->At(dettype)!=0) delete fReconstruction->At(dettype);
236   fReconstruction->AddAt(clf,dettype);
237 }
238 //______________________________________________________________________
239 AliITSClusterFinder* AliITSDetTypeRec::GetReconstructionModel(Int_t dettype){
240
241   //Get reconstruction model for detector type
242   if(fReconstruction==0)  {
243     Warning("GetReconstructionModel","fReconstruction is 0!");
244     return 0;     
245   }
246   return (AliITSClusterFinder*)fReconstruction->At(dettype);
247 }
248
249 //______________________________________________________________________
250 void AliITSDetTypeRec::SetSegmentationModel(Int_t dettype,AliITSsegmentation *seg){
251    
252   //Set segmentation model for detector type
253   
254   if(fSegmentation==0) fSegmentation = new TObjArray(fgkNdettypes);
255   if(fSegmentation->At(dettype)!=0) delete fSegmentation->At(dettype);
256   fSegmentation->AddAt(seg,dettype);
257
258 }
259 //______________________________________________________________________
260 AliITSsegmentation* AliITSDetTypeRec::GetSegmentationModel(Int_t dettype){
261
262   //Get segmentation model for detector type
263    
264    if(fSegmentation==0) {
265      Warning("GetSegmentationModel","fSegmentation is 0!");
266      return 0; 
267    } 
268    return (AliITSsegmentation*)fSegmentation->At(dettype);
269
270 }
271 //_______________________________________________________________________
272 void AliITSDetTypeRec::SetCalibrationModel(Int_t iMod, AliITSCalibration *cal){
273
274   //Set calibration (response) for the module iMod of type dettype
275   if (fCalibration==0) {
276     fCalibration = new TObjArray(GetITSgeom()->GetIndexMax());
277     fCalibration->SetOwner(kTRUE);
278     fCalibration->Clear();
279   }
280
281   if (fCalibration->At(iMod) != 0)
282     delete (AliITSCalibration*) fCalibration->At(iMod);
283   fCalibration->AddAt(cal,iMod);
284
285 }
286 //_______________________________________________________________________
287 AliITSCalibration* AliITSDetTypeRec::GetCalibrationModel(Int_t iMod){
288   
289   //Get calibration model for module type
290   
291   if(fCalibration==0) {
292     Warning("GetalibrationModel","fCalibration is 0!");
293     return 0; 
294   }  
295
296   return (AliITSCalibration*)fCalibration->At(iMod);
297 }
298
299 //______________________________________________________________________
300 void AliITSDetTypeRec::SetTreeAddress(){
301     // Set branch address for the Trees.
302  
303   TTree *treeR = fLoader->TreeR();
304   TTree *treeD = fLoader->TreeD();
305  
306   SetTreeAddressD(treeD);
307   SetTreeAddressR(treeR);
308 }
309 //______________________________________________________________________
310 void AliITSDetTypeRec::SetTreeAddressD(TTree *treeD){
311     // Set branch address for the tree of digits.
312
313     const char *det[4] = {"SPD","SDD","SSD","ITS"};
314     TBranch *branch;
315     Char_t* digclass;
316     Int_t i;
317     char branchname[30];
318
319     if(!treeD) return;
320     if (fDigits == 0x0) fDigits = new TObjArray(fgkNdettypes);
321     for (i=0; i<fgkNdettypes; i++) {
322         digclass = GetDigitClassName(i);
323         if(!(fDigits->At(i))) {
324             fDigits->AddAt(new TClonesArray(digclass,1000),i);
325         }else{
326             ResetDigits(i);
327         } 
328         if (fgkNdettypes==3) sprintf(branchname,"%sDigits%s",det[3],det[i]);
329         else  sprintf(branchname,"%sDigits%d",det[3],i+1);
330         if (fDigits) {
331             branch = treeD->GetBranch(branchname);
332             if (branch) branch->SetAddress(&((*fDigits)[i]));
333         } 
334     } 
335 }
336
337 //_______________________________________________________________________
338 TBranch* AliITSDetTypeRec::MakeBranchInTree(TTree *tree, const char* name, 
339                                        const char *classname, 
340                                        void* address,Int_t size, 
341                                        Int_t splitlevel, const char */*file*/)
342
343 //
344 // Makes branch in given tree and diverts them to a separate file
345 // 
346 //
347 //
348     
349   if (tree == 0x0) {
350     Error("MakeBranchInTree","Making Branch %s Tree is NULL",name);
351     return 0x0;
352   }
353   TBranch *branch = tree->GetBranch(name);
354   if (branch) {  
355     return branch;
356   }
357   if (classname){
358     branch = tree->Branch(name,classname,address,size,splitlevel);
359   }
360   else {
361     branch = tree->Bronch(name, "TClonesArray", address, size, splitlevel);
362   }
363   
364   return branch;
365 }
366
367 //____________________________________________________________________
368 void AliITSDetTypeRec::SetDefaults(){
369   
370   //Set defaults for segmentation and response
371
372   if(!GetITSgeom()){
373     Warning("SetDefaults","null pointer to AliITSgeomGeom !");
374     return;
375   }
376
377   AliITSsegmentation* seg;
378   if(!GetCalibration()) {AliFatal("Exit");exit(0);}  
379
380   for(Int_t dettype=0;dettype<fgkNdettypes;dettype++){
381     if(dettype==0){
382       seg = new AliITSsegmentationSPD(GetITSgeom());
383       SetSegmentationModel(dettype,seg);
384       SetDigitClassName(dettype,"AliITSdigitSPD");
385       SetClusterClassName(dettype,"AliITSRawClusterSPD");
386
387     }
388     if(dettype==1){
389       AliITSCalibrationSDD* res=(AliITSCalibrationSDD*) GetCalibrationModel(GetITSgeom()->GetStartSDD()); 
390       seg = new AliITSsegmentationSDD(GetITSgeom(),res);
391       SetSegmentationModel(dettype,seg);
392       const char *kopt = ((AliITSresponseSDD*)res->GetResponse())->ZeroSuppOption();
393       if((!strstr(kopt,"2D"))&&(!strstr(kopt,"1D"))) SetDigitClassName(dettype,"AliITSdigit");
394       else SetDigitClassName(dettype,"AliITSdigitSDD");
395       SetClusterClassName(dettype,"AliITSRawClusterSDD");
396
397     }
398     if(dettype==2){
399       AliITSsegmentationSSD* seg2 = new AliITSsegmentationSSD(GetITSgeom());
400       seg2->SetAngles(0.0075,0.0275); // strip angels rad P and N side.
401       seg2->SetAnglesLay5(0.0075,0.0275); // strip angels rad P and N side.
402       seg2->SetAnglesLay6(0.0275,0.0075); // strip angels rad P and N side.
403       SetSegmentationModel(dettype,seg2);
404       SetDigitClassName(dettype,"AliITSdigitSSD");
405       SetClusterClassName(dettype,"AliITSRawClusterSSD");
406     }
407   }
408   
409 }
410 //______________________________________________________________________
411 Bool_t AliITSDetTypeRec::GetCalibration() {
412   // Get Default calibration if a storage is not defined.
413
414   if(!fFirstcall){
415     AliITSCalibration* cal = GetCalibrationModel(0);
416     if(cal)return kTRUE;
417   }
418   else {
419     fFirstcall = kFALSE;
420   }
421
422   SetRunNumber((Int_t)AliCDBManager::Instance()->GetRun());
423   Int_t run=GetRunNumber();
424
425   Bool_t origCacheStatus = AliCDBManager::Instance()->GetCacheFlag();
426   Bool_t isCacheActive = kTRUE;
427   if(GetRunNumber()<0)isCacheActive=kFALSE;
428   if (fCalibration==0) {
429     fCalibration = new TObjArray(GetITSgeom()->GetIndexMax());
430     fCalibration->SetOwner(isCacheActive);
431     fCalibration->Clear();
432   }
433
434   AliCDBManager::Instance()->SetCacheFlag(isCacheActive);
435
436   AliCDBEntry *entrySPD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSPD", run);
437   AliCDBEntry *entrySDD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSDD", run);
438   AliCDBEntry *entrySSD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSSD", run);
439   AliCDBEntry *entry2SPD = AliCDBManager::Instance()->Get("ITS/Calib/RespSPD", run);
440   AliCDBEntry *entry2SDD = AliCDBManager::Instance()->Get("ITS/Calib/RespSDD", run);
441   AliCDBEntry *entry2SSD = AliCDBManager::Instance()->Get("ITS/Calib/RespSSD", run);
442
443   if(!entrySPD || !entrySDD || !entrySSD || !entry2SPD || !entry2SDD || !entry2SSD){
444     AliFatal("Calibration object retrieval failed! ");
445     return kFALSE;
446   }     
447
448   TObjArray *calSPD = (TObjArray *)entrySPD->GetObject();
449   if(!isCacheActive)entrySPD->SetObject(NULL);
450   entrySPD->SetOwner(kTRUE);
451  
452   AliITSresponseSPD *pSPD = (AliITSresponseSPD*)entry2SPD->GetObject();
453   if(!isCacheActive)entry2SPD->SetObject(NULL);
454   entry2SPD->SetOwner(kTRUE);
455     
456   TObjArray *calSDD = (TObjArray *)entrySDD->GetObject();
457   if(!isCacheActive)entrySDD->SetObject(NULL);
458   entrySDD->SetOwner(kTRUE);
459  
460   AliITSresponseSDD *pSDD = (AliITSresponseSDD*)entry2SDD->GetObject();
461   if(!isCacheActive)entry2SDD->SetObject(NULL);
462   entry2SDD->SetOwner(kTRUE);
463
464   TObjArray *calSSD = (TObjArray *)entrySSD->GetObject();
465   if(!isCacheActive)entrySSD->SetObject(NULL);
466   entrySSD->SetOwner(kTRUE);
467
468   AliITSresponseSSD *pSSD = (AliITSresponseSSD*)entry2SSD->GetObject();
469   if(!isCacheActive)entry2SSD->SetObject(NULL);
470   entry2SSD->SetOwner(kTRUE);
471
472   // DB entries are deleted. In this way metadeta objects are deleted as well
473   if(!isCacheActive){
474     delete entrySPD;
475     delete entrySDD;
476     delete entrySSD;
477     delete entry2SPD;
478     delete entry2SDD;
479     delete entry2SSD;
480   }
481
482   AliCDBManager::Instance()->SetCacheFlag(origCacheStatus);
483   
484   if ((!pSPD)||(!pSDD)||(!pSSD) || (!calSPD) || (!calSDD) || (!calSSD)) {
485     AliWarning("Can not get calibration from calibration database !");
486     return kFALSE;
487   }
488
489   fNMod[0] = calSPD->GetEntries();
490   fNMod[1] = calSDD->GetEntries();
491   fNMod[2] = calSSD->GetEntries();
492   AliInfo(Form("%i SPD, %i SDD and %i SSD in calibration database",
493                fNMod[0], fNMod[1], fNMod[2]));
494   AliITSCalibration* cal;
495   for (Int_t i=0; i<fNMod[0]; i++) {
496     cal = (AliITSCalibration*) calSPD->At(i);
497     cal->SetResponse((AliITSresponse*)pSPD);
498     SetCalibrationModel(i, cal);
499  }
500   for (Int_t i=0; i<fNMod[1]; i++) {
501     cal = (AliITSCalibration*) calSDD->At(i);
502     cal->SetResponse((AliITSresponse*)pSDD);
503     Int_t iMod = i + fNMod[0];
504     SetCalibrationModel(iMod, cal);
505  }
506   for (Int_t i=0; i<fNMod[2]; i++) {
507     cal = (AliITSCalibration*) calSSD->At(i);
508     cal->SetResponse((AliITSresponse*)pSSD);
509     Int_t iMod = i + fNMod[0] + fNMod[1];
510     SetCalibrationModel(iMod, cal);
511  }
512
513   return kTRUE;
514 }
515
516
517 //________________________________________________________________
518 void AliITSDetTypeRec::SetDefaultClusterFinders(){
519   
520   //set defaults for standard cluster finder
521
522   if(!GetITSgeom()){
523     Warning("SetDefaults","null pointer to AliITSgeom!");
524     return;
525   }
526
527   AliITSClusterFinder *clf; 
528
529   MakeTreeC();
530  
531  for(Int_t dettype=0;dettype<fgkNdettypes;dettype++){
532     //SPD
533     if(dettype==0){
534       if(!GetReconstructionModel(dettype)){
535         TClonesArray *dig0 = DigitsAddress(0);
536         TClonesArray *rec0 = ClustersAddress(0);
537         clf = new AliITSClusterFinderSPD(this,dig0,rec0);
538         SetReconstructionModel(dettype,clf);
539
540       }
541     }
542    
543     //SDD
544     if(dettype==1){
545       if(!GetReconstructionModel(dettype)){
546         TClonesArray *dig1 = DigitsAddress(1);
547         TClonesArray *rec1 = ClustersAddress(1);
548         clf = new AliITSClusterFinderSDD(this,dig1,rec1);
549         SetReconstructionModel(dettype,clf);
550       }
551
552     }
553     //SSD
554     if(dettype==2){
555       if(!GetReconstructionModel(dettype)){
556         TClonesArray* dig2 = DigitsAddress(2);
557         clf = new AliITSClusterFinderSSD(this,dig2);
558         SetReconstructionModel(dettype,clf);
559       }
560     }
561
562  }
563  
564   
565 }
566
567 //________________________________________________________________
568 void AliITSDetTypeRec::SetDefaultClusterFindersV2(Bool_t rawdata){
569
570   //Set defaults for cluster finder V2
571
572   if(!GetITSgeom()){
573     Warning("SetDefaults","Null pointer to AliITSgeom !");
574     return;
575   }
576
577   AliITSClusterFinder *clf; 
578
579   MakeTreeC();
580   for(Int_t dettype=0;dettype<fgkNdettypes;dettype++){
581     //SPD
582     if(dettype==0){
583       if(!GetReconstructionModel(dettype)){
584         clf = new AliITSClusterFinderV2SPD(this);
585         clf->InitGeometry();
586         if(!rawdata) clf->SetDigits(DigitsAddress(0));
587         SetReconstructionModel(dettype,clf);
588
589       }
590     }
591     //SDD
592     if(dettype==1){
593       if(!GetReconstructionModel(dettype)){
594         clf = new AliITSClusterFinderV2SDD(this);
595         clf->InitGeometry();
596         if(!rawdata) clf->SetDigits(DigitsAddress(1));
597         SetReconstructionModel(dettype,clf);
598       }
599
600     }
601
602     //SSD
603     if(dettype==2){
604       if(!GetReconstructionModel(dettype)){
605         clf = new AliITSClusterFinderV2SSD(this);
606         clf->InitGeometry();
607         if(!rawdata) clf->SetDigits(DigitsAddress(2));
608         SetReconstructionModel(dettype,clf);
609       }
610     }
611
612  }
613    
614 }
615 //______________________________________________________________________
616 void AliITSDetTypeRec::MakeBranch(Option_t* option){
617
618   //Creates branches for clusters and recpoints
619   Bool_t cR = (strstr(option,"R")!=0);
620   Bool_t cRF = (strstr(option,"RF")!=0);
621   
622   if(cRF)cR = kFALSE;
623
624   if(cR) MakeBranchR(0);
625   if(cRF) MakeBranchRF(0);
626
627 }
628
629 //_____________________________________________________________
630 void AliITSDetTypeRec::MakeTreeC(){
631   
632   //Create a separate tree to store the clusters
633   if(!fLoader){
634     Warning("MakeTreeC","ITS loader is null!");
635     return;
636   }
637   if(fLoader->TreeC()== 0x0) fLoader->MakeTree("C");
638   MakeBranchC();
639 }
640
641 //______________________________________________________________
642 void AliITSDetTypeRec::MakeBranchC(){
643   
644   //Make branches in the tree of clusters
645
646   if(!fLoader){
647     Warning("MakeBranchC","ITS loader is null!");
648     return;
649   }
650   TTree* lTC = fLoader->TreeC();
651   if(lTC==0x0){
652     Error("MakeTreeC","Can not get TreeC from loader");
653     return;
654   }
655   
656   Int_t buffersize = 4000;
657   Char_t branchname[30];
658   Char_t* cluclass;
659   const char *det[4]={"SPD","SDD","SSD","ITS"};
660
661   for(Int_t i=0;i<fgkNdettypes;i++){
662     cluclass = GetClusterClassName(i);
663     if(fCtype==0x0)  fCtype = new TObjArray(fgkNdettypes);
664     if(!ClustersAddress(i)){
665       fCtype->AddAt(new TClonesArray(cluclass,1000),i);
666     }
667     if(fgkNdettypes==3) sprintf(branchname,"%sClusters%s",det[3],det[i]);
668     else sprintf(branchname,"%sClusters%d",det[3],i+1);
669     if(fCtype && lTC){
670       if(lTC->GetBranch(branchname)){
671         Warning("MakeBranchC","Branch %s already exists in TreeC",branchname);
672       } else{
673         Info("MakeBranchC","Creating branch %s in TreeC",branchname);
674         lTC->Branch(branchname,&((*fCtype)[i]),buffersize);
675       }
676     }
677
678   }
679   
680 }
681
682 //_______________________________________________________________
683 void AliITSDetTypeRec::GetTreeC(Int_t event){
684   
685   //Get the clusters tree for this event and
686   //sets the branch address
687
688
689   if(!fLoader){
690     Warning("GetTreeC","ITS loader is null!");
691     return;
692   }
693   
694   Char_t branchname[30];
695   const char *det[4] = {"SPD","SDD","SSD","ITS"};
696   TTree* lTC = fLoader->TreeC();
697   
698   ResetClusters();
699   if(lTC) fLoader->CleanRawClusters();
700
701   TBranch* branch;
702   if(lTC){
703     Char_t* cluclass;
704     for(Int_t i=0;i<fgkNdettypes;i++){
705       cluclass = GetClusterClassName(i);
706       if(fCtype==0x0) fCtype = new TObjArray(fgkNdettypes);
707       if(!fCtype->At(i)) fCtype->AddAt(new TClonesArray(cluclass,1000),i);
708       if(fgkNdettypes==3) sprintf(branchname,"%sClusters%s",det[3],det[i]);
709       else sprintf(branchname,"%sClusters%d",det[3],i+1);
710       if(fCtype){
711         branch = lTC->GetBranch(branchname);
712         if(branch) branch->SetAddress(&((*fCtype)[i]));
713       }
714     }
715   } else{
716     Error("GetTreeC","cannot find clusters Tree for vent %d",event);
717   }
718
719 }
720
721 //___________________________________________________________________
722 void AliITSDetTypeRec::AddCluster(Int_t id, AliITSRawCluster *c){
723
724   // Adds a raw cluster to the list
725   TClonesArray &lc = *((TClonesArray*)fCtype->At(id));  
726   switch(id){
727   case 0:
728     new(lc[fNctype[id]++]) AliITSRawClusterSPD(*((AliITSRawClusterSPD*)c));
729     break;
730   case 1:
731     new(lc[fNctype[id]++]) AliITSRawClusterSDD(*((AliITSRawClusterSDD*)c));
732     break;
733   case 2:
734     new(lc[fNctype[id]++]) AliITSRawClusterSSD(*((AliITSRawClusterSSD*)c));
735     break;
736   } 
737 }
738 //___________________________________________________________________
739 void AliITSDetTypeRec::ResetDigits(){
740   // Reset number of digits and the digits array for the ITS detector.
741   
742   if(!fDigits) return;
743   for(Int_t i=0;i<fgkNdettypes;i++){
744     ResetDigits(i);
745   }
746 }
747 //___________________________________________________________________
748 void AliITSDetTypeRec::ResetDigits(Int_t branch){
749   // Reset number of digits and the digits array for this branch.
750   
751   if(fDigits->At(branch)) ((TClonesArray*)fDigits->At(branch))->Clear();
752   if(fNdtype) fNdtype[branch]=0;
753
754 }
755
756 //__________________________________________________________________
757 void AliITSDetTypeRec::ResetClusters(){
758
759   //Resets number of clusters and the cluster array 
760   for(Int_t i=0;i<fgkNdettypes;i++){
761     ResetClusters(i);
762   }
763 }
764
765 //__________________________________________________________________
766 void AliITSDetTypeRec::ResetClusters(Int_t i){
767
768   //Resets number of clusters and the cluster array for this branch
769
770   if (fCtype->At(i))    ((TClonesArray*)fCtype->At(i))->Clear();
771   if (fNctype)  fNctype[i]=0;
772 }
773 //__________________________________________________________________
774 void AliITSDetTypeRec::MakeBranchR(const char *file, Option_t *opt){
775
776   //Creates tree branches for recpoints
777   // Inputs:
778   //      cont char *file  File name where RecPoints branch is to be written
779   //                       to. If blank it write the SDigits to the same
780   //                       file in which the Hits were found.
781
782   if(!fLoader){
783     Warning("MakeBranchR","ITS loader is null!");
784     return;
785   }
786
787   Int_t buffsz = 4000;
788   char branchname[30];
789
790   // only one branch for rec points for all detector types
791   Bool_t oFast= (strstr(opt,"Fast")!=0);
792   
793   Char_t detname[10] = "ITS";
794  
795   
796   if(oFast){
797     sprintf(branchname,"%sRecPointsF",detname);
798   } else {
799     sprintf(branchname,"%sRecPoints",detname);
800   }
801   
802   if(!fRecPoints)fRecPoints = new TClonesArray("AliITSRecPoint",1000);
803   if (fLoader->TreeR()) {
804     if(fRecPoints==0x0) fRecPoints = new TClonesArray("AliITSRecPoint",
805                                                       1000);
806     MakeBranchInTree(fLoader->TreeR(),branchname,0,&fRecPoints,buffsz,99,file);
807   } // end if
808
809   
810 }
811 //______________________________________________________________________
812 void AliITSDetTypeRec::SetTreeAddressR(TTree *treeR){
813     // Set branch address for the Reconstructed points Trees.
814     // Inputs:
815     //      TTree *treeR   Tree containing the RecPoints.
816     // Outputs:
817     //      none.
818     // Return:
819
820     char branchname[30];
821     Char_t namedet[10]="ITS";
822
823     if(!treeR) return;
824     if(fRecPoints==0x0) fRecPoints = new TClonesArray("AliITSRecPoint",1000);
825     TBranch *branch;
826     sprintf(branchname,"%sRecPoints",namedet);
827     branch = treeR->GetBranch(branchname);
828     if (branch) {
829       branch->SetAddress(&fRecPoints);
830     }else {
831       sprintf(branchname,"%sRecPointsF",namedet);
832       branch = treeR->GetBranch(branchname);
833       if (branch) {
834         branch->SetAddress(&fRecPoints);
835       }
836
837     }
838 }
839 //____________________________________________________________________
840 void AliITSDetTypeRec::AddRecPoint(const AliITSRecPoint &r){
841     // Add a reconstructed space point to the list
842     // Inputs:
843     //      const AliITSRecPoint &r RecPoint class to be added to the tree
844     //                              of reconstructed points TreeR.
845     // Outputs:
846     //      none.
847     // Return:
848     //      none.
849
850     TClonesArray &lrecp = *fRecPoints;
851     new(lrecp[fNRecPoints++]) AliITSRecPoint(r);
852 }
853
854 //______________________________________________________________________
855 void AliITSDetTypeRec::DigitsToRecPoints(Int_t evNumber,Int_t lastentry,Option_t *opt, Bool_t v2){
856   // cluster finding and reconstruction of space points
857   // the condition below will disappear when the geom class will be
858   // initialized for all versions - for the moment it is only for v5 !
859   // 7 is the SDD beam test version
860   // Inputs:
861   //      Int_t evNumber   Event number to be processed.
862   //      Int_t lastentry  Offset for module when not all of the modules
863   //                       are processed.
864   //      Option_t *opt    String indicating which ITS sub-detectors should
865   //                       be processed. If ="All" then all of the ITS
866   //                       sub detectors are processed.
867
868   if(!GetITSgeom()){
869     Warning("DigitsToRecPoints","Null pointer to AliITSgeom !");
870     return;
871   }
872   if(!fLoader){
873     Warning("DigitsToRecPoints","ITS loader is null!");
874     return;
875   }
876
877   const char *all = strstr(opt,"All");
878   const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),
879                         strstr(opt,"SSD")};
880   if(!v2) {
881     SetDefaultClusterFinders();
882     AliInfo("Original cluster finder has been selected\n");
883   }
884   else   { 
885     SetDefaultClusterFindersV2();
886     AliInfo("V2 cluster finder has been selected \n");
887   }
888
889   TTree *treeC=fLoader->TreeC();
890   if(!treeC){
891     MakeTreeC();
892   }
893   AliITSClusterFinder *rec     = 0;
894   Int_t id,module,first=0;
895   for(module=0;module<GetITSgeom()->GetIndexMax();module++){
896       id       = GetITSgeom()->GetModuleType(module);
897       if (!all && !det[id]) continue;
898       if(det[id]) first = GetITSgeom()->GetStartDet(id);
899       rec = (AliITSClusterFinder*)GetReconstructionModel(id);
900       TClonesArray *itsDigits  = DigitsAddress(id);
901       if (!rec) {
902           Error("DigitsToRecPoints",
903                 "The reconstruction class was not instanciated! event=%d",
904                 evNumber);
905           exit(1);
906       } 
907       ResetDigits();  // MvL: Not sure we neeed this when rereading anyways
908       TTree *lTD = fLoader->TreeD();
909       if (all) {
910           lTD->GetEvent(lastentry+module);
911       }else {
912           lTD->GetEvent(lastentry+(module-first));
913       }
914       Int_t ndigits = itsDigits->GetEntriesFast();
915       if(ndigits>0){
916         rec->SetDetTypeRec(this);
917         rec->SetDigits(DigitsAddress(id));
918         rec->SetClusters(ClustersAddress(id));
919         rec->FindRawClusters(module);
920       } // end if
921       fLoader->TreeR()->Fill();
922       ResetRecPoints();
923       treeC->Fill();
924       ResetClusters();
925   } 
926       
927   fLoader->WriteRecPoints("OVERWRITE");
928   fLoader->WriteRawClusters("OVERWRITE");
929   fLoader->CleanRawClusters();
930 }
931 //______________________________________________________________________
932 void AliITSDetTypeRec::DigitsToRecPoints(AliRawReader* rawReader){
933   // cluster finding and reconstruction of space points
934   // the condition below will disappear when the geom class will be
935   // initialized for all versions - for the moment it is only for v5 !
936   // 7 is the SDD beam test version
937   // Inputs:
938   //      Int_t evNumber   Event number to be processed.
939   //      Int_t lastentry  Offset for module when not all of the modules
940   //                       are processed.
941   //      Option_t *opt    String indicating which ITS sub-detectors should
942   //                       be processed. If ="All" then all of the ITS
943   //                       sub detectors are processed.
944   // Outputs:
945   //      none.
946   // Return:
947   //      none.
948   if(!GetITSgeom()){
949     Warning("DigitsToRecPoints","Null pointer to AliITSgeom !");
950     return;
951   }
952   if(!fLoader){
953     Warning("DigitsToRecPoints","ITS loader is null!");
954     return;
955   }
956
957   
958   AliITSClusterFinderV2 *rec     = 0;
959   Int_t id=0;
960
961   if(!fLoader->TreeR()) fLoader->MakeTree("R");
962   TTree* cTree = fLoader->TreeR();
963   TClonesArray *array=new TClonesArray("AliITSRecPoint",1000);
964   cTree->Branch("ITSRecPoints",&array);
965   delete array;
966  
967   TClonesArray** clusters = new TClonesArray*[GetITSgeom()->GetIndexMax()]; 
968   for (Int_t iModule = 0; iModule < GetITSgeom()->GetIndexMax(); iModule++) {
969     clusters[iModule] = NULL;
970   }
971   for(id=0;id<3;id++){
972     rec = (AliITSClusterFinderV2*)GetReconstructionModel(id);
973     rec->SetDetTypeRec(this);
974     if (!rec)
975       AliFatal("The reconstruction class was not instanciated");
976
977     rec->RawdataToClusters(rawReader,clusters);    
978   } 
979   Int_t nClusters =0;
980   TClonesArray *emptyArray=new TClonesArray("AliITSRecPoint");
981   for(Int_t iModule=0;iModule<GetITSgeom()->GetIndexMax();iModule++){
982     array = clusters[iModule];
983     if(!array){
984       AliDebug(1,Form("data for module %d missing!",iModule));
985       array = emptyArray;
986     }
987     cTree->SetBranchAddress("ITSRecPoints",&array);
988     cTree->Fill();
989     nClusters+=array->GetEntriesFast();
990
991     if (array != emptyArray) {
992       array->Delete();
993       delete array;
994     }
995   }
996   delete emptyArray;
997
998   fLoader->WriteRecPoints("OVERWRITE");
999
1000   delete[] clusters;
1001   Info("DigitsToRecPoints", "total number of found recpoints in ITS: %d\n", 
1002        nClusters);
1003   
1004 }
1005
1006