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