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   if(run<0)run=0;   // if the run number is not yet set, use fake run # 0
 425
 426   Bool_t origCacheStatus = AliCDBManager::Instance()->GetCacheFlag();
 427   Bool_t isCacheActive = kTRUE;
 428   if(GetRunNumber()<0)isCacheActive=kFALSE;
 429   if (fCalibration==0) {
 430     fCalibration = new TObjArray(GetITSgeom()->GetIndexMax());
 431     fCalibration->SetOwner(isCacheActive);
 432     fCalibration->Clear();
 433   }
 434
 435   AliCDBManager::Instance()->SetCacheFlag(isCacheActive);
 436
 437   AliCDBEntry *entrySPD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSPD", run);
 438   AliCDBEntry *entrySDD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSDD", run);
 439   AliCDBEntry *entrySSD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSSD", run);
 440   AliCDBEntry *entry2SPD = AliCDBManager::Instance()->Get("ITS/Calib/RespSPD", run);
 441   AliCDBEntry *entry2SDD = AliCDBManager::Instance()->Get("ITS/Calib/RespSDD", run);
 442   AliCDBEntry *entry2SSD = AliCDBManager::Instance()->Get("ITS/Calib/RespSSD", run);
 443
 444   if(!entrySPD || !entrySDD || !entrySSD || !entry2SPD || !entry2SDD || !entry2SSD){
 445     AliFatal("Calibration object retrieval failed! ");
 446     return kFALSE;
 447   }
 448
 449   TObjArray *calSPD = (TObjArray *)entrySPD->GetObject();
 450   if(!isCacheActive)entrySPD->SetObject(NULL);
 451   entrySPD->SetOwner(kTRUE);
 452
 453   AliITSresponseSPD *pSPD = (AliITSresponseSPD*)entry2SPD->GetObject();
 454   if(!isCacheActive)entry2SPD->SetObject(NULL);
 455   entry2SPD->SetOwner(kTRUE);
 456
 457   TObjArray *calSDD = (TObjArray *)entrySDD->GetObject();
 458   if(!isCacheActive)entrySDD->SetObject(NULL);
 459   entrySDD->SetOwner(kTRUE);
 460
 461   AliITSresponseSDD *pSDD = (AliITSresponseSDD*)entry2SDD->GetObject();
 462   if(!isCacheActive)entry2SDD->SetObject(NULL);
 463   entry2SDD->SetOwner(kTRUE);
 464
 465   TObjArray *calSSD = (TObjArray *)entrySSD->GetObject();
 466   if(!isCacheActive)entrySSD->SetObject(NULL);
 467   entrySSD->SetOwner(kTRUE);
 468
 469   AliITSresponseSSD *pSSD = (AliITSresponseSSD*)entry2SSD->GetObject();
 470   if(!isCacheActive)entry2SSD->SetObject(NULL);
 471   entry2SSD->SetOwner(kTRUE);
 472
 473   // DB entries are deleted. In this way metadeta objects are deleted as well
 474   if(!isCacheActive){
 475     delete entrySPD;
 476     delete entrySDD;
 477     delete entrySSD;
 478     delete entry2SPD;
 479     delete entry2SDD;
 480     delete entry2SSD;
 481   }
 482
 483   AliCDBManager::Instance()->SetCacheFlag(origCacheStatus);
 484
 485   if ((!pSPD)||(!pSDD)||(!pSSD) || (!calSPD) || (!calSDD) || (!calSSD)) {
 486     AliWarning("Can not get calibration from calibration database !");
 487     return kFALSE;
 488   }
 489
 490   fNMod[0] = calSPD->GetEntries();
 491   fNMod[1] = calSDD->GetEntries();
 492   fNMod[2] = calSSD->GetEntries();
 493   AliInfo(Form("%i SPD, %i SDD and %i SSD in calibration database",
 494                fNMod[0], fNMod[1], fNMod[2]));
 495   AliITSCalibration* cal;
 496   for (Int_t i=0; i<fNMod[0]; i++) {
 497     cal = (AliITSCalibration*) calSPD->At(i);
 498     cal->SetResponse((AliITSresponse*)pSPD);
 499     SetCalibrationModel(i, cal);
 500  }
 501   for (Int_t i=0; i<fNMod[1]; i++) {
 502     cal = (AliITSCalibration*) calSDD->At(i);
 503     cal->SetResponse((AliITSresponse*)pSDD);
 504     Int_t iMod = i + fNMod[0];
 505     SetCalibrationModel(iMod, cal);
 506  }
 507   for (Int_t i=0; i<fNMod[2]; i++) {
 508     cal = (AliITSCalibration*) calSSD->At(i);
 509     cal->SetResponse((AliITSresponse*)pSSD);
 510     Int_t iMod = i + fNMod[0] + fNMod[1];
 511     SetCalibrationModel(iMod, cal);
 512  }
 513
 514   return kTRUE;
 515 }
 516
 517
 518 //________________________________________________________________
 519 void AliITSDetTypeRec::SetDefaultClusterFinders(){
 520
 521   //set defaults for standard cluster finder
 522
 523   if(!GetITSgeom()){
 524     Warning("SetDefaults","null pointer to AliITSgeom!");
 525     return;
 526   }
 527
 528   AliITSClusterFinder *clf;
 529
 530   MakeTreeC();
 531
 532  for(Int_t dettype=0;dettype<fgkNdettypes;dettype++){
 533     //SPD
 534     if(dettype==0){
 535       if(!GetReconstructionModel(dettype)){
 536         TClonesArray *dig0 = DigitsAddress(0);
 537         TClonesArray *rec0 = ClustersAddress(0);
 538         clf = new AliITSClusterFinderSPD(this,dig0,rec0);
 539         SetReconstructionModel(dettype,clf);
 540
 541       }
 542     }
 543
 544     //SDD
 545     if(dettype==1){
 546       if(!GetReconstructionModel(dettype)){
 547         TClonesArray *dig1 = DigitsAddress(1);
 548         TClonesArray *rec1 = ClustersAddress(1);
 549         clf = new AliITSClusterFinderSDD(this,dig1,rec1);
 550         SetReconstructionModel(dettype,clf);
 551       }
 552
 553     }
 554     //SSD
 555     if(dettype==2){
 556       if(!GetReconstructionModel(dettype)){
 557         TClonesArray* dig2 = DigitsAddress(2);
 558         clf = new AliITSClusterFinderSSD(this,dig2);
 559         SetReconstructionModel(dettype,clf);
 560       }
 561     }
 562
 563  }
 564
 565
 566 }
 567
 568 //________________________________________________________________
 569 void AliITSDetTypeRec::SetDefaultClusterFindersV2(Bool_t rawdata){
 570
 571   //Set defaults for cluster finder V2
 572
 573   if(!GetITSgeom()){
 574     Warning("SetDefaults","Null pointer to AliITSgeom !");
 575     return;
 576   }
 577
 578   AliITSClusterFinder *clf;
 579
 580   MakeTreeC();
 581   for(Int_t dettype=0;dettype<fgkNdettypes;dettype++){
 582     //SPD
 583     if(dettype==0){
 584       if(!GetReconstructionModel(dettype)){
 585         clf = new AliITSClusterFinderV2SPD(this);
 586         clf->InitGeometry();
 587         if(!rawdata) clf->SetDigits(DigitsAddress(0));
 588         SetReconstructionModel(dettype,clf);
 589
 590       }
 591     }
 592     //SDD
 593     if(dettype==1){
 594       if(!GetReconstructionModel(dettype)){
 595         clf = new AliITSClusterFinderV2SDD(this);
 596         clf->InitGeometry();
 597         if(!rawdata) clf->SetDigits(DigitsAddress(1));
 598         SetReconstructionModel(dettype,clf);
 599       }
 600
 601     }
 602
 603     //SSD
 604     if(dettype==2){
 605       if(!GetReconstructionModel(dettype)){
 606         clf = new AliITSClusterFinderV2SSD(this);
 607         clf->InitGeometry();
 608         if(!rawdata) clf->SetDigits(DigitsAddress(2));
 609         SetReconstructionModel(dettype,clf);
 610       }
 611     }
 612
 613  }
 614
 615 }
 616 //______________________________________________________________________
 617 void AliITSDetTypeRec::MakeBranch(Option_t* option){
 618
 619   //Creates branches for clusters and recpoints
 620   Bool_t cR = (strstr(option,"R")!=0);
 621   Bool_t cRF = (strstr(option,"RF")!=0);
 622
 623   if(cRF)cR = kFALSE;
 624
 625   if(cR) MakeBranchR(0);
 626   if(cRF) MakeBranchRF(0);
 627
 628 }
 629
 630 //_____________________________________________________________
 631 void AliITSDetTypeRec::MakeTreeC(){
 632
 633   //Create a separate tree to store the clusters
 634   if(!fLoader){
 635     Warning("MakeTreeC","ITS loader is null!");
 636     return;
 637   }
 638   if(fLoader->TreeC()== 0x0) fLoader->MakeTree("C");
 639   MakeBranchC();
 640 }
 641
 642 //______________________________________________________________
 643 void AliITSDetTypeRec::MakeBranchC(){
 644
 645   //Make branches in the tree of clusters
 646
 647   if(!fLoader){
 648     Warning("MakeBranchC","ITS loader is null!");
 649     return;
 650   }
 651   TTree* lTC = fLoader->TreeC();
 652   if(lTC==0x0){
 653     Error("MakeTreeC","Can not get TreeC from loader");
 654     return;
 655   }
 656
 657   Int_t buffersize = 4000;
 658   Char_t branchname[30];
 659   Char_t* cluclass;
 660   const char *det[4]={"SPD","SDD","SSD","ITS"};
 661
 662   for(Int_t i=0;i<fgkNdettypes;i++){
 663     cluclass = GetClusterClassName(i);
 664     if(fCtype==0x0)  fCtype = new TObjArray(fgkNdettypes);
 665     if(!ClustersAddress(i)){
 666       fCtype->AddAt(new TClonesArray(cluclass,1000),i);
 667     }
 668     if(fgkNdettypes==3) sprintf(branchname,"%sClusters%s",det[3],det[i]);
 669     else sprintf(branchname,"%sClusters%d",det[3],i+1);
 670     if(fCtype && lTC){
 671       if(lTC->GetBranch(branchname)){
 672         Warning("MakeBranchC","Branch %s already exists in TreeC",branchname);
 673       } else{
 674         Info("MakeBranchC","Creating branch %s in TreeC",branchname);
 675         lTC->Branch(branchname,&((*fCtype)[i]),buffersize);
 676       }
 677     }
 678
 679   }
 680
 681 }
 682
 683 //_______________________________________________________________
 684 void AliITSDetTypeRec::GetTreeC(Int_t event){
 685
 686   //Get the clusters tree for this event and
 687   //sets the branch address
 688
 689
 690   if(!fLoader){
 691     Warning("GetTreeC","ITS loader is null!");
 692     return;
 693   }
 694
 695   Char_t branchname[30];
 696   const char *det[4] = {"SPD","SDD","SSD","ITS"};
 697   TTree* lTC = fLoader->TreeC();
 698
 699   ResetClusters();
 700   if(lTC) fLoader->CleanRawClusters();
 701
 702   TBranch* branch;
 703   if(lTC){
 704     Char_t* cluclass;
 705     for(Int_t i=0;i<fgkNdettypes;i++){
 706       cluclass = GetClusterClassName(i);
 707       if(fCtype==0x0) fCtype = new TObjArray(fgkNdettypes);
 708       if(!fCtype->At(i)) fCtype->AddAt(new TClonesArray(cluclass,1000),i);
 709       if(fgkNdettypes==3) sprintf(branchname,"%sClusters%s",det[3],det[i]);
 710       else sprintf(branchname,"%sClusters%d",det[3],i+1);
 711       if(fCtype){
 712         branch = lTC->GetBranch(branchname);
 713         if(branch) branch->SetAddress(&((*fCtype)[i]));
 714       }
 715     }
 716   } else{
 717     Error("GetTreeC","cannot find clusters Tree for vent %d",event);
 718   }
 719
 720 }
 721
 722 //___________________________________________________________________
 723 void AliITSDetTypeRec::AddCluster(Int_t id, AliITSRawCluster *c){
 724
 725   // Adds a raw cluster to the list
 726   TClonesArray &lc = *((TClonesArray*)fCtype->At(id));
 727   switch(id){
 728   case 0:
 729     new(lc[fNctype[id]++]) AliITSRawClusterSPD(*((AliITSRawClusterSPD*)c));
 730     break;
 731   case 1:
 732     new(lc[fNctype[id]++]) AliITSRawClusterSDD(*((AliITSRawClusterSDD*)c));
 733     break;
 734   case 2:
 735     new(lc[fNctype[id]++]) AliITSRawClusterSSD(*((AliITSRawClusterSSD*)c));
 736     break;
 737   }
 738 }
 739 //___________________________________________________________________
 740 void AliITSDetTypeRec::ResetDigits(){
 741   // Reset number of digits and the digits array for the ITS detector.
 742
 743   if(!fDigits) return;
 744   for(Int_t i=0;i<fgkNdettypes;i++){
 745     ResetDigits(i);
 746   }
 747 }
 748 //___________________________________________________________________
 749 void AliITSDetTypeRec::ResetDigits(Int_t branch){
 750   // Reset number of digits and the digits array for this branch.
 751
 752   if(fDigits->At(branch)) ((TClonesArray*)fDigits->At(branch))->Clear();
 753   if(fNdtype) fNdtype[branch]=0;
 754
 755 }
 756
 757 //__________________________________________________________________
 758 void AliITSDetTypeRec::ResetClusters(){
 759
 760   //Resets number of clusters and the cluster array
 761   for(Int_t i=0;i<fgkNdettypes;i++){
 762     ResetClusters(i);
 763   }
 764 }
 765
 766 //__________________________________________________________________
 767 void AliITSDetTypeRec::ResetClusters(Int_t i){
 768
 769   //Resets number of clusters and the cluster array for this branch
 770
 771   if (fCtype->At(i))    ((TClonesArray*)fCtype->At(i))->Clear();
 772   if (fNctype)  fNctype[i]=0;
 773 }
 774 //__________________________________________________________________
 775 void AliITSDetTypeRec::MakeBranchR(const char *file, Option_t *opt){
 776
 777   //Creates tree branches for recpoints
 778   // Inputs:
 779   //      cont char *file  File name where RecPoints branch is to be written
 780   //                       to. If blank it write the SDigits to the same
 781   //                       file in which the Hits were found.
 782
 783   if(!fLoader){
 784     Warning("MakeBranchR","ITS loader is null!");
 785     return;
 786   }
 787
 788   Int_t buffsz = 4000;
 789   char branchname[30];
 790
 791   // only one branch for rec points for all detector types
 792   Bool_t oFast= (strstr(opt,"Fast")!=0);
 793
 794   Char_t detname[10] = "ITS";
 795
 796
 797   if(oFast){
 798     sprintf(branchname,"%sRecPointsF",detname);
 799   } else {
 800     sprintf(branchname,"%sRecPoints",detname);
 801   }
 802
 803   if(!fRecPoints)fRecPoints = new TClonesArray("AliITSRecPoint",1000);
 804   if (fLoader->TreeR()) {
 805     if(fRecPoints==0x0) fRecPoints = new TClonesArray("AliITSRecPoint",
 806                                                       1000);
 807     MakeBranchInTree(fLoader->TreeR(),branchname,0,&fRecPoints,buffsz,99,file);
 808   } // end if
 809
 810
 811 }
 812 //______________________________________________________________________
 813 void AliITSDetTypeRec::SetTreeAddressR(TTree *treeR){
 814     // Set branch address for the Reconstructed points Trees.
 815     // Inputs:
 816     //      TTree *treeR   Tree containing the RecPoints.
 817     // Outputs:
 818     //      none.
 819     // Return:
 820
 821     char branchname[30];
 822     Char_t namedet[10]="ITS";
 823
 824     if(!treeR) return;
 825     if(fRecPoints==0x0) fRecPoints = new TClonesArray("AliITSRecPoint",1000);
 826     TBranch *branch;
 827     sprintf(branchname,"%sRecPoints",namedet);
 828     branch = treeR->GetBranch(branchname);
 829     if (branch) {
 830       branch->SetAddress(&fRecPoints);
 831     }else {
 832       sprintf(branchname,"%sRecPointsF",namedet);
 833       branch = treeR->GetBranch(branchname);
 834       if (branch) {
 835         branch->SetAddress(&fRecPoints);
 836       }
 837
 838     }
 839 }
 840 //____________________________________________________________________
 841 void AliITSDetTypeRec::AddRecPoint(const AliITSRecPoint &r){
 842     // Add a reconstructed space point to the list
 843     // Inputs:
 844     //      const AliITSRecPoint &r RecPoint class to be added to the tree
 845     //                              of reconstructed points TreeR.
 846     // Outputs:
 847     //      none.
 848     // Return:
 849     //      none.
 850
 851     TClonesArray &lrecp = *fRecPoints;
 852     new(lrecp[fNRecPoints++]) AliITSRecPoint(r);
 853 }
 854
 855 //______________________________________________________________________
 856 void AliITSDetTypeRec::DigitsToRecPoints(Int_t evNumber,Int_t lastentry,Option_t *opt, Bool_t v2){
 857   // cluster finding and reconstruction of space points
 858   // the condition below will disappear when the geom class will be
 859   // initialized for all versions - for the moment it is only for v5 !
 860   // 7 is the SDD beam test version
 861   // Inputs:
 862   //      Int_t evNumber   Event number to be processed.
 863   //      Int_t lastentry  Offset for module when not all of the modules
 864   //                       are processed.
 865   //      Option_t *opt    String indicating which ITS sub-detectors should
 866   //                       be processed. If ="All" then all of the ITS
 867   //                       sub detectors are processed.
 868
 869   if(!GetITSgeom()){
 870     Warning("DigitsToRecPoints","Null pointer to AliITSgeom !");
 871     return;
 872   }
 873   if(!fLoader){
 874     Warning("DigitsToRecPoints","ITS loader is null!");
 875     return;
 876   }
 877
 878   const char *all = strstr(opt,"All");
 879   const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),
 880                         strstr(opt,"SSD")};
 881   if(!v2) {
 882     SetDefaultClusterFinders();
 883     AliInfo("Original cluster finder has been selected\n");
 884   }
 885   else   {
 886     SetDefaultClusterFindersV2();
 887     AliInfo("V2 cluster finder has been selected \n");
 888   }
 889
 890   TTree *treeC=fLoader->TreeC();
 891   if(!treeC){
 892     MakeTreeC();
 893     MakeBranchC();
 894   }
 895   AliITSClusterFinder *rec     = 0;
 896   Int_t id,module,first=0;
 897   for(module=0;module<GetITSgeom()->GetIndexMax();module++){
 898       id       = GetITSgeom()->GetModuleType(module);
 899       if (!all && !det[id]) continue;
 900       if(det[id]) first = GetITSgeom()->GetStartDet(id);
 901       rec = (AliITSClusterFinder*)GetReconstructionModel(id);
 902       TClonesArray *itsDigits  = DigitsAddress(id);
 903       if (!rec) {
 904           Error("DigitsToRecPoints",
 905                 "The reconstruction class was not instanciated! event=%d",
 906                 evNumber);
 907           exit(1);
 908       }
 909       ResetDigits();
 910       TTree *lTD = fLoader->TreeD();
 911       if (all) {
 912           lTD->GetEvent(lastentry+module);
 913       }else {
 914           lTD->GetEvent(lastentry+(module-first));
 915       }
 916       Int_t ndigits = itsDigits->GetEntriesFast();
 917       if(ndigits>0){
 918         rec->SetDetTypeRec(this);
 919         rec->SetDigits(DigitsAddress(id));
 920         rec->SetClusters(ClustersAddress(id));
 921         rec->FindRawClusters(module);
 922       } // end if
 923       fLoader->TreeR()->Fill();
 924       ResetRecPoints();
 925       treeC->Fill();
 926       ResetClusters();
 927   }
 928
 929   fLoader->WriteRecPoints("OVERWRITE");
 930   fLoader->WriteRawClusters("OVERWRITE");
 931 }
 932 //______________________________________________________________________
 933 void AliITSDetTypeRec::DigitsToRecPoints(AliRawReader* rawReader){
 934   // cluster finding and reconstruction of space points
 935   // the condition below will disappear when the geom class will be
 936   // initialized for all versions - for the moment it is only for v5 !
 937   // 7 is the SDD beam test version
 938   // Inputs:
 939   //      Int_t evNumber   Event number to be processed.
 940   //      Int_t lastentry  Offset for module when not all of the modules
 941   //                       are processed.
 942   //      Option_t *opt    String indicating which ITS sub-detectors should
 943   //                       be processed. If ="All" then all of the ITS
 944   //                       sub detectors are processed.
 945   // Outputs:
 946   //      none.
 947   // Return:
 948   //      none.
 949   if(!GetITSgeom()){
 950     Warning("DigitsToRecPoints","Null pointer to AliITSgeom !");
 951     return;
 952   }
 953   if(!fLoader){
 954     Warning("DigitsToRecPoints","ITS loader is null!");
 955     return;
 956   }
 957
 958
 959   AliITSClusterFinderV2 *rec     = 0;
 960   Int_t id=0;
 961
 962   if(!fLoader->TreeR()) fLoader->MakeTree("R");
 963   TTree* cTree = fLoader->TreeR();
 964   TClonesArray *array=new TClonesArray("AliITSRecPoint",1000);
 965   cTree->Branch("ITSRecPoints",&array);
 966   delete array;
 967
 968   TClonesArray** clusters = new TClonesArray*[GetITSgeom()->GetIndexMax()];
 969   for (Int_t iModule = 0; iModule < GetITSgeom()->GetIndexMax(); iModule++) {
 970     clusters[iModule] = NULL;
 971   }
 972   for(id=0;id<3;id++){
 973     rec = (AliITSClusterFinderV2*)GetReconstructionModel(id);
 974     rec->SetDetTypeRec(this);
 975     if (!rec) {
 976       Error("DigitsToRecPoints",
 977             "The reconstruction class was not instanciated");
 978       exit(1);
 979     }
 980     rec->RawdataToClusters(rawReader,clusters);
 981   }
 982   Int_t nClusters =0;
 983   for(Int_t iModule=0;iModule<GetITSgeom()->GetIndexMax();iModule++){
 984     array = clusters[iModule];
 985     if(!array){
 986       Error("DigitsToRecPoints","data for module %d missing!",iModule);
 987       array = new TClonesArray("AliITSRecPoint");
 988     }
 989     cTree->SetBranchAddress("ITSRecPoints",&array);
 990     cTree->Fill();
 991     nClusters+=array->GetEntriesFast();
 992     delete array;
 993   }
 994   fLoader->WriteRecPoints("OVERWRITE");
 995
 996   delete[] clusters;
 997   Info("DigitsToRecPoints", "total number of found recpoints in ITS: %d\n",
 998        nClusters);
 999
1000 }
1001
1002