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