1 /***************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Conributors are mentioned in the code where appropriate. *
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 **************************************************************************/
20 ////////////////////////////////////////////////////////////////////////
21 // This class defines the "Standard" reconstruction for the ITS //
24 ////////////////////////////////////////////////////////////////////////
25 #include "TObjArray.h"
28 #include "AliCDBManager.h"
29 #include "AliCDBEntry.h"
30 #include "AliITSClusterFinder.h"
31 #include "AliITSClusterFinderV2SPD.h"
32 #include "AliITSClusterFinderV2SDD.h"
33 #include "AliITSClusterFinderV2SSD.h"
34 #include "AliITSDetTypeRec.h"
35 #include "AliITSDDLModuleMapSDD.h"
36 #include "AliITSRecPoint.h"
37 #include "AliITSRecPointContainer.h"
38 #include "AliITSCalibrationSDD.h"
39 #include "AliITSMapSDD.h"
40 #include "AliITSCalibrationSSD.h"
41 #include "AliITSNoiseSSDv2.h"
42 #include "AliITSGainSSDv2.h"
43 #include "AliITSBadChannelsSSDv2.h"
44 #include "AliITSNoiseSSD.h"
45 #include "AliITSGainSSD.h"
46 #include "AliITSBadChannelsSSD.h"
47 #include "AliITSresponseSDD.h"
48 #include "AliITSsegmentationSPD.h"
49 #include "AliITSsegmentationSDD.h"
50 #include "AliITSsegmentationSSD.h"
52 #include "AliITSRawStreamSPD.h"
53 #include "AliITSTriggerConditions.h"
54 #include "AliITSFOSignalsSPD.h"
55 #include "AliRunLoader.h"
56 #include "AliDataLoader.h"
57 #include "AliITSLoader.h"
59 class AliITSDriftSpeedArraySDD;
60 class AliITSCorrMapSDD;
61 class AliITSRecoParam;
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;
68 ClassImp(AliITSDetTypeRec)
70 //________________________________________________________________
71 AliITSDetTypeRec::AliITSDetTypeRec(): TObject(),
80 fTriggerConditions(0),
90 fFastOrFiredMap(1200){
91 // Standard Constructor
99 fReconstruction = new TObjArray(fgkNdettypes);
100 fDigits = new TObjArray(fgkNdettypes);
101 for(Int_t i=0; i<3; i++){
104 fSSDCalibration=new AliITSCalibrationSSD();
105 fNMod = new Int_t [fgkNdettypes];
106 fNMod[0] = fgkDefaultNModulesSPD;
107 fNMod[1] = fgkDefaultNModulesSDD;
108 fNMod[2] = fgkDefaultNModulesSSD;
114 //______________________________________________________________________
115 AliITSDetTypeRec::AliITSDetTypeRec(const AliITSDetTypeRec & rec):TObject(rec),
117 fITSgeom(rec.fITSgeom),
118 fReconstruction(rec.fReconstruction),
119 fSegmentation(rec.fSegmentation),
120 fCalibration(rec.fCalibration),
121 fSSDCalibration(rec.fSSDCalibration),
122 fSPDDead(rec.fSPDDead),
123 fSPDSparseDead(rec.fSPDSparseDead),
124 fTriggerConditions(rec.fTriggerConditions),
125 fDigits(rec.fDigits),
126 fFOSignals(rec.fFOSignals),
127 fDDLMapSDD(rec.fDDLMapSDD),
128 fRespSDD(rec.fRespSDD),
129 fAveGainSDD(rec.fAveGainSDD),
130 fRecPoints(rec.fRecPoints),
131 fNRecPoints(rec.fNRecPoints),
132 fFirstcall(rec.fFirstcall),
133 fLoadOnlySPDCalib(rec.fLoadOnlySPDCalib),
134 fFastOrFiredMap(rec.fFastOrFiredMap){
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
141 //______________________________________________________________________
142 AliITSDetTypeRec& AliITSDetTypeRec::operator=(const AliITSDetTypeRec& source){
143 // Assignment operator.
144 this->~AliITSDetTypeRec();
145 new(this) AliITSDetTypeRec(source);
150 //_____________________________________________________________________
151 AliITSDetTypeRec::~AliITSDetTypeRec(){
155 fReconstruction->Delete();
156 delete fReconstruction;
159 fSegmentation->Delete();
160 delete fSegmentation;
163 if(!(AliCDBManager::Instance()->GetCacheFlag())) {
164 fCalibration->Delete();
166 if(fRespSDD) delete fRespSDD;
167 if(fDDLMapSDD) delete fDDLMapSDD;
171 if(!(AliCDBManager::Instance()->GetCacheFlag())) {
172 delete fSSDCalibration;
176 if(!(AliCDBManager::Instance()->GetCacheFlag())) {
182 if(!(AliCDBManager::Instance()->GetCacheFlag())) {
183 fSPDSparseDead->Delete();
184 delete fSPDSparseDead;
187 if(fTriggerConditions){
188 if(!(AliCDBManager::Instance()->GetCacheFlag())) {
189 fTriggerConditions->Delete();
190 delete fTriggerConditions;
198 fRecPoints->Delete();
203 if (fITSgeom) delete fITSgeom;
207 //___________________________________________________________________
208 void AliITSDetTypeRec::SetReconstructionModel(Int_t dettype,AliITSClusterFinder *clf){
210 //Set reconstruction model for detector type
212 if(fReconstruction==0) fReconstruction = new TObjArray(fgkNdettypes);
213 if(fReconstruction->At(dettype)!=0) delete fReconstruction->At(dettype);
214 fReconstruction->AddAt(clf,dettype);
216 //______________________________________________________________________
217 AliITSClusterFinder* AliITSDetTypeRec::GetReconstructionModel(Int_t dettype) const{
219 //Get reconstruction model for detector type
220 if(fReconstruction==0) {
221 Warning("GetReconstructionModel","fReconstruction is 0!");
224 return (AliITSClusterFinder*)fReconstruction->At(dettype);
227 //______________________________________________________________________
228 void AliITSDetTypeRec::SetSegmentationModel(Int_t dettype,AliITSsegmentation *seg){
230 //Set segmentation model for detector type
232 if(fSegmentation==0) fSegmentation = new TObjArray(fgkNdettypes);
233 if(fSegmentation->At(dettype)!=0) delete fSegmentation->At(dettype);
234 fSegmentation->AddAt(seg,dettype);
237 //______________________________________________________________________
238 AliITSsegmentation* AliITSDetTypeRec::GetSegmentationModel(Int_t dettype) const {
240 //Get segmentation model for detector type
242 if(fSegmentation==0) {
243 Warning("GetSegmentationModel","fSegmentation is 0!");
246 return (AliITSsegmentation*)fSegmentation->At(dettype);
249 //_______________________________________________________________________
250 void AliITSDetTypeRec::SetCalibrationModel(Int_t iMod, AliITSCalibration *cal){
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();
259 if (fCalibration->At(iMod) != 0)
260 delete (AliITSCalibration*) fCalibration->At(iMod);
261 fCalibration->AddAt(cal,iMod);
264 //_______________________________________________________________________
265 void AliITSDetTypeRec::SetSPDDeadModel(Int_t iMod, AliITSCalibration *cal){
267 //Set dead pixel info for the SPD module iMod
269 fSPDDead = new TObjArray(fgkDefaultNModulesSPD);
270 fSPDDead->SetOwner(kTRUE);
274 if (fSPDDead->At(iMod) != 0)
275 delete (AliITSCalibration*) fSPDDead->At(iMod);
276 fSPDDead->AddAt(cal,iMod);
278 //_______________________________________________________________________
279 void AliITSDetTypeRec::SetSPDSparseDeadModel(Int_t iMod, AliITSCalibration *cal){
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();
288 if (fSPDSparseDead->At(iMod) != 0)
289 delete (AliITSCalibration*) fSPDSparseDead->At(iMod);
290 fSPDSparseDead->AddAt(cal,iMod);
292 //_______________________________________________________________________
293 AliITSCalibration* AliITSDetTypeRec::GetCalibrationModel(Int_t iMod) const {
295 //Get calibration model for module type
297 if(fCalibration==0) {
298 Warning("GetalibrationModel","fCalibration is 0!");
302 if(iMod<fgkDefaultNModulesSPD+fgkDefaultNModulesSDD){
303 return (AliITSCalibration*)fCalibration->At(iMod);
305 Int_t i=iMod-(fgkDefaultNModulesSPD+fgkDefaultNModulesSDD);
306 fSSDCalibration->SetModule(i);
307 return (AliITSCalibration*)fSSDCalibration;
311 //_______________________________________________________________________
312 AliITSCalibration* AliITSDetTypeRec::GetSPDDeadModel(Int_t iMod) const {
314 //Get SPD dead for module iMod
317 AliWarning("fSPDDead is 0!");
320 return (AliITSCalibration*)fSPDDead->At(iMod);
322 //_______________________________________________________________________
323 AliITSCalibration* AliITSDetTypeRec::GetSPDSparseDeadModel(Int_t iMod) const {
325 //Get SPD dead for module iMod
327 if(fSPDSparseDead==0) {
328 AliWarning("fSPDSparseDead is 0!");
331 return (AliITSCalibration*)fSPDSparseDead->At(iMod);
333 //_______________________________________________________________________
334 AliITSTriggerConditions* AliITSDetTypeRec::GetTriggerConditions() const {
335 //Get Pixel Trigger Conditions
336 if (fTriggerConditions==0) {
337 AliWarning("fTriggerConditions is 0!");
339 return fTriggerConditions;
341 //______________________________________________________________________
342 void AliITSDetTypeRec::SetTreeAddressD(TTree* const treeD){
343 // Set branch address for the tree of digits.
345 const char *det[4] = {"SPD","SDD","SSD","ITS"};
347 const Char_t* digclass;
352 if (fDigits == 0x0) {
353 fDigits = new TObjArray(fgkNdettypes);
358 for (i=0; i<fgkNdettypes; i++) {
359 digclass = GetDigitClassName(i);
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]));
369 //_______________________________________________________________________
370 TBranch* AliITSDetTypeRec::MakeBranchInTree(TTree* const tree,
371 const char* name, const char *classname,
372 void* address,Int_t size,Int_t splitlevel)
375 // Makes branch in given tree and diverts them to a separate file
381 Error("MakeBranchInTree","Making Branch %s Tree is NULL",name);
384 TBranch *branch = tree->GetBranch(name);
389 branch = tree->Branch(name,classname,address,size,splitlevel);
392 branch = tree->Bronch(name, "TClonesArray", address, size, splitlevel);
398 //____________________________________________________________________
399 void AliITSDetTypeRec::SetDefaults(){
401 //Set defaults for segmentation and response
404 Warning("SetDefaults","null pointer to AliITSgeomGeom !");
408 AliITSsegmentation* seg;
409 if(!GetCalibration()) {AliFatal("Exit");exit(0);}
411 for(Int_t dettype=0;dettype<fgkNdettypes;dettype++){
413 seg = new AliITSsegmentationSPD();
414 SetSegmentationModel(dettype,seg);
415 SetDigitClassName(dettype,"AliITSdigitSPD");
418 seg = new AliITSsegmentationSDD();
419 if(fLoadOnlySPDCalib==kFALSE){
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);
426 SetSegmentationModel(dettype,seg);
427 SetDigitClassName(dettype,"AliITSdigitSDD");
430 AliITSsegmentationSSD* seg2 = new AliITSsegmentationSSD();
431 SetSegmentationModel(dettype,seg2);
432 SetDigitClassName(dettype,"AliITSdigitSSD");
436 //______________________________________________________________________
437 Bool_t AliITSDetTypeRec::GetCalibration() {
438 // Get Default calibration if a storage is not defined.
441 AliITSCalibration* cal = GetCalibrationModel(0);
447 // SetRunNumber((Int_t)AliCDBManager::Instance()->GetRun());
448 // Int_t run=GetRunNumber();
450 Bool_t cacheStatus = AliCDBManager::Instance()->GetCacheFlag();
451 if (fCalibration==0) {
452 fCalibration = new TObjArray(GetITSgeom()->GetIndexMax());
453 fCalibration->SetOwner(!cacheStatus);
454 fCalibration->Clear();
457 Bool_t retCode=GetCalibrationSPD(cacheStatus);
458 if(retCode==kFALSE) return kFALSE;
460 if(fLoadOnlySPDCalib==kFALSE){
461 retCode=GetCalibrationSDD(cacheStatus);
462 if(retCode==kFALSE) return kFALSE;
463 retCode=GetCalibrationSSD(cacheStatus);
464 if(retCode==kFALSE) return kFALSE;
467 AliInfo(Form("%i SPD, %i SDD and %i SSD in calibration database",
468 fNMod[0], fNMod[1], fNMod[2]));
471 //______________________________________________________________________
472 Bool_t AliITSDetTypeRec::GetCalibrationSPD(Bool_t cacheStatus) {
473 // Get SPD calibration objects from OCDB
474 // dead pixel are not used for local reconstruction
477 AliCDBEntry *noisySPD = AliCDBManager::Instance()->Get("ITS/Calib/SPDNoisy");
478 AliCDBEntry *deadSPD = AliCDBManager::Instance()->Get("ITS/Calib/SPDDead");
479 AliCDBEntry *deadSparseSPD = AliCDBManager::Instance()->Get("ITS/Calib/SPDSparseDead");
480 AliCDBEntry *pitCond = AliCDBManager::Instance()->Get("TRIGGER/SPD/PITConditions");
481 if(!noisySPD || !deadSPD || !pitCond ){
482 AliFatal("SPD Calibration object retrieval failed! ");
486 TObjArray *calNoisySPD = (TObjArray*) noisySPD->GetObject();
487 if (!cacheStatus) noisySPD->SetObject(NULL);
488 noisySPD->SetOwner(kTRUE);
490 TObjArray *calDeadSPD = (TObjArray*) deadSPD->GetObject();
491 if (!cacheStatus) deadSPD->SetObject(NULL);
492 deadSPD->SetOwner(kTRUE);
494 TObjArray *calSparseDeadSPD = (TObjArray*) deadSparseSPD->GetObject();
495 if (!cacheStatus) deadSparseSPD->SetObject(NULL);
496 deadSparseSPD->SetOwner(kTRUE);
499 AliITSTriggerConditions *calPitCond = (AliITSTriggerConditions*) pitCond->GetObject();
500 if (!cacheStatus) pitCond->SetObject(NULL);
501 pitCond->SetOwner(kTRUE);
506 delete deadSparseSPD;
509 if ((!calNoisySPD) || (!calDeadSPD) || (!calSparseDeadSPD) || (!calPitCond)){
510 AliWarning("Can not get SPD calibration from calibration database !");
514 fNMod[0] = calNoisySPD->GetEntries();
516 AliITSCalibration* cal;
517 for (Int_t i=0; i<fNMod[0]; i++) {
518 cal = (AliITSCalibration*) calNoisySPD->At(i);
519 SetCalibrationModel(i, cal);
520 cal = (AliITSCalibration*) calDeadSPD->At(i);
521 SetSPDDeadModel(i, cal);
522 cal = (AliITSCalibration*) calSparseDeadSPD->At(i);
523 SetSPDSparseDeadModel(i, cal);
525 fTriggerConditions = calPitCond;
530 //______________________________________________________________________
531 Bool_t AliITSDetTypeRec::GetCalibrationSDD(Bool_t cacheStatus) {
532 // Get SDD calibration objects from OCDB
534 AliCDBEntry *entrySDD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSDD");
535 AliCDBEntry *entry2SDD = AliCDBManager::Instance()->Get("ITS/Calib/RespSDD");
536 AliCDBEntry *drSpSDD = AliCDBManager::Instance()->Get("ITS/Calib/DriftSpeedSDD");
537 AliCDBEntry *ddlMapSDD = AliCDBManager::Instance()->Get("ITS/Calib/DDLMapSDD");
538 // AliCDBEntry *mapASDD = AliCDBManager::Instance()->Get("ITS/Calib/MapsAnodeSDD");
539 AliCDBEntry *mapTSDD = AliCDBManager::Instance()->Get("ITS/Calib/MapsTimeSDD");
541 if(!entrySDD || !entry2SDD || !drSpSDD || !ddlMapSDD || !mapTSDD ){
542 AliFatal("SDD Calibration object retrieval failed! ");
548 TObjArray *calSDD = (TObjArray *)entrySDD->GetObject();
549 if(!cacheStatus)entrySDD->SetObject(NULL);
550 entrySDD->SetOwner(kTRUE);
552 AliITSresponseSDD *pSDD = (AliITSresponseSDD*)entry2SDD->GetObject();
553 if(!cacheStatus)entry2SDD->SetObject(NULL);
554 entry2SDD->SetOwner(kTRUE);
556 TObjArray *drSp = (TObjArray *)drSpSDD->GetObject();
557 if(!cacheStatus)drSpSDD->SetObject(NULL);
558 drSpSDD->SetOwner(kTRUE);
560 AliITSDDLModuleMapSDD *ddlsdd=(AliITSDDLModuleMapSDD*)ddlMapSDD->GetObject();
561 if(!cacheStatus)ddlMapSDD->SetObject(NULL);
562 ddlMapSDD->SetOwner(kTRUE);
564 // TObjArray *mapAn = (TObjArray *)mapASDD->GetObject();
565 // if(!cacheStatus)mapASDD->SetObject(NULL);
566 // mapASDD->SetOwner(kTRUE);
568 TObjArray *mapT = (TObjArray *)mapTSDD->GetObject();
569 if(!cacheStatus)mapTSDD->SetObject(NULL);
570 mapTSDD->SetOwner(kTRUE);
573 // DB entries are deleted. In this way metadeta objects are deleted as well
583 if ((!pSDD)||(!calSDD) || (!drSp) || (!ddlsdd) || (!mapT) ){
584 AliWarning("Can not get SDD calibration from calibration database !");
588 fNMod[1] = calSDD->GetEntries();
592 AliITSCalibration* cal;
595 Bool_t oldMapFormat=kFALSE;
596 TObject* objmap=(TObject*)mapT->At(0);
597 TString cname(objmap->ClassName());
598 if(cname.CompareTo("AliITSMapSDD")==0){
600 AliInfo("SDD Maps converted to new format");
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);
610 for(Int_t iAnode=0;iAnode< ((AliITSCalibrationSDD*)cal)->NOfAnodes(); iAnode++){
611 if(((AliITSCalibrationSDD*)cal)->IsBadChannel(iAnode)) continue;
612 avegain+= ((AliITSCalibrationSDD*)cal)->GetChannelGain(iAnode);
615 AliITSDriftSpeedArraySDD* arr0 = (AliITSDriftSpeedArraySDD*) drSp->At(i0);
616 AliITSDriftSpeedArraySDD* arr1 = (AliITSDriftSpeedArraySDD*) drSp->At(i1);
618 AliITSCorrMapSDD* mt0 = 0;
619 AliITSCorrMapSDD* mt1 = 0;
621 AliITSMapSDD* oldmap0=(AliITSMapSDD*)mapT->At(i0);
622 AliITSMapSDD* oldmap1=(AliITSMapSDD*)mapT->At(i1);
623 mt0=oldmap0->ConvertToNewFormat();
624 mt1=oldmap1->ConvertToNewFormat();
626 mt0=(AliITSCorrMapSDD*)mapT->At(i0);
627 mt1=(AliITSCorrMapSDD*)mapT->At(i1);
629 cal->SetDriftSpeed(0,arr0);
630 cal->SetDriftSpeed(1,arr1);
633 SetCalibrationModel(iMod, cal);
636 if(nGdAnodes) fAveGainSDD=avegain/nGdAnodes;
641 //______________________________________________________________________
642 Bool_t AliITSDetTypeRec::GetCalibrationSSD(Bool_t cacheStatus) {
643 // Get SSD calibration objects from OCDB
644 // AliCDBEntry *entrySSD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSSD");
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");
650 if(!entryNoiseSSD || !entryGainSSD || !entryBadChannelsSSD){
651 AliFatal("SSD Calibration object retrieval failed! ");
655 TObject *emptyssd = 0; TString ssdobjectname;
656 AliITSNoiseSSDv2 *noiseSSD = NULL;
657 emptyssd = (TObject *)entryNoiseSSD->GetObject();
658 ssdobjectname = emptyssd->GetName();
659 if(ssdobjectname=="TObjArray") {
660 TObjArray *noiseSSDOld = (TObjArray *)entryNoiseSSD->GetObject();
661 noiseSSD = new AliITSNoiseSSDv2();
662 ReadOldSSDNoise(noiseSSDOld, noiseSSD);
664 else if(ssdobjectname=="AliITSNoiseSSDv2")
665 noiseSSD = (AliITSNoiseSSDv2 *)entryNoiseSSD->GetObject();
666 if(!cacheStatus)entryNoiseSSD->SetObject(NULL);
667 entryNoiseSSD->SetOwner(kTRUE);
669 AliITSGainSSDv2 *gainSSD = NULL;;
670 emptyssd = (TObject *)entryGainSSD->GetObject();
671 ssdobjectname = emptyssd->GetName();
672 if(ssdobjectname=="Gain") {
673 TObjArray *gainSSDOld = (TObjArray *)entryGainSSD->GetObject();
674 gainSSD = new AliITSGainSSDv2();
675 ReadOldSSDGain(gainSSDOld, gainSSD);
677 else if(ssdobjectname=="AliITSGainSSDv2")
678 gainSSD = (AliITSGainSSDv2 *)entryGainSSD->GetObject();
679 if(!cacheStatus)entryGainSSD->SetObject(NULL);
680 entryGainSSD->SetOwner(kTRUE);
682 AliITSBadChannelsSSDv2 *badChannelsSSD = NULL;
683 emptyssd = (TObject *)entryBadChannelsSSD->GetObject();
684 ssdobjectname = emptyssd->GetName();
685 if(ssdobjectname=="TObjArray") {
686 TObjArray *badChannelsSSDOld = (TObjArray *)entryBadChannelsSSD->GetObject();
687 badChannelsSSD = new AliITSBadChannelsSSDv2();
688 ReadOldSSDBadChannels(badChannelsSSDOld, badChannelsSSD);
690 else if(ssdobjectname=="AliITSBadChannelsSSDv2")
691 badChannelsSSD = (AliITSBadChannelsSSDv2*)entryBadChannelsSSD->GetObject();
692 if(!cacheStatus)entryBadChannelsSSD->SetObject(NULL);
693 entryBadChannelsSSD->SetOwner(kTRUE);
695 // DB entries are deleted. In this way metadeta objects are deleted as well
697 delete entryNoiseSSD;
699 delete entryBadChannelsSSD;
702 if ((!noiseSSD)|| (!gainSSD)|| (!badChannelsSSD)) {
703 AliWarning("Can not get SSD calibration from calibration database !");
707 fSSDCalibration->SetNoise(noiseSSD);
708 fSSDCalibration->SetGain(gainSSD);
709 fSSDCalibration->SetBadChannels(badChannelsSSD);
710 //fSSDCalibration->FillBadChipMap();
715 //________________________________________________________________
716 void AliITSDetTypeRec::SetDefaultClusterFindersV2(Bool_t rawdata){
718 //Set defaults for cluster finder V2
721 Warning("SetDefaults","Null pointer to AliITSgeom !");
725 AliITSClusterFinder *clf;
727 for(Int_t dettype=0;dettype<fgkNdettypes;dettype++){
730 if(!GetReconstructionModel(dettype)){
731 clf = new AliITSClusterFinderV2SPD(this);
733 if(!rawdata) clf->SetDigits(DigitsAddress(0));
734 SetReconstructionModel(dettype,clf);
740 if(!GetReconstructionModel(dettype)){
741 clf = new AliITSClusterFinderV2SDD(this);
743 if(!rawdata) clf->SetDigits(DigitsAddress(1));
744 SetReconstructionModel(dettype,clf);
751 if(!GetReconstructionModel(dettype)){
752 clf = new AliITSClusterFinderV2SSD(this);
754 if(!rawdata) clf->SetDigits(DigitsAddress(2));
755 SetReconstructionModel(dettype,clf);
762 //______________________________________________________________________
763 void AliITSDetTypeRec::MakeBranch(TTree* tree, Option_t* option){
765 //Creates branches for clusters and recpoints
766 Bool_t cR = (strstr(option,"R")!=0);
767 Bool_t cRF = (strstr(option,"RF")!=0);
771 if(cR) MakeBranchR(tree);
772 if(cRF) MakeBranchRF(tree);
776 //___________________________________________________________________
777 void AliITSDetTypeRec::ResetDigits(){
778 // Reset number of digits and the digits array for the ITS detector.
781 for(Int_t i=0;i<fgkNdettypes;i++){
785 //___________________________________________________________________
786 void AliITSDetTypeRec::ResetDigits(Int_t branch){
787 // Reset number of digits and the digits array for this branch.
789 if(fDigits->At(branch)) ((TClonesArray*)fDigits->At(branch))->Clear();
792 //__________________________________________________________________
793 void AliITSDetTypeRec::MakeBranchR(TTree *treeR, Option_t *opt){
795 //Creates tree branches for recpoints
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.
804 // only one branch for rec points for all detector types
805 Bool_t oFast= (strstr(opt,"Fast")!=0);
807 Char_t detname[10] = "ITS";
811 snprintf(branchname,29,"%sRecPointsF",detname);
813 snprintf(branchname,29,"%sRecPoints",detname);
816 if(!fRecPoints)fRecPoints = new TClonesArray("AliITSRecPoint",1000);
818 MakeBranchInTree(treeR,branchname,0,&fRecPoints,buffsz,99);
820 //______________________________________________________________________
821 void AliITSDetTypeRec::SetTreeAddressR(TTree* const treeR){
822 // Set branch address for the Reconstructed points Trees.
824 // TTree *treeR Tree containing the RecPoints.
830 Char_t namedet[10]="ITS";
833 if(fRecPoints==0x0) fRecPoints = new TClonesArray("AliITSRecPoint",1000);
835 snprintf(branchname,29,"%sRecPoints",namedet);
836 branch = treeR->GetBranch(branchname);
838 branch->SetAddress(&fRecPoints);
841 snprintf(branchname,29,"%sRecPointsF",namedet);
842 branch = treeR->GetBranch(branchname);
844 branch->SetAddress(&fRecPoints);
848 //____________________________________________________________________
849 void AliITSDetTypeRec::AddRecPoint(const AliITSRecPoint &r){
850 // Add a reconstructed space point to the list
852 // const AliITSRecPoint &r RecPoint class to be added to the tree
853 // of reconstructed points TreeR.
858 TClonesArray &lrecp = *fRecPoints;
859 new(lrecp[fNRecPoints++]) AliITSRecPoint(r);
862 //______________________________________________________________________
863 void AliITSDetTypeRec::DigitsToRecPoints(TTree *treeD,TTree *treeR,Int_t lastentry,Option_t *opt, Int_t optCluFind){
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
869 // TTree *treeD Digits tree
870 // TTree *treeR Clusters tree
871 // Int_t lastentry Offset for module when not all of the modules
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.
877 const char *all = strstr(opt,"All");
878 const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),
881 SetDefaultClusterFindersV2();
882 AliDebug(1,"V2 cluster finder has been selected \n");
884 SetDefaultClusterFindersV2();
885 AliInfo("Cluster Finder Option not implemented, V2 cluster finder will be used \n");
889 // Reset Fast-OR fired map
890 ResetFastOrFiredMap();
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");
897 AliError("ITS loader is NULL.");
900 fFOSignals = (AliITSFOSignalsSPD*)itsLoader->TreeD()->GetUserInfo()->FindObject("AliITSFOSignalsSPD");
901 if(!fFOSignals) AliError("FO signals not retrieved");
907 AliITSClusterFinder *rec = 0;
908 Int_t id,module,first=0;
909 for(module=0;module<GetITSgeom()->GetIndexMax();module++){
910 id = GetITSgeom()->GetModuleType(module);
911 if (!all && !det[id]) continue;
912 if(det[id]) first = GetITSgeom()->GetStartDet(id);
913 rec = (AliITSClusterFinder*)GetReconstructionModel(id);
914 TClonesArray *itsDigits = DigitsAddress(id);
916 AliFatal("The reconstruction class was not instanciated!");
919 ResetDigits(); // MvL: Not sure we neeed this when rereading anyways
921 treeD->GetEvent(lastentry+module);
924 treeD->GetEvent(lastentry+(module-first));
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);
937 // Remove PIT in-active chips from Fast-OR fired map
938 if (all || det[0]) { // SPD present
939 RemoveFastOrFiredInActive();
940 // here removing bits which have no associated clusters
941 RemoveFastOrFiredFromDead(GetFiredChipMap(treeR));
944 AliITSRecPointContainer* rpcont = AliITSRecPointContainer::Instance();
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]));
951 //______________________________________________________________________
952 void AliITSDetTypeRec::DigitsToRecPoints(AliRawReader* rawReader,TTree *treeR,Option_t *opt){
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
958 // AliRawReader *rawReader Pointer to the raw-data reader
959 // TTree *treeR Clusters tree
964 const char *all = strstr(opt,"All");
965 const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),
969 AliITSRecPointContainer* rpc = AliITSRecPointContainer::Instance();
971 TClonesArray* array = rpc->UncheckedGetClusters(0);
972 TBranch *branch = treeR->Branch("ITSRecPoints",&array);
973 DigitsToRecPoints(rawReader,opt);
976 for(Int_t iModule=0;iModule<GetITSgeom()->GetIndexMax();iModule++){
977 id = GetITSgeom()->GetModuleType(iModule);
978 if (!all && !det[id]) continue;
979 array = rpc->UncheckedGetClusters(iModule);
981 AliDebug(1,Form("data for module %d missing!",iModule));
983 branch->SetAddress(&array);
985 nClusters+=array->GetEntriesFast();
990 AliITSRecPointContainer* rpcont = AliITSRecPointContainer::Instance();
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));
997 //______________________________________________________________________
998 void AliITSDetTypeRec::DigitsToRecPoints(AliRawReader* rawReader,Option_t *opt){
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
1004 // AliRawReader *rawReader Pointer to the raw-data reader
1009 const char *all = strstr(opt,"All");
1010 const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),
1013 // Reset Fast-OR fired map
1014 ResetFastOrFiredMap();
1016 AliITSClusterFinder *rec = 0;
1019 for(id=0;id<3;id++){
1020 if (!all && !det[id]) continue;
1021 rec = (AliITSClusterFinder*)GetReconstructionModel(id);
1023 AliFatal("The reconstruction class was not instantiated");
1026 rec->SetDetTypeRec(this);
1027 rec->RawdataToClusters(rawReader);
1030 // Remove PIT in-active chips from Fast-OR fired map
1031 if (all || det[0]) { // SPD present
1032 RemoveFastOrFiredInActive();
1033 // here removing bits which have no associated clusters
1034 RemoveFastOrFiredFromDead(GetFiredChipMap());
1038 //______________________________________________________________________
1039 void AliITSDetTypeRec::ReadOldSSDNoise(const TObjArray *array,
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;
1045 Int_t gNMod = array->GetEntries();
1046 AliInfo("Converting old calibration object for noise...\n");
1049 Double_t noise = 0.0;
1050 for (Int_t iModule = 0; iModule < gNMod; iModule++) {
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);
1059 }//loop over modules
1062 //______________________________________________________________________
1063 void AliITSDetTypeRec::ReadOldSSDBadChannels(const TObjArray *array,
1064 AliITSBadChannelsSSDv2 *badChannelsSSD) {
1065 //Reads the old SSD calibration object and converts it to the new format
1066 Int_t gNMod = array->GetEntries();
1067 AliInfo("Converting old calibration object for bad channels...");
1068 for (Int_t iModule = 0; iModule < gNMod; iModule++) {
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,
1075 (Char_t)arrayPSide.At(iPCounter));
1077 TArrayI arrayNSide = bad->GetBadNChannelsList();
1078 for(Int_t iNCounter = 0; iNCounter < arrayNSide.GetSize(); iNCounter++)
1079 badChannelsSSD->AddBadChannelN(iModule,
1081 (Char_t)arrayNSide.At(iNCounter));
1083 }//loop over modules
1086 //______________________________________________________________________
1087 void AliITSDetTypeRec::ReadOldSSDGain(const TObjArray *array,
1088 AliITSGainSSDv2 *gainSSD) {
1089 //Reads the old SSD calibration object and converts it to the new format
1091 Int_t gNMod = array->GetEntries();
1092 AliInfo("Converting old calibration object for gain...\n");
1095 for (Int_t iModule = 0; iModule < gNMod; iModule++) {
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,
1101 arrayPSide.At(iPCounter));
1102 TArrayF arrayNSide = gainModule->GetGainN();
1103 for(Int_t iNCounter = 0; iNCounter < arrayNSide.GetSize(); iNCounter++)
1104 gainSSD->AddGainN(iModule,
1106 arrayNSide.At(iNCounter));
1107 }//loop over modules
1109 //______________________________________________________________________
1110 void AliITSDetTypeRec::RemoveFastOrFiredInActive() {
1111 // Removes the chips that were in-active in the pixel trigger (from fast-or fired map)
1113 if (fTriggerConditions==NULL) {
1114 AliError("Pixel trigger conditions are missing.");
1120 while (fTriggerConditions->GetNextInActiveChip(eq,hs,chip)) {
1121 UInt_t chipKey = AliITSRawStreamSPD::GetOfflineChipKeyFromOnline(eq,hs,chip);
1122 fFastOrFiredMap.SetBitNumber(chipKey,kFALSE);
1125 //______________________________________________________________________
1126 TBits AliITSDetTypeRec::GetFiredChipMap() const {
1129 // TBits of the fired chips
1132 AliITSRecPointContainer* rpc = AliITSRecPointContainer::Instance();
1134 TBits isfiredchip(1200);
1136 AliITSsegmentationSPD *segSPD = (AliITSsegmentationSPD*)GetSegmentationModel(0);
1138 AliError("no segmentation model for SPD available, the fired chip map is empty. Exiting");
1143 for(Int_t imod =0; imod < fgkDefaultNModulesSPD; imod++){
1144 TClonesArray *array = rpc->UncheckedGetClusters(imod);
1145 if(!array) continue;
1146 Int_t nCluster = array->GetEntriesFast();
1149 AliITSRecPoint* cluster = (AliITSRecPoint*)array->UncheckedAt(nCluster);
1150 if (cluster->GetLayer()>1)continue;
1151 Float_t local[3]={-1,-1};
1152 local[1]=cluster->GetDetLocalX();
1153 local[0]=cluster->GetDetLocalZ();
1155 Int_t eq = AliITSRawStreamSPD::GetOnlineEqIdFromOffline(imod);
1156 Int_t hs = AliITSRawStreamSPD::GetOnlineHSFromOffline(imod);
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);
1169 //______________________________________________________________________
1170 TBits AliITSDetTypeRec::GetFiredChipMap(TTree *treeR) const{
1172 // TBits of the fired chips
1174 TBits isfiredchip(1200);
1177 AliError("no treeR. fired chip map stays empty. Exiting.");
1181 AliITSRecPointContainer* rpcont=AliITSRecPointContainer::Instance();
1182 TClonesArray *recpoints = NULL;
1183 rpcont->FetchClusters(0,treeR);
1184 if(!rpcont->GetStatusOK() || !rpcont->IsSPDActive()){
1185 AliError("no clusters. fired chip map stays empty. Exiting.");
1189 AliITSsegmentationSPD *segSPD = (AliITSsegmentationSPD*)GetSegmentationModel(0);
1191 for(Int_t imod =0; imod < fgkDefaultNModulesSPD; imod++){
1192 recpoints = rpcont->UncheckedGetClusters(imod);
1193 Int_t nCluster = recpoints->GetEntriesFast();
1195 // loop over clusters
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();
1203 Int_t eq = AliITSRawStreamSPD::GetOnlineEqIdFromOffline(imod);
1204 Int_t hs = AliITSRawStreamSPD::GetOnlineHSFromOffline(imod);
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);
1215 //______________________________________________________________________
1216 void AliITSDetTypeRec::RemoveFastOrFiredFromDead(TBits firedchipmap){
1218 // resetting of the fast-or bit on cluster basis.
1219 // fast-or bits can be remnant from SPD ideal simulation (no dead channels)
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));
1232 //______________________________________________________________________
1233 void 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);