add getter to cut on n cells
[u/mrichter/AliRoot.git] / ITS / AliITSDetTypeRec.cxx
CommitLineData
3b9df642 1/***************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
b17dae48 5 * Conributors are mentioned in the code where appropriate. *
3b9df642 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/*
140e5249 17 $Id$
3b9df642 18*/
19
7d62fb64 20////////////////////////////////////////////////////////////////////////
21// This class defines the "Standard" reconstruction for the ITS //
22// detector. //
23// //
24////////////////////////////////////////////////////////////////////////
25#include "TObjArray.h"
26#include "TTree.h"
27
8ba39da9 28#include "AliCDBManager.h"
8ba39da9 29#include "AliCDBEntry.h"
7d62fb64 30#include "AliITSClusterFinder.h"
7d62fb64 31#include "AliITSClusterFinderV2SPD.h"
32#include "AliITSClusterFinderV2SDD.h"
33#include "AliITSClusterFinderV2SSD.h"
3b9df642 34#include "AliITSDetTypeRec.h"
ef665f5e 35#include "AliITSDDLModuleMapSDD.h"
7d62fb64 36#include "AliITSRecPoint.h"
e5c65a6d 37#include "AliITSRecPointContainer.h"
fcf95fc7 38#include "AliITSCalibrationSDD.h"
54af1add 39#include "AliITSMapSDD.h"
fb4dfab9 40#include "AliITSCalibrationSSD.h"
88128115 41#include "AliITSNoiseSSDv2.h"
42#include "AliITSGainSSDv2.h"
43#include "AliITSBadChannelsSSDv2.h"
fb4dfab9 44#include "AliITSNoiseSSD.h"
45#include "AliITSGainSSD.h"
46#include "AliITSBadChannelsSSD.h"
dc5c67dc 47#include "AliITSresponseSDD.h"
7d62fb64 48#include "AliITSsegmentationSPD.h"
49#include "AliITSsegmentationSDD.h"
50#include "AliITSsegmentationSSD.h"
00a7cc50 51#include "AliLog.h"
ad7f2bfa 52#include "AliITSRawStreamSPD.h"
53#include "AliITSTriggerConditions.h"
54#include "AliITSFOSignalsSPD.h"
55#include "AliRunLoader.h"
56#include "AliDataLoader.h"
57#include "AliITSLoader.h"
7d62fb64 58
ef665f5e 59class AliITSDriftSpeedArraySDD;
54af1add 60class AliITSCorrMapSDD;
ef665f5e 61class AliITSRecoParam;
3b9df642 62
7d62fb64 63const Int_t AliITSDetTypeRec::fgkNdettypes = 3;
8ba39da9 64const Int_t AliITSDetTypeRec::fgkDefaultNModulesSPD = 240;
65const Int_t AliITSDetTypeRec::fgkDefaultNModulesSDD = 260;
66const Int_t AliITSDetTypeRec::fgkDefaultNModulesSSD = 1698;
67
3b9df642 68ClassImp(AliITSDetTypeRec)
69
7d62fb64 70//________________________________________________________________
e56160b8 71AliITSDetTypeRec::AliITSDetTypeRec(): TObject(),
72fNMod(0),
6cae184e 73fITSgeom(0),
e56160b8 74fReconstruction(0),
75fSegmentation(0),
76fCalibration(0),
ced4d9bc 77fSSDCalibration(0),
23197852 78fSPDDead(0),
9806b6f8 79fSPDSparseDead(0),
ad7f2bfa 80fTriggerConditions(0),
e56160b8 81fDigits(0),
ad7f2bfa 82fFOSignals(0),
979b5a5f 83fDDLMapSDD(0),
253e68a0 84fRespSDD(0),
75065a60 85fAveGainSDD(0),
e56160b8 86fRecPoints(0),
87fNRecPoints(0),
62b93da7 88fFirstcall(kTRUE),
ff44c37c 89fLoadOnlySPDCalib(0),
90fFastOrFiredMap(1200){
8e50d897 91 // Standard Constructor
92 // Inputs:
93 // none.
94 // Outputs:
95 // none.
96 // Return:
97 //
7d62fb64 98
7d62fb64 99 fReconstruction = new TObjArray(fgkNdettypes);
7d62fb64 100 fDigits = new TObjArray(fgkNdettypes);
8e50d897 101 for(Int_t i=0; i<3; i++){
ef665f5e 102 fkDigClassName[i]=0;
8e50d897 103 }
ced4d9bc 104 fSSDCalibration=new AliITSCalibrationSSD();
8e50d897 105 fNMod = new Int_t [fgkNdettypes];
106 fNMod[0] = fgkDefaultNModulesSPD;
107 fNMod[1] = fgkDefaultNModulesSDD;
108 fNMod[2] = fgkDefaultNModulesSSD;
7d62fb64 109 fNRecPoints = 0;
7d62fb64 110
7d62fb64 111
7d62fb64 112}
7537d03c 113
7d62fb64 114//______________________________________________________________________
7537d03c 115AliITSDetTypeRec::AliITSDetTypeRec(const AliITSDetTypeRec & rec):TObject(rec),
116fNMod(rec.fNMod),
6cae184e 117fITSgeom(rec.fITSgeom),
7537d03c 118fReconstruction(rec.fReconstruction),
119fSegmentation(rec.fSegmentation),
120fCalibration(rec.fCalibration),
ced4d9bc 121fSSDCalibration(rec.fSSDCalibration),
23197852 122fSPDDead(rec.fSPDDead),
9806b6f8 123fSPDSparseDead(rec.fSPDSparseDead),
ad7f2bfa 124fTriggerConditions(rec.fTriggerConditions),
7537d03c 125fDigits(rec.fDigits),
ad7f2bfa 126fFOSignals(rec.fFOSignals),
979b5a5f 127fDDLMapSDD(rec.fDDLMapSDD),
253e68a0 128fRespSDD(rec.fRespSDD),
75065a60 129fAveGainSDD(rec.fAveGainSDD),
7537d03c 130fRecPoints(rec.fRecPoints),
131fNRecPoints(rec.fNRecPoints),
62b93da7 132fFirstcall(rec.fFirstcall),
ff44c37c 133fLoadOnlySPDCalib(rec.fLoadOnlySPDCalib),
134fFastOrFiredMap(rec.fFastOrFiredMap){
7d62fb64 135
e56160b8 136 // Copy constructor.
045be90c 137 for(Int_t i=0; i<3; i++){
138 fkDigClassName[i]=rec.fkDigClassName[i]; // NB only copies Char_t*, so not so safe, but this code should never be reached anyways
139 }
7d62fb64 140}
141//______________________________________________________________________
e56160b8 142AliITSDetTypeRec& AliITSDetTypeRec::operator=(const AliITSDetTypeRec& source){
7537d03c 143 // Assignment operator.
144 this->~AliITSDetTypeRec();
145 new(this) AliITSDetTypeRec(source);
146 return *this;
7d62fb64 147
e56160b8 148}
7537d03c 149
7d62fb64 150//_____________________________________________________________________
3b9df642 151AliITSDetTypeRec::~AliITSDetTypeRec(){
7d62fb64 152 //Destructor
6cae184e 153
fcf95fc7 154 if(fReconstruction){
155 fReconstruction->Delete();
156 delete fReconstruction;
fcf95fc7 157 }
158 if(fSegmentation){
159 fSegmentation->Delete();
160 delete fSegmentation;
fcf95fc7 161 }
6cae184e 162 if(fCalibration){
7032f6a2 163 if(!(AliCDBManager::Instance()->GetCacheFlag())) {
7032f6a2 164 fCalibration->Delete();
165 delete fCalibration;
253e68a0 166 if(fRespSDD) delete fRespSDD;
167 if(fDDLMapSDD) delete fDDLMapSDD;
168 }
fcf95fc7 169 }
964d8c19 170 if(fSSDCalibration){
171 if(!(AliCDBManager::Instance()->GetCacheFlag())) {
172 delete fSSDCalibration;
964d8c19 173 }
174 }
ced4d9bc 175 if(fSPDDead){
23197852 176 if(!(AliCDBManager::Instance()->GetCacheFlag())) {
177 fSPDDead->Delete();
178 delete fSPDDead;
23197852 179 }
ad7f2bfa 180 }
9806b6f8 181 if(fSPDSparseDead){
182 if(!(AliCDBManager::Instance()->GetCacheFlag())) {
183 fSPDSparseDead->Delete();
184 delete fSPDSparseDead;
9806b6f8 185 }
186 }
ad7f2bfa 187 if(fTriggerConditions){
188 if(!(AliCDBManager::Instance()->GetCacheFlag())) {
189 fTriggerConditions->Delete();
190 delete fTriggerConditions;
ad7f2bfa 191 }
192 }
7d62fb64 193 if(fDigits){
194 fDigits->Delete();
195 delete fDigits;
7d62fb64 196 }
197 if(fRecPoints){
198 fRecPoints->Delete();
199 delete fRecPoints;
7d62fb64 200 }
8e50d897 201 delete [] fNMod;
7d62fb64 202
6cae184e 203 if (fITSgeom) delete fITSgeom;
204
7d62fb64 205}
8e50d897 206
7d62fb64 207//___________________________________________________________________
208void 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//______________________________________________________________________
04c81913 217AliITSClusterFinder* AliITSDetTypeRec::GetReconstructionModel(Int_t dettype) const{
7d62fb64 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//______________________________________________________________________
228void 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//______________________________________________________________________
04c81913 238AliITSsegmentation* AliITSDetTypeRec::GetSegmentationModel(Int_t dettype) const {
7d62fb64 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//_______________________________________________________________________
fcf95fc7 250void AliITSDetTypeRec::SetCalibrationModel(Int_t iMod, AliITSCalibration *cal){
8ba39da9 251
252 //Set calibration (response) for the module iMod of type dettype
253 if (fCalibration==0) {
8e50d897 254 fCalibration = new TObjArray(GetITSgeom()->GetIndexMax());
8ba39da9 255 fCalibration->SetOwner(kTRUE);
256 fCalibration->Clear();
257 }
258
259 if (fCalibration->At(iMod) != 0)
fcf95fc7 260 delete (AliITSCalibration*) fCalibration->At(iMod);
8ba39da9 261 fCalibration->AddAt(cal,iMod);
7d62fb64 262
7d62fb64 263}
264//_______________________________________________________________________
23197852 265void AliITSDetTypeRec::SetSPDDeadModel(Int_t iMod, AliITSCalibration *cal){
266
267 //Set dead pixel info for the SPD module iMod
268 if (fSPDDead==0) {
269 fSPDDead = new TObjArray(fgkDefaultNModulesSPD);
270 fSPDDead->SetOwner(kTRUE);
271 fSPDDead->Clear();
272 }
273
274 if (fSPDDead->At(iMod) != 0)
275 delete (AliITSCalibration*) fSPDDead->At(iMod);
276 fSPDDead->AddAt(cal,iMod);
277}
278//_______________________________________________________________________
9806b6f8 279void AliITSDetTypeRec::SetSPDSparseDeadModel(Int_t iMod, AliITSCalibration *cal){
280
281 //Set dead pixel info for the SPD ACTIVE module iMod
282 if (fSPDSparseDead==0) {
283 fSPDSparseDead = new TObjArray(fgkDefaultNModulesSPD);
284 fSPDSparseDead->SetOwner(kTRUE);
285 fSPDSparseDead->Clear();
286 }
287
288 if (fSPDSparseDead->At(iMod) != 0)
289 delete (AliITSCalibration*) fSPDSparseDead->At(iMod);
290 fSPDSparseDead->AddAt(cal,iMod);
291}
292//_______________________________________________________________________
04c81913 293AliITSCalibration* AliITSDetTypeRec::GetCalibrationModel(Int_t iMod) const {
7d62fb64 294
8ba39da9 295 //Get calibration model for module type
7d62fb64 296
297 if(fCalibration==0) {
8ba39da9 298 Warning("GetalibrationModel","fCalibration is 0!");
7d62fb64 299 return 0;
300 }
8ba39da9 301
ced4d9bc 302 if(iMod<fgkDefaultNModulesSPD+fgkDefaultNModulesSDD){
303 return (AliITSCalibration*)fCalibration->At(iMod);
304 }else{
305 Int_t i=iMod-(fgkDefaultNModulesSPD+fgkDefaultNModulesSDD);
306 fSSDCalibration->SetModule(i);
307 return (AliITSCalibration*)fSSDCalibration;
308 }
309
7d62fb64 310}
23197852 311//_______________________________________________________________________
04c81913 312AliITSCalibration* AliITSDetTypeRec::GetSPDDeadModel(Int_t iMod) const {
23197852 313
314 //Get SPD dead for module iMod
315
316 if(fSPDDead==0) {
317 AliWarning("fSPDDead is 0!");
318 return 0;
319 }
23197852 320 return (AliITSCalibration*)fSPDDead->At(iMod);
321}
ad7f2bfa 322//_______________________________________________________________________
9806b6f8 323AliITSCalibration* AliITSDetTypeRec::GetSPDSparseDeadModel(Int_t iMod) const {
324
325 //Get SPD dead for module iMod
326
327 if(fSPDSparseDead==0) {
328 AliWarning("fSPDSparseDead is 0!");
329 return 0;
330 }
331 return (AliITSCalibration*)fSPDSparseDead->At(iMod);
332}
333//_______________________________________________________________________
ad7f2bfa 334AliITSTriggerConditions* AliITSDetTypeRec::GetTriggerConditions() const {
335 //Get Pixel Trigger Conditions
336 if (fTriggerConditions==0) {
337 AliWarning("fTriggerConditions is 0!");
338 }
339 return fTriggerConditions;
340}
7d62fb64 341//______________________________________________________________________
dc5c67dc 342void AliITSDetTypeRec::SetTreeAddressD(TTree* const treeD){
7d62fb64 343 // Set branch address for the tree of digits.
344
ad7f2bfa 345 const char *det[4] = {"SPD","SDD","SSD","ITS"};
346 TBranch *branch;
347 const Char_t* digclass;
348 Int_t i;
349 char branchname[30];
350
351 if(!treeD) return;
2d7561cf 352 if (fDigits == 0x0) {
353 fDigits = new TObjArray(fgkNdettypes);
354 }
355 else {
356 ResetDigits();
357 }
ad7f2bfa 358 for (i=0; i<fgkNdettypes; i++) {
359 digclass = GetDigitClassName(i);
2d7561cf 360 fDigits->AddAt(new TClonesArray(digclass,1000),i);
361 if (fgkNdettypes==3) snprintf(branchname,29,"%sDigits%s",det[3],det[i]);
362 else snprintf(branchname,29,"%sDigits%d",det[3],i+1);
363 branch = treeD->GetBranch(branchname);
364 if (branch) branch->SetAddress(&((*fDigits)[i]));
ad7f2bfa 365 }
366
7d62fb64 367}
368
369//_______________________________________________________________________
dc5c67dc 370TBranch* AliITSDetTypeRec::MakeBranchInTree(TTree* const tree,
371 const char* name, const char *classname,
372 void* address,Int_t size,Int_t splitlevel)
7d62fb64 373{
374//
375// Makes branch in given tree and diverts them to a separate file
376//
377//
378//
379
380 if (tree == 0x0) {
381 Error("MakeBranchInTree","Making Branch %s Tree is NULL",name);
382 return 0x0;
383 }
384 TBranch *branch = tree->GetBranch(name);
385 if (branch) {
386 return branch;
387 }
388 if (classname){
389 branch = tree->Branch(name,classname,address,size,splitlevel);
390 }
391 else {
392 branch = tree->Bronch(name, "TClonesArray", address, size, splitlevel);
393 }
394
395 return branch;
396}
397
398//____________________________________________________________________
399void AliITSDetTypeRec::SetDefaults(){
400
401 //Set defaults for segmentation and response
402
8e50d897 403 if(!GetITSgeom()){
404 Warning("SetDefaults","null pointer to AliITSgeomGeom !");
7d62fb64 405 return;
406 }
407
408 AliITSsegmentation* seg;
8ba39da9 409 if(!GetCalibration()) {AliFatal("Exit");exit(0);}
7d62fb64 410
411 for(Int_t dettype=0;dettype<fgkNdettypes;dettype++){
412 if(dettype==0){
d24bc9d6 413 seg = new AliITSsegmentationSPD();
7d62fb64 414 SetSegmentationModel(dettype,seg);
3a7c3e6d 415 SetDigitClassName(dettype,"AliITSdigitSPD");
7d62fb64 416 }
d5eae813 417 if(dettype==1){
418 seg = new AliITSsegmentationSDD();
419 if(fLoadOnlySPDCalib==kFALSE){
62b93da7 420 AliITSCalibrationSDD* cal=(AliITSCalibrationSDD*)GetCalibrationModel(fgkDefaultNModulesSPD+1);
421 if(cal->IsAMAt20MHz()){
422 seg->SetPadSize(seg->Dpz(0),20.);
423 seg->SetNPads(seg->Npz()/2,128);
424 }
b27af87f 425 }
d5eae813 426 SetSegmentationModel(dettype,seg);
427 SetDigitClassName(dettype,"AliITSdigitSDD");
7d62fb64 428 }
429 if(dettype==2){
d24bc9d6 430 AliITSsegmentationSSD* seg2 = new AliITSsegmentationSSD();
7d62fb64 431 SetSegmentationModel(dettype,seg2);
7d62fb64 432 SetDigitClassName(dettype,"AliITSdigitSSD");
7d62fb64 433 }
7d62fb64 434 }
7d62fb64 435}
8ba39da9 436//______________________________________________________________________
437Bool_t AliITSDetTypeRec::GetCalibration() {
438 // Get Default calibration if a storage is not defined.
439
b17dae48 440 if(!fFirstcall){
441 AliITSCalibration* cal = GetCalibrationModel(0);
442 if(cal)return kTRUE;
62b93da7 443 }else {
b17dae48 444 fFirstcall = kFALSE;
445 }
06232459 446
6cae184e 447 // SetRunNumber((Int_t)AliCDBManager::Instance()->GetRun());
448 // Int_t run=GetRunNumber();
b17dae48 449
6cae184e 450 Bool_t cacheStatus = AliCDBManager::Instance()->GetCacheFlag();
b17dae48 451 if (fCalibration==0) {
452 fCalibration = new TObjArray(GetITSgeom()->GetIndexMax());
6cae184e 453 fCalibration->SetOwner(!cacheStatus);
b17dae48 454 fCalibration->Clear();
455 }
75065a60 456
457 Bool_t retCode=GetCalibrationSPD(cacheStatus);
458 if(retCode==kFALSE) return kFALSE;
459
460 if(fLoadOnlySPDCalib==kFALSE){
461 retCode=GetCalibrationSDD(cacheStatus);
462 if(retCode==kFALSE) return kFALSE;
463 retCode=GetCalibrationSSD(cacheStatus);
464 if(retCode==kFALSE) return kFALSE;
465 }
466
467 AliInfo(Form("%i SPD, %i SDD and %i SSD in calibration database",
468 fNMod[0], fNMod[1], fNMod[2]));
469 return kTRUE;
470}
471//______________________________________________________________________
472Bool_t AliITSDetTypeRec::GetCalibrationSPD(Bool_t cacheStatus) {
473 // Get SPD calibration objects from OCDB
8d37cc87 474 // dead pixel are not used for local reconstruction
75065a60 475
ad7f2bfa 476
477 AliCDBEntry *noisySPD = AliCDBManager::Instance()->Get("ITS/Calib/SPDNoisy");
23197852 478 AliCDBEntry *deadSPD = AliCDBManager::Instance()->Get("ITS/Calib/SPDDead");
9806b6f8 479 AliCDBEntry *deadSparseSPD = AliCDBManager::Instance()->Get("ITS/Calib/SPDSparseDead");
e122592f 480 AliCDBEntry *pitCond = AliCDBManager::Instance()->Get("TRIGGER/SPD/PITConditions");
ad7f2bfa 481 if(!noisySPD || !deadSPD || !pitCond ){
62b93da7 482 AliFatal("SPD Calibration object retrieval failed! ");
483 return kFALSE;
ad7f2bfa 484 }
75065a60 485
ad7f2bfa 486 TObjArray *calNoisySPD = (TObjArray*) noisySPD->GetObject();
487 if (!cacheStatus) noisySPD->SetObject(NULL);
488 noisySPD->SetOwner(kTRUE);
fb4dfab9 489
ad7f2bfa 490 TObjArray *calDeadSPD = (TObjArray*) deadSPD->GetObject();
491 if (!cacheStatus) deadSPD->SetObject(NULL);
62b93da7 492 deadSPD->SetOwner(kTRUE);
493
9806b6f8 494 TObjArray *calSparseDeadSPD = (TObjArray*) deadSparseSPD->GetObject();
495 if (!cacheStatus) deadSparseSPD->SetObject(NULL);
496 deadSparseSPD->SetOwner(kTRUE);
497
498
ad7f2bfa 499 AliITSTriggerConditions *calPitCond = (AliITSTriggerConditions*) pitCond->GetObject();
500 if (!cacheStatus) pitCond->SetObject(NULL);
501 pitCond->SetOwner(kTRUE);
b457135f 502
62b93da7 503 if(!cacheStatus){
ad7f2bfa 504 delete noisySPD;
62b93da7 505 delete deadSPD;
9806b6f8 506 delete deadSparseSPD;
ad7f2bfa 507 delete pitCond;
62b93da7 508 }
9806b6f8 509 if ((!calNoisySPD) || (!calDeadSPD) || (!calSparseDeadSPD) || (!calPitCond)){
62b93da7 510 AliWarning("Can not get SPD calibration from calibration database !");
511 return kFALSE;
512 }
513
ad7f2bfa 514 fNMod[0] = calNoisySPD->GetEntries();
62b93da7 515
516 AliITSCalibration* cal;
517 for (Int_t i=0; i<fNMod[0]; i++) {
ad7f2bfa 518 cal = (AliITSCalibration*) calNoisySPD->At(i);
62b93da7 519 SetCalibrationModel(i, cal);
ad7f2bfa 520 cal = (AliITSCalibration*) calDeadSPD->At(i);
62b93da7 521 SetSPDDeadModel(i, cal);
9806b6f8 522 cal = (AliITSCalibration*) calSparseDeadSPD->At(i);
523 SetSPDSparseDeadModel(i, cal);
62b93da7 524 }
ad7f2bfa 525 fTriggerConditions = calPitCond;
62b93da7 526
62b93da7 527 return kTRUE;
528}
75065a60 529
62b93da7 530//______________________________________________________________________
75065a60 531Bool_t AliITSDetTypeRec::GetCalibrationSDD(Bool_t cacheStatus) {
532 // Get SDD calibration objects from OCDB
533
62b93da7 534 AliCDBEntry *entrySDD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSDD");
6cae184e 535 AliCDBEntry *entry2SDD = AliCDBManager::Instance()->Get("ITS/Calib/RespSDD");
18da6e54 536 AliCDBEntry *drSpSDD = AliCDBManager::Instance()->Get("ITS/Calib/DriftSpeedSDD");
979b5a5f 537 AliCDBEntry *ddlMapSDD = AliCDBManager::Instance()->Get("ITS/Calib/DDLMapSDD");
62b93da7 538 // AliCDBEntry *mapASDD = AliCDBManager::Instance()->Get("ITS/Calib/MapsAnodeSDD");
028a3709 539 AliCDBEntry *mapTSDD = AliCDBManager::Instance()->Get("ITS/Calib/MapsTimeSDD");
06232459 540
e5b2f7f2 541 if(!entrySDD || !entry2SDD || !drSpSDD || !ddlMapSDD || !mapTSDD ){
75065a60 542 AliFatal("SDD Calibration object retrieval failed! ");
e8c4cf33 543 return kFALSE;
566f73ca 544 }
545
23197852 546
fcf95fc7 547
b17dae48 548 TObjArray *calSDD = (TObjArray *)entrySDD->GetObject();
6cae184e 549 if(!cacheStatus)entrySDD->SetObject(NULL);
8ba39da9 550 entrySDD->SetOwner(kTRUE);
fcf95fc7 551
552 AliITSresponseSDD *pSDD = (AliITSresponseSDD*)entry2SDD->GetObject();
6cae184e 553 if(!cacheStatus)entry2SDD->SetObject(NULL);
fcf95fc7 554 entry2SDD->SetOwner(kTRUE);
555
18da6e54 556 TObjArray *drSp = (TObjArray *)drSpSDD->GetObject();
557 if(!cacheStatus)drSpSDD->SetObject(NULL);
558 drSpSDD->SetOwner(kTRUE);
559
979b5a5f 560 AliITSDDLModuleMapSDD *ddlsdd=(AliITSDDLModuleMapSDD*)ddlMapSDD->GetObject();
561 if(!cacheStatus)ddlMapSDD->SetObject(NULL);
562 ddlMapSDD->SetOwner(kTRUE);
563
2ebd5518 564// TObjArray *mapAn = (TObjArray *)mapASDD->GetObject();
565// if(!cacheStatus)mapASDD->SetObject(NULL);
566// mapASDD->SetOwner(kTRUE);
028a3709 567
568 TObjArray *mapT = (TObjArray *)mapTSDD->GetObject();
569 if(!cacheStatus)mapTSDD->SetObject(NULL);
570 mapTSDD->SetOwner(kTRUE);
571
75065a60 572
573 // DB entries are deleted. In this way metadeta objects are deleted as well
574 if(!cacheStatus){
575 delete entrySDD;
576 delete entry2SDD;
577 //delete mapASDD;
75065a60 578 delete mapTSDD;
579 delete drSpSDD;
580 delete ddlMapSDD;
581 }
582
e5b2f7f2 583 if ((!pSDD)||(!calSDD) || (!drSp) || (!ddlsdd) || (!mapT) ){
75065a60 584 AliWarning("Can not get SDD calibration from calibration database !");
585 return kFALSE;
586 }
587
588 fNMod[1] = calSDD->GetEntries();
589
590 fDDLMapSDD=ddlsdd;
591 fRespSDD=pSDD;
75065a60 592 AliITSCalibration* cal;
593 Float_t avegain=0.;
594 Float_t nGdAnodes=0;
54af1add 595 Bool_t oldMapFormat=kFALSE;
596 TObject* objmap=(TObject*)mapT->At(0);
597 TString cname(objmap->ClassName());
598 if(cname.CompareTo("AliITSMapSDD")==0){
599 oldMapFormat=kTRUE;
600 AliInfo("SDD Maps converted to new format");
601 }
75065a60 602 for(Int_t iddl=0; iddl<AliITSDDLModuleMapSDD::GetNDDLs(); iddl++){
603 for(Int_t icar=0; icar<AliITSDDLModuleMapSDD::GetNModPerDDL();icar++){
604 Int_t iMod=fDDLMapSDD->GetModuleNumber(iddl,icar);
605 if(iMod==-1) continue;
606 Int_t i=iMod - fgkDefaultNModulesSPD;
607 cal = (AliITSCalibration*) calSDD->At(i);
608 Int_t i0=2*i;
609 Int_t i1=1+2*i;
610 for(Int_t iAnode=0;iAnode< ((AliITSCalibrationSDD*)cal)->NOfAnodes(); iAnode++){
611 if(((AliITSCalibrationSDD*)cal)->IsBadChannel(iAnode)) continue;
612 avegain+= ((AliITSCalibrationSDD*)cal)->GetChannelGain(iAnode);
613 nGdAnodes++;
614 }
615 AliITSDriftSpeedArraySDD* arr0 = (AliITSDriftSpeedArraySDD*) drSp->At(i0);
75065a60 616 AliITSDriftSpeedArraySDD* arr1 = (AliITSDriftSpeedArraySDD*) drSp->At(i1);
54af1add 617
618 AliITSCorrMapSDD* mt0 = 0;
619 AliITSCorrMapSDD* mt1 = 0;
620 if(oldMapFormat){
621 AliITSMapSDD* oldmap0=(AliITSMapSDD*)mapT->At(i0);
622 AliITSMapSDD* oldmap1=(AliITSMapSDD*)mapT->At(i1);
623 mt0=oldmap0->ConvertToNewFormat();
624 mt1=oldmap1->ConvertToNewFormat();
625 }else{
626 mt0=(AliITSCorrMapSDD*)mapT->At(i0);
627 mt1=(AliITSCorrMapSDD*)mapT->At(i1);
628 }
75065a60 629 cal->SetDriftSpeed(0,arr0);
630 cal->SetDriftSpeed(1,arr1);
75065a60 631 cal->SetMapT(0,mt0);
632 cal->SetMapT(1,mt1);
633 SetCalibrationModel(iMod, cal);
634 }
635 }
636 if(nGdAnodes) fAveGainSDD=avegain/nGdAnodes;
637 return kTRUE;
638}
639
640
641//______________________________________________________________________
642Bool_t AliITSDetTypeRec::GetCalibrationSSD(Bool_t cacheStatus) {
643 // Get SSD calibration objects from OCDB
644 // AliCDBEntry *entrySSD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSSD");
645
646 AliCDBEntry *entryNoiseSSD = AliCDBManager::Instance()->Get("ITS/Calib/NoiseSSD");
647 AliCDBEntry *entryGainSSD = AliCDBManager::Instance()->Get("ITS/Calib/GainSSD");
648 AliCDBEntry *entryBadChannelsSSD = AliCDBManager::Instance()->Get("ITS/Calib/BadChannelsSSD");
649
650 if(!entryNoiseSSD || !entryGainSSD || !entryBadChannelsSSD){
651 AliFatal("SSD Calibration object retrieval failed! ");
652 return kFALSE;
653 }
654
9b4aee57 655 TObject *emptyssd = 0; TString ssdobjectname;
964d8c19 656 AliITSNoiseSSDv2 *noiseSSD = NULL;
88128115 657 emptyssd = (TObject *)entryNoiseSSD->GetObject();
658 ssdobjectname = emptyssd->GetName();
659 if(ssdobjectname=="TObjArray") {
660 TObjArray *noiseSSDOld = (TObjArray *)entryNoiseSSD->GetObject();
964d8c19 661 noiseSSD = new AliITSNoiseSSDv2();
88128115 662 ReadOldSSDNoise(noiseSSDOld, noiseSSD);
663 }
664 else if(ssdobjectname=="AliITSNoiseSSDv2")
665 noiseSSD = (AliITSNoiseSSDv2 *)entryNoiseSSD->GetObject();
fb4dfab9 666 if(!cacheStatus)entryNoiseSSD->SetObject(NULL);
667 entryNoiseSSD->SetOwner(kTRUE);
668
964d8c19 669 AliITSGainSSDv2 *gainSSD = NULL;;
88128115 670 emptyssd = (TObject *)entryGainSSD->GetObject();
671 ssdobjectname = emptyssd->GetName();
672 if(ssdobjectname=="Gain") {
673 TObjArray *gainSSDOld = (TObjArray *)entryGainSSD->GetObject();
964d8c19 674 gainSSD = new AliITSGainSSDv2();
88128115 675 ReadOldSSDGain(gainSSDOld, gainSSD);
676 }
677 else if(ssdobjectname=="AliITSGainSSDv2")
678 gainSSD = (AliITSGainSSDv2 *)entryGainSSD->GetObject();
fb4dfab9 679 if(!cacheStatus)entryGainSSD->SetObject(NULL);
680 entryGainSSD->SetOwner(kTRUE);
681
964d8c19 682 AliITSBadChannelsSSDv2 *badChannelsSSD = NULL;
88128115 683 emptyssd = (TObject *)entryBadChannelsSSD->GetObject();
684 ssdobjectname = emptyssd->GetName();
685 if(ssdobjectname=="TObjArray") {
686 TObjArray *badChannelsSSDOld = (TObjArray *)entryBadChannelsSSD->GetObject();
964d8c19 687 badChannelsSSD = new AliITSBadChannelsSSDv2();
88128115 688 ReadOldSSDBadChannels(badChannelsSSDOld, badChannelsSSD);
689 }
690 else if(ssdobjectname=="AliITSBadChannelsSSDv2")
691 badChannelsSSD = (AliITSBadChannelsSSDv2*)entryBadChannelsSSD->GetObject();
fb4dfab9 692 if(!cacheStatus)entryBadChannelsSSD->SetObject(NULL);
693 entryBadChannelsSSD->SetOwner(kTRUE);
fcf95fc7 694
b17dae48 695 // DB entries are deleted. In this way metadeta objects are deleted as well
6cae184e 696 if(!cacheStatus){
fb4dfab9 697 delete entryNoiseSSD;
698 delete entryGainSSD;
699 delete entryBadChannelsSSD;
b17dae48 700 }
06232459 701
75065a60 702 if ((!noiseSSD)|| (!gainSSD)|| (!badChannelsSSD)) {
703 AliWarning("Can not get SSD calibration from calibration database !");
8ba39da9 704 return kFALSE;
705 }
fcf95fc7 706
ced4d9bc 707 fSSDCalibration->SetNoise(noiseSSD);
ced4d9bc 708 fSSDCalibration->SetGain(gainSSD);
88128115 709 fSSDCalibration->SetBadChannels(badChannelsSSD);
ced4d9bc 710 //fSSDCalibration->FillBadChipMap();
711
8ba39da9 712 return kTRUE;
713}
714
7d62fb64 715//________________________________________________________________
3a7c3e6d 716void AliITSDetTypeRec::SetDefaultClusterFindersV2(Bool_t rawdata){
7d62fb64 717
718 //Set defaults for cluster finder V2
719
8e50d897 720 if(!GetITSgeom()){
721 Warning("SetDefaults","Null pointer to AliITSgeom !");
7d62fb64 722 return;
723 }
724
7d62fb64 725 AliITSClusterFinder *clf;
726
3a7c3e6d 727 for(Int_t dettype=0;dettype<fgkNdettypes;dettype++){
7d62fb64 728 //SPD
729 if(dettype==0){
730 if(!GetReconstructionModel(dettype)){
8ba39da9 731 clf = new AliITSClusterFinderV2SPD(this);
7d62fb64 732 clf->InitGeometry();
3a7c3e6d 733 if(!rawdata) clf->SetDigits(DigitsAddress(0));
7d62fb64 734 SetReconstructionModel(dettype,clf);
735
736 }
737 }
738 //SDD
739 if(dettype==1){
740 if(!GetReconstructionModel(dettype)){
8ba39da9 741 clf = new AliITSClusterFinderV2SDD(this);
742 clf->InitGeometry();
3a7c3e6d 743 if(!rawdata) clf->SetDigits(DigitsAddress(1));
7d62fb64 744 SetReconstructionModel(dettype,clf);
745 }
746
747 }
748
749 //SSD
750 if(dettype==2){
751 if(!GetReconstructionModel(dettype)){
8ba39da9 752 clf = new AliITSClusterFinderV2SSD(this);
7d62fb64 753 clf->InitGeometry();
3a7c3e6d 754 if(!rawdata) clf->SetDigits(DigitsAddress(2));
7d62fb64 755 SetReconstructionModel(dettype,clf);
756 }
757 }
758
759 }
760
761}
762//______________________________________________________________________
6cae184e 763void AliITSDetTypeRec::MakeBranch(TTree* tree, Option_t* option){
7d62fb64 764
765 //Creates branches for clusters and recpoints
766 Bool_t cR = (strstr(option,"R")!=0);
767 Bool_t cRF = (strstr(option,"RF")!=0);
7d62fb64 768
769 if(cRF)cR = kFALSE;
770
6cae184e 771 if(cR) MakeBranchR(tree);
772 if(cRF) MakeBranchRF(tree);
7d62fb64 773
774}
775
776//___________________________________________________________________
7d62fb64 777void AliITSDetTypeRec::ResetDigits(){
778 // Reset number of digits and the digits array for the ITS detector.
779
780 if(!fDigits) return;
781 for(Int_t i=0;i<fgkNdettypes;i++){
782 ResetDigits(i);
783 }
784}
785//___________________________________________________________________
786void AliITSDetTypeRec::ResetDigits(Int_t branch){
787 // Reset number of digits and the digits array for this branch.
788
789 if(fDigits->At(branch)) ((TClonesArray*)fDigits->At(branch))->Clear();
7d62fb64 790
7d62fb64 791}
792//__________________________________________________________________
6cae184e 793void AliITSDetTypeRec::MakeBranchR(TTree *treeR, Option_t *opt){
7d62fb64 794
795 //Creates tree branches for recpoints
796 // Inputs:
797 // cont char *file File name where RecPoints branch is to be written
798 // to. If blank it write the SDigits to the same
799 // file in which the Hits were found.
800
7d62fb64 801 Int_t buffsz = 4000;
802 char branchname[30];
803
804 // only one branch for rec points for all detector types
805 Bool_t oFast= (strstr(opt,"Fast")!=0);
7d62fb64 806
807 Char_t detname[10] = "ITS";
808
809
810 if(oFast){
2d7561cf 811 snprintf(branchname,29,"%sRecPointsF",detname);
7d62fb64 812 } else {
2d7561cf 813 snprintf(branchname,29,"%sRecPoints",detname);
7d62fb64 814 }
815
00a7cc50 816 if(!fRecPoints)fRecPoints = new TClonesArray("AliITSRecPoint",1000);
6cae184e 817 if (treeR)
818 MakeBranchInTree(treeR,branchname,0,&fRecPoints,buffsz,99);
7d62fb64 819}
820//______________________________________________________________________
dc5c67dc 821void AliITSDetTypeRec::SetTreeAddressR(TTree* const treeR){
7d62fb64 822 // Set branch address for the Reconstructed points Trees.
3b9df642 823 // Inputs:
7d62fb64 824 // TTree *treeR Tree containing the RecPoints.
3b9df642 825 // Outputs:
7d62fb64 826 // none.
3b9df642 827 // Return:
7d62fb64 828
ad7f2bfa 829 char branchname[30];
830 Char_t namedet[10]="ITS";
7d62fb64 831
ad7f2bfa 832 if(!treeR) return;
833 if(fRecPoints==0x0) fRecPoints = new TClonesArray("AliITSRecPoint",1000);
834 TBranch *branch;
2d7561cf 835 snprintf(branchname,29,"%sRecPoints",namedet);
ad7f2bfa 836 branch = treeR->GetBranch(branchname);
837 if (branch) {
00a7cc50 838 branch->SetAddress(&fRecPoints);
ad7f2bfa 839 }
840 else {
2d7561cf 841 snprintf(branchname,29,"%sRecPointsF",namedet);
7d62fb64 842 branch = treeR->GetBranch(branchname);
843 if (branch) {
00a7cc50 844 branch->SetAddress(&fRecPoints);
7d62fb64 845 }
ad7f2bfa 846 }
3b9df642 847}
7d62fb64 848//____________________________________________________________________
849void AliITSDetTypeRec::AddRecPoint(const AliITSRecPoint &r){
850 // Add a reconstructed space point to the list
851 // Inputs:
852 // const AliITSRecPoint &r RecPoint class to be added to the tree
853 // of reconstructed points TreeR.
854 // Outputs:
855 // none.
856 // Return:
857 // none.
7d62fb64 858 TClonesArray &lrecp = *fRecPoints;
859 new(lrecp[fNRecPoints++]) AliITSRecPoint(r);
860}
7d62fb64 861
862//______________________________________________________________________
5d2c2f86 863void AliITSDetTypeRec::DigitsToRecPoints(TTree *treeD,TTree *treeR,Int_t lastentry,Option_t *opt, Int_t optCluFind){
7d62fb64 864 // cluster finding and reconstruction of space points
865 // the condition below will disappear when the geom class will be
866 // initialized for all versions - for the moment it is only for v5 !
867 // 7 is the SDD beam test version
868 // Inputs:
6cae184e 869 // TTree *treeD Digits tree
870 // TTree *treeR Clusters tree
7d62fb64 871 // Int_t lastentry Offset for module when not all of the modules
872 // are processed.
873 // Option_t *opt String indicating which ITS sub-detectors should
874 // be processed. If ="All" then all of the ITS
875 // sub detectors are processed.
876
7d62fb64 877 const char *all = strstr(opt,"All");
878 const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),
879 strstr(opt,"SSD")};
5d2c2f86 880 if(optCluFind==0){
00a7cc50 881 SetDefaultClusterFindersV2();
75a74b11 882 AliDebug(1,"V2 cluster finder has been selected \n");
5d2c2f86 883 }else{
884 SetDefaultClusterFindersV2();
06a7cbee 885 AliInfo("Cluster Finder Option not implemented, V2 cluster finder will be used \n");
00a7cc50 886 }
7d62fb64 887
ad7f2bfa 888
889 // Reset Fast-OR fired map
890 ResetFastOrFiredMap();
891
892 if (all || det[0]) { // SPD present
893 // Get the FO signals for this event
894 AliRunLoader* runLoader = AliRunLoader::Instance();
895 AliITSLoader* itsLoader = (AliITSLoader*) runLoader->GetLoader("ITSLoader");
896 if (!itsLoader) {
897 AliError("ITS loader is NULL.");
898 }
a0d76912 899 else {
900 fFOSignals = (AliITSFOSignalsSPD*)itsLoader->TreeD()->GetUserInfo()->FindObject("AliITSFOSignalsSPD");
901 if(!fFOSignals) AliError("FO signals not retrieved");
902 }
903
ad7f2bfa 904 }
905
906
7d62fb64 907 AliITSClusterFinder *rec = 0;
908 Int_t id,module,first=0;
8e50d897 909 for(module=0;module<GetITSgeom()->GetIndexMax();module++){
910 id = GetITSgeom()->GetModuleType(module);
7d62fb64 911 if (!all && !det[id]) continue;
8e50d897 912 if(det[id]) first = GetITSgeom()->GetStartDet(id);
7d62fb64 913 rec = (AliITSClusterFinder*)GetReconstructionModel(id);
914 TClonesArray *itsDigits = DigitsAddress(id);
2d7561cf 915 if (!rec){
916 AliFatal("The reconstruction class was not instanciated!");
917 return;
918 }
5e5bc8f1 919 ResetDigits(); // MvL: Not sure we neeed this when rereading anyways
7d62fb64 920 if (all) {
6cae184e 921 treeD->GetEvent(lastentry+module);
ad7f2bfa 922 }
923 else {
924 treeD->GetEvent(lastentry+(module-first));
925 }
926 Int_t ndigits = itsDigits->GetEntriesFast();
927 if (ndigits>0 || id==0) { // for SPD we always want to call FindRawClusters (to process FO signals)
928 rec->SetDetTypeRec(this);
929 rec->SetDigits(DigitsAddress(id));
930 // rec->SetClusters(ClustersAddress(id));
931 rec->FindRawClusters(module);
932 } // end if
933 treeR->Fill();
934 ResetRecPoints();
935 }
936
937 // Remove PIT in-active chips from Fast-OR fired map
938 if (all || det[0]) { // SPD present
939 RemoveFastOrFiredInActive();
e5c65a6d 940 // here removing bits which have no associated clusters
941 RemoveFastOrFiredFromDead(GetFiredChipMap(treeR));
ad7f2bfa 942 }
3b1d8321 943
944 AliITSRecPointContainer* rpcont = AliITSRecPointContainer::Instance();
945 Int_t nClu[6];
946 nClu[0]=rpcont->GetNClustersInLayer(1,treeR);
947 for(Int_t iLay=2; iLay<=6; iLay++) nClu[iLay-1]=rpcont->GetNClustersInLayerFast(iLay);
948 AliInfo(Form("Number of RecPoints in ITS Layers = %d %d %d %d %d %d",
949 nClu[0],nClu[1],nClu[2],nClu[3],nClu[4],nClu[5]));
7d62fb64 950}
951//______________________________________________________________________
8484b32d 952void AliITSDetTypeRec::DigitsToRecPoints(AliRawReader* rawReader,TTree *treeR,Option_t *opt){
7d62fb64 953 // cluster finding and reconstruction of space points
954 // the condition below will disappear when the geom class will be
955 // initialized for all versions - for the moment it is only for v5 !
956 // 7 is the SDD beam test version
957 // Inputs:
6cae184e 958 // AliRawReader *rawReader Pointer to the raw-data reader
959 // TTree *treeR Clusters tree
7d62fb64 960 // Outputs:
961 // none.
962 // Return:
963 // none.
8484b32d 964 const char *all = strstr(opt,"All");
965 const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),
966 strstr(opt,"SSD")};
ad7f2bfa 967
7d62fb64 968 Int_t id=0;
01ef1bd4 969 AliITSRecPointContainer* rpc = AliITSRecPointContainer::Instance();
970 rpc->FullReset();
971 TClonesArray* array = rpc->UncheckedGetClusters(0);
972 TBranch *branch = treeR->Branch("ITSRecPoints",&array);
973 DigitsToRecPoints(rawReader,opt);
d97fc3e0 974
7d62fb64 975 Int_t nClusters =0;
8e50d897 976 for(Int_t iModule=0;iModule<GetITSgeom()->GetIndexMax();iModule++){
8484b32d 977 id = GetITSgeom()->GetModuleType(iModule);
978 if (!all && !det[id]) continue;
01ef1bd4 979 array = rpc->UncheckedGetClusters(iModule);
7d62fb64 980 if(!array){
c157c94e 981 AliDebug(1,Form("data for module %d missing!",iModule));
7d62fb64 982 }
6cae184e 983 branch->SetAddress(&array);
984 treeR->Fill();
7d62fb64 985 nClusters+=array->GetEntriesFast();
7d62fb64 986 }
cd634801 987
01ef1bd4 988 rpc->FullReset();
c157c94e 989
3b1d8321 990 AliITSRecPointContainer* rpcont = AliITSRecPointContainer::Instance();
991 Int_t nClu[6];
992 nClu[0]=rpcont->GetNClustersInLayer(1,treeR);
993 for(Int_t iLay=2; iLay<=6; iLay++) nClu[iLay-1]=rpcont->GetNClustersInLayerFast(iLay);
994 AliInfo(Form("Number of RecPoints in ITS Layers = %d %d %d %d %d %d, Total = %d",
995 nClu[0],nClu[1],nClu[2],nClu[3],nClu[4],nClu[5],nClusters));
d97fc3e0 996}
997//______________________________________________________________________
01ef1bd4 998void AliITSDetTypeRec::DigitsToRecPoints(AliRawReader* rawReader,Option_t *opt){
d97fc3e0 999 // cluster finding and reconstruction of space points
1000 // the condition below will disappear when the geom class will be
1001 // initialized for all versions - for the moment it is only for v5 !
1002 // 7 is the SDD beam test version
1003 // Inputs:
1004 // AliRawReader *rawReader Pointer to the raw-data reader
d97fc3e0 1005 // Outputs:
1006 // none.
1007 // Return:
1008 // none.
1009 const char *all = strstr(opt,"All");
1010 const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),
1011 strstr(opt,"SSD")};
1012
1013 // Reset Fast-OR fired map
1014 ResetFastOrFiredMap();
1015
1016 AliITSClusterFinder *rec = 0;
1017 Int_t id=0;
1018
1019 for(id=0;id<3;id++){
1020 if (!all && !det[id]) continue;
1021 rec = (AliITSClusterFinder*)GetReconstructionModel(id);
2d7561cf 1022 if (!rec){
d97fc3e0 1023 AliFatal("The reconstruction class was not instantiated");
2d7561cf 1024 return;
1025 }
d97fc3e0 1026 rec->SetDetTypeRec(this);
01ef1bd4 1027 rec->RawdataToClusters(rawReader);
d97fc3e0 1028 }
1029
ad7f2bfa 1030 // Remove PIT in-active chips from Fast-OR fired map
1031 if (all || det[0]) { // SPD present
1032 RemoveFastOrFiredInActive();
e5c65a6d 1033 // here removing bits which have no associated clusters
01ef1bd4 1034 RemoveFastOrFiredFromDead(GetFiredChipMap());
e5c65a6d 1035
ad7f2bfa 1036 }
7d62fb64 1037}
88128115 1038//______________________________________________________________________
ef665f5e 1039void AliITSDetTypeRec::ReadOldSSDNoise(const TObjArray *array,
88128115 1040 AliITSNoiseSSDv2 *noiseSSD) {
1041 //Reads the old SSD calibration object and converts it to the new format
1042 const Int_t fgkSSDSTRIPSPERMODULE = 1536;
1043 const Int_t fgkSSDPSIDESTRIPSPERMODULE = 768;
1044
3dd31ed2 1045 Int_t gNMod = array->GetEntries();
da631926 1046 AliInfo("Converting old calibration object for noise...\n");
88128115 1047
1048 //NOISE
1049 Double_t noise = 0.0;
3dd31ed2 1050 for (Int_t iModule = 0; iModule < gNMod; iModule++) {
88128115 1051 AliITSNoiseSSD *noiseModule = (AliITSNoiseSSD*) (array->At(iModule));
1052 for(Int_t iStrip = 0; iStrip < fgkSSDSTRIPSPERMODULE; iStrip++) {
1053 noise = (iStrip < fgkSSDPSIDESTRIPSPERMODULE) ? noiseModule->GetNoiseP(iStrip) : noiseModule->GetNoiseN(1535 - iStrip);
1054 if(iStrip < fgkSSDPSIDESTRIPSPERMODULE)
1055 noiseSSD->AddNoiseP(iModule,iStrip,noise);
1056 if(iStrip >= fgkSSDPSIDESTRIPSPERMODULE)
1057 noiseSSD->AddNoiseN(iModule,1535 - iStrip,noise);
1058 }//loop over strips
1059 }//loop over modules
1060}
1061
1062//______________________________________________________________________
ef665f5e 1063void AliITSDetTypeRec::ReadOldSSDBadChannels(const TObjArray *array,
88128115 1064 AliITSBadChannelsSSDv2 *badChannelsSSD) {
1065 //Reads the old SSD calibration object and converts it to the new format
3dd31ed2 1066 Int_t gNMod = array->GetEntries();
da631926 1067 AliInfo("Converting old calibration object for bad channels...");
3dd31ed2 1068 for (Int_t iModule = 0; iModule < gNMod; iModule++) {
88128115 1069 //for (Int_t iModule = 0; iModule < 1; iModule++) {
1070 AliITSBadChannelsSSD *bad = (AliITSBadChannelsSSD*) (array->At(iModule));
1071 TArrayI arrayPSide = bad->GetBadPChannelsList();
1072 for(Int_t iPCounter = 0; iPCounter < arrayPSide.GetSize(); iPCounter++)
1073 badChannelsSSD->AddBadChannelP(iModule,
1074 iPCounter,
1075 (Char_t)arrayPSide.At(iPCounter));
1076
1077 TArrayI arrayNSide = bad->GetBadNChannelsList();
1078 for(Int_t iNCounter = 0; iNCounter < arrayNSide.GetSize(); iNCounter++)
1079 badChannelsSSD->AddBadChannelN(iModule,
1080 iNCounter,
1081 (Char_t)arrayNSide.At(iNCounter));
1082
1083 }//loop over modules
1084}
1085
1086//______________________________________________________________________
ef665f5e 1087void AliITSDetTypeRec::ReadOldSSDGain(const TObjArray *array,
88128115 1088 AliITSGainSSDv2 *gainSSD) {
1089 //Reads the old SSD calibration object and converts it to the new format
1090
3dd31ed2 1091 Int_t gNMod = array->GetEntries();
da631926 1092 AliInfo("Converting old calibration object for gain...\n");
88128115 1093
1094 //GAIN
3dd31ed2 1095 for (Int_t iModule = 0; iModule < gNMod; iModule++) {
88128115 1096 AliITSGainSSD *gainModule = (AliITSGainSSD*) (array->At(iModule));
1097 TArrayF arrayPSide = gainModule->GetGainP();
1098 for(Int_t iPCounter = 0; iPCounter < arrayPSide.GetSize(); iPCounter++)
1099 gainSSD->AddGainP(iModule,
1100 iPCounter,
1101 arrayPSide.At(iPCounter));
1102 TArrayF arrayNSide = gainModule->GetGainN();
1103 for(Int_t iNCounter = 0; iNCounter < arrayNSide.GetSize(); iNCounter++)
1104 gainSSD->AddGainN(iModule,
1105 iNCounter,
1106 arrayNSide.At(iNCounter));
1107 }//loop over modules
1108}
ad7f2bfa 1109//______________________________________________________________________
1110void AliITSDetTypeRec::RemoveFastOrFiredInActive() {
1111 // Removes the chips that were in-active in the pixel trigger (from fast-or fired map)
e5c65a6d 1112
ad7f2bfa 1113 if (fTriggerConditions==NULL) {
1114 AliError("Pixel trigger conditions are missing.");
1115 return;
1116 }
1117 Int_t eq = -1;
1118 Int_t hs = -1;
1119 Int_t chip = -1;
1120 while (fTriggerConditions->GetNextInActiveChip(eq,hs,chip)) {
1121 UInt_t chipKey = AliITSRawStreamSPD::GetOfflineChipKeyFromOnline(eq,hs,chip);
1122 fFastOrFiredMap.SetBitNumber(chipKey,kFALSE);
1123 }
1124}
1125//______________________________________________________________________
01ef1bd4 1126TBits AliITSDetTypeRec::GetFiredChipMap() const {
e5c65a6d 1127
1128 //
1129 // TBits of the fired chips
1130 //
1131
01ef1bd4 1132 AliITSRecPointContainer* rpc = AliITSRecPointContainer::Instance();
1133
e5c65a6d 1134 TBits isfiredchip(1200);
1135
1136 AliITSsegmentationSPD *segSPD = (AliITSsegmentationSPD*)GetSegmentationModel(0);
1137 if(!segSPD) {
1138 AliError("no segmentation model for SPD available, the fired chip map is empty. Exiting");
1139 return isfiredchip;
1140 }
1141
1142
1143 for(Int_t imod =0; imod < fgkDefaultNModulesSPD; imod++){
01ef1bd4 1144 TClonesArray *array = rpc->UncheckedGetClusters(imod);
1145 if(!array) continue;
1146 Int_t nCluster = array->GetEntriesFast();
e5c65a6d 1147
01ef1bd4 1148 while(nCluster--) {
1149 AliITSRecPoint* cluster = (AliITSRecPoint*)array->UncheckedAt(nCluster);
e5c65a6d 1150 if (cluster->GetLayer()>1)continue;
01ef1bd4 1151 Float_t local[3]={-1,-1};
1152 local[1]=cluster->GetDetLocalX();
1153 local[0]=cluster->GetDetLocalZ();
1154
1155 Int_t eq = AliITSRawStreamSPD::GetOnlineEqIdFromOffline(imod);
1156 Int_t hs = AliITSRawStreamSPD::GetOnlineHSFromOffline(imod);
1157 Int_t row, col;
1158 segSPD->LocalToDet(0.5,local[0],row,col);
1159 Int_t chip = AliITSRawStreamSPD::GetOnlineChipFromOffline(imod,col);
1160 Int_t chipkey = AliITSRawStreamSPD::GetOfflineChipKeyFromOnline(eq,hs,chip);
1161 isfiredchip.SetBitNumber(chipkey,kTRUE);
1162 }
e5c65a6d 1163
01ef1bd4 1164 }
e5c65a6d 1165
01ef1bd4 1166 return isfiredchip;
e5c65a6d 1167
1168}
1169//______________________________________________________________________
1170TBits AliITSDetTypeRec::GetFiredChipMap(TTree *treeR) const{
1171 //
1172 // TBits of the fired chips
1173 //
1174 TBits isfiredchip(1200);
1175
1176 if(!treeR) {
1177 AliError("no treeR. fired chip map stays empty. Exiting.");
1178 return isfiredchip;
1179 }
1180
1181 AliITSRecPointContainer* rpcont=AliITSRecPointContainer::Instance();
2d7561cf 1182 TClonesArray *recpoints = NULL;
1183 rpcont->FetchClusters(0,treeR);
e5c65a6d 1184 if(!rpcont->GetStatusOK() || !rpcont->IsSPDActive()){
1185 AliError("no clusters. fired chip map stays empty. Exiting.");
1186 return isfiredchip;
1187 }
1188
1189 AliITSsegmentationSPD *segSPD = (AliITSsegmentationSPD*)GetSegmentationModel(0);
1190
1191 for(Int_t imod =0; imod < fgkDefaultNModulesSPD; imod++){
1192 recpoints = rpcont->UncheckedGetClusters(imod);
1193 Int_t nCluster = recpoints->GetEntriesFast();
1194
1195 // loop over clusters
1196 while(nCluster--) {
1197 AliITSRecPoint* cluster = (AliITSRecPoint*)recpoints->UncheckedAt(nCluster);
1198 if (cluster->GetLayer()>1)continue;
1199 Float_t local[3]={-1,-1};
1200 local[1]=cluster->GetDetLocalX();
1201 local[0]=cluster->GetDetLocalZ();
1202
1203 Int_t eq = AliITSRawStreamSPD::GetOnlineEqIdFromOffline(imod);
1204 Int_t hs = AliITSRawStreamSPD::GetOnlineHSFromOffline(imod);
1205 Int_t row, col;
1206 segSPD->LocalToDet(0.5,local[0],row,col);
1207 Int_t chip = AliITSRawStreamSPD::GetOnlineChipFromOffline(imod,col);
1208 Int_t chipkey = AliITSRawStreamSPD::GetOfflineChipKeyFromOnline(eq,hs,chip);
1209 isfiredchip.SetBitNumber(chipkey,kTRUE);
1210 }
1211 }
1212
1213 return isfiredchip;
1214}
1215//______________________________________________________________________
1216void AliITSDetTypeRec::RemoveFastOrFiredFromDead(TBits firedchipmap){
1217 //
1218 // resetting of the fast-or bit on cluster basis.
1219 // fast-or bits can be remnant from SPD ideal simulation (no dead channels)
1220 //
1221
1222 for(Int_t chipKey=0; chipKey<1200; chipKey++){
1223 // FO masked chips have been previously removed
1224 if(!fFastOrFiredMap.TestBitNumber(chipKey)) continue;
1225 if(!firedchipmap.TestBitNumber(chipKey)) {
1226 fFastOrFiredMap.SetBitNumber(chipKey,kFALSE);
1227 AliDebug(2,Form("removing bit in key %i \n ",chipKey));
1228 }
1229 }
1230
1231}
1232//______________________________________________________________________
ad7f2bfa 1233void AliITSDetTypeRec::SetFastOrFiredMapOnline(UInt_t eq, UInt_t hs, UInt_t chip) {
1234 // Set fast-or fired map for this chip
1235 Int_t chipKey = AliITSRawStreamSPD::GetOfflineChipKeyFromOnline(eq,hs,chip);
1236 return SetFastOrFiredMap(chipKey);
1237}
88128115 1238