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;
 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     MakeBranchC();
 893   }
 894   AliITSClusterFinder *rec     = 0;
 895   Int_t id,module,first=0;
 896   for(module=0;module<GetITSgeom()->GetIndexMax();module++){
 897       id       = GetITSgeom()->GetModuleType(module);
 898       if (!all && !det[id]) continue;
 899       if(det[id]) first = GetITSgeom()->GetStartDet(id);
 900       rec = (AliITSClusterFinder*)GetReconstructionModel(id);
 901       TClonesArray *itsDigits  = DigitsAddress(id);
 902       if (!rec) {
 903           Error("DigitsToRecPoints",
 904                 "The reconstruction class was not instanciated! event=%d",
 905                 evNumber);
 906           exit(1);
 907       }
 908       ResetDigits();
 909       TTree *lTD = fLoader->TreeD();
 910       if (all) {
 911           lTD->GetEvent(lastentry+module);
 912       }else {
 913           lTD->GetEvent(lastentry+(module-first));
 914       }
 915       Int_t ndigits = itsDigits->GetEntriesFast();
 916       if(ndigits>0){
 917         rec->SetDetTypeRec(this);
 918         rec->SetDigits(DigitsAddress(id));
 919         rec->SetClusters(ClustersAddress(id));
 920         rec->FindRawClusters(module);
 921       } // end if
 922       fLoader->TreeR()->Fill();
 923       ResetRecPoints();
 924       treeC->Fill();
 925       ResetClusters();
 926   }
 927
 928   fLoader->WriteRecPoints("OVERWRITE");
 929   fLoader->WriteRawClusters("OVERWRITE");
 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   delete emptyArray;
 992
 993   fLoader->WriteRecPoints("OVERWRITE");
 994
 995   delete[] clusters;
 996   Info("DigitsToRecPoints", "total number of found recpoints in ITS: %d\n",
 997        nClusters);
 998
 999 }
1000
1001